text: module.exports =
  /******/ (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;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// 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 = "./simulator-sdk/index.js");
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ "./.electron-vue/log.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  const log4js = __webpack_require__("./node_modules/log4js/lib/log4js.js");
  const path = __webpack_require__("path");
  const Os = __webpack_require__("os");
  
  module.exports = function logger() {
      let temPath = Os.tmpdir();
      let filePath = path.join(temPath, 'tmadevtool', 'projectInfo', 'info.log');
      if (false) {}
      log4js.configure({
          appenders: {
              out: { type: 'stdout' },
              info: { type: 'file', filename: filePath }
          },
          categories: {
              default: { appenders: ['out', 'info'], level: 'info' } }
      });
      return log4js.getLogger('build-info');
  };
  
  /***/ }),
  
  /***/ "./common/util.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(__dirname) {
  
  var _keys = __webpack_require__("./node_modules/babel-runtime/core-js/object/keys.js");
  
  var _keys2 = _interopRequireDefault(_keys);
  
  var _stringify = __webpack_require__("./node_modules/babel-runtime/core-js/json/stringify.js");
  
  var _stringify2 = _interopRequireDefault(_stringify);
  
  var _create = __webpack_require__("./node_modules/babel-runtime/core-js/object/create.js");
  
  var _create2 = _interopRequireDefault(_create);
  
  var _promise = __webpack_require__("./node_modules/babel-runtime/core-js/promise.js");
  
  var _promise2 = _interopRequireDefault(_promise);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  let queryString = __webpack_require__("./node_modules/query-string/index.js");
  let path = __webpack_require__("path");
  let fs = __webpack_require__("fs");
  let fse = __webpack_require__("fs-extra");
  
  global.logger = __webpack_require__("./.electron-vue/log.js")();
  
  const isDev = "production" === 'development';
  const isMac = process.platform === 'darwin';
  
  exports.commonResourceType = {
      'text/plain': 'txt',
      'application/vnd.android.package-archive': 'apk',
      'video/3gpp': '3gp',
      'application/atom+xml': 'atom',
      'video/x-msvideo': 'avi',
      'application/x-bcpio': 'bcpio',
      'image/bmp': 'bmp',
      'image/cgm': 'cgm',
      'application/x-cpio': 'cpio',
      'application/mac-compactpro': 'cpt',
      'application/x-csh': 'csh',
      'text/css': 'css',
      'application/xml-dtd': 'dtd',
      'application/x-dvi': 'dvi',
      'application/x-director': 'dxr',
      'application/postscript': 'eps',
      'text/x-setext': 'etx',
      'application/andrew-inset': 'ez',
      'video/x-flv': 'flv',
      'image/gif': 'gif',
      'application/srgs': 'gram',
      'application/srgs+xml': 'grxml',
      'application/x-gtar': 'gtar',
      'application/x-gzip': 'gz',
      'application/x-hdf': 'hdf',
      'application/mac-binhex40': 'hqx',
      'x-conference/x-cooltalk': 'ice',
      'image/x-icon': 'ico',
      'image/ief': 'ief',
      'application/x-java-jnlp-file': 'jnlp',
      'image/jp2': 'jp2',
      'application/x-javascript': 'js',
      'application/x-latex': 'latex',
      'audio/x-mpegurl': 'm3u',
      'video/x-m4v': 'm4v',
      'application/x-troff-man': 'man',
      'application/mathml+xml': 'mathml',
      'application/x-troff-me': 'me',
      'application/vnd.mif': 'mif',
      'video/x-sgi-movie': 'movie',
      'video/mp4': 'mp4',
      'application/x-troff-ms': 'ms',
      'application/oda': 'oda',
      'application/ogg': 'ogg',
      'video/ogv': 'ogv',
      'image/x-portable-bitmap': 'pbm',
      'chemical/x-pdb': 'pdb',
      'application/pdf': 'pdf',
      'image/x-portable-graymap': 'pgm',
      'application/x-chess-pgn': 'pgn',
      'image/png': 'png',
      'image/x-portable-anymap': 'pnm',
      'image/x-portable-pixmap': 'ppm',
      'image/x-cmu-raster': 'ras',
      'application/rdf+xml': 'rdf',
      'image/x-rgb': 'rgb',
      'application/vnd.rn-realmedia': 'rm',
      'text/rtf': 'rtf',
      'text/richtext': 'rtx',
      'application/x-sh': 'sh',
      'application/x-shar': 'shar',
      'application/x-stuffit': 'sit',
      'application/x-futuresplash': 'spl',
      'application/x-wais-source': 'src',
      'application/x-sv4cpio': 'sv4cpio',
      'application/x-sv4crc': 'sv4crc',
      'image/svg+xml': 'svg',
      'application/x-shockwave-flash': 'swf',
      'application/x-tar': 'tar',
      'application/x-tcl': 'tcl',
      'application/x-tex': 'tex',
      'text/tab-separated-values': 'tsv',
      'application/x-ustar': 'ustar',
      'application/x-cdlink': 'vcd',
      'application/voicexml+xml': 'vxml',
      'audio/x-wav': 'wav',
      'image/vnd.wap.wbmp': 'wbmp',
      'application/vnd.wap.wbxml': 'wbxml',
      'video/webm': 'webm',
      'text/vnd.wap.wml': 'wml',
      'application/vnd.wap.wmlc': 'wmlc',
      'text/vnd.wap.wmlscript': 'wmls',
      'application/vnd.wap.wmlscriptc': 'wmlsc',
      'video/x-ms-wmv': 'wmv',
      'image/x-xbitmap': 'xbm',
      'image/x-xpixmap': 'xpm',
      'application/xslt+xml': 'xslt',
      'application/vnd.mozilla.xul+xml': 'xul',
      'image/x-xwindowdump': 'xwd',
      'chemical/x-xyz': 'xyz',
      'application/zip': 'zip'
  };
  
  exports.serialize = function (url, obj) {
      var str = [];
      for (var p in obj) {
          if (obj.hasOwnProperty(p)) {
              str.push(encodeURIComponent(p) + '=' + encodeURIComponent(obj[p]));
          }
      }
      str = str.join('&');
      url = url.replace(/\?$/, url);
      return `${url}?${str}`;
  };
  
  exports.commonGetCookies = function (cookieUrl) {
      let session = getElectron().session;
      return new _promise2.default(function (resolve, reject) {
          session.defaultSession.cookies.get({ url: cookieUrl }, (error, cookies) => {
              if (error) {
                  reject(error);
                  return;
              }
              resolve(cookies);
          });
      });
  };
  exports.commonClearCookie = function () {
      const { URL_CONFIG } = __webpack_require__("./src/config/url.js");
      try {
          let session = getElectron().session;
          session.defaultSession.cookies.remove(URL_CONFIG.cookieUrl, URL_CONFIG.apiCookieKey, function () {});
          if ("lark".indexOf('lark') > -1) {
              session.defaultSession.cookies.remove(`https://api${URL_CONFIG.cookieDomain}`, URL_CONFIG.cookieKey, function () {});
          }
  
          const cookieFilePath = commonGetCookiePath();
          logger && logger.info('clearCookie cookieFilePath', cookieFilePath);
          if (fs.existsSync(cookieFilePath)) {
              fs.unlinkSync(cookieFilePath);
          }
      } catch (e) {
          logger && logger.info('clear cookie error:', e);
      }
  };
  function commonGetCookiePath() {
      let userDirPath;
      const packagePath = isDev ? path.resolve(__dirname, '../package.json') : path.resolve(__dirname, '../../package.json');
      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
      const userDirName = packageJson.name;
      if (!isDev) {
          if (isMac) {
              userDirPath = path.join(process.env.HOME || '~', `Library/Application Support/${userDirName}/tmadevtool`);
          } else {
              userDirPath = path.join(process.env.USERPROFILE || '~', `AppData/Local/Programs/${global.userDirName}/tmadevtool`);
          }
      } else {
          if (isMac) {
              userDirPath = path.join(process.env.HOME || '~', `Library/Application Support/Electron/tmadevtool`);
          } else {
              userDirPath = path.join(process.env.USERPROFILE || '~', `AppData/Local/Programs/${global.userDirName}/tmadevtool`);
          }
      }
      const cookieFilePath = path.join(userDirPath, 'ideCookies');
      return cookieFilePath;
  }
  exports.commonGetSession = function (domain, name) {
      const filter = { domain, name };
      let session = getElectron().session;
      return new _promise2.default(function (resolve, reject) {
          session.defaultSession.cookies.get(filter, (error, cookies) => {
              if (error) {
                  reject(error);
              }
              if (cookies.length && cookies[0].value) {
                  resolve(cookies[0].value);
              } else {
                  resolve('bad session');
              }
          });
      });
  };
  
  exports.commonFormUrl = function (url, query) {
      const queryStr = queryString.stringify(query);
      return appendParam(url, queryStr);
  };
  
  function commonGetProjectInfo(fileName = 'projectInfo.json') {
      let app = getElectron().app;
      const storagePath = app.getPath('userData');
      const PROJECT_INFO_PATH = path.join(storagePath, 'tmadevtool', 'projectInfo', fileName);
      if (!fs.existsSync(PROJECT_INFO_PATH)) {
          return {};
      } else {
          let data = fs.readFileSync(PROJECT_INFO_PATH, { encoding: 'utf-8' });
          if (data) {
              return JSON.parse(data);
          } else {
              return {};
          }
      }
  }
  
  function commonGetAuthorizeInfo(authorizePath) {
      if (!fs.existsSync(authorizePath)) {
          return {};
      } else {
          let data = fs.readFileSync(authorizePath, { encoding: 'utf-8' });
          if (data) {
              return JSON.parse(data);
          } else {
              return {};
          }
      }
  }
  
  function commonVersionCompare(v1, v2, options) {
      var lexicographical = options && options.lexicographical,
          zeroExtend = options && options.zeroExtend,
          v1parts = v1.split('.'),
          v2parts = v2.split('.');
  
      function isValidPart(x) {
          return (lexicographical ? /^\d+[A-Za-z]*$/ : /^\d+$/).test(x);
      }
  
      if (!v1parts.every(isValidPart) || !v2parts.every(isValidPart)) {
          return NaN;
      }
  
      if (zeroExtend) {
          while (v1parts.length < v2parts.length) v1parts.push('0');
          while (v2parts.length < v1parts.length) v2parts.push('0');
      }
  
      if (!lexicographical) {
          v1parts = v1parts.map(Number);
          v2parts = v2parts.map(Number);
      }
  
      for (var i = 0; i < v1parts.length; ++i) {
          if (v2parts.length == i) {
              return 1;
          }
  
          if (v1parts[i] == v2parts[i]) {
              continue;
          } else if (v1parts[i] > v2parts[i]) {
              return 1;
          } else {
              return -1;
          }
      }
  
      if (v1parts.length != v2parts.length) {
          return -1;
      }
  
      return 0;
  }
  
  function commonGetPackageEnv() {
      if (true) {
          return "production";
      } else {}
  }
  
  function commonGetBigLocalBase(sdkPath) {
      let baseRepoPath = path.resolve(sdkPath, 'temFiles', 'dist', 'common', 'base');
      if (commonGetPackageEnv() === 'test') {
          baseRepoPath = path.resolve(sdkPath, 'temFiles', 'dist', 'common', 'base', 'local_test');
          !fs.existsSync(baseRepoPath) && fse.ensureDirSync(baseRepoPath);
      }
      fse.removeSync(path.join(baseRepoPath, '.DS_Store'));
      fse.removeSync(path.join(baseRepoPath, '__dev__'));
      return new _promise2.default(function (resolve, reject) {
          fs.readdir(baseRepoPath, function (err, files) {
              if (err) {
                  reject();
              }
              if (files.length === 0) {
                  resolve('empty');
                  return;
              }
              var indexofMaxValue = files.reduce((initial, value, index, arr) => {
                  return isLargeEqual(value, arr[initial]) ? index : initial;
              }, 0);
              resolve(files[indexofMaxValue]);
          });
      });
  }
  function isLargeEqual(a, b) {
      return commonVersionCompare(a, b) >= 0;
  }
  
  function commonSaveFile(dataStr, distPath) {
      try {
          if (!fs.existsSync(distPath)) {
              logger && logger.info('[SDK-INFO]saveFile: file not exist', distPath);
              fse.ensureFileSync(distPath);
          }
      } catch (err) {
          logger && logger.info('[SDK-INFO]saveFile ensureFileSync error:', err);
      }
  
      try {
          fs.writeFileSync(distPath, dataStr);
      } catch (err) {
          logger && logger.info('[SDK-INFO]saveFile writeFileSync error:', err);
      }
  }
  
  function commonGetProjectHash(isIDE = true) {
      let projectInfo = commonGetProjectInfo();
      let currentHash = commonGetCurrentHash(projectInfo);
      let currentProject = projectInfo.project[currentHash];
      if (isIDE) {
          return {
              useDir: currentProject.useDir,
              useDirHash: currentProject.useDirHash
          };
      }
      return {
          useDirHash: currentProject.useDirHash
      };
  }
  
  function commonGetConfigFileInfo(projectPath, localConfigFile) {
      if (!projectPath) {
          console.log('project not valid');
          return;
      }
      let confFilePath = path.join(projectPath, 'project.config.json');
      if (!fs.existsSync(confFilePath) && localConfigFile && fs.existsSync(localConfigFile)) {
          confFilePath = localConfigFile;
      }
      try {
          let rawData, configData;
          try {
              rawData = fs.readFileSync(confFilePath, { encoding: 'utf-8' });
          } catch (err) {
              throw err;
          }
          try {
              configData = JSON.parse(rawData);
          } catch (err) {
              throw err;
          }
          return configData;
      } catch (e) {
          console.error('read project.config.json error:', e);
          throw e;
      }
  }
  
  function commomSaveCurrentJSSDKVersion(version) {
      let fileName = 'versionInfo.json';
      let app = getElectron().app;
      let storagePath = app.getPath('userData');
      let versionInfoPath = path.join(storagePath, 'tmadevtool', 'projectInfo', fileName);
      console.log('versionInfoPath', versionInfoPath);
      try {
          let versionInfo = (0, _create2.default)(null);
          let currentHash = commonGetProjectHash().useDirHash;
          if (!fs.existsSync(versionInfoPath)) {
              versionInfo[currentHash] = {
                  "jssdk": {
                      "currentVersion": version
                  }
              };
          } else {
              versionInfo = commonGetProjectInfo(fileName);
              versionInfo[currentHash] = {
                  "jssdk": {
                      "currentVersion": version
                  }
              };
          }
          commonSaveFile((0, _stringify2.default)(versionInfo), versionInfoPath);
      } catch (e) {
          console.warn('saveCurrentJSSDKVersion', e);
      }
  }
  
  function updateAllCurrentJSSDKVersion(version) {
      let fileName = 'versionInfo.json';
      let app = getElectron().app;
      let storagePath = app.getPath('userData');
      let versionInfoPath = path.join(storagePath, 'tmadevtool', 'projectInfo', fileName);
      try {
          let versionInfo = (0, _create2.default)(null);
          if (fs.existsSync(versionInfoPath)) {
              versionInfo = commonGetProjectInfo(fileName);
              if (versionInfo) {
                  (0, _keys2.default)(versionInfo).forEach(function (projectHash) {
                      versionInfo[projectHash] = {
                          "jssdk": {
                              "currentVersion": version
                          }
                      };
                  });
              }
          }
          commonSaveFile((0, _stringify2.default)(versionInfo), versionInfoPath);
      } catch (e) {
          console.warn('saveCurrentJSSDKVersion', e);
      }
  }
  
  function commonGetInfoFromDir(dir) {
      try {
          let isDirectory = fs.statSync(dir).isDirectory(),
              configPath;
          if (isDirectory) {
              configPath = path.resolve(dir, 'project.config.json');
          } else if (dir.indexOf('project.config.json') > -1) {
              configPath = dir;
          }
          const datastr = fs.readFileSync(configPath, { encoding: 'utf-8' });
          const jsonData = JSON.parse(datastr);
          const { appid, projectname, ttappid } = jsonData;
          return {
              appId: ttappid || appid,
              projectName: projectname
          };
      } catch (err) {
          return { isNotExit: true };
      }
  }
  
  function commonGetCurrentHash(projectInfo, windowId = "") {
      if (!windowId) {
          windowId = getWindowId();
      }
      if (!projectInfo) {
          return null;
      }
      return projectInfo['browserWindow'][windowId];
  }
  
  function getWindowId() {
      let windowHref = window.location.href;
      let urlObj = commonParseUrl(windowHref);
      let windowId = urlObj.query && urlObj.query.windowId;
  
      return +(windowId && windowId.split('#')[0]) || 0;
  }
  function commonParseUrl(url) {
      var [cleanUrl, queryParts] = url.split('?');
      var pairs = queryParts && queryParts.split('&');
  
      var result = {};
      pairs && pairs.forEach(function (pair) {
          pair = pair.split('=');
  
          result[pair[0]] = pair[1] || '';
      });
  
      result = JSON.parse((0, _stringify2.default)(result));
      return { url: cleanUrl, query: result };
  }
  
  function addIdForUrl(url, id) {
      let windowId = id;
      if (!id) {
          windowId = getWindowId();
      }
      let [urlParts, queryStr] = url.split('?');
      if (queryStr) {
          let queryObj = queryString.parse(queryStr);
          queryObj.windowId = windowId;
          queryStr = queryString.stringify(queryObj);
          return `${urlParts}?${queryStr}`;
      } else if (url.indexOf('#') > -1) {
          let [urlNoHashparts, hashParts] = url.split('#');
          return `${urlNoHashparts}?windowId=${windowId}#${hashParts}`;
      } else {
          return `${url}?windowId=${windowId}`;
      }
  }
  
  function commonGetCurrentWindow() {
      let BrowserWindow = getElectron().BrowserWindow;
      return BrowserWindow.getFocusedWindow();
  }
  
  function getElectron() {
      return isRenderType() ? __webpack_require__("electron").remote : __webpack_require__("electron");
  }
  
  function isRenderType() {
      return process.type === "renderer";
  }
  
  function appendParam(url, params) {
      var testQues = /\?/;
      if (testQues.test(url)) {
          var length = url.length;
          var index = url.indexOf('?') + 1;
          if (length !== index) {
              if (url[length - 1] !== '&') {
                  url += '&' + params;
              } else {
                  url += params;
              }
          } else {
              url += params;
          }
      } else {
          url += '?' + params;
      }
      return url;
  }
  
  exports.commonGetProjectHash = commonGetProjectHash;
  exports.commonGetProjectInfo = commonGetProjectInfo;
  exports.commonGetCurrentHash = commonGetCurrentHash;
  exports.commonGetCurrentWindow = commonGetCurrentWindow;
  exports.commonGetAuthorizeInfo = commonGetAuthorizeInfo;
  exports.commonVersionCompare = commonVersionCompare;
  exports.commonGetBigLocalBase = commonGetBigLocalBase;
  exports.commonGetPackageEnv = commonGetPackageEnv;
  exports.commonGetConfigFileInfo = commonGetConfigFileInfo;
  exports.commomSaveCurrentJSSDKVersion = commomSaveCurrentJSSDKVersion;
  exports.commonGetInfoFromDir = commonGetInfoFromDir;
  exports.commonParseUrl = commonParseUrl;
  exports.getWindowId = getWindowId;
  exports.addIdForUrl = addIdForUrl;
  exports.commonGetCookiePath = commonGetCookiePath;
  exports.isLargeEqual = isLargeEqual;
  exports.commonSaveFile = commonSaveFile;
  exports.updateAllCurrentJSSDKVersion = updateAllCurrentJSSDKVersion;
  /* WEBPACK VAR INJECTION */}.call(this, "common"))
  
  /***/ }),
  
  /***/ "./node_modules/babel-runtime/core-js/json/stringify.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = { "default": __webpack_require__("./node_modules/core-js/library/fn/json/stringify.js"), __esModule: true };
  
  /***/ }),
  
  /***/ "./node_modules/babel-runtime/core-js/object/assign.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = { "default": __webpack_require__("./node_modules/core-js/library/fn/object/assign.js"), __esModule: true };
  
  /***/ }),
  
  /***/ "./node_modules/babel-runtime/core-js/object/create.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = { "default": __webpack_require__("./node_modules/core-js/library/fn/object/create.js"), __esModule: true };
  
  /***/ }),
  
  /***/ "./node_modules/babel-runtime/core-js/object/keys.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = { "default": __webpack_require__("./node_modules/core-js/library/fn/object/keys.js"), __esModule: true };
  
  /***/ }),
  
  /***/ "./node_modules/babel-runtime/core-js/promise.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = { "default": __webpack_require__("./node_modules/core-js/library/fn/promise.js"), __esModule: true };
  
  /***/ }),
  
  /***/ "./node_modules/circular-json/build/circular-json.node.js":
  /***/ (function(module, exports) {
  
  /*!
  Copyright (C) 2013-2017 by Andrea Giammarchi - @WebReflection
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
  
  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.
  
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  
  */
  var
    // should be a not so common char
    // possibly one JSON does not encode
    // possibly one encodeURIComponent does not encode
    // right now this char is '~' but this might change in the future
    specialChar = '~',
    safeSpecialChar = '\\x' + (
      '0' + specialChar.charCodeAt(0).toString(16)
    ).slice(-2),
    escapedSafeSpecialChar = '\\' + safeSpecialChar,
    specialCharRG = new RegExp(safeSpecialChar, 'g'),
    safeSpecialCharRG = new RegExp(escapedSafeSpecialChar, 'g'),
  
    safeStartWithSpecialCharRG = new RegExp('(?:^|([^\\\\]))' + escapedSafeSpecialChar),
  
    indexOf = [].indexOf || function(v){
      for(var i=this.length;i--&&this[i]!==v;);
      return i;
    },
    $String = String  // there's no way to drop warnings in JSHint
                      // about new String ... well, I need that here!
                      // faked, and happy linter!
  ;
  
  function generateReplacer(value, replacer, resolve) {
    var
      doNotIgnore = false,
      inspect = !!replacer,
      path = [],
      all  = [value],
      seen = [value],
      mapp = [resolve ? specialChar : '[Circular]'],
      last = value,
      lvl  = 1,
      i, fn
    ;
    if (inspect) {
      fn = typeof replacer === 'object' ?
        function (key, value) {
          return key !== '' && replacer.indexOf(key) < 0 ? void 0 : value;
        } :
        replacer;
    }
    return function(key, value) {
      // the replacer has rights to decide
      // if a new object should be returned
      // or if there's some key to drop
      // let's call it here rather than "too late"
      if (inspect) value = fn.call(this, key, value);
  
      // first pass should be ignored, since it's just the initial object
      if (doNotIgnore) {
        if (last !== this) {
          i = lvl - indexOf.call(all, this) - 1;
          lvl -= i;
          all.splice(lvl, all.length);
          path.splice(lvl - 1, path.length);
          last = this;
        }
        // console.log(lvl, key, path);
        if (typeof value === 'object' && value) {
      	// if object isn't referring to parent object, add to the
          // object path stack. Otherwise it is already there.
          if (indexOf.call(all, value) < 0) {
            all.push(last = value);
          }
          lvl = all.length;
          i = indexOf.call(seen, value);
          if (i < 0) {
            i = seen.push(value) - 1;
            if (resolve) {
              // key cannot contain specialChar but could be not a string
              path.push(('' + key).replace(specialCharRG, safeSpecialChar));
              mapp[i] = specialChar + path.join(specialChar);
            } else {
              mapp[i] = mapp[0];
            }
          } else {
            value = mapp[i];
          }
        } else {
          if (typeof value === 'string' && resolve) {
            // ensure no special char involved on deserialization
            // in this case only first char is important
            // no need to replace all value (better performance)
            value = value .replace(safeSpecialChar, escapedSafeSpecialChar)
                          .replace(specialChar, safeSpecialChar);
          }
        }
      } else {
        doNotIgnore = true;
      }
      return value;
    };
  }
  
  function retrieveFromPath(current, keys) {
    for(var i = 0, length = keys.length; i < length; current = current[
      // keys should be normalized back here
      keys[i++].replace(safeSpecialCharRG, specialChar)
    ]);
    return current;
  }
  
  function generateReviver(reviver) {
    return function(key, value) {
      var isString = typeof value === 'string';
      if (isString && value.charAt(0) === specialChar) {
        return new $String(value.slice(1));
      }
      if (key === '') value = regenerate(value, value, {});
      // again, only one needed, do not use the RegExp for this replacement
      // only keys need the RegExp
      if (isString) value = value .replace(safeStartWithSpecialCharRG, '$1' + specialChar)
                                  .replace(escapedSafeSpecialChar, safeSpecialChar);
      return reviver ? reviver.call(this, key, value) : value;
    };
  }
  
  function regenerateArray(root, current, retrieve) {
    for (var i = 0, length = current.length; i < length; i++) {
      current[i] = regenerate(root, current[i], retrieve);
    }
    return current;
  }
  
  function regenerateObject(root, current, retrieve) {
    for (var key in current) {
      if (current.hasOwnProperty(key)) {
        current[key] = regenerate(root, current[key], retrieve);
      }
    }
    return current;
  }
  
  function regenerate(root, current, retrieve) {
    return current instanceof Array ?
      // fast Array reconstruction
      regenerateArray(root, current, retrieve) :
      (
        current instanceof $String ?
          (
            // root is an empty string
            current.length ?
              (
                retrieve.hasOwnProperty(current) ?
                  retrieve[current] :
                  retrieve[current] = retrieveFromPath(
                    root, current.split(specialChar)
                  )
              ) :
              root
          ) :
          (
            current instanceof Object ?
              // dedicated Object parser
              regenerateObject(root, current, retrieve) :
              // value as it is
              current
          )
      )
    ;
  }
  
  var CircularJSON = {
    stringify: function stringify(value, replacer, space, doNotResolve) {
      return CircularJSON.parser.stringify(
        value,
        generateReplacer(value, replacer, !doNotResolve),
        space
      );
    },
    parse: function parse(text, reviver) {
      return CircularJSON.parser.parse(
        text,
        generateReviver(reviver)
      );
    },
    // A parser should be an API 1:1 compatible with JSON
    // it should expose stringify and parse methods.
    // The default parser is the native JSON.
    parser: JSON
  };
  
  module.exports = CircularJSON;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/fn/json/stringify.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var core = __webpack_require__("./node_modules/core-js/library/modules/_core.js");
  var $JSON = core.JSON || (core.JSON = { stringify: JSON.stringify });
  module.exports = function stringify(it) { // eslint-disable-line no-unused-vars
    return $JSON.stringify.apply($JSON, arguments);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/fn/object/assign.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__("./node_modules/core-js/library/modules/es6.object.assign.js");
  module.exports = __webpack_require__("./node_modules/core-js/library/modules/_core.js").Object.assign;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/fn/object/create.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__("./node_modules/core-js/library/modules/es6.object.create.js");
  var $Object = __webpack_require__("./node_modules/core-js/library/modules/_core.js").Object;
  module.exports = function create(P, D) {
    return $Object.create(P, D);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/fn/object/keys.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__("./node_modules/core-js/library/modules/es6.object.keys.js");
  module.exports = __webpack_require__("./node_modules/core-js/library/modules/_core.js").Object.keys;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/fn/promise.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__("./node_modules/core-js/library/modules/es6.object.to-string.js");
  __webpack_require__("./node_modules/core-js/library/modules/es6.string.iterator.js");
  __webpack_require__("./node_modules/core-js/library/modules/web.dom.iterable.js");
  __webpack_require__("./node_modules/core-js/library/modules/es6.promise.js");
  __webpack_require__("./node_modules/core-js/library/modules/es7.promise.finally.js");
  __webpack_require__("./node_modules/core-js/library/modules/es7.promise.try.js");
  module.exports = __webpack_require__("./node_modules/core-js/library/modules/_core.js").Promise;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_a-function.js":
  /***/ (function(module, exports) {
  
  module.exports = function (it) {
    if (typeof it != 'function') throw TypeError(it + ' is not a function!');
    return it;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_add-to-unscopables.js":
  /***/ (function(module, exports) {
  
  module.exports = function () { /* empty */ };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_an-instance.js":
  /***/ (function(module, exports) {
  
  module.exports = function (it, Constructor, name, forbiddenField) {
    if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
      throw TypeError(name + ': incorrect invocation!');
    } return it;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_an-object.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var isObject = __webpack_require__("./node_modules/core-js/library/modules/_is-object.js");
  module.exports = function (it) {
    if (!isObject(it)) throw TypeError(it + ' is not an object!');
    return it;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_array-includes.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // false -> Array#indexOf
  // true  -> Array#includes
  var toIObject = __webpack_require__("./node_modules/core-js/library/modules/_to-iobject.js");
  var toLength = __webpack_require__("./node_modules/core-js/library/modules/_to-length.js");
  var toAbsoluteIndex = __webpack_require__("./node_modules/core-js/library/modules/_to-absolute-index.js");
  module.exports = function (IS_INCLUDES) {
    return function ($this, el, fromIndex) {
      var O = toIObject($this);
      var length = toLength(O.length);
      var index = toAbsoluteIndex(fromIndex, length);
      var value;
      // Array#includes uses SameValueZero equality algorithm
      // eslint-disable-next-line no-self-compare
      if (IS_INCLUDES && el != el) while (length > index) {
        value = O[index++];
        // eslint-disable-next-line no-self-compare
        if (value != value) return true;
      // Array#indexOf ignores holes, Array#includes - not
      } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
        if (O[index] === el) return IS_INCLUDES || index || 0;
      } return !IS_INCLUDES && -1;
    };
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_classof.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // getting tag from 19.1.3.6 Object.prototype.toString()
  var cof = __webpack_require__("./node_modules/core-js/library/modules/_cof.js");
  var TAG = __webpack_require__("./node_modules/core-js/library/modules/_wks.js")('toStringTag');
  // ES3 wrong here
  var ARG = cof(function () { return arguments; }()) == 'Arguments';
  
  // fallback for IE11 Script Access Denied error
  var tryGet = function (it, key) {
    try {
      return it[key];
    } catch (e) { /* empty */ }
  };
  
  module.exports = function (it) {
    var O, T, B;
    return it === undefined ? 'Undefined' : it === null ? 'Null'
      // @@toStringTag case
      : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
      // builtinTag case
      : ARG ? cof(O)
      // ES3 arguments fallback
      : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_cof.js":
  /***/ (function(module, exports) {
  
  var toString = {}.toString;
  
  module.exports = function (it) {
    return toString.call(it).slice(8, -1);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_core.js":
  /***/ (function(module, exports) {
  
  var core = module.exports = { version: '2.6.5' };
  if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_ctx.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // optional / simple context binding
  var aFunction = __webpack_require__("./node_modules/core-js/library/modules/_a-function.js");
  module.exports = function (fn, that, length) {
    aFunction(fn);
    if (that === undefined) return fn;
    switch (length) {
      case 1: return function (a) {
        return fn.call(that, a);
      };
      case 2: return function (a, b) {
        return fn.call(that, a, b);
      };
      case 3: return function (a, b, c) {
        return fn.call(that, a, b, c);
      };
    }
    return function (/* ...args */) {
      return fn.apply(that, arguments);
    };
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_defined.js":
  /***/ (function(module, exports) {
  
  // 7.2.1 RequireObjectCoercible(argument)
  module.exports = function (it) {
    if (it == undefined) throw TypeError("Can't call method on  " + it);
    return it;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_descriptors.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // Thank's IE8 for his funny defineProperty
  module.exports = !__webpack_require__("./node_modules/core-js/library/modules/_fails.js")(function () {
    return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
  });
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_dom-create.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var isObject = __webpack_require__("./node_modules/core-js/library/modules/_is-object.js");
  var document = __webpack_require__("./node_modules/core-js/library/modules/_global.js").document;
  // typeof document.createElement is 'object' in old IE
  var is = isObject(document) && isObject(document.createElement);
  module.exports = function (it) {
    return is ? document.createElement(it) : {};
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_enum-bug-keys.js":
  /***/ (function(module, exports) {
  
  // IE 8- don't enum bug keys
  module.exports = (
    'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
  ).split(',');
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_export.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var global = __webpack_require__("./node_modules/core-js/library/modules/_global.js");
  var core = __webpack_require__("./node_modules/core-js/library/modules/_core.js");
  var ctx = __webpack_require__("./node_modules/core-js/library/modules/_ctx.js");
  var hide = __webpack_require__("./node_modules/core-js/library/modules/_hide.js");
  var has = __webpack_require__("./node_modules/core-js/library/modules/_has.js");
  var PROTOTYPE = 'prototype';
  
  var $export = function (type, name, source) {
    var IS_FORCED = type & $export.F;
    var IS_GLOBAL = type & $export.G;
    var IS_STATIC = type & $export.S;
    var IS_PROTO = type & $export.P;
    var IS_BIND = type & $export.B;
    var IS_WRAP = type & $export.W;
    var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
    var expProto = exports[PROTOTYPE];
    var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE];
    var key, own, out;
    if (IS_GLOBAL) source = name;
    for (key in source) {
      // contains in native
      own = !IS_FORCED && target && target[key] !== undefined;
      if (own && has(exports, key)) continue;
      // export native or passed
      out = own ? target[key] : source[key];
      // prevent global pollution for namespaces
      exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key]
      // bind timers to global for call from export context
      : IS_BIND && own ? ctx(out, global)
      // wrap global constructors for prevent change them in library
      : IS_WRAP && target[key] == out ? (function (C) {
        var F = function (a, b, c) {
          if (this instanceof C) {
            switch (arguments.length) {
              case 0: return new C();
              case 1: return new C(a);
              case 2: return new C(a, b);
            } return new C(a, b, c);
          } return C.apply(this, arguments);
        };
        F[PROTOTYPE] = C[PROTOTYPE];
        return F;
      // make static versions for prototype methods
      })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
      // export proto methods to core.%CONSTRUCTOR%.methods.%NAME%
      if (IS_PROTO) {
        (exports.virtual || (exports.virtual = {}))[key] = out;
        // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME%
        if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out);
      }
    }
  };
  // type bitmap
  $export.F = 1;   // forced
  $export.G = 2;   // global
  $export.S = 4;   // static
  $export.P = 8;   // proto
  $export.B = 16;  // bind
  $export.W = 32;  // wrap
  $export.U = 64;  // safe
  $export.R = 128; // real proto method for `library`
  module.exports = $export;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_fails.js":
  /***/ (function(module, exports) {
  
  module.exports = function (exec) {
    try {
      return !!exec();
    } catch (e) {
      return true;
    }
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_for-of.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var ctx = __webpack_require__("./node_modules/core-js/library/modules/_ctx.js");
  var call = __webpack_require__("./node_modules/core-js/library/modules/_iter-call.js");
  var isArrayIter = __webpack_require__("./node_modules/core-js/library/modules/_is-array-iter.js");
  var anObject = __webpack_require__("./node_modules/core-js/library/modules/_an-object.js");
  var toLength = __webpack_require__("./node_modules/core-js/library/modules/_to-length.js");
  var getIterFn = __webpack_require__("./node_modules/core-js/library/modules/core.get-iterator-method.js");
  var BREAK = {};
  var RETURN = {};
  var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
    var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);
    var f = ctx(fn, that, entries ? 2 : 1);
    var index = 0;
    var length, step, iterator, result;
    if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
    // fast case for arrays with default iterator
    if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {
      result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
      if (result === BREAK || result === RETURN) return result;
    } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
      result = call(iterator, f, step.value, entries);
      if (result === BREAK || result === RETURN) return result;
    }
  };
  exports.BREAK = BREAK;
  exports.RETURN = RETURN;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_global.js":
  /***/ (function(module, exports) {
  
  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
  var global = module.exports = typeof window != 'undefined' && window.Math == Math
    ? window : typeof self != 'undefined' && self.Math == Math ? self
    // eslint-disable-next-line no-new-func
    : Function('return this')();
  if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_has.js":
  /***/ (function(module, exports) {
  
  var hasOwnProperty = {}.hasOwnProperty;
  module.exports = function (it, key) {
    return hasOwnProperty.call(it, key);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_hide.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var dP = __webpack_require__("./node_modules/core-js/library/modules/_object-dp.js");
  var createDesc = __webpack_require__("./node_modules/core-js/library/modules/_property-desc.js");
  module.exports = __webpack_require__("./node_modules/core-js/library/modules/_descriptors.js") ? function (object, key, value) {
    return dP.f(object, key, createDesc(1, value));
  } : function (object, key, value) {
    object[key] = value;
    return object;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_html.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var document = __webpack_require__("./node_modules/core-js/library/modules/_global.js").document;
  module.exports = document && document.documentElement;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_ie8-dom-define.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = !__webpack_require__("./node_modules/core-js/library/modules/_descriptors.js") && !__webpack_require__("./node_modules/core-js/library/modules/_fails.js")(function () {
    return Object.defineProperty(__webpack_require__("./node_modules/core-js/library/modules/_dom-create.js")('div'), 'a', { get: function () { return 7; } }).a != 7;
  });
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_invoke.js":
  /***/ (function(module, exports) {
  
  // fast apply, http://jsperf.lnkit.com/fast-apply/5
  module.exports = function (fn, args, that) {
    var un = that === undefined;
    switch (args.length) {
      case 0: return un ? fn()
                        : fn.call(that);
      case 1: return un ? fn(args[0])
                        : fn.call(that, args[0]);
      case 2: return un ? fn(args[0], args[1])
                        : fn.call(that, args[0], args[1]);
      case 3: return un ? fn(args[0], args[1], args[2])
                        : fn.call(that, args[0], args[1], args[2]);
      case 4: return un ? fn(args[0], args[1], args[2], args[3])
                        : fn.call(that, args[0], args[1], args[2], args[3]);
    } return fn.apply(that, args);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_iobject.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // fallback for non-array-like ES3 and non-enumerable old V8 strings
  var cof = __webpack_require__("./node_modules/core-js/library/modules/_cof.js");
  // eslint-disable-next-line no-prototype-builtins
  module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
    return cof(it) == 'String' ? it.split('') : Object(it);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_is-array-iter.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // check on default Array iterator
  var Iterators = __webpack_require__("./node_modules/core-js/library/modules/_iterators.js");
  var ITERATOR = __webpack_require__("./node_modules/core-js/library/modules/_wks.js")('iterator');
  var ArrayProto = Array.prototype;
  
  module.exports = function (it) {
    return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_is-object.js":
  /***/ (function(module, exports) {
  
  module.exports = function (it) {
    return typeof it === 'object' ? it !== null : typeof it === 'function';
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_iter-call.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // call something on iterator step with safe closing on error
  var anObject = __webpack_require__("./node_modules/core-js/library/modules/_an-object.js");
  module.exports = function (iterator, fn, value, entries) {
    try {
      return entries ? fn(anObject(value)[0], value[1]) : fn(value);
    // 7.4.6 IteratorClose(iterator, completion)
    } catch (e) {
      var ret = iterator['return'];
      if (ret !== undefined) anObject(ret.call(iterator));
      throw e;
    }
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_iter-create.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var create = __webpack_require__("./node_modules/core-js/library/modules/_object-create.js");
  var descriptor = __webpack_require__("./node_modules/core-js/library/modules/_property-desc.js");
  var setToStringTag = __webpack_require__("./node_modules/core-js/library/modules/_set-to-string-tag.js");
  var IteratorPrototype = {};
  
  // 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
  __webpack_require__("./node_modules/core-js/library/modules/_hide.js")(IteratorPrototype, __webpack_require__("./node_modules/core-js/library/modules/_wks.js")('iterator'), function () { return this; });
  
  module.exports = function (Constructor, NAME, next) {
    Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
    setToStringTag(Constructor, NAME + ' Iterator');
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_iter-define.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var LIBRARY = __webpack_require__("./node_modules/core-js/library/modules/_library.js");
  var $export = __webpack_require__("./node_modules/core-js/library/modules/_export.js");
  var redefine = __webpack_require__("./node_modules/core-js/library/modules/_redefine.js");
  var hide = __webpack_require__("./node_modules/core-js/library/modules/_hide.js");
  var Iterators = __webpack_require__("./node_modules/core-js/library/modules/_iterators.js");
  var $iterCreate = __webpack_require__("./node_modules/core-js/library/modules/_iter-create.js");
  var setToStringTag = __webpack_require__("./node_modules/core-js/library/modules/_set-to-string-tag.js");
  var getPrototypeOf = __webpack_require__("./node_modules/core-js/library/modules/_object-gpo.js");
  var ITERATOR = __webpack_require__("./node_modules/core-js/library/modules/_wks.js")('iterator');
  var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
  var FF_ITERATOR = '@@iterator';
  var KEYS = 'keys';
  var VALUES = 'values';
  
  var returnThis = function () { return this; };
  
  module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
    $iterCreate(Constructor, NAME, next);
    var getMethod = function (kind) {
      if (!BUGGY && kind in proto) return proto[kind];
      switch (kind) {
        case KEYS: return function keys() { return new Constructor(this, kind); };
        case VALUES: return function values() { return new Constructor(this, kind); };
      } return function entries() { return new Constructor(this, kind); };
    };
    var TAG = NAME + ' Iterator';
    var DEF_VALUES = DEFAULT == VALUES;
    var VALUES_BUG = false;
    var proto = Base.prototype;
    var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
    var $default = $native || getMethod(DEFAULT);
    var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
    var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
    var methods, key, IteratorPrototype;
    // Fix native
    if ($anyNative) {
      IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
      if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
        // Set @@toStringTag to native iterators
        setToStringTag(IteratorPrototype, TAG, true);
        // fix for some old engines
        if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);
      }
    }
    // fix Array#{values, @@iterator}.name in V8 / FF
    if (DEF_VALUES && $native && $native.name !== VALUES) {
      VALUES_BUG = true;
      $default = function values() { return $native.call(this); };
    }
    // Define iterator
    if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
      hide(proto, ITERATOR, $default);
    }
    // Plug for library
    Iterators[NAME] = $default;
    Iterators[TAG] = returnThis;
    if (DEFAULT) {
      methods = {
        values: DEF_VALUES ? $default : getMethod(VALUES),
        keys: IS_SET ? $default : getMethod(KEYS),
        entries: $entries
      };
      if (FORCED) for (key in methods) {
        if (!(key in proto)) redefine(proto, key, methods[key]);
      } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
    }
    return methods;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_iter-detect.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var ITERATOR = __webpack_require__("./node_modules/core-js/library/modules/_wks.js")('iterator');
  var SAFE_CLOSING = false;
  
  try {
    var riter = [7][ITERATOR]();
    riter['return'] = function () { SAFE_CLOSING = true; };
    // eslint-disable-next-line no-throw-literal
    Array.from(riter, function () { throw 2; });
  } catch (e) { /* empty */ }
  
  module.exports = function (exec, skipClosing) {
    if (!skipClosing && !SAFE_CLOSING) return false;
    var safe = false;
    try {
      var arr = [7];
      var iter = arr[ITERATOR]();
      iter.next = function () { return { done: safe = true }; };
      arr[ITERATOR] = function () { return iter; };
      exec(arr);
    } catch (e) { /* empty */ }
    return safe;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_iter-step.js":
  /***/ (function(module, exports) {
  
  module.exports = function (done, value) {
    return { value: value, done: !!done };
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_iterators.js":
  /***/ (function(module, exports) {
  
  module.exports = {};
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_library.js":
  /***/ (function(module, exports) {
  
  module.exports = true;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_microtask.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var global = __webpack_require__("./node_modules/core-js/library/modules/_global.js");
  var macrotask = __webpack_require__("./node_modules/core-js/library/modules/_task.js").set;
  var Observer = global.MutationObserver || global.WebKitMutationObserver;
  var process = global.process;
  var Promise = global.Promise;
  var isNode = __webpack_require__("./node_modules/core-js/library/modules/_cof.js")(process) == 'process';
  
  module.exports = function () {
    var head, last, notify;
  
    var flush = function () {
      var parent, fn;
      if (isNode && (parent = process.domain)) parent.exit();
      while (head) {
        fn = head.fn;
        head = head.next;
        try {
          fn();
        } catch (e) {
          if (head) notify();
          else last = undefined;
          throw e;
        }
      } last = undefined;
      if (parent) parent.enter();
    };
  
    // Node.js
    if (isNode) {
      notify = function () {
        process.nextTick(flush);
      };
    // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339
    } else if (Observer && !(global.navigator && global.navigator.standalone)) {
      var toggle = true;
      var node = document.createTextNode('');
      new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new
      notify = function () {
        node.data = toggle = !toggle;
      };
    // environments with maybe non-completely correct, but existent Promise
    } else if (Promise && Promise.resolve) {
      // Promise.resolve without an argument throws an error in LG WebOS 2
      var promise = Promise.resolve(undefined);
      notify = function () {
        promise.then(flush);
      };
    // for other environments - macrotask based on:
    // - setImmediate
    // - MessageChannel
    // - window.postMessag
    // - onreadystatechange
    // - setTimeout
    } else {
      notify = function () {
        // strange IE + webpack dev server bug - use .call(global)
        macrotask.call(global, flush);
      };
    }
  
    return function (fn) {
      var task = { fn: fn, next: undefined };
      if (last) last.next = task;
      if (!head) {
        head = task;
        notify();
      } last = task;
    };
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_new-promise-capability.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  // 25.4.1.5 NewPromiseCapability(C)
  var aFunction = __webpack_require__("./node_modules/core-js/library/modules/_a-function.js");
  
  function PromiseCapability(C) {
    var resolve, reject;
    this.promise = new C(function ($$resolve, $$reject) {
      if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
      resolve = $$resolve;
      reject = $$reject;
    });
    this.resolve = aFunction(resolve);
    this.reject = aFunction(reject);
  }
  
  module.exports.f = function (C) {
    return new PromiseCapability(C);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_object-assign.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  // 19.1.2.1 Object.assign(target, source, ...)
  var getKeys = __webpack_require__("./node_modules/core-js/library/modules/_object-keys.js");
  var gOPS = __webpack_require__("./node_modules/core-js/library/modules/_object-gops.js");
  var pIE = __webpack_require__("./node_modules/core-js/library/modules/_object-pie.js");
  var toObject = __webpack_require__("./node_modules/core-js/library/modules/_to-object.js");
  var IObject = __webpack_require__("./node_modules/core-js/library/modules/_iobject.js");
  var $assign = Object.assign;
  
  // should work with symbols and should have deterministic property order (V8 bug)
  module.exports = !$assign || __webpack_require__("./node_modules/core-js/library/modules/_fails.js")(function () {
    var A = {};
    var B = {};
    // eslint-disable-next-line no-undef
    var S = Symbol();
    var K = 'abcdefghijklmnopqrst';
    A[S] = 7;
    K.split('').forEach(function (k) { B[k] = k; });
    return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
  }) ? function assign(target, source) { // eslint-disable-line no-unused-vars
    var T = toObject(target);
    var aLen = arguments.length;
    var index = 1;
    var getSymbols = gOPS.f;
    var isEnum = pIE.f;
    while (aLen > index) {
      var S = IObject(arguments[index++]);
      var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);
      var length = keys.length;
      var j = 0;
      var key;
      while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key];
    } return T;
  } : $assign;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_object-create.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
  var anObject = __webpack_require__("./node_modules/core-js/library/modules/_an-object.js");
  var dPs = __webpack_require__("./node_modules/core-js/library/modules/_object-dps.js");
  var enumBugKeys = __webpack_require__("./node_modules/core-js/library/modules/_enum-bug-keys.js");
  var IE_PROTO = __webpack_require__("./node_modules/core-js/library/modules/_shared-key.js")('IE_PROTO');
  var Empty = function () { /* empty */ };
  var PROTOTYPE = 'prototype';
  
  // Create object with fake `null` prototype: use iframe Object with cleared prototype
  var createDict = function () {
    // Thrash, waste and sodomy: IE GC bug
    var iframe = __webpack_require__("./node_modules/core-js/library/modules/_dom-create.js")('iframe');
    var i = enumBugKeys.length;
    var lt = '<';
    var gt = '>';
    var iframeDocument;
    iframe.style.display = 'none';
    __webpack_require__("./node_modules/core-js/library/modules/_html.js").appendChild(iframe);
    iframe.src = 'javascript:'; // eslint-disable-line no-script-url
    // createDict = iframe.contentWindow.Object;
    // html.removeChild(iframe);
    iframeDocument = iframe.contentWindow.document;
    iframeDocument.open();
    iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
    iframeDocument.close();
    createDict = iframeDocument.F;
    while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];
    return createDict();
  };
  
  module.exports = Object.create || function create(O, Properties) {
    var result;
    if (O !== null) {
      Empty[PROTOTYPE] = anObject(O);
      result = new Empty();
      Empty[PROTOTYPE] = null;
      // add "__proto__" for Object.getPrototypeOf polyfill
      result[IE_PROTO] = O;
    } else result = createDict();
    return Properties === undefined ? result : dPs(result, Properties);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_object-dp.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var anObject = __webpack_require__("./node_modules/core-js/library/modules/_an-object.js");
  var IE8_DOM_DEFINE = __webpack_require__("./node_modules/core-js/library/modules/_ie8-dom-define.js");
  var toPrimitive = __webpack_require__("./node_modules/core-js/library/modules/_to-primitive.js");
  var dP = Object.defineProperty;
  
  exports.f = __webpack_require__("./node_modules/core-js/library/modules/_descriptors.js") ? Object.defineProperty : function defineProperty(O, P, Attributes) {
    anObject(O);
    P = toPrimitive(P, true);
    anObject(Attributes);
    if (IE8_DOM_DEFINE) try {
      return dP(O, P, Attributes);
    } catch (e) { /* empty */ }
    if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
    if ('value' in Attributes) O[P] = Attributes.value;
    return O;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_object-dps.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var dP = __webpack_require__("./node_modules/core-js/library/modules/_object-dp.js");
  var anObject = __webpack_require__("./node_modules/core-js/library/modules/_an-object.js");
  var getKeys = __webpack_require__("./node_modules/core-js/library/modules/_object-keys.js");
  
  module.exports = __webpack_require__("./node_modules/core-js/library/modules/_descriptors.js") ? Object.defineProperties : function defineProperties(O, Properties) {
    anObject(O);
    var keys = getKeys(Properties);
    var length = keys.length;
    var i = 0;
    var P;
    while (length > i) dP.f(O, P = keys[i++], Properties[P]);
    return O;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_object-gops.js":
  /***/ (function(module, exports) {
  
  exports.f = Object.getOwnPropertySymbols;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_object-gpo.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
  var has = __webpack_require__("./node_modules/core-js/library/modules/_has.js");
  var toObject = __webpack_require__("./node_modules/core-js/library/modules/_to-object.js");
  var IE_PROTO = __webpack_require__("./node_modules/core-js/library/modules/_shared-key.js")('IE_PROTO');
  var ObjectProto = Object.prototype;
  
  module.exports = Object.getPrototypeOf || function (O) {
    O = toObject(O);
    if (has(O, IE_PROTO)) return O[IE_PROTO];
    if (typeof O.constructor == 'function' && O instanceof O.constructor) {
      return O.constructor.prototype;
    } return O instanceof Object ? ObjectProto : null;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_object-keys-internal.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var has = __webpack_require__("./node_modules/core-js/library/modules/_has.js");
  var toIObject = __webpack_require__("./node_modules/core-js/library/modules/_to-iobject.js");
  var arrayIndexOf = __webpack_require__("./node_modules/core-js/library/modules/_array-includes.js")(false);
  var IE_PROTO = __webpack_require__("./node_modules/core-js/library/modules/_shared-key.js")('IE_PROTO');
  
  module.exports = function (object, names) {
    var O = toIObject(object);
    var i = 0;
    var result = [];
    var key;
    for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
    // Don't enum bug & hidden keys
    while (names.length > i) if (has(O, key = names[i++])) {
      ~arrayIndexOf(result, key) || result.push(key);
    }
    return result;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_object-keys.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.2.14 / 15.2.3.14 Object.keys(O)
  var $keys = __webpack_require__("./node_modules/core-js/library/modules/_object-keys-internal.js");
  var enumBugKeys = __webpack_require__("./node_modules/core-js/library/modules/_enum-bug-keys.js");
  
  module.exports = Object.keys || function keys(O) {
    return $keys(O, enumBugKeys);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_object-pie.js":
  /***/ (function(module, exports) {
  
  exports.f = {}.propertyIsEnumerable;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_object-sap.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // most Object methods by ES6 should accept primitives
  var $export = __webpack_require__("./node_modules/core-js/library/modules/_export.js");
  var core = __webpack_require__("./node_modules/core-js/library/modules/_core.js");
  var fails = __webpack_require__("./node_modules/core-js/library/modules/_fails.js");
  module.exports = function (KEY, exec) {
    var fn = (core.Object || {})[KEY] || Object[KEY];
    var exp = {};
    exp[KEY] = exec(fn);
    $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_perform.js":
  /***/ (function(module, exports) {
  
  module.exports = function (exec) {
    try {
      return { e: false, v: exec() };
    } catch (e) {
      return { e: true, v: e };
    }
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_promise-resolve.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var anObject = __webpack_require__("./node_modules/core-js/library/modules/_an-object.js");
  var isObject = __webpack_require__("./node_modules/core-js/library/modules/_is-object.js");
  var newPromiseCapability = __webpack_require__("./node_modules/core-js/library/modules/_new-promise-capability.js");
  
  module.exports = function (C, x) {
    anObject(C);
    if (isObject(x) && x.constructor === C) return x;
    var promiseCapability = newPromiseCapability.f(C);
    var resolve = promiseCapability.resolve;
    resolve(x);
    return promiseCapability.promise;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_property-desc.js":
  /***/ (function(module, exports) {
  
  module.exports = function (bitmap, value) {
    return {
      enumerable: !(bitmap & 1),
      configurable: !(bitmap & 2),
      writable: !(bitmap & 4),
      value: value
    };
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_redefine-all.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var hide = __webpack_require__("./node_modules/core-js/library/modules/_hide.js");
  module.exports = function (target, src, safe) {
    for (var key in src) {
      if (safe && target[key]) target[key] = src[key];
      else hide(target, key, src[key]);
    } return target;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_redefine.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__("./node_modules/core-js/library/modules/_hide.js");
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_set-species.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var global = __webpack_require__("./node_modules/core-js/library/modules/_global.js");
  var core = __webpack_require__("./node_modules/core-js/library/modules/_core.js");
  var dP = __webpack_require__("./node_modules/core-js/library/modules/_object-dp.js");
  var DESCRIPTORS = __webpack_require__("./node_modules/core-js/library/modules/_descriptors.js");
  var SPECIES = __webpack_require__("./node_modules/core-js/library/modules/_wks.js")('species');
  
  module.exports = function (KEY) {
    var C = typeof core[KEY] == 'function' ? core[KEY] : global[KEY];
    if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {
      configurable: true,
      get: function () { return this; }
    });
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_set-to-string-tag.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var def = __webpack_require__("./node_modules/core-js/library/modules/_object-dp.js").f;
  var has = __webpack_require__("./node_modules/core-js/library/modules/_has.js");
  var TAG = __webpack_require__("./node_modules/core-js/library/modules/_wks.js")('toStringTag');
  
  module.exports = function (it, tag, stat) {
    if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_shared-key.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var shared = __webpack_require__("./node_modules/core-js/library/modules/_shared.js")('keys');
  var uid = __webpack_require__("./node_modules/core-js/library/modules/_uid.js");
  module.exports = function (key) {
    return shared[key] || (shared[key] = uid(key));
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_shared.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var core = __webpack_require__("./node_modules/core-js/library/modules/_core.js");
  var global = __webpack_require__("./node_modules/core-js/library/modules/_global.js");
  var SHARED = '__core-js_shared__';
  var store = global[SHARED] || (global[SHARED] = {});
  
  (module.exports = function (key, value) {
    return store[key] || (store[key] = value !== undefined ? value : {});
  })('versions', []).push({
    version: core.version,
    mode: __webpack_require__("./node_modules/core-js/library/modules/_library.js") ? 'pure' : 'global',
    copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
  });
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_species-constructor.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.3.20 SpeciesConstructor(O, defaultConstructor)
  var anObject = __webpack_require__("./node_modules/core-js/library/modules/_an-object.js");
  var aFunction = __webpack_require__("./node_modules/core-js/library/modules/_a-function.js");
  var SPECIES = __webpack_require__("./node_modules/core-js/library/modules/_wks.js")('species');
  module.exports = function (O, D) {
    var C = anObject(O).constructor;
    var S;
    return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_string-at.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var toInteger = __webpack_require__("./node_modules/core-js/library/modules/_to-integer.js");
  var defined = __webpack_require__("./node_modules/core-js/library/modules/_defined.js");
  // true  -> String#at
  // false -> String#codePointAt
  module.exports = function (TO_STRING) {
    return function (that, pos) {
      var s = String(defined(that));
      var i = toInteger(pos);
      var l = s.length;
      var a, b;
      if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
      a = s.charCodeAt(i);
      return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
        ? TO_STRING ? s.charAt(i) : a
        : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
    };
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_task.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var ctx = __webpack_require__("./node_modules/core-js/library/modules/_ctx.js");
  var invoke = __webpack_require__("./node_modules/core-js/library/modules/_invoke.js");
  var html = __webpack_require__("./node_modules/core-js/library/modules/_html.js");
  var cel = __webpack_require__("./node_modules/core-js/library/modules/_dom-create.js");
  var global = __webpack_require__("./node_modules/core-js/library/modules/_global.js");
  var process = global.process;
  var setTask = global.setImmediate;
  var clearTask = global.clearImmediate;
  var MessageChannel = global.MessageChannel;
  var Dispatch = global.Dispatch;
  var counter = 0;
  var queue = {};
  var ONREADYSTATECHANGE = 'onreadystatechange';
  var defer, channel, port;
  var run = function () {
    var id = +this;
    // eslint-disable-next-line no-prototype-builtins
    if (queue.hasOwnProperty(id)) {
      var fn = queue[id];
      delete queue[id];
      fn();
    }
  };
  var listener = function (event) {
    run.call(event.data);
  };
  // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
  if (!setTask || !clearTask) {
    setTask = function setImmediate(fn) {
      var args = [];
      var i = 1;
      while (arguments.length > i) args.push(arguments[i++]);
      queue[++counter] = function () {
        // eslint-disable-next-line no-new-func
        invoke(typeof fn == 'function' ? fn : Function(fn), args);
      };
      defer(counter);
      return counter;
    };
    clearTask = function clearImmediate(id) {
      delete queue[id];
    };
    // Node.js 0.8-
    if (__webpack_require__("./node_modules/core-js/library/modules/_cof.js")(process) == 'process') {
      defer = function (id) {
        process.nextTick(ctx(run, id, 1));
      };
    // Sphere (JS game engine) Dispatch API
    } else if (Dispatch && Dispatch.now) {
      defer = function (id) {
        Dispatch.now(ctx(run, id, 1));
      };
    // Browsers with MessageChannel, includes WebWorkers
    } else if (MessageChannel) {
      channel = new MessageChannel();
      port = channel.port2;
      channel.port1.onmessage = listener;
      defer = ctx(port.postMessage, port, 1);
    // Browsers with postMessage, skip WebWorkers
    // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
    } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {
      defer = function (id) {
        global.postMessage(id + '', '*');
      };
      global.addEventListener('message', listener, false);
    // IE8-
    } else if (ONREADYSTATECHANGE in cel('script')) {
      defer = function (id) {
        html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {
          html.removeChild(this);
          run.call(id);
        };
      };
    // Rest old browsers
    } else {
      defer = function (id) {
        setTimeout(ctx(run, id, 1), 0);
      };
    }
  }
  module.exports = {
    set: setTask,
    clear: clearTask
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_to-absolute-index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var toInteger = __webpack_require__("./node_modules/core-js/library/modules/_to-integer.js");
  var max = Math.max;
  var min = Math.min;
  module.exports = function (index, length) {
    index = toInteger(index);
    return index < 0 ? max(index + length, 0) : min(index, length);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_to-integer.js":
  /***/ (function(module, exports) {
  
  // 7.1.4 ToInteger
  var ceil = Math.ceil;
  var floor = Math.floor;
  module.exports = function (it) {
    return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_to-iobject.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // to indexed object, toObject with fallback for non-array-like ES3 strings
  var IObject = __webpack_require__("./node_modules/core-js/library/modules/_iobject.js");
  var defined = __webpack_require__("./node_modules/core-js/library/modules/_defined.js");
  module.exports = function (it) {
    return IObject(defined(it));
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_to-length.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.1.15 ToLength
  var toInteger = __webpack_require__("./node_modules/core-js/library/modules/_to-integer.js");
  var min = Math.min;
  module.exports = function (it) {
    return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_to-object.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.1.13 ToObject(argument)
  var defined = __webpack_require__("./node_modules/core-js/library/modules/_defined.js");
  module.exports = function (it) {
    return Object(defined(it));
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_to-primitive.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // 7.1.1 ToPrimitive(input [, PreferredType])
  var isObject = __webpack_require__("./node_modules/core-js/library/modules/_is-object.js");
  // instead of the ES6 spec version, we didn't implement @@toPrimitive case
  // and the second argument - flag - preferred type is a string
  module.exports = function (it, S) {
    if (!isObject(it)) return it;
    var fn, val;
    if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
    if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
    if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
    throw TypeError("Can't convert object to primitive value");
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_uid.js":
  /***/ (function(module, exports) {
  
  var id = 0;
  var px = Math.random();
  module.exports = function (key) {
    return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_user-agent.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var global = __webpack_require__("./node_modules/core-js/library/modules/_global.js");
  var navigator = global.navigator;
  
  module.exports = navigator && navigator.userAgent || '';
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/_wks.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var store = __webpack_require__("./node_modules/core-js/library/modules/_shared.js")('wks');
  var uid = __webpack_require__("./node_modules/core-js/library/modules/_uid.js");
  var Symbol = __webpack_require__("./node_modules/core-js/library/modules/_global.js").Symbol;
  var USE_SYMBOL = typeof Symbol == 'function';
  
  var $exports = module.exports = function (name) {
    return store[name] || (store[name] =
      USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
  };
  
  $exports.store = store;
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/core.get-iterator-method.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var classof = __webpack_require__("./node_modules/core-js/library/modules/_classof.js");
  var ITERATOR = __webpack_require__("./node_modules/core-js/library/modules/_wks.js")('iterator');
  var Iterators = __webpack_require__("./node_modules/core-js/library/modules/_iterators.js");
  module.exports = __webpack_require__("./node_modules/core-js/library/modules/_core.js").getIteratorMethod = function (it) {
    if (it != undefined) return it[ITERATOR]
      || it['@@iterator']
      || Iterators[classof(it)];
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/es6.array.iterator.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var addToUnscopables = __webpack_require__("./node_modules/core-js/library/modules/_add-to-unscopables.js");
  var step = __webpack_require__("./node_modules/core-js/library/modules/_iter-step.js");
  var Iterators = __webpack_require__("./node_modules/core-js/library/modules/_iterators.js");
  var toIObject = __webpack_require__("./node_modules/core-js/library/modules/_to-iobject.js");
  
  // 22.1.3.4 Array.prototype.entries()
  // 22.1.3.13 Array.prototype.keys()
  // 22.1.3.29 Array.prototype.values()
  // 22.1.3.30 Array.prototype[@@iterator]()
  module.exports = __webpack_require__("./node_modules/core-js/library/modules/_iter-define.js")(Array, 'Array', function (iterated, kind) {
    this._t = toIObject(iterated); // target
    this._i = 0;                   // next index
    this._k = kind;                // kind
  // 22.1.5.2.1 %ArrayIteratorPrototype%.next()
  }, function () {
    var O = this._t;
    var kind = this._k;
    var index = this._i++;
    if (!O || index >= O.length) {
      this._t = undefined;
      return step(1);
    }
    if (kind == 'keys') return step(0, index);
    if (kind == 'values') return step(0, O[index]);
    return step(0, [index, O[index]]);
  }, 'values');
  
  // argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
  Iterators.Arguments = Iterators.Array;
  
  addToUnscopables('keys');
  addToUnscopables('values');
  addToUnscopables('entries');
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/es6.object.assign.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.3.1 Object.assign(target, source)
  var $export = __webpack_require__("./node_modules/core-js/library/modules/_export.js");
  
  $export($export.S + $export.F, 'Object', { assign: __webpack_require__("./node_modules/core-js/library/modules/_object-assign.js") });
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/es6.object.create.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var $export = __webpack_require__("./node_modules/core-js/library/modules/_export.js");
  // 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
  $export($export.S, 'Object', { create: __webpack_require__("./node_modules/core-js/library/modules/_object-create.js") });
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/es6.object.keys.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  // 19.1.2.14 Object.keys(O)
  var toObject = __webpack_require__("./node_modules/core-js/library/modules/_to-object.js");
  var $keys = __webpack_require__("./node_modules/core-js/library/modules/_object-keys.js");
  
  __webpack_require__("./node_modules/core-js/library/modules/_object-sap.js")('keys', function () {
    return function keys(it) {
      return $keys(toObject(it));
    };
  });
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/es6.object.to-string.js":
  /***/ (function(module, exports) {
  
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/es6.promise.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var LIBRARY = __webpack_require__("./node_modules/core-js/library/modules/_library.js");
  var global = __webpack_require__("./node_modules/core-js/library/modules/_global.js");
  var ctx = __webpack_require__("./node_modules/core-js/library/modules/_ctx.js");
  var classof = __webpack_require__("./node_modules/core-js/library/modules/_classof.js");
  var $export = __webpack_require__("./node_modules/core-js/library/modules/_export.js");
  var isObject = __webpack_require__("./node_modules/core-js/library/modules/_is-object.js");
  var aFunction = __webpack_require__("./node_modules/core-js/library/modules/_a-function.js");
  var anInstance = __webpack_require__("./node_modules/core-js/library/modules/_an-instance.js");
  var forOf = __webpack_require__("./node_modules/core-js/library/modules/_for-of.js");
  var speciesConstructor = __webpack_require__("./node_modules/core-js/library/modules/_species-constructor.js");
  var task = __webpack_require__("./node_modules/core-js/library/modules/_task.js").set;
  var microtask = __webpack_require__("./node_modules/core-js/library/modules/_microtask.js")();
  var newPromiseCapabilityModule = __webpack_require__("./node_modules/core-js/library/modules/_new-promise-capability.js");
  var perform = __webpack_require__("./node_modules/core-js/library/modules/_perform.js");
  var userAgent = __webpack_require__("./node_modules/core-js/library/modules/_user-agent.js");
  var promiseResolve = __webpack_require__("./node_modules/core-js/library/modules/_promise-resolve.js");
  var PROMISE = 'Promise';
  var TypeError = global.TypeError;
  var process = global.process;
  var versions = process && process.versions;
  var v8 = versions && versions.v8 || '';
  var $Promise = global[PROMISE];
  var isNode = classof(process) == 'process';
  var empty = function () { /* empty */ };
  var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
  var newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f;
  
  var USE_NATIVE = !!function () {
    try {
      // correct subclassing with @@species support
      var promise = $Promise.resolve(1);
      var FakePromise = (promise.constructor = {})[__webpack_require__("./node_modules/core-js/library/modules/_wks.js")('species')] = function (exec) {
        exec(empty, empty);
      };
      // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
      return (isNode || typeof PromiseRejectionEvent == 'function')
        && promise.then(empty) instanceof FakePromise
        // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
        // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
        // we can't detect it synchronously, so just check versions
        && v8.indexOf('6.6') !== 0
        && userAgent.indexOf('Chrome/66') === -1;
    } catch (e) { /* empty */ }
  }();
  
  // helpers
  var isThenable = function (it) {
    var then;
    return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
  };
  var notify = function (promise, isReject) {
    if (promise._n) return;
    promise._n = true;
    var chain = promise._c;
    microtask(function () {
      var value = promise._v;
      var ok = promise._s == 1;
      var i = 0;
      var run = function (reaction) {
        var handler = ok ? reaction.ok : reaction.fail;
        var resolve = reaction.resolve;
        var reject = reaction.reject;
        var domain = reaction.domain;
        var result, then, exited;
        try {
          if (handler) {
            if (!ok) {
              if (promise._h == 2) onHandleUnhandled(promise);
              promise._h = 1;
            }
            if (handler === true) result = value;
            else {
              if (domain) domain.enter();
              result = handler(value); // may throw
              if (domain) {
                domain.exit();
                exited = true;
              }
            }
            if (result === reaction.promise) {
              reject(TypeError('Promise-chain cycle'));
            } else if (then = isThenable(result)) {
              then.call(result, resolve, reject);
            } else resolve(result);
          } else reject(value);
        } catch (e) {
          if (domain && !exited) domain.exit();
          reject(e);
        }
      };
      while (chain.length > i) run(chain[i++]); // variable length - can't use forEach
      promise._c = [];
      promise._n = false;
      if (isReject && !promise._h) onUnhandled(promise);
    });
  };
  var onUnhandled = function (promise) {
    task.call(global, function () {
      var value = promise._v;
      var unhandled = isUnhandled(promise);
      var result, handler, console;
      if (unhandled) {
        result = perform(function () {
          if (isNode) {
            process.emit('unhandledRejection', value, promise);
          } else if (handler = global.onunhandledrejection) {
            handler({ promise: promise, reason: value });
          } else if ((console = global.console) && console.error) {
            console.error('Unhandled promise rejection', value);
          }
        });
        // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
        promise._h = isNode || isUnhandled(promise) ? 2 : 1;
      } promise._a = undefined;
      if (unhandled && result.e) throw result.v;
    });
  };
  var isUnhandled = function (promise) {
    return promise._h !== 1 && (promise._a || promise._c).length === 0;
  };
  var onHandleUnhandled = function (promise) {
    task.call(global, function () {
      var handler;
      if (isNode) {
        process.emit('rejectionHandled', promise);
      } else if (handler = global.onrejectionhandled) {
        handler({ promise: promise, reason: promise._v });
      }
    });
  };
  var $reject = function (value) {
    var promise = this;
    if (promise._d) return;
    promise._d = true;
    promise = promise._w || promise; // unwrap
    promise._v = value;
    promise._s = 2;
    if (!promise._a) promise._a = promise._c.slice();
    notify(promise, true);
  };
  var $resolve = function (value) {
    var promise = this;
    var then;
    if (promise._d) return;
    promise._d = true;
    promise = promise._w || promise; // unwrap
    try {
      if (promise === value) throw TypeError("Promise can't be resolved itself");
      if (then = isThenable(value)) {
        microtask(function () {
          var wrapper = { _w: promise, _d: false }; // wrap
          try {
            then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
          } catch (e) {
            $reject.call(wrapper, e);
          }
        });
      } else {
        promise._v = value;
        promise._s = 1;
        notify(promise, false);
      }
    } catch (e) {
      $reject.call({ _w: promise, _d: false }, e); // wrap
    }
  };
  
  // constructor polyfill
  if (!USE_NATIVE) {
    // 25.4.3.1 Promise(executor)
    $Promise = function Promise(executor) {
      anInstance(this, $Promise, PROMISE, '_h');
      aFunction(executor);
      Internal.call(this);
      try {
        executor(ctx($resolve, this, 1), ctx($reject, this, 1));
      } catch (err) {
        $reject.call(this, err);
      }
    };
    // eslint-disable-next-line no-unused-vars
    Internal = function Promise(executor) {
      this._c = [];             // <- awaiting reactions
      this._a = undefined;      // <- checked in isUnhandled reactions
      this._s = 0;              // <- state
      this._d = false;          // <- done
      this._v = undefined;      // <- value
      this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
      this._n = false;          // <- notify
    };
    Internal.prototype = __webpack_require__("./node_modules/core-js/library/modules/_redefine-all.js")($Promise.prototype, {
      // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
      then: function then(onFulfilled, onRejected) {
        var reaction = newPromiseCapability(speciesConstructor(this, $Promise));
        reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
        reaction.fail = typeof onRejected == 'function' && onRejected;
        reaction.domain = isNode ? process.domain : undefined;
        this._c.push(reaction);
        if (this._a) this._a.push(reaction);
        if (this._s) notify(this, false);
        return reaction.promise;
      },
      // 25.4.5.1 Promise.prototype.catch(onRejected)
      'catch': function (onRejected) {
        return this.then(undefined, onRejected);
      }
    });
    OwnPromiseCapability = function () {
      var promise = new Internal();
      this.promise = promise;
      this.resolve = ctx($resolve, promise, 1);
      this.reject = ctx($reject, promise, 1);
    };
    newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
      return C === $Promise || C === Wrapper
        ? new OwnPromiseCapability(C)
        : newGenericPromiseCapability(C);
    };
  }
  
  $export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise });
  __webpack_require__("./node_modules/core-js/library/modules/_set-to-string-tag.js")($Promise, PROMISE);
  __webpack_require__("./node_modules/core-js/library/modules/_set-species.js")(PROMISE);
  Wrapper = __webpack_require__("./node_modules/core-js/library/modules/_core.js")[PROMISE];
  
  // statics
  $export($export.S + $export.F * !USE_NATIVE, PROMISE, {
    // 25.4.4.5 Promise.reject(r)
    reject: function reject(r) {
      var capability = newPromiseCapability(this);
      var $$reject = capability.reject;
      $$reject(r);
      return capability.promise;
    }
  });
  $export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
    // 25.4.4.6 Promise.resolve(x)
    resolve: function resolve(x) {
      return promiseResolve(LIBRARY && this === Wrapper ? $Promise : this, x);
    }
  });
  $export($export.S + $export.F * !(USE_NATIVE && __webpack_require__("./node_modules/core-js/library/modules/_iter-detect.js")(function (iter) {
    $Promise.all(iter)['catch'](empty);
  })), PROMISE, {
    // 25.4.4.1 Promise.all(iterable)
    all: function all(iterable) {
      var C = this;
      var capability = newPromiseCapability(C);
      var resolve = capability.resolve;
      var reject = capability.reject;
      var result = perform(function () {
        var values = [];
        var index = 0;
        var remaining = 1;
        forOf(iterable, false, function (promise) {
          var $index = index++;
          var alreadyCalled = false;
          values.push(undefined);
          remaining++;
          C.resolve(promise).then(function (value) {
            if (alreadyCalled) return;
            alreadyCalled = true;
            values[$index] = value;
            --remaining || resolve(values);
          }, reject);
        });
        --remaining || resolve(values);
      });
      if (result.e) reject(result.v);
      return capability.promise;
    },
    // 25.4.4.4 Promise.race(iterable)
    race: function race(iterable) {
      var C = this;
      var capability = newPromiseCapability(C);
      var reject = capability.reject;
      var result = perform(function () {
        forOf(iterable, false, function (promise) {
          C.resolve(promise).then(capability.resolve, reject);
        });
      });
      if (result.e) reject(result.v);
      return capability.promise;
    }
  });
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/es6.string.iterator.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var $at = __webpack_require__("./node_modules/core-js/library/modules/_string-at.js")(true);
  
  // 21.1.3.27 String.prototype[@@iterator]()
  __webpack_require__("./node_modules/core-js/library/modules/_iter-define.js")(String, 'String', function (iterated) {
    this._t = String(iterated); // target
    this._i = 0;                // next index
  // 21.1.5.2.1 %StringIteratorPrototype%.next()
  }, function () {
    var O = this._t;
    var index = this._i;
    var point;
    if (index >= O.length) return { value: undefined, done: true };
    point = $at(O, index);
    this._i += point.length;
    return { value: point, done: false };
  });
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/es7.promise.finally.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  // https://github.com/tc39/proposal-promise-finally
  
  var $export = __webpack_require__("./node_modules/core-js/library/modules/_export.js");
  var core = __webpack_require__("./node_modules/core-js/library/modules/_core.js");
  var global = __webpack_require__("./node_modules/core-js/library/modules/_global.js");
  var speciesConstructor = __webpack_require__("./node_modules/core-js/library/modules/_species-constructor.js");
  var promiseResolve = __webpack_require__("./node_modules/core-js/library/modules/_promise-resolve.js");
  
  $export($export.P + $export.R, 'Promise', { 'finally': function (onFinally) {
    var C = speciesConstructor(this, core.Promise || global.Promise);
    var isFunction = typeof onFinally == 'function';
    return this.then(
      isFunction ? function (x) {
        return promiseResolve(C, onFinally()).then(function () { return x; });
      } : onFinally,
      isFunction ? function (e) {
        return promiseResolve(C, onFinally()).then(function () { throw e; });
      } : onFinally
    );
  } });
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/es7.promise.try.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  // https://github.com/tc39/proposal-promise-try
  var $export = __webpack_require__("./node_modules/core-js/library/modules/_export.js");
  var newPromiseCapability = __webpack_require__("./node_modules/core-js/library/modules/_new-promise-capability.js");
  var perform = __webpack_require__("./node_modules/core-js/library/modules/_perform.js");
  
  $export($export.S, 'Promise', { 'try': function (callbackfn) {
    var promiseCapability = newPromiseCapability.f(this);
    var result = perform(callbackfn);
    (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);
    return promiseCapability.promise;
  } });
  
  
  /***/ }),
  
  /***/ "./node_modules/core-js/library/modules/web.dom.iterable.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  __webpack_require__("./node_modules/core-js/library/modules/es6.array.iterator.js");
  var global = __webpack_require__("./node_modules/core-js/library/modules/_global.js");
  var hide = __webpack_require__("./node_modules/core-js/library/modules/_hide.js");
  var Iterators = __webpack_require__("./node_modules/core-js/library/modules/_iterators.js");
  var TO_STRING_TAG = __webpack_require__("./node_modules/core-js/library/modules/_wks.js")('toStringTag');
  
  var DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +
    'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +
    'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +
    'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +
    'TextTrackList,TouchList').split(',');
  
  for (var i = 0; i < DOMIterables.length; i++) {
    var NAME = DOMIterables[i];
    var Collection = global[NAME];
    var proto = Collection && Collection.prototype;
    if (proto && !proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
    Iterators[NAME] = Iterators.Array;
  }
  
  
  /***/ }),
  
  /***/ "./node_modules/core-util-is/lib/util.js":
  /***/ (function(module, exports) {
  
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  // NOTE: These type checking functions intentionally don't use `instanceof`
  // because it is fragile and can be easily faked with `Object.create()`.
  
  function isArray(arg) {
    if (Array.isArray) {
      return Array.isArray(arg);
    }
    return objectToString(arg) === '[object Array]';
  }
  exports.isArray = isArray;
  
  function isBoolean(arg) {
    return typeof arg === 'boolean';
  }
  exports.isBoolean = isBoolean;
  
  function isNull(arg) {
    return arg === null;
  }
  exports.isNull = isNull;
  
  function isNullOrUndefined(arg) {
    return arg == null;
  }
  exports.isNullOrUndefined = isNullOrUndefined;
  
  function isNumber(arg) {
    return typeof arg === 'number';
  }
  exports.isNumber = isNumber;
  
  function isString(arg) {
    return typeof arg === 'string';
  }
  exports.isString = isString;
  
  function isSymbol(arg) {
    return typeof arg === 'symbol';
  }
  exports.isSymbol = isSymbol;
  
  function isUndefined(arg) {
    return arg === void 0;
  }
  exports.isUndefined = isUndefined;
  
  function isRegExp(re) {
    return objectToString(re) === '[object RegExp]';
  }
  exports.isRegExp = isRegExp;
  
  function isObject(arg) {
    return typeof arg === 'object' && arg !== null;
  }
  exports.isObject = isObject;
  
  function isDate(d) {
    return objectToString(d) === '[object Date]';
  }
  exports.isDate = isDate;
  
  function isError(e) {
    return (objectToString(e) === '[object Error]' || e instanceof Error);
  }
  exports.isError = isError;
  
  function isFunction(arg) {
    return typeof arg === 'function';
  }
  exports.isFunction = isFunction;
  
  function isPrimitive(arg) {
    return arg === null ||
           typeof arg === 'boolean' ||
           typeof arg === 'number' ||
           typeof arg === 'string' ||
           typeof arg === 'symbol' ||  // ES6 symbol
           typeof arg === 'undefined';
  }
  exports.isPrimitive = isPrimitive;
  
  exports.isBuffer = Buffer.isBuffer;
  
  function objectToString(o) {
    return Object.prototype.toString.call(o);
  }
  
  
  /***/ }),
  
  /***/ "./node_modules/date-format/lib/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  function padWithZeros(vNumber, width) {
      var numAsString = vNumber.toString();
      while (numAsString.length < width) {
          numAsString = '0' + numAsString;
      }
      return numAsString;
  }
  
  function addZero(vNumber) {
      return padWithZeros(vNumber, 2);
  }
  
  /**
   * Formats the TimeOffset
   * Thanks to http://www.svendtofte.com/code/date_format/
   * @private
   */
  function offset(timezoneOffset) {
    // Difference to Greenwich time (GMT) in hours
      var os = Math.abs(timezoneOffset);
      var h = String(Math.floor(os / 60));
      var m = String(os % 60);
      if (h.length === 1) {
          h = '0' + h;
      }
      if (m.length === 1) {
          m = '0' + m;
      }
      return timezoneOffset < 0 ? '+' + h + m : '-' + h + m;
  }
  
  function asString(format, date, timezoneOffset) {
      if (typeof format !== 'string') {
          timezoneOffset = date;
          date = format;
          format = module.exports.ISO8601_FORMAT;
      }
      if (!date) {
          date = new Date();
      }
    // make the date independent of the system timezone by working with UTC
      if (timezoneOffset === undefined) {
          timezoneOffset = date.getTimezoneOffset();
      }
  
      date.setUTCMinutes(date.getUTCMinutes() - timezoneOffset);
      var vDay = addZero(date.getUTCDate());
      var vMonth = addZero(date.getUTCMonth() + 1);
      var vYearLong = addZero(date.getUTCFullYear());
      var vYearShort = addZero(date.getUTCFullYear().toString().substring(2, 4));
      var vYear = (format.indexOf('yyyy') > -1 ? vYearLong : vYearShort);
      var vHour = addZero(date.getUTCHours());
      var vMinute = addZero(date.getUTCMinutes());
      var vSecond = addZero(date.getUTCSeconds());
      var vMillisecond = padWithZeros(date.getUTCMilliseconds(), 3);
      var vTimeZone = offset(timezoneOffset);
      date.setUTCMinutes(date.getUTCMinutes() + timezoneOffset);
      var formatted = format
      .replace(/dd/g, vDay)
      .replace(/MM/g, vMonth)
      .replace(/y{1,4}/g, vYear)
      .replace(/hh/g, vHour)
      .replace(/mm/g, vMinute)
      .replace(/ss/g, vSecond)
      .replace(/SSS/g, vMillisecond)
      .replace(/O/g, vTimeZone);
      return formatted;
  }
  
  module.exports = asString;
  module.exports.asString = asString;
  module.exports.ISO8601_FORMAT = 'yyyy-MM-ddThh:mm:ss.SSS';
  module.exports.ISO8601_WITH_TZ_OFFSET_FORMAT = 'yyyy-MM-ddThh:mm:ss.SSSO';
  module.exports.DATETIME_FORMAT = 'dd MM yyyy hh:mm:ss.SSS';
  module.exports.ABSOLUTETIME_FORMAT = 'hh:mm:ss.SSS';
  
  
  /***/ }),
  
  /***/ "./node_modules/debug/src/browser.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  /* eslint-env browser */
  
  /**
   * This is the web browser implementation of `debug()`.
   */
  exports.log = log;
  exports.formatArgs = formatArgs;
  exports.save = save;
  exports.load = load;
  exports.useColors = useColors;
  exports.storage = localstorage();
  /**
   * Colors.
   */
  
  exports.colors = ['#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC', '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF', '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC', '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF', '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC', '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033', '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366', '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933', '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC', '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF', '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'];
  /**
   * Currently only WebKit-based Web Inspectors, Firefox >= v31,
   * and the Firebug extension (any Firefox version) are known
   * to support "%c" CSS customizations.
   *
   * TODO: add a `localStorage` variable to explicitly enable/disable colors
   */
  // eslint-disable-next-line complexity
  
  function useColors() {
    // NB: In an Electron preload script, document will be defined but not fully
    // initialized. Since we know we're in Chrome, we'll just detect this case
    // explicitly
    if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
      return true;
    } // Internet Explorer and Edge do not support colors.
  
  
    if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
      return false;
    } // Is webkit? http://stackoverflow.com/a/16459606/376773
    // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
  
  
    return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
    typeof window !== 'undefined' && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
    typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
    typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
  }
  /**
   * Colorize log arguments if enabled.
   *
   * @api public
   */
  
  
  function formatArgs(args) {
    args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff);
  
    if (!this.useColors) {
      return;
    }
  
    var c = 'color: ' + this.color;
    args.splice(1, 0, c, 'color: inherit'); // The final "%c" is somewhat tricky, because there could be other
    // arguments passed either before or after the %c, so we need to
    // figure out the correct index to insert the CSS into
  
    var index = 0;
    var lastC = 0;
    args[0].replace(/%[a-zA-Z%]/g, function (match) {
      if (match === '%%') {
        return;
      }
  
      index++;
  
      if (match === '%c') {
        // We only are interested in the *last* %c
        // (the user may have provided their own)
        lastC = index;
      }
    });
    args.splice(lastC, 0, c);
  }
  /**
   * Invokes `console.log()` when available.
   * No-op when `console.log` is not a "function".
   *
   * @api public
   */
  
  
  function log() {
    var _console;
  
    // This hackery is required for IE8/9, where
    // the `console.log` function doesn't have 'apply'
    return (typeof console === "undefined" ? "undefined" : _typeof(console)) === 'object' && console.log && (_console = console).log.apply(_console, arguments);
  }
  /**
   * Save `namespaces`.
   *
   * @param {String} namespaces
   * @api private
   */
  
  
  function save(namespaces) {
    try {
      if (namespaces) {
        exports.storage.setItem('debug', namespaces);
      } else {
        exports.storage.removeItem('debug');
      }
    } catch (error) {// Swallow
      // XXX (@Qix-) should we be logging these?
    }
  }
  /**
   * Load `namespaces`.
   *
   * @return {String} returns the previously persisted debug modes
   * @api private
   */
  
  
  function load() {
    var r;
  
    try {
      r = exports.storage.getItem('debug');
    } catch (error) {} // Swallow
    // XXX (@Qix-) should we be logging these?
    // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
  
  
    if (!r && typeof process !== 'undefined' && 'env' in process) {
      r = process.env.DEBUG;
    }
  
    return r;
  }
  /**
   * Localstorage attempts to return the localstorage.
   *
   * This is necessary because safari throws
   * when a user disables cookies/localstorage
   * and you attempt to access it.
   *
   * @return {LocalStorage}
   * @api private
   */
  
  
  function localstorage() {
    try {
      // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
      // The Browser also has localStorage in the global context.
      return localStorage;
    } catch (error) {// Swallow
      // XXX (@Qix-) should we be logging these?
    }
  }
  
  module.exports = __webpack_require__("./node_modules/debug/src/common.js")(exports);
  var formatters = module.exports.formatters;
  /**
   * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
   */
  
  formatters.j = function (v) {
    try {
      return JSON.stringify(v);
    } catch (error) {
      return '[UnexpectedJSONParseError]: ' + error.message;
    }
  };
  
  
  
  /***/ }),
  
  /***/ "./node_modules/debug/src/common.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /**
   * This is the common logic for both the Node.js and web browser
   * implementations of `debug()`.
   */
  function setup(env) {
    createDebug.debug = createDebug;
    createDebug.default = createDebug;
    createDebug.coerce = coerce;
    createDebug.disable = disable;
    createDebug.enable = enable;
    createDebug.enabled = enabled;
    createDebug.humanize = __webpack_require__("./node_modules/ms/index.js");
    Object.keys(env).forEach(function (key) {
      createDebug[key] = env[key];
    });
    /**
    * Active `debug` instances.
    */
  
    createDebug.instances = [];
    /**
    * The currently active debug mode names, and names to skip.
    */
  
    createDebug.names = [];
    createDebug.skips = [];
    /**
    * Map of special "%n" handling functions, for the debug "format" argument.
    *
    * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
    */
  
    createDebug.formatters = {};
    /**
    * Selects a color for a debug namespace
    * @param {String} namespace The namespace string for the for the debug instance to be colored
    * @return {Number|String} An ANSI color code for the given namespace
    * @api private
    */
  
    function selectColor(namespace) {
      var hash = 0;
  
      for (var i = 0; i < namespace.length; i++) {
        hash = (hash << 5) - hash + namespace.charCodeAt(i);
        hash |= 0; // Convert to 32bit integer
      }
  
      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
    }
  
    createDebug.selectColor = selectColor;
    /**
    * Create a debugger with the given `namespace`.
    *
    * @param {String} namespace
    * @return {Function}
    * @api public
    */
  
    function createDebug(namespace) {
      var prevTime;
  
      function debug() {
        // Disabled?
        if (!debug.enabled) {
          return;
        }
  
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
  
        var self = debug; // Set `diff` timestamp
  
        var curr = Number(new Date());
        var ms = curr - (prevTime || curr);
        self.diff = ms;
        self.prev = prevTime;
        self.curr = curr;
        prevTime = curr;
        args[0] = createDebug.coerce(args[0]);
  
        if (typeof args[0] !== 'string') {
          // Anything else let's inspect with %O
          args.unshift('%O');
        } // Apply any `formatters` transformations
  
  
        var index = 0;
        args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
          // If we encounter an escaped % then don't increase the array index
          if (match === '%%') {
            return match;
          }
  
          index++;
          var formatter = createDebug.formatters[format];
  
          if (typeof formatter === 'function') {
            var val = args[index];
            match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format`
  
            args.splice(index, 1);
            index--;
          }
  
          return match;
        }); // Apply env-specific formatting (colors, etc.)
  
        createDebug.formatArgs.call(self, args);
        var logFn = self.log || createDebug.log;
        logFn.apply(self, args);
      }
  
      debug.namespace = namespace;
      debug.enabled = createDebug.enabled(namespace);
      debug.useColors = createDebug.useColors();
      debug.color = selectColor(namespace);
      debug.destroy = destroy;
      debug.extend = extend; // Debug.formatArgs = formatArgs;
      // debug.rawLog = rawLog;
      // env-specific initialization logic for debug instances
  
      if (typeof createDebug.init === 'function') {
        createDebug.init(debug);
      }
  
      createDebug.instances.push(debug);
      return debug;
    }
  
    function destroy() {
      var index = createDebug.instances.indexOf(this);
  
      if (index !== -1) {
        createDebug.instances.splice(index, 1);
        return true;
      }
  
      return false;
    }
  
    function extend(namespace, delimiter) {
      return createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
    }
    /**
    * Enables a debug mode by namespaces. This can include modes
    * separated by a colon and wildcards.
    *
    * @param {String} namespaces
    * @api public
    */
  
  
    function enable(namespaces) {
      createDebug.save(namespaces);
      createDebug.names = [];
      createDebug.skips = [];
      var i;
      var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
      var len = split.length;
  
      for (i = 0; i < len; i++) {
        if (!split[i]) {
          // ignore empty strings
          continue;
        }
  
        namespaces = split[i].replace(/\*/g, '.*?');
  
        if (namespaces[0] === '-') {
          createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
        } else {
          createDebug.names.push(new RegExp('^' + namespaces + '$'));
        }
      }
  
      for (i = 0; i < createDebug.instances.length; i++) {
        var instance = createDebug.instances[i];
        instance.enabled = createDebug.enabled(instance.namespace);
      }
    }
    /**
    * Disable debug output.
    *
    * @api public
    */
  
  
    function disable() {
      createDebug.enable('');
    }
    /**
    * Returns true if the given mode name is enabled, false otherwise.
    *
    * @param {String} name
    * @return {Boolean}
    * @api public
    */
  
  
    function enabled(name) {
      if (name[name.length - 1] === '*') {
        return true;
      }
  
      var i;
      var len;
  
      for (i = 0, len = createDebug.skips.length; i < len; i++) {
        if (createDebug.skips[i].test(name)) {
          return false;
        }
      }
  
      for (i = 0, len = createDebug.names.length; i < len; i++) {
        if (createDebug.names[i].test(name)) {
          return true;
        }
      }
  
      return false;
    }
    /**
    * Coerce `val`.
    *
    * @param {Mixed} val
    * @return {Mixed}
    * @api private
    */
  
  
    function coerce(val) {
      if (val instanceof Error) {
        return val.stack || val.message;
      }
  
      return val;
    }
  
    createDebug.enable(createDebug.load());
    return createDebug;
  }
  
  module.exports = setup;
  
  
  
  /***/ }),
  
  /***/ "./node_modules/debug/src/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /**
   * Detect Electron renderer / nwjs process, which is node, but we should
   * treat as a browser.
   */
  if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
    module.exports = __webpack_require__("./node_modules/debug/src/browser.js");
  } else {
    module.exports = __webpack_require__("./node_modules/debug/src/node.js");
  }
  
  
  
  /***/ }),
  
  /***/ "./node_modules/debug/src/node.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /**
   * Module dependencies.
   */
  var tty = __webpack_require__("tty");
  
  var util = __webpack_require__("util");
  /**
   * This is the Node.js implementation of `debug()`.
   */
  
  
  exports.init = init;
  exports.log = log;
  exports.formatArgs = formatArgs;
  exports.save = save;
  exports.load = load;
  exports.useColors = useColors;
  /**
   * Colors.
   */
  
  exports.colors = [6, 2, 3, 4, 5, 1];
  
  try {
    // Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
    // eslint-disable-next-line import/no-extraneous-dependencies
    var supportsColor = __webpack_require__("./node_modules/supports-color/index.js");
  
    if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
      exports.colors = [20, 21, 26, 27, 32, 33, 38, 39, 40, 41, 42, 43, 44, 45, 56, 57, 62, 63, 68, 69, 74, 75, 76, 77, 78, 79, 80, 81, 92, 93, 98, 99, 112, 113, 128, 129, 134, 135, 148, 149, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 178, 179, 184, 185, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 214, 215, 220, 221];
    }
  } catch (error) {} // Swallow - we only care if `supports-color` is available; it doesn't have to be.
  
  /**
   * Build up the default `inspectOpts` object from the environment variables.
   *
   *   $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
   */
  
  
  exports.inspectOpts = Object.keys(process.env).filter(function (key) {
    return /^debug_/i.test(key);
  }).reduce(function (obj, key) {
    // Camel-case
    var prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, function (_, k) {
      return k.toUpperCase();
    }); // Coerce string value into JS value
  
    var val = process.env[key];
  
    if (/^(yes|on|true|enabled)$/i.test(val)) {
      val = true;
    } else if (/^(no|off|false|disabled)$/i.test(val)) {
      val = false;
    } else if (val === 'null') {
      val = null;
    } else {
      val = Number(val);
    }
  
    obj[prop] = val;
    return obj;
  }, {});
  /**
   * Is stdout a TTY? Colored output is enabled when `true`.
   */
  
  function useColors() {
    return 'colors' in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
  }
  /**
   * Adds ANSI color escape codes if enabled.
   *
   * @api public
   */
  
  
  function formatArgs(args) {
    var name = this.namespace,
        useColors = this.useColors;
  
    if (useColors) {
      var c = this.color;
      var colorCode = "\x1B[3" + (c < 8 ? c : '8;5;' + c);
      var prefix = "  ".concat(colorCode, ";1m").concat(name, " \x1B[0m");
      args[0] = prefix + args[0].split('\n').join('\n' + prefix);
      args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + "\x1B[0m");
    } else {
      args[0] = getDate() + name + ' ' + args[0];
    }
  }
  
  function getDate() {
    if (exports.inspectOpts.hideDate) {
      return '';
    }
  
    return new Date().toISOString() + ' ';
  }
  /**
   * Invokes `util.format()` with the specified arguments and writes to stderr.
   */
  
  
  function log() {
    return process.stderr.write(util.format.apply(util, arguments) + '\n');
  }
  /**
   * Save `namespaces`.
   *
   * @param {String} namespaces
   * @api private
   */
  
  
  function save(namespaces) {
    if (namespaces) {
      process.env.DEBUG = namespaces;
    } else {
      // If you set a process.env field to null or undefined, it gets cast to the
      // string 'null' or 'undefined'. Just delete instead.
      delete process.env.DEBUG;
    }
  }
  /**
   * Load `namespaces`.
   *
   * @return {String} returns the previously persisted debug modes
   * @api private
   */
  
  
  function load() {
    return process.env.DEBUG;
  }
  /**
   * Init logic for `debug` instances.
   *
   * Create a new `inspectOpts` object in case `useColors` is set
   * differently for a particular `debug` instance.
   */
  
  
  function init(debug) {
    debug.inspectOpts = {};
    var keys = Object.keys(exports.inspectOpts);
  
    for (var i = 0; i < keys.length; i++) {
      debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
    }
  }
  
  module.exports = __webpack_require__("./node_modules/debug/src/common.js")(exports);
  var formatters = module.exports.formatters;
  /**
   * Map %o to `util.inspect()`, all on a single line.
   */
  
  formatters.o = function (v) {
    this.inspectOpts.colors = this.useColors;
    return util.inspect(v, this.inspectOpts).replace(/\s*\n\s*/g, ' ');
  };
  /**
   * Map %O to `util.inspect()`, allowing multiple lines if needed.
   */
  
  
  formatters.O = function (v) {
    this.inspectOpts.colors = this.useColors;
    return util.inspect(v, this.inspectOpts);
  };
  
  
  
  /***/ }),
  
  /***/ "./node_modules/decode-uri-component/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var token = '%[a-f0-9]{2}';
  var singleMatcher = new RegExp(token, 'gi');
  var multiMatcher = new RegExp('(' + token + ')+', 'gi');
  
  function decodeComponents(components, split) {
  	try {
  		// Try to decode the entire string first
  		return decodeURIComponent(components.join(''));
  	} catch (err) {
  		// Do nothing
  	}
  
  	if (components.length === 1) {
  		return components;
  	}
  
  	split = split || 1;
  
  	// Split the array in 2 parts
  	var left = components.slice(0, split);
  	var right = components.slice(split);
  
  	return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
  }
  
  function decode(input) {
  	try {
  		return decodeURIComponent(input);
  	} catch (err) {
  		var tokens = input.match(singleMatcher);
  
  		for (var i = 1; i < tokens.length; i++) {
  			input = decodeComponents(tokens, i).join('');
  
  			tokens = input.match(singleMatcher);
  		}
  
  		return input;
  	}
  }
  
  function customDecodeURIComponent(input) {
  	// Keep track of all the replacements and prefill the map with the `BOM`
  	var replaceMap = {
  		'%FE%FF': '\uFFFD\uFFFD',
  		'%FF%FE': '\uFFFD\uFFFD'
  	};
  
  	var match = multiMatcher.exec(input);
  	while (match) {
  		try {
  			// Decode as big chunks as possible
  			replaceMap[match[0]] = decodeURIComponent(match[0]);
  		} catch (err) {
  			var result = decode(match[0]);
  
  			if (result !== match[0]) {
  				replaceMap[match[0]] = result;
  			}
  		}
  
  		match = multiMatcher.exec(input);
  	}
  
  	// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
  	replaceMap['%C2'] = '\uFFFD';
  
  	var entries = Object.keys(replaceMap);
  
  	for (var i = 0; i < entries.length; i++) {
  		// Replace all decoded components
  		var key = entries[i];
  		input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
  	}
  
  	return input;
  }
  
  module.exports = function (encodedURI) {
  	if (typeof encodedURI !== 'string') {
  		throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
  	}
  
  	try {
  		encodedURI = encodedURI.replace(/\+/g, ' ');
  
  		// Try the built in decoder first
  		return decodeURIComponent(encodedURI);
  	} catch (err) {
  		// Fallback to a more advanced decoder
  		return customDecodeURIComponent(encodedURI);
  	}
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/has-flag/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  module.exports = (flag, argv) => {
  	argv = argv || process.argv;
  	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
  	const pos = argv.indexOf(prefix + flag);
  	const terminatorPos = argv.indexOf('--');
  	return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/inherits/inherits.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  try {
    var util = __webpack_require__("util");
    if (typeof util.inherits !== 'function') throw '';
    module.exports = util.inherits;
  } catch (e) {
    module.exports = __webpack_require__("./node_modules/inherits/inherits_browser.js");
  }
  
  
  /***/ }),
  
  /***/ "./node_modules/inherits/inherits_browser.js":
  /***/ (function(module, exports) {
  
  if (typeof Object.create === 'function') {
    // implementation from standard node.js 'util' module
    module.exports = function inherits(ctor, superCtor) {
      ctor.super_ = superCtor
      ctor.prototype = Object.create(superCtor.prototype, {
        constructor: {
          value: ctor,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
    };
  } else {
    // old school shim for old browsers
    module.exports = function inherits(ctor, superCtor) {
      ctor.super_ = superCtor
      var TempCtor = function () {}
      TempCtor.prototype = superCtor.prototype
      ctor.prototype = new TempCtor()
      ctor.prototype.constructor = ctor
    }
  }
  
  
  /***/ }),
  
  /***/ "./node_modules/isarray/index.js":
  /***/ (function(module, exports) {
  
  var toString = {}.toString;
  
  module.exports = Array.isArray || function (arr) {
    return toString.call(arr) == '[object Array]';
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/LoggingEvent.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  const CircularJSON = __webpack_require__("./node_modules/circular-json/build/circular-json.node.js");
  const levels = __webpack_require__("./node_modules/log4js/lib/levels.js");
  
  /**
   * @name LoggingEvent
   * @namespace Log4js
   */
  class LoggingEvent {
    /**
     * Models a logging event.
     * @constructor
     * @param {String} categoryName name of category
     * @param {Log4js.Level} level level of message
     * @param {Array} data objects to log
     * @author Seth Chisamore
     */
    constructor(categoryName, level, data, context) {
      this.startTime = new Date();
      this.categoryName = categoryName;
      this.data = data;
      this.level = level;
      this.context = Object.assign({}, context);
      this.pid = process.pid;
    }
  
    serialise() {
      const logData = this.data.map((e) => {
        // JSON.stringify(new Error('test')) returns {}, which is not really useful for us.
        // The following allows us to serialize errors correctly.
        if (e && e.message && e.stack) {
          e = Object.assign({ message: e.message, stack: e.stack }, e);
        }
        return e;
      });
      this.data = logData;
      return CircularJSON.stringify(this);
    }
  
    static deserialise(serialised) {
      let event;
      try {
        const rehydratedEvent = CircularJSON.parse(serialised);
        rehydratedEvent.data = rehydratedEvent.data.map((e) => {
          if (e && e.message && e.stack) {
            const fakeError = new Error(e);
            Object.keys(e).forEach((key) => { fakeError[key] = e[key]; });
            e = fakeError;
          }
          return e;
        });
        event = new LoggingEvent(
          rehydratedEvent.categoryName,
          levels.getLevel(rehydratedEvent.level.levelStr),
          rehydratedEvent.data,
          rehydratedEvent.context
        );
        event.startTime = new Date(rehydratedEvent.startTime);
        event.pid = rehydratedEvent.pid;
        event.cluster = rehydratedEvent.cluster;
      } catch (e) {
        event = new LoggingEvent(
          'log4js',
          levels.ERROR,
          ['Unable to parse log:', serialised, 'because: ', e]
        );
      }
  
      return event;
    }
  }
  
  module.exports = LoggingEvent;
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/appenders sync recursive":
  /***/ (function(module, exports) {
  
  function webpackEmptyContext(req) {
  	var e = new Error("Cannot find module '" + req + "'");
  	e.code = 'MODULE_NOT_FOUND';
  	throw e;
  }
  webpackEmptyContext.keys = function() { return []; };
  webpackEmptyContext.resolve = webpackEmptyContext;
  module.exports = webpackEmptyContext;
  webpackEmptyContext.id = "./node_modules/log4js/lib/appenders sync recursive";
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/appenders/adapters.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  function maxFileSizeUnitTransform(maxLogSize) {
    if (typeof maxLogSize === 'number' && Number.isInteger(maxLogSize)) {
      return maxLogSize;
    }
  
    const units = {
      K: 1024,
      M: 1024 * 1024,
      G: 1024 * 1024 * 1024,
    };
    const validUnit = Object.keys(units);
    const unit = maxLogSize.substr(maxLogSize.length - 1).toLocaleUpperCase();
    const value = maxLogSize.substring(0, maxLogSize.length - 1).trim();
  
    if (validUnit.indexOf(unit) < 0 || !Number.isInteger(Number(value))) {
      throw Error(`maxLogSize: "${maxLogSize}" is invalid`);
    } else {
      return value * units[unit];
    }
  }
  
  function adapter(configAdapter, config) {
    const newConfig = Object.assign({}, config);
    Object.keys(configAdapter).forEach((key) => {
      if (newConfig[key]) {
        newConfig[key] = configAdapter[key](config[key]);
      }
    });
    return newConfig;
  }
  
  function fileAppenderAdapter(config) {
    const configAdapter = {
      maxLogSize: maxFileSizeUnitTransform
    };
    return adapter(configAdapter, config);
  }
  
  const adapters = {
    file: fileAppenderAdapter,
    fileSync: fileAppenderAdapter
  };
  
  module.exports.modifyConfig = config => (adapters[config.type] ? adapters[config.type](config) : config);
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/appenders/console.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  const consoleLog = console.log.bind(console);
  
  function consoleAppender(layout, timezoneOffset) {
    return (loggingEvent) => {
      consoleLog(layout(loggingEvent, timezoneOffset));
    };
  }
  
  function configure(config, layouts) {
    let layout = layouts.colouredLayout;
    if (config.layout) {
      layout = layouts.layout(config.layout.type, config.layout);
    }
    return consoleAppender(layout, config.timezoneOffset);
  }
  
  module.exports.configure = configure;
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/appenders/dateFile.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  const streams = __webpack_require__("./node_modules/streamroller/lib/index.js");
  const os = __webpack_require__("os");
  
  const eol = os.EOL || '\n';
  
  /**
   * File appender that rolls files according to a date pattern.
   * @filename base filename.
   * @pattern the format that will be added to the end of filename when rolling,
   *          also used to check when to roll files - defaults to '.yyyy-MM-dd'
   * @layout layout function for log messages - defaults to basicLayout
   * @timezoneOffset optional timezone offset in minutes - defaults to system local
   */
  function appender(
    filename,
    pattern,
    layout,
    options,
    timezoneOffset
  ) {
    const logFile = new streams.DateRollingFileStream(
      filename,
      pattern,
      options
    );
  
    const app = function (logEvent) {
      logFile.write(layout(logEvent, timezoneOffset) + eol, 'utf8');
    };
  
    app.shutdown = function (complete) {
      logFile.write('', 'utf-8', () => {
        logFile.end(complete);
      });
    };
  
    return app;
  }
  
  function configure(config, layouts) {
    let layout = layouts.basicLayout;
  
    if (config.layout) {
      layout = layouts.layout(config.layout.type, config.layout);
    }
  
    if (!config.alwaysIncludePattern) {
      config.alwaysIncludePattern = false;
    }
  
    return appender(
      config.filename,
      config.pattern,
      layout,
      config,
      config.timezoneOffset
    );
  }
  
  module.exports.configure = configure;
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/appenders/file.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  const debug = __webpack_require__("./node_modules/debug/src/index.js")('log4js:file');
  const path = __webpack_require__("path");
  const streams = __webpack_require__("./node_modules/streamroller/lib/index.js");
  const os = __webpack_require__("os");
  
  const eol = os.EOL || '\n';
  
  function openTheStream(file, fileSize, numFiles, options) {
    const stream = new streams.RollingFileStream(
      file,
      fileSize,
      numFiles,
      options
    );
    stream.on('error', (err) => {
      console.error('log4js.fileAppender - Writing to file %s, error happened ', file, err); //eslint-disable-line
    });
    return stream;
  }
  
  
  /**
   * File Appender writing the logs to a text file. Supports rolling of logs by size.
   *
   * @param file file log messages will be written to
   * @param layout a function that takes a logEvent and returns a string
   *   (defaults to basicLayout).
   * @param logSize - the maximum size (in bytes) for a log file,
   *   if not provided then logs won't be rotated.
   * @param numBackups - the number of log files to keep after logSize
   *   has been reached (default 5)
   * @param options - options to be passed to the underlying stream
   * @param timezoneOffset - optional timezone offset in minutes (default system local)
   */
  function fileAppender(file, layout, logSize, numBackups, options, timezoneOffset) {
    file = path.normalize(file);
    numBackups = numBackups === undefined ? 5 : numBackups;
    // there has to be at least one backup if logSize has been specified
    numBackups = numBackups === 0 ? 1 : numBackups;
  
    debug(
      'Creating file appender (',
      file, ', ',
      logSize, ', ',
      numBackups, ', ',
      options, ', ',
      timezoneOffset, ')'
    );
  
    const writer = openTheStream(file, logSize, numBackups, options);
  
    const app = function (loggingEvent) {
      writer.write(layout(loggingEvent, timezoneOffset) + eol, 'utf8');
    };
  
    app.reopen = function () {
      writer.closeTheStream(writer.openTheStream.bind(writer));
    };
  
    app.sighupHandler = function () {
      debug('SIGHUP handler called.');
      app.reopen();
    };
  
    app.shutdown = function (complete) {
      process.removeListener('SIGHUP', app.sighupHandler);
      writer.write('', 'utf-8', () => {
        writer.end(complete);
      });
    };
  
    // On SIGHUP, close and reopen all files. This allows this appender to work with
    // logrotate. Note that if you are using logrotate, you should not set
    // `logSize`.
    process.on('SIGHUP', app.sighupHandler);
  
    return app;
  }
  
  function configure(config, layouts) {
    let layout = layouts.basicLayout;
    if (config.layout) {
      layout = layouts.layout(config.layout.type, config.layout);
    }
  
    return fileAppender(
      config.filename,
      layout,
      config.maxLogSize,
      config.backups,
      config,
      config.timezoneOffset
    );
  }
  
  module.exports.configure = configure;
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/appenders/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  const path = __webpack_require__("path");
  const debug = __webpack_require__("./node_modules/debug/src/index.js")('log4js:appenders');
  const configuration = __webpack_require__("./node_modules/log4js/lib/configuration.js");
  const clustering = __webpack_require__("./node_modules/log4js/lib/clustering.js");
  const levels = __webpack_require__("./node_modules/log4js/lib/levels.js");
  const layouts = __webpack_require__("./node_modules/log4js/lib/layouts.js");
  const adapters = __webpack_require__("./node_modules/log4js/lib/appenders/adapters.js");
  
  // pre-load the core appenders so that webpack can find them
  const coreAppenders = new Map();
  coreAppenders.set('console', __webpack_require__("./node_modules/log4js/lib/appenders/console.js"));
  coreAppenders.set('stdout', __webpack_require__("./node_modules/log4js/lib/appenders/stdout.js"));
  coreAppenders.set('stderr', __webpack_require__("./node_modules/log4js/lib/appenders/stderr.js"));
  coreAppenders.set('file', __webpack_require__("./node_modules/log4js/lib/appenders/file.js"));
  coreAppenders.set('dateFile', __webpack_require__("./node_modules/log4js/lib/appenders/dateFile.js"));
  
  const appenders = new Map();
  
  const tryLoading = (modulePath, config) => {
    debug('Loading module from ', modulePath);
    try {
      return __webpack_require__("./node_modules/log4js/lib/appenders sync recursive")(modulePath); //eslint-disable-line
    } catch (e) {
      // if the module was found, and we still got an error, then raise it
      configuration.throwExceptionIf(
        config,
        e.code !== 'MODULE_NOT_FOUND',
        `appender "${modulePath}" could not be loaded (error was: ${e})`
      );
      return undefined;
    }
  };
  
  const loadAppenderModule = (type, config) => coreAppenders.get(type) ||
    tryLoading(`./${type}`, config) ||
    tryLoading(type, config) ||
    (__webpack_require__.c[__webpack_require__.s] && tryLoading(path.join(path.dirname(__webpack_require__.c[__webpack_require__.s].filename), type), config)) ||
    tryLoading(path.join(process.cwd(), type), config);
  
  const createAppender = (name, config) => {
    const appenderConfig = config.appenders[name];
    const appenderModule = loadAppenderModule(appenderConfig.type, config);
    configuration.throwExceptionIf(
      config,
      configuration.not(appenderModule),
      `appender "${name}" is not valid (type "${appenderConfig.type}" could not be found)`
    );
    if (appenderModule.appender) {
      debug(`DEPRECATION: Appender ${appenderConfig.type} exports an appender function.`);
    }
    if (appenderModule.shutdown) {
      debug(`DEPRECATION: Appender ${appenderConfig.type} exports a shutdown function.`);
    }
  
    debug(`${name}: clustering.isMaster ? ${clustering.isMaster()}`);
    debug(`${name}: appenderModule is ${__webpack_require__("util").inspect(appenderModule)}`); // eslint-disable-line
    return clustering.onlyOnMaster(() => {
      debug(`calling appenderModule.configure for ${name} / ${appenderConfig.type}`);
      return appenderModule.configure(
        adapters.modifyConfig(appenderConfig),
        layouts,
        appender => appenders.get(appender),
        levels
      );
    }, () => {});
  };
  
  const setup = (config) => {
    appenders.clear();
  
    Object.keys(config.appenders).forEach((name) => {
      debug(`Creating appender ${name}`);
      appenders.set(name, createAppender(name, config));
    });
  };
  
  setup({ appenders: { out: { type: 'stdout' } } });
  
  configuration.addListener((config) => {
    configuration.throwExceptionIf(
      config,
      configuration.not(configuration.anObject(config.appenders)),
      'must have a property "appenders" of type object.'
    );
    const appenderNames = Object.keys(config.appenders);
    configuration.throwExceptionIf(
      config,
      configuration.not(appenderNames.length),
      'must define at least one appender.'
    );
  
    appenderNames.forEach((name) => {
      configuration.throwExceptionIf(
        config,
        configuration.not(config.appenders[name].type),
        `appender "${name}" is not valid (must be an object with property "type")`
      );
    });
  });
  
  configuration.addListener(setup);
  
  module.exports = appenders;
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/appenders/stderr.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  function stderrAppender(layout, timezoneOffset) {
    return (loggingEvent) => {
      process.stderr.write(`${layout(loggingEvent, timezoneOffset)}\n`);
    };
  }
  
  function configure(config, layouts) {
    let layout = layouts.colouredLayout;
    if (config.layout) {
      layout = layouts.layout(config.layout.type, config.layout);
    }
    return stderrAppender(layout, config.timezoneOffset);
  }
  
  module.exports.configure = configure;
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/appenders/stdout.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  function stdoutAppender(layout, timezoneOffset) {
    return (loggingEvent) => {
      process.stdout.write(`${layout(loggingEvent, timezoneOffset)}\n`);
    };
  }
  
  function configure(config, layouts) {
    let layout = layouts.colouredLayout;
    if (config.layout) {
      layout = layouts.layout(config.layout.type, config.layout);
    }
    return stdoutAppender(layout, config.timezoneOffset);
  }
  
  exports.configure = configure;
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/categories.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  const configuration = __webpack_require__("./node_modules/log4js/lib/configuration.js");
  const levels = __webpack_require__("./node_modules/log4js/lib/levels.js");
  const appenders = __webpack_require__("./node_modules/log4js/lib/appenders/index.js");
  const debug = __webpack_require__("./node_modules/debug/src/index.js")('log4js:categories');
  
  const categories = new Map();
  
  configuration.addListener((config) => {
    configuration.throwExceptionIf(
      config,
      configuration.not(configuration.anObject(config.categories)),
      'must have a property "categories" of type object.'
    );
  
    const categoryNames = Object.keys(config.categories);
    configuration.throwExceptionIf(
      config,
      configuration.not(categoryNames.length),
      'must define at least one category.'
    );
  
    categoryNames.forEach((name) => {
      const category = config.categories[name];
      configuration.throwExceptionIf(
        config,
        [
          configuration.not(category.appenders),
          configuration.not(category.level)
        ],
        `category "${name}" is not valid (must be an object with properties "appenders" and "level")`
      );
  
      configuration.throwExceptionIf(
        config,
        configuration.not(Array.isArray(category.appenders)),
        `category "${name}" is not valid (appenders must be an array of appender names)`
      );
  
      configuration.throwExceptionIf(
        config,
        configuration.not(category.appenders.length),
        `category "${name}" is not valid (appenders must contain at least one appender name)`
      );
  
      category.appenders.forEach((appender) => {
        configuration.throwExceptionIf(
          config,
          configuration.not(appenders.get(appender)),
          `category "${name}" is not valid (appender "${appender}" is not defined)`
        );
      });
  
      configuration.throwExceptionIf(
        config,
        configuration.not(levels.getLevel(category.level)),
        `category "${name}" is not valid (level "${category.level}" not recognised;` +
          ` valid levels are ${levels.levels.join(', ')})`
      );
    });
  
    configuration.throwExceptionIf(
      config,
      configuration.not(config.categories.default),
      'must define a "default" category.'
    );
  });
  
  const setup = (config) => {
    categories.clear();
  
    const categoryNames = Object.keys(config.categories);
    categoryNames.forEach((name) => {
      const category = config.categories[name];
      const categoryAppenders = [];
      category.appenders.forEach((appender) => {
        categoryAppenders.push(appenders.get(appender));
        debug(`Creating category ${name}`);
        categories.set(
          name,
          { appenders: categoryAppenders, level: levels.getLevel(category.level) }
        );
      });
    });
  };
  
  setup({ categories: { default: { appenders: ['out'], level: 'OFF' } } });
  configuration.addListener(setup);
  
  const configForCategory = (category) => {
    debug(`configForCategory: searching for config for ${category}`);
    if (categories.has(category)) {
      debug(`configForCategory: ${category} exists in config, returning it`);
      return categories.get(category);
    }
    if (category.indexOf('.') > 0) {
      debug(`configForCategory: ${category} has hierarchy, searching for parents`);
      return configForCategory(category.substring(0, category.lastIndexOf('.')));
    }
    debug('configForCategory: returning config for default category');
    return configForCategory('default');
  };
  
  const appendersForCategory = category => configForCategory(category).appenders;
  const getLevelForCategory = category => configForCategory(category).level;
  
  const setLevelForCategory = (category, level) => {
    let categoryConfig = categories.get(category);
    debug(`setLevelForCategory: found ${categoryConfig} for ${category}`);
    if (!categoryConfig) {
      const sourceCategoryConfig = configForCategory(category);
      debug('setLevelForCategory: no config found for category, ' +
        `found ${sourceCategoryConfig} for parents of ${category}`);
      categoryConfig = { appenders: sourceCategoryConfig.appenders };
    }
    categoryConfig.level = level;
    categories.set(category, categoryConfig);
  };
  
  module.exports = {
    appendersForCategory,
    getLevelForCategory,
    setLevelForCategory
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/clustering.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  const debug = __webpack_require__("./node_modules/debug/src/index.js")('log4js:clustering');
  const LoggingEvent = __webpack_require__("./node_modules/log4js/lib/LoggingEvent.js");
  const configuration = __webpack_require__("./node_modules/log4js/lib/configuration.js");
  const cluster = __webpack_require__("cluster");
  
  const listeners = [];
  
  let disabled = false;
  let pm2 = false;
  let pm2InstanceVar = 'NODE_APP_INSTANCE';
  
  const isPM2Master = () => pm2 && process.env[pm2InstanceVar] === '0';
  const isMaster = () => disabled || cluster.isMaster || isPM2Master();
  
  const sendToListeners = (logEvent) => {
    listeners.forEach(l => l(logEvent));
  };
  
  // in a multi-process node environment, worker loggers will use
  // process.send
  const receiver = (worker, message) => {
    // prior to node v6, the worker parameter was not passed (args were message, handle)
    debug('cluster message received from worker ', worker, ': ', message);
    if (worker.topic && worker.data) {
      message = worker;
      worker = undefined;
    }
    if (message && message.topic && message.topic === 'log4js:message') {
      debug('received message: ', message.data);
      const logEvent = LoggingEvent.deserialise(message.data);
      sendToListeners(logEvent);
    }
  };
  
  configuration.addListener((config) => {
    // clear out the listeners, because configure has been called.
    listeners.length = 0;
  
    disabled = config.disableClustering;
    pm2 = config.pm2;
    pm2InstanceVar = config.pm2InstanceVar || 'NODE_APP_INSTANCE';
  
    debug(`clustering disabled ? ${disabled}`);
    debug(`cluster.isMaster ? ${cluster.isMaster}`);
    debug(`pm2 enabled ? ${pm2}`);
    debug(`pm2InstanceVar = ${pm2InstanceVar}`);
    debug(`process.env[${pm2InstanceVar}] = ${process.env[pm2InstanceVar]}`);
  
    // just in case configure is called after shutdown
    if (pm2) {
      process.removeListener('message', receiver);
    }
    if (cluster.removeListener) {
      cluster.removeListener('message', receiver);
    }
  
    if (config.disableClustering) {
      debug('Not listening for cluster messages, because clustering disabled.');
    } else if (isPM2Master()) {
      // PM2 cluster support
      // PM2 runs everything as workers - install pm2-intercom for this to work.
      // we only want one of the app instances to write logs
      debug('listening for PM2 broadcast messages');
      process.on('message', receiver);
    } else if (cluster.isMaster) {
      debug('listening for cluster messages');
      cluster.on('message', receiver);
    } else {
      debug('not listening for messages, because we are not a master process');
    }
  });
  
  module.exports = {
    onlyOnMaster: (fn, notMaster) => (isMaster() ? fn() : notMaster),
    isMaster: isMaster,
    send: (msg) => {
      if (isMaster()) {
        sendToListeners(msg);
      } else {
        if (!pm2) {
          msg.cluster = {
            workerId: cluster.worker.id,
            worker: process.pid
          };
        }
        process.send({ topic: 'log4js:message', data: msg.serialise() });
      }
    },
    onMessage: (listener) => {
      listeners.push(listener);
    }
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/configuration.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  const util = __webpack_require__("util");
  const debug = __webpack_require__("./node_modules/debug/src/index.js")('log4js:configuration');
  
  const listeners = [];
  
  const not = thing => !thing;
  
  const anObject = thing => thing && typeof thing === 'object' && !Array.isArray(thing);
  
  const validIdentifier = thing => /^[A-Za-z][A-Za-z0-9_]*$/g.test(thing);
  
  const anInteger = thing => thing && typeof thing === 'number' && Number.isInteger(thing);
  
  const addListener = (fn) => {
    listeners.push(fn);
    debug(`Added listener, listeners now ${listeners.length}`);
  };
  
  const throwExceptionIf = (config, checks, message) => {
    const tests = Array.isArray(checks) ? checks : [checks];
    tests.forEach((test) => {
      if (test) {
        throw new Error(`Problem with log4js configuration: (${util.inspect(config, { depth: 5 })})` +
          ` - ${message}`);
      }
    });
  };
  
  const configure = (candidate) => {
    debug('New configuration to be validated: ', candidate);
    throwExceptionIf(candidate, not(anObject(candidate)), 'must be an object.');
  
    debug(`Calling configuration listeners (${listeners.length})`);
    listeners.forEach(listener => listener(candidate));
    debug('Configuration finished.');
  };
  
  module.exports = {
    configure,
    addListener,
    throwExceptionIf,
    anObject,
    anInteger,
    validIdentifier,
    not
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/connect-logger.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* eslint-disable no-plusplus */
  
  
  
  const levels = __webpack_require__("./node_modules/log4js/lib/levels.js");
  
  const DEFAULT_FORMAT = ':remote-addr - -' +
    ' ":method :url HTTP/:http-version"' +
    ' :status :content-length ":referrer"' +
    ' ":user-agent"';
  
    /**
     * Return request url path,
     * adding this function prevents the Cyclomatic Complexity,
     * for the assemble_tokens function at low, to pass the tests.
     *
     * @param  {IncomingMessage} req
     * @return {String}
     * @api private
     */
  
  function getUrl(req) {
    return req.originalUrl || req.url;
  }
  
  
  /**
     * Adds custom {token, replacement} objects to defaults,
     * overwriting the defaults if any tokens clash
     *
     * @param  {IncomingMessage} req
     * @param  {ServerResponse} res
     * @param  {Array} customTokens
     *    [{ token: string-or-regexp, replacement: string-or-replace-function }]
     * @return {Array}
     */
  function assembleTokens(req, res, customTokens) {
    const arrayUniqueTokens = (array) => {
      const a = array.concat();
      for (let i = 0; i < a.length; ++i) {
        for (let j = i + 1; j < a.length; ++j) {
          // not === because token can be regexp object
          /* eslint eqeqeq:0 */
          if (a[i].token == a[j].token) {
            a.splice(j--, 1);
          }
        }
      }
      return a;
    };
  
    const defaultTokens = [];
    defaultTokens.push({ token: ':url', replacement: getUrl(req) });
    defaultTokens.push({ token: ':protocol', replacement: req.protocol });
    defaultTokens.push({ token: ':hostname', replacement: req.hostname });
    defaultTokens.push({ token: ':method', replacement: req.method });
    defaultTokens.push({ token: ':status', replacement: res.__statusCode || res.statusCode });
    defaultTokens.push({ token: ':response-time', replacement: res.responseTime });
    defaultTokens.push({ token: ':date', replacement: new Date().toUTCString() });
    defaultTokens.push({
      token: ':referrer',
      replacement: req.headers.referer || req.headers.referrer || ''
    });
    defaultTokens.push({
      token: ':http-version',
      replacement: `${req.httpVersionMajor}.${req.httpVersionMinor}`
    });
    defaultTokens.push({
      token: ':remote-addr',
      replacement: req.headers['x-forwarded-for'] ||
        req.ip ||
        req._remoteAddress ||
        (req.socket &&
          (req.socket.remoteAddress ||
            (req.socket.socket && req.socket.socket.remoteAddress)
          )
        )
    });
    defaultTokens.push({ token: ':user-agent', replacement: req.headers['user-agent'] });
    defaultTokens.push({
      token: ':content-length',
      replacement: (res._headers && res._headers['content-length']) ||
        (res.__headers && res.__headers['Content-Length']) ||
        '-'
    });
    defaultTokens.push({
      token: /:req\[([^\]]+)]/g,
      replacement: function (_, field) {
        return req.headers[field.toLowerCase()];
      }
    });
    defaultTokens.push({
      token: /:res\[([^\]]+)]/g,
      replacement: function (_, field) {
        return res._headers ?
          (res._headers[field.toLowerCase()] || res.__headers[field])
          : (res.__headers && res.__headers[field]);
      }
    });
  
    return arrayUniqueTokens(customTokens.concat(defaultTokens));
  }
  
  /**
     * Return formatted log line.
     *
     * @param  {String} str
     * @param {Array} tokens
     * @return {String}
     * @api private
     */
  function format(str, tokens) {
    for (let i = 0; i < tokens.length; i++) {
      str = str.replace(tokens[i].token, tokens[i].replacement);
    }
    return str;
  }
  
  /**
     * Return RegExp Object about nolog
     *
     * @param  {String|Array} nolog
     * @return {RegExp}
     * @api private
     *
     * syntax
     *  1. String
     *   1.1 "\\.gif"
     *         NOT LOGGING http://example.com/hoge.gif and http://example.com/hoge.gif?fuga
     *         LOGGING http://example.com/hoge.agif
     *   1.2 in "\\.gif|\\.jpg$"
     *         NOT LOGGING http://example.com/hoge.gif and
     *           http://example.com/hoge.gif?fuga and http://example.com/hoge.jpg?fuga
     *         LOGGING http://example.com/hoge.agif,
     *           http://example.com/hoge.ajpg and http://example.com/hoge.jpg?hoge
     *   1.3 in "\\.(gif|jpe?g|png)$"
     *         NOT LOGGING http://example.com/hoge.gif and http://example.com/hoge.jpeg
     *         LOGGING http://example.com/hoge.gif?uid=2 and http://example.com/hoge.jpg?pid=3
     *  2. RegExp
     *   2.1 in /\.(gif|jpe?g|png)$/
     *         SAME AS 1.3
     *  3. Array
     *   3.1 ["\\.jpg$", "\\.png", "\\.gif"]
     *         SAME AS "\\.jpg|\\.png|\\.gif"
     */
  function createNoLogCondition(nolog) {
    let regexp = null;
  
    if (nolog) {
      if (nolog instanceof RegExp) {
        regexp = nolog;
      }
  
      if (typeof nolog === 'string') {
        regexp = new RegExp(nolog);
      }
  
      if (Array.isArray(nolog)) {
        // convert to strings
        const regexpsAsStrings = nolog.map(reg => (reg.source ? reg.source : reg));
        regexp = new RegExp(regexpsAsStrings.join('|'));
      }
    }
  
    return regexp;
  }
  
  /**
     * Log requests with the given `options` or a `format` string.
     *
     * Options:
     *
     *   - `format`        Format string, see below for tokens
     *   - `level`         A log4js levels instance. Supports also 'auto'
     *   - `nolog`         A string or RegExp to exclude target logs
     *
     * Tokens:
     *
     *   - `:req[header]` ex: `:req[Accept]`
     *   - `:res[header]` ex: `:res[Content-Length]`
     *   - `:http-version`
     *   - `:response-time`
     *   - `:remote-addr`
     *   - `:date`
     *   - `:method`
     *   - `:url`
     *   - `:referrer`
     *   - `:user-agent`
     *   - `:status`
     *
     * @return {Function}
     * @param logger4js
     * @param options
     * @api public
     */
  module.exports = function getLogger(logger4js, options) {
    /* eslint no-underscore-dangle:0 */
    if (typeof options === 'object') {
      options = options || {};
    } else if (options) {
      options = { format: options };
    } else {
      options = {};
    }
  
    const thisLogger = logger4js;
    let level = levels.getLevel(options.level, levels.INFO);
    const fmt = options.format || DEFAULT_FORMAT;
    const nolog = options.nolog ? createNoLogCondition(options.nolog) : null;
  
    return (req, res, next) => {
      // mount safety
      if (req._logging) return next();
  
      // nologs
      if (nolog && nolog.test(req.originalUrl)) return next();
  
      if (thisLogger.isLevelEnabled(level) || options.level === 'auto') {
        const start = new Date();
        const writeHead = res.writeHead;
  
        // flag as logging
        req._logging = true;
  
        // proxy for statusCode.
        res.writeHead = (code, headers) => {
          res.writeHead = writeHead;
          res.writeHead(code, headers);
  
          res.__statusCode = code;
          res.__headers = headers || {};
  
          // status code response level handling
          if (options.level === 'auto') {
            level = levels.INFO;
            if (code >= 300) level = levels.WARN;
            if (code >= 400) level = levels.ERROR;
          } else {
            level = levels.getLevel(options.level, levels.INFO);
          }
        };
  
        // hook on end request to emit the log entry of the HTTP request.
        res.on('finish', () => {
          res.responseTime = new Date() - start;
          // status code response level handling
          if (res.statusCode && options.level === 'auto') {
            level = levels.INFO;
            if (res.statusCode >= 300) level = levels.WARN;
            if (res.statusCode >= 400) level = levels.ERROR;
          }
  
          if (thisLogger.isLevelEnabled(level)) {
            const combinedTokens = assembleTokens(req, res, options.tokens || []);
  
            if (typeof fmt === 'function') {
              const line = fmt(req, res, str => format(str, combinedTokens));
              if (line) thisLogger.log(level, line);
            } else {
              thisLogger.log(level, format(fmt, combinedTokens));
            }
          }
        });
      }
  
      // ensure next gets always called
      return next();
    };
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/layouts.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  const dateFormat = __webpack_require__("./node_modules/date-format/lib/index.js");
  const os = __webpack_require__("os");
  const util = __webpack_require__("util");
  
  const eol = os.EOL || '\n';
  
  const styles = {
    // styles
    bold: [1, 22],
    italic: [3, 23],
    underline: [4, 24],
    inverse: [7, 27],
    // grayscale
    white: [37, 39],
    grey: [90, 39],
    black: [90, 39],
    // colors
    blue: [34, 39],
    cyan: [36, 39],
    green: [32, 39],
    magenta: [35, 39],
    red: [91, 39],
    yellow: [33, 39]
  };
  
  function colorizeStart(style) {
    return style ? `\x1B[${styles[style][0]}m` : '';
  }
  
  function colorizeEnd(style) {
    return style ? `\x1B[${styles[style][1]}m` : '';
  }
  
  /**
   * Taken from masylum's fork (https://github.com/masylum/log4js-node)
   */
  function colorize(str, style) {
    return colorizeStart(style) + str + colorizeEnd(style);
  }
  
  function timestampLevelAndCategory(loggingEvent, colour, timezoneOffset) {
    return colorize(
      util.format(
        '[%s] [%s] %s - '
        , dateFormat.asString(loggingEvent.startTime, timezoneOffset)
        , loggingEvent.level
        , loggingEvent.categoryName
      )
      , colour
    );
  }
  
  /**
   * BasicLayout is a simple layout for storing the logs. The logs are stored
   * in following format:
   * <pre>
   * [startTime] [logLevel] categoryName - message\n
   * </pre>
   *
   * @author Stephan Strittmatter
   */
  function basicLayout(loggingEvent, timezoneOffset) {
    return timestampLevelAndCategory(
      loggingEvent,
      undefined,
      timezoneOffset
    ) + util.format(...loggingEvent.data);
  }
  
  /**
   * colouredLayout - taken from masylum's fork.
   * same as basicLayout, but with colours.
   */
  function colouredLayout(loggingEvent, timezoneOffset) {
    return timestampLevelAndCategory(
      loggingEvent,
      loggingEvent.level.colour,
      timezoneOffset
    ) + util.format(...loggingEvent.data);
  }
  
  function messagePassThroughLayout(loggingEvent) {
    return util.format(...loggingEvent.data);
  }
  
  function dummyLayout(loggingEvent) {
    return loggingEvent.data[0];
  }
  
  /**
   * PatternLayout
   * Format for specifiers is %[padding].[truncation][field]{[format]}
   * e.g. %5.10p - left pad the log level by 5 characters, up to a max of 10
   * Fields can be any of:
   *  - %r time in toLocaleTimeString format
   *  - %p log level
   *  - %c log category
   *  - %h hostname
   *  - %m log data
   *  - %d date in constious formats
   *  - %% %
   *  - %n newline
   *  - %z pid
   *  - %x{<tokenname>} add dynamic tokens to your log. Tokens are specified in the tokens parameter
   *  - %X{<tokenname>} add dynamic tokens to your log. Tokens are specified in logger context
   * You can use %[ and %] to define a colored block.
   *
   * Tokens are specified as simple key:value objects.
   * The key represents the token name whereas the value can be a string or function
   * which is called to extract the value to put in the log message. If token is not
   * found, it doesn't replace the field.
   *
   * A sample token would be: { 'pid' : function() { return process.pid; } }
   *
   * Takes a pattern string, array of tokens and returns a layout function.
   * @return {Function}
   * @param pattern
   * @param tokens
   * @param timezoneOffset
   *
   * @authors ['Stephan Strittmatter', 'Jan Schmidle']
   */
  function patternLayout(pattern, tokens, timezoneOffset) {
    const TTCC_CONVERSION_PATTERN = '%r %p %c - %m%n';
    const regex = /%(-?[0-9]+)?(\.?[0-9]+)?([[\]cdhmnprzxXy%])(\{([^}]+)\})?|([^%]+)/;
  
    pattern = pattern || TTCC_CONVERSION_PATTERN;
  
    function categoryName(loggingEvent, specifier) {
      let loggerName = loggingEvent.categoryName;
      if (specifier) {
        const precision = parseInt(specifier, 10);
        const loggerNameBits = loggerName.split('.');
        if (precision < loggerNameBits.length) {
          loggerName = loggerNameBits.slice(loggerNameBits.length - precision).join('.');
        }
      }
      return loggerName;
    }
  
    function formatAsDate(loggingEvent, specifier) {
      let format = dateFormat.ISO8601_FORMAT;
      if (specifier) {
        format = specifier;
        // Pick up special cases
        if (format === 'ISO8601') {
          format = dateFormat.ISO8601_FORMAT;
        } else if (format === 'ISO8601_WITH_TZ_OFFSET') {
          format = dateFormat.ISO8601_WITH_TZ_OFFSET_FORMAT;
        } else if (format === 'ABSOLUTE') {
          format = dateFormat.ABSOLUTETIME_FORMAT;
        } else if (format === 'DATE') {
          format = dateFormat.DATETIME_FORMAT;
        }
      }
      // Format the date
      return dateFormat.asString(format, loggingEvent.startTime, timezoneOffset);
    }
  
    function hostname() {
      return os.hostname().toString();
    }
  
    function formatMessage(loggingEvent) {
      return util.format(...loggingEvent.data);
    }
  
    function endOfLine() {
      return eol;
    }
  
    function logLevel(loggingEvent) {
      return loggingEvent.level.toString();
    }
  
    function startTime(loggingEvent) {
      return dateFormat.asString('hh:mm:ss', loggingEvent.startTime, timezoneOffset);
    }
  
    function startColour(loggingEvent) {
      return colorizeStart(loggingEvent.level.colour);
    }
  
    function endColour(loggingEvent) {
      return colorizeEnd(loggingEvent.level.colour);
    }
  
    function percent() {
      return '%';
    }
  
    function pid(loggingEvent) {
      return loggingEvent && loggingEvent.pid ? loggingEvent.pid.toString() : process.pid.toString();
    }
  
    function clusterInfo() {
      // this used to try to return the master and worker pids,
      // but it would never have worked because master pid is not available to workers
      // leaving this here to maintain compatibility for patterns
      return pid();
    }
  
    function userDefined(loggingEvent, specifier) {
      if (typeof tokens[specifier] !== 'undefined') {
        return typeof tokens[specifier] === 'function' ? tokens[specifier](loggingEvent) : tokens[specifier];
      }
  
      return null;
    }
  
    function contextDefined(loggingEvent, specifier) {
      const resolver = loggingEvent.context[specifier];
  
      if (typeof resolver !== 'undefined') {
        return typeof resolver === 'function' ? resolver(loggingEvent) : resolver;
      }
  
      return null;
    }
  
    /* eslint quote-props:0 */
    const replacers = {
      'c': categoryName,
      'd': formatAsDate,
      'h': hostname,
      'm': formatMessage,
      'n': endOfLine,
      'p': logLevel,
      'r': startTime,
      '[': startColour,
      ']': endColour,
      'y': clusterInfo,
      'z': pid,
      '%': percent,
      'x': userDefined,
      'X': contextDefined
    };
  
    function replaceToken(conversionCharacter, loggingEvent, specifier) {
      return replacers[conversionCharacter](loggingEvent, specifier);
    }
  
    function truncate(truncation, toTruncate) {
      let len;
      if (truncation) {
        len = parseInt(truncation.substr(1), 10);
        return toTruncate.substring(0, len);
      }
  
      return toTruncate;
    }
  
    function pad(padding, toPad) {
      let len;
      if (padding) {
        if (padding.charAt(0) === '-') {
          len = parseInt(padding.substr(1), 10);
          // Right pad with spaces
          while (toPad.length < len) {
            toPad += ' ';
          }
        } else {
          len = parseInt(padding, 10);
          // Left pad with spaces
          while (toPad.length < len) {
            toPad = ` ${toPad}`;
          }
        }
      }
      return toPad;
    }
  
    function truncateAndPad(toTruncAndPad, truncation, padding) {
      let replacement = toTruncAndPad;
      replacement = truncate(truncation, replacement);
      replacement = pad(padding, replacement);
      return replacement;
    }
  
    return function (loggingEvent) {
      let formattedString = '';
      let result;
      let searchString = pattern;
  
      /* eslint no-cond-assign:0 */
      while ((result = regex.exec(searchString)) !== null) {
        // const matchedString = result[0];
        const padding = result[1];
        const truncation = result[2];
        const conversionCharacter = result[3];
        const specifier = result[5];
        const text = result[6];
  
        // Check if the pattern matched was just normal text
        if (text) {
          formattedString += text.toString();
        } else {
          // Create a raw replacement string based on the conversion
          // character and specifier
          const replacement = replaceToken(conversionCharacter, loggingEvent, specifier);
          formattedString += truncateAndPad(replacement, truncation, padding);
        }
        searchString = searchString.substr(result.index + result[0].length);
      }
      return formattedString;
    };
  }
  
  const layoutMakers = {
    messagePassThrough: function () {
      return messagePassThroughLayout;
    },
    basic: function () {
      return basicLayout;
    },
    colored: function () {
      return colouredLayout;
    },
    coloured: function () {
      return colouredLayout;
    },
    pattern: function (config) {
      return patternLayout(config && config.pattern, config && config.tokens);
    },
    dummy: function () {
      return dummyLayout;
    }
  };
  
  module.exports = {
    basicLayout,
    messagePassThroughLayout,
    patternLayout,
    colouredLayout,
    coloredLayout: colouredLayout,
    dummyLayout,
    addLayout: function (name, serializerGenerator) {
      layoutMakers[name] = serializerGenerator;
    },
    layout: function (name, config) {
      return layoutMakers[name] && layoutMakers[name](config);
    }
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/levels.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  const configuration = __webpack_require__("./node_modules/log4js/lib/configuration.js");
  
  const validColours = [
    'white', 'grey', 'black',
    'blue', 'cyan', 'green',
    'magenta', 'red', 'yellow'
  ];
  
  class Level {
    constructor(level, levelStr, colour) {
      this.level = level;
      this.levelStr = levelStr;
      this.colour = colour;
    }
  
    toString() {
      return this.levelStr;
    }
  
    /**
     * converts given String to corresponding Level
     * @param {Level|String} sArg -- String value of Level OR Log4js.Level
     * @param {Level} [defaultLevel] -- default Level, if no String representation
     * @return {Level}
     */
    static getLevel(sArg, defaultLevel) {
      if (!sArg) {
        return defaultLevel;
      }
  
      if (sArg instanceof Level) {
        return sArg;
      }
  
      // a json-serialised level won't be an instance of Level (see issue #768)
      if (sArg instanceof Object && sArg.levelStr) {
        sArg = sArg.levelStr;
      }
  
      if (typeof sArg === 'string') {
        return Level[sArg.toUpperCase()] || defaultLevel;
      }
  
      return Level.getLevel(sArg.toString());
    }
  
    static addLevels(customLevels) {
      if (customLevels) {
        const levels = Object.keys(customLevels);
        levels.forEach((l) => {
          Level[l.toUpperCase()] = new Level(
            customLevels[l].value,
            l.toUpperCase(),
            customLevels[l].colour
          );
          Level.levels.push(Level[l.toUpperCase()]);
        });
        Level.levels.sort((a, b) => a.level - b.level);
      }
    }
  
  
    isLessThanOrEqualTo(otherLevel) {
      if (typeof otherLevel === 'string') {
        otherLevel = Level.getLevel(otherLevel);
      }
      return this.level <= otherLevel.level;
    }
  
    isGreaterThanOrEqualTo(otherLevel) {
      if (typeof otherLevel === 'string') {
        otherLevel = Level.getLevel(otherLevel);
      }
      return this.level >= otherLevel.level;
    }
  
    isEqualTo(otherLevel) {
      if (typeof otherLevel === 'string') {
        otherLevel = Level.getLevel(otherLevel);
      }
      return this.level === otherLevel.level;
    }
  }
  
  Level.levels = [];
  Level.addLevels({
    ALL: { value: Number.MIN_VALUE, colour: 'grey' },
    TRACE: { value: 5000, colour: 'blue' },
    DEBUG: { value: 10000, colour: 'cyan' },
    INFO: { value: 20000, colour: 'green' },
    WARN: { value: 30000, colour: 'yellow' },
    ERROR: { value: 40000, colour: 'red' },
    FATAL: { value: 50000, colour: 'magenta' },
    MARK: { value: 9007199254740992, colour: 'grey' }, // 2^53
    OFF: { value: Number.MAX_VALUE, colour: 'grey' }
  });
  
  configuration.addListener((config) => {
    const levelConfig = config.levels;
    if (levelConfig) {
      configuration.throwExceptionIf(
        config,
        configuration.not(configuration.anObject(levelConfig)),
        'levels must be an object'
      );
      const newLevels = Object.keys(levelConfig);
      newLevels.forEach((l) => {
        configuration.throwExceptionIf(
          config,
          configuration.not(configuration.validIdentifier(l)),
          `level name "${l}" is not a valid identifier (must start with a letter, only contain A-Z,a-z,0-9,_)`
        );
        configuration.throwExceptionIf(
          config,
          configuration.not(configuration.anObject(levelConfig[l])),
          `level "${l}" must be an object`
        );
        configuration.throwExceptionIf(
          config,
          configuration.not(levelConfig[l].value),
          `level "${l}" must have a 'value' property`
        );
        configuration.throwExceptionIf(
          config,
          configuration.not(configuration.anInteger(levelConfig[l].value)),
          `level "${l}".value must have an integer value`
        );
        configuration.throwExceptionIf(
          config,
          configuration.not(levelConfig[l].colour),
          `level "${l}" must have a 'colour' property`
        );
        configuration.throwExceptionIf(
          config,
          configuration.not(validColours.indexOf(levelConfig[l].colour) > -1),
          `level "${l}".colour must be one of ${validColours.join(', ')}`
        );
      });
    }
  });
  
  configuration.addListener((config) => {
    Level.addLevels(config.levels);
  });
  
  module.exports = Level;
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/log4js.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /**
   * @fileoverview log4js is a library to log in JavaScript in similar manner
   * than in log4j for Java (but not really).
   *
   * <h3>Example:</h3>
   * <pre>
   *  const logging = require('log4js');
   *  const log = logging.getLogger('some-category');
   *
   *  //call the log
   *  log.trace('trace me' );
   * </pre>
   *
   * NOTE: the authors below are the original browser-based log4js authors
   * don't try to contact them about bugs in this version :)
   * @author Stephan Strittmatter - http://jroller.com/page/stritti
   * @author Seth Chisamore - http://www.chisamore.com
   * @since 2005-05-20
   * Website: http://log4js.berlios.de
   */
  const debug = __webpack_require__("./node_modules/debug/src/index.js")('log4js:main');
  const fs = __webpack_require__("fs");
  const deepClone = __webpack_require__("./node_modules/rfdc/index.js")({ proto: true });
  const configuration = __webpack_require__("./node_modules/log4js/lib/configuration.js");
  const layouts = __webpack_require__("./node_modules/log4js/lib/layouts.js");
  const levels = __webpack_require__("./node_modules/log4js/lib/levels.js");
  const appenders = __webpack_require__("./node_modules/log4js/lib/appenders/index.js");
  const categories = __webpack_require__("./node_modules/log4js/lib/categories.js");
  const Logger = __webpack_require__("./node_modules/log4js/lib/logger.js");
  const clustering = __webpack_require__("./node_modules/log4js/lib/clustering.js");
  const connectLogger = __webpack_require__("./node_modules/log4js/lib/connect-logger.js");
  
  let enabled = false;
  
  function sendLogEventToAppender(logEvent) {
    if (!enabled) return;
    debug('Received log event ', logEvent);
    const categoryAppenders = categories.appendersForCategory(logEvent.categoryName);
    categoryAppenders.forEach((appender) => {
      appender(logEvent);
    });
  }
  
  function loadConfigurationFile(filename) {
    if (filename) {
      debug(`Loading configuration from ${filename}`);
      return JSON.parse(fs.readFileSync(filename, 'utf8'));
    }
    return filename;
  }
  
  function configure(configurationFileOrObject) {
    let configObject = configurationFileOrObject;
  
    if (typeof configObject === 'string') {
      configObject = loadConfigurationFile(configurationFileOrObject);
    }
    debug(`Configuration is ${configObject}`);
  
    configuration.configure(deepClone(configObject));
  
    clustering.onMessage(sendLogEventToAppender);
  
    enabled = true;
  
    return log4js;
  }
  
  /**
   * Shutdown all log appenders. This will first disable all writing to appenders
   * and then call the shutdown function each appender.
   *
   * @params {Function} cb - The callback to be invoked once all appenders have
   *  shutdown. If an error occurs, the callback will be given the error object
   *  as the first argument.
   */
  function shutdown(cb) {
    debug('Shutdown called. Disabling all log writing.');
    // First, disable all writing to appenders. This prevents appenders from
    // not being able to be drained because of run-away log writes.
    enabled = false;
  
    // Call each of the shutdown functions in parallel
    const appendersToCheck = Array.from(appenders.values());
    const shutdownFunctions = appendersToCheck.reduceRight((accum, next) => (next.shutdown ? accum + 1 : accum), 0);
    let completed = 0;
    let error;
  
    debug(`Found ${shutdownFunctions} appenders with shutdown functions.`);
    function complete(err) {
      error = error || err;
      completed += 1;
      debug(`Appender shutdowns complete: ${completed} / ${shutdownFunctions}`);
      if (completed >= shutdownFunctions) {
        debug('All shutdown functions completed.');
        cb(error);
      }
    }
  
    if (shutdownFunctions === 0) {
      debug('No appenders with shutdown functions found.');
      return cb();
    }
  
    appendersToCheck.filter(a => a.shutdown).forEach(a => a.shutdown(complete));
  
    return null;
  }
  
  /**
   * Get a logger instance.
   * @static
   * @param loggerCategoryName
   * @return {Logger} instance of logger for the category
   */
  function getLogger(category) {
    if (!enabled) {
      configure(process.env.LOG4JS_CONFIG || {
        appenders: { out: { type: 'stdout' } },
        categories: { default: { appenders: ['out'], level: 'OFF' } }
      });
    }
    return new Logger(category || 'default');
  }
  
  
  /**
   * @name log4js
   * @namespace Log4js
   * @property getLogger
   * @property configure
   * @property shutdown
   */
  const log4js = {
    getLogger,
    configure,
    shutdown,
    connectLogger,
    levels,
    addLayout: layouts.addLayout
  };
  
  module.exports = log4js;
  
  
  /***/ }),
  
  /***/ "./node_modules/log4js/lib/logger.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* eslint no-underscore-dangle:0 */
  
  
  
  const debug = __webpack_require__("./node_modules/debug/src/index.js")('log4js:logger');
  const LoggingEvent = __webpack_require__("./node_modules/log4js/lib/LoggingEvent.js");
  const levels = __webpack_require__("./node_modules/log4js/lib/levels.js");
  const clustering = __webpack_require__("./node_modules/log4js/lib/clustering.js");
  const categories = __webpack_require__("./node_modules/log4js/lib/categories.js");
  const configuration = __webpack_require__("./node_modules/log4js/lib/configuration.js");
  
  /**
   * Logger to log messages.
   * use {@see log4js#getLogger(String)} to get an instance.
   *
   * @name Logger
   * @namespace Log4js
   * @param name name of category to log to
   * @param level - the loglevel for the category
   * @param dispatch - the function which will receive the logevents
   *
   * @author Stephan Strittmatter
   */
  class Logger {
    constructor(name) {
      if (!name) {
        throw new Error('No category provided.');
      }
      this.category = name;
      this.context = {};
      debug(`Logger created (${this.category}, ${this.level})`);
    }
  
    get level() {
      return levels.getLevel(categories.getLevelForCategory(this.category), levels.TRACE);
    }
  
    set level(level) {
      categories.setLevelForCategory(this.category, levels.getLevel(level, this.level));
    }
  
    log(level, ...args) {
      const logLevel = levels.getLevel(level, levels.INFO);
      if (this.isLevelEnabled(logLevel)) {
        this._log(logLevel, args);
      }
    }
  
    isLevelEnabled(otherLevel) {
      return this.level.isLessThanOrEqualTo(otherLevel);
    }
  
    _log(level, data) {
      debug(`sending log data (${level}) to appenders`);
      const loggingEvent = new LoggingEvent(this.category, level, data, this.context);
      clustering.send(loggingEvent);
    }
  
    addContext(key, value) {
      this.context[key] = value;
    }
  
    removeContext(key) {
      delete this.context[key];
    }
  
    clearContext() {
      this.context = {};
    }
  }
  
  function addLevelMethods(target) {
    const level = levels.getLevel(target);
  
    const levelStrLower = level.toString().toLowerCase();
    const levelMethod = levelStrLower.replace(/_([a-z])/g, g => g[1].toUpperCase());
    const isLevelMethod = levelMethod[0].toUpperCase() + levelMethod.slice(1);
  
    Logger.prototype[`is${isLevelMethod}Enabled`] = function () {
      return this.isLevelEnabled(level);
    };
  
    Logger.prototype[levelMethod] = function (...args) {
      this.log(level, ...args);
    };
  }
  
  levels.levels.forEach(addLevelMethods);
  
  configuration.addListener(() => {
    levels.levels.forEach(addLevelMethods);
  });
  
  module.exports = Logger;
  
  
  /***/ }),
  
  /***/ "./node_modules/mkdirp/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var path = __webpack_require__("path");
  var fs = __webpack_require__("fs");
  var _0777 = parseInt('0777', 8);
  
  module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
  
  function mkdirP (p, opts, f, made) {
      if (typeof opts === 'function') {
          f = opts;
          opts = {};
      }
      else if (!opts || typeof opts !== 'object') {
          opts = { mode: opts };
      }
      
      var mode = opts.mode;
      var xfs = opts.fs || fs;
      
      if (mode === undefined) {
          mode = _0777 & (~process.umask());
      }
      if (!made) made = null;
      
      var cb = f || function () {};
      p = path.resolve(p);
      
      xfs.mkdir(p, mode, function (er) {
          if (!er) {
              made = made || p;
              return cb(null, made);
          }
          switch (er.code) {
              case 'ENOENT':
                  mkdirP(path.dirname(p), opts, function (er, made) {
                      if (er) cb(er, made);
                      else mkdirP(p, opts, cb, made);
                  });
                  break;
  
              // In the case of any other error, just see if there's a dir
              // there already.  If so, then hooray!  If not, then something
              // is borked.
              default:
                  xfs.stat(p, function (er2, stat) {
                      // if the stat fails, then that's super weird.
                      // let the original error be the failure reason.
                      if (er2 || !stat.isDirectory()) cb(er, made)
                      else cb(null, made);
                  });
                  break;
          }
      });
  }
  
  mkdirP.sync = function sync (p, opts, made) {
      if (!opts || typeof opts !== 'object') {
          opts = { mode: opts };
      }
      
      var mode = opts.mode;
      var xfs = opts.fs || fs;
      
      if (mode === undefined) {
          mode = _0777 & (~process.umask());
      }
      if (!made) made = null;
  
      p = path.resolve(p);
  
      try {
          xfs.mkdirSync(p, mode);
          made = made || p;
      }
      catch (err0) {
          switch (err0.code) {
              case 'ENOENT' :
                  made = sync(path.dirname(p), opts, made);
                  sync(p, opts, made);
                  break;
  
              // In the case of any other error, just see if there's a dir
              // there already.  If so, then hooray!  If not, then something
              // is borked.
              default:
                  var stat;
                  try {
                      stat = xfs.statSync(p);
                  }
                  catch (err1) {
                      throw err0;
                  }
                  if (!stat.isDirectory()) throw err0;
                  break;
          }
      }
  
      return made;
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/ms/index.js":
  /***/ (function(module, exports) {
  
  /**
   * Helpers.
   */
  
  var s = 1000;
  var m = s * 60;
  var h = m * 60;
  var d = h * 24;
  var w = d * 7;
  var y = d * 365.25;
  
  /**
   * Parse or format the given `val`.
   *
   * Options:
   *
   *  - `long` verbose formatting [false]
   *
   * @param {String|Number} val
   * @param {Object} [options]
   * @throws {Error} throw an error if val is not a non-empty string or a number
   * @return {String|Number}
   * @api public
   */
  
  module.exports = function(val, options) {
    options = options || {};
    var type = typeof val;
    if (type === 'string' && val.length > 0) {
      return parse(val);
    } else if (type === 'number' && isNaN(val) === false) {
      return options.long ? fmtLong(val) : fmtShort(val);
    }
    throw new Error(
      'val is not a non-empty string or a valid number. val=' +
        JSON.stringify(val)
    );
  };
  
  /**
   * Parse the given `str` and return milliseconds.
   *
   * @param {String} str
   * @return {Number}
   * @api private
   */
  
  function parse(str) {
    str = String(str);
    if (str.length > 100) {
      return;
    }
    var match = /^((?:\d+)?\-?\d?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
      str
    );
    if (!match) {
      return;
    }
    var n = parseFloat(match[1]);
    var type = (match[2] || 'ms').toLowerCase();
    switch (type) {
      case 'years':
      case 'year':
      case 'yrs':
      case 'yr':
      case 'y':
        return n * y;
      case 'weeks':
      case 'week':
      case 'w':
        return n * w;
      case 'days':
      case 'day':
      case 'd':
        return n * d;
      case 'hours':
      case 'hour':
      case 'hrs':
      case 'hr':
      case 'h':
        return n * h;
      case 'minutes':
      case 'minute':
      case 'mins':
      case 'min':
      case 'm':
        return n * m;
      case 'seconds':
      case 'second':
      case 'secs':
      case 'sec':
      case 's':
        return n * s;
      case 'milliseconds':
      case 'millisecond':
      case 'msecs':
      case 'msec':
      case 'ms':
        return n;
      default:
        return undefined;
    }
  }
  
  /**
   * Short format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtShort(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return Math.round(ms / d) + 'd';
    }
    if (msAbs >= h) {
      return Math.round(ms / h) + 'h';
    }
    if (msAbs >= m) {
      return Math.round(ms / m) + 'm';
    }
    if (msAbs >= s) {
      return Math.round(ms / s) + 's';
    }
    return ms + 'ms';
  }
  
  /**
   * Long format for `ms`.
   *
   * @param {Number} ms
   * @return {String}
   * @api private
   */
  
  function fmtLong(ms) {
    var msAbs = Math.abs(ms);
    if (msAbs >= d) {
      return plural(ms, msAbs, d, 'day');
    }
    if (msAbs >= h) {
      return plural(ms, msAbs, h, 'hour');
    }
    if (msAbs >= m) {
      return plural(ms, msAbs, m, 'minute');
    }
    if (msAbs >= s) {
      return plural(ms, msAbs, s, 'second');
    }
    return ms + ' ms';
  }
  
  /**
   * Pluralization helper.
   */
  
  function plural(ms, msAbs, n, name) {
    var isPlural = msAbs >= n * 1.5;
    return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
  }
  
  
  /***/ }),
  
  /***/ "./node_modules/process-nextick-args/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  if (!process.version ||
      process.version.indexOf('v0.') === 0 ||
      process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
    module.exports = { nextTick: nextTick };
  } else {
    module.exports = process
  }
  
  function nextTick(fn, arg1, arg2, arg3) {
    if (typeof fn !== 'function') {
      throw new TypeError('"callback" argument must be a function');
    }
    var len = arguments.length;
    var args, i;
    switch (len) {
    case 0:
    case 1:
      return process.nextTick(fn);
    case 2:
      return process.nextTick(function afterTickOne() {
        fn.call(null, arg1);
      });
    case 3:
      return process.nextTick(function afterTickTwo() {
        fn.call(null, arg1, arg2);
      });
    case 4:
      return process.nextTick(function afterTickThree() {
        fn.call(null, arg1, arg2, arg3);
      });
    default:
      args = new Array(len - 1);
      i = 0;
      while (i < args.length) {
        args[i++] = arguments[i];
      }
      return process.nextTick(function afterTick() {
        fn.apply(null, args);
      });
    }
  }
  
  
  
  /***/ }),
  
  /***/ "./node_modules/query-string/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  const strictUriEncode = __webpack_require__("./node_modules/strict-uri-encode/index.js");
  const decodeComponent = __webpack_require__("./node_modules/decode-uri-component/index.js");
  
  function encoderForArrayFormat(options) {
  	switch (options.arrayFormat) {
  		case 'index':
  			return (key, value, index) => {
  				return value === null ? [
  					encode(key, options),
  					'[',
  					index,
  					']'
  				].join('') : [
  					encode(key, options),
  					'[',
  					encode(index, options),
  					']=',
  					encode(value, options)
  				].join('');
  			};
  
  		case 'bracket':
  			return (key, value) => {
  				return value === null ? [encode(key, options), '[]'].join('') : [
  					encode(key, options),
  					'[]=',
  					encode(value, options)
  				].join('');
  			};
  
  		default:
  			return (key, value) => {
  				return value === null ? encode(key, options) : [
  					encode(key, options),
  					'=',
  					encode(value, options)
  				].join('');
  			};
  	}
  }
  
  function parserForArrayFormat(options) {
  	let result;
  
  	switch (options.arrayFormat) {
  		case 'index':
  			return (key, value, accumulator) => {
  				result = /\[(\d*)\]$/.exec(key);
  
  				key = key.replace(/\[\d*\]$/, '');
  
  				if (!result) {
  					accumulator[key] = value;
  					return;
  				}
  
  				if (accumulator[key] === undefined) {
  					accumulator[key] = {};
  				}
  
  				accumulator[key][result[1]] = value;
  			};
  
  		case 'bracket':
  			return (key, value, accumulator) => {
  				result = /(\[\])$/.exec(key);
  				key = key.replace(/\[\]$/, '');
  
  				if (!result) {
  					accumulator[key] = value;
  					return;
  				}
  
  				if (accumulator[key] === undefined) {
  					accumulator[key] = [value];
  					return;
  				}
  
  				accumulator[key] = [].concat(accumulator[key], value);
  			};
  
  		default:
  			return (key, value, accumulator) => {
  				if (accumulator[key] === undefined) {
  					accumulator[key] = value;
  					return;
  				}
  
  				accumulator[key] = [].concat(accumulator[key], value);
  			};
  	}
  }
  
  function encode(value, options) {
  	if (options.encode) {
  		return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
  	}
  
  	return value;
  }
  
  function decode(value, options) {
  	if (options.decode) {
  		return decodeComponent(value);
  	}
  
  	return value;
  }
  
  function keysSorter(input) {
  	if (Array.isArray(input)) {
  		return input.sort();
  	}
  
  	if (typeof input === 'object') {
  		return keysSorter(Object.keys(input))
  			.sort((a, b) => Number(a) - Number(b))
  			.map(key => input[key]);
  	}
  
  	return input;
  }
  
  function extract(input) {
  	const queryStart = input.indexOf('?');
  	if (queryStart === -1) {
  		return '';
  	}
  
  	return input.slice(queryStart + 1);
  }
  
  function parse(input, options) {
  	options = Object.assign({decode: true, arrayFormat: 'none'}, options);
  
  	const formatter = parserForArrayFormat(options);
  
  	// Create an object with no prototype
  	const ret = Object.create(null);
  
  	if (typeof input !== 'string') {
  		return ret;
  	}
  
  	input = input.trim().replace(/^[?#&]/, '');
  
  	if (!input) {
  		return ret;
  	}
  
  	for (const param of input.split('&')) {
  		let [key, value] = param.replace(/\+/g, ' ').split('=');
  
  		// Missing `=` should be `null`:
  		// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
  		value = value === undefined ? null : decode(value, options);
  
  		formatter(decode(key, options), value, ret);
  	}
  
  	return Object.keys(ret).sort().reduce((result, key) => {
  		const value = ret[key];
  		if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {
  			// Sort object keys, not values
  			result[key] = keysSorter(value);
  		} else {
  			result[key] = value;
  		}
  
  		return result;
  	}, Object.create(null));
  }
  
  exports.extract = extract;
  exports.parse = parse;
  
  exports.stringify = (obj, options) => {
  	if (!obj) {
  		return '';
  	}
  
  	options = Object.assign({
  		encode: true,
  		strict: true,
  		arrayFormat: 'none'
  	}, options);
  
  	const formatter = encoderForArrayFormat(options);
  	const keys = Object.keys(obj);
  
  	if (options.sort !== false) {
  		keys.sort(options.sort);
  	}
  
  	return keys.map(key => {
  		const value = obj[key];
  
  		if (value === undefined) {
  			return '';
  		}
  
  		if (value === null) {
  			return encode(key, options);
  		}
  
  		if (Array.isArray(value)) {
  			const result = [];
  
  			for (const value2 of value.slice()) {
  				if (value2 === undefined) {
  					continue;
  				}
  
  				result.push(formatter(key, value2, result.length));
  			}
  
  			return result.join('&');
  		}
  
  		return encode(key, options) + '=' + encode(value, options);
  	}).filter(x => x.length > 0).join('&');
  };
  
  exports.parseUrl = (input, options) => {
  	const hashStart = input.indexOf('#');
  	if (hashStart !== -1) {
  		input = input.slice(0, hashStart);
  	}
  
  	return {
  		url: input.split('?')[0] || '',
  		query: parse(extract(input), options)
  	};
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/readable-stream/lib/_stream_duplex.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  // a duplex stream is just a stream that is both readable and writable.
  // Since JS doesn't have multiple prototypal inheritance, this class
  // prototypally inherits from Readable, and then parasitically from
  // Writable.
  
  
  
  /*<replacement>*/
  
  var pna = __webpack_require__("./node_modules/process-nextick-args/index.js");
  /*</replacement>*/
  
  /*<replacement>*/
  var objectKeys = Object.keys || function (obj) {
    var keys = [];
    for (var key in obj) {
      keys.push(key);
    }return keys;
  };
  /*</replacement>*/
  
  module.exports = Duplex;
  
  /*<replacement>*/
  var util = __webpack_require__("./node_modules/core-util-is/lib/util.js");
  util.inherits = __webpack_require__("./node_modules/inherits/inherits.js");
  /*</replacement>*/
  
  var Readable = __webpack_require__("./node_modules/readable-stream/lib/_stream_readable.js");
  var Writable = __webpack_require__("./node_modules/readable-stream/lib/_stream_writable.js");
  
  util.inherits(Duplex, Readable);
  
  {
    // avoid scope creep, the keys array can then be collected
    var keys = objectKeys(Writable.prototype);
    for (var v = 0; v < keys.length; v++) {
      var method = keys[v];
      if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
    }
  }
  
  function Duplex(options) {
    if (!(this instanceof Duplex)) return new Duplex(options);
  
    Readable.call(this, options);
    Writable.call(this, options);
  
    if (options && options.readable === false) this.readable = false;
  
    if (options && options.writable === false) this.writable = false;
  
    this.allowHalfOpen = true;
    if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
  
    this.once('end', onend);
  }
  
  Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function () {
      return this._writableState.highWaterMark;
    }
  });
  
  // the no-half-open enforcer
  function onend() {
    // if we allow half-open state, or if the writable side ended,
    // then we're ok.
    if (this.allowHalfOpen || this._writableState.ended) return;
  
    // no more data can be written.
    // But allow more writes to happen in this tick.
    pna.nextTick(onEndNT, this);
  }
  
  function onEndNT(self) {
    self.end();
  }
  
  Object.defineProperty(Duplex.prototype, 'destroyed', {
    get: function () {
      if (this._readableState === undefined || this._writableState === undefined) {
        return false;
      }
      return this._readableState.destroyed && this._writableState.destroyed;
    },
    set: function (value) {
      // we ignore the value if the stream
      // has not been initialized yet
      if (this._readableState === undefined || this._writableState === undefined) {
        return;
      }
  
      // backward compatibility, the user is explicitly
      // managing destroyed
      this._readableState.destroyed = value;
      this._writableState.destroyed = value;
    }
  });
  
  Duplex.prototype._destroy = function (err, cb) {
    this.push(null);
    this.end();
  
    pna.nextTick(cb, err);
  };
  
  /***/ }),
  
  /***/ "./node_modules/readable-stream/lib/_stream_passthrough.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  // a passthrough stream.
  // basically just the most minimal sort of Transform stream.
  // Every written chunk gets output as-is.
  
  
  
  module.exports = PassThrough;
  
  var Transform = __webpack_require__("./node_modules/readable-stream/lib/_stream_transform.js");
  
  /*<replacement>*/
  var util = __webpack_require__("./node_modules/core-util-is/lib/util.js");
  util.inherits = __webpack_require__("./node_modules/inherits/inherits.js");
  /*</replacement>*/
  
  util.inherits(PassThrough, Transform);
  
  function PassThrough(options) {
    if (!(this instanceof PassThrough)) return new PassThrough(options);
  
    Transform.call(this, options);
  }
  
  PassThrough.prototype._transform = function (chunk, encoding, cb) {
    cb(null, chunk);
  };
  
  /***/ }),
  
  /***/ "./node_modules/readable-stream/lib/_stream_readable.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  
  
  /*<replacement>*/
  
  var pna = __webpack_require__("./node_modules/process-nextick-args/index.js");
  /*</replacement>*/
  
  module.exports = Readable;
  
  /*<replacement>*/
  var isArray = __webpack_require__("./node_modules/isarray/index.js");
  /*</replacement>*/
  
  /*<replacement>*/
  var Duplex;
  /*</replacement>*/
  
  Readable.ReadableState = ReadableState;
  
  /*<replacement>*/
  var EE = __webpack_require__("events").EventEmitter;
  
  var EElistenerCount = function (emitter, type) {
    return emitter.listeners(type).length;
  };
  /*</replacement>*/
  
  /*<replacement>*/
  var Stream = __webpack_require__("./node_modules/readable-stream/lib/internal/streams/stream.js");
  /*</replacement>*/
  
  /*<replacement>*/
  
  var Buffer = __webpack_require__("./node_modules/safe-buffer/index.js").Buffer;
  var OurUint8Array = global.Uint8Array || function () {};
  function _uint8ArrayToBuffer(chunk) {
    return Buffer.from(chunk);
  }
  function _isUint8Array(obj) {
    return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
  }
  
  /*</replacement>*/
  
  /*<replacement>*/
  var util = __webpack_require__("./node_modules/core-util-is/lib/util.js");
  util.inherits = __webpack_require__("./node_modules/inherits/inherits.js");
  /*</replacement>*/
  
  /*<replacement>*/
  var debugUtil = __webpack_require__("util");
  var debug = void 0;
  if (debugUtil && debugUtil.debuglog) {
    debug = debugUtil.debuglog('stream');
  } else {
    debug = function () {};
  }
  /*</replacement>*/
  
  var BufferList = __webpack_require__("./node_modules/readable-stream/lib/internal/streams/BufferList.js");
  var destroyImpl = __webpack_require__("./node_modules/readable-stream/lib/internal/streams/destroy.js");
  var StringDecoder;
  
  util.inherits(Readable, Stream);
  
  var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
  
  function prependListener(emitter, event, fn) {
    // Sadly this is not cacheable as some libraries bundle their own
    // event emitter implementation with them.
    if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
  
    // This is a hack to make sure that our error handler is attached before any
    // userland ones.  NEVER DO THIS. This is here only because this code needs
    // to continue to work with older versions of Node.js that do not include
    // the prependListener() method. The goal is to eventually remove this hack.
    if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
  }
  
  function ReadableState(options, stream) {
    Duplex = Duplex || __webpack_require__("./node_modules/readable-stream/lib/_stream_duplex.js");
  
    options = options || {};
  
    // Duplex streams are both readable and writable, but share
    // the same options object.
    // However, some cases require setting options to different
    // values for the readable and the writable sides of the duplex stream.
    // These options can be provided separately as readableXXX and writableXXX.
    var isDuplex = stream instanceof Duplex;
  
    // object stream flag. Used to make read(n) ignore n and to
    // make all the buffer merging and length checks go away
    this.objectMode = !!options.objectMode;
  
    if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
  
    // the point at which it stops calling _read() to fill the buffer
    // Note: 0 is a valid value, means "don't call _read preemptively ever"
    var hwm = options.highWaterMark;
    var readableHwm = options.readableHighWaterMark;
    var defaultHwm = this.objectMode ? 16 : 16 * 1024;
  
    if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;
  
    // cast to ints.
    this.highWaterMark = Math.floor(this.highWaterMark);
  
    // A linked list is used to store data chunks instead of an array because the
    // linked list can remove elements from the beginning faster than
    // array.shift()
    this.buffer = new BufferList();
    this.length = 0;
    this.pipes = null;
    this.pipesCount = 0;
    this.flowing = null;
    this.ended = false;
    this.endEmitted = false;
    this.reading = false;
  
    // a flag to be able to tell if the event 'readable'/'data' is emitted
    // immediately, or on a later tick.  We set this to true at first, because
    // any actions that shouldn't happen until "later" should generally also
    // not happen before the first read call.
    this.sync = true;
  
    // whenever we return null, then we set a flag to say
    // that we're awaiting a 'readable' event emission.
    this.needReadable = false;
    this.emittedReadable = false;
    this.readableListening = false;
    this.resumeScheduled = false;
  
    // has it been destroyed
    this.destroyed = false;
  
    // Crypto is kind of old and crusty.  Historically, its default string
    // encoding is 'binary' so we have to make this configurable.
    // Everything else in the universe uses 'utf8', though.
    this.defaultEncoding = options.defaultEncoding || 'utf8';
  
    // the number of writers that are awaiting a drain event in .pipe()s
    this.awaitDrain = 0;
  
    // if true, a maybeReadMore has been scheduled
    this.readingMore = false;
  
    this.decoder = null;
    this.encoding = null;
    if (options.encoding) {
      if (!StringDecoder) StringDecoder = __webpack_require__("./node_modules/readable-stream/node_modules/string_decoder/lib/string_decoder.js").StringDecoder;
      this.decoder = new StringDecoder(options.encoding);
      this.encoding = options.encoding;
    }
  }
  
  function Readable(options) {
    Duplex = Duplex || __webpack_require__("./node_modules/readable-stream/lib/_stream_duplex.js");
  
    if (!(this instanceof Readable)) return new Readable(options);
  
    this._readableState = new ReadableState(options, this);
  
    // legacy
    this.readable = true;
  
    if (options) {
      if (typeof options.read === 'function') this._read = options.read;
  
      if (typeof options.destroy === 'function') this._destroy = options.destroy;
    }
  
    Stream.call(this);
  }
  
  Object.defineProperty(Readable.prototype, 'destroyed', {
    get: function () {
      if (this._readableState === undefined) {
        return false;
      }
      return this._readableState.destroyed;
    },
    set: function (value) {
      // we ignore the value if the stream
      // has not been initialized yet
      if (!this._readableState) {
        return;
      }
  
      // backward compatibility, the user is explicitly
      // managing destroyed
      this._readableState.destroyed = value;
    }
  });
  
  Readable.prototype.destroy = destroyImpl.destroy;
  Readable.prototype._undestroy = destroyImpl.undestroy;
  Readable.prototype._destroy = function (err, cb) {
    this.push(null);
    cb(err);
  };
  
  // Manually shove something into the read() buffer.
  // This returns true if the highWaterMark has not been hit yet,
  // similar to how Writable.write() returns true if you should
  // write() some more.
  Readable.prototype.push = function (chunk, encoding) {
    var state = this._readableState;
    var skipChunkCheck;
  
    if (!state.objectMode) {
      if (typeof chunk === 'string') {
        encoding = encoding || state.defaultEncoding;
        if (encoding !== state.encoding) {
          chunk = Buffer.from(chunk, encoding);
          encoding = '';
        }
        skipChunkCheck = true;
      }
    } else {
      skipChunkCheck = true;
    }
  
    return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
  };
  
  // Unshift should *always* be something directly out of read()
  Readable.prototype.unshift = function (chunk) {
    return readableAddChunk(this, chunk, null, true, false);
  };
  
  function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
    var state = stream._readableState;
    if (chunk === null) {
      state.reading = false;
      onEofChunk(stream, state);
    } else {
      var er;
      if (!skipChunkCheck) er = chunkInvalid(state, chunk);
      if (er) {
        stream.emit('error', er);
      } else if (state.objectMode || chunk && chunk.length > 0) {
        if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
          chunk = _uint8ArrayToBuffer(chunk);
        }
  
        if (addToFront) {
          if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
        } else if (state.ended) {
          stream.emit('error', new Error('stream.push() after EOF'));
        } else {
          state.reading = false;
          if (state.decoder && !encoding) {
            chunk = state.decoder.write(chunk);
            if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
          } else {
            addChunk(stream, state, chunk, false);
          }
        }
      } else if (!addToFront) {
        state.reading = false;
      }
    }
  
    return needMoreData(state);
  }
  
  function addChunk(stream, state, chunk, addToFront) {
    if (state.flowing && state.length === 0 && !state.sync) {
      stream.emit('data', chunk);
      stream.read(0);
    } else {
      // update the buffer info.
      state.length += state.objectMode ? 1 : chunk.length;
      if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
  
      if (state.needReadable) emitReadable(stream);
    }
    maybeReadMore(stream, state);
  }
  
  function chunkInvalid(state, chunk) {
    var er;
    if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
      er = new TypeError('Invalid non-string/buffer chunk');
    }
    return er;
  }
  
  // if it's past the high water mark, we can push in some more.
  // Also, if we have no data yet, we can stand some
  // more bytes.  This is to work around cases where hwm=0,
  // such as the repl.  Also, if the push() triggered a
  // readable event, and the user called read(largeNumber) such that
  // needReadable was set, then we ought to push more, so that another
  // 'readable' event will be triggered.
  function needMoreData(state) {
    return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
  }
  
  Readable.prototype.isPaused = function () {
    return this._readableState.flowing === false;
  };
  
  // backwards compatibility.
  Readable.prototype.setEncoding = function (enc) {
    if (!StringDecoder) StringDecoder = __webpack_require__("./node_modules/readable-stream/node_modules/string_decoder/lib/string_decoder.js").StringDecoder;
    this._readableState.decoder = new StringDecoder(enc);
    this._readableState.encoding = enc;
    return this;
  };
  
  // Don't raise the hwm > 8MB
  var MAX_HWM = 0x800000;
  function computeNewHighWaterMark(n) {
    if (n >= MAX_HWM) {
      n = MAX_HWM;
    } else {
      // Get the next highest power of 2 to prevent increasing hwm excessively in
      // tiny amounts
      n--;
      n |= n >>> 1;
      n |= n >>> 2;
      n |= n >>> 4;
      n |= n >>> 8;
      n |= n >>> 16;
      n++;
    }
    return n;
  }
  
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  function howMuchToRead(n, state) {
    if (n <= 0 || state.length === 0 && state.ended) return 0;
    if (state.objectMode) return 1;
    if (n !== n) {
      // Only flow one buffer at a time
      if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
    }
    // If we're asking for more than the current hwm, then raise the hwm.
    if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
    if (n <= state.length) return n;
    // Don't have enough
    if (!state.ended) {
      state.needReadable = true;
      return 0;
    }
    return state.length;
  }
  
  // you can override either this method, or the async _read(n) below.
  Readable.prototype.read = function (n) {
    debug('read', n);
    n = parseInt(n, 10);
    var state = this._readableState;
    var nOrig = n;
  
    if (n !== 0) state.emittedReadable = false;
  
    // if we're doing read(0) to trigger a readable event, but we
    // already have a bunch of data in the buffer, then just trigger
    // the 'readable' event and move on.
    if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
      debug('read: emitReadable', state.length, state.ended);
      if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
      return null;
    }
  
    n = howMuchToRead(n, state);
  
    // if we've ended, and we're now clear, then finish it up.
    if (n === 0 && state.ended) {
      if (state.length === 0) endReadable(this);
      return null;
    }
  
    // All the actual chunk generation logic needs to be
    // *below* the call to _read.  The reason is that in certain
    // synthetic stream cases, such as passthrough streams, _read
    // may be a completely synchronous operation which may change
    // the state of the read buffer, providing enough data when
    // before there was *not* enough.
    //
    // So, the steps are:
    // 1. Figure out what the state of things will be after we do
    // a read from the buffer.
    //
    // 2. If that resulting state will trigger a _read, then call _read.
    // Note that this may be asynchronous, or synchronous.  Yes, it is
    // deeply ugly to write APIs this way, but that still doesn't mean
    // that the Readable class should behave improperly, as streams are
    // designed to be sync/async agnostic.
    // Take note if the _read call is sync or async (ie, if the read call
    // has returned yet), so that we know whether or not it's safe to emit
    // 'readable' etc.
    //
    // 3. Actually pull the requested chunks out of the buffer and return.
  
    // if we need a readable event, then we need to do some reading.
    var doRead = state.needReadable;
    debug('need readable', doRead);
  
    // if we currently have less than the highWaterMark, then also read some
    if (state.length === 0 || state.length - n < state.highWaterMark) {
      doRead = true;
      debug('length less than watermark', doRead);
    }
  
    // however, if we've ended, then there's no point, and if we're already
    // reading, then it's unnecessary.
    if (state.ended || state.reading) {
      doRead = false;
      debug('reading or ended', doRead);
    } else if (doRead) {
      debug('do read');
      state.reading = true;
      state.sync = true;
      // if the length is currently zero, then we *need* a readable event.
      if (state.length === 0) state.needReadable = true;
      // call internal read method
      this._read(state.highWaterMark);
      state.sync = false;
      // If _read pushed data synchronously, then `reading` will be false,
      // and we need to re-evaluate how much data we can return to the user.
      if (!state.reading) n = howMuchToRead(nOrig, state);
    }
  
    var ret;
    if (n > 0) ret = fromList(n, state);else ret = null;
  
    if (ret === null) {
      state.needReadable = true;
      n = 0;
    } else {
      state.length -= n;
    }
  
    if (state.length === 0) {
      // If we have nothing in the buffer, then we want to know
      // as soon as we *do* get something into the buffer.
      if (!state.ended) state.needReadable = true;
  
      // If we tried to read() past the EOF, then emit end on the next tick.
      if (nOrig !== n && state.ended) endReadable(this);
    }
  
    if (ret !== null) this.emit('data', ret);
  
    return ret;
  };
  
  function onEofChunk(stream, state) {
    if (state.ended) return;
    if (state.decoder) {
      var chunk = state.decoder.end();
      if (chunk && chunk.length) {
        state.buffer.push(chunk);
        state.length += state.objectMode ? 1 : chunk.length;
      }
    }
    state.ended = true;
  
    // emit 'readable' now to make sure it gets picked up.
    emitReadable(stream);
  }
  
  // Don't emit readable right away in sync mode, because this can trigger
  // another read() call => stack overflow.  This way, it might trigger
  // a nextTick recursion warning, but that's not so bad.
  function emitReadable(stream) {
    var state = stream._readableState;
    state.needReadable = false;
    if (!state.emittedReadable) {
      debug('emitReadable', state.flowing);
      state.emittedReadable = true;
      if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
    }
  }
  
  function emitReadable_(stream) {
    debug('emit readable');
    stream.emit('readable');
    flow(stream);
  }
  
  // at this point, the user has presumably seen the 'readable' event,
  // and called read() to consume some data.  that may have triggered
  // in turn another _read(n) call, in which case reading = true if
  // it's in progress.
  // However, if we're not ended, or reading, and the length < hwm,
  // then go ahead and try to read some more preemptively.
  function maybeReadMore(stream, state) {
    if (!state.readingMore) {
      state.readingMore = true;
      pna.nextTick(maybeReadMore_, stream, state);
    }
  }
  
  function maybeReadMore_(stream, state) {
    var len = state.length;
    while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
      debug('maybeReadMore read 0');
      stream.read(0);
      if (len === state.length)
        // didn't get any data, stop spinning.
        break;else len = state.length;
    }
    state.readingMore = false;
  }
  
  // abstract method.  to be overridden in specific implementation classes.
  // call cb(er, data) where data is <= n in length.
  // for virtual (non-string, non-buffer) streams, "length" is somewhat
  // arbitrary, and perhaps not very meaningful.
  Readable.prototype._read = function (n) {
    this.emit('error', new Error('_read() is not implemented'));
  };
  
  Readable.prototype.pipe = function (dest, pipeOpts) {
    var src = this;
    var state = this._readableState;
  
    switch (state.pipesCount) {
      case 0:
        state.pipes = dest;
        break;
      case 1:
        state.pipes = [state.pipes, dest];
        break;
      default:
        state.pipes.push(dest);
        break;
    }
    state.pipesCount += 1;
    debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
  
    var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
  
    var endFn = doEnd ? onend : unpipe;
    if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
  
    dest.on('unpipe', onunpipe);
    function onunpipe(readable, unpipeInfo) {
      debug('onunpipe');
      if (readable === src) {
        if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
          unpipeInfo.hasUnpiped = true;
          cleanup();
        }
      }
    }
  
    function onend() {
      debug('onend');
      dest.end();
    }
  
    // when the dest drains, it reduces the awaitDrain counter
    // on the source.  This would be more elegant with a .once()
    // handler in flow(), but adding and removing repeatedly is
    // too slow.
    var ondrain = pipeOnDrain(src);
    dest.on('drain', ondrain);
  
    var cleanedUp = false;
    function cleanup() {
      debug('cleanup');
      // cleanup event handlers once the pipe is broken
      dest.removeListener('close', onclose);
      dest.removeListener('finish', onfinish);
      dest.removeListener('drain', ondrain);
      dest.removeListener('error', onerror);
      dest.removeListener('unpipe', onunpipe);
      src.removeListener('end', onend);
      src.removeListener('end', unpipe);
      src.removeListener('data', ondata);
  
      cleanedUp = true;
  
      // if the reader is waiting for a drain event from this
      // specific writer, then it would cause it to never start
      // flowing again.
      // So, if this is awaiting a drain, then we just call it now.
      // If we don't know, then assume that we are waiting for one.
      if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
    }
  
    // If the user pushes more data while we're writing to dest then we'll end up
    // in ondata again. However, we only want to increase awaitDrain once because
    // dest will only emit one 'drain' event for the multiple writes.
    // => Introduce a guard on increasing awaitDrain.
    var increasedAwaitDrain = false;
    src.on('data', ondata);
    function ondata(chunk) {
      debug('ondata');
      increasedAwaitDrain = false;
      var ret = dest.write(chunk);
      if (false === ret && !increasedAwaitDrain) {
        // If the user unpiped during `dest.write()`, it is possible
        // to get stuck in a permanently paused state if that write
        // also returned false.
        // => Check whether `dest` is still a piping destination.
        if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
          debug('false write response, pause', src._readableState.awaitDrain);
          src._readableState.awaitDrain++;
          increasedAwaitDrain = true;
        }
        src.pause();
      }
    }
  
    // if the dest has an error, then stop piping into it.
    // however, don't suppress the throwing behavior for this.
    function onerror(er) {
      debug('onerror', er);
      unpipe();
      dest.removeListener('error', onerror);
      if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
    }
  
    // Make sure our error handler is attached before userland ones.
    prependListener(dest, 'error', onerror);
  
    // Both close and finish should trigger unpipe, but only once.
    function onclose() {
      dest.removeListener('finish', onfinish);
      unpipe();
    }
    dest.once('close', onclose);
    function onfinish() {
      debug('onfinish');
      dest.removeListener('close', onclose);
      unpipe();
    }
    dest.once('finish', onfinish);
  
    function unpipe() {
      debug('unpipe');
      src.unpipe(dest);
    }
  
    // tell the dest that it's being piped to
    dest.emit('pipe', src);
  
    // start the flow if it hasn't been started already.
    if (!state.flowing) {
      debug('pipe resume');
      src.resume();
    }
  
    return dest;
  };
  
  function pipeOnDrain(src) {
    return function () {
      var state = src._readableState;
      debug('pipeOnDrain', state.awaitDrain);
      if (state.awaitDrain) state.awaitDrain--;
      if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
        state.flowing = true;
        flow(src);
      }
    };
  }
  
  Readable.prototype.unpipe = function (dest) {
    var state = this._readableState;
    var unpipeInfo = { hasUnpiped: false };
  
    // if we're not piping anywhere, then do nothing.
    if (state.pipesCount === 0) return this;
  
    // just one destination.  most common case.
    if (state.pipesCount === 1) {
      // passed in one, but it's not the right one.
      if (dest && dest !== state.pipes) return this;
  
      if (!dest) dest = state.pipes;
  
      // got a match.
      state.pipes = null;
      state.pipesCount = 0;
      state.flowing = false;
      if (dest) dest.emit('unpipe', this, unpipeInfo);
      return this;
    }
  
    // slow case. multiple pipe destinations.
  
    if (!dest) {
      // remove all.
      var dests = state.pipes;
      var len = state.pipesCount;
      state.pipes = null;
      state.pipesCount = 0;
      state.flowing = false;
  
      for (var i = 0; i < len; i++) {
        dests[i].emit('unpipe', this, unpipeInfo);
      }return this;
    }
  
    // try to find the right one.
    var index = indexOf(state.pipes, dest);
    if (index === -1) return this;
  
    state.pipes.splice(index, 1);
    state.pipesCount -= 1;
    if (state.pipesCount === 1) state.pipes = state.pipes[0];
  
    dest.emit('unpipe', this, unpipeInfo);
  
    return this;
  };
  
  // set up data events if they are asked for
  // Ensure readable listeners eventually get something
  Readable.prototype.on = function (ev, fn) {
    var res = Stream.prototype.on.call(this, ev, fn);
  
    if (ev === 'data') {
      // Start flowing on next tick if stream isn't explicitly paused
      if (this._readableState.flowing !== false) this.resume();
    } else if (ev === 'readable') {
      var state = this._readableState;
      if (!state.endEmitted && !state.readableListening) {
        state.readableListening = state.needReadable = true;
        state.emittedReadable = false;
        if (!state.reading) {
          pna.nextTick(nReadingNextTick, this);
        } else if (state.length) {
          emitReadable(this);
        }
      }
    }
  
    return res;
  };
  Readable.prototype.addListener = Readable.prototype.on;
  
  function nReadingNextTick(self) {
    debug('readable nexttick read 0');
    self.read(0);
  }
  
  // pause() and resume() are remnants of the legacy readable stream API
  // If the user uses them, then switch into old mode.
  Readable.prototype.resume = function () {
    var state = this._readableState;
    if (!state.flowing) {
      debug('resume');
      state.flowing = true;
      resume(this, state);
    }
    return this;
  };
  
  function resume(stream, state) {
    if (!state.resumeScheduled) {
      state.resumeScheduled = true;
      pna.nextTick(resume_, stream, state);
    }
  }
  
  function resume_(stream, state) {
    if (!state.reading) {
      debug('resume read 0');
      stream.read(0);
    }
  
    state.resumeScheduled = false;
    state.awaitDrain = 0;
    stream.emit('resume');
    flow(stream);
    if (state.flowing && !state.reading) stream.read(0);
  }
  
  Readable.prototype.pause = function () {
    debug('call pause flowing=%j', this._readableState.flowing);
    if (false !== this._readableState.flowing) {
      debug('pause');
      this._readableState.flowing = false;
      this.emit('pause');
    }
    return this;
  };
  
  function flow(stream) {
    var state = stream._readableState;
    debug('flow', state.flowing);
    while (state.flowing && stream.read() !== null) {}
  }
  
  // wrap an old-style stream as the async data source.
  // This is *not* part of the readable stream interface.
  // It is an ugly unfortunate mess of history.
  Readable.prototype.wrap = function (stream) {
    var _this = this;
  
    var state = this._readableState;
    var paused = false;
  
    stream.on('end', function () {
      debug('wrapped end');
      if (state.decoder && !state.ended) {
        var chunk = state.decoder.end();
        if (chunk && chunk.length) _this.push(chunk);
      }
  
      _this.push(null);
    });
  
    stream.on('data', function (chunk) {
      debug('wrapped data');
      if (state.decoder) chunk = state.decoder.write(chunk);
  
      // don't skip over falsy values in objectMode
      if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
  
      var ret = _this.push(chunk);
      if (!ret) {
        paused = true;
        stream.pause();
      }
    });
  
    // proxy all the other methods.
    // important when wrapping filters and duplexes.
    for (var i in stream) {
      if (this[i] === undefined && typeof stream[i] === 'function') {
        this[i] = function (method) {
          return function () {
            return stream[method].apply(stream, arguments);
          };
        }(i);
      }
    }
  
    // proxy certain important events.
    for (var n = 0; n < kProxyEvents.length; n++) {
      stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
    }
  
    // when we try to consume some more bytes, simply unpause the
    // underlying stream.
    this._read = function (n) {
      debug('wrapped _read', n);
      if (paused) {
        paused = false;
        stream.resume();
      }
    };
  
    return this;
  };
  
  Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function () {
      return this._readableState.highWaterMark;
    }
  });
  
  // exposed for testing purposes only.
  Readable._fromList = fromList;
  
  // Pluck off n bytes from an array of buffers.
  // Length is the combined lengths of all the buffers in the list.
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  function fromList(n, state) {
    // nothing buffered
    if (state.length === 0) return null;
  
    var ret;
    if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
      // read it all, truncate the list
      if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
      state.buffer.clear();
    } else {
      // read part of list
      ret = fromListPartial(n, state.buffer, state.decoder);
    }
  
    return ret;
  }
  
  // Extracts only enough buffered data to satisfy the amount requested.
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  function fromListPartial(n, list, hasStrings) {
    var ret;
    if (n < list.head.data.length) {
      // slice is the same for buffers and strings
      ret = list.head.data.slice(0, n);
      list.head.data = list.head.data.slice(n);
    } else if (n === list.head.data.length) {
      // first chunk is a perfect match
      ret = list.shift();
    } else {
      // result spans more than one buffer
      ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
    }
    return ret;
  }
  
  // Copies a specified amount of characters from the list of buffered data
  // chunks.
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  function copyFromBufferString(n, list) {
    var p = list.head;
    var c = 1;
    var ret = p.data;
    n -= ret.length;
    while (p = p.next) {
      var str = p.data;
      var nb = n > str.length ? str.length : n;
      if (nb === str.length) ret += str;else ret += str.slice(0, n);
      n -= nb;
      if (n === 0) {
        if (nb === str.length) {
          ++c;
          if (p.next) list.head = p.next;else list.head = list.tail = null;
        } else {
          list.head = p;
          p.data = str.slice(nb);
        }
        break;
      }
      ++c;
    }
    list.length -= c;
    return ret;
  }
  
  // Copies a specified amount of bytes from the list of buffered data chunks.
  // This function is designed to be inlinable, so please take care when making
  // changes to the function body.
  function copyFromBuffer(n, list) {
    var ret = Buffer.allocUnsafe(n);
    var p = list.head;
    var c = 1;
    p.data.copy(ret);
    n -= p.data.length;
    while (p = p.next) {
      var buf = p.data;
      var nb = n > buf.length ? buf.length : n;
      buf.copy(ret, ret.length - n, 0, nb);
      n -= nb;
      if (n === 0) {
        if (nb === buf.length) {
          ++c;
          if (p.next) list.head = p.next;else list.head = list.tail = null;
        } else {
          list.head = p;
          p.data = buf.slice(nb);
        }
        break;
      }
      ++c;
    }
    list.length -= c;
    return ret;
  }
  
  function endReadable(stream) {
    var state = stream._readableState;
  
    // If we get here before consuming all the bytes, then that is a
    // bug in node.  Should never happen.
    if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
  
    if (!state.endEmitted) {
      state.ended = true;
      pna.nextTick(endReadableNT, state, stream);
    }
  }
  
  function endReadableNT(state, stream) {
    // Check that we didn't get one last unshift.
    if (!state.endEmitted && state.length === 0) {
      state.endEmitted = true;
      stream.readable = false;
      stream.emit('end');
    }
  }
  
  function indexOf(xs, x) {
    for (var i = 0, l = xs.length; i < l; i++) {
      if (xs[i] === x) return i;
    }
    return -1;
  }
  
  /***/ }),
  
  /***/ "./node_modules/readable-stream/lib/_stream_transform.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  // a transform stream is a readable/writable stream where you do
  // something with the data.  Sometimes it's called a "filter",
  // but that's not a great name for it, since that implies a thing where
  // some bits pass through, and others are simply ignored.  (That would
  // be a valid example of a transform, of course.)
  //
  // While the output is causally related to the input, it's not a
  // necessarily symmetric or synchronous transformation.  For example,
  // a zlib stream might take multiple plain-text writes(), and then
  // emit a single compressed chunk some time in the future.
  //
  // Here's how this works:
  //
  // The Transform stream has all the aspects of the readable and writable
  // stream classes.  When you write(chunk), that calls _write(chunk,cb)
  // internally, and returns false if there's a lot of pending writes
  // buffered up.  When you call read(), that calls _read(n) until
  // there's enough pending readable data buffered up.
  //
  // In a transform stream, the written data is placed in a buffer.  When
  // _read(n) is called, it transforms the queued up data, calling the
  // buffered _write cb's as it consumes chunks.  If consuming a single
  // written chunk would result in multiple output chunks, then the first
  // outputted bit calls the readcb, and subsequent chunks just go into
  // the read buffer, and will cause it to emit 'readable' if necessary.
  //
  // This way, back-pressure is actually determined by the reading side,
  // since _read has to be called to start processing a new chunk.  However,
  // a pathological inflate type of transform can cause excessive buffering
  // here.  For example, imagine a stream where every byte of input is
  // interpreted as an integer from 0-255, and then results in that many
  // bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
  // 1kb of data being output.  In this case, you could write a very small
  // amount of input, and end up with a very large amount of output.  In
  // such a pathological inflating mechanism, there'd be no way to tell
  // the system to stop doing the transform.  A single 4MB write could
  // cause the system to run out of memory.
  //
  // However, even in such a pathological case, only a single written chunk
  // would be consumed, and then the rest would wait (un-transformed) until
  // the results of the previous transformed chunk were consumed.
  
  
  
  module.exports = Transform;
  
  var Duplex = __webpack_require__("./node_modules/readable-stream/lib/_stream_duplex.js");
  
  /*<replacement>*/
  var util = __webpack_require__("./node_modules/core-util-is/lib/util.js");
  util.inherits = __webpack_require__("./node_modules/inherits/inherits.js");
  /*</replacement>*/
  
  util.inherits(Transform, Duplex);
  
  function afterTransform(er, data) {
    var ts = this._transformState;
    ts.transforming = false;
  
    var cb = ts.writecb;
  
    if (!cb) {
      return this.emit('error', new Error('write callback called multiple times'));
    }
  
    ts.writechunk = null;
    ts.writecb = null;
  
    if (data != null) // single equals check for both `null` and `undefined`
      this.push(data);
  
    cb(er);
  
    var rs = this._readableState;
    rs.reading = false;
    if (rs.needReadable || rs.length < rs.highWaterMark) {
      this._read(rs.highWaterMark);
    }
  }
  
  function Transform(options) {
    if (!(this instanceof Transform)) return new Transform(options);
  
    Duplex.call(this, options);
  
    this._transformState = {
      afterTransform: afterTransform.bind(this),
      needTransform: false,
      transforming: false,
      writecb: null,
      writechunk: null,
      writeencoding: null
    };
  
    // start out asking for a readable event once data is transformed.
    this._readableState.needReadable = true;
  
    // we have implemented the _read method, and done the other things
    // that Readable wants before the first _read call, so unset the
    // sync guard flag.
    this._readableState.sync = false;
  
    if (options) {
      if (typeof options.transform === 'function') this._transform = options.transform;
  
      if (typeof options.flush === 'function') this._flush = options.flush;
    }
  
    // When the writable side finishes, then flush out anything remaining.
    this.on('prefinish', prefinish);
  }
  
  function prefinish() {
    var _this = this;
  
    if (typeof this._flush === 'function') {
      this._flush(function (er, data) {
        done(_this, er, data);
      });
    } else {
      done(this, null, null);
    }
  }
  
  Transform.prototype.push = function (chunk, encoding) {
    this._transformState.needTransform = false;
    return Duplex.prototype.push.call(this, chunk, encoding);
  };
  
  // This is the part where you do stuff!
  // override this function in implementation classes.
  // 'chunk' is an input chunk.
  //
  // Call `push(newChunk)` to pass along transformed output
  // to the readable side.  You may call 'push' zero or more times.
  //
  // Call `cb(err)` when you are done with this chunk.  If you pass
  // an error, then that'll put the hurt on the whole operation.  If you
  // never call cb(), then you'll never get another chunk.
  Transform.prototype._transform = function (chunk, encoding, cb) {
    throw new Error('_transform() is not implemented');
  };
  
  Transform.prototype._write = function (chunk, encoding, cb) {
    var ts = this._transformState;
    ts.writecb = cb;
    ts.writechunk = chunk;
    ts.writeencoding = encoding;
    if (!ts.transforming) {
      var rs = this._readableState;
      if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
    }
  };
  
  // Doesn't matter what the args are here.
  // _transform does all the work.
  // That we got here means that the readable side wants more data.
  Transform.prototype._read = function (n) {
    var ts = this._transformState;
  
    if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
      ts.transforming = true;
      this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
    } else {
      // mark that we need a transform, so that any data that comes in
      // will get processed, now that we've asked for it.
      ts.needTransform = true;
    }
  };
  
  Transform.prototype._destroy = function (err, cb) {
    var _this2 = this;
  
    Duplex.prototype._destroy.call(this, err, function (err2) {
      cb(err2);
      _this2.emit('close');
    });
  };
  
  function done(stream, er, data) {
    if (er) return stream.emit('error', er);
  
    if (data != null) // single equals check for both `null` and `undefined`
      stream.push(data);
  
    // if there's nothing in the write buffer, then that means
    // that nothing more will ever be provided
    if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
  
    if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
  
    return stream.push(null);
  }
  
  /***/ }),
  
  /***/ "./node_modules/readable-stream/lib/_stream_writable.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  // A bit simpler than readable streams.
  // Implement an async ._write(chunk, encoding, cb), and it'll handle all
  // the drain event emission and buffering.
  
  
  
  /*<replacement>*/
  
  var pna = __webpack_require__("./node_modules/process-nextick-args/index.js");
  /*</replacement>*/
  
  module.exports = Writable;
  
  /* <replacement> */
  function WriteReq(chunk, encoding, cb) {
    this.chunk = chunk;
    this.encoding = encoding;
    this.callback = cb;
    this.next = null;
  }
  
  // It seems a linked list but it is not
  // there will be only 2 of these for each stream
  function CorkedRequest(state) {
    var _this = this;
  
    this.next = null;
    this.entry = null;
    this.finish = function () {
      onCorkedFinish(_this, state);
    };
  }
  /* </replacement> */
  
  /*<replacement>*/
  var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
  /*</replacement>*/
  
  /*<replacement>*/
  var Duplex;
  /*</replacement>*/
  
  Writable.WritableState = WritableState;
  
  /*<replacement>*/
  var util = __webpack_require__("./node_modules/core-util-is/lib/util.js");
  util.inherits = __webpack_require__("./node_modules/inherits/inherits.js");
  /*</replacement>*/
  
  /*<replacement>*/
  var internalUtil = {
    deprecate: __webpack_require__("./node_modules/util-deprecate/node.js")
  };
  /*</replacement>*/
  
  /*<replacement>*/
  var Stream = __webpack_require__("./node_modules/readable-stream/lib/internal/streams/stream.js");
  /*</replacement>*/
  
  /*<replacement>*/
  
  var Buffer = __webpack_require__("./node_modules/safe-buffer/index.js").Buffer;
  var OurUint8Array = global.Uint8Array || function () {};
  function _uint8ArrayToBuffer(chunk) {
    return Buffer.from(chunk);
  }
  function _isUint8Array(obj) {
    return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
  }
  
  /*</replacement>*/
  
  var destroyImpl = __webpack_require__("./node_modules/readable-stream/lib/internal/streams/destroy.js");
  
  util.inherits(Writable, Stream);
  
  function nop() {}
  
  function WritableState(options, stream) {
    Duplex = Duplex || __webpack_require__("./node_modules/readable-stream/lib/_stream_duplex.js");
  
    options = options || {};
  
    // Duplex streams are both readable and writable, but share
    // the same options object.
    // However, some cases require setting options to different
    // values for the readable and the writable sides of the duplex stream.
    // These options can be provided separately as readableXXX and writableXXX.
    var isDuplex = stream instanceof Duplex;
  
    // object stream flag to indicate whether or not this stream
    // contains buffers or objects.
    this.objectMode = !!options.objectMode;
  
    if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
  
    // the point at which write() starts returning false
    // Note: 0 is a valid value, means that we always return false if
    // the entire buffer is not flushed immediately on write()
    var hwm = options.highWaterMark;
    var writableHwm = options.writableHighWaterMark;
    var defaultHwm = this.objectMode ? 16 : 16 * 1024;
  
    if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
  
    // cast to ints.
    this.highWaterMark = Math.floor(this.highWaterMark);
  
    // if _final has been called
    this.finalCalled = false;
  
    // drain event flag.
    this.needDrain = false;
    // at the start of calling end()
    this.ending = false;
    // when end() has been called, and returned
    this.ended = false;
    // when 'finish' is emitted
    this.finished = false;
  
    // has it been destroyed
    this.destroyed = false;
  
    // should we decode strings into buffers before passing to _write?
    // this is here so that some node-core streams can optimize string
    // handling at a lower level.
    var noDecode = options.decodeStrings === false;
    this.decodeStrings = !noDecode;
  
    // Crypto is kind of old and crusty.  Historically, its default string
    // encoding is 'binary' so we have to make this configurable.
    // Everything else in the universe uses 'utf8', though.
    this.defaultEncoding = options.defaultEncoding || 'utf8';
  
    // not an actual buffer we keep track of, but a measurement
    // of how much we're waiting to get pushed to some underlying
    // socket or file.
    this.length = 0;
  
    // a flag to see when we're in the middle of a write.
    this.writing = false;
  
    // when true all writes will be buffered until .uncork() call
    this.corked = 0;
  
    // a flag to be able to tell if the onwrite cb is called immediately,
    // or on a later tick.  We set this to true at first, because any
    // actions that shouldn't happen until "later" should generally also
    // not happen before the first write call.
    this.sync = true;
  
    // a flag to know if we're processing previously buffered items, which
    // may call the _write() callback in the same tick, so that we don't
    // end up in an overlapped onwrite situation.
    this.bufferProcessing = false;
  
    // the callback that's passed to _write(chunk,cb)
    this.onwrite = function (er) {
      onwrite(stream, er);
    };
  
    // the callback that the user supplies to write(chunk,encoding,cb)
    this.writecb = null;
  
    // the amount that is being written when _write is called.
    this.writelen = 0;
  
    this.bufferedRequest = null;
    this.lastBufferedRequest = null;
  
    // number of pending user-supplied write callbacks
    // this must be 0 before 'finish' can be emitted
    this.pendingcb = 0;
  
    // emit prefinish if the only thing we're waiting for is _write cbs
    // This is relevant for synchronous Transform streams
    this.prefinished = false;
  
    // True if the error was already emitted and should not be thrown again
    this.errorEmitted = false;
  
    // count buffered requests
    this.bufferedRequestCount = 0;
  
    // allocate the first CorkedRequest, there is always
    // one allocated and free to use, and we maintain at most two
    this.corkedRequestsFree = new CorkedRequest(this);
  }
  
  WritableState.prototype.getBuffer = function getBuffer() {
    var current = this.bufferedRequest;
    var out = [];
    while (current) {
      out.push(current);
      current = current.next;
    }
    return out;
  };
  
  (function () {
    try {
      Object.defineProperty(WritableState.prototype, 'buffer', {
        get: internalUtil.deprecate(function () {
          return this.getBuffer();
        }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
      });
    } catch (_) {}
  })();
  
  // Test _writableState for inheritance to account for Duplex streams,
  // whose prototype chain only points to Readable.
  var realHasInstance;
  if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
    realHasInstance = Function.prototype[Symbol.hasInstance];
    Object.defineProperty(Writable, Symbol.hasInstance, {
      value: function (object) {
        if (realHasInstance.call(this, object)) return true;
        if (this !== Writable) return false;
  
        return object && object._writableState instanceof WritableState;
      }
    });
  } else {
    realHasInstance = function (object) {
      return object instanceof this;
    };
  }
  
  function Writable(options) {
    Duplex = Duplex || __webpack_require__("./node_modules/readable-stream/lib/_stream_duplex.js");
  
    // Writable ctor is applied to Duplexes, too.
    // `realHasInstance` is necessary because using plain `instanceof`
    // would return false, as no `_writableState` property is attached.
  
    // Trying to use the custom `instanceof` for Writable here will also break the
    // Node.js LazyTransform implementation, which has a non-trivial getter for
    // `_writableState` that would lead to infinite recursion.
    if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
      return new Writable(options);
    }
  
    this._writableState = new WritableState(options, this);
  
    // legacy.
    this.writable = true;
  
    if (options) {
      if (typeof options.write === 'function') this._write = options.write;
  
      if (typeof options.writev === 'function') this._writev = options.writev;
  
      if (typeof options.destroy === 'function') this._destroy = options.destroy;
  
      if (typeof options.final === 'function') this._final = options.final;
    }
  
    Stream.call(this);
  }
  
  // Otherwise people can pipe Writable streams, which is just wrong.
  Writable.prototype.pipe = function () {
    this.emit('error', new Error('Cannot pipe, not readable'));
  };
  
  function writeAfterEnd(stream, cb) {
    var er = new Error('write after end');
    // TODO: defer error events consistently everywhere, not just the cb
    stream.emit('error', er);
    pna.nextTick(cb, er);
  }
  
  // Checks that a user-supplied chunk is valid, especially for the particular
  // mode the stream is in. Currently this means that `null` is never accepted
  // and undefined/non-string values are only allowed in object mode.
  function validChunk(stream, state, chunk, cb) {
    var valid = true;
    var er = false;
  
    if (chunk === null) {
      er = new TypeError('May not write null values to stream');
    } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
      er = new TypeError('Invalid non-string/buffer chunk');
    }
    if (er) {
      stream.emit('error', er);
      pna.nextTick(cb, er);
      valid = false;
    }
    return valid;
  }
  
  Writable.prototype.write = function (chunk, encoding, cb) {
    var state = this._writableState;
    var ret = false;
    var isBuf = !state.objectMode && _isUint8Array(chunk);
  
    if (isBuf && !Buffer.isBuffer(chunk)) {
      chunk = _uint8ArrayToBuffer(chunk);
    }
  
    if (typeof encoding === 'function') {
      cb = encoding;
      encoding = null;
    }
  
    if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
  
    if (typeof cb !== 'function') cb = nop;
  
    if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
      state.pendingcb++;
      ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
    }
  
    return ret;
  };
  
  Writable.prototype.cork = function () {
    var state = this._writableState;
  
    state.corked++;
  };
  
  Writable.prototype.uncork = function () {
    var state = this._writableState;
  
    if (state.corked) {
      state.corked--;
  
      if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
    }
  };
  
  Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
    // node::ParseEncoding() requires lower case.
    if (typeof encoding === 'string') encoding = encoding.toLowerCase();
    if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
    this._writableState.defaultEncoding = encoding;
    return this;
  };
  
  function decodeChunk(state, chunk, encoding) {
    if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
      chunk = Buffer.from(chunk, encoding);
    }
    return chunk;
  }
  
  Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
    // making it explicit this property is not enumerable
    // because otherwise some prototype manipulation in
    // userland will fail
    enumerable: false,
    get: function () {
      return this._writableState.highWaterMark;
    }
  });
  
  // if we're already writing something, then just put this
  // in the queue, and wait our turn.  Otherwise, call _write
  // If we return false, then we need a drain event, so set that flag.
  function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
    if (!isBuf) {
      var newChunk = decodeChunk(state, chunk, encoding);
      if (chunk !== newChunk) {
        isBuf = true;
        encoding = 'buffer';
        chunk = newChunk;
      }
    }
    var len = state.objectMode ? 1 : chunk.length;
  
    state.length += len;
  
    var ret = state.length < state.highWaterMark;
    // we must ensure that previous needDrain will not be reset to false.
    if (!ret) state.needDrain = true;
  
    if (state.writing || state.corked) {
      var last = state.lastBufferedRequest;
      state.lastBufferedRequest = {
        chunk: chunk,
        encoding: encoding,
        isBuf: isBuf,
        callback: cb,
        next: null
      };
      if (last) {
        last.next = state.lastBufferedRequest;
      } else {
        state.bufferedRequest = state.lastBufferedRequest;
      }
      state.bufferedRequestCount += 1;
    } else {
      doWrite(stream, state, false, len, chunk, encoding, cb);
    }
  
    return ret;
  }
  
  function doWrite(stream, state, writev, len, chunk, encoding, cb) {
    state.writelen = len;
    state.writecb = cb;
    state.writing = true;
    state.sync = true;
    if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
    state.sync = false;
  }
  
  function onwriteError(stream, state, sync, er, cb) {
    --state.pendingcb;
  
    if (sync) {
      // defer the callback if we are being called synchronously
      // to avoid piling up things on the stack
      pna.nextTick(cb, er);
      // this can emit finish, and it will always happen
      // after error
      pna.nextTick(finishMaybe, stream, state);
      stream._writableState.errorEmitted = true;
      stream.emit('error', er);
    } else {
      // the caller expect this to happen before if
      // it is async
      cb(er);
      stream._writableState.errorEmitted = true;
      stream.emit('error', er);
      // this can emit finish, but finish must
      // always follow error
      finishMaybe(stream, state);
    }
  }
  
  function onwriteStateUpdate(state) {
    state.writing = false;
    state.writecb = null;
    state.length -= state.writelen;
    state.writelen = 0;
  }
  
  function onwrite(stream, er) {
    var state = stream._writableState;
    var sync = state.sync;
    var cb = state.writecb;
  
    onwriteStateUpdate(state);
  
    if (er) onwriteError(stream, state, sync, er, cb);else {
      // Check if we're actually ready to finish, but don't emit yet
      var finished = needFinish(state);
  
      if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
        clearBuffer(stream, state);
      }
  
      if (sync) {
        /*<replacement>*/
        asyncWrite(afterWrite, stream, state, finished, cb);
        /*</replacement>*/
      } else {
        afterWrite(stream, state, finished, cb);
      }
    }
  }
  
  function afterWrite(stream, state, finished, cb) {
    if (!finished) onwriteDrain(stream, state);
    state.pendingcb--;
    cb();
    finishMaybe(stream, state);
  }
  
  // Must force callback to be called on nextTick, so that we don't
  // emit 'drain' before the write() consumer gets the 'false' return
  // value, and has a chance to attach a 'drain' listener.
  function onwriteDrain(stream, state) {
    if (state.length === 0 && state.needDrain) {
      state.needDrain = false;
      stream.emit('drain');
    }
  }
  
  // if there's something in the buffer waiting, then process it
  function clearBuffer(stream, state) {
    state.bufferProcessing = true;
    var entry = state.bufferedRequest;
  
    if (stream._writev && entry && entry.next) {
      // Fast case, write everything using _writev()
      var l = state.bufferedRequestCount;
      var buffer = new Array(l);
      var holder = state.corkedRequestsFree;
      holder.entry = entry;
  
      var count = 0;
      var allBuffers = true;
      while (entry) {
        buffer[count] = entry;
        if (!entry.isBuf) allBuffers = false;
        entry = entry.next;
        count += 1;
      }
      buffer.allBuffers = allBuffers;
  
      doWrite(stream, state, true, state.length, buffer, '', holder.finish);
  
      // doWrite is almost always async, defer these to save a bit of time
      // as the hot path ends with doWrite
      state.pendingcb++;
      state.lastBufferedRequest = null;
      if (holder.next) {
        state.corkedRequestsFree = holder.next;
        holder.next = null;
      } else {
        state.corkedRequestsFree = new CorkedRequest(state);
      }
      state.bufferedRequestCount = 0;
    } else {
      // Slow case, write chunks one-by-one
      while (entry) {
        var chunk = entry.chunk;
        var encoding = entry.encoding;
        var cb = entry.callback;
        var len = state.objectMode ? 1 : chunk.length;
  
        doWrite(stream, state, false, len, chunk, encoding, cb);
        entry = entry.next;
        state.bufferedRequestCount--;
        // if we didn't call the onwrite immediately, then
        // it means that we need to wait until it does.
        // also, that means that the chunk and cb are currently
        // being processed, so move the buffer counter past them.
        if (state.writing) {
          break;
        }
      }
  
      if (entry === null) state.lastBufferedRequest = null;
    }
  
    state.bufferedRequest = entry;
    state.bufferProcessing = false;
  }
  
  Writable.prototype._write = function (chunk, encoding, cb) {
    cb(new Error('_write() is not implemented'));
  };
  
  Writable.prototype._writev = null;
  
  Writable.prototype.end = function (chunk, encoding, cb) {
    var state = this._writableState;
  
    if (typeof chunk === 'function') {
      cb = chunk;
      chunk = null;
      encoding = null;
    } else if (typeof encoding === 'function') {
      cb = encoding;
      encoding = null;
    }
  
    if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
  
    // .end() fully uncorks
    if (state.corked) {
      state.corked = 1;
      this.uncork();
    }
  
    // ignore unnecessary end() calls.
    if (!state.ending && !state.finished) endWritable(this, state, cb);
  };
  
  function needFinish(state) {
    return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
  }
  function callFinal(stream, state) {
    stream._final(function (err) {
      state.pendingcb--;
      if (err) {
        stream.emit('error', err);
      }
      state.prefinished = true;
      stream.emit('prefinish');
      finishMaybe(stream, state);
    });
  }
  function prefinish(stream, state) {
    if (!state.prefinished && !state.finalCalled) {
      if (typeof stream._final === 'function') {
        state.pendingcb++;
        state.finalCalled = true;
        pna.nextTick(callFinal, stream, state);
      } else {
        state.prefinished = true;
        stream.emit('prefinish');
      }
    }
  }
  
  function finishMaybe(stream, state) {
    var need = needFinish(state);
    if (need) {
      prefinish(stream, state);
      if (state.pendingcb === 0) {
        state.finished = true;
        stream.emit('finish');
      }
    }
    return need;
  }
  
  function endWritable(stream, state, cb) {
    state.ending = true;
    finishMaybe(stream, state);
    if (cb) {
      if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
    }
    state.ended = true;
    stream.writable = false;
  }
  
  function onCorkedFinish(corkReq, state, err) {
    var entry = corkReq.entry;
    corkReq.entry = null;
    while (entry) {
      var cb = entry.callback;
      state.pendingcb--;
      cb(err);
      entry = entry.next;
    }
    if (state.corkedRequestsFree) {
      state.corkedRequestsFree.next = corkReq;
    } else {
      state.corkedRequestsFree = corkReq;
    }
  }
  
  Object.defineProperty(Writable.prototype, 'destroyed', {
    get: function () {
      if (this._writableState === undefined) {
        return false;
      }
      return this._writableState.destroyed;
    },
    set: function (value) {
      // we ignore the value if the stream
      // has not been initialized yet
      if (!this._writableState) {
        return;
      }
  
      // backward compatibility, the user is explicitly
      // managing destroyed
      this._writableState.destroyed = value;
    }
  });
  
  Writable.prototype.destroy = destroyImpl.destroy;
  Writable.prototype._undestroy = destroyImpl.undestroy;
  Writable.prototype._destroy = function (err, cb) {
    this.end();
    cb(err);
  };
  
  /***/ }),
  
  /***/ "./node_modules/readable-stream/lib/internal/streams/BufferList.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var Buffer = __webpack_require__("./node_modules/safe-buffer/index.js").Buffer;
  var util = __webpack_require__("util");
  
  function copyBuffer(src, target, offset) {
    src.copy(target, offset);
  }
  
  module.exports = function () {
    function BufferList() {
      _classCallCheck(this, BufferList);
  
      this.head = null;
      this.tail = null;
      this.length = 0;
    }
  
    BufferList.prototype.push = function push(v) {
      var entry = { data: v, next: null };
      if (this.length > 0) this.tail.next = entry;else this.head = entry;
      this.tail = entry;
      ++this.length;
    };
  
    BufferList.prototype.unshift = function unshift(v) {
      var entry = { data: v, next: this.head };
      if (this.length === 0) this.tail = entry;
      this.head = entry;
      ++this.length;
    };
  
    BufferList.prototype.shift = function shift() {
      if (this.length === 0) return;
      var ret = this.head.data;
      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
      --this.length;
      return ret;
    };
  
    BufferList.prototype.clear = function clear() {
      this.head = this.tail = null;
      this.length = 0;
    };
  
    BufferList.prototype.join = function join(s) {
      if (this.length === 0) return '';
      var p = this.head;
      var ret = '' + p.data;
      while (p = p.next) {
        ret += s + p.data;
      }return ret;
    };
  
    BufferList.prototype.concat = function concat(n) {
      if (this.length === 0) return Buffer.alloc(0);
      if (this.length === 1) return this.head.data;
      var ret = Buffer.allocUnsafe(n >>> 0);
      var p = this.head;
      var i = 0;
      while (p) {
        copyBuffer(p.data, ret, i);
        i += p.data.length;
        p = p.next;
      }
      return ret;
    };
  
    return BufferList;
  }();
  
  if (util && util.inspect && util.inspect.custom) {
    module.exports.prototype[util.inspect.custom] = function () {
      var obj = util.inspect({ length: this.length });
      return this.constructor.name + ' ' + obj;
    };
  }
  
  /***/ }),
  
  /***/ "./node_modules/readable-stream/lib/internal/streams/destroy.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /*<replacement>*/
  
  var pna = __webpack_require__("./node_modules/process-nextick-args/index.js");
  /*</replacement>*/
  
  // undocumented cb() API, needed for core, not for public API
  function destroy(err, cb) {
    var _this = this;
  
    var readableDestroyed = this._readableState && this._readableState.destroyed;
    var writableDestroyed = this._writableState && this._writableState.destroyed;
  
    if (readableDestroyed || writableDestroyed) {
      if (cb) {
        cb(err);
      } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
        pna.nextTick(emitErrorNT, this, err);
      }
      return this;
    }
  
    // we set destroyed to true before firing error callbacks in order
    // to make it re-entrance safe in case destroy() is called within callbacks
  
    if (this._readableState) {
      this._readableState.destroyed = true;
    }
  
    // if this is a duplex stream mark the writable part as destroyed as well
    if (this._writableState) {
      this._writableState.destroyed = true;
    }
  
    this._destroy(err || null, function (err) {
      if (!cb && err) {
        pna.nextTick(emitErrorNT, _this, err);
        if (_this._writableState) {
          _this._writableState.errorEmitted = true;
        }
      } else if (cb) {
        cb(err);
      }
    });
  
    return this;
  }
  
  function undestroy() {
    if (this._readableState) {
      this._readableState.destroyed = false;
      this._readableState.reading = false;
      this._readableState.ended = false;
      this._readableState.endEmitted = false;
    }
  
    if (this._writableState) {
      this._writableState.destroyed = false;
      this._writableState.ended = false;
      this._writableState.ending = false;
      this._writableState.finished = false;
      this._writableState.errorEmitted = false;
    }
  }
  
  function emitErrorNT(self, err) {
    self.emit('error', err);
  }
  
  module.exports = {
    destroy: destroy,
    undestroy: undestroy
  };
  
  /***/ }),
  
  /***/ "./node_modules/readable-stream/lib/internal/streams/stream.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__("stream");
  
  
  /***/ }),
  
  /***/ "./node_modules/readable-stream/node_modules/string_decoder/lib/string_decoder.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  // Copyright Joyent, Inc. and other Node contributors.
  //
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the
  // "Software"), to deal in the Software without restriction, including
  // without limitation the rights to use, copy, modify, merge, publish,
  // distribute, sublicense, and/or sell copies of the Software, and to permit
  // persons to whom the Software is furnished to do so, subject to the
  // following conditions:
  //
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  //
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  // USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  
  
  /*<replacement>*/
  
  var Buffer = __webpack_require__("./node_modules/safe-buffer/index.js").Buffer;
  /*</replacement>*/
  
  var isEncoding = Buffer.isEncoding || function (encoding) {
    encoding = '' + encoding;
    switch (encoding && encoding.toLowerCase()) {
      case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
        return true;
      default:
        return false;
    }
  };
  
  function _normalizeEncoding(enc) {
    if (!enc) return 'utf8';
    var retried;
    while (true) {
      switch (enc) {
        case 'utf8':
        case 'utf-8':
          return 'utf8';
        case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return 'utf16le';
        case 'latin1':
        case 'binary':
          return 'latin1';
        case 'base64':
        case 'ascii':
        case 'hex':
          return enc;
        default:
          if (retried) return; // undefined
          enc = ('' + enc).toLowerCase();
          retried = true;
      }
    }
  };
  
  // Do not cache `Buffer.isEncoding` when checking encoding names as some
  // modules monkey-patch it to support additional encodings
  function normalizeEncoding(enc) {
    var nenc = _normalizeEncoding(enc);
    if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
    return nenc || enc;
  }
  
  // StringDecoder provides an interface for efficiently splitting a series of
  // buffers into a series of JS strings without breaking apart multi-byte
  // characters.
  exports.StringDecoder = StringDecoder;
  function StringDecoder(encoding) {
    this.encoding = normalizeEncoding(encoding);
    var nb;
    switch (this.encoding) {
      case 'utf16le':
        this.text = utf16Text;
        this.end = utf16End;
        nb = 4;
        break;
      case 'utf8':
        this.fillLast = utf8FillLast;
        nb = 4;
        break;
      case 'base64':
        this.text = base64Text;
        this.end = base64End;
        nb = 3;
        break;
      default:
        this.write = simpleWrite;
        this.end = simpleEnd;
        return;
    }
    this.lastNeed = 0;
    this.lastTotal = 0;
    this.lastChar = Buffer.allocUnsafe(nb);
  }
  
  StringDecoder.prototype.write = function (buf) {
    if (buf.length === 0) return '';
    var r;
    var i;
    if (this.lastNeed) {
      r = this.fillLast(buf);
      if (r === undefined) return '';
      i = this.lastNeed;
      this.lastNeed = 0;
    } else {
      i = 0;
    }
    if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
    return r || '';
  };
  
  StringDecoder.prototype.end = utf8End;
  
  // Returns only complete characters in a Buffer
  StringDecoder.prototype.text = utf8Text;
  
  // Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
  StringDecoder.prototype.fillLast = function (buf) {
    if (this.lastNeed <= buf.length) {
      buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
    }
    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
    this.lastNeed -= buf.length;
  };
  
  // Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
  // continuation byte. If an invalid byte is detected, -2 is returned.
  function utf8CheckByte(byte) {
    if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
    return byte >> 6 === 0x02 ? -1 : -2;
  }
  
  // Checks at most 3 bytes at the end of a Buffer in order to detect an
  // incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
  // needed to complete the UTF-8 character (if applicable) are returned.
  function utf8CheckIncomplete(self, buf, i) {
    var j = buf.length - 1;
    if (j < i) return 0;
    var nb = utf8CheckByte(buf[j]);
    if (nb >= 0) {
      if (nb > 0) self.lastNeed = nb - 1;
      return nb;
    }
    if (--j < i || nb === -2) return 0;
    nb = utf8CheckByte(buf[j]);
    if (nb >= 0) {
      if (nb > 0) self.lastNeed = nb - 2;
      return nb;
    }
    if (--j < i || nb === -2) return 0;
    nb = utf8CheckByte(buf[j]);
    if (nb >= 0) {
      if (nb > 0) {
        if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
      }
      return nb;
    }
    return 0;
  }
  
  // Validates as many continuation bytes for a multi-byte UTF-8 character as
  // needed or are available. If we see a non-continuation byte where we expect
  // one, we "replace" the validated continuation bytes we've seen so far with
  // a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
  // behavior. The continuation byte check is included three times in the case
  // where all of the continuation bytes for a character exist in the same buffer.
  // It is also done this way as a slight performance increase instead of using a
  // loop.
  function utf8CheckExtraBytes(self, buf, p) {
    if ((buf[0] & 0xC0) !== 0x80) {
      self.lastNeed = 0;
      return '\ufffd';
    }
    if (self.lastNeed > 1 && buf.length > 1) {
      if ((buf[1] & 0xC0) !== 0x80) {
        self.lastNeed = 1;
        return '\ufffd';
      }
      if (self.lastNeed > 2 && buf.length > 2) {
        if ((buf[2] & 0xC0) !== 0x80) {
          self.lastNeed = 2;
          return '\ufffd';
        }
      }
    }
  }
  
  // Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
  function utf8FillLast(buf) {
    var p = this.lastTotal - this.lastNeed;
    var r = utf8CheckExtraBytes(this, buf, p);
    if (r !== undefined) return r;
    if (this.lastNeed <= buf.length) {
      buf.copy(this.lastChar, p, 0, this.lastNeed);
      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
    }
    buf.copy(this.lastChar, p, 0, buf.length);
    this.lastNeed -= buf.length;
  }
  
  // Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
  // partial character, the character's bytes are buffered until the required
  // number of bytes are available.
  function utf8Text(buf, i) {
    var total = utf8CheckIncomplete(this, buf, i);
    if (!this.lastNeed) return buf.toString('utf8', i);
    this.lastTotal = total;
    var end = buf.length - (total - this.lastNeed);
    buf.copy(this.lastChar, 0, end);
    return buf.toString('utf8', i, end);
  }
  
  // For UTF-8, a replacement character is added when ending on a partial
  // character.
  function utf8End(buf) {
    var r = buf && buf.length ? this.write(buf) : '';
    if (this.lastNeed) return r + '\ufffd';
    return r;
  }
  
  // UTF-16LE typically needs two bytes per character, but even if we have an even
  // number of bytes available, we need to check if we end on a leading/high
  // surrogate. In that case, we need to wait for the next two bytes in order to
  // decode the last character properly.
  function utf16Text(buf, i) {
    if ((buf.length - i) % 2 === 0) {
      var r = buf.toString('utf16le', i);
      if (r) {
        var c = r.charCodeAt(r.length - 1);
        if (c >= 0xD800 && c <= 0xDBFF) {
          this.lastNeed = 2;
          this.lastTotal = 4;
          this.lastChar[0] = buf[buf.length - 2];
          this.lastChar[1] = buf[buf.length - 1];
          return r.slice(0, -1);
        }
      }
      return r;
    }
    this.lastNeed = 1;
    this.lastTotal = 2;
    this.lastChar[0] = buf[buf.length - 1];
    return buf.toString('utf16le', i, buf.length - 1);
  }
  
  // For UTF-16LE we do not explicitly append special replacement characters if we
  // end on a partial character, we simply let v8 handle that.
  function utf16End(buf) {
    var r = buf && buf.length ? this.write(buf) : '';
    if (this.lastNeed) {
      var end = this.lastTotal - this.lastNeed;
      return r + this.lastChar.toString('utf16le', 0, end);
    }
    return r;
  }
  
  function base64Text(buf, i) {
    var n = (buf.length - i) % 3;
    if (n === 0) return buf.toString('base64', i);
    this.lastNeed = 3 - n;
    this.lastTotal = 3;
    if (n === 1) {
      this.lastChar[0] = buf[buf.length - 1];
    } else {
      this.lastChar[0] = buf[buf.length - 2];
      this.lastChar[1] = buf[buf.length - 1];
    }
    return buf.toString('base64', i, buf.length - n);
  }
  
  function base64End(buf) {
    var r = buf && buf.length ? this.write(buf) : '';
    if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
    return r;
  }
  
  // Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
  function simpleWrite(buf) {
    return buf.toString(this.encoding);
  }
  
  function simpleEnd(buf) {
    return buf && buf.length ? this.write(buf) : '';
  }
  
  /***/ }),
  
  /***/ "./node_modules/readable-stream/readable.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  var Stream = __webpack_require__("stream");
  if (process.env.READABLE_STREAM === 'disable' && Stream) {
    module.exports = Stream;
    exports = module.exports = Stream.Readable;
    exports.Readable = Stream.Readable;
    exports.Writable = Stream.Writable;
    exports.Duplex = Stream.Duplex;
    exports.Transform = Stream.Transform;
    exports.PassThrough = Stream.PassThrough;
    exports.Stream = Stream;
  } else {
    exports = module.exports = __webpack_require__("./node_modules/readable-stream/lib/_stream_readable.js");
    exports.Stream = Stream || exports;
    exports.Readable = exports;
    exports.Writable = __webpack_require__("./node_modules/readable-stream/lib/_stream_writable.js");
    exports.Duplex = __webpack_require__("./node_modules/readable-stream/lib/_stream_duplex.js");
    exports.Transform = __webpack_require__("./node_modules/readable-stream/lib/_stream_transform.js");
    exports.PassThrough = __webpack_require__("./node_modules/readable-stream/lib/_stream_passthrough.js");
  }
  
  
  /***/ }),
  
  /***/ "./node_modules/rfdc/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  module.exports = rfdc
  
  function rfdc (opts) {
    opts = opts || {}
    const proto = opts.proto || false
    const circles = opts.circles || false
    if (circles) return rfdcCircles(opts)
    return proto ? cloneProto : clone
    function clone (o) {
      const type = typeof o
      if (type === 'function') return o
      if (o === null || type !== 'object') return o
      if (o instanceof Date) return new Date(o)
      const o2 = Array.isArray(o) ? new Array(o.length) : {}
      for (var k in o) {
        if (Object.hasOwnProperty.call(o, k) === false) continue
        var cur = o[k]
        if (typeof cur === 'function') {
          o2[k] = cur
          continue
        }
        if (cur === null) {
          o2[k] = null
          continue
        }
        if (typeof cur === 'object') {
          if (cur instanceof Date) {
            o2[k] = new Date(cur)
            continue
          }
          o2[k] = clone(cur)
          continue
        }
        o2[k] = cur
      }
      return o2
    }
  
    function cloneProto (o) {
      const type = typeof o
      if (type === 'function') return o
      if (o === null || type !== 'object') return o
      if (o instanceof Date) return new Date(o)
      const o2 = Array.isArray(o) ? new Array(o.length) : {} 
      for (var k in o) {
        var cur = o[k]
        if (typeof cur === 'function') {
          o2[k] = cur
          continue
        }
        if (cur === null) {
          o2[k] = null
          continue
        }
        if (typeof cur === 'object') {
          if (cur instanceof Date) {
            o2[k] = new Date(cur)
            continue
          }
          o2[k] = cloneProto(cur)
          continue
        }
        o2[k] = cur
      }
      return o2
    }
  }
  
  
  function rfdcCircles (opts) {
    const proto = opts.proto || false
    const refs = new WeakMap()
  
    return proto ? cloneProto : clone
    function clone (o) {
      const type = typeof o
      if (type === 'function') return o
      if (o === null || type !== 'object') return o
      if (o instanceof Date) return new Date(o)
      const o2 = Array.isArray(o) ? new Array(o.length) : {}
      refs.set(o, o2)
      for (var k in o) {
        if (Object.hasOwnProperty.call(o, k) === false) continue
        var cur = o[k]
        if (typeof cur === 'function') {
          o2[k] = cur
          continue
        }
        if (cur === null) {
          o2[k] = null
          continue
        }
        if (typeof cur === 'object') {
          if (cur instanceof Date) {
            o2[k] = new Date(cur)
            continue
          }
          if (refs.has(cur)) o2[k] = refs.get(cur)
          else o2[k] = clone(cur)
          continue
        }
        o2[k] = cur
      }
      refs.delete(o)
      return o2
    }
  
    function cloneProto (o) {
      const type = typeof o
      if (type === 'function') return o
      if (o === null || type !== 'object') return o
      if (o instanceof Date) return new Date(o)
      const o2 = Array.isArray(o) ? new Array(o.length) : {}
      refs.set(o, o2)    
      for (var k in o) {
        var cur = o[k]
        if (typeof cur === 'function') {
          o2[k] = cur
          continue
        }
        if (cur === null) {
          o2[k] = null
          continue
        }
        if (typeof cur === 'object') {
          if (cur instanceof Date) {
            o2[k] = new Date(cur)
            continue
          }
          if (refs.has(cur)) o2[k] = refs.get(cur)
          else o2[k] = cloneProto(cur)
          continue
        }
        o2[k] = cur
      }
      refs.delete(o)
      return o2
    }
  }
  
  /***/ }),
  
  /***/ "./node_modules/safe-buffer/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  /* eslint-disable node/no-deprecated-api */
  var buffer = __webpack_require__("buffer")
  var Buffer = buffer.Buffer
  
  // alternative to using Object.keys for old browsers
  function copyProps (src, dst) {
    for (var key in src) {
      dst[key] = src[key]
    }
  }
  if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
    module.exports = buffer
  } else {
    // Copy properties from require('buffer')
    copyProps(buffer, exports)
    exports.Buffer = SafeBuffer
  }
  
  function SafeBuffer (arg, encodingOrOffset, length) {
    return Buffer(arg, encodingOrOffset, length)
  }
  
  // Copy static methods from Buffer
  copyProps(Buffer, SafeBuffer)
  
  SafeBuffer.from = function (arg, encodingOrOffset, length) {
    if (typeof arg === 'number') {
      throw new TypeError('Argument must not be a number')
    }
    return Buffer(arg, encodingOrOffset, length)
  }
  
  SafeBuffer.alloc = function (size, fill, encoding) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    var buf = Buffer(size)
    if (fill !== undefined) {
      if (typeof encoding === 'string') {
        buf.fill(fill, encoding)
      } else {
        buf.fill(fill)
      }
    } else {
      buf.fill(0)
    }
    return buf
  }
  
  SafeBuffer.allocUnsafe = function (size) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    return Buffer(size)
  }
  
  SafeBuffer.allocUnsafeSlow = function (size) {
    if (typeof size !== 'number') {
      throw new TypeError('Argument must be a number')
    }
    return buffer.SlowBuffer(size)
  }
  
  
  /***/ }),
  
  /***/ "./node_modules/streamroller/lib/BaseRollingFileStream.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var fs = __webpack_require__("fs")
  , zlib = __webpack_require__("zlib")
  , debug = __webpack_require__("./node_modules/debug/src/index.js")('streamroller:BaseRollingFileStream')
  , mkdirp = __webpack_require__("./node_modules/mkdirp/index.js")
  , path = __webpack_require__("path")
  , util = __webpack_require__("util")
  , stream = __webpack_require__("./node_modules/readable-stream/readable.js");
  
  module.exports = BaseRollingFileStream;
  
  function BaseRollingFileStream(filename, options) {
    debug("In BaseRollingFileStream");
    this.filename = filename;
    this.options = options || {};
    this.options.encoding = this.options.encoding || 'utf8';
    this.options.mode = this.options.mode || parseInt('0644', 8);
    this.options.flags = this.options.flags || 'a';
  
    this.currentSize = 0;
  
    function currentFileSize(file) {
      var fileSize = 0;
      try {
        fileSize = fs.statSync(file).size;
      } catch (e) {
        // file does not exist
      }
      return fileSize;
    }
  
    function throwErrorIfArgumentsAreNotValid() {
      if (!filename) {
        throw new Error("You must specify a filename");
      }
    }
  
    throwErrorIfArgumentsAreNotValid();
    debug("Calling BaseRollingFileStream.super");
    BaseRollingFileStream.super_.call(this);
    this.openTheStream();
    this.currentSize = currentFileSize(this.filename);
  }
  util.inherits(BaseRollingFileStream, stream.Writable);
  
  BaseRollingFileStream.prototype._writeTheChunk = function(chunk, encoding, callback) {
    debug("writing the chunk to the underlying stream");
    this.currentSize += chunk.length;
    try {
      if (!this.theStream.write(chunk,encoding)) {
        debug('waiting for drain event');
        this.theStream.once('drain',callback);
      } else {
        process.nextTick(callback);
      }
      debug("chunk written");
    } catch (err) {
      debug(err);
      if (callback) {
        callback(err);
      }
    }
  };
  
  BaseRollingFileStream.prototype._write = function(chunk, encoding, callback) {
    debug("in _write");
  
    if (this.shouldRoll()) {
      this.currentSize = 0;
      this.roll(this.filename, this._writeTheChunk.bind(this, chunk, encoding, callback));
    } else {
      this._writeTheChunk(chunk, encoding, callback);
    }
  };
  
  BaseRollingFileStream.prototype.openTheStream = function(cb) {
    debug("opening the underlying stream");
    var that = this;
    mkdirp.sync(path.dirname(this.filename));
    this.theStream = fs.createWriteStream(this.filename, this.options);
    this.theStream.on('error', function(err) {
      that.emit('error', err);
    });
    if (cb) {
      this.theStream.on("open", cb);
    }
  };
  
  BaseRollingFileStream.prototype.closeTheStream = function(cb) {
    debug("closing the underlying stream");
    this.theStream.end(cb);
  };
  
  BaseRollingFileStream.prototype.compress = function(filename, cb) {
      debug('Compressing ', filename, ' -> ', filename, '.gz');
      var gzip = zlib.createGzip();
      var inp = fs.createReadStream(filename);
      var out = fs.createWriteStream(filename+".gz");
      inp.pipe(gzip).pipe(out);
  
      out.on('finish', function(err) {
        debug('Removing original ', filename);
        fs.unlink(filename, cb);
      });
  };
  
  BaseRollingFileStream.prototype.shouldRoll = function() {
    return false; // default behaviour is never to roll
  };
  
  BaseRollingFileStream.prototype.roll = function(filename, callback) {
    callback(); // default behaviour is not to do anything
  };
  
  BaseRollingFileStream.prototype.end = function(chunk, encoding, callback) {
    var self = this;
    debug('end called - first close myself');
    stream.Writable.prototype.end.call(self, function() {
      debug('writable end callback, now close underlying stream');
      self.theStream.end(chunk, encoding, function(err) {
        debug('underlying stream closed');
        if (callback) {
          callback(err);
        }
      });
    });
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/streamroller/lib/DateRollingFileStream.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var BaseRollingFileStream = __webpack_require__("./node_modules/streamroller/lib/BaseRollingFileStream.js")
    , debug = __webpack_require__("./node_modules/debug/src/index.js")('streamroller:DateRollingFileStream')
    , format = __webpack_require__("./node_modules/date-format/lib/index.js")
    , fs = __webpack_require__("fs")
    , path = __webpack_require__("path")
    , util = __webpack_require__("util");
  
  module.exports = DateRollingFileStream;
  
  function findTimestampFromFileIfExists(filename, now) {
    return fs.existsSync(filename) ? fs.statSync(filename).mtime : new Date(now());
  }
  
  function DateRollingFileStream(filename, pattern, options, now) {
    debug("Now is ", now);
    if (pattern && typeof(pattern) === 'object') {
      now = options;
      options = pattern;
      pattern = null;
    }
    this.pattern = pattern || '.yyyy-MM-dd';
    this.now = now || Date.now;
    this.lastTimeWeWroteSomething = format.asString(
      this.pattern,
      findTimestampFromFileIfExists(filename, this.now)
    );
  
    this.baseFilename = filename;
    this.alwaysIncludePattern = false;
  
    debug('options is ', options);
  
    if (options) {
      if (options.alwaysIncludePattern) {
        debug('always include pattern is true');
        this.alwaysIncludePattern = true;
        filename = this.baseFilename + this.lastTimeWeWroteSomething;
        debug('filename is now ', filename);
      }
    }
    debug("this.now is ", this.now, ", now is ", now);
  
    DateRollingFileStream.super_.call(this, filename, options);
  }
  util.inherits(DateRollingFileStream, BaseRollingFileStream);
  
  DateRollingFileStream.prototype.shouldRoll = function () {
    var lastTime = this.lastTimeWeWroteSomething,
      thisTime = format.asString(this.pattern, new Date(this.now()));
  
    debug("DateRollingFileStream.shouldRoll with now = ",
      this.now(), ", thisTime = ", thisTime, ", lastTime = ", lastTime);
  
    this.lastTimeWeWroteSomething = thisTime;
    this.previousTime = lastTime;
  
    return thisTime !== lastTime;
  };
  
  DateRollingFileStream.prototype.roll = function (filename, callback) {
    var that = this;
  
    debug("Starting roll");
  
    var filenameObj = path.parse(this.baseFilename);
  
    if (this.alwaysIncludePattern) {
      this.filename = this.options.keepFileExt ?
        path.join(
          filenameObj.dir,
          filenameObj.name + this.lastTimeWeWroteSomething + filenameObj.ext
        ) :
        this.baseFilename + this.lastTimeWeWroteSomething;
      this.closeTheStream(
        this.compressIfNeeded.bind(this, filename,
          this.removeOldFilesIfNeeded.bind(this,
            this.openTheStream.bind(this, callback))));
    } else {
      var newFilename = this.options.keepFileExt ?
        path.join(filenameObj.dir, filenameObj.name + this.previousTime + filenameObj.ext) :
        this.baseFilename + this.previousTime;
      this.closeTheStream(
        deleteAnyExistingFile.bind(null,
          renameTheCurrentFile.bind(null,
            this.compressIfNeeded.bind(this, newFilename,
              this.removeOldFilesIfNeeded.bind(this,
                this.openTheStream.bind(this, callback))))));
    }
  
    function deleteAnyExistingFile(cb) {
      //on windows, you can get a EEXIST error if you rename a file to an existing file
      //so, we'll try to delete the file we're renaming to first
      fs.unlink(newFilename, function (err) {
  
        //ignore err: if we could not delete, it's most likely that it doesn't exist
        cb();
      });
    }
  
    function renameTheCurrentFile(cb) {
      debug("Renaming the ", filename, " -> ", newFilename);
      fs.rename(filename, newFilename, cb);
    }
  };
  
  DateRollingFileStream.prototype.compressIfNeeded = function (filename, cb) {
    debug("Checking if we need to compress the old file");
    if (this.options.compress) {
      this.compress(filename, cb);
    } else {
      cb();
    }
  };
  
  DateRollingFileStream.prototype.removeOldFilesIfNeeded = function (cb) {
    debug("Checking if we need to delete old files");
    if (this.options.daysToKeep && this.options.daysToKeep > 0) {
      var oldestDate = new Date(this.now() - (this.options.daysToKeep * (24 * 60 * 60 * 1000)));
      debug("Will delete any log files modified before ", oldestDate.toString());
  
      this.removeFilesOlderThan(oldestDate);
    }
    cb();
  };
  
  DateRollingFileStream.prototype.removeFilesOlderThan = function (oldestDate) {
  
    // Loop through any log files and delete any whose mtime is earlier than oldestDate
    var dirToScan = path.dirname(this.baseFilename);
    var fileToMatch = path.basename(this.baseFilename);
    var filesToCheck = fs.readdirSync(dirToScan).filter(function (file) {
      return file.indexOf(fileToMatch) > -1;
    });
    for (var i = 0; i < filesToCheck.length; i++) {
      var fileToCheck = path.join(dirToScan, filesToCheck[i]);
      var fileStats = fs.statSync(fileToCheck);
      if (fileStats.mtime < oldestDate) {
        debug("Deleting old log ", filesToCheck);
        fs.unlinkSync(fileToCheck);
      }
    }
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/streamroller/lib/RollingFileStream.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  var BaseRollingFileStream = __webpack_require__("./node_modules/streamroller/lib/BaseRollingFileStream.js")
  , debug = __webpack_require__("./node_modules/debug/src/index.js")('streamroller:RollingFileStream')
  , util = __webpack_require__("util")
  , path = __webpack_require__("path")
  , child_process = __webpack_require__("child_process")
  , fs = __webpack_require__("fs");
  
  module.exports = RollingFileStream;
  
  function RollingFileStream (filename, size, backups, options) {
    //if you don't specify a size, this will behave like a normal file stream
    this.size = size || Number.MAX_SAFE_INTEGER;
    this.backups = backups || 1;
  
    function throwErrorIfArgumentsAreNotValid() {
      if (!filename || size <= 0) {
        throw new Error("You must specify a filename and file size");
      }
    }
  
    throwErrorIfArgumentsAreNotValid();
  
    RollingFileStream.super_.call(this, filename, options);
  }
  util.inherits(RollingFileStream, BaseRollingFileStream);
  
  RollingFileStream.prototype.shouldRoll = function() {
    debug("should roll with current size ", this.currentSize, " and max size ", this.size);
    return this.currentSize >= this.size;
  };
  
  RollingFileStream.prototype.roll = function(filename, callback) {
    var that = this;
    var fileNameObj = path.parse(filename);
    var dir = fileNameObj.dir;
    var name = fileNameObj.name;
    var ext = fileNameObj.ext === '' ? '' : fileNameObj.ext.substring(1);
    var nameMatcher = new RegExp('^' + name);
  
  
    function justTheseFiles (item) {
      return nameMatcher.test(item);
    }
  
    function getExtensions(filename_) {
      return filename_.substring((name + '.').length).split('.');
    }
  
    function index(filename_) {
      debug('Calculating index of '+filename_);
      var exts = getExtensions(filename_);
      if (exts[exts.length - 1] === 'gz') {
        exts.pop();
      }
      if (that.options.keepFileExt) {
        return parseInt(exts[0], 10) || 0;
      } else {
        return parseInt(exts[exts.length - 1]) || 0;
      }
    }
  
    function byIndex(a, b) {
      if (index(a) > index(b)) {
        return 1;
      } else if (index(a) < index(b) ) {
        return -1;
      } else {
        return 0;
      }
    }
  
    function increaseFileIndex (fileToRename, cb) {
      var idx = index(fileToRename);
      debug('Index of ' + fileToRename + ' is ' + idx);
      if (idx < that.backups) {
        var newIdx =  (idx + 1).toString();
        var fileNameItems = [name];
        if (ext) {
          if (that.options.keepFileExt) {
            fileNameItems.push(newIdx, ext);
          } else {
            fileNameItems.push(ext, newIdx);
          }
        } else {
          fileNameItems.push(newIdx);
        }
        var destination = path.join(dir, fileNameItems.join('.'));
        if (that.options.compress && path.extname(fileToRename) === '.gz') {
            destination += '.gz';
        }
        //on windows, you can get a EEXIST error if you rename a file to an existing file
        //so, we'll try to delete the file we're renaming to first
        fs.unlink(destination, function (err) {
          //ignore err: if we could not delete, it's most likely that it doesn't exist
          debug('Renaming ' + fileToRename + ' -> ' + destination);
          fs.rename(path.join(dir, fileToRename), destination, function(err) {
            if (err) {
              cb(err);
            } else {
              if (that.options.compress && path.extname(fileToRename) !== '.gz') {
                that.compress(destination, cb);
              } else {
                cb();
              }
            }
          });
        });
      } else {
        cb();
      }
    }
  
    function renameTheFiles(cb) {
      //roll the backups (rename file.n to file.n+1, where n <= numBackups)
      debug("Renaming the old files");
      fs.readdir(path.dirname(filename), function (err, files) {
        if (err) {
          return cb(err);
        }
        var filesToProcess = files.filter(justTheseFiles).sort(byIndex);
        (function processOne(err) {
          var file = filesToProcess.pop();
          if (!file || err) { return cb(err); }
          increaseFileIndex(file, processOne);
        })();
      });
    }
  
    debug("Rolling, rolling, rolling");
    this.closeTheStream(
      renameTheFiles.bind(null,
        this.openTheStream.bind(this,
          callback)));
  
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/streamroller/lib/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  exports.RollingFileStream = __webpack_require__("./node_modules/streamroller/lib/RollingFileStream.js");
  exports.DateRollingFileStream = __webpack_require__("./node_modules/streamroller/lib/DateRollingFileStream.js");
  
  
  /***/ }),
  
  /***/ "./node_modules/strict-uri-encode/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  module.exports = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
  
  
  /***/ }),
  
  /***/ "./node_modules/supports-color/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  const os = __webpack_require__("os");
  const hasFlag = __webpack_require__("./node_modules/has-flag/index.js");
  
  const env = process.env;
  
  let forceColor;
  if (hasFlag('no-color') ||
  	hasFlag('no-colors') ||
  	hasFlag('color=false')) {
  	forceColor = false;
  } else if (hasFlag('color') ||
  	hasFlag('colors') ||
  	hasFlag('color=true') ||
  	hasFlag('color=always')) {
  	forceColor = true;
  }
  if ('FORCE_COLOR' in env) {
  	forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
  }
  
  function translateLevel(level) {
  	if (level === 0) {
  		return false;
  	}
  
  	return {
  		level,
  		hasBasic: true,
  		has256: level >= 2,
  		has16m: level >= 3
  	};
  }
  
  function supportsColor(stream) {
  	if (forceColor === false) {
  		return 0;
  	}
  
  	if (hasFlag('color=16m') ||
  		hasFlag('color=full') ||
  		hasFlag('color=truecolor')) {
  		return 3;
  	}
  
  	if (hasFlag('color=256')) {
  		return 2;
  	}
  
  	if (stream && !stream.isTTY && forceColor !== true) {
  		return 0;
  	}
  
  	const min = forceColor ? 1 : 0;
  
  	if (process.platform === 'win32') {
  		// Node.js 7.5.0 is the first version of Node.js to include a patch to
  		// libuv that enables 256 color output on Windows. Anything earlier and it
  		// won't work. However, here we target Node.js 8 at minimum as it is an LTS
  		// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
  		// release that supports 256 colors. Windows 10 build 14931 is the first release
  		// that supports 16m/TrueColor.
  		const osRelease = os.release().split('.');
  		if (
  			Number(process.versions.node.split('.')[0]) >= 8 &&
  			Number(osRelease[0]) >= 10 &&
  			Number(osRelease[2]) >= 10586
  		) {
  			return Number(osRelease[2]) >= 14931 ? 3 : 2;
  		}
  
  		return 1;
  	}
  
  	if ('CI' in env) {
  		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
  			return 1;
  		}
  
  		return min;
  	}
  
  	if ('TEAMCITY_VERSION' in env) {
  		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
  	}
  
  	if (env.COLORTERM === 'truecolor') {
  		return 3;
  	}
  
  	if ('TERM_PROGRAM' in env) {
  		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
  
  		switch (env.TERM_PROGRAM) {
  			case 'iTerm.app':
  				return version >= 3 ? 3 : 2;
  			case 'Apple_Terminal':
  				return 2;
  			// No default
  		}
  	}
  
  	if (/-256(color)?$/i.test(env.TERM)) {
  		return 2;
  	}
  
  	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
  		return 1;
  	}
  
  	if ('COLORTERM' in env) {
  		return 1;
  	}
  
  	if (env.TERM === 'dumb') {
  		return min;
  	}
  
  	return min;
  }
  
  function getSupportLevel(stream) {
  	const level = supportsColor(stream);
  	return translateLevel(level);
  }
  
  module.exports = {
  	supportsColor: getSupportLevel,
  	stdout: getSupportLevel(process.stdout),
  	stderr: getSupportLevel(process.stderr)
  };
  
  
  /***/ }),
  
  /***/ "./node_modules/util-deprecate/node.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  
  /**
   * For Node.js, simply re-export the core `util.deprecate` function.
   */
  
  module.exports = __webpack_require__("util").deprecate;
  
  
  /***/ }),
  
  /***/ "./simulator-sdk/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(__dirname) {
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.SDK = undefined;
  
  var _promise = __webpack_require__("./node_modules/babel-runtime/core-js/promise.js");
  
  var _promise2 = _interopRequireDefault(_promise);
  
  var _stringify = __webpack_require__("./node_modules/babel-runtime/core-js/json/stringify.js");
  
  var _stringify2 = _interopRequireDefault(_stringify);
  
  var _index = __webpack_require__("./src/main/api/index.js");
  
  var _util = __webpack_require__("./src/config/util.js");
  
  var _emitConst = __webpack_require__("./simulator-sdk/renderer/emitConst.js");
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  const { getStartPageFromMain, getStartPageFromMainAsync,
      startPageMainBack, closeMiniprogram } = __webpack_require__("./simulator-sdk/renderer/ipcConst.js");
  
  let path = __webpack_require__("path");
  let fse = __webpack_require__("fs-extra");
  let fs = __webpack_require__("fs");
  let unzip = __webpack_require__("unzipper");
  let Module = __webpack_require__("module");
  let { ipcMain, session } = __webpack_require__("electron");
  let ipc = ipcMain;
  
  let SDK = exports.SDK = class SDK {
      constructor(appInfo, container, logger) {
          this.container = container;
  
          this.windowId = container.id;
          this.appId = appInfo.appId;
          this.isIDE = appInfo.type === "IDE";
          this.URL = appInfo.URL;
          this.useDir = appInfo.useDir;
          this.projectName = appInfo.projectName;
          this.platform = appInfo.platform;
          this.isGame = appInfo.isGame;
          this.microZipUrl = appInfo.microZipUrl;
          this.startPage = appInfo.startPage;
          this.user_id = appInfo.user_id;
          this.logger = logger;
          this.machineArgs = {
              appType: appInfo.appType,
              resultPath: appInfo.resultPath,
              sourcePath: appInfo.sourcePath,
              communicationChannel: appInfo.communicationChannel
          };
      }
  
      init() {
          try {
              let url = "";
              if (this.isIDE) {
                  url = this.URL;
              } else {
                  url = `file://${(0, _util.getSDKPath)(false)}/dist/index.html?windowId=${this.windowId}`;
              }
              this.initSharedObject();
              this.logger && this.logger('[SDK-INFO] sdk init url:', url);
              this.container.loadURL(url);
          } catch (err) {
              this.logger && this.logger('[SDK-INFO] sdk init catch err:', err);
          }
          if (!global.logger) {
              global.logger = {};
              global.logger.info = this.logger;
          }
          this.initAll();
      }
  
      initAll() {
          this.initProjectInfo();
          this.initImgInfo();
          this.initAuthorize();
          this.getMicroAppZip();
          this.setCookieDomin();
          this.setCertificate();
          this.ensureFile();
          this.initIpc();
          this.initListener();
          this.initEnvironment();
          this.initDominList();
  
          this.saveLocalConfig();
      }
      setCookieDomin() {
          let projectInfo, current, project, port;
          let that = this;
          try {
              projectInfo = (0, _util.getProjectInfo)() || {};
              current = (0, _util.getCurrentHash)(projectInfo, this.windowId);
              project = projectInfo && projectInfo.project;
              if (project[current] && project[current].staticPort) {
                  port = project[current].staticPort;
              }
          } catch (err) {
              this.logger && this.logger('setCookieDomin getProjectInfo error', err);
          }
  
          let appId = this.appId;
  
          session.defaultSession.webRequest.onBeforeRequest(['*://*./*'], function (details, callback) {
              try {
                  var reqestUrl = details.url;
                  var filterDomain = ['ttfile://user/', 'ttfile://store/', 'http://user/', 'http://store/'];
  
                  for (var i = 0; i < filterDomain.length; i++) {
                      if (reqestUrl.indexOf(filterDomain[i]) !== -1) {
                          let dir = reqestUrl.indexOf('store') !== -1 ? 'store' : 'usr';
                          var redirect = `http://127.0.0.1:${port}/static/dist/public/ttFileSystemTmp/${current}/${dir}/`;
                          reqestUrl = reqestUrl.replace(filterDomain[i], redirect);
                          console.log(reqestUrl);
                          callback({ cancel: false, redirectURL: reqestUrl });
                          return;
                      }
                  }
                  callback({ cancel: false });
              } catch (err) {
                  console.error('setCookieDomin err', err);
              }
          });
  
          session.defaultSession.webRequest.onBeforeSendHeaders(function (details, callback) {
              if (false) {}
              if (details.requestHeaders && details.requestHeaders['x-devtools-request-cookie']) {
                  details.requestHeaders['Cookie'] = details.requestHeaders['x-devtools-request-cookie'];
                  delete details.requestHeaders['x-devtools-request-cookie'];
              }
              callback({ cancel: false, requestHeaders: details.requestHeaders });
          });
  
          session.defaultSession.webRequest.onHeadersReceived(function (details, callback) {
              details.responseHeaders['Access-Control-Allow-Origin'] = ['*'];
              details.responseHeaders['Access-Control-Allow-Headers'] = ['x-requested-with, x-devtools-request-cookie, accept, origin, content-type'];
              details.responseHeaders['Access-Control-Allow-Methods'] = ['OPTIONS, GET, PUT, POST, DELETE'];
  
              that.handleCookie(details.responseHeaders);
              callback({ cancel: false, responseHeaders: details.responseHeaders });
          });
      }
      setCertificate() {
          let that = this;
          this.container.webContents.session.setCertificateVerifyProc((request, callback) => {
              const flag = (0, _util.getUrlCheck)(that.windowId);
              if (!flag) {
                  callback(0);
              } else {
                  callback(3);
              }
          });
      }
      handleCookie(headers) {
          try {
              let headerMap = [];
              headerMap.push((0, _stringify2.default)(headers));
              headers['for-byte-devtools'] = headerMap;
              return headers;
          } catch (err) {
              console.error('handleCookie error', err);
          }
      }
      initDominList() {
          let that = this;
          let dominList = {
              'request': ["未设置"],
              'socket': ["未设置"],
              'upload': ["未设置"],
              'download': ["未设置"],
              'web-view': ["未设置"]
          };
  
          (0, _index.getWhiteDominList)(this.appId).then(res => {
              try {
                  let { error, data } = JSON.parse(res.data);
                  if (error !== 0) {
                      that.logger && that.logger('处理域名白名单接口调用失败');
                      that.saveDominList(dominList);
                      return;
                  }
                  dominList = data && data.domains;
                  that.saveDominList(dominList);
              } catch (err) {
                  that.logger && that.logger('处理域名白名单数据失败', err);
                  that.saveDominList(dominList);
              }
          }).catch(err => {
              that.logger && that.logger('获取白名单异常', err);
              that.saveDominList(dominList);
          });
      }
      initEmptyPro(projectInfo) {
          if (!projectInfo.project) {
              projectInfo.project = {};
          }
          if (!projectInfo.browserWindow) {
              projectInfo.browserWindow = {};
          }
      }
      saveDominList(dominList) {
          try {
              let projectInfo = (0, _util.getProjectInfo)() || {};
              this.initEmptyPro(projectInfo);
              let useDirHash = (0, _util.getHash)(this.useDir || this.microZipUrl);
              projectInfo.browserWindow[this.windowId] = useDirHash;
              if (!projectInfo.project[useDirHash]) {
                  projectInfo.project[useDirHash] = {
                      domains: dominList
                  };
              } else {
                  projectInfo.project[useDirHash].domains = dominList;
              }
              (0, _util.saveProjectInfo)(projectInfo);
          } catch (e) {
              this.logger && this.logger("saveDominList error====>", e.stack || e.message);
          }
      }
  
      initEnvironment() {
          let asarPath = path.resolve(__dirname, '../../../app.asar');
          const originalNodeModulePaths = Module._nodeModulePaths;
          Module._nodeModulePaths = function (from) {
              const paths = originalNodeModulePaths(from);
              const asarNodePath = `${asarPath}/node_modules`;
              if (!paths.includes(asarNodePath)) {
                  paths.push(asarNodePath);
              }
              return paths;
          };
      }
      ensureFile() {
          try {
              const downTmpFile = path.join((0, _util.getSDKPath)(), 'temFiles', 'download');
              const imgTmpFile = path.join((0, _util.getSDKPath)(), 'temFiles', 'temImages');
              !fs.existsSync(downTmpFile) && fse.ensureDirSync(downTmpFile);
              !fs.existsSync(imgTmpFile) && fse.ensureDirSync(imgTmpFile);
          } catch (error) {
              this.logger && this.logger('test: ensure dir fail', error);
          }
      }
  
      initListener() {
          this.container.on('close', () => {
              try {
                  this.removeCallBacks();
              } catch (err) {
                  this.logger && this.logger('going to close mainWindow err', this.container.id, err);
              }
          });
          this.container.webContents.on('devtools-reload-page', () => {
              try {
                  this.removeCallBacks();
              } catch (err) {
                  this.logger && this.logger('devtools-reload-page', this.container.id, err);
              }
          });
          this.container.on('closed', () => {
              this.logger && this.logger('mainWindow closed');
              try {
                  this.container = null;
  
                  let projectInfo = (0, _util.getProjectInfo)() || {};
                  let currentHash = (0, _util.getCurrentHash)(projectInfo, this.windowId);
                  let projectPath = path.join((0, _util.getSDKPath)(), 'temFiles', 'dist', 'public', currentHash);
                  this.logger && this.logger('projectPath', projectPath);
                  try {
                      fs.existsSync(projectPath) && fse.removeSync(projectPath);
                  } catch (err) {
                      this.logger && this.logger('删除编译后目录失败', err);
                  }
              } catch (err) {
                  this.logger && this.logger('close mainWindow error', err);
              }
          });
      }
      removeCallBacks() {
          this.container.webContents.session.webRequest.onBeforeSendHeaders(null);
          this.container.webContents.session.webRequest.onBeforeRequest(null);
          this.container.webContents.session.setCertificateVerifyProc(null);
      }
      initIpc() {
          var that = this;
  
          ipc && ipc.on(getStartPageFromMain, function (event, args) {
              event.returnValue = that.startPage || '';
          });
  
          ipc && ipc.on(getStartPageFromMainAsync, function (event, args) {
              let startPage = that.startPage || '';
              let mainWindow = that.container;
              that.logger && that.logger('initIpc mainWindow', typeof mainWindow);
              mainWindow && mainWindow.webContents.send(startPageMainBack, startPage);
          });
          ipc && ipc.on(closeMiniprogram, function (event, args) {
              that.container.close();
          });
      }
  
      unZipDir(zipPath, pagePath) {
          return new _promise2.default(function (resolve, reject) {
              fs.createReadStream(zipPath).pipe(unzip.Extract({ path: pagePath })).on('finish', function () {
                  console.log('unzip finish');
                  resolve(pagePath);
              }).on('error', function (err) {
                  reject(err);
              });
          });
      }
  
      getMicroAppZip() {
          if (!this.isIDE) {
              let that = this;
              _promise2.default.resolve().then(function () {
                  let zipPath = that.microZipUrl;
  
                  let pagePath = (0, _util.getProjectBuildUrl)(that.windowId);
  
                  !fs.existsSync(pagePath) && fse.ensureDirSync(pagePath);
                  return that.unZipDir(zipPath, pagePath);
              }).then(function (pagePath) {
                  let zipInterval;
                  ipc.on("cleanZipInterval", function () {
                      zipInterval && clearInterval(zipInterval);
                  });
                  zipInterval = setInterval(function () {
                      that.container.webContents.send(_emitConst.FRONT_GET_ZIP_DONE);
                  }, 400);
                  that.logger && that.logger('[SDK-INFO]mini-program解压成功', pagePath);
              }).catch(function (error) {
                  that.logger && that.logger('[SDK-INFO]下载失败', error);
              });
          }
      }
      static downLoad(options) {
          this.logger && this.logger('[SDK-INFO]mini-program下载', options);
          return (0, _util.downloadTask)(options);
      }
  
      initSharedObject() {
          let self = this;
          global.nativeSharedObject = {
              machineArgs: self.machineArgs,
              userInfo: userInfo,
              machineResult: null
          };
          console.log('....nativeSharedObject', global.nativeSharedObject);
      }
      initProjectInfo() {
          try {
              let projectInfo = (0, _util.getProjectInfo)() || {};
              this.initEmptyPro(projectInfo);
              let useDirHash;
              if (this.isIDE) {
                  useDirHash = (0, _util.getHash)(this.useDir || this.microZipUrl);
                  projectInfo.browserWindow[this.windowId] = useDirHash;
                  if (!projectInfo.project[useDirHash]) {
                      projectInfo.project[useDirHash] = {
                          useDir: this.useDir,
                          appId: this.appId,
                          useDirHash: useDirHash,
                          projectName: this.projectName,
                          updateTime: Date.now(),
                          currentNet: 'WiFi'
                      };
                  }
                  projectInfo.project[useDirHash].isGame = this.isGame;
              } else {
                  useDirHash = (0, _util.getHash)(this.useDir || this.microZipUrl);
                  projectInfo.browserWindow[this.windowId] = useDirHash;
                  if (!projectInfo.project[useDirHash]) {
                      projectInfo.project[useDirHash] = {
                          appId: this.appId,
                          useDirHash: useDirHash,
                          projectName: this.projectName,
                          updateTime: Date.now()
                      };
                  }
              }
              projectInfo.project[useDirHash].updateTime = Date.now();
              (0, _util.saveProjectInfo)(projectInfo);
          } catch (e) {
              this.logger && this.logger("initProjectInfo error====>", e.stack || e.message);
          }
      }
  
      initImgInfo() {
          let projectInfo = (0, _util.getImgFileInfo)() || {};
          this.initEmptyPro(projectInfo);
          let useDirHash;
  
          useDirHash = (0, _util.getHash)(this.useDir || this.microZipUrl);
          projectInfo.browserWindow[this.windowId] = useDirHash;
          if (!projectInfo.project[useDirHash]) {
              projectInfo.project[useDirHash] = {
                  useDir: this.useDir || this.microZipUrl,
                  useDirHash: useDirHash
              };
          }
          projectInfo.project[useDirHash].isGame = this.isGame;
          (0, _util.saveImgFileInfo)(projectInfo);
      }
  
      initAuthorize() {
          let authorizeInfo = (0, _util.getAuthorizeInfo)() || {};
          let uidAppidKey = this.user_id + this.appId;
          if (!authorizeInfo[uidAppidKey]) {
              authorizeInfo[uidAppidKey] = {};
          }
          if (!authorizeInfo["browserWindow"]) {
              authorizeInfo["browserWindow"] = {};
          }
          authorizeInfo.browserWindow[this.windowId] = uidAppidKey;
          (0, _util.saveAuthorizeInfo)(authorizeInfo);
      }
  
      saveLocalConfig() {
          let useDirHash = (0, _util.getHash)(this.useDir);
          let userConfigPath = path.join(this.useDir, 'project.config.json');
          let fileSystemPath = path.join((0, _util.getSDKPath)(), 'temFiles', 'dist', 'public', 'ttFileSystemTmp', useDirHash, 'projectConfig', 'project.config.json');
          if (fs.existsSync(userConfigPath)) {
              fse.copySync(userConfigPath, fileSystemPath);
          }
      }
  };
  /* WEBPACK VAR INJECTION */}.call(this, "simulator-sdk"))
  
  /***/ }),
  
  /***/ "./simulator-sdk/renderer/emitConst.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  const RELOAD_PAGE = exports.RELOAD_PAGE = 'reloadPage';
  
  const SWITCH_LAYOUT = exports.SWITCH_LAYOUT = 'switchLayout';
  
  const CHANGE_COMPILE = exports.CHANGE_COMPILE = 'changeCompile';
  
  const RENDER_TO_EDITOR_WEBVIEW = exports.RENDER_TO_EDITOR_WEBVIEW = 'sendToEditorWebview';
  
  const OPEN_LOCATION = exports.OPEN_LOCATION = 'openLocation';
  
  const SHOW_SETTING_WIN = exports.SHOW_SETTING_WIN = 'showSettingWindow';
  
  const OPEN_HEADER_MENU = exports.OPEN_HEADER_MENU = 'openHeaderMenu';
  
  const SET_LANDSCAPE = exports.SET_LANDSCAPE = 'setLandscape';
  
  const PAGE_LOADING = exports.PAGE_LOADING = 'pageLoading';
  
  const DID_NAVIGATE_BACK = exports.DID_NAVIGATE_BACK = 'didNavigateBack';
  
  const PAGE_NAVIGATE = exports.PAGE_NAVIGATE = 'pageNavigate';
  
  const SWITCH_TARGET = exports.SWITCH_TARGET = 'switchTarget';
  
  const INIT_CLOSE = exports.INIT_CLOSE = 'initClose';
  
  const INTERACTION = exports.INTERACTION = 'interaction';
  
  const SHOW_AUTHORIZE_WIN = exports.SHOW_AUTHORIZE_WIN = 'showAuthorizeWindow';
  
  const ROUTER_CHANGE = exports.ROUTER_CHANGE = 'routeChange';
  
  const NAV_BAR_COLOR = exports.NAV_BAR_COLOR = 'navigationBarColor';
  
  const WEBVIEW_COMP_SHOW = exports.WEBVIEW_COMP_SHOW = 'webviewComponentShow';
  
  const WEBVIEW_COMP_BACK = exports.WEBVIEW_COMP_BACK = 'webviewComponentBack';
  
  const FRONT_PULLDOWN_REFRESH = exports.FRONT_PULLDOWN_REFRESH = 'frontPullDownRefresh';
  const FRONT_GET_ZIP_DONE = exports.FRONT_GET_ZIP_DONE = 'frontGetZipDone';
  const FRONT_RESET_REFRESH = exports.FRONT_RESET_REFRESH = 'frontResetRefresh';const SWITCH_TAB = exports.SWITCH_TAB = 'switchTab';
  
  const PICKER_VIEW = exports.PICKER_VIEW = 'pickerView';
  
  const WEBVIEW_API = exports.WEBVIEW_API = 'webviewMessage';
  
  const FRONT_WEBVIEW_DOM_READY = exports.FRONT_WEBVIEW_DOM_READY = 'webviewDomReady';
  
  const BOTH_WEBVIEW_DOM_READY = exports.BOTH_WEBVIEW_DOM_READY = 'BothDocumentReady';
  
  const SET_WV_COMP_NAV_BAR_TITLE = exports.SET_WV_COMP_NAV_BAR_TITLE = 'setNavigationBarTitleComp';
  
  const WV_COMP_NAVIGATE = exports.WV_COMP_NAVIGATE = 'webviewComponentNavigate';
  
  const CREATE_PROJECT = exports.CREATE_PROJECT = 'createProject';
  
  const ENSURE_DOWNLOAD = exports.ENSURE_DOWNLOAD = 'ensureDownload';
  
  const RE_COMPILE = exports.RE_COMPILE = 'recompile';
  
  const SHOW_SCENE = exports.SHOW_SCENE = 'showScene';
  
  const UPDATECONFIG = exports.UPDATECONFIG = "update-project-config";
  
  /***/ }),
  
  /***/ "./simulator-sdk/renderer/ipcConst.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  exports.mainChannelSync = "webviewToMain-sync";
  exports.mainChannelAsync = "webviewToMain-async";
  exports.frontWebviewToEndWebview = "frontWebview-publish-to-endWebview";
  
  exports.bgMainChannelSync = "bg-webviewToMain-sync";
  exports.bgMainChannelAsync = "bg-webviewToMain-async";
  
  exports.webviewToRender = "webToMain";
  exports.showAuthorizeWindow = "showAuthorizeWindow";
  exports.showSettingWindow = "showSettingWindow";
  
  exports.compileChannelAsync = "compile-channel";
  exports.renderToBgWebviewForScene = "renderToBgWebview-forScene";
  
  exports.webviewChannelConsole = "webview-console-channel";
  exports.renderClearStorage = "renderClearStorage";
  
  exports.renderToForeEndWebview = "renderToForeEndWebview";
  
  exports.frontEndWebview = "endWebview-publish-to-frontWebview";
  
  exports.editorChannel = "editorChannel";
  
  exports.renderBeginCompile = "render:beginCompile";
  exports.updateWatcherStatus = "update:watcherStatus";
  exports.compileErrorMsg = "compile-log";
  exports.compileMsg = "compile";
  exports.compileWebviewToRender = "compileWebviewToRender";
  
  exports.sendCmd = "sendCmd";
  
  exports.getStartPageFromMainAsync = "getStartPageFromMainAsync";
  exports.startPageMainBack = "startPageMainBack";
  
  exports.getStartPageFromMain = "getStartPageFromMain";
  
  exports.closeMiniprogram = "closeMiniprogram";
  
  exports.getToutiaoLoginMibile = "get-toutiao-login-mobile";
  exports.getToutiaoLoginMobileDone = "get-toutiao-login-mobile-done";
  
  exports.getUserNameId = "get-username-id";
  exports.getUserNameIdDone = "get-username-id-done";
  
  exports.switchAccount = "switch-account";
  
  exports.getMicroAppInfo = "get-microApp-info";
  exports.getMicroAppInfoDone = "get-microApp-info-done";
  
  exports.jumpToMainPage = "click-jump-from-choosePage-to-mainPage";
  exports.jumpToMainPageFail = "click-jump-from-choosePage-to-mainPage-fail";
  
  exports.sideBarQuitApp = "sidebar-quit-app";
  
  exports.clearLoginState = "clear-login-state";
  exports.larkReLogin = "LARK-RE-LOGIN";
  exports.debugWindowStatus = "debug-Window-Status";
  
  exports.openExternalUrl = "open-external-url";
  
  exports.updateFrontWebviewDevtoolsDebuggerUrl = "updateFrontWebviewDevtoolsDebuggerUrl";
  
  exports.ideAutoUpdateUiReady = "ide-auto-updateui-ready";
  exports.ideAutoUpdateEnsureDownload = "ide-auto-update-ensure-download";
  exports.ideAutoUpdateRestart = "ide-auto-update-restart";
  exports.ideAutoUpdateHasNew = "ide-auto-update-hasnew";
  exports.ideAutoUpdateDownloadProgress = "ide-auto-update-downloadProgress";
  exports.ideAutoUpdateDownloadFail = "ide-auto-update-downloadFail";
  exports.ideAutoUpdateDownloadSuccess = "ide-auto-update-downloadSuccess";
  
  exports.previewImageRender = "previewImageRender";
  
  exports.chooseAddressEvType = 'chooseAddress';
  exports.openLocationEvType = 'openLocation';
  exports.setNavigationBarTitleEvType = "setNavigationBarTitle";
  exports.previewImageEvType = "previewImage";
  exports.makePhoneCallEvType = "makePhoneCall";
  exports.requestPaymentEvType = 'requestPayment';
  exports.requestGamePaymentEvType = 'requestGamePayment';
  
  /***/ }),
  
  /***/ "./simulator-sdk/renderer/teaConst.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  const IDE_MAINWINDOW_SHOW = exports.IDE_MAINWINDOW_SHOW = 'IDE_MAINWINDOW_SHOW';
  const IDE_FOLDERWINDOW_SHOW = exports.IDE_FOLDERWINDOW_SHOW = 'IDE_FOLDERWINDOW_SHOW';
  
  const IDE_UPDATEBASE = exports.IDE_UPDATEBASE = 'IDE_UPDATEBASE';
  const IDE_UPDATEBASE_SUCCESS = exports.IDE_UPDATEBASE_SUCCESS = 'IDE_UPDATEBASE_SUCCESS';
  const IDE_UPDATEBASE_FAIL = exports.IDE_UPDATEBASE_FAIL = 'IDE_UPDATEBASE_FAIL';
  
  const IDE_CHECKUPDATE_UPDATE_LATER = exports.IDE_CHECKUPDATE_UPDATE_LATER = 'IDE_CHECKUPDATE_UPDATE_LATER';
  
  const IDE_CHECKUPDATE_ENSURE_GO = exports.IDE_CHECKUPDATE_ENSURE_GO = 'IDE_CHECKUPDATE_ENSURE_GO';
  
  const IDE_CHECKUPDATE_RELAUNCH_LATER = exports.IDE_CHECKUPDATE_RELAUNCH_LATER = 'IDE_CHECKUPDATE_RELAUNCH_LATER';
  
  const IDE_CHECKUPDATE_RELAUNCH_NOW = exports.IDE_CHECKUPDATE_RELAUNCH_NOW = 'IDE_CHECKUPDATE_RELAUNCH_NOW';
  
  const IDE_CHECKUPDATE_MANNUAL_DOWNLOAD = exports.IDE_CHECKUPDATE_MANNUAL_DOWNLOAD = 'IDE_CHECKUPDATE_MANNUAL_DOWNLOAD';
  
  const IDE_CHECKUPDATE_RETRY_UPDATE = exports.IDE_CHECKUPDATE_RETRY_UPDATE = 'IDE_CHECKUPDATE_RETRY_UPDATE';
  
  const IDE_CLICK_PREVIEW = exports.IDE_CLICK_PREVIEW = 'IDE_CLICK_PREVIEW';
  
  const IDE_PREVIEW_SUCCESS = exports.IDE_PREVIEW_SUCCESS = 'IDE_PREVIEW_SUCCESS';
  
  const IDE_PREVIEW_FAIL = exports.IDE_PREVIEW_FAIL = 'IDE_PREVIEW_FAIL';
  
  const IDE_CLICK_UPLOAD = exports.IDE_CLICK_UPLOAD = 'IDE_CLICK_UPLOAD';
  
  const IDE_UPLOAD_SUCCESS = exports.IDE_UPLOAD_SUCCESS = 'IDE_UPLOAD_SUCCESS';
  
  const IDE_UPLOAD_FAIL = exports.IDE_UPLOAD_FAIL = 'IDE_UPLOAD_FAIL';
  
  const IDE_CLICK_REMOTE_DEBUG = exports.IDE_CLICK_REMOTE_DEBUG = 'IDE_CLICK_REMOTE_DEBUG';
  
  const IDE_REMOTE_DEBUG_SUCCESS = exports.IDE_REMOTE_DEBUG_SUCCESS = 'IDE_REMOTE_DEBUG_SUCCESS';
  
  const IDE_REMOTE_DEBUG_FAIL = exports.IDE_REMOTE_DEBUG_FAIL = 'IDE_REMOTE_DEBUG_FAIL';
  
  const IDE_CLICK_COMPILE = exports.IDE_CLICK_COMPILE = 'IDE_CLICK_COMPILE';
  
  const IDE_CLICK_CLEAR_CACHE = exports.IDE_CLICK_CLEAR_CACHE = 'IDE_CLICK_CLEAR_CACHE';
  
  const IDE_TOGGLE_IGNORE_DOMAIN_CHECK = exports.IDE_TOGGLE_IGNORE_DOMAIN_CHECK = 'IDE_TOGGLE_IGNORE_DOMAIN_CHECK';
  
  const IDE_SWITCH_ACCOUNT = exports.IDE_SWITCH_ACCOUNT = 'IDE_SWITCH_ACCOUNT';
  
  /***/ }),
  
  /***/ "./simulator-sdk/server/serverPortManager.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.getProjectPort = getProjectPort;
  function getProjectPort(getMethod, getCurrentHash) {
      let protjectInfo = getMethod();
      let current = getCurrentHash(protjectInfo);
      let project = protjectInfo.project;
      let port;
      if (project[current] && project[current].staticPort) {
          port = project[current].staticPort;
      }
      return port;
  }
  
  /***/ }),
  
  /***/ "./simulator-sdk/temFiles/dist/preload/initInvoke/common/customNet.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _stringify = __webpack_require__("./node_modules/babel-runtime/core-js/json/stringify.js");
  
  var _stringify2 = _interopRequireDefault(_stringify);
  
  var _promise = __webpack_require__("./node_modules/babel-runtime/core-js/promise.js");
  
  var _promise2 = _interopRequireDefault(_promise);
  
  exports.customNet = customNet;
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  const https = __webpack_require__("https");
  function extractHostname(options, cookies) {
      let hostname, noHostUrl, opts;
      let { url, method } = options;
      let urlParts = url.split('/');
  
      if (url.indexOf("//") > -1) {
          hostname = urlParts[2];
          noHostUrl = urlParts.slice(3).join('/');
      } else {
          hostname = urlParts[0];
          noHostUrl = urlParts.slice(1).join('/');
      }
  
      hostname = hostname.split(':')[0];
  
      hostname = hostname.split('?')[0];
  
      opts = {
          hostname,
          path: `/${noHostUrl}`,
          method: method,
          port: 443
      };
  
      return opts;
  }
  function customNet(options, body, cookies, logger) {
      let opts = extractHostname(options, cookies);
      return new _promise2.default(function (resolve, reject) {
          let buf = Buffer.alloc(0);
          const request = https.request(opts, response => {
              let res;
              response.on('data', chunk => {
                  buf = Buffer.concat([buf, Buffer.from(chunk)]);
              });
              response.on('end', () => {
                  let resDataObj = buf.toString();
  
                  if (response.statusCode === 200) {
                      res = {
                          data: resDataObj,
                          statusCode: response.statusCode
                      };
                      resolve(res);
                  } else {
                      res = {
                          data: response.statusMessage,
                          statusCode: response.statusCode
                      };
                      reject(res);
                  }
              });
              response.on('abort', () => {
                  console.log('请求已经被终止。');
              });
              response.on('error', error => {
                  console.log(`ERROR: ${(0, _stringify2.default)(error)}`);
                  logger && logger.info(`ERROR: ${(0, _stringify2.default)(error)}`);
                  reject(error);
              });
          });
          request.on('error', err => {
              logger && logger.info('net request fail', err);
              reject(err);
          });
          cookies && request.setHeader('Cookie', cookies.map(item => `${item.name}=${item.value}`).join('; '));
          if (options.method === "POST") {
              request.write(body);
          }
          request.end();
      });
  }
  
  /***/ }),
  
  /***/ "./src/config/url.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  const isStaging = "lark" === 'lark-staging';
  const isFr = "lark" === 'lark-fr';
  const appTypePath = `/api/v1/app`;
  const larkPrefix = isFr ? 'https://open.larksuite.com' : isStaging ? `https://lark-open-staging.bytedance.net` : `https://open.feishu.cn`;
  const larkHost = isFr ? 'open.larksuite.com' : isStaging ? 'lark-open-staging.bytedance.net' : 'open.feishu.cn';
  const larkLoginPrefix = isFr ? 'https://open.larksuite.com/open-apis/mina/' : isStaging ? 'https://mina-staging.bytedance.net/openapi' : 'https://open.feishu.cn/open-apis/mina';
  const larkLoginPage = isFr ? 'https://api.larksuite.com/suite/passport/page/sso/?redirect_uri=https%3A%2F%2Fopen.larksuite.com%2Fapi%2Fv2%2Fpassport%2Foauth%2Fcallback%2F%3Fnext%3Dhttps%253A%252F%252Fopen.larksuite.com%252Fpages%252Fide%252Flogin%252Fsuccess&client_id=QBndTH9uSTKMA2CHtbYCqQ&lang=zh-CN' : isStaging ? 'https://api-staging.zjurl.cn/suite/passport/page/sso/?client_id=r6spccSoSziiipeb2ekOzQ&redirect_uri=https%3A%2F%2Flark-open-staging.bytedance.net%2Fapi%2Fv2%2Fpassport%2Foauth%2Fcallback%2F%3Fnext%3Dhttps%253A%252F%252Flark-open-staging.bytedance.net%252Fpages%252Fide%252Flogin%252Fsuccess' : 'https://api.feishu.cn/suite/passport/page/login/?redirect_uri=https%3A%2F%2Fopen.feishu.cn%2Fpages%2Fide%2Flogin%2Fsuccess&sso=0&client_id=QBndTH9uSTKMA2CHtbYCqQ&lang=zh-CN';
  
  const larkSSOHost = isFr ? '.larksuite.com' : isStaging ? '.zjurl.cn' : '.feishu.cn';
  const URL_CONFIG = exports.URL_CONFIG = "lark".indexOf('lark') > -1 ? {
      productName: isFr ? '飞书开发者工具-FR' : isStaging ? '飞书开发者工具-staging' : '飞书开发者工具',
      cookieUrl: `${larkPrefix}`,
      apiCookieKey: isStaging ? 'oapi-session' : 'session',
      loginPage: larkLoginPage,
      metaUrl: appId => `${larkPrefix}/miniprogram/api/v3/app/${appId}/meta`,
      host: larkHost,
      uploadPath: appId => `/miniprogram/api/v3/app/${appId}/testing`,
      previewPath: appId => `/miniprogram/api/v3/app/${appId}/preview`,
      compileUrl: appId => `${larkPrefix}/miniprogram/api/v3/app/${appId}/compile_progress`,
      qrcodeUrl: (appId, version, startPage) => {
          if (startPage) {
              return `${larkPrefix}/miniprogram/api/v3/app/${appId}/qrcode/${version}?t=${new Date().getTime()}&start_page=${encodeURIComponent(startPage)}`;
          } else {
              return `${larkPrefix}/miniprogram/api/v3/app/${appId}/qrcode/${version}?t=${new Date().getTime()}`;
          }
      },
      permissionUrl: appId => `${larkPrefix}/miniprogram/api/v3/app/${appId}/permissions`,
      loginUrl: `${larkLoginPrefix}/login`,
      getUserInfoUrl: `${larkLoginPrefix}/getUserInfo`,
      userUrl: `${larkPrefix}/miniprogram/api/v3/user`,
      loginSucUrl: `${larkPrefix}/app`,
      appIdRule: /(tt|cli_)[0-9a-f]{16}/,
      cookieKey: 'session',
      cookieDomain: `${larkSSOHost}`,
      registerUrl: `${larkPrefix}/app`,
      versionUrl: `${larkPrefix}/app`,
      loginQrCodeUrl: `https://api${larkSSOHost}/suite/passport/qrlogin/token/`,
      qrCodeStatusUrl: `https://api${larkSSOHost}/suite/passport/qrlogin/login/`,
      chooseUser: `https://api${larkSSOHost}/suite/passport/login/app/`,
      qrcodeOriginUrl: (appId, version) => `${larkPrefix}/miniprogram/api/v3/app/${appId}/qrcode_url/${version}?t=${new Date().getTime()}`,
      noticeUrl: '',
      developerDocUrl: `${larkPrefix}/document/ukTMukTMukTM/uADOy4CM4IjLwgjM`,
      helpCenterUrl: `${larkPrefix}/document/uQjL04CN/ukzM04SOzQjL5MDN`
  } : {
      productName: '字节跳动开发者工具',
      cookieUrl: 'https://developer.toutiao.com',
      apiCookieKey: 'sdessionid',
      loginPage: 'https://developer.toutiao.com/ide-login/?service=https%3A%2F%2Fdeveloper.toutiao.com%2Ftma-ide-redirect',
      metaUrl: appId => `https://developer.toutiao.com/api/v1/app/${appId}/meta`,
      host: 'developer.toutiao.com',
      uploadPath: appId => `/api/v2/app/${appId}/testing`,
      previewPath: appId => `/api/v2/app/${appId}/preview`,
      compileUrl: appId => `${appTypePath}/${appId}/compile_progress`,
      qrcodeUrl: (appId, version, startPage) => {
          if (startPage) {
              return `${appTypePath}/${appId}/${version}/qrcode?t=${new Date().getTime()}&start_page=${encodeURIComponent(startPage)}`;
          } else {
              return `${appTypePath}/${appId}/${version}/qrcode?t=${new Date().getTime()}`;
          }
      },
      permissionUrl: appId => `${appTypePath}/${appId}/permissions`,
      getUserInfoUrl: 'https://developer.toutiao.com/api/apps/user/info',
      loginUrl: 'https://developer.toutiao.com/api/apps/login',
      roomUrl: 'http://gate.snssdk.com/debug_room_api/apply',
      userUrl: 'https://developer.toutiao.com/api/v1/user',
      appIdRule: /tt[0-9a-f]{16}/,
      cookieKey: 'sdessionid',
      cookieDomain: '.toutiao.com',
      registerUrl: 'https://developer.toutiao.com/app/applist',
      versionUrl: 'https://developer.toutiao.com/docs/devtool/versionUpdate.html',
      loginApiUrl: 'https://developer.toutiao.com/api/v1/passport/web/sms_login/?account_sdk_source=web',
      getSmsCodeApiUrl: 'https://developer.toutiao.com/api/v1/passport/web/send_code/?account_sdk_source=web&',
      qrcodeOriginUrl: (appId, version) => `${appTypePath}/${appId}/${version}/qrcode_url?t=${new Date().getTime()}`,
      noticeUrl: 'https://developer.toutiao.com/notifications',
      developerDocUrl: 'https://developer.toutiao.com/docs/framework/directory.html',
      helpCenterUrl: 'https://developer.toutiao.com/docs/feedback/faq.html',
      forumCenterUrl: 'https://forum.microapp.bytedance.com/#/new'
  };
  
  /***/ }),
  
  /***/ "./src/config/util.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(__dirname) {
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.isFunction = exports.isUndefined = exports.ipc = exports.ideVerUrl = exports.testAppId = exports.zipBasePort = exports.staticPort = exports.baseURL = exports.initUrl = exports.remoteDebugUrl = exports.importUrl = exports.middleUrl = exports.winURL = exports.urlPage = exports.PROJECT_INFO_PATH = exports.isDev = undefined;
  
  var _stringify = __webpack_require__("./node_modules/babel-runtime/core-js/json/stringify.js");
  
  var _stringify2 = _interopRequireDefault(_stringify);
  
  var _promise = __webpack_require__("./node_modules/babel-runtime/core-js/promise.js");
  
  var _promise2 = _interopRequireDefault(_promise);
  
  exports.getVersion = getVersion;
  exports.init = init;
  exports.initOnce = initOnce;
  exports.getCookies = getCookies;
  exports.formUrl = formUrl;
  exports.getSession = getSession;
  exports.downloadTask = downloadTask;
  exports.getPackageEnv = getPackageEnv;
  exports.copyBase = copyBase;
  exports.getSDKPath = getSDKPath;
  exports.saveProjectInfo = saveProjectInfo;
  exports.getCurrentHash = getCurrentHash;
  exports.getCurrentWindow = getCurrentWindow;
  exports.saveImgFileInfo = saveImgFileInfo;
  exports.getProjectInfo = getProjectInfo;
  exports.getAppId = getAppId;
  exports.getImgFileInfo = getImgFileInfo;
  exports.getAuthorizeInfo = getAuthorizeInfo;
  exports.saveAuthorizeInfo = saveAuthorizeInfo;
  exports.isLarge = isLarge;
  exports.getBigLocalBase = getBigLocalBase;
  exports.getProjectBuildUrl = getProjectBuildUrl;
  exports.getHash = getHash;
  exports.getStaticPort = getStaticPort;
  exports.getProjectHash = getProjectHash;
  exports.getPorjectBaserUrl = getPorjectBaserUrl;
  exports.getStaticServerHost = getStaticServerHost;
  exports.getDevtoolsPort = getDevtoolsPort;
  exports.handlePromise = handlePromise;
  exports.handleError = handleError;
  exports.notification = notification;
  exports.clearCookie = clearCookie;
  exports.clearSession = clearSession;
  exports.getInfoFromDir = getInfoFromDir;
  exports.surroundByTryCatch = surroundByTryCatch;
  exports.getUrlCheck = getUrlCheck;
  
  var _electron = __webpack_require__("electron");
  
  var _electron2 = _interopRequireDefault(_electron);
  
  var _crypto = __webpack_require__("crypto");
  
  var _crypto2 = _interopRequireDefault(_crypto);
  
  var _serverPortManager = __webpack_require__("./simulator-sdk/server/serverPortManager.js");
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  const { commonResourceType, commonGetCookies, commonClearCookie,
      commonFormUrl, commonGetSession, commonGetProjectInfo,
      commonSaveFile, commonGetProjectHash, commonGetCurrentHash,
      commonGetCurrentWindow, commonGetAuthorizeInfo, commonVersionCompare,
      commonGetBigLocalBase, commonGetPackageEnv, commonGetConfigFileInfo,
      commonGetInfoFromDir, updateAllCurrentJSSDKVersion } = __webpack_require__("./common/util.js");
  const { IDE_UPDATEBASE_SUCCESS, IDE_UPDATEBASE_FAIL } = __webpack_require__("./simulator-sdk/renderer/teaConst.js");
  let path = __webpack_require__("path");
  let fs = __webpack_require__("fs");
  let fse = __webpack_require__("fs-extra");
  let unzip = __webpack_require__("unzipper");
  let nodeNet = __webpack_require__("http");
  
  const isDev = exports.isDev = getPackageEnv() === 'development';
  const storagePath = _electron.app.getPath('userData');
  const PROJECT_INFO_DIR = path.join(storagePath, 'tmadevtool', 'projectInfo');
  
  const PROJECT_INFO_PATH = exports.PROJECT_INFO_PATH = path.join(storagePath, 'tmadevtool', 'projectInfo', 'projectInfo.json');
  
  const urlPage = exports.urlPage = isDev ? `http://localhost:9080/#/login` : `file://${getSDKPath(false)}/dist/index.html#/login`;
  
  const winURL = exports.winURL = isDev ? `http://localhost:9080` : `file://${getSDKPath(false)}/dist/index.html`;
  
  const middleUrl = exports.middleUrl = isDev ? `http://localhost:9080/#/projectmanager` : `file://${getSDKPath(false)}/dist/index.html#/projectmanager`;
  
  const importUrl = exports.importUrl = isDev ? `http://localhost:9080/#/importcode` : `file://${getSDKPath(false)}/dist/index.html#/importcode`;
  
  const remoteDebugUrl = exports.remoteDebugUrl = isDev ? `http://localhost:9080/#/remoteDebug` : `file://${getSDKPath(false)}/dist/index.html#/remoteDebug`;
  
  const initUrl = exports.initUrl = `file://${getSDKPath(false)}/temFiles/dist/common/init.html`;
  
  const baseURL = exports.baseURL = isDev ? 'http://10.8.124.71:12111' : 'https://developer.toutiao.com';
  
  const staticPort = exports.staticPort = 41351;
  
  const zipBasePort = exports.zipBasePort = 18241;
  
  const testAppId = exports.testAppId = '体验appId';
  
  const ideVerUrl = exports.ideVerUrl = 'https://developer.toutiao.com/api/v1/ide/version';
  
  const ipc = exports.ipc = _electron2.default.ipcMain;
  
  function getVersion() {
      let packagePath;
      if (true) {
          packagePath = path.resolve(__dirname, '../package.json');
      } else {}
      var packageContent = fs.readFileSync(packagePath).toString();
      var version, environment;
      if (typeof packageContent === 'string') {
          packageContent = JSON.parse(packageContent);
      }
      version = packageContent && packageContent.version;
      environment = packageContent && packageContent.environment;
      if (environment === 'test') {
          version = 'test';
      }
      return version;
  }
  
  function init(eventName, callback) {
      ipc.on(eventName, function (event, arg) {
          callback(event, arg);
      });
  }
  
  function initOnce(eventName, callback) {
      ipc.once(eventName, function (event, arg) {
          callback(event, arg);
      });
  }
  
  function getCookies(path) {
      return commonGetCookies(path);
  }
  
  function formUrl(url, query) {
      return commonFormUrl(url, query);
  }
  
  function getSession(domain, name) {
      return commonGetSession(domain, name);
  }
  
  function downloadTask(options) {
      return new _promise2.default(function (resolve, reject) {
          let out, tmpPath, request;
          try {
              request = _electron.net.request(options);
          } catch (error) {
              console.log('请求错误', error);
          }
          request.on('response', response => {
              let res, dotExt;
              let url = options.url.split('?')[0];
              let extname = path.extname(url);
              let baseName = path.basename(url, extname);
              let contentTypeHeader = response.headers && response.headers['content-type'] && response.headers['content-type'][0];
              if (contentTypeHeader) {
                  const typeHeader = contentTypeHeader.replace(/;.*/g, ''),
                        newExt = commonResourceType[typeHeader.toLowerCase()];
                  if (newExt) dotExt = `.${newExt}`;else {
                      let splitHeader = typeHeader.split('/');
                      splitHeader && splitHeader[1] && !/\-|\+/ig.test(splitHeader[1]) && (dotExt = `.${splitHeader[1]}`);
                  }
              }
              baseName = baseName + dotExt;
              const downTmpFile = path.join(getSDKPath(), 'temFiles', 'download');
              !fs.existsSync(downTmpFile) && fse.ensureDirSync(downTmpFile);
              tmpPath = path.join(downTmpFile, baseName);
              out = fs.createWriteStream(tmpPath);
              out && response.pipe(out);
              response.on('end', () => {
                  console.log('response请求中没有更多数据。');
                  if (response.statusCode === 200) {
                      res = {
                          tempFilePath: tmpPath
                      };
                      resolve(res);
                  } else {
                      res = { errMsg: '下载失败' };
                      reject(res);
                  }
              });
              response.on('abort', () => {
                  console.log('请求已经被终止。');
              });
              response.on('error', error => {
                  console.log(`ERROR: ${(0, _stringify2.default)(error)}`);
              });
          });
          request.on('error', error => {
              console.log(`请求出错: ${(0, _stringify2.default)(error)}`);
          });
          request.end();
      });
  }
  
  function getPackageEnv() {
      return commonGetPackageEnv();
  }
  
  function getUnzipPath() {
      let sdkPath = getSDKPath();
      let versionPath = path.join(sdkPath, 'temFiles', 'dist', 'common', 'base');
      if (getPackageEnv() === 'test') {
          versionPath = path.resolve(sdkPath, 'temFiles', 'dist', 'common', 'base', 'local_test');
      }
      !fs.existsSync(versionPath) && fse.ensureDirSync(versionPath);
      return versionPath;
  }
  
  function copyFile(newFile, oldFile) {
      return new _promise2.default(function (resolve, reject) {
          fse.copy(newFile, oldFile, function (err) {
              if (err) {
                  reject(err);
                  return;
              }
              resolve(true);
          });
      });
  }
  
  function portIsOccupied(port) {
      var server = nodeNet.createServer().listen(port);
      return new _promise2.default(function (resolve, reject) {
          server.on('listening', function () {
              server.close();
              console.log('The port【' + port + '】 is available.');
              resolve(false);
          });
  
          server.on('error', function (err) {
              if (err.code === 'EADDRINUSE') {
                  console.log('The port【' + port + '】 is occupied, please change other port.');
                  resolve(true);
              }
          });
      });
  }
  
  function downCopy(version, options) {
      downloadTask(options).then(function (res) {
          let zipPath = res.tempFilePath,
              newZipLL;
          let unZipPath = getUnzipPath();
          console.log('unZipPath', unZipPath, zipPath);
          let unZipDev = newZipLL = path.join(unZipPath, '__dev__');
          if (getPackageEnv() !== 'development') {
              newZipLL = path.join(unZipPath, version);
          }
          let oldZipLL = path.join(getSDKPath(), 'temFiles', 'dist', 'common', 'base', 'dev');
  
          fs.createReadStream(zipPath).pipe(unzip.Extract({ path: unZipPath })).on('finish', function () {
              if (getPackageEnv() !== 'development') {
                  try {
                      global.Tea.collectEvent(IDE_UPDATEBASE_SUCCESS);
                      fs.renameSync(unZipDev, newZipLL);
                      updateAllCurrentJSSDKVersion(version);
                  } catch (e) {
                      global.Tea.collectEvent(IDE_UPDATEBASE_FAIL);
                      global.reportError && global.reportError(e);
                      console.log('saveCurrentJSSDKVersion err', e);
                  }
              } else {
                  let newWbjs = path.join(newZipLL, 'webview.js');
                  let newWbcss = path.join(newZipLL, 'webview.css');
                  let newTCjs = path.join(newZipLL, 'tma-core.js');
                  let newGameJs = path.join(newZipLL, 'tmg-core.js');
                  let oldWbjs = path.join(oldZipLL, 'webview.js');
                  let oldWbcss = path.join(oldZipLL, 'webview.css');
                  let oldTCjs = path.join(oldZipLL, 'tma-core.js');
                  let oldGameJs = path.join(oldZipLL, 'tmg-core.js');
                  _promise2.default.all([copyFile(newWbjs, oldWbjs), copyFile(newTCjs, oldTCjs), copyFile(newGameJs, oldGameJs), copyFile(newWbcss, oldWbcss)]).then(function (res) {
                      console.log('res', res);
                  }).catch(function (err) {
                      console.log('err', err);
                  });
              }
          }).on('error', function (err) {
              console.log('err', err);
          });
      }).catch(function (error) {
          console.log('下载失败', error);
          global.Tea.collectEvent(IDE_UPDATEBASE_FAIL);
      });
  }
  function copyBase(version, url) {
      const options = {
          method: 'GET',
          url
      };
      let zipInterval;
      if (getPackageEnv() === 'development') {
          return portIsOccupied(zipBasePort).then(function (isOccupied) {
              if (isOccupied) {
                  zipInterval = setInterval(function () {
                      downCopy(version, options);
                  }, 10000);
                  return zipInterval;
              } else {
                  return zipInterval;
              }
          });
      } else {
          downCopy(version, options);
      }
      return zipInterval;
  }
  function getSDKPath(isForTemFiles = true) {
      if (true) {
          if (false) {} else {
              const sdkPath = path.resolve(path.join(require.resolve('@byted/simulator-sdk'), '..', '..'));
              return sdkPath.indexOf('app.asar.unpacked') > -1 ? sdkPath : sdkPath.replace('app.asar', 'app.asar.unpacked');
          }
      } else {}
  }
  
  function saveFile(dataStr, distPath) {
      commonSaveFile(dataStr, distPath);
  }
  
  
  function getFilePath(fileName) {
      let filePath = path.join(PROJECT_INFO_DIR, fileName);
      return filePath;
  }
  
  let filePath = getFilePath('projectInfo.json'),
      imgFilePath = getFilePath('imageInfo.json');
  
  function saveProjectInfo(data, path = filePath) {
      saveFile((0, _stringify2.default)(data), path);
  }
  
  function getCurrentHash(projectInfo, windowId = '') {
      return commonGetCurrentHash(projectInfo, windowId);
  }
  
  function getCurrentWindow() {
      return commonGetCurrentWindow();
  }
  
  function saveImgFileInfo(data) {
      saveFile((0, _stringify2.default)(data), imgFilePath);
  }
  
  function getProjectInfo(fileName) {
      return commonGetProjectInfo(fileName);
  }
  
  function getAppId() {
      let projectInfo = getProjectInfo();
      let currentHash = getCurrentHash(projectInfo);
      let appId = projectInfo.project[currentHash].appId;
      return appId;
  }
  
  function getImgFileInfo() {
      return getProjectInfo('imageInfo.json');
  }
  
  let authorizePath = path.join(getSDKPath(), 'temFiles', 'authorizeInfo', 'authorizeInfo.json');
  function getAuthorizeInfo() {
      return commonGetAuthorizeInfo(authorizePath);
  }
  
  function saveAuthorizeInfo(data) {
      saveFile((0, _stringify2.default)(data), authorizePath);
  }
  
  function isLarge(a, b) {
      return commonVersionCompare(a, b) > 0;
  }
  function getBigLocalBase() {
      let sdkPath = getSDKPath();
      return commonGetBigLocalBase(sdkPath);
  }
  
  function getProjectBuildUrl(windowId) {
      let projectInfo = getProjectInfo();
      let currentHash = getCurrentHash(projectInfo, windowId);
      let currentProject = projectInfo.project[currentHash];
      return path.join(getSDKPath(), 'temFiles/dist/public', currentProject.useDirHash);
  }
  
  function getHash(dataStr) {
      let hash = _crypto2.default.createHash('md5');
      hash.update(dataStr);
      return hash.digest('hex');
  }
  
  function getStaticPort() {
      let port = (0, _serverPortManager.getProjectPort)(getProjectInfo, getCurrentHash);
      return port;
  }
  
  function getProjectHash(isIDE = true) {
      return commonGetProjectHash(isIDE);
  }
  
  function getPorjectBaserUrl(isIDE) {
      return `http://127.0.0.1:${getStaticPort()}/static/dist/public/${getProjectHash(isIDE).useDirHash}/`;
  }
  
  function getStaticServerHost() {
      const staticPort = getStaticPort();
      return `http://127.0.0.1:${staticPort}/static`;
  }
  
  var portrange = 8090;
  
  function getDevtoolsPort() {
      var port = portrange;
      return new _promise2.default(function (resolve, reject) {
          var server = nodeNet.createServer();
          server.listen(port, '127.0.0.1', function (err) {
              server.once('close', function () {
                  portrange = port + 1;
                  resolve(port);
              });
              server.close();
          });
          server.on('error', function (err) {
              logger && logger.info('getDevtoolsPort error', err);
              portrange++;
              resolve();
          });
      }).then(function (portTem) {
          return portTem || getDevtoolsPort();
      });
  }
  
  function handlePromise(promise) {
      return promise.then(data => {
          return [null, data];
      }).catch(err => [err]);
  }
  
  function handleError(text, err) {
      logger && logger.info(`${text}:`, err);
  }
  
  function notification(title, body) {
      let notice = new _electron.Notification({
          title,
          body
      });
      notice.on('show', function () {});
      notice.show();
  }
  
  function clearCookie() {
      commonClearCookie();
  }
  
  function clearSession(windowId) {
      let projectInfo = getProjectInfo() || {};
      if (windowId) {
          clearLoginSessin(projectInfo, windowId);
      } else {
          const projectMap = projectInfo.project;
          for (let pro in projectMap) {
              delete projectMap[pro].session;
          }
      }
      saveProjectInfo(projectInfo);
  }
  
  function clearLoginSessin(projectInfo, windowId) {
      let currentHash = getCurrentHash(projectInfo, windowId);
      let currentObj = projectInfo.project[currentHash];
      if (currentObj && currentObj.session) {
          delete currentObj.session;
      }
      projectInfo.project[currentHash] = currentObj;
  }
  function getInfoFromDir(dir) {
      return commonGetInfoFromDir(dir);
  }
  
  function surroundByTryCatch(func, msg) {
      return function () {
          try {
              return func.apply(func, arguments);
          } catch (err) {
              if (Object.prototype.toString.apply(err) === '[object Error]') {
                  global.reportError && global.reportError(err);
                  logger && logger.info(`${msg}:`, err, global.reportError);
              }
          }
      };
  }
  
  function getUrlCheck(windowId) {
      const projectPath = (getCurrentObj(windowId) || {}).useDir;
      const proConfJSON = getConfigFileInfo(projectPath, windowId);
      const urlCheck = proConfJSON && proConfJSON.setting ? proConfJSON.setting.urlCheck : false || false;
      return urlCheck;
  }
  
  function getCurrentObj(windowId) {
      let projectInfo = getProjectInfo() || {};
      let currentHash = getCurrentHash(projectInfo, windowId);
      let currentObj = projectInfo.project[currentHash];
      return currentObj || {};
  }
  function getLocalConfigPath(windowId) {
      let sdkPath = getSDKPath();
      let currentObj = getCurrentObj(windowId);
      let userHash = currentObj.useDirHash;
      let localConfigPath = path.join(sdkPath, 'temFiles', 'dist', 'public', 'ttFileSystemTmp', userHash, 'projectConfig', 'project.config.json');
      return localConfigPath;
  }
  function getConfigFileInfo(projectPath, windowId) {
      let localConfigPath = getLocalConfigPath(windowId);
  
      return commonGetConfigFileInfo(projectPath, localConfigPath);
  }
  
  const isUndefined = exports.isUndefined = val => typeof val === 'undefined';
  const isFunction = exports.isFunction = val => typeof val === 'function';
  /* WEBPACK VAR INJECTION */}.call(this, "src/config"))
  
  /***/ }),
  
  /***/ "./src/main/api/index.js":
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _assign = __webpack_require__("./node_modules/babel-runtime/core-js/object/assign.js");
  
  var _assign2 = _interopRequireDefault(_assign);
  
  exports.getBaseVersion = getBaseVersion;
  exports.getUserInfo = getUserInfo;
  exports.getWhiteDominList = getWhiteDominList;
  
  var _util = __webpack_require__("./src/config/util.js");
  
  var _customNet = __webpack_require__("./simulator-sdk/temFiles/dist/preload/initInvoke/common/customNet.js");
  
  var _url = __webpack_require__("./src/config/url.js");
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  const { serialize } = __webpack_require__("./common/util.js");
  
  function getBaseVersion() {
      let url = 'https://is.snssdk.com/service/settings/v2/';
  
      let version_code = (0, _util.getVersion)();
      let params = { channel: '' };
      logger.info('process.env.NODE_ENV', "production", (0, _util.getPackageEnv)());
      if ((0, _util.getPackageEnv)() === 'test') {
          params.channel = 'local_test';
      }
      let query = {
          version_code,
          device_platform: 'IDE',
          device_id: 1,
          iid: 1,
          app: 1,
          aid: 13,
          caller_name: 'microapp_ide'
      };
      query = (0, _assign2.default)({}, params, query);
      url = serialize(url, query);
      const options = {
          method: 'GET',
          url: url
      };
      logger.info('getBaseVersion options', options);
      return (0, _customNet.customNet)(options, null, null, logger);
  }
  
  function getUserInfo() {
      let path = _url.URL_CONFIG.cookieUrl;
      const { userUrl } = _url.URL_CONFIG;
      return (0, _util.getCookies)(path).then(function (cookies) {
          const options = {
              method: 'GET',
              url: userUrl
          };
          return (0, _customNet.customNet)(options, null, cookies, logger);
      });
  }
  
  function getWhiteDominList(appid) {
      let path = _url.URL_CONFIG.cookieUrl;
      const metaUrl = _url.URL_CONFIG.metaUrl(appid);
      console.log('metaUrlmetaUrlmetaUrl', metaUrl);
      return (0, _util.getCookies)(path).then(function (cookies) {
          const options = {
              method: 'GET',
              url: metaUrl
          };
          return (0, _customNet.customNet)(options, null, cookies, logger);
      });
  }
  
  /***/ }),
  
  /***/ "buffer":
  /***/ (function(module, exports) {
  
  module.exports = require("buffer");
  
  /***/ }),
  
  /***/ "child_process":
  /***/ (function(module, exports) {
  
  module.exports = require("child_process");
  
  /***/ }),
  
  /***/ "cluster":
  /***/ (function(module, exports) {
  
  module.exports = require("cluster");
  
  /***/ }),
  
  /***/ "crypto":
  /***/ (function(module, exports) {
  
  module.exports = require("crypto");
  
  /***/ }),
  
  /***/ "electron":
  /***/ (function(module, exports) {
  
  module.exports = require("electron");
  
  /***/ }),
  
  /***/ "events":
  /***/ (function(module, exports) {
  
  module.exports = require("events");
  
  /***/ }),
  
  /***/ "fs":
  /***/ (function(module, exports) {
  
  module.exports = require("fs");
  
  /***/ }),
  
  /***/ "fs-extra":
  /***/ (function(module, exports) {
  
  module.exports = require("fs-extra");
  
  /***/ }),
  
  /***/ "http":
  /***/ (function(module, exports) {
  
  module.exports = require("http");
  
  /***/ }),
  
  /***/ "https":
  /***/ (function(module, exports) {
  
  module.exports = require("https");
  
  /***/ }),
  
  /***/ "module":
  /***/ (function(module, exports) {
  
  module.exports = require("module");
  
  /***/ }),
  
  /***/ "os":
  /***/ (function(module, exports) {
  
  module.exports = require("os");
  
  /***/ }),
  
  /***/ "path":
  /***/ (function(module, exports) {
  
  module.exports = require("path");
  
  /***/ }),
  
  /***/ "stream":
  /***/ (function(module, exports) {
  
  module.exports = require("stream");
  
  /***/ }),
  
  /***/ "tty":
  /***/ (function(module, exports) {
  
  module.exports = require("tty");
  
  /***/ }),
  
  /***/ "unzipper":
  /***/ (function(module, exports) {
  
  module.exports = require("unzipper");
  
  /***/ }),
  
  /***/ "util":
  /***/ (function(module, exports) {
  
  module.exports = require("util");
  
  /***/ }),
  
  /***/ "zlib":
  /***/ (function(module, exports) {
  
  module.exports = require("zlib");
  
  /***/ })
  
  /******/ });