{
  "version": 3,
  "sources": ["../../../node_modules/mobx-react/dist/mobxreact.esm.js"],
  "sourcesContent": ["import { Reaction, _allowStateChanges, _allowStateReadsStart, _allowStateReadsEnd, $mobx, createAtom, untracked, isObservableMap, isObservableObject, isObservableArray, observable } from 'mobx';\nimport React__default, { PureComponent, Component, forwardRef, memo, createElement } from 'react';\nimport { isUsingStaticRendering, Observer, observer as observer$1 } from 'mobx-react-lite';\nexport { Observer, isUsingStaticRendering, observerBatching, useAsObservableSource, useLocalStore, useObserver, useStaticRendering } from 'mobx-react-lite';\n\nvar symbolId = 0;\n\nfunction createSymbol(name) {\n  if (typeof Symbol === \"function\") {\n    return Symbol(name);\n  }\n\n  var symbol = \"__$mobx-react \" + name + \" (\" + symbolId + \")\";\n  symbolId++;\n  return symbol;\n}\n\nvar createdSymbols = {};\nfunction newSymbol(name) {\n  if (!createdSymbols[name]) {\n    createdSymbols[name] = createSymbol(name);\n  }\n\n  return createdSymbols[name];\n}\nfunction shallowEqual(objA, objB) {\n  //From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js\n  if (is(objA, objB)) return true;\n\n  if (typeof objA !== \"object\" || objA === null || typeof objB !== \"object\" || objB === null) {\n    return false;\n  }\n\n  var keysA = Object.keys(objA);\n  var keysB = Object.keys(objB);\n  if (keysA.length !== keysB.length) return false;\n\n  for (var i = 0; i < keysA.length; i++) {\n    if (!Object.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction is(x, y) {\n  // From: https://github.com/facebook/fbjs/blob/c69904a511b900266935168223063dd8772dfc40/packages/fbjs/src/core/shallowEqual.js\n  if (x === y) {\n    return x !== 0 || 1 / x === 1 / y;\n  } else {\n    return x !== x && y !== y;\n  }\n} // based on https://github.com/mridgway/hoist-non-react-statics/blob/master/src/index.js\n\n\nvar hoistBlackList = {\n  $$typeof: 1,\n  render: 1,\n  compare: 1,\n  type: 1,\n  childContextTypes: 1,\n  contextType: 1,\n  contextTypes: 1,\n  defaultProps: 1,\n  getDefaultProps: 1,\n  getDerivedStateFromError: 1,\n  getDerivedStateFromProps: 1,\n  mixins: 1,\n  propTypes: 1\n};\nfunction copyStaticProperties(base, target) {\n  var protoProps = Object.getOwnPropertyNames(Object.getPrototypeOf(base));\n  Object.getOwnPropertyNames(base).forEach(function (key) {\n    if (!hoistBlackList[key] && protoProps.indexOf(key) === -1) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(base, key));\n    }\n  });\n}\n/**\r\n * Helper to set `prop` to `this` as non-enumerable (hidden prop)\r\n * @param target\r\n * @param prop\r\n * @param value\r\n */\n\nfunction setHiddenProp(target, prop, value) {\n  if (!Object.hasOwnProperty.call(target, prop)) {\n    Object.defineProperty(target, prop, {\n      enumerable: false,\n      configurable: true,\n      writable: true,\n      value: value\n    });\n  } else {\n    target[prop] = value;\n  }\n}\n/**\r\n * Utilities for patching componentWillUnmount, to make sure @disposeOnUnmount works correctly icm with user defined hooks\r\n * and the handler provided by mobx-react\r\n */\n\nvar mobxMixins =\n/*#__PURE__*/\nnewSymbol(\"patchMixins\");\nvar mobxPatchedDefinition =\n/*#__PURE__*/\nnewSymbol(\"patchedDefinition\");\n\nfunction getMixins(target, methodName) {\n  var mixins = target[mobxMixins] = target[mobxMixins] || {};\n  var methodMixins = mixins[methodName] = mixins[methodName] || {};\n  methodMixins.locks = methodMixins.locks || 0;\n  methodMixins.methods = methodMixins.methods || [];\n  return methodMixins;\n}\n\nfunction wrapper(realMethod, mixins) {\n  var _this = this;\n\n  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {\n    args[_key - 2] = arguments[_key];\n  }\n\n  // locks are used to ensure that mixins are invoked only once per invocation, even on recursive calls\n  mixins.locks++;\n\n  try {\n    var retVal;\n\n    if (realMethod !== undefined && realMethod !== null) {\n      retVal = realMethod.apply(this, args);\n    }\n\n    return retVal;\n  } finally {\n    mixins.locks--;\n\n    if (mixins.locks === 0) {\n      mixins.methods.forEach(function (mx) {\n        mx.apply(_this, args);\n      });\n    }\n  }\n}\n\nfunction wrapFunction(realMethod, mixins) {\n  var fn = function fn() {\n    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    wrapper.call.apply(wrapper, [this, realMethod, mixins].concat(args));\n  };\n\n  return fn;\n}\n\nfunction patch(target, methodName, mixinMethod) {\n  var mixins = getMixins(target, methodName);\n\n  if (mixins.methods.indexOf(mixinMethod) < 0) {\n    mixins.methods.push(mixinMethod);\n  }\n\n  var oldDefinition = Object.getOwnPropertyDescriptor(target, methodName);\n\n  if (oldDefinition && oldDefinition[mobxPatchedDefinition]) {\n    // already patched definition, do not repatch\n    return;\n  }\n\n  var originalMethod = target[methodName];\n  var newDefinition = createDefinition(target, methodName, oldDefinition ? oldDefinition.enumerable : undefined, mixins, originalMethod);\n  Object.defineProperty(target, methodName, newDefinition);\n}\n\nfunction createDefinition(target, methodName, enumerable, mixins, originalMethod) {\n  var _ref;\n\n  var wrappedFunc = wrapFunction(originalMethod, mixins);\n  return _ref = {}, _ref[mobxPatchedDefinition] = true, _ref.get = function get() {\n    return wrappedFunc;\n  }, _ref.set = function set(value) {\n    if (this === target) {\n      wrappedFunc = wrapFunction(value, mixins);\n    } else {\n      // when it is an instance of the prototype/a child prototype patch that particular case again separately\n      // since we need to store separate values depending on wether it is the actual instance, the prototype, etc\n      // e.g. the method for super might not be the same as the method for the prototype which might be not the same\n      // as the method for the instance\n      var newDefinition = createDefinition(this, methodName, enumerable, mixins, value);\n      Object.defineProperty(this, methodName, newDefinition);\n    }\n  }, _ref.configurable = true, _ref.enumerable = enumerable, _ref;\n}\n\nvar mobxAdminProperty = $mobx || \"$mobx\";\nvar mobxObserverProperty =\n/*#__PURE__*/\nnewSymbol(\"isMobXReactObserver\");\nvar mobxIsUnmounted =\n/*#__PURE__*/\nnewSymbol(\"isUnmounted\");\nvar skipRenderKey =\n/*#__PURE__*/\nnewSymbol(\"skipRender\");\nvar isForcingUpdateKey =\n/*#__PURE__*/\nnewSymbol(\"isForcingUpdate\");\nfunction makeClassComponentObserver(componentClass) {\n  var target = componentClass.prototype;\n\n  if (componentClass[mobxObserverProperty]) {\n    var displayName = getDisplayName(target);\n    console.warn(\"The provided component class (\" + displayName + \") \\n                has already been declared as an observer component.\");\n  } else {\n    componentClass[mobxObserverProperty] = true;\n  }\n\n  if (target.componentWillReact) throw new Error(\"The componentWillReact life-cycle event is no longer supported\");\n\n  if (componentClass[\"__proto__\"] !== PureComponent) {\n    if (!target.shouldComponentUpdate) target.shouldComponentUpdate = observerSCU;else if (target.shouldComponentUpdate !== observerSCU) // n.b. unequal check, instead of existence check, as @observer might be on superclass as well\n      throw new Error(\"It is not allowed to use shouldComponentUpdate in observer based components.\");\n  } // this.props and this.state are made observable, just to make sure @computed fields that\n  // are defined inside the component, and which rely on state or props, re-compute if state or props change\n  // (otherwise the computed wouldn't update and become stale on props change, since props are not observable)\n  // However, this solution is not without it's own problems: https://github.com/mobxjs/mobx-react/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3Aobservable-props-or-not+\n\n\n  makeObservableProp(target, \"props\");\n  makeObservableProp(target, \"state\");\n  var baseRender = target.render;\n\n  target.render = function () {\n    return makeComponentReactive.call(this, baseRender);\n  };\n\n  patch(target, \"componentWillUnmount\", function () {\n    var _this$render$mobxAdmi;\n\n    if (isUsingStaticRendering() === true) return;\n    (_this$render$mobxAdmi = this.render[mobxAdminProperty]) === null || _this$render$mobxAdmi === void 0 ? void 0 : _this$render$mobxAdmi.dispose();\n    this[mobxIsUnmounted] = true;\n\n    if (!this.render[mobxAdminProperty]) {\n      // Render may have been hot-swapped and/or overriden by a subclass.\n      var _displayName = getDisplayName(this);\n\n      console.warn(\"The reactive render of an observer class component (\" + _displayName + \") \\n                was overriden after MobX attached. This may result in a memory leak if the \\n                overriden reactive render was not properly disposed.\");\n    }\n  });\n  return componentClass;\n} // Generates a friendly name for debugging\n\nfunction getDisplayName(comp) {\n  return comp.displayName || comp.name || comp.constructor && (comp.constructor.displayName || comp.constructor.name) || \"<component>\";\n}\n\nfunction makeComponentReactive(render) {\n  var _this = this;\n\n  if (isUsingStaticRendering() === true) return render.call(this);\n  /**\r\n   * If props are shallowly modified, react will render anyway,\r\n   * so atom.reportChanged() should not result in yet another re-render\r\n   */\n\n  setHiddenProp(this, skipRenderKey, false);\n  /**\r\n   * forceUpdate will re-assign this.props. We don't want that to cause a loop,\r\n   * so detect these changes\r\n   */\n\n  setHiddenProp(this, isForcingUpdateKey, false);\n  var initialName = getDisplayName(this);\n  var baseRender = render.bind(this);\n  var isRenderingPending = false;\n  var reaction = new Reaction(initialName + \".render()\", function () {\n    if (!isRenderingPending) {\n      // N.B. Getting here *before mounting* means that a component constructor has side effects (see the relevant test in misc.js)\n      // This unidiomatic React usage but React will correctly warn about this so we continue as usual\n      // See #85 / Pull #44\n      isRenderingPending = true;\n\n      if (_this[mobxIsUnmounted] !== true) {\n        var hasError = true;\n\n        try {\n          setHiddenProp(_this, isForcingUpdateKey, true);\n          if (!_this[skipRenderKey]) Component.prototype.forceUpdate.call(_this);\n          hasError = false;\n        } finally {\n          setHiddenProp(_this, isForcingUpdateKey, false);\n          if (hasError) reaction.dispose();\n        }\n      }\n    }\n  });\n  reaction[\"reactComponent\"] = this;\n  reactiveRender[mobxAdminProperty] = reaction;\n  this.render = reactiveRender;\n\n  function reactiveRender() {\n    isRenderingPending = false;\n    var exception = undefined;\n    var rendering = undefined;\n    reaction.track(function () {\n      try {\n        rendering = _allowStateChanges(false, baseRender);\n      } catch (e) {\n        exception = e;\n      }\n    });\n\n    if (exception) {\n      throw exception;\n    }\n\n    return rendering;\n  }\n\n  return reactiveRender.call(this);\n}\n\nfunction observerSCU(nextProps, nextState) {\n  if (isUsingStaticRendering()) {\n    console.warn(\"[mobx-react] It seems that a re-rendering of a React component is triggered while in static (server-side) mode. Please make sure components are rendered only once server-side.\");\n  } // update on any state changes (as is the default)\n\n\n  if (this.state !== nextState) {\n    return true;\n  } // update if props are shallowly not equal, inspired by PureRenderMixin\n  // we could return just 'false' here, and avoid the `skipRender` checks etc\n  // however, it is nicer if lifecycle events are triggered like usually,\n  // so we return true here if props are shallowly modified.\n\n\n  return !shallowEqual(this.props, nextProps);\n}\n\nfunction makeObservableProp(target, propName) {\n  var valueHolderKey = newSymbol(\"reactProp_\" + propName + \"_valueHolder\");\n  var atomHolderKey = newSymbol(\"reactProp_\" + propName + \"_atomHolder\");\n\n  function getAtom() {\n    if (!this[atomHolderKey]) {\n      setHiddenProp(this, atomHolderKey, createAtom(\"reactive \" + propName));\n    }\n\n    return this[atomHolderKey];\n  }\n\n  Object.defineProperty(target, propName, {\n    configurable: true,\n    enumerable: true,\n    get: function get() {\n      var prevReadState = false;\n\n      if (_allowStateReadsStart && _allowStateReadsEnd) {\n        prevReadState = _allowStateReadsStart(true);\n      }\n\n      getAtom.call(this).reportObserved();\n\n      if (_allowStateReadsStart && _allowStateReadsEnd) {\n        _allowStateReadsEnd(prevReadState);\n      }\n\n      return this[valueHolderKey];\n    },\n    set: function set(v) {\n      if (!this[isForcingUpdateKey] && !shallowEqual(this[valueHolderKey], v)) {\n        setHiddenProp(this, valueHolderKey, v);\n        setHiddenProp(this, skipRenderKey, true);\n        getAtom.call(this).reportChanged();\n        setHiddenProp(this, skipRenderKey, false);\n      } else {\n        setHiddenProp(this, valueHolderKey, v);\n      }\n    }\n  });\n}\n\nvar hasSymbol = typeof Symbol === \"function\" && Symbol.for; // Using react-is had some issues (and operates on elements, not on types), see #608 / #609\n\nvar ReactForwardRefSymbol = hasSymbol ?\n/*#__PURE__*/\nSymbol.for(\"react.forward_ref\") : typeof forwardRef === \"function\" &&\n/*#__PURE__*/\nforwardRef(function (props) {\n  return null;\n})[\"$$typeof\"];\nvar ReactMemoSymbol = hasSymbol ?\n/*#__PURE__*/\nSymbol.for(\"react.memo\") : typeof memo === \"function\" &&\n/*#__PURE__*/\nmemo(function (props) {\n  return null;\n})[\"$$typeof\"];\n/**\r\n * Observer function / decorator\r\n */\n\nfunction observer(component) {\n  if (component[\"isMobxInjector\"] === true) {\n    console.warn(\"Mobx observer: You are trying to use 'observer' on a component that already has 'inject'. Please apply 'observer' before applying 'inject'\");\n  }\n\n  if (ReactMemoSymbol && component[\"$$typeof\"] === ReactMemoSymbol) {\n    throw new Error(\"Mobx observer: You are trying to use 'observer' on a function component wrapped in either another observer or 'React.memo'. The observer already applies 'React.memo' for you.\");\n  } // Unwrap forward refs into `<Observer>` component\n  // we need to unwrap the render, because it is the inner render that needs to be tracked,\n  // not the ForwardRef HoC\n\n\n  if (ReactForwardRefSymbol && component[\"$$typeof\"] === ReactForwardRefSymbol) {\n    var baseRender = component[\"render\"];\n    if (typeof baseRender !== \"function\") throw new Error(\"render property of ForwardRef was not a function\");\n    return forwardRef(function ObserverForwardRef() {\n      var args = arguments;\n      return createElement(Observer, null, function () {\n        return baseRender.apply(undefined, args);\n      });\n    });\n  } // Function component\n\n\n  if (typeof component === \"function\" && (!component.prototype || !component.prototype.render) && !component[\"isReactClass\"] && !Object.prototype.isPrototypeOf.call(Component, component)) {\n    return observer$1(component);\n  }\n\n  return makeClassComponentObserver(component);\n}\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nvar MobXProviderContext =\n/*#__PURE__*/\nReact__default.createContext({});\nfunction Provider(props) {\n  var children = props.children,\n      stores = _objectWithoutPropertiesLoose(props, [\"children\"]);\n\n  var parentValue = React__default.useContext(MobXProviderContext);\n  var mutableProviderRef = React__default.useRef(_extends({}, parentValue, stores));\n  var value = mutableProviderRef.current;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    var newValue = _extends({}, value, stores); // spread in previous state for the context based stores\n\n\n    if (!shallowEqual(value, newValue)) {\n      throw new Error(\"MobX Provider: The set of provided stores has changed. See: https://github.com/mobxjs/mobx-react#the-set-of-provided-stores-has-changed-error.\");\n    }\n  }\n\n  return React__default.createElement(MobXProviderContext.Provider, {\n    value: value\n  }, children);\n}\nProvider.displayName = \"MobXProvider\";\n\n/**\r\n * Store Injection\r\n */\n\nfunction createStoreInjector(grabStoresFn, component, injectNames, makeReactive) {\n  // Support forward refs\n  var Injector = React__default.forwardRef(function (props, ref) {\n    var newProps = _extends({}, props);\n\n    var context = React__default.useContext(MobXProviderContext);\n    Object.assign(newProps, grabStoresFn(context || {}, newProps) || {});\n\n    if (ref) {\n      newProps.ref = ref;\n    }\n\n    return React__default.createElement(component, newProps);\n  });\n  if (makeReactive) Injector = observer(Injector);\n  Injector[\"isMobxInjector\"] = true; // assigned late to suppress observer warning\n  // Static fields from component should be visible on the generated Injector\n\n  copyStaticProperties(component, Injector);\n  Injector[\"wrappedComponent\"] = component;\n  Injector.displayName = getInjectName(component, injectNames);\n  return Injector;\n}\n\nfunction getInjectName(component, injectNames) {\n  var displayName;\n  var componentName = component.displayName || component.name || component.constructor && component.constructor.name || \"Component\";\n  if (injectNames) displayName = \"inject-with-\" + injectNames + \"(\" + componentName + \")\";else displayName = \"inject(\" + componentName + \")\";\n  return displayName;\n}\n\nfunction grabStoresByName(storeNames) {\n  return function (baseStores, nextProps) {\n    storeNames.forEach(function (storeName) {\n      if (storeName in nextProps // prefer props over stores\n      ) return;\n      if (!(storeName in baseStores)) throw new Error(\"MobX injector: Store '\" + storeName + \"' is not available! Make sure it is provided by some Provider\");\n      nextProps[storeName] = baseStores[storeName];\n    });\n    return nextProps;\n  };\n}\n/**\r\n * higher order component that injects stores to a child.\r\n * takes either a varargs list of strings, which are stores read from the context,\r\n * or a function that manually maps the available stores from the context to props:\r\n * storesToProps(mobxStores, props, context) => newProps\r\n */\n\n\nfunction inject() {\n  for (var _len = arguments.length, storeNames = new Array(_len), _key = 0; _key < _len; _key++) {\n    storeNames[_key] = arguments[_key];\n  }\n\n  if (typeof arguments[0] === \"function\") {\n    var grabStoresFn = arguments[0];\n    return function (componentClass) {\n      return createStoreInjector(grabStoresFn, componentClass, grabStoresFn.name, true);\n    };\n  } else {\n    return function (componentClass) {\n      return createStoreInjector(grabStoresByName(storeNames), componentClass, storeNames.join(\"-\"), false);\n    };\n  }\n}\n\nvar protoStoreKey =\n/*#__PURE__*/\nnewSymbol(\"disposeOnUnmountProto\");\nvar instStoreKey =\n/*#__PURE__*/\nnewSymbol(\"disposeOnUnmountInst\");\n\nfunction runDisposersOnWillUnmount() {\n  var _this = this;\n  [].concat(this[protoStoreKey] || [], this[instStoreKey] || []).forEach(function (propKeyOrFunction) {\n    var prop = typeof propKeyOrFunction === \"string\" ? _this[propKeyOrFunction] : propKeyOrFunction;\n\n    if (prop !== undefined && prop !== null) {\n      if (Array.isArray(prop)) prop.map(function (f) {\n        return f();\n      });else prop();\n    }\n  });\n}\n\nfunction disposeOnUnmount(target, propertyKeyOrFunction) {\n  if (Array.isArray(propertyKeyOrFunction)) {\n    return propertyKeyOrFunction.map(function (fn) {\n      return disposeOnUnmount(target, fn);\n    });\n  }\n\n  var c = Object.getPrototypeOf(target).constructor;\n  var c2 = Object.getPrototypeOf(target.constructor); // Special case for react-hot-loader\n\n  var c3 = Object.getPrototypeOf(Object.getPrototypeOf(target));\n\n  if (!(c === React__default.Component || c === React__default.PureComponent || c2 === React__default.Component || c2 === React__default.PureComponent || c3 === React__default.Component || c3 === React__default.PureComponent)) {\n    throw new Error(\"[mobx-react] disposeOnUnmount only supports direct subclasses of React.Component or React.PureComponent.\");\n  }\n\n  if (typeof propertyKeyOrFunction !== \"string\" && typeof propertyKeyOrFunction !== \"function\" && !Array.isArray(propertyKeyOrFunction)) {\n    throw new Error(\"[mobx-react] disposeOnUnmount only works if the parameter is either a property key or a function.\");\n  } // decorator's target is the prototype, so it doesn't have any instance properties like props\n\n\n  var isDecorator = typeof propertyKeyOrFunction === \"string\"; // add property key / function we want run (disposed) to the store\n\n  var componentWasAlreadyModified = !!target[protoStoreKey] || !!target[instStoreKey];\n  var store = isDecorator ? // decorators are added to the prototype store\n  target[protoStoreKey] || (target[protoStoreKey] = []) : // functions are added to the instance store\n  target[instStoreKey] || (target[instStoreKey] = []);\n  store.push(propertyKeyOrFunction); // tweak the component class componentWillUnmount if not done already\n\n  if (!componentWasAlreadyModified) {\n    patch(target, \"componentWillUnmount\", runDisposersOnWillUnmount);\n  } // return the disposer as is if invoked as a non decorator\n\n\n  if (typeof propertyKeyOrFunction !== \"string\") {\n    return propertyKeyOrFunction;\n  }\n}\n\nfunction createChainableTypeChecker(validator) {\n  function checkType(isRequired, props, propName, componentName, location, propFullName) {\n    for (var _len = arguments.length, rest = new Array(_len > 6 ? _len - 6 : 0), _key = 6; _key < _len; _key++) {\n      rest[_key - 6] = arguments[_key];\n    }\n\n    return untracked(function () {\n      componentName = componentName || \"<<anonymous>>\";\n      propFullName = propFullName || propName;\n\n      if (props[propName] == null) {\n        if (isRequired) {\n          var actual = props[propName] === null ? \"null\" : \"undefined\";\n          return new Error(\"The \" + location + \" `\" + propFullName + \"` is marked as required \" + \"in `\" + componentName + \"`, but its value is `\" + actual + \"`.\");\n        }\n\n        return null;\n      } else {\n        // @ts-ignore rest arg is necessary for some React internals - fails tests otherwise\n        return validator.apply(void 0, [props, propName, componentName, location, propFullName].concat(rest));\n      }\n    });\n  }\n\n  var chainedCheckType = checkType.bind(null, false); // Add isRequired to satisfy Requirable\n\n  chainedCheckType.isRequired = checkType.bind(null, true);\n  return chainedCheckType;\n} // Copied from React.PropTypes\n\n\nfunction isSymbol(propType, propValue) {\n  // Native Symbol.\n  if (propType === \"symbol\") {\n    return true;\n  } // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\n\n\n  if (propValue[\"@@toStringTag\"] === \"Symbol\") {\n    return true;\n  } // Fallback for non-spec compliant Symbols which are polyfilled.\n\n\n  if (typeof Symbol === \"function\" && propValue instanceof Symbol) {\n    return true;\n  }\n\n  return false;\n} // Copied from React.PropTypes\n\n\nfunction getPropType(propValue) {\n  var propType = typeof propValue;\n\n  if (Array.isArray(propValue)) {\n    return \"array\";\n  }\n\n  if (propValue instanceof RegExp) {\n    // Old webkits (at least until Android 4.0) return 'function' rather than\n    // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n    // passes PropTypes.object.\n    return \"object\";\n  }\n\n  if (isSymbol(propType, propValue)) {\n    return \"symbol\";\n  }\n\n  return propType;\n} // This handles more types than `getPropType`. Only used for error messages.\n// Copied from React.PropTypes\n\n\nfunction getPreciseType(propValue) {\n  var propType = getPropType(propValue);\n\n  if (propType === \"object\") {\n    if (propValue instanceof Date) {\n      return \"date\";\n    } else if (propValue instanceof RegExp) {\n      return \"regexp\";\n    }\n  }\n\n  return propType;\n}\n\nfunction createObservableTypeCheckerCreator(allowNativeType, mobxType) {\n  return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {\n    return untracked(function () {\n      if (allowNativeType) {\n        if (getPropType(props[propName]) === mobxType.toLowerCase()) return null;\n      }\n\n      var mobxChecker;\n\n      switch (mobxType) {\n        case \"Array\":\n          mobxChecker = isObservableArray;\n          break;\n\n        case \"Object\":\n          mobxChecker = isObservableObject;\n          break;\n\n        case \"Map\":\n          mobxChecker = isObservableMap;\n          break;\n\n        default:\n          throw new Error(\"Unexpected mobxType: \" + mobxType);\n      }\n\n      var propValue = props[propName];\n\n      if (!mobxChecker(propValue)) {\n        var preciseType = getPreciseType(propValue);\n        var nativeTypeExpectationMessage = allowNativeType ? \" or javascript `\" + mobxType.toLowerCase() + \"`\" : \"\";\n        return new Error(\"Invalid prop `\" + propFullName + \"` of type `\" + preciseType + \"` supplied to\" + \" `\" + componentName + \"`, expected `mobx.Observable\" + mobxType + \"`\" + nativeTypeExpectationMessage + \".\");\n      }\n\n      return null;\n    });\n  });\n}\n\nfunction createObservableArrayOfTypeChecker(allowNativeType, typeChecker) {\n  return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {\n    for (var _len2 = arguments.length, rest = new Array(_len2 > 5 ? _len2 - 5 : 0), _key2 = 5; _key2 < _len2; _key2++) {\n      rest[_key2 - 5] = arguments[_key2];\n    }\n\n    return untracked(function () {\n      if (typeof typeChecker !== \"function\") {\n        return new Error(\"Property `\" + propFullName + \"` of component `\" + componentName + \"` has \" + \"invalid PropType notation.\");\n      } else {\n        var error = createObservableTypeCheckerCreator(allowNativeType, \"Array\")(props, propName, componentName, location, propFullName);\n        if (error instanceof Error) return error;\n        var propValue = props[propName];\n\n        for (var i = 0; i < propValue.length; i++) {\n          error = typeChecker.apply(void 0, [propValue, i, componentName, location, propFullName + \"[\" + i + \"]\"].concat(rest));\n          if (error instanceof Error) return error;\n        }\n\n        return null;\n      }\n    });\n  });\n}\n\nvar observableArray =\n/*#__PURE__*/\ncreateObservableTypeCheckerCreator(false, \"Array\");\nvar observableArrayOf =\n/*#__PURE__*/\ncreateObservableArrayOfTypeChecker.bind(null, false);\nvar observableMap =\n/*#__PURE__*/\ncreateObservableTypeCheckerCreator(false, \"Map\");\nvar observableObject =\n/*#__PURE__*/\ncreateObservableTypeCheckerCreator(false, \"Object\");\nvar arrayOrObservableArray =\n/*#__PURE__*/\ncreateObservableTypeCheckerCreator(true, \"Array\");\nvar arrayOrObservableArrayOf =\n/*#__PURE__*/\ncreateObservableArrayOfTypeChecker.bind(null, true);\nvar objectOrObservableObject =\n/*#__PURE__*/\ncreateObservableTypeCheckerCreator(true, \"Object\");\nvar PropTypes = {\n  observableArray: observableArray,\n  observableArrayOf: observableArrayOf,\n  observableMap: observableMap,\n  observableObject: observableObject,\n  arrayOrObservableArray: arrayOrObservableArray,\n  arrayOrObservableArrayOf: arrayOrObservableArrayOf,\n  objectOrObservableObject: objectOrObservableObject\n};\n\nif (!Component) throw new Error(\"mobx-react requires React to be available\");\nif (!observable) throw new Error(\"mobx-react requires mobx to be available\");\n\nexport { MobXProviderContext, PropTypes, Provider, disposeOnUnmount, inject, observer };\n//# sourceMappingURL=mobxreact.esm.js.map\n"],
  "mappings": "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",
  "names": ["init_virtual_process_polyfill", "init_buffer", "import_react", "symbolId", "createSymbol", "name", "symbol", "__name", "createdSymbols", "newSymbol", "shallowEqual", "objA", "objB", "is", "keysA", "keysB", "i", "x", "y", "hoistBlackList", "copyStaticProperties", "base", "target", "protoProps", "key", "setHiddenProp", "prop", "value", "mobxMixins", "mobxPatchedDefinition", "getMixins", "methodName", "mixins", "methodMixins", "wrapper", "realMethod", "_this", "_len", "args", "_key", "retVal", "mx", "wrapFunction", "fn", "_len2", "_key2", "patch", "mixinMethod", "oldDefinition", "originalMethod", "newDefinition", "createDefinition", "enumerable", "_ref", "wrappedFunc", "mobxAdminProperty", "$mobx", "mobxObserverProperty", "mobxIsUnmounted", "skipRenderKey", "isForcingUpdateKey", "makeClassComponentObserver", "componentClass", "displayName", "getDisplayName", "observerSCU", "makeObservableProp", "baseRender", "makeComponentReactive", "_this$render$mobxAdmi", "isUsingStaticRendering", "_displayName", "comp", "render", "initialName", "isRenderingPending", "reaction", "Reaction", "hasError", "reactiveRender", "exception", "rendering", "allowStateChanges", "e", "nextProps", "nextState", "propName", "valueHolderKey", "atomHolderKey", "getAtom", "createAtom", "prevReadState", "allowStateReadsStart", "allowStateReadsEnd", "v", "hasSymbol", "ReactForwardRefSymbol", "props", "ReactMemoSymbol", "observer", "component", "ObserverComponent", "_extends", "source", "_objectWithoutPropertiesLoose", "excluded", "sourceKeys", "MobXProviderContext", "React__default", "Provider", "children", "stores", "parentValue", "mutableProviderRef", "newValue", "createStoreInjector", "grabStoresFn", "injectNames", "makeReactive", "Injector", "ref", "newProps", "context", "getInjectName", "componentName", "grabStoresByName", "storeNames", "baseStores", "storeName", "inject", "observable"]
}