(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('hoist-non-react-statics')) :
  typeof define === 'function' && define.amd ? define(['exports', 'react', 'hoist-non-react-statics'], factory) :
  (global = global || self, factory(global.loadable = {}, global.React, global.hoistNonReactStatics));
}(this, (function (exports, React, hoistNonReactStatics) { 'use strict';

  React = React && React.hasOwnProperty('default') ? React['default'] : React;
  hoistNonReactStatics = hoistNonReactStatics && hoistNonReactStatics.hasOwnProperty('default') ? hoistNonReactStatics['default'] : hoistNonReactStatics;

  /* eslint-disable import/prefer-default-export */
  function invariant(condition, message) {
    if (condition) return;
    var error = new Error("loadable: " + message);
    error.framesToPop = 1;
    error.name = 'Invariant Violation';
    throw error;
  }
  function warn(message) {
    // eslint-disable-next-line no-console
    console.warn("loadable: " + message);
  }

  var Context = /*#__PURE__*/
  React.createContext();

  var LOADABLE_REQUIRED_CHUNKS_KEY = '__LOADABLE_REQUIRED_CHUNKS__';
  function getRequiredChunkKey(namespace) {
    return "" + namespace + LOADABLE_REQUIRED_CHUNKS_KEY;
  }

  var sharedInternals = /*#__PURE__*/Object.freeze({
    __proto__: null,
    getRequiredChunkKey: getRequiredChunkKey,
    invariant: invariant,
    Context: Context
  });

  function _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;

    for (i = 0; i < sourceKeys.length; i++) {
      key = sourceKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      target[key] = source[key];
    }

    return target;
  }

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

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function _inheritsLoose(subClass, superClass) {
    subClass.prototype = Object.create(superClass.prototype);
    subClass.prototype.constructor = subClass;
    subClass.__proto__ = superClass;
  }

  function unwrapExports (x) {
  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
  }

  function createCommonjsModule(fn, module) {
  	return module = { exports: {} }, fn(module, module.exports), module.exports;
  }

  var reactIs_production_min = createCommonjsModule(function (module, exports) {

  Object.defineProperty(exports, "__esModule", {
    value: !0
  });
  var b = "function" === typeof Symbol && Symbol["for"],
      c = b ?
  /*#__PURE__*/
  Symbol["for"]("react.element") : 60103,
      d = b ?
  /*#__PURE__*/
  Symbol["for"]("react.portal") : 60106,
      e = b ?
  /*#__PURE__*/
  Symbol["for"]("react.fragment") : 60107,
      f = b ?
  /*#__PURE__*/
  Symbol["for"]("react.strict_mode") : 60108,
      g = b ?
  /*#__PURE__*/
  Symbol["for"]("react.profiler") : 60114,
      h = b ?
  /*#__PURE__*/
  Symbol["for"]("react.provider") : 60109,
      k = b ?
  /*#__PURE__*/
  Symbol["for"]("react.context") : 60110,
      l = b ?
  /*#__PURE__*/
  Symbol["for"]("react.async_mode") : 60111,
      m = b ?
  /*#__PURE__*/
  Symbol["for"]("react.concurrent_mode") : 60111,
      n = b ?
  /*#__PURE__*/
  Symbol["for"]("react.forward_ref") : 60112,
      p = b ?
  /*#__PURE__*/
  Symbol["for"]("react.suspense") : 60113,
      q = b ?
  /*#__PURE__*/
  Symbol["for"]("react.suspense_list") : 60120,
      r = b ?
  /*#__PURE__*/
  Symbol["for"]("react.memo") : 60115,
      t = b ?
  /*#__PURE__*/
  Symbol["for"]("react.lazy") : 60116,
      v = b ?
  /*#__PURE__*/
  Symbol["for"]("react.fundamental") : 60117,
      w = b ?
  /*#__PURE__*/
  Symbol["for"]("react.responder") : 60118,
      x = b ?
  /*#__PURE__*/
  Symbol["for"]("react.scope") : 60119;

  function y(a) {
    if ("object" === typeof a && null !== a) {
      var u = a.$$typeof;

      switch (u) {
        case c:
          switch (a = a.type, a) {
            case l:
            case m:
            case e:
            case g:
            case f:
            case p:
              return a;

            default:
              switch (a = a && a.$$typeof, a) {
                case k:
                case n:
                case t:
                case r:
                case h:
                  return a;

                default:
                  return u;
              }

          }

        case d:
          return u;
      }
    }
  }

  function z(a) {
    return y(a) === m;
  }

  exports.typeOf = y;
  exports.AsyncMode = l;
  exports.ConcurrentMode = m;
  exports.ContextConsumer = k;
  exports.ContextProvider = h;
  exports.Element = c;
  exports.ForwardRef = n;
  exports.Fragment = e;
  exports.Lazy = t;
  exports.Memo = r;
  exports.Portal = d;
  exports.Profiler = g;
  exports.StrictMode = f;
  exports.Suspense = p;

  exports.isValidElementType = function (a) {
    return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === v || a.$$typeof === w || a.$$typeof === x);
  };

  exports.isAsyncMode = function (a) {
    return z(a) || y(a) === l;
  };

  exports.isConcurrentMode = z;

  exports.isContextConsumer = function (a) {
    return y(a) === k;
  };

  exports.isContextProvider = function (a) {
    return y(a) === h;
  };

  exports.isElement = function (a) {
    return "object" === typeof a && null !== a && a.$$typeof === c;
  };

  exports.isForwardRef = function (a) {
    return y(a) === n;
  };

  exports.isFragment = function (a) {
    return y(a) === e;
  };

  exports.isLazy = function (a) {
    return y(a) === t;
  };

  exports.isMemo = function (a) {
    return y(a) === r;
  };

  exports.isPortal = function (a) {
    return y(a) === d;
  };

  exports.isProfiler = function (a) {
    return y(a) === g;
  };

  exports.isStrictMode = function (a) {
    return y(a) === f;
  };

  exports.isSuspense = function (a) {
    return y(a) === p;
  };
  });

  unwrapExports(reactIs_production_min);
  var reactIs_production_min_1 = reactIs_production_min.typeOf;
  var reactIs_production_min_2 = reactIs_production_min.AsyncMode;
  var reactIs_production_min_3 = reactIs_production_min.ConcurrentMode;
  var reactIs_production_min_4 = reactIs_production_min.ContextConsumer;
  var reactIs_production_min_5 = reactIs_production_min.ContextProvider;
  var reactIs_production_min_6 = reactIs_production_min.Element;
  var reactIs_production_min_7 = reactIs_production_min.ForwardRef;
  var reactIs_production_min_8 = reactIs_production_min.Fragment;
  var reactIs_production_min_9 = reactIs_production_min.Lazy;
  var reactIs_production_min_10 = reactIs_production_min.Memo;
  var reactIs_production_min_11 = reactIs_production_min.Portal;
  var reactIs_production_min_12 = reactIs_production_min.Profiler;
  var reactIs_production_min_13 = reactIs_production_min.StrictMode;
  var reactIs_production_min_14 = reactIs_production_min.Suspense;
  var reactIs_production_min_15 = reactIs_production_min.isValidElementType;
  var reactIs_production_min_16 = reactIs_production_min.isAsyncMode;
  var reactIs_production_min_17 = reactIs_production_min.isConcurrentMode;
  var reactIs_production_min_18 = reactIs_production_min.isContextConsumer;
  var reactIs_production_min_19 = reactIs_production_min.isContextProvider;
  var reactIs_production_min_20 = reactIs_production_min.isElement;
  var reactIs_production_min_21 = reactIs_production_min.isForwardRef;
  var reactIs_production_min_22 = reactIs_production_min.isFragment;
  var reactIs_production_min_23 = reactIs_production_min.isLazy;
  var reactIs_production_min_24 = reactIs_production_min.isMemo;
  var reactIs_production_min_25 = reactIs_production_min.isPortal;
  var reactIs_production_min_26 = reactIs_production_min.isProfiler;
  var reactIs_production_min_27 = reactIs_production_min.isStrictMode;
  var reactIs_production_min_28 = reactIs_production_min.isSuspense;

  var reactIs_development = createCommonjsModule(function (module, exports) {

  {
    (function () {

      Object.defineProperty(exports, '__esModule', {
        value: true
      }); // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
      // nor polyfill, then a plain number is used for performance.

      var hasSymbol = typeof Symbol === 'function' && Symbol["for"];
      var REACT_ELEMENT_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.element') : 0xeac7;
      var REACT_PORTAL_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.portal') : 0xeaca;
      var REACT_FRAGMENT_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.fragment') : 0xeacb;
      var REACT_STRICT_MODE_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.strict_mode') : 0xeacc;
      var REACT_PROFILER_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.profiler') : 0xead2;
      var REACT_PROVIDER_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.provider') : 0xeacd;
      var REACT_CONTEXT_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
      // (unstable) APIs that have been removed. Can we remove the symbols?

      var REACT_ASYNC_MODE_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.async_mode') : 0xeacf;
      var REACT_CONCURRENT_MODE_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.concurrent_mode') : 0xeacf;
      var REACT_FORWARD_REF_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.forward_ref') : 0xead0;
      var REACT_SUSPENSE_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.suspense') : 0xead1;
      var REACT_SUSPENSE_LIST_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.suspense_list') : 0xead8;
      var REACT_MEMO_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.memo') : 0xead3;
      var REACT_LAZY_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.lazy') : 0xead4;
      var REACT_FUNDAMENTAL_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.fundamental') : 0xead5;
      var REACT_RESPONDER_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.responder') : 0xead6;
      var REACT_SCOPE_TYPE = hasSymbol ?
      /*#__PURE__*/
      Symbol["for"]('react.scope') : 0xead7;

      function isValidElementType(type) {
        return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
        type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE);
      }
      /**
       * Forked from fbjs/warning:
       * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
       *
       * Only change is we use console.warn instead of console.error,
       * and do nothing when 'console' is not supported.
       * This really simplifies the code.
       * ---
       * Similar to invariant but only logs a warning if the condition is not met.
       * This can be used to log issues in development environments in critical
       * paths. Removing the logging code for production environments will keep the
       * same logic and follow the same code paths.
       */


      var lowPriorityWarningWithoutStack = function lowPriorityWarningWithoutStack() {};

      {
        var printWarning = function printWarning(format) {
          for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
          }

          var argIndex = 0;
          var message = 'Warning: ' + format.replace(/%s/g, function () {
            return args[argIndex++];
          });

          if (typeof console !== 'undefined') {
            console.warn(message);
          }

          try {
            // --- Welcome to debugging React ---
            // This error was thrown as a convenience so that you can use this stack
            // to find the callsite that caused this warning to fire.
            throw new Error(message);
          } catch (x) {}
        };

        lowPriorityWarningWithoutStack = function lowPriorityWarningWithoutStack(condition, format) {
          if (format === undefined) {
            throw new Error('`lowPriorityWarningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');
          }

          if (!condition) {
            for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
              args[_key2 - 2] = arguments[_key2];
            }

            printWarning.apply(void 0, [format].concat(args));
          }
        };
      }
      var lowPriorityWarningWithoutStack$1 = lowPriorityWarningWithoutStack;

      function typeOf(object) {
        if (typeof object === 'object' && object !== null) {
          var $$typeof = object.$$typeof;

          switch ($$typeof) {
            case REACT_ELEMENT_TYPE:
              var type = object.type;

              switch (type) {
                case REACT_ASYNC_MODE_TYPE:
                case REACT_CONCURRENT_MODE_TYPE:
                case REACT_FRAGMENT_TYPE:
                case REACT_PROFILER_TYPE:
                case REACT_STRICT_MODE_TYPE:
                case REACT_SUSPENSE_TYPE:
                  return type;

                default:
                  var $$typeofType = type && type.$$typeof;

                  switch ($$typeofType) {
                    case REACT_CONTEXT_TYPE:
                    case REACT_FORWARD_REF_TYPE:
                    case REACT_LAZY_TYPE:
                    case REACT_MEMO_TYPE:
                    case REACT_PROVIDER_TYPE:
                      return $$typeofType;

                    default:
                      return $$typeof;
                  }

              }

            case REACT_PORTAL_TYPE:
              return $$typeof;
          }
        }

        return undefined;
      } // AsyncMode is deprecated along with isAsyncMode


      var AsyncMode = REACT_ASYNC_MODE_TYPE;
      var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
      var ContextConsumer = REACT_CONTEXT_TYPE;
      var ContextProvider = REACT_PROVIDER_TYPE;
      var Element = REACT_ELEMENT_TYPE;
      var ForwardRef = REACT_FORWARD_REF_TYPE;
      var Fragment = REACT_FRAGMENT_TYPE;
      var Lazy = REACT_LAZY_TYPE;
      var Memo = REACT_MEMO_TYPE;
      var Portal = REACT_PORTAL_TYPE;
      var Profiler = REACT_PROFILER_TYPE;
      var StrictMode = REACT_STRICT_MODE_TYPE;
      var Suspense = REACT_SUSPENSE_TYPE;
      var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated

      function isAsyncMode(object) {
        {
          if (!hasWarnedAboutDeprecatedIsAsyncMode) {
            hasWarnedAboutDeprecatedIsAsyncMode = true;
            lowPriorityWarningWithoutStack$1(false, 'The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
          }
        }
        return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
      }

      function isConcurrentMode(object) {
        return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
      }

      function isContextConsumer(object) {
        return typeOf(object) === REACT_CONTEXT_TYPE;
      }

      function isContextProvider(object) {
        return typeOf(object) === REACT_PROVIDER_TYPE;
      }

      function isElement(object) {
        return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
      }

      function isForwardRef(object) {
        return typeOf(object) === REACT_FORWARD_REF_TYPE;
      }

      function isFragment(object) {
        return typeOf(object) === REACT_FRAGMENT_TYPE;
      }

      function isLazy(object) {
        return typeOf(object) === REACT_LAZY_TYPE;
      }

      function isMemo(object) {
        return typeOf(object) === REACT_MEMO_TYPE;
      }

      function isPortal(object) {
        return typeOf(object) === REACT_PORTAL_TYPE;
      }

      function isProfiler(object) {
        return typeOf(object) === REACT_PROFILER_TYPE;
      }

      function isStrictMode(object) {
        return typeOf(object) === REACT_STRICT_MODE_TYPE;
      }

      function isSuspense(object) {
        return typeOf(object) === REACT_SUSPENSE_TYPE;
      }

      exports.typeOf = typeOf;
      exports.AsyncMode = AsyncMode;
      exports.ConcurrentMode = ConcurrentMode;
      exports.ContextConsumer = ContextConsumer;
      exports.ContextProvider = ContextProvider;
      exports.Element = Element;
      exports.ForwardRef = ForwardRef;
      exports.Fragment = Fragment;
      exports.Lazy = Lazy;
      exports.Memo = Memo;
      exports.Portal = Portal;
      exports.Profiler = Profiler;
      exports.StrictMode = StrictMode;
      exports.Suspense = Suspense;
      exports.isValidElementType = isValidElementType;
      exports.isAsyncMode = isAsyncMode;
      exports.isConcurrentMode = isConcurrentMode;
      exports.isContextConsumer = isContextConsumer;
      exports.isContextProvider = isContextProvider;
      exports.isElement = isElement;
      exports.isForwardRef = isForwardRef;
      exports.isFragment = isFragment;
      exports.isLazy = isLazy;
      exports.isMemo = isMemo;
      exports.isPortal = isPortal;
      exports.isProfiler = isProfiler;
      exports.isStrictMode = isStrictMode;
      exports.isSuspense = isSuspense;
    })();
  }
  });

  unwrapExports(reactIs_development);
  var reactIs_development_1 = reactIs_development.typeOf;
  var reactIs_development_2 = reactIs_development.AsyncMode;
  var reactIs_development_3 = reactIs_development.ConcurrentMode;
  var reactIs_development_4 = reactIs_development.ContextConsumer;
  var reactIs_development_5 = reactIs_development.ContextProvider;
  var reactIs_development_6 = reactIs_development.Element;
  var reactIs_development_7 = reactIs_development.ForwardRef;
  var reactIs_development_8 = reactIs_development.Fragment;
  var reactIs_development_9 = reactIs_development.Lazy;
  var reactIs_development_10 = reactIs_development.Memo;
  var reactIs_development_11 = reactIs_development.Portal;
  var reactIs_development_12 = reactIs_development.Profiler;
  var reactIs_development_13 = reactIs_development.StrictMode;
  var reactIs_development_14 = reactIs_development.Suspense;
  var reactIs_development_15 = reactIs_development.isValidElementType;
  var reactIs_development_16 = reactIs_development.isAsyncMode;
  var reactIs_development_17 = reactIs_development.isConcurrentMode;
  var reactIs_development_18 = reactIs_development.isContextConsumer;
  var reactIs_development_19 = reactIs_development.isContextProvider;
  var reactIs_development_20 = reactIs_development.isElement;
  var reactIs_development_21 = reactIs_development.isForwardRef;
  var reactIs_development_22 = reactIs_development.isFragment;
  var reactIs_development_23 = reactIs_development.isLazy;
  var reactIs_development_24 = reactIs_development.isMemo;
  var reactIs_development_25 = reactIs_development.isPortal;
  var reactIs_development_26 = reactIs_development.isProfiler;
  var reactIs_development_27 = reactIs_development.isStrictMode;
  var reactIs_development_28 = reactIs_development.isSuspense;

  var reactIs = createCommonjsModule(function (module) {

  {
    module.exports =
    /*#__PURE__*/
    reactIs_development;
  }
  });

  var ReactIs = /*#__PURE__*/Object.freeze({
    __proto__: null,
    'default': reactIs,
    __moduleExports: reactIs
  });

  var LOADABLE_SHARED = {
    initialChunks: {}
  };

  var STATUS_PENDING = 'PENDING';
  var STATUS_RESOLVED = 'RESOLVED';
  var STATUS_REJECTED = 'REJECTED';

  function resolveConstructor(ctor) {
    if (typeof ctor === 'function') {
      return {
        requireAsync: ctor,
        resolve: function resolve() {
          return undefined;
        },
        chunkName: function chunkName() {
          return undefined;
        }
      };
    }

    return ctor;
  }

  var withChunkExtractor = function withChunkExtractor(Component) {
    var LoadableWithChunkExtractor = function LoadableWithChunkExtractor(props) {
      return React.createElement(Context.Consumer, null, function (extractor) {
        return React.createElement(Component, Object.assign({
          __chunkExtractor: extractor
        }, props));
      });
    };

    if (Component.displayName) {
      LoadableWithChunkExtractor.displayName = Component.displayName + "WithChunkExtractor";
    }

    return LoadableWithChunkExtractor;
  };

  var identity = function identity(v) {
    return v;
  };

  function createLoadable(_ref) {
    var _ref$defaultResolveCo = _ref.defaultResolveComponent,
        defaultResolveComponent = _ref$defaultResolveCo === void 0 ? identity : _ref$defaultResolveCo,
        _render = _ref.render,
        onLoad = _ref.onLoad;

    function loadable(loadableConstructor, options) {
      if (options === void 0) {
        options = {};
      }

      var ctor = resolveConstructor(loadableConstructor);
      var cache = {};
      /**
       * Cachekey represents the component to be loaded
       * if key changes - component has to be reloaded
       * @param props
       * @returns {null|Component}
       */

      function _getCacheKey(props) {
        if (options.cacheKey) {
          return options.cacheKey(props);
        }

        if (ctor.resolve) {
          return ctor.resolve(props);
        }

        return 'static';
      }
      /**
       * Resolves loaded `module` to a specific `Component
       * @param module
       * @param props
       * @param Loadable
       * @returns Component
       */


      function resolve(module, props, Loadable) {
        var Component = options.resolveComponent ? options.resolveComponent(module, props) : defaultResolveComponent(module);

        if (options.resolveComponent && !undefined(Component)) {
          throw new Error("resolveComponent returned something that is not a React component!");
        }

        hoistNonReactStatics(Loadable, Component, {
          preload: true
        });
        return Component;
      }

      var InnerLoadable =
      /*#__PURE__*/
      function (_React$Component) {
        _inheritsLoose(InnerLoadable, _React$Component);

        InnerLoadable.getDerivedStateFromProps = function getDerivedStateFromProps(props, state) {
          var cacheKey = _getCacheKey(props);

          return _extends({}, state, {
            cacheKey: cacheKey,
            // change of a key triggers loading state automatically
            loading: state.loading || state.cacheKey !== cacheKey
          });
        };

        function InnerLoadable(props) {
          var _this;

          _this = _React$Component.call(this, props) || this;
          _this.state = {
            result: null,
            error: null,
            loading: true,
            cacheKey: _getCacheKey(props)
          };
          invariant(!props.__chunkExtractor || ctor.requireSync, 'SSR requires `@loadable/babel-plugin`, please install it'); // Server-side

          if (props.__chunkExtractor) {
            // This module has been marked with no SSR
            if (options.ssr === false) {
              return _assertThisInitialized(_this);
            } // We run load function, we assume that it won't fail and that it
            // triggers a synchronous loading of the module


            ctor.requireAsync(props)["catch"](function () {
              return null;
            }); // So we can require now the module synchronously

            _this.loadSync();

            props.__chunkExtractor.addChunk(ctor.chunkName(props));

            return _assertThisInitialized(_this);
          } // Client-side with `isReady` method present (SSR probably)
          // If module is already loaded, we use a synchronous loading
          // Only perform this synchronous loading if the component has not
          // been marked with no SSR, else we risk hydration mismatches


          if (options.ssr !== false && ( // is ready - was loaded in this session
          ctor.isReady && ctor.isReady(props) || // is ready - was loaded during SSR process
          ctor.chunkName && LOADABLE_SHARED.initialChunks[ctor.chunkName(props)])) {
            _this.loadSync();
          }

          return _this;
        }

        var _proto = InnerLoadable.prototype;

        _proto.componentDidMount = function componentDidMount() {
          this.mounted = true; // retrieve loading promise from a global cache

          var cachedPromise = this.getCache(); // if promise exists, but rejected - clear cache

          if (cachedPromise && cachedPromise.status === STATUS_REJECTED) {
            this.setCache();
          } // component might be resolved synchronously in the constructor


          if (this.state.loading) {
            this.loadAsync();
          }
        };

        _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
          // Component has to be reloaded on cacheKey change
          if (prevState.cacheKey !== this.state.cacheKey) {
            this.loadAsync();
          }
        };

        _proto.componentWillUnmount = function componentWillUnmount() {
          this.mounted = false;
        };

        _proto.safeSetState = function safeSetState(nextState, callback) {
          if (this.mounted) {
            this.setState(nextState, callback);
          }
        }
        /**
         * returns a cache key for the current props
         * @returns {Component|string}
         */
        ;

        _proto.getCacheKey = function getCacheKey() {
          return _getCacheKey(this.props);
        }
        /**
         * access the persistent cache
         */
        ;

        _proto.getCache = function getCache() {
          return cache[this.getCacheKey()];
        }
        /**
         * sets the cache value. If called without value sets it as undefined
         */
        ;

        _proto.setCache = function setCache(value) {
          if (value === void 0) {
            value = undefined;
          }

          cache[this.getCacheKey()] = value;
        };

        _proto.triggerOnLoad = function triggerOnLoad() {
          var _this2 = this;

          if (onLoad) {
            setTimeout(function () {
              onLoad(_this2.state.result, _this2.props);
            });
          }
        }
        /**
         * Synchronously loads component
         * target module is expected to already exists in the module cache
         * or be capable to resolve synchronously (webpack target=node)
         */
        ;

        _proto.loadSync = function loadSync() {
          // load sync is expecting component to be in the "loading" state already
          // sounds weird, but loading=true is the initial state of InnerLoadable
          if (!this.state.loading) return;

          try {
            var loadedModule = ctor.requireSync(this.props);
            var result = resolve(loadedModule, this.props, Loadable);
            this.state.result = result;
            this.state.loading = false;
          } catch (error) {
            console.error('loadable-components: failed to synchronously load component, which expected to be available', {
              fileName: ctor.resolve(this.props),
              chunkName: ctor.chunkName(this.props),
              error: error ? error.message : error
            });
            this.state.error = error;
          }
        }
        /**
         * Asynchronously loads a component.
         */
        ;

        _proto.loadAsync = function loadAsync() {
          var _this3 = this;

          var promise = this.resolveAsync();
          promise.then(function (loadedModule) {
            var result = resolve(loadedModule, _this3.props, {
              Loadable: Loadable
            });

            _this3.safeSetState({
              result: result,
              loading: false
            }, function () {
              return _this3.triggerOnLoad();
            });
          })["catch"](function (error) {
            return _this3.safeSetState({
              error: error,
              loading: false
            });
          });
          return promise;
        }
        /**
         * Asynchronously resolves(not loads) a component.
         * Note - this function does not change the state
         */
        ;

        _proto.resolveAsync = function resolveAsync() {
          var _this4 = this;

          var _this$props = this.props,
              __chunkExtractor = _this$props.__chunkExtractor,
              forwardedRef = _this$props.forwardedRef,
              props = _objectWithoutPropertiesLoose(_this$props, ["__chunkExtractor", "forwardedRef"]);

          var promise = this.getCache();

          if (!promise) {
            promise = ctor.requireAsync(props);
            promise.status = STATUS_PENDING;
            this.setCache(promise);
            promise.then(function () {
              promise.status = STATUS_RESOLVED;
            }, function (error) {
              console.error('loadable-components: failed to asynchronously load component', {
                fileName: ctor.resolve(_this4.props),
                chunkName: ctor.chunkName(_this4.props),
                error: error ? error.message : error
              });
              promise.status = STATUS_REJECTED;
            });
          }

          return promise;
        };

        _proto.render = function render() {
          var _this$props2 = this.props,
              forwardedRef = _this$props2.forwardedRef,
              propFallback = _this$props2.fallback,
              __chunkExtractor = _this$props2.__chunkExtractor,
              props = _objectWithoutPropertiesLoose(_this$props2, ["forwardedRef", "fallback", "__chunkExtractor"]);

          var _this$state = this.state,
              error = _this$state.error,
              loading = _this$state.loading,
              result = _this$state.result;

          if (options.suspense) {
            var cachedPromise = this.getCache() || this.loadAsync();

            if (cachedPromise.status === STATUS_PENDING) {
              throw this.loadAsync();
            }
          }

          if (error) {
            throw error;
          }

          var fallback = propFallback || options.fallback || null;

          if (loading) {
            return fallback;
          }

          return _render({
            fallback: fallback,
            result: result,
            options: options,
            props: _extends({}, props, {
              ref: forwardedRef
            })
          });
        };

        return InnerLoadable;
      }(React.Component);

      var EnhancedInnerLoadable = withChunkExtractor(InnerLoadable);
      var Loadable = React.forwardRef(function (props, ref) {
        return React.createElement(EnhancedInnerLoadable, Object.assign({
          forwardedRef: ref
        }, props));
      });
      Loadable.displayName = 'Loadable'; // In future, preload could use `<link rel="preload">`

      Loadable.preload = function (props) {
        ctor.requireAsync(props);
      };

      Loadable.load = function (props) {
        return ctor.requireAsync(props);
      };

      return Loadable;
    }

    function lazy(ctor, options) {
      return loadable(ctor, _extends({}, options, {
        suspense: true
      }));
    }

    return {
      loadable: loadable,
      lazy: lazy
    };
  }

  function defaultResolveComponent(loadedModule) {
    // eslint-disable-next-line no-underscore-dangle
    return loadedModule.__esModule ? loadedModule["default"] : loadedModule["default"] || loadedModule;
  }

  /* eslint-disable no-use-before-define, react/no-multi-comp */

  var _createLoadable =
  /*#__PURE__*/
  createLoadable({
    defaultResolveComponent: defaultResolveComponent,
    render: function render(_ref) {
      var Component = _ref.result,
          props = _ref.props;
      return React.createElement(Component, props);
    }
  }),
      loadable = _createLoadable.loadable,
      lazy = _createLoadable.lazy;

  /* eslint-disable no-use-before-define, react/no-multi-comp */

  var _createLoadable$1 =
  /*#__PURE__*/
  createLoadable({
    onLoad: function onLoad(result, props) {
      if (result && props.forwardedRef) {
        if (typeof props.forwardedRef === 'function') {
          props.forwardedRef(result);
        } else {
          props.forwardedRef.current = result;
        }
      }
    },
    render: function render(_ref) {
      var result = _ref.result,
          props = _ref.props;

      if (props.children) {
        return props.children(result);
      }

      return null;
    }
  }),
      loadable$1 = _createLoadable$1.loadable,
      lazy$1 = _createLoadable$1.lazy;

  /* eslint-disable no-underscore-dangle, camelcase */
  var BROWSER = typeof window !== 'undefined';
  function loadableReady(done, _temp) {
    if (done === void 0) {
      done = function done() {};
    }

    var _ref = _temp === void 0 ? {} : _temp,
        _ref$namespace = _ref.namespace,
        namespace = _ref$namespace === void 0 ? '' : _ref$namespace,
        _ref$chunkLoadingGlob = _ref.chunkLoadingGlobal,
        chunkLoadingGlobal = _ref$chunkLoadingGlob === void 0 ? '__LOADABLE_LOADED_CHUNKS__' : _ref$chunkLoadingGlob;

    if (!BROWSER) {
      warn('`loadableReady()` must be called in browser only');
      done();
      return Promise.resolve();
    }

    var requiredChunks = null;

    if (BROWSER) {
      var id = getRequiredChunkKey(namespace);
      var dataElement = document.getElementById(id);

      if (dataElement) {
        requiredChunks = JSON.parse(dataElement.textContent);
        var extElement = document.getElementById(id + "_ext");

        if (extElement) {
          var _JSON$parse = JSON.parse(extElement.textContent),
              namedChunks = _JSON$parse.namedChunks;

          namedChunks.forEach(function (chunkName) {
            LOADABLE_SHARED.initialChunks[chunkName] = true;
          });
        } else {
          // version mismatch
          throw new Error('loadable-component: @loadable/server does not match @loadable/component');
        }
      }
    }

    if (!requiredChunks) {
      warn('`loadableReady()` requires state, please use `getScriptTags` or `getScriptElements` server-side');
      done();
      return Promise.resolve();
    }

    var resolved = false;
    return new Promise(function (resolve) {
      window[chunkLoadingGlobal] = window[chunkLoadingGlobal] || [];
      var loadedChunks = window[chunkLoadingGlobal];
      var originalPush = loadedChunks.push.bind(loadedChunks);

      function checkReadyState() {
        if (requiredChunks.every(function (chunk) {
          return loadedChunks.some(function (_ref2) {
            var chunks = _ref2[0];
            return chunks.indexOf(chunk) > -1;
          });
        })) {
          if (!resolved) {
            resolved = true;
            resolve();
          }
        }
      }

      loadedChunks.push = function () {
        originalPush.apply(void 0, arguments);
        checkReadyState();
      };

      checkReadyState();
    }).then(done);
  }

  /* eslint-disable no-underscore-dangle */
  var loadable$2 = loadable;
  loadable$2.lib = loadable$1;
  var lazy$2 = lazy;
  lazy$2.lib = lazy$1;
  var __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = sharedInternals;

  exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
  exports.default = loadable$2;
  exports.lazy = lazy$2;
  exports.loadableReady = loadableReady;

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

})));