{"version":3,"sources":["../node_modules/create-react-class/factory.js","../node_modules/fbjs/lib/emptyObject.js","../node_modules/react-bootstrap/es/Col.js","../node_modules/react-bootstrap/es/Row.js","../node_modules/fbjs/lib/invariant.js"],"names":["_assign","__webpack_require__","emptyObject","_invariant","MIXINS_KEY","module","exports","ReactComponent","isValidElement","ReactNoopUpdateQueue","injectedMixins","ReactClassInterface","mixins","statics","propTypes","contextTypes","childContextTypes","getDefaultProps","getInitialState","getChildContext","render","componentWillMount","componentDidMount","componentWillReceiveProps","shouldComponentUpdate","componentWillUpdate","componentDidUpdate","componentWillUnmount","UNSAFE_componentWillMount","UNSAFE_componentWillReceiveProps","UNSAFE_componentWillUpdate","updateComponent","ReactClassStaticInterface","getDerivedStateFromProps","RESERVED_SPEC_KEYS","displayName","Constructor","_displayName","_mixins","i","length","mixSpecIntoComponent","_childContextTypes","_contextTypes","_getDefaultProps","createMergedResultFunction","_propTypes","_statics","name","property","hasOwnProperty","isReserved","isAlreadyDefined","specPolicy","mixStaticSpecIntoComponent","autobind","validateMethodOverride","ReactClassMixin","spec","proto","prototype","autoBindPairs","__reactAutoBindPairs","isReactClassMethod","createChainedFunction","push","mergeIntoWithNoDuplicateKeys","one","two","key","undefined","a","apply","this","arguments","b","c","bindAutoBindMethod","component","method","bind","IsMountedPreMixin","__isMounted","IsMountedPostMixin","replaceState","newState","callback","updater","enqueueReplaceState","isMounted","ReactClassComponent","props","context","pairs","autoBindKey","bindAutoBindMethods","refs","state","initialState","Array","isArray","methodName","constructor","forEach","defaultProps","_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__","_babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_1__","classnames__WEBPACK_IMPORTED_MODULE_2__","classnames__WEBPACK_IMPORTED_MODULE_2___default","n","react__WEBPACK_IMPORTED_MODULE_3__","react__WEBPACK_IMPORTED_MODULE_3___default","_ThemeProvider__WEBPACK_IMPORTED_MODULE_4__","DEVICE_SIZES","Col","forwardRef","_ref","ref","bsPrefix","className","_ref$as","as","Component","Object","prefix","spans","classes","brkPoint","span","offset","order","propValue","_propValue$span","infix","createElement","concat","__webpack_exports__","_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_2__","classnames__WEBPACK_IMPORTED_MODULE_3__","classnames__WEBPACK_IMPORTED_MODULE_3___default","react__WEBPACK_IMPORTED_MODULE_4__","react__WEBPACK_IMPORTED_MODULE_4___default","_ThemeProvider__WEBPACK_IMPORTED_MODULE_5__","Row","_React$Component","_this$props","noGutters","_this$props$as","validateFormat","format","condition","d","e","f","error","Error","args","argIndex","replace","framesToPop"],"mappings":"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","file":"static/js/1.9e94cdc3.chunk.js","sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar emptyObject = require('fbjs/lib/emptyObject');\n\nvar _invariant = require('fbjs/lib/invariant');\n\nif (process.env.NODE_ENV !== 'production') {\n  var warning = require('fbjs/lib/warning');\n}\n\nvar MIXINS_KEY = 'mixins'; // Helper function to allow the creation of anonymous functions which do not\n// have .name set to the name of the variable being assigned to.\n\nfunction identity(fn) {\n  return fn;\n}\n\nvar ReactPropTypeLocationNames;\n\nif (process.env.NODE_ENV !== 'production') {\n  ReactPropTypeLocationNames = {\n    prop: 'prop',\n    context: 'context',\n    childContext: 'child context'\n  };\n} else {\n  ReactPropTypeLocationNames = {};\n}\n\nfunction factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) {\n  /**\n   * Policies that describe methods in `ReactClassInterface`.\n   */\n  var injectedMixins = [];\n  /**\n   * Composite components are higher-level components that compose other composite\n   * or host components.\n   *\n   * To create a new type of `ReactClass`, pass a specification of\n   * your new class to `React.createClass`. The only requirement of your class\n   * specification is that you implement a `render` method.\n   *\n   *   var MyComponent = React.createClass({\n   *     render: function() {\n   *       return <div>Hello World</div>;\n   *     }\n   *   });\n   *\n   * The class specification supports a specific protocol of methods that have\n   * special meaning (e.g. `render`). See `ReactClassInterface` for\n   * more the comprehensive protocol. Any other properties and methods in the\n   * class specification will be available on the prototype.\n   *\n   * @interface ReactClassInterface\n   * @internal\n   */\n\n  var ReactClassInterface = {\n    /**\n     * An array of Mixin objects to include when defining your component.\n     *\n     * @type {array}\n     * @optional\n     */\n    mixins: 'DEFINE_MANY',\n\n    /**\n     * An object containing properties and methods that should be defined on\n     * the component's constructor instead of its prototype (static methods).\n     *\n     * @type {object}\n     * @optional\n     */\n    statics: 'DEFINE_MANY',\n\n    /**\n     * Definition of prop types for this component.\n     *\n     * @type {object}\n     * @optional\n     */\n    propTypes: 'DEFINE_MANY',\n\n    /**\n     * Definition of context types for this component.\n     *\n     * @type {object}\n     * @optional\n     */\n    contextTypes: 'DEFINE_MANY',\n\n    /**\n     * Definition of context types this component sets for its children.\n     *\n     * @type {object}\n     * @optional\n     */\n    childContextTypes: 'DEFINE_MANY',\n    // ==== Definition methods ====\n\n    /**\n     * Invoked when the component is mounted. Values in the mapping will be set on\n     * `this.props` if that prop is not specified (i.e. using an `in` check).\n     *\n     * This method is invoked before `getInitialState` and therefore cannot rely\n     * on `this.state` or use `this.setState`.\n     *\n     * @return {object}\n     * @optional\n     */\n    getDefaultProps: 'DEFINE_MANY_MERGED',\n\n    /**\n     * Invoked once before the component is mounted. The return value will be used\n     * as the initial value of `this.state`.\n     *\n     *   getInitialState: function() {\n     *     return {\n     *       isOn: false,\n     *       fooBaz: new BazFoo()\n     *     }\n     *   }\n     *\n     * @return {object}\n     * @optional\n     */\n    getInitialState: 'DEFINE_MANY_MERGED',\n\n    /**\n     * @return {object}\n     * @optional\n     */\n    getChildContext: 'DEFINE_MANY_MERGED',\n\n    /**\n     * Uses props from `this.props` and state from `this.state` to render the\n     * structure of the component.\n     *\n     * No guarantees are made about when or how often this method is invoked, so\n     * it must not have side effects.\n     *\n     *   render: function() {\n     *     var name = this.props.name;\n     *     return <div>Hello, {name}!</div>;\n     *   }\n     *\n     * @return {ReactComponent}\n     * @required\n     */\n    render: 'DEFINE_ONCE',\n    // ==== Delegate methods ====\n\n    /**\n     * Invoked when the component is initially created and about to be mounted.\n     * This may have side effects, but any external subscriptions or data created\n     * by this method must be cleaned up in `componentWillUnmount`.\n     *\n     * @optional\n     */\n    componentWillMount: 'DEFINE_MANY',\n\n    /**\n     * Invoked when the component has been mounted and has a DOM representation.\n     * However, there is no guarantee that the DOM node is in the document.\n     *\n     * Use this as an opportunity to operate on the DOM when the component has\n     * been mounted (initialized and rendered) for the first time.\n     *\n     * @param {DOMElement} rootNode DOM element representing the component.\n     * @optional\n     */\n    componentDidMount: 'DEFINE_MANY',\n\n    /**\n     * Invoked before the component receives new props.\n     *\n     * Use this as an opportunity to react to a prop transition by updating the\n     * state using `this.setState`. Current props are accessed via `this.props`.\n     *\n     *   componentWillReceiveProps: function(nextProps, nextContext) {\n     *     this.setState({\n     *       likesIncreasing: nextProps.likeCount > this.props.likeCount\n     *     });\n     *   }\n     *\n     * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop\n     * transition may cause a state change, but the opposite is not true. If you\n     * need it, you are probably looking for `componentWillUpdate`.\n     *\n     * @param {object} nextProps\n     * @optional\n     */\n    componentWillReceiveProps: 'DEFINE_MANY',\n\n    /**\n     * Invoked while deciding if the component should be updated as a result of\n     * receiving new props, state and/or context.\n     *\n     * Use this as an opportunity to `return false` when you're certain that the\n     * transition to the new props/state/context will not require a component\n     * update.\n     *\n     *   shouldComponentUpdate: function(nextProps, nextState, nextContext) {\n     *     return !equal(nextProps, this.props) ||\n     *       !equal(nextState, this.state) ||\n     *       !equal(nextContext, this.context);\n     *   }\n     *\n     * @param {object} nextProps\n     * @param {?object} nextState\n     * @param {?object} nextContext\n     * @return {boolean} True if the component should update.\n     * @optional\n     */\n    shouldComponentUpdate: 'DEFINE_ONCE',\n\n    /**\n     * Invoked when the component is about to update due to a transition from\n     * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`\n     * and `nextContext`.\n     *\n     * Use this as an opportunity to perform preparation before an update occurs.\n     *\n     * NOTE: You **cannot** use `this.setState()` in this method.\n     *\n     * @param {object} nextProps\n     * @param {?object} nextState\n     * @param {?object} nextContext\n     * @param {ReactReconcileTransaction} transaction\n     * @optional\n     */\n    componentWillUpdate: 'DEFINE_MANY',\n\n    /**\n     * Invoked when the component's DOM representation has been updated.\n     *\n     * Use this as an opportunity to operate on the DOM when the component has\n     * been updated.\n     *\n     * @param {object} prevProps\n     * @param {?object} prevState\n     * @param {?object} prevContext\n     * @param {DOMElement} rootNode DOM element representing the component.\n     * @optional\n     */\n    componentDidUpdate: 'DEFINE_MANY',\n\n    /**\n     * Invoked when the component is about to be removed from its parent and have\n     * its DOM representation destroyed.\n     *\n     * Use this as an opportunity to deallocate any external resources.\n     *\n     * NOTE: There is no `componentDidUnmount` since your component will have been\n     * destroyed by that point.\n     *\n     * @optional\n     */\n    componentWillUnmount: 'DEFINE_MANY',\n\n    /**\n     * Replacement for (deprecated) `componentWillMount`.\n     *\n     * @optional\n     */\n    UNSAFE_componentWillMount: 'DEFINE_MANY',\n\n    /**\n     * Replacement for (deprecated) `componentWillReceiveProps`.\n     *\n     * @optional\n     */\n    UNSAFE_componentWillReceiveProps: 'DEFINE_MANY',\n\n    /**\n     * Replacement for (deprecated) `componentWillUpdate`.\n     *\n     * @optional\n     */\n    UNSAFE_componentWillUpdate: 'DEFINE_MANY',\n    // ==== Advanced methods ====\n\n    /**\n     * Updates the component's currently mounted DOM representation.\n     *\n     * By default, this implements React's rendering and reconciliation algorithm.\n     * Sophisticated clients may wish to override this.\n     *\n     * @param {ReactReconcileTransaction} transaction\n     * @internal\n     * @overridable\n     */\n    updateComponent: 'OVERRIDE_BASE'\n  };\n  /**\n   * Similar to ReactClassInterface but for static methods.\n   */\n\n  var ReactClassStaticInterface = {\n    /**\n     * This method is invoked after a component is instantiated and when it\n     * receives new props. Return an object to update state in response to\n     * prop changes. Return null to indicate no change to state.\n     *\n     * If an object is returned, its keys will be merged into the existing state.\n     *\n     * @return {object || null}\n     * @optional\n     */\n    getDerivedStateFromProps: 'DEFINE_MANY_MERGED'\n  };\n  /**\n   * Mapping from class specification keys to special processing functions.\n   *\n   * Although these are declared like instance properties in the specification\n   * when defining classes using `React.createClass`, they are actually static\n   * and are accessible on the constructor instead of the prototype. Despite\n   * being static, they must be defined outside of the \"statics\" key under\n   * which all other static methods are defined.\n   */\n\n  var RESERVED_SPEC_KEYS = {\n    displayName: function displayName(Constructor, _displayName) {\n      Constructor.displayName = _displayName;\n    },\n    mixins: function mixins(Constructor, _mixins) {\n      if (_mixins) {\n        for (var i = 0; i < _mixins.length; i++) {\n          mixSpecIntoComponent(Constructor, _mixins[i]);\n        }\n      }\n    },\n    childContextTypes: function childContextTypes(Constructor, _childContextTypes) {\n      if (process.env.NODE_ENV !== 'production') {\n        validateTypeDef(Constructor, _childContextTypes, 'childContext');\n      }\n\n      Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, _childContextTypes);\n    },\n    contextTypes: function contextTypes(Constructor, _contextTypes) {\n      if (process.env.NODE_ENV !== 'production') {\n        validateTypeDef(Constructor, _contextTypes, 'context');\n      }\n\n      Constructor.contextTypes = _assign({}, Constructor.contextTypes, _contextTypes);\n    },\n\n    /**\n     * Special case getDefaultProps which should move into statics but requires\n     * automatic merging.\n     */\n    getDefaultProps: function getDefaultProps(Constructor, _getDefaultProps) {\n      if (Constructor.getDefaultProps) {\n        Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, _getDefaultProps);\n      } else {\n        Constructor.getDefaultProps = _getDefaultProps;\n      }\n    },\n    propTypes: function propTypes(Constructor, _propTypes) {\n      if (process.env.NODE_ENV !== 'production') {\n        validateTypeDef(Constructor, _propTypes, 'prop');\n      }\n\n      Constructor.propTypes = _assign({}, Constructor.propTypes, _propTypes);\n    },\n    statics: function statics(Constructor, _statics) {\n      mixStaticSpecIntoComponent(Constructor, _statics);\n    },\n    autobind: function autobind() {}\n  };\n\n  function validateTypeDef(Constructor, typeDef, location) {\n    for (var propName in typeDef) {\n      if (typeDef.hasOwnProperty(propName)) {\n        // use a warning instead of an _invariant so components\n        // don't show up in prod but only in __DEV__\n        if (process.env.NODE_ENV !== 'production') {\n          warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName);\n        }\n      }\n    }\n  }\n\n  function validateMethodOverride(isAlreadyDefined, name) {\n    var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null; // Disallow overriding of base class methods unless explicitly allowed.\n\n    if (ReactClassMixin.hasOwnProperty(name)) {\n      _invariant(specPolicy === 'OVERRIDE_BASE', 'ReactClassInterface: You are attempting to override ' + '`%s` from your class specification. Ensure that your method names ' + 'do not overlap with React methods.', name);\n    } // Disallow defining methods more than once unless explicitly allowed.\n\n\n    if (isAlreadyDefined) {\n      _invariant(specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED', 'ReactClassInterface: You are attempting to define ' + '`%s` on your component more than once. This conflict may be due ' + 'to a mixin.', name);\n    }\n  }\n  /**\n   * Mixin helper which handles policy validation and reserved\n   * specification keys when building React classes.\n   */\n\n\n  function mixSpecIntoComponent(Constructor, spec) {\n    if (!spec) {\n      if (process.env.NODE_ENV !== 'production') {\n        var typeofSpec = typeof spec;\n        var isMixinValid = typeofSpec === 'object' && spec !== null;\n\n        if (process.env.NODE_ENV !== 'production') {\n          warning(isMixinValid, \"%s: You're attempting to include a mixin that is either null \" + 'or not an object. Check the mixins included by the component, ' + 'as well as any mixins they include themselves. ' + 'Expected object but got %s.', Constructor.displayName || 'ReactClass', spec === null ? null : typeofSpec);\n        }\n      }\n\n      return;\n    }\n\n    _invariant(typeof spec !== 'function', \"ReactClass: You're attempting to \" + 'use a component class or function as a mixin. Instead, just use a ' + 'regular object.');\n\n    _invariant(!isValidElement(spec), \"ReactClass: You're attempting to \" + 'use a component as a mixin. Instead, just use a regular object.');\n\n    var proto = Constructor.prototype;\n    var autoBindPairs = proto.__reactAutoBindPairs; // By handling mixins before any other properties, we ensure the same\n    // chaining order is applied to methods with DEFINE_MANY policy, whether\n    // mixins are listed before or after these methods in the spec.\n\n    if (spec.hasOwnProperty(MIXINS_KEY)) {\n      RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);\n    }\n\n    for (var name in spec) {\n      if (!spec.hasOwnProperty(name)) {\n        continue;\n      }\n\n      if (name === MIXINS_KEY) {\n        // We have already handled mixins in a special case above.\n        continue;\n      }\n\n      var property = spec[name];\n      var isAlreadyDefined = proto.hasOwnProperty(name);\n      validateMethodOverride(isAlreadyDefined, name);\n\n      if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {\n        RESERVED_SPEC_KEYS[name](Constructor, property);\n      } else {\n        // Setup methods on prototype:\n        // The following member methods should not be automatically bound:\n        // 1. Expected ReactClass methods (in the \"interface\").\n        // 2. Overridden methods (that were mixed in).\n        var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);\n        var isFunction = typeof property === 'function';\n        var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;\n\n        if (shouldAutoBind) {\n          autoBindPairs.push(name, property);\n          proto[name] = property;\n        } else {\n          if (isAlreadyDefined) {\n            var specPolicy = ReactClassInterface[name]; // These cases should already be caught by validateMethodOverride.\n\n            _invariant(isReactClassMethod && (specPolicy === 'DEFINE_MANY_MERGED' || specPolicy === 'DEFINE_MANY'), 'ReactClass: Unexpected spec policy %s for key %s ' + 'when mixing in component specs.', specPolicy, name); // For methods which are defined more than once, call the existing\n            // methods before calling the new property, merging if appropriate.\n\n\n            if (specPolicy === 'DEFINE_MANY_MERGED') {\n              proto[name] = createMergedResultFunction(proto[name], property);\n            } else if (specPolicy === 'DEFINE_MANY') {\n              proto[name] = createChainedFunction(proto[name], property);\n            }\n          } else {\n            proto[name] = property;\n\n            if (process.env.NODE_ENV !== 'production') {\n              // Add verbose displayName to the function, which helps when looking\n              // at profiling tools.\n              if (typeof property === 'function' && spec.displayName) {\n                proto[name].displayName = spec.displayName + '_' + name;\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n\n  function mixStaticSpecIntoComponent(Constructor, statics) {\n    if (!statics) {\n      return;\n    }\n\n    for (var name in statics) {\n      var property = statics[name];\n\n      if (!statics.hasOwnProperty(name)) {\n        continue;\n      }\n\n      var isReserved = name in RESERVED_SPEC_KEYS;\n\n      _invariant(!isReserved, 'ReactClass: You are attempting to define a reserved ' + 'property, `%s`, that shouldn\\'t be on the \"statics\" key. Define it ' + 'as an instance property instead; it will still be accessible on the ' + 'constructor.', name);\n\n      var isAlreadyDefined = name in Constructor;\n\n      if (isAlreadyDefined) {\n        var specPolicy = ReactClassStaticInterface.hasOwnProperty(name) ? ReactClassStaticInterface[name] : null;\n\n        _invariant(specPolicy === 'DEFINE_MANY_MERGED', 'ReactClass: You are attempting to define ' + '`%s` on your component more than once. This conflict may be ' + 'due to a mixin.', name);\n\n        Constructor[name] = createMergedResultFunction(Constructor[name], property);\n        return;\n      }\n\n      Constructor[name] = property;\n    }\n  }\n  /**\n   * Merge two objects, but throw if both contain the same key.\n   *\n   * @param {object} one The first object, which is mutated.\n   * @param {object} two The second object\n   * @return {object} one after it has been mutated to contain everything in two.\n   */\n\n\n  function mergeIntoWithNoDuplicateKeys(one, two) {\n    _invariant(one && two && typeof one === 'object' && typeof two === 'object', 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.');\n\n    for (var key in two) {\n      if (two.hasOwnProperty(key)) {\n        _invariant(one[key] === undefined, 'mergeIntoWithNoDuplicateKeys(): ' + 'Tried to merge two objects with the same key: `%s`. This conflict ' + 'may be due to a mixin; in particular, this may be caused by two ' + 'getInitialState() or getDefaultProps() methods returning objects ' + 'with clashing keys.', key);\n\n        one[key] = two[key];\n      }\n    }\n\n    return one;\n  }\n  /**\n   * Creates a function that invokes two functions and merges their return values.\n   *\n   * @param {function} one Function to invoke first.\n   * @param {function} two Function to invoke second.\n   * @return {function} Function that invokes the two argument functions.\n   * @private\n   */\n\n\n  function createMergedResultFunction(one, two) {\n    return function mergedResult() {\n      var a = one.apply(this, arguments);\n      var b = two.apply(this, arguments);\n\n      if (a == null) {\n        return b;\n      } else if (b == null) {\n        return a;\n      }\n\n      var c = {};\n      mergeIntoWithNoDuplicateKeys(c, a);\n      mergeIntoWithNoDuplicateKeys(c, b);\n      return c;\n    };\n  }\n  /**\n   * Creates a function that invokes two functions and ignores their return vales.\n   *\n   * @param {function} one Function to invoke first.\n   * @param {function} two Function to invoke second.\n   * @return {function} Function that invokes the two argument functions.\n   * @private\n   */\n\n\n  function createChainedFunction(one, two) {\n    return function chainedFunction() {\n      one.apply(this, arguments);\n      two.apply(this, arguments);\n    };\n  }\n  /**\n   * Binds a method to the component.\n   *\n   * @param {object} component Component whose method is going to be bound.\n   * @param {function} method Method to be bound.\n   * @return {function} The bound method.\n   */\n\n\n  function bindAutoBindMethod(component, method) {\n    var boundMethod = method.bind(component);\n\n    if (process.env.NODE_ENV !== 'production') {\n      boundMethod.__reactBoundContext = component;\n      boundMethod.__reactBoundMethod = method;\n      boundMethod.__reactBoundArguments = null;\n      var componentName = component.constructor.displayName;\n      var _bind = boundMethod.bind;\n\n      boundMethod.bind = function (newThis) {\n        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n          args[_key - 1] = arguments[_key];\n        } // User is trying to bind() an autobound method; we effectively will\n        // ignore the value of \"this\" that the user is trying to use, so\n        // let's warn.\n\n\n        if (newThis !== component && newThis !== null) {\n          if (process.env.NODE_ENV !== 'production') {\n            warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName);\n          }\n        } else if (!args.length) {\n          if (process.env.NODE_ENV !== 'production') {\n            warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName);\n          }\n\n          return boundMethod;\n        }\n\n        var reboundMethod = _bind.apply(boundMethod, arguments);\n\n        reboundMethod.__reactBoundContext = component;\n        reboundMethod.__reactBoundMethod = method;\n        reboundMethod.__reactBoundArguments = args;\n        return reboundMethod;\n      };\n    }\n\n    return boundMethod;\n  }\n  /**\n   * Binds all auto-bound methods in a component.\n   *\n   * @param {object} component Component whose method is going to be bound.\n   */\n\n\n  function bindAutoBindMethods(component) {\n    var pairs = component.__reactAutoBindPairs;\n\n    for (var i = 0; i < pairs.length; i += 2) {\n      var autoBindKey = pairs[i];\n      var method = pairs[i + 1];\n      component[autoBindKey] = bindAutoBindMethod(component, method);\n    }\n  }\n\n  var IsMountedPreMixin = {\n    componentDidMount: function componentDidMount() {\n      this.__isMounted = true;\n    }\n  };\n  var IsMountedPostMixin = {\n    componentWillUnmount: function componentWillUnmount() {\n      this.__isMounted = false;\n    }\n  };\n  /**\n   * Add more to the ReactClass base class. These are all legacy features and\n   * therefore not already part of the modern ReactComponent.\n   */\n\n  var ReactClassMixin = {\n    /**\n     * TODO: This will be deprecated because state should always keep a consistent\n     * type signature and the only use case for this, is to avoid that.\n     */\n    replaceState: function replaceState(newState, callback) {\n      this.updater.enqueueReplaceState(this, newState, callback);\n    },\n\n    /**\n     * Checks whether or not this composite component is mounted.\n     * @return {boolean} True if mounted, false otherwise.\n     * @protected\n     * @final\n     */\n    isMounted: function isMounted() {\n      if (process.env.NODE_ENV !== 'production') {\n        warning(this.__didWarnIsMounted, '%s: isMounted is deprecated. Instead, make sure to clean up ' + 'subscriptions and pending requests in componentWillUnmount to ' + 'prevent memory leaks.', this.constructor && this.constructor.displayName || this.name || 'Component');\n        this.__didWarnIsMounted = true;\n      }\n\n      return !!this.__isMounted;\n    }\n  };\n\n  var ReactClassComponent = function ReactClassComponent() {};\n\n  _assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);\n  /**\n   * Creates a composite component class given a class specification.\n   * See https://facebook.github.io/react/docs/top-level-api.html#react.createclass\n   *\n   * @param {object} spec Class specification (which must define `render`).\n   * @return {function} Component constructor function.\n   * @public\n   */\n\n\n  function createClass(spec) {\n    // To keep our warnings more understandable, we'll use a little hack here to\n    // ensure that Constructor.name !== 'Constructor'. This makes sure we don't\n    // unnecessarily identify a class without displayName as 'Constructor'.\n    var Constructor = identity(function (props, context, updater) {\n      // This constructor gets overridden by mocks. The argument is used\n      // by mocks to assert on what gets mounted.\n      if (process.env.NODE_ENV !== 'production') {\n        warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory');\n      } // Wire up auto-binding\n\n\n      if (this.__reactAutoBindPairs.length) {\n        bindAutoBindMethods(this);\n      }\n\n      this.props = props;\n      this.context = context;\n      this.refs = emptyObject;\n      this.updater = updater || ReactNoopUpdateQueue;\n      this.state = null; // ReactClasses doesn't have constructors. Instead, they use the\n      // getInitialState and componentWillMount methods for initialization.\n\n      var initialState = this.getInitialState ? this.getInitialState() : null;\n\n      if (process.env.NODE_ENV !== 'production') {\n        // We allow auto-mocks to proceed as if they're returning null.\n        if (initialState === undefined && this.getInitialState._isMockFunction) {\n          // This is probably bad practice. Consider warning here and\n          // deprecating this convenience.\n          initialState = null;\n        }\n      }\n\n      _invariant(typeof initialState === 'object' && !Array.isArray(initialState), '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent');\n\n      this.state = initialState;\n    });\n    Constructor.prototype = new ReactClassComponent();\n    Constructor.prototype.constructor = Constructor;\n    Constructor.prototype.__reactAutoBindPairs = [];\n    injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));\n    mixSpecIntoComponent(Constructor, IsMountedPreMixin);\n    mixSpecIntoComponent(Constructor, spec);\n    mixSpecIntoComponent(Constructor, IsMountedPostMixin); // Initialize the defaultProps property after all mixins have been merged.\n\n    if (Constructor.getDefaultProps) {\n      Constructor.defaultProps = Constructor.getDefaultProps();\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      // This is a tag to indicate that the use of these method names is ok,\n      // since it's used with createClass. If it's not, then it's likely a\n      // mistake so we'll warn you to use the static property, property\n      // initializer or constructor respectively.\n      if (Constructor.getDefaultProps) {\n        Constructor.getDefaultProps.isReactClassApproved = {};\n      }\n\n      if (Constructor.prototype.getInitialState) {\n        Constructor.prototype.getInitialState.isReactClassApproved = {};\n      }\n    }\n\n    _invariant(Constructor.prototype.render, 'createClass(...): Class specification must implement a `render` method.');\n\n    if (process.env.NODE_ENV !== 'production') {\n      warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component');\n      warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component');\n      warning(!Constructor.prototype.UNSAFE_componentWillRecieveProps, '%s has a method called UNSAFE_componentWillRecieveProps(). ' + 'Did you mean UNSAFE_componentWillReceiveProps()?', spec.displayName || 'A component');\n    } // Reduce time spent doing lookups by setting these on the prototype.\n\n\n    for (var methodName in ReactClassInterface) {\n      if (!Constructor.prototype[methodName]) {\n        Constructor.prototype[methodName] = null;\n      }\n    }\n\n    return Constructor;\n  }\n\n  return createClass;\n}\n\nmodule.exports = factory;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n'use strict';\n\nvar emptyObject = {};\n\nif (process.env.NODE_ENV !== 'production') {\n  Object.freeze(emptyObject);\n}\n\nmodule.exports = emptyObject;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport classNames from 'classnames';\nimport React from 'react';\nimport { useBootstrapPrefix } from './ThemeProvider';\nvar DEVICE_SIZES = ['xl', 'lg', 'md', 'sm', 'xs'];\nvar Col = React.forwardRef( // Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\nfunction (_ref, ref) {\n  var bsPrefix = _ref.bsPrefix,\n      className = _ref.className,\n      _ref$as = _ref.as,\n      Component = _ref$as === void 0 ? 'div' : _ref$as,\n      props = _objectWithoutPropertiesLoose(_ref, [\"bsPrefix\", \"className\", \"as\"]);\n\n  var prefix = useBootstrapPrefix(bsPrefix, 'col');\n  var spans = [];\n  var classes = [];\n  DEVICE_SIZES.forEach(function (brkPoint) {\n    var propValue = props[brkPoint];\n    delete props[brkPoint];\n    var span, offset, order;\n\n    if (propValue != null && typeof propValue === 'object') {\n      var _propValue$span = propValue.span;\n      span = _propValue$span === void 0 ? true : _propValue$span;\n      offset = propValue.offset;\n      order = propValue.order;\n    } else {\n      span = propValue;\n    }\n\n    var infix = brkPoint !== 'xs' ? \"-\" + brkPoint : '';\n    if (span != null) spans.push(span === true ? \"\" + prefix + infix : \"\" + prefix + infix + \"-\" + span);\n    if (order != null) classes.push(\"order\" + infix + \"-\" + order);\n    if (offset != null) classes.push(\"offset\" + infix + \"-\" + offset);\n  });\n\n  if (!spans.length) {\n    spans.push(prefix); // plain 'col'\n  }\n\n  return React.createElement(Component, _extends({}, props, {\n    ref: ref,\n    className: classNames.apply(void 0, [className].concat(spans, classes))\n  }));\n});\nCol.displayName = 'Col';\nexport default Col;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport classNames from 'classnames';\nimport React from 'react';\nimport { createBootstrapComponent } from './ThemeProvider';\n\nvar Row =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(Row, _React$Component);\n\n  function Row() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = Row.prototype;\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        bsPrefix = _this$props.bsPrefix,\n        noGutters = _this$props.noGutters,\n        _this$props$as = _this$props.as,\n        Component = _this$props$as === void 0 ? 'div' : _this$props$as,\n        className = _this$props.className,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"bsPrefix\", \"noGutters\", \"as\", \"className\"]);\n\n    return React.createElement(Component, _extends({}, props, {\n      className: classNames(className, bsPrefix, noGutters && 'no-gutters')\n    }));\n  };\n\n  return Row;\n}(React.Component);\n\nRow.defaultProps = {\n  noGutters: false\n};\nexport default createBootstrapComponent(Row, 'row');","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n'use strict';\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar validateFormat = function validateFormat(format) {};\n\nif (process.env.NODE_ENV !== 'production') {\n  validateFormat = function validateFormat(format) {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  };\n}\n\nfunction invariant(condition, format, a, b, c, d, e, f) {\n  validateFormat(format);\n\n  if (!condition) {\n    var error;\n\n    if (format === undefined) {\n      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(format.replace(/%s/g, function () {\n        return args[argIndex++];\n      }));\n      error.name = 'Invariant Violation';\n    }\n\n    error.framesToPop = 1; // we don't care about invariant's own frame\n\n    throw error;\n  }\n}\n\nmodule.exports = invariant;"],"sourceRoot":""}