up n_m

node_modules/react-loadable/lib/babel.js

@@ -0,0 +1,65 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = _default;
+
+function _default(_ref) {
+  var t = _ref.types,
+      template = _ref.template;
+  return {
+    visitor: {
+      ImportDeclaration: function ImportDeclaration(path) {
+        var source = path.node.source.value;
+        if (source !== 'react-loadable') return;
+        var defaultSpecifier = path.get('specifiers').find(function (specifier) {
+          return specifier.isImportDefaultSpecifier();
+        });
+        if (!defaultSpecifier) return;
+        var bindingName = defaultSpecifier.node.local.name;
+        var binding = path.scope.getBinding(bindingName);
+        binding.referencePaths.forEach(function (refPath) {
+          var callExpression = refPath.parentPath;
+
+          if (callExpression.isMemberExpression() && callExpression.node.computed === false && callExpression.get('property').isIdentifier({
+            name: 'Map'
+          })) {
+            callExpression = callExpression.parentPath;
+          }
+
+          if (!callExpression.isCallExpression()) return;
+          var args = callExpression.get('arguments');
+          if (args.length !== 1) throw callExpression.error;
+          var options = args[0];
+          if (!options.isObjectExpression()) return;
+          var properties = options.get('properties');
+          var propertiesMap = {};
+          properties.forEach(function (property) {
+            if (property.type !== 'SpreadProperty') {
+              var key = property.get('key');
+              propertiesMap[key.node.name] = property;
+            }
+          });
+
+          if (propertiesMap.webpack) {
+            return;
+          }
+
+          var loaderMethod = propertiesMap.loader.get('value');
+          var dynamicImports = [];
+          loaderMethod.traverse({
+            Import: function Import(path) {
+              dynamicImports.push(path.parentPath);
+            }
+          });
+          if (!dynamicImports.length) return;
+          propertiesMap.loader.insertAfter(t.objectProperty(t.identifier('webpack'), t.arrowFunctionExpression([], t.arrayExpression(dynamicImports.map(function (dynamicImport) {
+            return t.callExpression(t.memberExpression(t.identifier('require'), t.identifier('resolveWeak')), [dynamicImport.get('arguments')[0].node]);
+          })))));
+          propertiesMap.loader.insertAfter(t.objectProperty(t.identifier('modules'), t.arrayExpression(dynamicImports.map(function (dynamicImport) {
+            return dynamicImport.get('arguments')[0].node;
+          }))));
+        });
+      }
+    }
+  };
+}

node_modules/react-loadable/lib/index.js

@@ -0,0 +1,356 @@
+"use strict";
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+var React = require("react");
+
+var PropTypes = require("prop-types");
+
+var ALL_INITIALIZERS = [];
+var READY_INITIALIZERS = [];
+
+function isWebpackReady(getModuleIds) {
+  if (typeof __webpack_modules__ !== "object") {
+    return false;
+  }
+
+  return getModuleIds().every(function (moduleId) {
+    return typeof moduleId !== "undefined" && typeof __webpack_modules__[moduleId] !== "undefined";
+  });
+}
+
+function load(loader) {
+  var promise = loader();
+  var state = {
+    loading: true,
+    loaded: null,
+    error: null
+  };
+  state.promise = promise.then(function (loaded) {
+    state.loading = false;
+    state.loaded = loaded;
+    return loaded;
+  }).catch(function (err) {
+    state.loading = false;
+    state.error = err;
+    throw err;
+  });
+  return state;
+}
+
+function loadMap(obj) {
+  var state = {
+    loading: false,
+    loaded: {},
+    error: null
+  };
+  var promises = [];
+
+  try {
+    Object.keys(obj).forEach(function (key) {
+      var result = load(obj[key]);
+
+      if (!result.loading) {
+        state.loaded[key] = result.loaded;
+        state.error = result.error;
+      } else {
+        state.loading = true;
+      }
+
+      promises.push(result.promise);
+      result.promise.then(function (res) {
+        state.loaded[key] = res;
+      }).catch(function (err) {
+        state.error = err;
+      });
+    });
+  } catch (err) {
+    state.error = err;
+  }
+
+  state.promise = Promise.all(promises).then(function (res) {
+    state.loading = false;
+    return res;
+  }).catch(function (err) {
+    state.loading = false;
+    throw err;
+  });
+  return state;
+}
+
+function resolve(obj) {
+  return obj && obj.__esModule ? obj.default : obj;
+}
+
+function render(loaded, props) {
+  return React.createElement(resolve(loaded), props);
+}
+
+function createLoadableComponent(loadFn, options) {
+  var _class, _temp;
+
+  if (!options.loading) {
+    throw new Error("react-loadable requires a `loading` component");
+  }
+
+  var opts = _extends({
+    loader: null,
+    loading: null,
+    delay: 200,
+    timeout: null,
+    render: render,
+    webpack: null,
+    modules: null
+  }, options);
+
+  var res = null;
+
+  function init() {
+    if (!res) {
+      res = loadFn(opts.loader);
+    }
+
+    return res.promise;
+  }
+
+  ALL_INITIALIZERS.push(init);
+
+  if (typeof opts.webpack === "function") {
+    READY_INITIALIZERS.push(function () {
+      if (isWebpackReady(opts.webpack)) {
+        return init();
+      }
+    });
+  }
+
+  return _temp = _class =
+  /*#__PURE__*/
+  function (_React$Component) {
+    _inheritsLoose(LoadableComponent, _React$Component);
+
+    function LoadableComponent(props) {
+      var _this;
+
+      _this = _React$Component.call(this, props) || this;
+
+      _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "retry", function () {
+        _this.setState({
+          error: null,
+          loading: true,
+          timedOut: false
+        });
+
+        res = loadFn(opts.loader);
+
+        _this._loadModule();
+      });
+
+      init();
+      _this.state = {
+        error: res.error,
+        pastDelay: false,
+        timedOut: false,
+        loading: res.loading,
+        loaded: res.loaded
+      };
+      return _this;
+    }
+
+    LoadableComponent.preload = function preload() {
+      return init();
+    };
+
+    var _proto = LoadableComponent.prototype;
+
+    _proto.UNSAFE_componentWillMount = function UNSAFE_componentWillMount() {
+      this._loadModule();
+    };
+
+    _proto.componentDidMount = function componentDidMount() {
+      this._mounted = true;
+    };
+
+    _proto._loadModule = function _loadModule() {
+      var _this2 = this;
+
+      if (this.context.loadable && Array.isArray(opts.modules)) {
+        opts.modules.forEach(function (moduleName) {
+          _this2.context.loadable.report(moduleName);
+        });
+      }
+
+      if (!res.loading) {
+        return;
+      }
+
+      var setStateWithMountCheck = function setStateWithMountCheck(newState) {
+        if (!_this2._mounted) {
+          return;
+        }
+
+        _this2.setState(newState);
+      };
+
+      if (typeof opts.delay === 'number') {
+        if (opts.delay === 0) {
+          this.setState({
+            pastDelay: true
+          });
+        } else {
+          this._delay = setTimeout(function () {
+            setStateWithMountCheck({
+              pastDelay: true
+            });
+          }, opts.delay);
+        }
+      }
+
+      if (typeof opts.timeout === "number") {
+        this._timeout = setTimeout(function () {
+          setStateWithMountCheck({
+            timedOut: true
+          });
+        }, opts.timeout);
+      }
+
+      var update = function update() {
+        setStateWithMountCheck({
+          error: res.error,
+          loaded: res.loaded,
+          loading: res.loading
+        });
+
+        _this2._clearTimeouts();
+      };
+
+      res.promise.then(function () {
+        update();
+        return null;
+      }).catch(function (err) {
+        update();
+        return null;
+      });
+    };
+
+    _proto.componentWillUnmount = function componentWillUnmount() {
+      this._mounted = false;
+
+      this._clearTimeouts();
+    };
+
+    _proto._clearTimeouts = function _clearTimeouts() {
+      clearTimeout(this._delay);
+      clearTimeout(this._timeout);
+    };
+
+    _proto.render = function render() {
+      if (this.state.loading || this.state.error) {
+        return React.createElement(opts.loading, {
+          isLoading: this.state.loading,
+          pastDelay: this.state.pastDelay,
+          timedOut: this.state.timedOut,
+          error: this.state.error,
+          retry: this.retry
+        });
+      } else if (this.state.loaded) {
+        return opts.render(this.state.loaded, this.props);
+      } else {
+        return null;
+      }
+    };
+
+    return LoadableComponent;
+  }(React.Component), _defineProperty(_class, "contextTypes", {
+    loadable: PropTypes.shape({
+      report: PropTypes.func.isRequired
+    })
+  }), _temp;
+}
+
+function Loadable(opts) {
+  return createLoadableComponent(load, opts);
+}
+
+function LoadableMap(opts) {
+  if (typeof opts.render !== "function") {
+    throw new Error("LoadableMap requires a `render(loaded, props)` function");
+  }
+
+  return createLoadableComponent(loadMap, opts);
+}
+
+Loadable.Map = LoadableMap;
+
+var Capture =
+/*#__PURE__*/
+function (_React$Component2) {
+  _inheritsLoose(Capture, _React$Component2);
+
+  function Capture() {
+    return _React$Component2.apply(this, arguments) || this;
+  }
+
+  var _proto2 = Capture.prototype;
+
+  _proto2.getChildContext = function getChildContext() {
+    return {
+      loadable: {
+        report: this.props.report
+      }
+    };
+  };
+
+  _proto2.render = function render() {
+    return React.Children.only(this.props.children);
+  };
+
+  return Capture;
+}(React.Component);
+
+_defineProperty(Capture, "propTypes", {
+  report: PropTypes.func.isRequired
+});
+
+_defineProperty(Capture, "childContextTypes", {
+  loadable: PropTypes.shape({
+    report: PropTypes.func.isRequired
+  }).isRequired
+});
+
+Loadable.Capture = Capture;
+
+function flushInitializers(initializers) {
+  var promises = [];
+
+  while (initializers.length) {
+    var init = initializers.pop();
+    promises.push(init());
+  }
+
+  return Promise.all(promises).then(function () {
+    if (initializers.length) {
+      return flushInitializers(initializers);
+    }
+  });
+}
+
+Loadable.preloadAll = function () {
+  return new Promise(function (resolve, reject) {
+    flushInitializers(ALL_INITIALIZERS).then(resolve, reject);
+  });
+};
+
+Loadable.preloadReady = function () {
+  return new Promise(function (resolve, reject) {
+    // We always will resolve, errors should be handled within loading UIs.
+    flushInitializers(READY_INITIALIZERS).then(resolve, resolve);
+  });
+};
+
+module.exports = Loadable;

node_modules/react-loadable/lib/webpack.js

@@ -0,0 +1,79 @@
+'use strict';
+
+var url = require('url');
+
+function buildManifest(compiler, compilation) {
+  var context = compiler.options.context;
+  var manifest = {};
+  compilation.chunks.forEach(function (chunk) {
+    chunk.files.forEach(function (file) {
+      chunk.forEachModule(function (module) {
+        var id = module.id;
+        var name = typeof module.libIdent === 'function' ? module.libIdent({
+          context: context
+        }) : null;
+        var publicPath = url.resolve(compilation.outputOptions.publicPath || '', file);
+        var currentModule = module;
+
+        if (module.constructor.name === 'ConcatenatedModule') {
+          currentModule = module.rootModule;
+        }
+
+        if (!manifest[currentModule.rawRequest]) {
+          manifest[currentModule.rawRequest] = [];
+        }
+
+        manifest[currentModule.rawRequest].push({
+          id: id,
+          name: name,
+          file: file,
+          publicPath: publicPath
+        });
+      });
+    });
+  });
+  return manifest;
+}
+
+var ReactLoadablePlugin =
+/*#__PURE__*/
+function () {
+  function ReactLoadablePlugin(opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+
+    this.filename = opts.filename;
+  }
+
+  var _proto = ReactLoadablePlugin.prototype;
+
+  _proto.apply = function apply(compiler) {
+    var _this = this;
+
+    compiler.plugin('emit', function (compilation, callback) {
+      var manifest = buildManifest(compiler, compilation);
+      var json = JSON.stringify(manifest, null, 2);
+      compilation.assets[_this.filename] = {
+        source: function source() {
+          return json;
+        },
+        size: function size() {
+          return json.length;
+        }
+      };
+      callback();
+    });
+  };
+
+  return ReactLoadablePlugin;
+}();
+
+function getBundles(manifest, moduleIds) {
+  return moduleIds.reduce(function (bundles, moduleId) {
+    return bundles.concat(manifest[moduleId]);
+  }, []);
+}
+
+exports.ReactLoadablePlugin = ReactLoadablePlugin;
+exports.getBundles = getBundles;