{"version":3,"sources":["webpack:///./node_modules/lodash-es/_root.js","webpack:///./node_modules/lodash-es/_Symbol.js","webpack:///./node_modules/lodash-es/_getRawTag.js","webpack:///./node_modules/lodash-es/_objectToString.js","webpack:///./node_modules/lodash-es/_baseGetTag.js","webpack:///./node_modules/lodash-es/_overArg.js","webpack:///./node_modules/lodash-es/_getPrototype.js","webpack:///./node_modules/lodash-es/isObjectLike.js","webpack:///./node_modules/lodash-es/isPlainObject.js","webpack:///./node_modules/redux/es/createStore.js","webpack:///./node_modules/redux/es/combineReducers.js","webpack:///./node_modules/redux/es/bindActionCreators.js","webpack:///./node_modules/redux/es/applyMiddleware.js","webpack:///./node_modules/react-redux/es/components/Context.js","webpack:///./node_modules/react-redux/es/utils/batch.js","webpack:///./node_modules/react-redux/es/utils/Subscription.js","webpack:///./node_modules/react-redux/es/components/Provider.js","webpack:///./node_modules/react-redux/es/components/connectAdvanced.js","webpack:///./node_modules/react-redux/es/utils/shallowEqual.js","webpack:///./node_modules/react-redux/es/connect/wrapMapToProps.js","webpack:///./node_modules/react-redux/es/connect/mapDispatchToProps.js","webpack:///./node_modules/react-redux/es/connect/mapStateToProps.js","webpack:///./node_modules/react-redux/es/connect/mergeProps.js","webpack:///./node_modules/react-redux/es/connect/selectorFactory.js","webpack:///./node_modules/react-redux/es/connect/connect.js","webpack:///./node_modules/react-redux/es/hooks/useReduxContext.js","webpack:///./node_modules/react-redux/es/hooks/useStore.js","webpack:///./node_modules/react-redux/es/hooks/useDispatch.js","webpack:///./node_modules/react-redux/es/hooks/useSelector.js","webpack:///./node_modules/react-redux/es/index.js","webpack:///./node_modules/invariant/browser.js","webpack:///./node_modules/ramda/es/internal/_isPlaceholder.js","webpack:///./node_modules/ramda/es/internal/_curry1.js","webpack:///./node_modules/ramda/es/always.js","webpack:///./node_modules/ramda/es/T.js","webpack:///./node_modules/ramda/es/__.js","webpack:///./node_modules/ramda/es/internal/_curry2.js","webpack:///./node_modules/ramda/es/internal/_concat.js","webpack:///./node_modules/ramda/es/internal/_arity.js","webpack:///./node_modules/ramda/es/internal/_curryN.js","webpack:///./node_modules/ramda/es/curryN.js","webpack:///./node_modules/ramda/es/internal/_curry3.js","webpack:///./node_modules/ramda/es/adjust.js","webpack:///./node_modules/ramda/es/internal/_isArray.js","webpack:///./node_modules/ramda/es/internal/_isTransformer.js","webpack:///./node_modules/ramda/es/internal/_dispatchable.js","webpack:///./node_modules/ramda/es/internal/_xfBase.js","webpack:///./node_modules/ramda/es/max.js","webpack:///./node_modules/ramda/es/internal/_map.js","webpack:///./node_modules/ramda/es/internal/_isString.js","webpack:///./node_modules/ramda/es/internal/_isArrayLike.js","webpack:///./node_modules/ramda/es/internal/_xwrap.js","webpack:///./node_modules/ramda/es/bind.js","webpack:///./node_modules/ramda/es/internal/_reduce.js","webpack:///./node_modules/ramda/es/internal/_xmap.js","webpack:///./node_modules/ramda/es/internal/_has.js","webpack:///./node_modules/ramda/es/internal/_isArguments.js","webpack:///./node_modules/ramda/es/keys.js","webpack:///./node_modules/ramda/es/map.js","webpack:///./node_modules/ramda/es/path.js","webpack:///./node_modules/ramda/es/prop.js","webpack:///./node_modules/ramda/es/pluck.js","webpack:///./node_modules/ramda/es/reduce.js","webpack:///./node_modules/ramda/es/anyPass.js","webpack:///./node_modules/ramda/es/ap.js","webpack:///./node_modules/ramda/es/internal/_isInteger.js","webpack:///./node_modules/ramda/es/internal/_xaperture.js","webpack:///./node_modules/ramda/es/isNil.js","webpack:///./node_modules/ramda/es/internal/_isFunction.js","webpack:///./node_modules/ramda/es/liftN.js","webpack:///./node_modules/ramda/es/lift.js","webpack:///./node_modules/ramda/es/type.js","webpack:///./node_modules/ramda/es/clone.js","webpack:///./node_modules/ramda/es/complement.js","webpack:///./node_modules/ramda/es/not.js","webpack:///./node_modules/ramda/es/internal/_pipe.js","webpack:///./node_modules/ramda/es/internal/_checkForMethod.js","webpack:///./node_modules/ramda/es/slice.js","webpack:///./node_modules/ramda/es/tail.js","webpack:///./node_modules/ramda/es/pipe.js","webpack:///./node_modules/ramda/es/internal/_arrayFromIterator.js","webpack:///./node_modules/ramda/es/internal/_containsWith.js","webpack:///./node_modules/ramda/es/identical.js","webpack:///./node_modules/ramda/es/internal/_equals.js","webpack:///./node_modules/ramda/es/internal/_functionName.js","webpack:///./node_modules/ramda/es/equals.js","webpack:///./node_modules/ramda/es/internal/_indexOf.js","webpack:///./node_modules/ramda/es/internal/_contains.js","webpack:///./node_modules/ramda/es/internal/_quote.js","webpack:///./node_modules/ramda/es/internal/_toISOString.js","webpack:///./node_modules/ramda/es/internal/_complement.js","webpack:///./node_modules/ramda/es/internal/_filter.js","webpack:///./node_modules/ramda/es/internal/_isObject.js","webpack:///./node_modules/ramda/es/internal/_xfilter.js","webpack:///./node_modules/ramda/es/filter.js","webpack:///./node_modules/ramda/es/reject.js","webpack:///./node_modules/ramda/es/internal/_toString.js","webpack:///./node_modules/ramda/es/toString.js","webpack:///./node_modules/ramda/es/concat.js","webpack:///./node_modules/ramda/es/cond.js","webpack:///./node_modules/ramda/es/contains.js","webpack:///./node_modules/ramda/es/defaultTo.js","webpack:///./node_modules/ramda/es/divide.js","webpack:///./node_modules/ramda/es/internal/_xdropLastWhile.js","webpack:///./node_modules/ramda/es/nth.js","webpack:///./node_modules/ramda/es/last.js","webpack:///./node_modules/ramda/es/or.js","webpack:///./node_modules/ramda/es/either.js","webpack:///./node_modules/ramda/es/empty.js","webpack:///./node_modules/ramda/es/flip.js","webpack:///./node_modules/ramda/es/forEach.js","webpack:///./node_modules/ramda/es/head.js","webpack:///./node_modules/ramda/es/internal/_assign.js","webpack:///./node_modules/ramda/es/into.js","webpack:///./node_modules/ramda/es/isEmpty.js","webpack:///./node_modules/ramda/es/length.js","webpack:///./node_modules/ramda/es/multiply.js","webpack:///./node_modules/ramda/es/partial.js","webpack:///./node_modules/ramda/es/pathEq.js","webpack:///./node_modules/ramda/es/pick.js","webpack:///./node_modules/ramda/es/prepend.js","webpack:///./node_modules/ramda/es/internal/_xtap.js","webpack:///./node_modules/ramda/es/tap.js","webpack:///./node_modules/ramda/es/test.js","webpack:///./node_modules/ramda/es/toPairs.js","webpack:///./node_modules/ramda/es/trim.js","webpack:///./node_modules/ramda/es/when.js","webpack:///./node_modules/classnames/bind.js","webpack:///./node_modules/@apollo/client/link/context/index.js","webpack:///./node_modules/react-spring/web.cjs.js","webpack:///./node_modules/react-dropzone/dist/index.js","webpack:///./node_modules/symbol-observable/es/index.js","webpack:///./node_modules/symbol-observable/es/ponyfill.js","webpack:///./node_modules/lodash-es/_freeGlobal.js","webpack:///./node_modules/@apollo/client/react/components/Query.js","webpack:///./node_modules/react-router-dom/esm/react-router-dom.js","webpack:///./node_modules/@babel/runtime/helpers/extends.js","webpack:///./node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js","webpack:///./node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack:///./node_modules/@apollo/client/react/context/ApolloConsumer.js","webpack:///./node_modules/@apollo/client/react/hoc/withApollo.js"],"names":["freeSelf","self","Object","Function","Symbol","objectProto","prototype","hasOwnProperty","nativeObjectToString","toString","symToStringTag","toStringTag","undefined","value","isOwn","call","tag","unmasked","e","result","func","transform","arg","getPrototypeOf","funcProto","funcToString","objectCtorString","proto","Ctor","constructor","ActionTypes","reducer","preloadedState","enhancer","_ref2","Error","currentReducer","currentState","currentListeners","nextListeners","isDispatching","ensureCanMutateNextListeners","slice","getState","subscribe","listener","isSubscribed","push","index","indexOf","splice","dispatch","action","type","listeners","i","length","replaceReducer","nextReducer","_ref","outerSubscribe","observer","TypeError","observeState","next","unsubscribe","this","getUndefinedStateErrorMessage","key","actionType","combineReducers","reducers","reducerKeys","keys","finalReducers","finalReducerKeys","shapeAssertionError","forEach","Math","random","substring","split","join","assertReducerShape","state","arguments","hasChanged","nextState","_i","_key","previousStateForKey","nextStateForKey","errorMessage","bindActionCreator","actionCreator","apply","bindActionCreators","actionCreators","boundActionCreators","assign","ReactReduxContext","createContext","callback","CLEARED","nullListeners","notify","createListenerCollection","batch","current","clear","get","Subscription","store","parentSub","handleChangeWrapper","bind","_proto","addNestedSub","trySubscribe","notifyNestedSubs","onStateChange","Boolean","tryUnsubscribe","Provider","context","children","contextValue","subscription","previousState","Context","createElement","propTypes","shape","isRequired","object","any","EMPTY_ARRAY","NO_SUBSCRIPTION_ARRAY","storeStateUpdatesReducer","updateCount","payload","initStateUpdates","useIsomorphicLayoutEffect","window","document","connectAdvanced","selectorFactory","_ref2$getDisplayName","getDisplayName","name","_ref2$methodName","methodName","_ref2$renderCountProp","renderCountProp","_ref2$shouldHandleSta","shouldHandleStateChanges","_ref2$storeKey","storeKey","_ref2$withRef","withRef","_ref2$forwardRef","forwardRef","_ref2$context","connectOptions","WrappedComponent","wrappedComponentName","displayName","selectorFactoryOptions","pure","usePureOnlyMemo","ConnectFunction","props","_useMemo","forwardedRef","wrapperProps","propsContext","ContextToUse","Consumer","didStoreComeFromProps","didStoreComeFromContext","childPropsSelector","createChildSelector","_useMemo2","overriddenContextValue","_useReducer","previousStateUpdateResult","forceComponentUpdateDispatch","error","lastChildProps","lastWrapperProps","childPropsFromStoreUpdate","renderIsScheduled","actualChildProps","didUnsubscribe","lastThrownError","checkForUpdates","newChildProps","latestStoreState","renderedWrappedComponent","ref","Connect","memo","forwarded","hasOwn","is","x","y","shallowEqual","objA","objB","keysA","keysB","wrapMapToPropsConstant","getConstant","options","constant","constantSelector","dependsOnOwnProps","getDependsOnOwnProps","mapToProps","wrapMapToPropsFunc","proxy","stateOrDispatch","ownProps","mapDispatchToProps","mapStateToProps","defaultMergeProps","stateProps","dispatchProps","mergeProps","mergedProps","areMergedPropsEqual","hasRunOnce","nextMergedProps","wrapMergePropsFunc","impureFinalPropsSelectorFactory","pureFinalPropsSelectorFactory","areStatesEqual","areOwnPropsEqual","areStatePropsEqual","hasRunAtLeastOnce","handleSubsequentCalls","nextOwnProps","nextStateProps","statePropsChanged","propsChanged","stateChanged","finalPropsSelectorFactory","initMapStateToProps","initMapDispatchToProps","initMergeProps","match","factories","strictEqual","a","b","_temp","_ref$connectHOC","connectHOC","_ref$mapStateToPropsF","mapStateToPropsFactories","_ref$mapDispatchToPro","mapDispatchToPropsFactories","_ref$mergePropsFactor","mergePropsFactories","_ref$selectorFactory","_ref3","_ref3$pure","_ref3$areStatesEqual","_ref3$areOwnPropsEqua","_ref3$areStatePropsEq","_ref3$areMergedPropsE","extraOptions","createStoreHook","useReduxContext","useStore","createDispatchHook","refEquality","createSelectorHook","newBatch","module","exports","condition","format","c","d","f","args","argIndex","replace","framesToPop","_isPlaceholder","_curry1","fn","f1","val","_curry2","f2","_b","_a","_concat","set1","set2","idx","len1","len2","_arity","n","a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","_curryN","received","combined","argsIdx","left","combinedIdx","_curry3","f3","_c","Array","_isTransformer","obj","_dispatchable","methodNames","xf","pop","_isArray","transducer","init","_map","functor","len","_isString","nodeType","XWrap","acc","_xwrap","thisObj","_iterableReduce","iter","step","done","_methodReduce","symIterator","iterator","_reduce","list","_arrayReduce","reduce","XMap","_xfBase","input","_has","prop","hasEnumBug","propertyIsEnumerable","nonEnumerableProps","hasArgsEnumBug","contains","item","nIdx","ks","checkArgsLength","paths","p","preds","applyF","applyX","ap","Number","_isFunction","arity","lifted","_pipe","g","_checkForMethod","methodname","fromIndex","toIndex","Infinity","pipe","_arrayFromIterator","_containsWith","pred","_uniqContentEquals","aIterator","bIterator","stackA","stackB","eq","_equals","aItem","typeA","equals","String","_functionName","valueOf","message","source","global","ignoreCase","multiline","sticky","unicode","size","entries","concat","values","extendedStackA","extendedStackB","_indexOf","inf","_contains","_quote","s","pad","Date","toISOString","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","toFixed","_complement","_filter","_isObject","XFilter","filterable","_toString","seen","recur","xs","mapPairs","k","sort","test","isNaN","NaN","repr","pairs","pair","v","offset","charAt","empty","_path","names","XTap","ws","trim","whenTrueFn","classNames","classes","argType","isArray","default","setContext","setter","operation","forward","request","handle","closed","Promise","resolve","then","req","getContext","complete","catch","_interopDefault","ex","defineProperty","_extends","_objectWithoutPropertiesLoose","React","React__default","_inheritsLoose","_assertThisInitialized","arr","fun","str","num","und","nul","set","Set","map","Map","equ","useForceUpdate","useState","useCallback","withDefault","defaultValue","toArray","callProp","_len","interpolateTo","to","from","config","onStart","onRest","onFrame","reset","reverse","force","immediate","delay","attach","destroyed","lazy","getForwardProps","rest","_extends2","applyAnimatedValues","colorNames","Animated","getAnimatedValue","getValue","getPayload","detach","getChildren","addChild","child","removeChild","AnimatedArray","_Animated","_this","AnimatedObject","_Animated2","_this2","_len3","_key3","_proto2","animated","_key4","injectApplyAnimatedValues","injectColorNames","interpolation","requestFrame","cb","requestAnimationFrame","cancelFrame","id","cancelAnimationFrame","injectStringInterpolator","defaultElement","now","injectDefaultElement","el","createAnimatedStyle","manualFrameloop","animatedApi","node","injectCreateAnimatedStyle","factory","Globals","freeze","injectFrame","raf","caf","injectNow","nowFn","injectAnimatedApi","injectManualFrameloop","AnimatedProps","_AnimatedObject","update","style","active","controllers","time","_iterator","controller","isActive","configIdx","configs","endOfAnimation","lastTime","valIdx","animatedValues","animation","fromValues","toValues","position","lastPosition","isAnimated","velocity","initialVelocity","setValue","duration","easing","startTime","decay","exp","abs","lastVelocity","numSteps","floor","tension","friction","mass","isOvershooting","clamp","isVelocity","precision","isDisplacement","delete","stop","createInterpolator","range","output","extrapolate","outputRange","inputRange","extrapolateLeft","extrapolateRight","t","findRange","inputMin","inputMax","outputMin","outputMax","interpolate","AnimatedInterpolation","_AnimatedArray","parents","calc","updateConfig","addAnimatedStyles","styles","add","AnimatedValue","_value","animatedStyles","startPosition","flush","animatedStyle","clearStyles","AnimatedValueArray","G","Controller","idle","guid","local","merged","animations","interpolations","queue","localQueue","getValues","_ref$delay","ops","_to","entry","previous","diff","start","onEnd","_ref3$from","_ref3$to","_ref4","finished","async","setTimeout","runAsync","has","pause","_ref5","_this3","_loop","fresh","r","last","_this4","_this$props","_this$props$from","_this$props$to","_this$props$config","_ref6","target","_ref7","isNumber","isString","startsWith","isInterpolation","fromValue","toValue","toConfig","parent","interpolation$$1","newValue","_extends3","currentValue","some","currentValueDiffersFromGoal","hasNewGoal","hasNewConfig","prev","destroy","useSprings","mounted","useRef","ctrl","isFn","useMemo","fill","_","newProps","useImperativeHandle","all","updateCtrl","updateProps","useEffect","propValues","ENTER","LEAVE","UPDATE","mapKeys","items","_props$keys","cleanUp","filterKey","_ref8","filter","instances","transitions","deleted","forceUpdate","AnimatedStyle","colors","transparent","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","burntsienna","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkgrey","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","green","greenyellow","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","NUMBER","PERCENTAGE","parts","rgb","RegExp","rgba","hsl","hsla","hex3","hex4","hex6","hex8","hue2rgb","q","hslToRgb","h","l","round","parse255","int","parseInt","parse360","parseFloat","parse1","parsePercentage","colorToRgba","color","int32Color","exec","stringShapeRegex","colorRegex","colorNamesRegex","isUnitlessNumber","animationIterationCount","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","columns","flex","flexGrow","flexPositive","flexShrink","flexNegative","flexOrder","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","fontWeight","lineClamp","lineHeight","opacity","order","orphans","tabSize","widows","zIndex","zoom","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","strokeWidth","prefixes","dangerousStyleValue","isCustomProperty","prefix","toUpperCase","prefixKey","attributeCache","rangeValue","outputRanges","number","p1","p2","p3","p4","instance","setAttribute","scrollTop","scrollLeft","attributes","nodeName","parentNode","styleName","textContent","styleValue","setProperty","dashCase","toLowerCase","getAttribute","lowercase","Component","propsAnimated","attachProps","oldPropsAnimated","didUpdate","_getValue","animatedProps","refFn","childRef","handleRef","element","extendedAnimated","gentle","wobbly","stiff","slow","molasses","useSpring","_useSprings","useTrail","attachIdx","attachController","useTransition","keyTransform","_get","_get$lazy","_get$reset","unique","onDestroyed","enter","leave","_onRest","extra","first","prevProps","paused","_ref9","_get2","initial","_get2$trail","trail","_get2$order","_get3","_keys","_items","currentKeys","currentSet","nextSet","added","removed","originalKey","updated","shift","find","keyIndex","slot","unshift","max","right","min","out","_ref10","pos","findIndex","changed","diffItems","transition","useChain","refs","timeSteps","timeFrame","ctrls","rI","__WEBPACK_EXTERNAL_MODULE_2__","__WEBPACK_EXTERNAL_MODULE_3__","modules","installedModules","__webpack_require__","moduleId","loaded","m","process","_createClass","defineProperties","descriptor","enumerable","configurable","writable","Constructor","protoProps","staticProps","_react2","_interopRequireDefault","_propTypes2","_attrAccept2","_getDataTransferItems2","__esModule","_objectWithoutProperties","supportMultiple","fileAccepted","file","accept","Dropzone","_React$Component","_classCallCheck","ReferenceError","_possibleConstructorReturn","__proto__","renderChildren","isDragActive","isDragAccept","isDragReject","composeHandlers","onClick","onDocumentDrop","onDragEnter","onDragLeave","onDragOver","onDragStart","onDrop","onFileDialogCancel","onInputElementClick","setRef","setRefs","isFileDialogActive","draggedFiles","acceptedFiles","rejectedFiles","subClass","superClass","create","setPrototypeOf","_inherits","evt","preventDefault","preventDropOnDocument","dragTargets","addEventListener","onDocumentDragOver","fileInputEl","body","onfocus","removeEventListener","handler","disabled","setState","stopPropagation","dataTransfer","dropEffect","err","_props","onDropAccepted","onDropRejected","multiple","disablePreview","fileList","preview","URL","createObjectURL","env","NODE_ENV","console","fileMatchSize","arr2","_toConsumableArray","_props2","disableClick","open","inputProps","files","maxSize","minSize","every","click","_props3","acceptClassName","activeClassName","disabledClassName","rejectClassName","acceptStyle","activeStyle","className","disabledStyle","rejectStyle","_state","filesCount","isMultipleAllowed","allFilesAccepted","width","height","borderWidth","borderColor","borderStyle","borderRadius","backgroundColor","appliedStyle","inputAttributes","display","onChange","autoComplete","divProps","string","oneOfType","bool","defaultProps","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","clearTimeout","currentQueue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","run","marker","runClearTimeout","Item","array","noop","nextTick","title","browser","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","binding","cwd","chdir","dir","umask","o","endsWith","__e","__g","u","P","S","F","B","core","W","setDesc","getProto","isEnum","getDesc","getOwnPropertyDescriptor","setDescs","getKeys","getNames","getOwnPropertyNames","getSymbols","getOwnPropertySymbols","each","inspectSource","ceil","event","dataTransferItemsList","dt","root","symbolObservablePonyfill","observable","freeGlobal","Query","query","client","fetchPolicy","notifyOnNetworkStatusChange","onCompleted","onError","pollInterval","variables","ssr","partialRefetch","returnPartialData","BrowserRouter","history","render","resolveToLocation","currentLocation","normalizeToLocation","forwardRefShim","C","LinkAnchor","innerRef","navigate","_onClick","defaultPrevented","button","metaKey","altKey","ctrlKey","shiftKey","isModifiedEvent","Link","_ref2$component","component","location","href","createHref","forwardRefShim$1","forwardRef$1","_ref$ariaCurrent","ariaCurrent","_ref$activeClassName","classNameProp","exact","isActiveProp","locationProp","strict","styleProp","toLocation","path","pathname","escapedPath","classnames","joinClassnames","excluded","sourceKeys","ApolloConsumer","ApolloContext","withApollo","operationOptions","withDisplayName","WithApollo","_super","setWrappedInstance","getWrappedInstance","wrappedInstance"],"mappings":"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","file":"js/5-e27fe2a2c7adfd4c1d5b.chunk.js","sourcesContent":["import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nexport default root;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nexport default getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nexport default objectToString;\n","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nexport default baseGetTag;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nexport default overArg;\n","import overArg from './_overArg.js';\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nexport default getPrototype;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n","import baseGetTag from './_baseGetTag.js';\nimport getPrototype from './_getPrototype.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n    objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n    return false;\n  }\n  var proto = getPrototype(value);\n  if (proto === null) {\n    return true;\n  }\n  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n  return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n    funcToString.call(Ctor) == objectCtorString;\n}\n\nexport default isPlainObject;\n","import isPlainObject from 'lodash-es/isPlainObject';\nimport $$observable from 'symbol-observable';\n\n/**\n * These are private action types reserved by Redux.\n * For any unknown actions, you must return the current state.\n * If the current state is undefined, you must return the initial state.\n * Do not reference these action types directly in your code.\n */\nexport var ActionTypes = {\n  INIT: '@@redux/INIT'\n\n  /**\n   * Creates a Redux store that holds the state tree.\n   * The only way to change the data in the store is to call `dispatch()` on it.\n   *\n   * There should only be a single store in your app. To specify how different\n   * parts of the state tree respond to actions, you may combine several reducers\n   * into a single reducer function by using `combineReducers`.\n   *\n   * @param {Function} reducer A function that returns the next state tree, given\n   * the current state tree and the action to handle.\n   *\n   * @param {any} [preloadedState] The initial state. You may optionally specify it\n   * to hydrate the state from the server in universal apps, or to restore a\n   * previously serialized user session.\n   * If you use `combineReducers` to produce the root reducer function, this must be\n   * an object with the same shape as `combineReducers` keys.\n   *\n   * @param {Function} [enhancer] The store enhancer. You may optionally specify it\n   * to enhance the store with third-party capabilities such as middleware,\n   * time travel, persistence, etc. The only store enhancer that ships with Redux\n   * is `applyMiddleware()`.\n   *\n   * @returns {Store} A Redux store that lets you read the state, dispatch actions\n   * and subscribe to changes.\n   */\n};export default function createStore(reducer, preloadedState, enhancer) {\n  var _ref2;\n\n  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {\n    enhancer = preloadedState;\n    preloadedState = undefined;\n  }\n\n  if (typeof enhancer !== 'undefined') {\n    if (typeof enhancer !== 'function') {\n      throw new Error('Expected the enhancer to be a function.');\n    }\n\n    return enhancer(createStore)(reducer, preloadedState);\n  }\n\n  if (typeof reducer !== 'function') {\n    throw new Error('Expected the reducer to be a function.');\n  }\n\n  var currentReducer = reducer;\n  var currentState = preloadedState;\n  var currentListeners = [];\n  var nextListeners = currentListeners;\n  var isDispatching = false;\n\n  function ensureCanMutateNextListeners() {\n    if (nextListeners === currentListeners) {\n      nextListeners = currentListeners.slice();\n    }\n  }\n\n  /**\n   * Reads the state tree managed by the store.\n   *\n   * @returns {any} The current state tree of your application.\n   */\n  function getState() {\n    return currentState;\n  }\n\n  /**\n   * Adds a change listener. It will be called any time an action is dispatched,\n   * and some part of the state tree may potentially have changed. You may then\n   * call `getState()` to read the current state tree inside the callback.\n   *\n   * You may call `dispatch()` from a change listener, with the following\n   * caveats:\n   *\n   * 1. The subscriptions are snapshotted just before every `dispatch()` call.\n   * If you subscribe or unsubscribe while the listeners are being invoked, this\n   * will not have any effect on the `dispatch()` that is currently in progress.\n   * However, the next `dispatch()` call, whether nested or not, will use a more\n   * recent snapshot of the subscription list.\n   *\n   * 2. The listener should not expect to see all state changes, as the state\n   * might have been updated multiple times during a nested `dispatch()` before\n   * the listener is called. It is, however, guaranteed that all subscribers\n   * registered before the `dispatch()` started will be called with the latest\n   * state by the time it exits.\n   *\n   * @param {Function} listener A callback to be invoked on every dispatch.\n   * @returns {Function} A function to remove this change listener.\n   */\n  function subscribe(listener) {\n    if (typeof listener !== 'function') {\n      throw new Error('Expected listener to be a function.');\n    }\n\n    var isSubscribed = true;\n\n    ensureCanMutateNextListeners();\n    nextListeners.push(listener);\n\n    return function unsubscribe() {\n      if (!isSubscribed) {\n        return;\n      }\n\n      isSubscribed = false;\n\n      ensureCanMutateNextListeners();\n      var index = nextListeners.indexOf(listener);\n      nextListeners.splice(index, 1);\n    };\n  }\n\n  /**\n   * Dispatches an action. It is the only way to trigger a state change.\n   *\n   * The `reducer` function, used to create the store, will be called with the\n   * current state tree and the given `action`. Its return value will\n   * be considered the **next** state of the tree, and the change listeners\n   * will be notified.\n   *\n   * The base implementation only supports plain object actions. If you want to\n   * dispatch a Promise, an Observable, a thunk, or something else, you need to\n   * wrap your store creating function into the corresponding middleware. For\n   * example, see the documentation for the `redux-thunk` package. Even the\n   * middleware will eventually dispatch plain object actions using this method.\n   *\n   * @param {Object} action A plain object representing “what changed”. It is\n   * a good idea to keep actions serializable so you can record and replay user\n   * sessions, or use the time travelling `redux-devtools`. An action must have\n   * a `type` property which may not be `undefined`. It is a good idea to use\n   * string constants for action types.\n   *\n   * @returns {Object} For convenience, the same action object you dispatched.\n   *\n   * Note that, if you use a custom middleware, it may wrap `dispatch()` to\n   * return something else (for example, a Promise you can await).\n   */\n  function dispatch(action) {\n    if (!isPlainObject(action)) {\n      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');\n    }\n\n    if (typeof action.type === 'undefined') {\n      throw new Error('Actions may not have an undefined \"type\" property. ' + 'Have you misspelled a constant?');\n    }\n\n    if (isDispatching) {\n      throw new Error('Reducers may not dispatch actions.');\n    }\n\n    try {\n      isDispatching = true;\n      currentState = currentReducer(currentState, action);\n    } finally {\n      isDispatching = false;\n    }\n\n    var listeners = currentListeners = nextListeners;\n    for (var i = 0; i < listeners.length; i++) {\n      var listener = listeners[i];\n      listener();\n    }\n\n    return action;\n  }\n\n  /**\n   * Replaces the reducer currently used by the store to calculate the state.\n   *\n   * You might need this if your app implements code splitting and you want to\n   * load some of the reducers dynamically. You might also need this if you\n   * implement a hot reloading mechanism for Redux.\n   *\n   * @param {Function} nextReducer The reducer for the store to use instead.\n   * @returns {void}\n   */\n  function replaceReducer(nextReducer) {\n    if (typeof nextReducer !== 'function') {\n      throw new Error('Expected the nextReducer to be a function.');\n    }\n\n    currentReducer = nextReducer;\n    dispatch({ type: ActionTypes.INIT });\n  }\n\n  /**\n   * Interoperability point for observable/reactive libraries.\n   * @returns {observable} A minimal observable of state changes.\n   * For more information, see the observable proposal:\n   * https://github.com/tc39/proposal-observable\n   */\n  function observable() {\n    var _ref;\n\n    var outerSubscribe = subscribe;\n    return _ref = {\n      /**\n       * The minimal observable subscription method.\n       * @param {Object} observer Any object that can be used as an observer.\n       * The observer object should have a `next` method.\n       * @returns {subscription} An object with an `unsubscribe` method that can\n       * be used to unsubscribe the observable from the store, and prevent further\n       * emission of values from the observable.\n       */\n      subscribe: function subscribe(observer) {\n        if (typeof observer !== 'object') {\n          throw new TypeError('Expected the observer to be an object.');\n        }\n\n        function observeState() {\n          if (observer.next) {\n            observer.next(getState());\n          }\n        }\n\n        observeState();\n        var unsubscribe = outerSubscribe(observeState);\n        return { unsubscribe: unsubscribe };\n      }\n    }, _ref[$$observable] = function () {\n      return this;\n    }, _ref;\n  }\n\n  // When a store is created, an \"INIT\" action is dispatched so that every\n  // reducer returns their initial state. This effectively populates\n  // the initial state tree.\n  dispatch({ type: ActionTypes.INIT });\n\n  return _ref2 = {\n    dispatch: dispatch,\n    subscribe: subscribe,\n    getState: getState,\n    replaceReducer: replaceReducer\n  }, _ref2[$$observable] = observable, _ref2;\n}","import { ActionTypes } from './createStore';\nimport isPlainObject from 'lodash-es/isPlainObject';\nimport warning from './utils/warning';\n\nfunction getUndefinedStateErrorMessage(key, action) {\n  var actionType = action && action.type;\n  var actionName = actionType && '\"' + actionType.toString() + '\"' || 'an action';\n\n  return 'Given action ' + actionName + ', reducer \"' + key + '\" returned undefined. ' + 'To ignore an action, you must explicitly return the previous state. ' + 'If you want this reducer to hold no value, you can return null instead of undefined.';\n}\n\nfunction getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {\n  var reducerKeys = Object.keys(reducers);\n  var argumentName = action && action.type === ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';\n\n  if (reducerKeys.length === 0) {\n    return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';\n  }\n\n  if (!isPlainObject(inputState)) {\n    return 'The ' + argumentName + ' has unexpected type of \"' + {}.toString.call(inputState).match(/\\s([a-z|A-Z]+)/)[1] + '\". Expected argument to be an object with the following ' + ('keys: \"' + reducerKeys.join('\", \"') + '\"');\n  }\n\n  var unexpectedKeys = Object.keys(inputState).filter(function (key) {\n    return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];\n  });\n\n  unexpectedKeys.forEach(function (key) {\n    unexpectedKeyCache[key] = true;\n  });\n\n  if (unexpectedKeys.length > 0) {\n    return 'Unexpected ' + (unexpectedKeys.length > 1 ? 'keys' : 'key') + ' ' + ('\"' + unexpectedKeys.join('\", \"') + '\" found in ' + argumentName + '. ') + 'Expected to find one of the known reducer keys instead: ' + ('\"' + reducerKeys.join('\", \"') + '\". Unexpected keys will be ignored.');\n  }\n}\n\nfunction assertReducerShape(reducers) {\n  Object.keys(reducers).forEach(function (key) {\n    var reducer = reducers[key];\n    var initialState = reducer(undefined, { type: ActionTypes.INIT });\n\n    if (typeof initialState === 'undefined') {\n      throw new Error('Reducer \"' + key + '\" returned undefined during initialization. ' + 'If the state passed to the reducer is undefined, you must ' + 'explicitly return the initial state. The initial state may ' + 'not be undefined. If you don\\'t want to set a value for this reducer, ' + 'you can use null instead of undefined.');\n    }\n\n    var type = '@@redux/PROBE_UNKNOWN_ACTION_' + Math.random().toString(36).substring(7).split('').join('.');\n    if (typeof reducer(undefined, { type: type }) === 'undefined') {\n      throw new Error('Reducer \"' + key + '\" returned undefined when probed with a random type. ' + ('Don\\'t try to handle ' + ActionTypes.INIT + ' or other actions in \"redux/*\" ') + 'namespace. They are considered private. Instead, you must return the ' + 'current state for any unknown actions, unless it is undefined, ' + 'in which case you must return the initial state, regardless of the ' + 'action type. The initial state may not be undefined, but can be null.');\n    }\n  });\n}\n\n/**\n * Turns an object whose values are different reducer functions, into a single\n * reducer function. It will call every child reducer, and gather their results\n * into a single state object, whose keys correspond to the keys of the passed\n * reducer functions.\n *\n * @param {Object} reducers An object whose values correspond to different\n * reducer functions that need to be combined into one. One handy way to obtain\n * it is to use ES6 `import * as reducers` syntax. The reducers may never return\n * undefined for any action. Instead, they should return their initial state\n * if the state passed to them was undefined, and the current state for any\n * unrecognized action.\n *\n * @returns {Function} A reducer function that invokes every reducer inside the\n * passed object, and builds a state object with the same shape.\n */\nexport default function combineReducers(reducers) {\n  var reducerKeys = Object.keys(reducers);\n  var finalReducers = {};\n  for (var i = 0; i < reducerKeys.length; i++) {\n    var key = reducerKeys[i];\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (typeof reducers[key] === 'undefined') {\n        warning('No reducer provided for key \"' + key + '\"');\n      }\n    }\n\n    if (typeof reducers[key] === 'function') {\n      finalReducers[key] = reducers[key];\n    }\n  }\n  var finalReducerKeys = Object.keys(finalReducers);\n\n  var unexpectedKeyCache = void 0;\n  if (process.env.NODE_ENV !== 'production') {\n    unexpectedKeyCache = {};\n  }\n\n  var shapeAssertionError = void 0;\n  try {\n    assertReducerShape(finalReducers);\n  } catch (e) {\n    shapeAssertionError = e;\n  }\n\n  return function combination() {\n    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var action = arguments[1];\n\n    if (shapeAssertionError) {\n      throw shapeAssertionError;\n    }\n\n    if (process.env.NODE_ENV !== 'production') {\n      var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);\n      if (warningMessage) {\n        warning(warningMessage);\n      }\n    }\n\n    var hasChanged = false;\n    var nextState = {};\n    for (var _i = 0; _i < finalReducerKeys.length; _i++) {\n      var _key = finalReducerKeys[_i];\n      var reducer = finalReducers[_key];\n      var previousStateForKey = state[_key];\n      var nextStateForKey = reducer(previousStateForKey, action);\n      if (typeof nextStateForKey === 'undefined') {\n        var errorMessage = getUndefinedStateErrorMessage(_key, action);\n        throw new Error(errorMessage);\n      }\n      nextState[_key] = nextStateForKey;\n      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;\n    }\n    return hasChanged ? nextState : state;\n  };\n}","function bindActionCreator(actionCreator, dispatch) {\n  return function () {\n    return dispatch(actionCreator.apply(undefined, arguments));\n  };\n}\n\n/**\n * Turns an object whose values are action creators, into an object with the\n * same keys, but with every function wrapped into a `dispatch` call so they\n * may be invoked directly. This is just a convenience method, as you can call\n * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.\n *\n * For convenience, you can also pass a single function as the first argument,\n * and get a function in return.\n *\n * @param {Function|Object} actionCreators An object whose values are action\n * creator functions. One handy way to obtain it is to use ES6 `import * as`\n * syntax. You may also pass a single function.\n *\n * @param {Function} dispatch The `dispatch` function available on your Redux\n * store.\n *\n * @returns {Function|Object} The object mimicking the original object, but with\n * every action creator wrapped into the `dispatch` call. If you passed a\n * function as `actionCreators`, the return value will also be a single\n * function.\n */\nexport default function bindActionCreators(actionCreators, dispatch) {\n  if (typeof actionCreators === 'function') {\n    return bindActionCreator(actionCreators, dispatch);\n  }\n\n  if (typeof actionCreators !== 'object' || actionCreators === null) {\n    throw new Error('bindActionCreators expected an object or a function, instead received ' + (actionCreators === null ? 'null' : typeof actionCreators) + '. ' + 'Did you write \"import ActionCreators from\" instead of \"import * as ActionCreators from\"?');\n  }\n\n  var keys = Object.keys(actionCreators);\n  var boundActionCreators = {};\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    var actionCreator = actionCreators[key];\n    if (typeof actionCreator === 'function') {\n      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);\n    }\n  }\n  return boundActionCreators;\n}","var _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; };\n\nimport compose from './compose';\n\n/**\n * Creates a store enhancer that applies middleware to the dispatch method\n * of the Redux store. This is handy for a variety of tasks, such as expressing\n * asynchronous actions in a concise manner, or logging every action payload.\n *\n * See `redux-thunk` package as an example of the Redux middleware.\n *\n * Because middleware is potentially asynchronous, this should be the first\n * store enhancer in the composition chain.\n *\n * Note that each middleware will be given the `dispatch` and `getState` functions\n * as named arguments.\n *\n * @param {...Function} middlewares The middleware chain to be applied.\n * @returns {Function} A store enhancer applying the middleware.\n */\nexport default function applyMiddleware() {\n  for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {\n    middlewares[_key] = arguments[_key];\n  }\n\n  return function (createStore) {\n    return function (reducer, preloadedState, enhancer) {\n      var store = createStore(reducer, preloadedState, enhancer);\n      var _dispatch = store.dispatch;\n      var chain = [];\n\n      var middlewareAPI = {\n        getState: store.getState,\n        dispatch: function dispatch(action) {\n          return _dispatch(action);\n        }\n      };\n      chain = middlewares.map(function (middleware) {\n        return middleware(middlewareAPI);\n      });\n      _dispatch = compose.apply(undefined, chain)(store.dispatch);\n\n      return _extends({}, store, {\n        dispatch: _dispatch\n      });\n    };\n  };\n}","import React from 'react';\nexport var ReactReduxContext = React.createContext(null);\nexport default ReactReduxContext;","// Default to a dummy \"batch\" implementation that just runs the callback\nfunction defaultNoopBatch(callback) {\n  callback();\n}\n\nvar batch = defaultNoopBatch; // Allow injecting another batching function later\n\nexport var setBatch = function setBatch(newBatch) {\n  return batch = newBatch;\n}; // Supply a getter just to skip dealing with ESM bindings\n\nexport var getBatch = function getBatch() {\n  return batch;\n};","import { getBatch } from './batch'; // encapsulates the subscription logic for connecting a component to the redux store, as\n// well as nesting subscriptions of descendant components, so that we can ensure the\n// ancestor components re-render before descendants\n\nvar CLEARED = null;\nvar nullListeners = {\n  notify: function notify() {}\n};\n\nfunction createListenerCollection() {\n  var batch = getBatch(); // the current/next pattern is copied from redux's createStore code.\n  // TODO: refactor+expose that code to be reusable here?\n\n  var current = [];\n  var next = [];\n  return {\n    clear: function clear() {\n      next = CLEARED;\n      current = CLEARED;\n    },\n    notify: function notify() {\n      var listeners = current = next;\n      batch(function () {\n        for (var i = 0; i < listeners.length; i++) {\n          listeners[i]();\n        }\n      });\n    },\n    get: function get() {\n      return next;\n    },\n    subscribe: function subscribe(listener) {\n      var isSubscribed = true;\n      if (next === current) next = current.slice();\n      next.push(listener);\n      return function unsubscribe() {\n        if (!isSubscribed || current === CLEARED) return;\n        isSubscribed = false;\n        if (next === current) next = current.slice();\n        next.splice(next.indexOf(listener), 1);\n      };\n    }\n  };\n}\n\nvar Subscription =\n/*#__PURE__*/\nfunction () {\n  function Subscription(store, parentSub) {\n    this.store = store;\n    this.parentSub = parentSub;\n    this.unsubscribe = null;\n    this.listeners = nullListeners;\n    this.handleChangeWrapper = this.handleChangeWrapper.bind(this);\n  }\n\n  var _proto = Subscription.prototype;\n\n  _proto.addNestedSub = function addNestedSub(listener) {\n    this.trySubscribe();\n    return this.listeners.subscribe(listener);\n  };\n\n  _proto.notifyNestedSubs = function notifyNestedSubs() {\n    this.listeners.notify();\n  };\n\n  _proto.handleChangeWrapper = function handleChangeWrapper() {\n    if (this.onStateChange) {\n      this.onStateChange();\n    }\n  };\n\n  _proto.isSubscribed = function isSubscribed() {\n    return Boolean(this.unsubscribe);\n  };\n\n  _proto.trySubscribe = function trySubscribe() {\n    if (!this.unsubscribe) {\n      this.unsubscribe = this.parentSub ? this.parentSub.addNestedSub(this.handleChangeWrapper) : this.store.subscribe(this.handleChangeWrapper);\n      this.listeners = createListenerCollection();\n    }\n  };\n\n  _proto.tryUnsubscribe = function tryUnsubscribe() {\n    if (this.unsubscribe) {\n      this.unsubscribe();\n      this.unsubscribe = null;\n      this.listeners.clear();\n      this.listeners = nullListeners;\n    }\n  };\n\n  return Subscription;\n}();\n\nexport { Subscription as default };","import React, { useMemo, useEffect } from 'react';\nimport PropTypes from 'prop-types';\nimport { ReactReduxContext } from './Context';\nimport Subscription from '../utils/Subscription';\n\nfunction Provider(_ref) {\n  var store = _ref.store,\n      context = _ref.context,\n      children = _ref.children;\n  var contextValue = useMemo(function () {\n    var subscription = new Subscription(store);\n    subscription.onStateChange = subscription.notifyNestedSubs;\n    return {\n      store: store,\n      subscription: subscription\n    };\n  }, [store]);\n  var previousState = useMemo(function () {\n    return store.getState();\n  }, [store]);\n  useEffect(function () {\n    var subscription = contextValue.subscription;\n    subscription.trySubscribe();\n\n    if (previousState !== store.getState()) {\n      subscription.notifyNestedSubs();\n    }\n\n    return function () {\n      subscription.tryUnsubscribe();\n      subscription.onStateChange = null;\n    };\n  }, [contextValue, previousState]);\n  var Context = context || ReactReduxContext;\n  return React.createElement(Context.Provider, {\n    value: contextValue\n  }, children);\n}\n\nProvider.propTypes = {\n  store: PropTypes.shape({\n    subscribe: PropTypes.func.isRequired,\n    dispatch: PropTypes.func.isRequired,\n    getState: PropTypes.func.isRequired\n  }),\n  context: PropTypes.object,\n  children: PropTypes.any\n};\nexport default Provider;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport hoistStatics from 'hoist-non-react-statics';\nimport invariant from 'invariant';\nimport React, { useContext, useMemo, useEffect, useLayoutEffect, useRef, useReducer } from 'react';\nimport { isValidElementType, isContextConsumer } from 'react-is';\nimport Subscription from '../utils/Subscription';\nimport { ReactReduxContext } from './Context'; // Define some constant arrays just to avoid re-creating these\n\nvar EMPTY_ARRAY = [];\nvar NO_SUBSCRIPTION_ARRAY = [null, null];\n\nvar stringifyComponent = function stringifyComponent(Comp) {\n  try {\n    return JSON.stringify(Comp);\n  } catch (err) {\n    return String(Comp);\n  }\n};\n\nfunction storeStateUpdatesReducer(state, action) {\n  var updateCount = state[1];\n  return [action.payload, updateCount + 1];\n}\n\nvar initStateUpdates = function initStateUpdates() {\n  return [null, 0];\n}; // React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser. We need useLayoutEffect because we want\n// `connect` to perform sync updates to a ref to save the latest props after\n// a render is actually committed to the DOM.\n\n\nvar useIsomorphicLayoutEffect = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined' ? useLayoutEffect : useEffect;\nexport default function connectAdvanced(\n/*\n  selectorFactory is a func that is responsible for returning the selector function used to\n  compute new props from state, props, and dispatch. For example:\n     export default connectAdvanced((dispatch, options) => (state, props) => ({\n      thing: state.things[props.thingId],\n      saveThing: fields => dispatch(actionCreators.saveThing(props.thingId, fields)),\n    }))(YourComponent)\n   Access to dispatch is provided to the factory so selectorFactories can bind actionCreators\n  outside of their selector as an optimization. Options passed to connectAdvanced are passed to\n  the selectorFactory, along with displayName and WrappedComponent, as the second argument.\n   Note that selectorFactory is responsible for all caching/memoization of inbound and outbound\n  props. Do not use connectAdvanced directly without memoizing results between calls to your\n  selector, otherwise the Connect component will re-render on every state or props change.\n*/\nselectorFactory, // options object:\n_ref) {\n  if (_ref === void 0) {\n    _ref = {};\n  }\n\n  var _ref2 = _ref,\n      _ref2$getDisplayName = _ref2.getDisplayName,\n      getDisplayName = _ref2$getDisplayName === void 0 ? function (name) {\n    return \"ConnectAdvanced(\" + name + \")\";\n  } : _ref2$getDisplayName,\n      _ref2$methodName = _ref2.methodName,\n      methodName = _ref2$methodName === void 0 ? 'connectAdvanced' : _ref2$methodName,\n      _ref2$renderCountProp = _ref2.renderCountProp,\n      renderCountProp = _ref2$renderCountProp === void 0 ? undefined : _ref2$renderCountProp,\n      _ref2$shouldHandleSta = _ref2.shouldHandleStateChanges,\n      shouldHandleStateChanges = _ref2$shouldHandleSta === void 0 ? true : _ref2$shouldHandleSta,\n      _ref2$storeKey = _ref2.storeKey,\n      storeKey = _ref2$storeKey === void 0 ? 'store' : _ref2$storeKey,\n      _ref2$withRef = _ref2.withRef,\n      withRef = _ref2$withRef === void 0 ? false : _ref2$withRef,\n      _ref2$forwardRef = _ref2.forwardRef,\n      forwardRef = _ref2$forwardRef === void 0 ? false : _ref2$forwardRef,\n      _ref2$context = _ref2.context,\n      context = _ref2$context === void 0 ? ReactReduxContext : _ref2$context,\n      connectOptions = _objectWithoutPropertiesLoose(_ref2, [\"getDisplayName\", \"methodName\", \"renderCountProp\", \"shouldHandleStateChanges\", \"storeKey\", \"withRef\", \"forwardRef\", \"context\"]);\n\n  invariant(renderCountProp === undefined, \"renderCountProp is removed. render counting is built into the latest React Dev Tools profiling extension\");\n  invariant(!withRef, 'withRef is removed. To access the wrapped instance, use a ref on the connected component');\n  var customStoreWarningMessage = 'To use a custom Redux store for specific components, create a custom React context with ' + \"React.createContext(), and pass the context object to React Redux's Provider and specific components\" + ' like: <Provider context={MyContext}><ConnectedComponent context={MyContext} /></Provider>. ' + 'You may also pass a {context : MyContext} option to connect';\n  invariant(storeKey === 'store', 'storeKey has been removed and does not do anything. ' + customStoreWarningMessage);\n  var Context = context;\n  return function wrapWithConnect(WrappedComponent) {\n    if (process.env.NODE_ENV !== 'production') {\n      invariant(isValidElementType(WrappedComponent), \"You must pass a component to the function returned by \" + (methodName + \". Instead received \" + stringifyComponent(WrappedComponent)));\n    }\n\n    var wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || 'Component';\n    var displayName = getDisplayName(wrappedComponentName);\n\n    var selectorFactoryOptions = _extends({}, connectOptions, {\n      getDisplayName: getDisplayName,\n      methodName: methodName,\n      renderCountProp: renderCountProp,\n      shouldHandleStateChanges: shouldHandleStateChanges,\n      storeKey: storeKey,\n      displayName: displayName,\n      wrappedComponentName: wrappedComponentName,\n      WrappedComponent: WrappedComponent\n    });\n\n    var pure = connectOptions.pure;\n\n    function createChildSelector(store) {\n      return selectorFactory(store.dispatch, selectorFactoryOptions);\n    } // If we aren't running in \"pure\" mode, we don't want to memoize values.\n    // To avoid conditionally calling hooks, we fall back to a tiny wrapper\n    // that just executes the given callback immediately.\n\n\n    var usePureOnlyMemo = pure ? useMemo : function (callback) {\n      return callback();\n    };\n\n    function ConnectFunction(props) {\n      var _useMemo = useMemo(function () {\n        // Distinguish between actual \"data\" props that were passed to the wrapper component,\n        // and values needed to control behavior (forwarded refs, alternate context instances).\n        // To maintain the wrapperProps object reference, memoize this destructuring.\n        var forwardedRef = props.forwardedRef,\n            wrapperProps = _objectWithoutPropertiesLoose(props, [\"forwardedRef\"]);\n\n        return [props.context, forwardedRef, wrapperProps];\n      }, [props]),\n          propsContext = _useMemo[0],\n          forwardedRef = _useMemo[1],\n          wrapperProps = _useMemo[2];\n\n      var ContextToUse = useMemo(function () {\n        // Users may optionally pass in a custom context instance to use instead of our ReactReduxContext.\n        // Memoize the check that determines which context instance we should use.\n        return propsContext && propsContext.Consumer && isContextConsumer(React.createElement(propsContext.Consumer, null)) ? propsContext : Context;\n      }, [propsContext, Context]); // Retrieve the store and ancestor subscription via context, if available\n\n      var contextValue = useContext(ContextToUse); // The store _must_ exist as either a prop or in context\n\n      var didStoreComeFromProps = Boolean(props.store);\n      var didStoreComeFromContext = Boolean(contextValue) && Boolean(contextValue.store);\n      invariant(didStoreComeFromProps || didStoreComeFromContext, \"Could not find \\\"store\\\" in the context of \" + (\"\\\"\" + displayName + \"\\\". Either wrap the root component in a <Provider>, \") + \"or pass a custom React context provider to <Provider> and the corresponding \" + (\"React context consumer to \" + displayName + \" in connect options.\"));\n      var store = props.store || contextValue.store;\n      var childPropsSelector = useMemo(function () {\n        // The child props selector needs the store reference as an input.\n        // Re-create this selector whenever the store changes.\n        return createChildSelector(store);\n      }, [store]);\n\n      var _useMemo2 = useMemo(function () {\n        if (!shouldHandleStateChanges) return NO_SUBSCRIPTION_ARRAY; // This Subscription's source should match where store came from: props vs. context. A component\n        // connected to the store via props shouldn't use subscription from context, or vice versa.\n\n        var subscription = new Subscription(store, didStoreComeFromProps ? null : contextValue.subscription); // `notifyNestedSubs` is duplicated to handle the case where the component is unmounted in\n        // the middle of the notification loop, where `subscription` will then be null. This can\n        // probably be avoided if Subscription's listeners logic is changed to not call listeners\n        // that have been unsubscribed in the  middle of the notification loop.\n\n        var notifyNestedSubs = subscription.notifyNestedSubs.bind(subscription);\n        return [subscription, notifyNestedSubs];\n      }, [store, didStoreComeFromProps, contextValue]),\n          subscription = _useMemo2[0],\n          notifyNestedSubs = _useMemo2[1]; // Determine what {store, subscription} value should be put into nested context, if necessary,\n      // and memoize that value to avoid unnecessary context updates.\n\n\n      var overriddenContextValue = useMemo(function () {\n        if (didStoreComeFromProps) {\n          // This component is directly subscribed to a store from props.\n          // We don't want descendants reading from this store - pass down whatever\n          // the existing context value is from the nearest connected ancestor.\n          return contextValue;\n        } // Otherwise, put this component's subscription instance into context, so that\n        // connected descendants won't update until after this component is done\n\n\n        return _extends({}, contextValue, {\n          subscription: subscription\n        });\n      }, [didStoreComeFromProps, contextValue, subscription]); // We need to force this wrapper component to re-render whenever a Redux store update\n      // causes a change to the calculated child component props (or we caught an error in mapState)\n\n      var _useReducer = useReducer(storeStateUpdatesReducer, EMPTY_ARRAY, initStateUpdates),\n          _useReducer$ = _useReducer[0],\n          previousStateUpdateResult = _useReducer$[0],\n          forceComponentUpdateDispatch = _useReducer[1]; // Propagate any mapState/mapDispatch errors upwards\n\n\n      if (previousStateUpdateResult && previousStateUpdateResult.error) {\n        throw previousStateUpdateResult.error;\n      } // Set up refs to coordinate values between the subscription effect and the render logic\n\n\n      var lastChildProps = useRef();\n      var lastWrapperProps = useRef(wrapperProps);\n      var childPropsFromStoreUpdate = useRef();\n      var renderIsScheduled = useRef(false);\n      var actualChildProps = usePureOnlyMemo(function () {\n        // Tricky logic here:\n        // - This render may have been triggered by a Redux store update that produced new child props\n        // - However, we may have gotten new wrapper props after that\n        // If we have new child props, and the same wrapper props, we know we should use the new child props as-is.\n        // But, if we have new wrapper props, those might change the child props, so we have to recalculate things.\n        // So, we'll use the child props from store update only if the wrapper props are the same as last time.\n        if (childPropsFromStoreUpdate.current && wrapperProps === lastWrapperProps.current) {\n          return childPropsFromStoreUpdate.current;\n        } // TODO We're reading the store directly in render() here. Bad idea?\n        // This will likely cause Bad Things (TM) to happen in Concurrent Mode.\n        // Note that we do this because on renders _not_ caused by store updates, we need the latest store state\n        // to determine what the child props should be.\n\n\n        return childPropsSelector(store.getState(), wrapperProps);\n      }, [store, previousStateUpdateResult, wrapperProps]); // We need this to execute synchronously every time we re-render. However, React warns\n      // about useLayoutEffect in SSR, so we try to detect environment and fall back to\n      // just useEffect instead to avoid the warning, since neither will run anyway.\n\n      useIsomorphicLayoutEffect(function () {\n        // We want to capture the wrapper props and child props we used for later comparisons\n        lastWrapperProps.current = wrapperProps;\n        lastChildProps.current = actualChildProps;\n        renderIsScheduled.current = false; // If the render was from a store update, clear out that reference and cascade the subscriber update\n\n        if (childPropsFromStoreUpdate.current) {\n          childPropsFromStoreUpdate.current = null;\n          notifyNestedSubs();\n        }\n      }); // Our re-subscribe logic only runs when the store/subscription setup changes\n\n      useIsomorphicLayoutEffect(function () {\n        // If we're not subscribed to the store, nothing to do here\n        if (!shouldHandleStateChanges) return; // Capture values for checking if and when this component unmounts\n\n        var didUnsubscribe = false;\n        var lastThrownError = null; // We'll run this callback every time a store subscription update propagates to this component\n\n        var checkForUpdates = function checkForUpdates() {\n          if (didUnsubscribe) {\n            // Don't run stale listeners.\n            // Redux doesn't guarantee unsubscriptions happen until next dispatch.\n            return;\n          }\n\n          var latestStoreState = store.getState();\n          var newChildProps, error;\n\n          try {\n            // Actually run the selector with the most recent store state and wrapper props\n            // to determine what the child props should be\n            newChildProps = childPropsSelector(latestStoreState, lastWrapperProps.current);\n          } catch (e) {\n            error = e;\n            lastThrownError = e;\n          }\n\n          if (!error) {\n            lastThrownError = null;\n          } // If the child props haven't changed, nothing to do here - cascade the subscription update\n\n\n          if (newChildProps === lastChildProps.current) {\n            if (!renderIsScheduled.current) {\n              notifyNestedSubs();\n            }\n          } else {\n            // Save references to the new child props.  Note that we track the \"child props from store update\"\n            // as a ref instead of a useState/useReducer because we need a way to determine if that value has\n            // been processed.  If this went into useState/useReducer, we couldn't clear out the value without\n            // forcing another re-render, which we don't want.\n            lastChildProps.current = newChildProps;\n            childPropsFromStoreUpdate.current = newChildProps;\n            renderIsScheduled.current = true; // If the child props _did_ change (or we caught an error), this wrapper component needs to re-render\n\n            forceComponentUpdateDispatch({\n              type: 'STORE_UPDATED',\n              payload: {\n                latestStoreState: latestStoreState,\n                error: error\n              }\n            });\n          }\n        }; // Actually subscribe to the nearest connected ancestor (or store)\n\n\n        subscription.onStateChange = checkForUpdates;\n        subscription.trySubscribe(); // Pull data from the store after first render in case the store has\n        // changed since we began.\n\n        checkForUpdates();\n\n        var unsubscribeWrapper = function unsubscribeWrapper() {\n          didUnsubscribe = true;\n          subscription.tryUnsubscribe();\n          subscription.onStateChange = null;\n\n          if (lastThrownError) {\n            // It's possible that we caught an error due to a bad mapState function, but the\n            // parent re-rendered without this component and we're about to unmount.\n            // This shouldn't happen as long as we do top-down subscriptions correctly, but\n            // if we ever do those wrong, this throw will surface the error in our tests.\n            // In that case, throw the error from here so it doesn't get lost.\n            throw lastThrownError;\n          }\n        };\n\n        return unsubscribeWrapper;\n      }, [store, subscription, childPropsSelector]); // Now that all that's done, we can finally try to actually render the child component.\n      // We memoize the elements for the rendered child component as an optimization.\n\n      var renderedWrappedComponent = useMemo(function () {\n        return React.createElement(WrappedComponent, _extends({}, actualChildProps, {\n          ref: forwardedRef\n        }));\n      }, [forwardedRef, WrappedComponent, actualChildProps]); // If React sees the exact same element reference as last time, it bails out of re-rendering\n      // that child, same as if it was wrapped in React.memo() or returned false from shouldComponentUpdate.\n\n      var renderedChild = useMemo(function () {\n        if (shouldHandleStateChanges) {\n          // If this component is subscribed to store updates, we need to pass its own\n          // subscription instance down to our descendants. That means rendering the same\n          // Context instance, and putting a different value into the context.\n          return React.createElement(ContextToUse.Provider, {\n            value: overriddenContextValue\n          }, renderedWrappedComponent);\n        }\n\n        return renderedWrappedComponent;\n      }, [ContextToUse, renderedWrappedComponent, overriddenContextValue]);\n      return renderedChild;\n    } // If we're in \"pure\" mode, ensure our wrapper component only re-renders when incoming props have changed.\n\n\n    var Connect = pure ? React.memo(ConnectFunction) : ConnectFunction;\n    Connect.WrappedComponent = WrappedComponent;\n    Connect.displayName = displayName;\n\n    if (forwardRef) {\n      var forwarded = React.forwardRef(function forwardConnectRef(props, ref) {\n        return React.createElement(Connect, _extends({}, props, {\n          forwardedRef: ref\n        }));\n      });\n      forwarded.displayName = displayName;\n      forwarded.WrappedComponent = WrappedComponent;\n      return hoistStatics(forwarded, WrappedComponent);\n    }\n\n    return hoistStatics(Connect, WrappedComponent);\n  };\n}","var hasOwn = Object.prototype.hasOwnProperty;\n\nfunction is(x, y) {\n  if (x === y) {\n    return x !== 0 || y !== 0 || 1 / x === 1 / y;\n  } else {\n    return x !== x && y !== y;\n  }\n}\n\nexport default function shallowEqual(objA, objB) {\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 (!hasOwn.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {\n      return false;\n    }\n  }\n\n  return true;\n}","import verifyPlainObject from '../utils/verifyPlainObject';\nexport function wrapMapToPropsConstant(getConstant) {\n  return function initConstantSelector(dispatch, options) {\n    var constant = getConstant(dispatch, options);\n\n    function constantSelector() {\n      return constant;\n    }\n\n    constantSelector.dependsOnOwnProps = false;\n    return constantSelector;\n  };\n} // dependsOnOwnProps is used by createMapToPropsProxy to determine whether to pass props as args\n// to the mapToProps function being wrapped. It is also used by makePurePropsSelector to determine\n// whether mapToProps needs to be invoked when props have changed.\n//\n// A length of one signals that mapToProps does not depend on props from the parent component.\n// A length of zero is assumed to mean mapToProps is getting args via arguments or ...args and\n// therefore not reporting its length accurately..\n\nexport function getDependsOnOwnProps(mapToProps) {\n  return mapToProps.dependsOnOwnProps !== null && mapToProps.dependsOnOwnProps !== undefined ? Boolean(mapToProps.dependsOnOwnProps) : mapToProps.length !== 1;\n} // Used by whenMapStateToPropsIsFunction and whenMapDispatchToPropsIsFunction,\n// this function wraps mapToProps in a proxy function which does several things:\n//\n//  * Detects whether the mapToProps function being called depends on props, which\n//    is used by selectorFactory to decide if it should reinvoke on props changes.\n//\n//  * On first call, handles mapToProps if returns another function, and treats that\n//    new function as the true mapToProps for subsequent calls.\n//\n//  * On first call, verifies the first result is a plain object, in order to warn\n//    the developer that their mapToProps function is not returning a valid result.\n//\n\nexport function wrapMapToPropsFunc(mapToProps, methodName) {\n  return function initProxySelector(dispatch, _ref) {\n    var displayName = _ref.displayName;\n\n    var proxy = function mapToPropsProxy(stateOrDispatch, ownProps) {\n      return proxy.dependsOnOwnProps ? proxy.mapToProps(stateOrDispatch, ownProps) : proxy.mapToProps(stateOrDispatch);\n    }; // allow detectFactoryAndVerify to get ownProps\n\n\n    proxy.dependsOnOwnProps = true;\n\n    proxy.mapToProps = function detectFactoryAndVerify(stateOrDispatch, ownProps) {\n      proxy.mapToProps = mapToProps;\n      proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps);\n      var props = proxy(stateOrDispatch, ownProps);\n\n      if (typeof props === 'function') {\n        proxy.mapToProps = props;\n        proxy.dependsOnOwnProps = getDependsOnOwnProps(props);\n        props = proxy(stateOrDispatch, ownProps);\n      }\n\n      if (process.env.NODE_ENV !== 'production') verifyPlainObject(props, displayName, methodName);\n      return props;\n    };\n\n    return proxy;\n  };\n}","import { bindActionCreators } from 'redux';\nimport { wrapMapToPropsConstant, wrapMapToPropsFunc } from './wrapMapToProps';\nexport function whenMapDispatchToPropsIsFunction(mapDispatchToProps) {\n  return typeof mapDispatchToProps === 'function' ? wrapMapToPropsFunc(mapDispatchToProps, 'mapDispatchToProps') : undefined;\n}\nexport function whenMapDispatchToPropsIsMissing(mapDispatchToProps) {\n  return !mapDispatchToProps ? wrapMapToPropsConstant(function (dispatch) {\n    return {\n      dispatch: dispatch\n    };\n  }) : undefined;\n}\nexport function whenMapDispatchToPropsIsObject(mapDispatchToProps) {\n  return mapDispatchToProps && typeof mapDispatchToProps === 'object' ? wrapMapToPropsConstant(function (dispatch) {\n    return bindActionCreators(mapDispatchToProps, dispatch);\n  }) : undefined;\n}\nexport default [whenMapDispatchToPropsIsFunction, whenMapDispatchToPropsIsMissing, whenMapDispatchToPropsIsObject];","import { wrapMapToPropsConstant, wrapMapToPropsFunc } from './wrapMapToProps';\nexport function whenMapStateToPropsIsFunction(mapStateToProps) {\n  return typeof mapStateToProps === 'function' ? wrapMapToPropsFunc(mapStateToProps, 'mapStateToProps') : undefined;\n}\nexport function whenMapStateToPropsIsMissing(mapStateToProps) {\n  return !mapStateToProps ? wrapMapToPropsConstant(function () {\n    return {};\n  }) : undefined;\n}\nexport default [whenMapStateToPropsIsFunction, whenMapStateToPropsIsMissing];","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport verifyPlainObject from '../utils/verifyPlainObject';\nexport function defaultMergeProps(stateProps, dispatchProps, ownProps) {\n  return _extends({}, ownProps, {}, stateProps, {}, dispatchProps);\n}\nexport function wrapMergePropsFunc(mergeProps) {\n  return function initMergePropsProxy(dispatch, _ref) {\n    var displayName = _ref.displayName,\n        pure = _ref.pure,\n        areMergedPropsEqual = _ref.areMergedPropsEqual;\n    var hasRunOnce = false;\n    var mergedProps;\n    return function mergePropsProxy(stateProps, dispatchProps, ownProps) {\n      var nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n\n      if (hasRunOnce) {\n        if (!pure || !areMergedPropsEqual(nextMergedProps, mergedProps)) mergedProps = nextMergedProps;\n      } else {\n        hasRunOnce = true;\n        mergedProps = nextMergedProps;\n        if (process.env.NODE_ENV !== 'production') verifyPlainObject(mergedProps, displayName, 'mergeProps');\n      }\n\n      return mergedProps;\n    };\n  };\n}\nexport function whenMergePropsIsFunction(mergeProps) {\n  return typeof mergeProps === 'function' ? wrapMergePropsFunc(mergeProps) : undefined;\n}\nexport function whenMergePropsIsOmitted(mergeProps) {\n  return !mergeProps ? function () {\n    return defaultMergeProps;\n  } : undefined;\n}\nexport default [whenMergePropsIsFunction, whenMergePropsIsOmitted];","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport verifySubselectors from './verifySubselectors';\nexport function impureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch) {\n  return function impureFinalPropsSelector(state, ownProps) {\n    return mergeProps(mapStateToProps(state, ownProps), mapDispatchToProps(dispatch, ownProps), ownProps);\n  };\n}\nexport function pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, _ref) {\n  var areStatesEqual = _ref.areStatesEqual,\n      areOwnPropsEqual = _ref.areOwnPropsEqual,\n      areStatePropsEqual = _ref.areStatePropsEqual;\n  var hasRunAtLeastOnce = false;\n  var state;\n  var ownProps;\n  var stateProps;\n  var dispatchProps;\n  var mergedProps;\n\n  function handleFirstCall(firstState, firstOwnProps) {\n    state = firstState;\n    ownProps = firstOwnProps;\n    stateProps = mapStateToProps(state, ownProps);\n    dispatchProps = mapDispatchToProps(dispatch, ownProps);\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    hasRunAtLeastOnce = true;\n    return mergedProps;\n  }\n\n  function handleNewPropsAndNewState() {\n    stateProps = mapStateToProps(state, ownProps);\n    if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps);\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    return mergedProps;\n  }\n\n  function handleNewProps() {\n    if (mapStateToProps.dependsOnOwnProps) stateProps = mapStateToProps(state, ownProps);\n    if (mapDispatchToProps.dependsOnOwnProps) dispatchProps = mapDispatchToProps(dispatch, ownProps);\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    return mergedProps;\n  }\n\n  function handleNewState() {\n    var nextStateProps = mapStateToProps(state, ownProps);\n    var statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps);\n    stateProps = nextStateProps;\n    if (statePropsChanged) mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    return mergedProps;\n  }\n\n  function handleSubsequentCalls(nextState, nextOwnProps) {\n    var propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps);\n    var stateChanged = !areStatesEqual(nextState, state);\n    state = nextState;\n    ownProps = nextOwnProps;\n    if (propsChanged && stateChanged) return handleNewPropsAndNewState();\n    if (propsChanged) return handleNewProps();\n    if (stateChanged) return handleNewState();\n    return mergedProps;\n  }\n\n  return function pureFinalPropsSelector(nextState, nextOwnProps) {\n    return hasRunAtLeastOnce ? handleSubsequentCalls(nextState, nextOwnProps) : handleFirstCall(nextState, nextOwnProps);\n  };\n} // TODO: Add more comments\n// If pure is true, the selector returned by selectorFactory will memoize its results,\n// allowing connectAdvanced's shouldComponentUpdate to return false if final\n// props have not changed. If false, the selector will always return a new\n// object and shouldComponentUpdate will always return true.\n\nexport default function finalPropsSelectorFactory(dispatch, _ref2) {\n  var initMapStateToProps = _ref2.initMapStateToProps,\n      initMapDispatchToProps = _ref2.initMapDispatchToProps,\n      initMergeProps = _ref2.initMergeProps,\n      options = _objectWithoutPropertiesLoose(_ref2, [\"initMapStateToProps\", \"initMapDispatchToProps\", \"initMergeProps\"]);\n\n  var mapStateToProps = initMapStateToProps(dispatch, options);\n  var mapDispatchToProps = initMapDispatchToProps(dispatch, options);\n  var mergeProps = initMergeProps(dispatch, options);\n\n  if (process.env.NODE_ENV !== 'production') {\n    verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps, options.displayName);\n  }\n\n  var selectorFactory = options.pure ? pureFinalPropsSelectorFactory : impureFinalPropsSelectorFactory;\n  return selectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, options);\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport connectAdvanced from '../components/connectAdvanced';\nimport shallowEqual from '../utils/shallowEqual';\nimport defaultMapDispatchToPropsFactories from './mapDispatchToProps';\nimport defaultMapStateToPropsFactories from './mapStateToProps';\nimport defaultMergePropsFactories from './mergeProps';\nimport defaultSelectorFactory from './selectorFactory';\n/*\n  connect is a facade over connectAdvanced. It turns its args into a compatible\n  selectorFactory, which has the signature:\n\n    (dispatch, options) => (nextState, nextOwnProps) => nextFinalProps\n  \n  connect passes its args to connectAdvanced as options, which will in turn pass them to\n  selectorFactory each time a Connect component instance is instantiated or hot reloaded.\n\n  selectorFactory returns a final props selector from its mapStateToProps,\n  mapStateToPropsFactories, mapDispatchToProps, mapDispatchToPropsFactories, mergeProps,\n  mergePropsFactories, and pure args.\n\n  The resulting final props selector is called by the Connect component instance whenever\n  it receives new props or store state.\n */\n\nfunction match(arg, factories, name) {\n  for (var i = factories.length - 1; i >= 0; i--) {\n    var result = factories[i](arg);\n    if (result) return result;\n  }\n\n  return function (dispatch, options) {\n    throw new Error(\"Invalid value of type \" + typeof arg + \" for \" + name + \" argument when connecting component \" + options.wrappedComponentName + \".\");\n  };\n}\n\nfunction strictEqual(a, b) {\n  return a === b;\n} // createConnect with default args builds the 'official' connect behavior. Calling it with\n// different options opens up some testing and extensibility scenarios\n\n\nexport function createConnect(_temp) {\n  var _ref = _temp === void 0 ? {} : _temp,\n      _ref$connectHOC = _ref.connectHOC,\n      connectHOC = _ref$connectHOC === void 0 ? connectAdvanced : _ref$connectHOC,\n      _ref$mapStateToPropsF = _ref.mapStateToPropsFactories,\n      mapStateToPropsFactories = _ref$mapStateToPropsF === void 0 ? defaultMapStateToPropsFactories : _ref$mapStateToPropsF,\n      _ref$mapDispatchToPro = _ref.mapDispatchToPropsFactories,\n      mapDispatchToPropsFactories = _ref$mapDispatchToPro === void 0 ? defaultMapDispatchToPropsFactories : _ref$mapDispatchToPro,\n      _ref$mergePropsFactor = _ref.mergePropsFactories,\n      mergePropsFactories = _ref$mergePropsFactor === void 0 ? defaultMergePropsFactories : _ref$mergePropsFactor,\n      _ref$selectorFactory = _ref.selectorFactory,\n      selectorFactory = _ref$selectorFactory === void 0 ? defaultSelectorFactory : _ref$selectorFactory;\n\n  return function connect(mapStateToProps, mapDispatchToProps, mergeProps, _ref2) {\n    if (_ref2 === void 0) {\n      _ref2 = {};\n    }\n\n    var _ref3 = _ref2,\n        _ref3$pure = _ref3.pure,\n        pure = _ref3$pure === void 0 ? true : _ref3$pure,\n        _ref3$areStatesEqual = _ref3.areStatesEqual,\n        areStatesEqual = _ref3$areStatesEqual === void 0 ? strictEqual : _ref3$areStatesEqual,\n        _ref3$areOwnPropsEqua = _ref3.areOwnPropsEqual,\n        areOwnPropsEqual = _ref3$areOwnPropsEqua === void 0 ? shallowEqual : _ref3$areOwnPropsEqua,\n        _ref3$areStatePropsEq = _ref3.areStatePropsEqual,\n        areStatePropsEqual = _ref3$areStatePropsEq === void 0 ? shallowEqual : _ref3$areStatePropsEq,\n        _ref3$areMergedPropsE = _ref3.areMergedPropsEqual,\n        areMergedPropsEqual = _ref3$areMergedPropsE === void 0 ? shallowEqual : _ref3$areMergedPropsE,\n        extraOptions = _objectWithoutPropertiesLoose(_ref3, [\"pure\", \"areStatesEqual\", \"areOwnPropsEqual\", \"areStatePropsEqual\", \"areMergedPropsEqual\"]);\n\n    var initMapStateToProps = match(mapStateToProps, mapStateToPropsFactories, 'mapStateToProps');\n    var initMapDispatchToProps = match(mapDispatchToProps, mapDispatchToPropsFactories, 'mapDispatchToProps');\n    var initMergeProps = match(mergeProps, mergePropsFactories, 'mergeProps');\n    return connectHOC(selectorFactory, _extends({\n      // used in error messages\n      methodName: 'connect',\n      // used to compute Connect's displayName from the wrapped component's displayName.\n      getDisplayName: function getDisplayName(name) {\n        return \"Connect(\" + name + \")\";\n      },\n      // if mapStateToProps is falsy, the Connect component doesn't subscribe to store state changes\n      shouldHandleStateChanges: Boolean(mapStateToProps),\n      // passed through to selectorFactory\n      initMapStateToProps: initMapStateToProps,\n      initMapDispatchToProps: initMapDispatchToProps,\n      initMergeProps: initMergeProps,\n      pure: pure,\n      areStatesEqual: areStatesEqual,\n      areOwnPropsEqual: areOwnPropsEqual,\n      areStatePropsEqual: areStatePropsEqual,\n      areMergedPropsEqual: areMergedPropsEqual\n    }, extraOptions));\n  };\n}\nexport default createConnect();","import { useContext } from 'react';\nimport invariant from 'invariant';\nimport { ReactReduxContext } from '../components/Context';\n/**\n * A hook to access the value of the `ReactReduxContext`. This is a low-level\n * hook that you should usually not need to call directly.\n *\n * @returns {any} the value of the `ReactReduxContext`\n *\n * @example\n *\n * import React from 'react'\n * import { useReduxContext } from 'react-redux'\n *\n * export const CounterComponent = ({ value }) => {\n *   const { store } = useReduxContext()\n *   return <div>{store.getState()}</div>\n * }\n */\n\nexport function useReduxContext() {\n  var contextValue = useContext(ReactReduxContext);\n  invariant(contextValue, 'could not find react-redux context value; please ensure the component is wrapped in a <Provider>');\n  return contextValue;\n}","import { useContext } from 'react';\nimport { ReactReduxContext } from '../components/Context';\nimport { useReduxContext as useDefaultReduxContext } from './useReduxContext';\n/**\n * Hook factory, which creates a `useStore` hook bound to a given context.\n *\n * @param {Function} [context=ReactReduxContext] Context passed to your `<Provider>`.\n * @returns {Function} A `useStore` hook bound to the specified context.\n */\n\nexport function createStoreHook(context) {\n  if (context === void 0) {\n    context = ReactReduxContext;\n  }\n\n  var useReduxContext = context === ReactReduxContext ? useDefaultReduxContext : function () {\n    return useContext(context);\n  };\n  return function useStore() {\n    var _useReduxContext = useReduxContext(),\n        store = _useReduxContext.store;\n\n    return store;\n  };\n}\n/**\n * A hook to access the redux store.\n *\n * @returns {any} the redux store\n *\n * @example\n *\n * import React from 'react'\n * import { useStore } from 'react-redux'\n *\n * export const ExampleComponent = () => {\n *   const store = useStore()\n *   return <div>{store.getState()}</div>\n * }\n */\n\nexport var useStore = createStoreHook();","import { ReactReduxContext } from '../components/Context';\nimport { useStore as useDefaultStore, createStoreHook } from './useStore';\n/**\n * Hook factory, which creates a `useDispatch` hook bound to a given context.\n *\n * @param {Function} [context=ReactReduxContext] Context passed to your `<Provider>`.\n * @returns {Function} A `useDispatch` hook bound to the specified context.\n */\n\nexport function createDispatchHook(context) {\n  if (context === void 0) {\n    context = ReactReduxContext;\n  }\n\n  var useStore = context === ReactReduxContext ? useDefaultStore : createStoreHook(context);\n  return function useDispatch() {\n    var store = useStore();\n    return store.dispatch;\n  };\n}\n/**\n * A hook to access the redux `dispatch` function.\n *\n * @returns {any|function} redux store's `dispatch` function\n *\n * @example\n *\n * import React, { useCallback } from 'react'\n * import { useDispatch } from 'react-redux'\n *\n * export const CounterComponent = ({ value }) => {\n *   const dispatch = useDispatch()\n *   const increaseCounter = useCallback(() => dispatch({ type: 'increase-counter' }), [])\n *   return (\n *     <div>\n *       <span>{value}</span>\n *       <button onClick={increaseCounter}>Increase counter</button>\n *     </div>\n *   )\n * }\n */\n\nexport var useDispatch = createDispatchHook();","import { useReducer, useRef, useEffect, useMemo, useLayoutEffect, useContext } from 'react';\nimport invariant from 'invariant';\nimport { useReduxContext as useDefaultReduxContext } from './useReduxContext';\nimport Subscription from '../utils/Subscription';\nimport { ReactReduxContext } from '../components/Context'; // React currently throws a warning when using useLayoutEffect on the server.\n// To get around it, we can conditionally useEffect on the server (no-op) and\n// useLayoutEffect in the browser. We need useLayoutEffect to ensure the store\n// subscription callback always has the selector from the latest render commit\n// available, otherwise a store update may happen between render and the effect,\n// which may cause missed updates; we also must ensure the store subscription\n// is created synchronously, otherwise a store update may occur before the\n// subscription is created and an inconsistent state may be observed\n\nvar useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;\n\nvar refEquality = function refEquality(a, b) {\n  return a === b;\n};\n\nfunction useSelectorWithStoreAndSubscription(selector, equalityFn, store, contextSub) {\n  var _useReducer = useReducer(function (s) {\n    return s + 1;\n  }, 0),\n      forceRender = _useReducer[1];\n\n  var subscription = useMemo(function () {\n    return new Subscription(store, contextSub);\n  }, [store, contextSub]);\n  var latestSubscriptionCallbackError = useRef();\n  var latestSelector = useRef();\n  var latestSelectedState = useRef();\n  var selectedState;\n\n  try {\n    if (selector !== latestSelector.current || latestSubscriptionCallbackError.current) {\n      selectedState = selector(store.getState());\n    } else {\n      selectedState = latestSelectedState.current;\n    }\n  } catch (err) {\n    var errorMessage = \"An error occured while selecting the store state: \" + err.message + \".\";\n\n    if (latestSubscriptionCallbackError.current) {\n      errorMessage += \"\\nThe error may be correlated with this previous error:\\n\" + latestSubscriptionCallbackError.current.stack + \"\\n\\nOriginal stack trace:\";\n    }\n\n    throw new Error(errorMessage);\n  }\n\n  useIsomorphicLayoutEffect(function () {\n    latestSelector.current = selector;\n    latestSelectedState.current = selectedState;\n    latestSubscriptionCallbackError.current = undefined;\n  });\n  useIsomorphicLayoutEffect(function () {\n    function checkForUpdates() {\n      try {\n        var newSelectedState = latestSelector.current(store.getState());\n\n        if (equalityFn(newSelectedState, latestSelectedState.current)) {\n          return;\n        }\n\n        latestSelectedState.current = newSelectedState;\n      } catch (err) {\n        // we ignore all errors here, since when the component\n        // is re-rendered, the selectors are called again, and\n        // will throw again, if neither props nor store state\n        // changed\n        latestSubscriptionCallbackError.current = err;\n      }\n\n      forceRender({});\n    }\n\n    subscription.onStateChange = checkForUpdates;\n    subscription.trySubscribe();\n    checkForUpdates();\n    return function () {\n      return subscription.tryUnsubscribe();\n    };\n  }, [store, subscription]);\n  return selectedState;\n}\n/**\n * Hook factory, which creates a `useSelector` hook bound to a given context.\n *\n * @param {Function} [context=ReactReduxContext] Context passed to your `<Provider>`.\n * @returns {Function} A `useSelector` hook bound to the specified context.\n */\n\n\nexport function createSelectorHook(context) {\n  if (context === void 0) {\n    context = ReactReduxContext;\n  }\n\n  var useReduxContext = context === ReactReduxContext ? useDefaultReduxContext : function () {\n    return useContext(context);\n  };\n  return function useSelector(selector, equalityFn) {\n    if (equalityFn === void 0) {\n      equalityFn = refEquality;\n    }\n\n    invariant(selector, \"You must pass a selector to useSelectors\");\n\n    var _useReduxContext = useReduxContext(),\n        store = _useReduxContext.store,\n        contextSub = _useReduxContext.subscription;\n\n    return useSelectorWithStoreAndSubscription(selector, equalityFn, store, contextSub);\n  };\n}\n/**\n * A hook to access the redux store's state. This hook takes a selector function\n * as an argument. The selector is called with the store state.\n *\n * This hook takes an optional equality comparison function as the second parameter\n * that allows you to customize the way the selected state is compared to determine\n * whether the component needs to be re-rendered.\n *\n * @param {Function} selector the selector function\n * @param {Function=} equalityFn the function that will be used to determine equality\n *\n * @returns {any} the selected state\n *\n * @example\n *\n * import React from 'react'\n * import { useSelector } from 'react-redux'\n *\n * export const CounterComponent = () => {\n *   const counter = useSelector(state => state.counter)\n *   return <div>{counter}</div>\n * }\n */\n\nexport var useSelector = createSelectorHook();","import Provider from './components/Provider';\nimport connectAdvanced from './components/connectAdvanced';\nimport { ReactReduxContext } from './components/Context';\nimport connect from './connect/connect';\nimport { useDispatch, createDispatchHook } from './hooks/useDispatch';\nimport { useSelector, createSelectorHook } from './hooks/useSelector';\nimport { useStore, createStoreHook } from './hooks/useStore';\nimport { setBatch } from './utils/batch';\nimport { unstable_batchedUpdates as batch } from './utils/reactBatchedUpdates';\nimport shallowEqual from './utils/shallowEqual';\nsetBatch(batch);\nexport { Provider, connectAdvanced, ReactReduxContext, connect, batch, useDispatch, createDispatchHook, useSelector, createSelectorHook, useStore, createStoreHook, shallowEqual };","/**\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/**\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 invariant = function(condition, format, a, b, c, d, e, f) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (format === undefined) {\n      throw new Error('invariant requires an error message argument');\n    }\n  }\n\n  if (!condition) {\n    var error;\n    if (format === undefined) {\n      error = new Error(\n        'Minified exception occurred; use the non-minified dev environment ' +\n        'for the full error message and additional helpful warnings.'\n      );\n    } else {\n      var args = [a, b, c, d, e, f];\n      var argIndex = 0;\n      error = new Error(\n        format.replace(/%s/g, function() { 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    throw error;\n  }\n};\n\nmodule.exports = invariant;\n","export default function _isPlaceholder(a) {\n       return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;\n}","import _isPlaceholder from './_isPlaceholder';\n\n/**\n * Optimized internal one-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nexport default function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0 || _isPlaceholder(a)) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n}","import _curry1 from './internal/_curry1';\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator) in\n * other languages and libraries.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      var t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nvar always = /*#__PURE__*/_curry1(function always(val) {\n  return function () {\n    return val;\n  };\n});\nexport default always;","import always from './always';\n\n/**\n * A function that always returns `true`. Any passed in parameters are ignored.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Function\n * @sig * -> Boolean\n * @param {*}\n * @return {Boolean}\n * @see R.always, R.F\n * @example\n *\n *      R.T(); //=> true\n */\nvar T = /*#__PURE__*/always(true);\nexport default T;","/**\n * A special placeholder value used to specify \"gaps\" within curried functions,\n * allowing partial application of any combination of arguments, regardless of\n * their positions.\n *\n * If `g` is a curried ternary function and `_` is `R.__`, the following are\n * equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2, _)(1, 3)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @constant\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @example\n *\n *      var greet = R.replace('{name}', R.__, 'Hello, {name}!');\n *      greet('Alice'); //=> 'Hello, Alice!'\n */\nexport default { '@@functional/placeholder': true };","import _curry1 from './_curry1';\nimport _isPlaceholder from './_isPlaceholder';\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nexport default function _curry2(fn) {\n  return function f2(a, b) {\n    switch (arguments.length) {\n      case 0:\n        return f2;\n      case 1:\n        return _isPlaceholder(a) ? f2 : _curry1(function (_b) {\n          return fn(a, _b);\n        });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {\n          return fn(_a, b);\n        }) : _isPlaceholder(b) ? _curry1(function (_b) {\n          return fn(a, _b);\n        }) : fn(a, b);\n    }\n  };\n}","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nexport default function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n}","export default function _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0:\n      return function () {\n        return fn.apply(this, arguments);\n      };\n    case 1:\n      return function (a0) {\n        return fn.apply(this, arguments);\n      };\n    case 2:\n      return function (a0, a1) {\n        return fn.apply(this, arguments);\n      };\n    case 3:\n      return function (a0, a1, a2) {\n        return fn.apply(this, arguments);\n      };\n    case 4:\n      return function (a0, a1, a2, a3) {\n        return fn.apply(this, arguments);\n      };\n    case 5:\n      return function (a0, a1, a2, a3, a4) {\n        return fn.apply(this, arguments);\n      };\n    case 6:\n      return function (a0, a1, a2, a3, a4, a5) {\n        return fn.apply(this, arguments);\n      };\n    case 7:\n      return function (a0, a1, a2, a3, a4, a5, a6) {\n        return fn.apply(this, arguments);\n      };\n    case 8:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n        return fn.apply(this, arguments);\n      };\n    case 9:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n        return fn.apply(this, arguments);\n      };\n    case 10:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n        return fn.apply(this, arguments);\n      };\n    default:\n      throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n}","import _arity from './_arity';\nimport _isPlaceholder from './_isPlaceholder';\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @param {Array} received An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nexport default function _curryN(length, received, fn) {\n  return function () {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length && (!_isPlaceholder(received[combinedIdx]) || argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (!_isPlaceholder(result)) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined) : _arity(left, _curryN(length, combined, fn));\n  };\n}","import _arity from './internal/_arity';\nimport _curry1 from './internal/_curry1';\nimport _curry2 from './internal/_curry2';\nimport _curryN from './internal/_curryN';\n\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value [`R.__`](#__) may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is [`R.__`](#__),\n * the following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var sumArgs = (...args) => R.sum(args);\n *\n *      var curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nvar curryN = /*#__PURE__*/_curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\nexport default curryN;","import _curry1 from './_curry1';\nimport _curry2 from './_curry2';\nimport _isPlaceholder from './_isPlaceholder';\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nexport default function _curry3(fn) {\n  return function f3(a, b, c) {\n    switch (arguments.length) {\n      case 0:\n        return f3;\n      case 1:\n        return _isPlaceholder(a) ? f3 : _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        });\n      case 2:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f3 : _isPlaceholder(a) ? _curry2(function (_a, _c) {\n          return fn(_a, b, _c);\n        }) : _isPlaceholder(b) ? _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        }) : _curry1(function (_c) {\n          return fn(a, b, _c);\n        });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3 : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function (_a, _b) {\n          return fn(_a, _b, c);\n        }) : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function (_a, _c) {\n          return fn(_a, b, _c);\n        }) : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function (_b, _c) {\n          return fn(a, _b, _c);\n        }) : _isPlaceholder(a) ? _curry1(function (_a) {\n          return fn(_a, b, c);\n        }) : _isPlaceholder(b) ? _curry1(function (_b) {\n          return fn(a, _b, c);\n        }) : _isPlaceholder(c) ? _curry1(function (_c) {\n          return fn(a, b, _c);\n        }) : fn(a, b, c);\n    }\n  };\n}","import _concat from './internal/_concat';\nimport _curry3 from './internal/_curry3';\n\n/**\n * Applies a function to the value at the given index of an array, returning a\n * new copy of the array with the element at the given index replaced with the\n * result of the function application.\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category List\n * @sig (a -> a) -> Number -> [a] -> [a]\n * @param {Function} fn The function to apply.\n * @param {Number} idx The index.\n * @param {Array|Arguments} list An array-like object whose value\n *        at the supplied index will be replaced.\n * @return {Array} A copy of the supplied array-like object with\n *         the element at index `idx` replaced with the value\n *         returned by applying `fn` to the existing element.\n * @see R.update\n * @example\n *\n *      R.adjust(R.add(10), 1, [1, 2, 3]);     //=> [1, 12, 3]\n *      R.adjust(R.add(10))(1)([1, 2, 3]);     //=> [1, 12, 3]\n * @symb R.adjust(f, -1, [a, b]) = [a, f(b)]\n * @symb R.adjust(f, 0, [a, b]) = [f(a), b]\n */\nvar adjust = /*#__PURE__*/_curry3(function adjust(fn, idx, list) {\n  if (idx >= list.length || idx < -list.length) {\n    return list;\n  }\n  var start = idx < 0 ? list.length : 0;\n  var _idx = start + idx;\n  var _list = _concat(list);\n  _list[_idx] = fn(list[_idx]);\n  return _list;\n});\nexport default adjust;","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nexport default Array.isArray || function _isArray(val) {\n  return val != null && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n};","export default function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n}","import _isArray from './_isArray';\nimport _isTransformer from './_isTransformer';\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a function with one of the given method names, it will\n * execute that function (functor case). Otherwise, if it is a transformer,\n * uses transducer [xf] to return a new transformer (transducer case).\n * Otherwise, it will default to executing [fn].\n *\n * @private\n * @param {Array} methodNames properties to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nexport default function _dispatchable(methodNames, xf, fn) {\n  return function () {\n    if (arguments.length === 0) {\n      return fn();\n    }\n    var args = Array.prototype.slice.call(arguments, 0);\n    var obj = args.pop();\n    if (!_isArray(obj)) {\n      var idx = 0;\n      while (idx < methodNames.length) {\n        if (typeof obj[methodNames[idx]] === 'function') {\n          return obj[methodNames[idx]].apply(obj, args);\n        }\n        idx += 1;\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n}","export default {\n  init: function () {\n    return this.xf['@@transducer/init']();\n  },\n  result: function (result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};","import _curry2 from './internal/_curry2';\n\n/**\n * Returns the larger of its two arguments.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Relation\n * @sig Ord a => a -> a -> a\n * @param {*} a\n * @param {*} b\n * @return {*}\n * @see R.maxBy, R.min\n * @example\n *\n *      R.max(789, 123); //=> 789\n *      R.max('a', 'b'); //=> 'b'\n */\nvar max = /*#__PURE__*/_curry2(function max(a, b) {\n  return b > a ? b : a;\n});\nexport default max;","export default function _map(fn, functor) {\n  var idx = 0;\n  var len = functor.length;\n  var result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(functor[idx]);\n    idx += 1;\n  }\n  return result;\n}","export default function _isString(x) {\n  return Object.prototype.toString.call(x) === '[object String]';\n}","import _curry1 from './_curry1';\nimport _isArray from './_isArray';\nimport _isString from './_isString';\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @private\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      _isArrayLike([]); //=> true\n *      _isArrayLike(true); //=> false\n *      _isArrayLike({}); //=> false\n *      _isArrayLike({length: 10}); //=> false\n *      _isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nvar _isArrayLike = /*#__PURE__*/_curry1(function isArrayLike(x) {\n  if (_isArray(x)) {\n    return true;\n  }\n  if (!x) {\n    return false;\n  }\n  if (typeof x !== 'object') {\n    return false;\n  }\n  if (_isString(x)) {\n    return false;\n  }\n  if (x.nodeType === 1) {\n    return !!x.length;\n  }\n  if (x.length === 0) {\n    return true;\n  }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\nexport default _isArrayLike;","var XWrap = /*#__PURE__*/function () {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function () {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function (acc) {\n    return acc;\n  };\n  XWrap.prototype['@@transducer/step'] = function (acc, x) {\n    return this.f(acc, x);\n  };\n\n  return XWrap;\n}();\n\nexport default function _xwrap(fn) {\n  return new XWrap(fn);\n}","import _arity from './internal/_arity';\nimport _curry2 from './internal/_curry2';\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @category Object\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n * @see R.partial\n * @example\n *\n *      var log = R.bind(console.log, console);\n *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}\n *      // logs {a: 2}\n * @symb R.bind(f, o)(a, b) = f.call(o, a, b)\n */\nvar bind = /*#__PURE__*/_curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function () {\n    return fn.apply(thisObj, arguments);\n  });\n});\nexport default bind;","import _isArrayLike from './_isArrayLike';\nimport _xwrap from './_xwrap';\nimport bind from '../bind';\n\nfunction _arrayReduce(xf, acc, list) {\n  var idx = 0;\n  var len = list.length;\n  while (idx < len) {\n    acc = xf['@@transducer/step'](acc, list[idx]);\n    if (acc && acc['@@transducer/reduced']) {\n      acc = acc['@@transducer/value'];\n      break;\n    }\n    idx += 1;\n  }\n  return xf['@@transducer/result'](acc);\n}\n\nfunction _iterableReduce(xf, acc, iter) {\n  var step = iter.next();\n  while (!step.done) {\n    acc = xf['@@transducer/step'](acc, step.value);\n    if (acc && acc['@@transducer/reduced']) {\n      acc = acc['@@transducer/value'];\n      break;\n    }\n    step = iter.next();\n  }\n  return xf['@@transducer/result'](acc);\n}\n\nfunction _methodReduce(xf, acc, obj, methodName) {\n  return xf['@@transducer/result'](obj[methodName](bind(xf['@@transducer/step'], xf), acc));\n}\n\nvar symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n\nexport default function _reduce(fn, acc, list) {\n  if (typeof fn === 'function') {\n    fn = _xwrap(fn);\n  }\n  if (_isArrayLike(list)) {\n    return _arrayReduce(fn, acc, list);\n  }\n  if (typeof list['fantasy-land/reduce'] === 'function') {\n    return _methodReduce(fn, acc, list, 'fantasy-land/reduce');\n  }\n  if (list[symIterator] != null) {\n    return _iterableReduce(fn, acc, list[symIterator]());\n  }\n  if (typeof list.next === 'function') {\n    return _iterableReduce(fn, acc, list);\n  }\n  if (typeof list.reduce === 'function') {\n    return _methodReduce(fn, acc, list, 'reduce');\n  }\n\n  throw new TypeError('reduce: list must be array or iterable');\n}","import _curry2 from './_curry2';\nimport _xfBase from './_xfBase';\n\nvar XMap = /*#__PURE__*/function () {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function (result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return XMap;\n}();\n\nvar _xmap = /*#__PURE__*/_curry2(function _xmap(f, xf) {\n  return new XMap(f, xf);\n});\nexport default _xmap;","export default function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}","import _has from './_has';\n\nvar toString = Object.prototype.toString;\nvar _isArguments = function () {\n  return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) {\n    return toString.call(x) === '[object Arguments]';\n  } : function _isArguments(x) {\n    return _has('callee', x);\n  };\n};\n\nexport default _isArguments;","import _curry1 from './internal/_curry1';\nimport _has from './internal/_has';\nimport _isArguments from './internal/_isArguments';\n\n// cover IE < 9 keys issues\nvar hasEnumBug = ! /*#__PURE__*/{ toString: null }.propertyIsEnumerable('toString');\nvar nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n// Safari bug\nvar hasArgsEnumBug = /*#__PURE__*/function () {\n  'use strict';\n\n  return arguments.propertyIsEnumerable('length');\n}();\n\nvar contains = function contains(list, item) {\n  var idx = 0;\n  while (idx < list.length) {\n    if (list[idx] === item) {\n      return true;\n    }\n    idx += 1;\n  }\n  return false;\n};\n\n/**\n * Returns a list containing the names of all the enumerable own properties of\n * the supplied object.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @see R.keysIn, R.values\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nvar _keys = typeof Object.keys === 'function' && !hasArgsEnumBug ? function keys(obj) {\n  return Object(obj) !== obj ? [] : Object.keys(obj);\n} : function keys(obj) {\n  if (Object(obj) !== obj) {\n    return [];\n  }\n  var prop, nIdx;\n  var ks = [];\n  var checkArgsLength = hasArgsEnumBug && _isArguments(obj);\n  for (prop in obj) {\n    if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {\n      ks[ks.length] = prop;\n    }\n  }\n  if (hasEnumBug) {\n    nIdx = nonEnumerableProps.length - 1;\n    while (nIdx >= 0) {\n      prop = nonEnumerableProps[nIdx];\n      if (_has(prop, obj) && !contains(ks, prop)) {\n        ks[ks.length] = prop;\n      }\n      nIdx -= 1;\n    }\n  }\n  return ks;\n};\nvar keys = /*#__PURE__*/_curry1(_keys);\nexport default keys;","import _curry2 from './internal/_curry2';\nimport _dispatchable from './internal/_dispatchable';\nimport _map from './internal/_map';\nimport _reduce from './internal/_reduce';\nimport _xmap from './internal/_xmap';\nimport curryN from './curryN';\nimport keys from './keys';\n\n/**\n * Takes a function and\n * a [functor](https://github.com/fantasyland/fantasy-land#functor),\n * applies the function to each of the functor's values, and returns\n * a functor of the same shape.\n *\n * Ramda provides suitable `map` implementations for `Array` and `Object`,\n * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.\n *\n * Dispatches to the `map` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * Also treats functions as functors and will compose them together.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Functor f => (a -> b) -> f a -> f b\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @see R.transduce, R.addIndex\n * @example\n *\n *      var double = x => x * 2;\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n *\n *      R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}\n * @symb R.map(f, [a, b]) = [f(a), f(b)]\n * @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }\n * @symb R.map(f, functor_o) = functor_o.map(f)\n */\nvar map = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['fantasy-land/map', 'map'], _xmap, function map(fn, functor) {\n  switch (Object.prototype.toString.call(functor)) {\n    case '[object Function]':\n      return curryN(functor.length, function () {\n        return fn.call(this, functor.apply(this, arguments));\n      });\n    case '[object Object]':\n      return _reduce(function (acc, key) {\n        acc[key] = fn(functor[key]);\n        return acc;\n      }, {}, keys(functor));\n    default:\n      return _map(fn, functor);\n  }\n}));\nexport default map;","import _curry2 from './internal/_curry2';\n\n/**\n * Retrieve the value at a given path.\n *\n * @func\n * @memberOf R\n * @since v0.2.0\n * @category Object\n * @typedefn Idx = String | Int\n * @sig [Idx] -> {a} -> a | Undefined\n * @param {Array} path The path to use.\n * @param {Object} obj The object to retrieve the nested property from.\n * @return {*} The data at `path`.\n * @see R.prop\n * @example\n *\n *      R.path(['a', 'b'], {a: {b: 2}}); //=> 2\n *      R.path(['a', 'b'], {c: {b: 2}}); //=> undefined\n */\nvar path = /*#__PURE__*/_curry2(function path(paths, obj) {\n  var val = obj;\n  var idx = 0;\n  while (idx < paths.length) {\n    if (val == null) {\n      return;\n    }\n    val = val[paths[idx]];\n    idx += 1;\n  }\n  return val;\n});\nexport default path;","import _curry2 from './internal/_curry2';\nimport path from './path';\n\n/**\n * Returns a function that when supplied an object returns the indicated\n * property of that object, if it exists.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig s -> {s: a} -> a | Undefined\n * @param {String} p The property name\n * @param {Object} obj The object to query\n * @return {*} The value at `obj.p`.\n * @see R.path\n * @example\n *\n *      R.prop('x', {x: 100}); //=> 100\n *      R.prop('x', {}); //=> undefined\n */\n\nvar prop = /*#__PURE__*/_curry2(function prop(p, obj) {\n  return path([p], obj);\n});\nexport default prop;","import _curry2 from './internal/_curry2';\nimport map from './map';\nimport prop from './prop';\n\n/**\n * Returns a new list by plucking the same named property off all objects in\n * the list supplied.\n *\n * `pluck` will work on\n * any [functor](https://github.com/fantasyland/fantasy-land#functor) in\n * addition to arrays, as it is equivalent to `R.map(R.prop(k), f)`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Functor f => k -> f {k: v} -> f v\n * @param {Number|String} key The key name to pluck off of each object.\n * @param {Array} f The array or functor to consider.\n * @return {Array} The list of values for the given key.\n * @see R.props\n * @example\n *\n *      R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]\n *      R.pluck(0)([[1, 2], [3, 4]]);   //=> [1, 3]\n *      R.pluck('val', {a: {val: 3}, b: {val: 5}}); //=> {a: 3, b: 5}\n * @symb R.pluck('x', [{x: 1, y: 2}, {x: 3, y: 4}, {x: 5, y: 6}]) = [1, 3, 5]\n * @symb R.pluck(0, [[1, 2], [3, 4], [5, 6]]) = [1, 3, 5]\n */\nvar pluck = /*#__PURE__*/_curry2(function pluck(p, list) {\n  return map(prop(p), list);\n});\nexport default pluck;","import _curry3 from './internal/_curry3';\nimport _reduce from './internal/_reduce';\n\n/**\n * Returns a single item by iterating through the list, successively calling\n * the iterator function and passing it an accumulator value and the current\n * value from the array, and then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*. It may use\n * [`R.reduced`](#reduced) to shortcut the iteration.\n *\n * The arguments' order of [`reduceRight`](#reduceRight)'s iterator function\n * is *(value, acc)*.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.reduce` method. For more details\n * on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n *\n * Dispatches to the `reduce` method of the third argument, if present. When\n * doing so, it is up to the user to handle the [`R.reduced`](#reduced)\n * shortcuting, as this is not implemented by `reduce`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduced, R.addIndex, R.reduceRight\n * @example\n *\n *      R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10\n *      //          -               -10\n *      //         / \\              / \\\n *      //        -   4           -6   4\n *      //       / \\              / \\\n *      //      -   3   ==>     -3   3\n *      //     / \\              / \\\n *      //    -   2           -1   2\n *      //   / \\              / \\\n *      //  0   1            0   1\n *\n * @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d)\n */\nvar reduce = /*#__PURE__*/_curry3(_reduce);\nexport default reduce;","import _curry1 from './internal/_curry1';\nimport curryN from './curryN';\nimport max from './max';\nimport pluck from './pluck';\nimport reduce from './reduce';\n\n/**\n * Takes a list of predicates and returns a predicate that returns true for a\n * given list of arguments if at least one of the provided predicates is\n * satisfied by those arguments.\n *\n * The function returned is a curried function whose arity matches that of the\n * highest-arity predicate.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Logic\n * @sig [(*... -> Boolean)] -> (*... -> Boolean)\n * @param {Array} predicates An array of predicates to check\n * @return {Function} The combined predicate\n * @see R.allPass\n * @example\n *\n *      var isClub = R.propEq('suit', '♣');\n *      var isSpade = R.propEq('suit', '♠');\n *      var isBlackCard = R.anyPass([isClub, isSpade]);\n *\n *      isBlackCard({rank: '10', suit: '♣'}); //=> true\n *      isBlackCard({rank: 'Q', suit: '♠'}); //=> true\n *      isBlackCard({rank: 'Q', suit: '♦'}); //=> false\n */\nvar anyPass = /*#__PURE__*/_curry1(function anyPass(preds) {\n  return curryN(reduce(max, 0, pluck('length', preds)), function () {\n    var idx = 0;\n    var len = preds.length;\n    while (idx < len) {\n      if (preds[idx].apply(this, arguments)) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  });\n});\nexport default anyPass;","import _concat from './internal/_concat';\nimport _curry2 from './internal/_curry2';\nimport _reduce from './internal/_reduce';\nimport map from './map';\n\n/**\n * ap applies a list of functions to a list of values.\n *\n * Dispatches to the `ap` method of the second argument, if present. Also\n * treats curried functions as applicatives.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig [a -> b] -> [a] -> [b]\n * @sig Apply f => f (a -> b) -> f a -> f b\n * @sig (a -> b -> c) -> (a -> b) -> (a -> c)\n * @param {*} applyF\n * @param {*} applyX\n * @return {*}\n * @example\n *\n *      R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]\n *      R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> [\"tasty pizza\", \"tasty salad\", \"PIZZA\", \"SALAD\"]\n *\n *      // R.ap can also be used as S combinator\n *      // when only two functions are passed\n *      R.ap(R.concat, R.toUpper)('Ramda') //=> 'RamdaRAMDA'\n * @symb R.ap([f, g], [a, b]) = [f(a), f(b), g(a), g(b)]\n */\nvar ap = /*#__PURE__*/_curry2(function ap(applyF, applyX) {\n  return typeof applyX['fantasy-land/ap'] === 'function' ? applyX['fantasy-land/ap'](applyF) : typeof applyF.ap === 'function' ? applyF.ap(applyX) : typeof applyF === 'function' ? function (x) {\n    return applyF(x)(applyX(x));\n  } :\n  // else\n  _reduce(function (acc, f) {\n    return _concat(acc, map(f, applyX));\n  }, [], applyF);\n});\nexport default ap;","/**\n * Determine if the passed argument is an integer.\n *\n * @private\n * @param {*} n\n * @category Type\n * @return {Boolean}\n */\nexport default Number.isInteger || function _isInteger(n) {\n  return n << 0 === n;\n};","import _concat from './_concat';\nimport _curry2 from './_curry2';\nimport _xfBase from './_xfBase';\n\nvar XAperture = /*#__PURE__*/function () {\n  function XAperture(n, xf) {\n    this.xf = xf;\n    this.pos = 0;\n    this.full = false;\n    this.acc = new Array(n);\n  }\n  XAperture.prototype['@@transducer/init'] = _xfBase.init;\n  XAperture.prototype['@@transducer/result'] = function (result) {\n    this.acc = null;\n    return this.xf['@@transducer/result'](result);\n  };\n  XAperture.prototype['@@transducer/step'] = function (result, input) {\n    this.store(input);\n    return this.full ? this.xf['@@transducer/step'](result, this.getCopy()) : result;\n  };\n  XAperture.prototype.store = function (input) {\n    this.acc[this.pos] = input;\n    this.pos += 1;\n    if (this.pos === this.acc.length) {\n      this.pos = 0;\n      this.full = true;\n    }\n  };\n  XAperture.prototype.getCopy = function () {\n    return _concat(Array.prototype.slice.call(this.acc, this.pos), Array.prototype.slice.call(this.acc, 0, this.pos));\n  };\n\n  return XAperture;\n}();\n\nvar _xaperture = /*#__PURE__*/_curry2(function _xaperture(n, xf) {\n  return new XAperture(n, xf);\n});\nexport default _xaperture;","import _curry1 from './internal/_curry1';\n\n/**\n * Checks if the input value is `null` or `undefined`.\n *\n * @func\n * @memberOf R\n * @since v0.9.0\n * @category Type\n * @sig * -> Boolean\n * @param {*} x The value to test.\n * @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.\n * @example\n *\n *      R.isNil(null); //=> true\n *      R.isNil(undefined); //=> true\n *      R.isNil(0); //=> false\n *      R.isNil([]); //=> false\n */\nvar isNil = /*#__PURE__*/_curry1(function isNil(x) {\n  return x == null;\n});\nexport default isNil;","export default function _isFunction(x) {\n  return Object.prototype.toString.call(x) === '[object Function]';\n}","import _curry2 from './internal/_curry2';\nimport _reduce from './internal/_reduce';\nimport ap from './ap';\nimport curryN from './curryN';\nimport map from './map';\n\n/**\n * \"lifts\" a function to be the specified arity, so that it may \"map over\" that\n * many lists, Functions or other objects that satisfy the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig Number -> (*... -> *) -> ([*]... -> [*])\n * @param {Function} fn The function to lift into higher context\n * @return {Function} The lifted function.\n * @see R.lift, R.ap\n * @example\n *\n *      var madd3 = R.liftN(3, (...args) => R.sum(args));\n *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n */\nvar liftN = /*#__PURE__*/_curry2(function liftN(arity, fn) {\n  var lifted = curryN(arity, fn);\n  return curryN(arity, function () {\n    return _reduce(ap, map(lifted, arguments[0]), Array.prototype.slice.call(arguments, 1));\n  });\n});\nexport default liftN;","import _curry1 from './internal/_curry1';\nimport liftN from './liftN';\n\n/**\n * \"lifts\" a function of arity > 1 so that it may \"map over\" a list, Function or other\n * object that satisfies the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Function\n * @sig (*... -> *) -> ([*]... -> [*])\n * @param {Function} fn The function to lift into higher context\n * @return {Function} The lifted function.\n * @see R.liftN\n * @example\n *\n *      var madd3 = R.lift((a, b, c) => a + b + c);\n *\n *      madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]\n *\n *      var madd5 = R.lift((a, b, c, d, e) => a + b + c + d + e);\n *\n *      madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]\n */\nvar lift = /*#__PURE__*/_curry1(function lift(fn) {\n  return liftN(fn.length, fn);\n});\nexport default lift;","import _curry1 from './internal/_curry1';\n\n/**\n * Gives a single-word string description of the (native) type of a value,\n * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not\n * attempt to distinguish user Object types any further, reporting them all as\n * 'Object'.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n *      R.type(() => {}); //=> \"Function\"\n *      R.type(undefined); //=> \"Undefined\"\n */\nvar type = /*#__PURE__*/_curry1(function type(val) {\n  return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n});\nexport default type;","import _clone from './internal/_clone';\nimport _curry1 from './internal/_curry1';\n\n/**\n * Creates a deep copy of the value which may contain (nested) `Array`s and\n * `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are\n * assigned by reference rather than copied\n *\n * Dispatches to a `clone` method if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {*} -> {*}\n * @param {*} value The object or array to clone\n * @return {*} A deeply cloned copy of `val`\n * @example\n *\n *      var objects = [{}, {}, {}];\n *      var objectsClone = R.clone(objects);\n *      objects === objectsClone; //=> false\n *      objects[0] === objectsClone[0]; //=> false\n */\nvar clone = /*#__PURE__*/_curry1(function clone(value) {\n  return value != null && typeof value.clone === 'function' ? value.clone() : _clone(value, [], [], true);\n});\nexport default clone;","import lift from './lift';\nimport not from './not';\n\n/**\n * Takes a function `f` and returns a function `g` such that if called with the same arguments\n * when `f` returns a \"truthy\" value, `g` returns `false` and when `f` returns a \"falsy\" value `g` returns `true`.\n *\n * `R.complement` may be applied to any functor\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> *) -> (*... -> Boolean)\n * @param {Function} f\n * @return {Function}\n * @see R.not\n * @example\n *\n *      var isNotNil = R.complement(R.isNil);\n *      isNil(null); //=> true\n *      isNotNil(null); //=> false\n *      isNil(7); //=> false\n *      isNotNil(7); //=> true\n */\nvar complement = /*#__PURE__*/lift(not);\nexport default complement;","import _curry1 from './internal/_curry1';\n\n/**\n * A function that returns the `!` of its argument. It will return `true` when\n * passed false-y value, and `false` when passed a truth-y one.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig * -> Boolean\n * @param {*} a any value\n * @return {Boolean} the logical inverse of passed argument.\n * @see R.complement\n * @example\n *\n *      R.not(true); //=> false\n *      R.not(false); //=> true\n *      R.not(0); //=> true\n *      R.not(1); //=> false\n */\nvar not = /*#__PURE__*/_curry1(function not(a) {\n  return !a;\n});\nexport default not;","export default function _pipe(f, g) {\n  return function () {\n    return g.call(this, f.apply(this, arguments));\n  };\n}","import _isArray from './_isArray';\n\n/**\n * This checks whether a function has a [methodname] function. If it isn't an\n * array it will execute that function otherwise it will default to the ramda\n * implementation.\n *\n * @private\n * @param {Function} fn ramda implemtation\n * @param {String} methodname property to check for a custom implementation\n * @return {Object} Whatever the return value of the method is.\n */\nexport default function _checkForMethod(methodname, fn) {\n  return function () {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    return _isArray(obj) || typeof obj[methodname] !== 'function' ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));\n  };\n}","import _checkForMethod from './internal/_checkForMethod';\nimport _curry3 from './internal/_curry3';\n\n/**\n * Returns the elements of the given list or string (or object with a `slice`\n * method) from `fromIndex` (inclusive) to `toIndex` (exclusive).\n *\n * Dispatches to the `slice` method of the third argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig Number -> Number -> [a] -> [a]\n * @sig Number -> Number -> String -> String\n * @param {Number} fromIndex The start index (inclusive).\n * @param {Number} toIndex The end index (exclusive).\n * @param {*} list\n * @return {*}\n * @example\n *\n *      R.slice(1, 3, ['a', 'b', 'c', 'd']);        //=> ['b', 'c']\n *      R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']\n *      R.slice(0, -1, ['a', 'b', 'c', 'd']);       //=> ['a', 'b', 'c']\n *      R.slice(-3, -1, ['a', 'b', 'c', 'd']);      //=> ['b', 'c']\n *      R.slice(0, 3, 'ramda');                     //=> 'ram'\n */\nvar slice = /*#__PURE__*/_curry3( /*#__PURE__*/_checkForMethod('slice', function slice(fromIndex, toIndex, list) {\n  return Array.prototype.slice.call(list, fromIndex, toIndex);\n}));\nexport default slice;","import _checkForMethod from './internal/_checkForMethod';\nimport _curry1 from './internal/_curry1';\nimport slice from './slice';\n\n/**\n * Returns all but the first element of the given list or string (or object\n * with a `tail` method).\n *\n * Dispatches to the `slice` method of the first argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.head, R.init, R.last\n * @example\n *\n *      R.tail([1, 2, 3]);  //=> [2, 3]\n *      R.tail([1, 2]);     //=> [2]\n *      R.tail([1]);        //=> []\n *      R.tail([]);         //=> []\n *\n *      R.tail('abc');  //=> 'bc'\n *      R.tail('ab');   //=> 'b'\n *      R.tail('a');    //=> ''\n *      R.tail('');     //=> ''\n */\nvar tail = /*#__PURE__*/_curry1( /*#__PURE__*/_checkForMethod('tail', /*#__PURE__*/slice(1, Infinity)));\nexport default tail;","import _arity from './internal/_arity';\nimport _pipe from './internal/_pipe';\nimport reduce from './reduce';\nimport tail from './tail';\n\n/**\n * Performs left-to-right function composition. The leftmost function may have\n * any arity; the remaining functions must be unary.\n *\n * In some libraries this function is named `sequence`.\n *\n * **Note:** The result of pipe is not automatically curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)\n * @param {...Function} functions\n * @return {Function}\n * @see R.compose\n * @example\n *\n *      var f = R.pipe(Math.pow, R.negate, R.inc);\n *\n *      f(3, 4); // -(3^4) + 1\n * @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b)))\n */\nexport default function pipe() {\n  if (arguments.length === 0) {\n    throw new Error('pipe requires at least one argument');\n  }\n  return _arity(arguments[0].length, reduce(_pipe, arguments[0], tail(arguments)));\n}","export default function _arrayFromIterator(iter) {\n  var list = [];\n  var next;\n  while (!(next = iter.next()).done) {\n    list.push(next.value);\n  }\n  return list;\n}","export default function _containsWith(pred, x, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    if (pred(x, list[idx])) {\n      return true;\n    }\n    idx += 1;\n  }\n  return false;\n}","import _curry2 from './internal/_curry2';\n\n/**\n * Returns true if its arguments are identical, false otherwise. Values are\n * identical if they reference the same memory. `NaN` is identical to `NaN`;\n * `0` and `-0` are not identical.\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Relation\n * @sig a -> a -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      var o = {};\n *      R.identical(o, o); //=> true\n *      R.identical(1, 1); //=> true\n *      R.identical(1, '1'); //=> false\n *      R.identical([], []); //=> false\n *      R.identical(0, -0); //=> false\n *      R.identical(NaN, NaN); //=> true\n */\nvar identical = /*#__PURE__*/_curry2(function identical(a, b) {\n  // SameValue algorithm\n  if (a === b) {\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n});\nexport default identical;","import _arrayFromIterator from './_arrayFromIterator';\nimport _containsWith from './_containsWith';\nimport _functionName from './_functionName';\nimport _has from './_has';\nimport identical from '../identical';\nimport keys from '../keys';\nimport type from '../type';\n\n/**\n * private _uniqContentEquals function.\n * That function is checking equality of 2 iterator contents with 2 assumptions\n * - iterators lengths are the same\n * - iterators values are unique\n *\n * false-positive result will be returned for comparision of, e.g.\n * - [1,2,3] and [1,2,3,4]\n * - [1,1,1] and [1,2,3]\n * */\n\nfunction _uniqContentEquals(aIterator, bIterator, stackA, stackB) {\n  var a = _arrayFromIterator(aIterator);\n  var b = _arrayFromIterator(bIterator);\n\n  function eq(_a, _b) {\n    return _equals(_a, _b, stackA.slice(), stackB.slice());\n  }\n\n  // if *a* array contains any element that is not included in *b*\n  return !_containsWith(function (b, aItem) {\n    return !_containsWith(eq, aItem, b);\n  }, b, a);\n}\n\nexport default function _equals(a, b, stackA, stackB) {\n  if (identical(a, b)) {\n    return true;\n  }\n\n  var typeA = type(a);\n\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (a == null || b == null) {\n    return false;\n  }\n\n  if (typeof a['fantasy-land/equals'] === 'function' || typeof b['fantasy-land/equals'] === 'function') {\n    return typeof a['fantasy-land/equals'] === 'function' && a['fantasy-land/equals'](b) && typeof b['fantasy-land/equals'] === 'function' && b['fantasy-land/equals'](a);\n  }\n\n  if (typeof a.equals === 'function' || typeof b.equals === 'function') {\n    return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a);\n  }\n\n  switch (typeA) {\n    case 'Arguments':\n    case 'Array':\n    case 'Object':\n      if (typeof a.constructor === 'function' && _functionName(a.constructor) === 'Promise') {\n        return a === b;\n      }\n      break;\n    case 'Boolean':\n    case 'Number':\n    case 'String':\n      if (!(typeof a === typeof b && identical(a.valueOf(), b.valueOf()))) {\n        return false;\n      }\n      break;\n    case 'Date':\n      if (!identical(a.valueOf(), b.valueOf())) {\n        return false;\n      }\n      break;\n    case 'Error':\n      return a.name === b.name && a.message === b.message;\n    case 'RegExp':\n      if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {\n        return false;\n      }\n      break;\n  }\n\n  var idx = stackA.length - 1;\n  while (idx >= 0) {\n    if (stackA[idx] === a) {\n      return stackB[idx] === b;\n    }\n    idx -= 1;\n  }\n\n  switch (typeA) {\n    case 'Map':\n      if (a.size !== b.size) {\n        return false;\n      }\n\n      return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));\n    case 'Set':\n      if (a.size !== b.size) {\n        return false;\n      }\n\n      return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));\n    case 'Arguments':\n    case 'Array':\n    case 'Object':\n    case 'Boolean':\n    case 'Number':\n    case 'String':\n    case 'Date':\n    case 'Error':\n    case 'RegExp':\n    case 'Int8Array':\n    case 'Uint8Array':\n    case 'Uint8ClampedArray':\n    case 'Int16Array':\n    case 'Uint16Array':\n    case 'Int32Array':\n    case 'Uint32Array':\n    case 'Float32Array':\n    case 'Float64Array':\n    case 'ArrayBuffer':\n      break;\n    default:\n      // Values of other types are only equal if identical.\n      return false;\n  }\n\n  var keysA = keys(a);\n  if (keysA.length !== keys(b).length) {\n    return false;\n  }\n\n  var extendedStackA = stackA.concat([a]);\n  var extendedStackB = stackB.concat([b]);\n\n  idx = keysA.length - 1;\n  while (idx >= 0) {\n    var key = keysA[idx];\n    if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {\n      return false;\n    }\n    idx -= 1;\n  }\n  return true;\n}","export default function _functionName(f) {\n  // String(x => x) evaluates to \"x => x\", so the pattern may not match.\n  var match = String(f).match(/^function (\\w*)/);\n  return match == null ? '' : match[1];\n}","import _curry2 from './internal/_curry2';\nimport _equals from './internal/_equals';\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise. Handles\n * cyclical data structures.\n *\n * Dispatches symmetrically to the `equals` methods of both arguments, if\n * present.\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      var a = {}; a.v = a;\n *      var b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\nvar equals = /*#__PURE__*/_curry2(function equals(a, b) {\n  return _equals(a, b, [], []);\n});\nexport default equals;","import equals from '../equals';\n\nexport default function _indexOf(list, a, idx) {\n  var inf, item;\n  // Array.prototype.indexOf doesn't exist below IE9\n  if (typeof list.indexOf === 'function') {\n    switch (typeof a) {\n      case 'number':\n        if (a === 0) {\n          // manually crawl the list to distinguish between +0 and -0\n          inf = 1 / a;\n          while (idx < list.length) {\n            item = list[idx];\n            if (item === 0 && 1 / item === inf) {\n              return idx;\n            }\n            idx += 1;\n          }\n          return -1;\n        } else if (a !== a) {\n          // NaN\n          while (idx < list.length) {\n            item = list[idx];\n            if (typeof item === 'number' && item !== item) {\n              return idx;\n            }\n            idx += 1;\n          }\n          return -1;\n        }\n        // non-zero numbers can utilise Set\n        return list.indexOf(a, idx);\n\n      // all these types can utilise Set\n      case 'string':\n      case 'boolean':\n      case 'function':\n      case 'undefined':\n        return list.indexOf(a, idx);\n\n      case 'object':\n        if (a === null) {\n          // null can utilise Set\n          return list.indexOf(a, idx);\n        }\n    }\n  }\n  // anything else not covered above, defer to R.equals\n  while (idx < list.length) {\n    if (equals(list[idx], a)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n}","import _indexOf from './_indexOf';\n\nexport default function _contains(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n}","export default function _quote(s) {\n  var escaped = s.replace(/\\\\/g, '\\\\\\\\').replace(/[\\b]/g, '\\\\b') // \\b matches word boundary; [\\b] matches backspace\n  .replace(/\\f/g, '\\\\f').replace(/\\n/g, '\\\\n').replace(/\\r/g, '\\\\r').replace(/\\t/g, '\\\\t').replace(/\\v/g, '\\\\v').replace(/\\0/g, '\\\\0');\n\n  return '\"' + escaped.replace(/\"/g, '\\\\\"') + '\"';\n}","/**\n * Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.\n */\nvar pad = function pad(n) {\n  return (n < 10 ? '0' : '') + n;\n};\n\nvar _toISOString = typeof Date.prototype.toISOString === 'function' ? function _toISOString(d) {\n  return d.toISOString();\n} : function _toISOString(d) {\n  return d.getUTCFullYear() + '-' + pad(d.getUTCMonth() + 1) + '-' + pad(d.getUTCDate()) + 'T' + pad(d.getUTCHours()) + ':' + pad(d.getUTCMinutes()) + ':' + pad(d.getUTCSeconds()) + '.' + (d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z';\n};\n\nexport default _toISOString;","export default function _complement(f) {\n  return function () {\n    return !f.apply(this, arguments);\n  };\n}","export default function _filter(fn, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [];\n\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n}","export default function _isObject(x) {\n  return Object.prototype.toString.call(x) === '[object Object]';\n}","import _curry2 from './_curry2';\nimport _xfBase from './_xfBase';\n\nvar XFilter = /*#__PURE__*/function () {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function (result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return XFilter;\n}();\n\nvar _xfilter = /*#__PURE__*/_curry2(function _xfilter(f, xf) {\n  return new XFilter(f, xf);\n});\nexport default _xfilter;","import _curry2 from './internal/_curry2';\nimport _dispatchable from './internal/_dispatchable';\nimport _filter from './internal/_filter';\nimport _isObject from './internal/_isObject';\nimport _reduce from './internal/_reduce';\nimport _xfilter from './internal/_xfilter';\nimport keys from './keys';\n\n/**\n * Takes a predicate and a `Filterable`, and returns a new filterable of the\n * same type containing the members of the given filterable which satisfy the\n * given predicate. Filterable objects include plain objects or any object\n * that has a filter method such as `Array`.\n *\n * Dispatches to the `filter` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> f a\n * @param {Function} pred\n * @param {Array} filterable\n * @return {Array} Filterable\n * @see R.reject, R.transduce, R.addIndex\n * @example\n *\n *      var isEven = n => n % 2 === 0;\n *\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n *\n *      R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}\n */\nvar filter = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['filter'], _xfilter, function (pred, filterable) {\n  return _isObject(filterable) ? _reduce(function (acc, key) {\n    if (pred(filterable[key])) {\n      acc[key] = filterable[key];\n    }\n    return acc;\n  }, {}, keys(filterable)) :\n  // else\n  _filter(pred, filterable);\n}));\nexport default filter;","import _complement from './internal/_complement';\nimport _curry2 from './internal/_curry2';\nimport filter from './filter';\n\n/**\n * The complement of [`filter`](#filter).\n *\n * Acts as a transducer if a transformer is given in list position. Filterable\n * objects include plain objects or any object that has a filter method such\n * as `Array`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> f a\n * @param {Function} pred\n * @param {Array} filterable\n * @return {Array}\n * @see R.filter, R.transduce, R.addIndex\n * @example\n *\n *      var isOdd = (n) => n % 2 === 1;\n *\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n *\n *      R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}\n */\nvar reject = /*#__PURE__*/_curry2(function reject(pred, filterable) {\n  return filter(_complement(pred), filterable);\n});\nexport default reject;","import _contains from './_contains';\nimport _map from './_map';\nimport _quote from './_quote';\nimport _toISOString from './_toISOString';\nimport keys from '../keys';\nimport reject from '../reject';\n\nexport default function _toString(x, seen) {\n  var recur = function recur(y) {\n    var xs = seen.concat([x]);\n    return _contains(y, xs) ? '<Circular>' : _toString(y, xs);\n  };\n\n  //  mapPairs :: (Object, [String]) -> [String]\n  var mapPairs = function (obj, keys) {\n    return _map(function (k) {\n      return _quote(k) + ': ' + recur(obj[k]);\n    }, keys.slice().sort());\n  };\n\n  switch (Object.prototype.toString.call(x)) {\n    case '[object Arguments]':\n      return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';\n    case '[object Array]':\n      return '[' + _map(recur, x).concat(mapPairs(x, reject(function (k) {\n        return (/^\\d+$/.test(k)\n        );\n      }, keys(x)))).join(', ') + ']';\n    case '[object Boolean]':\n      return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();\n    case '[object Date]':\n      return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';\n    case '[object Null]':\n      return 'null';\n    case '[object Number]':\n      return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);\n    case '[object String]':\n      return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);\n    case '[object Undefined]':\n      return 'undefined';\n    default:\n      if (typeof x.toString === 'function') {\n        var repr = x.toString();\n        if (repr !== '[object Object]') {\n          return repr;\n        }\n      }\n      return '{' + mapPairs(x, keys(x)).join(', ') + '}';\n  }\n}","import _curry1 from './internal/_curry1';\nimport _toString from './internal/_toString';\n\n/**\n * Returns the string representation of the given value. `eval`'ing the output\n * should result in a value equivalent to the input value. Many of the built-in\n * `toString` methods do not satisfy this requirement.\n *\n * If the given value is an `[object Object]` with a `toString` method other\n * than `Object.prototype.toString`, this method is invoked with no arguments\n * to produce the return value. This means user-defined constructor functions\n * can provide a suitable `toString` method. For example:\n *\n *     function Point(x, y) {\n *       this.x = x;\n *       this.y = y;\n *     }\n *\n *     Point.prototype.toString = function() {\n *       return 'new Point(' + this.x + ', ' + this.y + ')';\n *     };\n *\n *     R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'\n *\n * @func\n * @memberOf R\n * @since v0.14.0\n * @category String\n * @sig * -> String\n * @param {*} val\n * @return {String}\n * @example\n *\n *      R.toString(42); //=> '42'\n *      R.toString('abc'); //=> '\"abc\"'\n *      R.toString([1, 2, 3]); //=> '[1, 2, 3]'\n *      R.toString({foo: 1, bar: 2, baz: 3}); //=> '{\"bar\": 2, \"baz\": 3, \"foo\": 1}'\n *      R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date(\"2001-02-03T04:05:06.000Z\")'\n */\nvar toString = /*#__PURE__*/_curry1(function toString(val) {\n  return _toString(val, []);\n});\nexport default toString;","import _curry2 from './internal/_curry2';\nimport _isArray from './internal/_isArray';\nimport _isFunction from './internal/_isFunction';\nimport _isString from './internal/_isString';\nimport toString from './toString';\n\n/**\n * Returns the result of concatenating the given lists or strings.\n *\n * Note: `R.concat` expects both arguments to be of the same type,\n * unlike the native `Array.prototype.concat` method. It will throw\n * an error if you `concat` an Array with a non-Array value.\n *\n * Dispatches to the `concat` method of the first argument, if present.\n * Can also concatenate two members of a [fantasy-land\n * compatible semigroup](https://github.com/fantasyland/fantasy-land#semigroup).\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a] -> [a]\n * @sig String -> String -> String\n * @param {Array|String} firstList The first list\n * @param {Array|String} secondList The second list\n * @return {Array|String} A list consisting of the elements of `firstList` followed by the elements of\n * `secondList`.\n *\n * @example\n *\n *      R.concat('ABC', 'DEF'); // 'ABCDEF'\n *      R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n *      R.concat([], []); //=> []\n */\nvar concat = /*#__PURE__*/_curry2(function concat(a, b) {\n  if (_isArray(a)) {\n    if (_isArray(b)) {\n      return a.concat(b);\n    }\n    throw new TypeError(toString(b) + ' is not an array');\n  }\n  if (_isString(a)) {\n    if (_isString(b)) {\n      return a + b;\n    }\n    throw new TypeError(toString(b) + ' is not a string');\n  }\n  if (a != null && _isFunction(a['fantasy-land/concat'])) {\n    return a['fantasy-land/concat'](b);\n  }\n  if (a != null && _isFunction(a.concat)) {\n    return a.concat(b);\n  }\n  throw new TypeError(toString(a) + ' does not have a method named \"concat\" or \"fantasy-land/concat\"');\n});\nexport default concat;","import _arity from './internal/_arity';\nimport _curry1 from './internal/_curry1';\nimport map from './map';\nimport max from './max';\nimport reduce from './reduce';\n\n/**\n * Returns a function, `fn`, which encapsulates `if/else, if/else, ...` logic.\n * `R.cond` takes a list of [predicate, transformer] pairs. All of the arguments\n * to `fn` are applied to each of the predicates in turn until one returns a\n * \"truthy\" value, at which point `fn` returns the result of applying its\n * arguments to the corresponding transformer. If none of the predicates\n * matches, `fn` returns undefined.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Logic\n * @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)\n * @param {Array} pairs A list of [predicate, transformer]\n * @return {Function}\n * @example\n *\n *      var fn = R.cond([\n *        [R.equals(0),   R.always('water freezes at 0°C')],\n *        [R.equals(100), R.always('water boils at 100°C')],\n *        [R.T,           temp => 'nothing special happens at ' + temp + '°C']\n *      ]);\n *      fn(0); //=> 'water freezes at 0°C'\n *      fn(50); //=> 'nothing special happens at 50°C'\n *      fn(100); //=> 'water boils at 100°C'\n */\nvar cond = /*#__PURE__*/_curry1(function cond(pairs) {\n  var arity = reduce(max, 0, map(function (pair) {\n    return pair[0].length;\n  }, pairs));\n  return _arity(arity, function () {\n    var idx = 0;\n    while (idx < pairs.length) {\n      if (pairs[idx][0].apply(this, arguments)) {\n        return pairs[idx][1].apply(this, arguments);\n      }\n      idx += 1;\n    }\n  });\n});\nexport default cond;","import _contains from './internal/_contains';\nimport _curry2 from './internal/_curry2';\n\n/**\n * Returns `true` if the specified value is equal, in [`R.equals`](#equals)\n * terms, to at least one element of the given list; `false` otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> Boolean\n * @param {Object} a The item to compare against.\n * @param {Array} list The array to consider.\n * @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise.\n * @see R.any\n * @example\n *\n *      R.contains(3, [1, 2, 3]); //=> true\n *      R.contains(4, [1, 2, 3]); //=> false\n *      R.contains({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true\n *      R.contains([42], [[42]]); //=> true\n */\nvar contains = /*#__PURE__*/_curry2(_contains);\nexport default contains;","import _curry2 from './internal/_curry2';\n\n/**\n * Returns the second argument if it is not `null`, `undefined` or `NaN`;\n * otherwise the first argument is returned.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Logic\n * @sig a -> b -> a | b\n * @param {a} default The default value.\n * @param {b} val `val` will be returned instead of `default` unless `val` is `null`, `undefined` or `NaN`.\n * @return {*} The second value if it is not `null`, `undefined` or `NaN`, otherwise the default value\n * @example\n *\n *      var defaultTo42 = R.defaultTo(42);\n *\n *      defaultTo42(null);  //=> 42\n *      defaultTo42(undefined);  //=> 42\n *      defaultTo42('Ramda');  //=> 'Ramda'\n *      // parseInt('string') results in NaN\n *      defaultTo42(parseInt('string')); //=> 42\n */\nvar defaultTo = /*#__PURE__*/_curry2(function defaultTo(d, v) {\n  return v == null || v !== v ? d : v;\n});\nexport default defaultTo;","import _curry2 from './internal/_curry2';\n\n/**\n * Divides two numbers. Equivalent to `a / b`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a / b`.\n * @see R.multiply\n * @example\n *\n *      R.divide(71, 100); //=> 0.71\n *\n *      var half = R.divide(R.__, 2);\n *      half(42); //=> 21\n *\n *      var reciprocal = R.divide(1);\n *      reciprocal(4);   //=> 0.25\n */\nvar divide = /*#__PURE__*/_curry2(function divide(a, b) {\n  return a / b;\n});\nexport default divide;","import _curry2 from './_curry2';\nimport _reduce from './_reduce';\nimport _xfBase from './_xfBase';\n\nvar XDropLastWhile = /*#__PURE__*/function () {\n  function XDropLastWhile(fn, xf) {\n    this.f = fn;\n    this.retained = [];\n    this.xf = xf;\n  }\n  XDropLastWhile.prototype['@@transducer/init'] = _xfBase.init;\n  XDropLastWhile.prototype['@@transducer/result'] = function (result) {\n    this.retained = null;\n    return this.xf['@@transducer/result'](result);\n  };\n  XDropLastWhile.prototype['@@transducer/step'] = function (result, input) {\n    return this.f(input) ? this.retain(result, input) : this.flush(result, input);\n  };\n  XDropLastWhile.prototype.flush = function (result, input) {\n    result = _reduce(this.xf['@@transducer/step'], result, this.retained);\n    this.retained = [];\n    return this.xf['@@transducer/step'](result, input);\n  };\n  XDropLastWhile.prototype.retain = function (result, input) {\n    this.retained.push(input);\n    return result;\n  };\n\n  return XDropLastWhile;\n}();\n\nvar _xdropLastWhile = /*#__PURE__*/_curry2(function _xdropLastWhile(fn, xf) {\n  return new XDropLastWhile(fn, xf);\n});\nexport default _xdropLastWhile;","import _curry2 from './internal/_curry2';\nimport _isString from './internal/_isString';\n\n/**\n * Returns the nth element of the given list or string. If n is negative the\n * element at index length + n is returned.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Number -> [a] -> a | Undefined\n * @sig Number -> String -> String\n * @param {Number} offset\n * @param {*} list\n * @return {*}\n * @example\n *\n *      var list = ['foo', 'bar', 'baz', 'quux'];\n *      R.nth(1, list); //=> 'bar'\n *      R.nth(-1, list); //=> 'quux'\n *      R.nth(-99, list); //=> undefined\n *\n *      R.nth(2, 'abc'); //=> 'c'\n *      R.nth(3, 'abc'); //=> ''\n * @symb R.nth(-1, [a, b, c]) = c\n * @symb R.nth(0, [a, b, c]) = a\n * @symb R.nth(1, [a, b, c]) = b\n */\nvar nth = /*#__PURE__*/_curry2(function nth(offset, list) {\n  var idx = offset < 0 ? list.length + offset : offset;\n  return _isString(list) ? list.charAt(idx) : list[idx];\n});\nexport default nth;","import nth from './nth';\n\n/**\n * Returns the last element of the given list or string.\n *\n * @func\n * @memberOf R\n * @since v0.1.4\n * @category List\n * @sig [a] -> a | Undefined\n * @sig String -> String\n * @param {*} list\n * @return {*}\n * @see R.init, R.head, R.tail\n * @example\n *\n *      R.last(['fi', 'fo', 'fum']); //=> 'fum'\n *      R.last([]); //=> undefined\n *\n *      R.last('abc'); //=> 'c'\n *      R.last(''); //=> ''\n */\nvar last = /*#__PURE__*/nth(-1);\nexport default last;","import _curry2 from './internal/_curry2';\n\n/**\n * Returns `true` if one or both of its arguments are `true`. Returns `false`\n * if both arguments are `false`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig a -> b -> a | b\n * @param {Any} a\n * @param {Any} b\n * @return {Any} the first argument if truthy, otherwise the second argument.\n * @see R.either\n * @example\n *\n *      R.or(true, true); //=> true\n *      R.or(true, false); //=> true\n *      R.or(false, true); //=> true\n *      R.or(false, false); //=> false\n */\nvar or = /*#__PURE__*/_curry2(function or(a, b) {\n  return a || b;\n});\nexport default or;","import _curry2 from './internal/_curry2';\nimport _isFunction from './internal/_isFunction';\nimport lift from './lift';\nimport or from './or';\n\n/**\n * A function wrapping calls to the two functions in an `||` operation,\n * returning the result of the first function if it is truth-y and the result\n * of the second function otherwise. Note that this is short-circuited,\n * meaning that the second function will not be invoked if the first returns a\n * truth-y value.\n *\n * In addition to functions, `R.either` also accepts any fantasy-land compatible\n * applicative functor.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category Logic\n * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)\n * @param {Function} f a predicate\n * @param {Function} g another predicate\n * @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.\n * @see R.or\n * @example\n *\n *      var gt10 = x => x > 10;\n *      var even = x => x % 2 === 0;\n *      var f = R.either(gt10, even);\n *      f(101); //=> true\n *      f(8); //=> true\n */\nvar either = /*#__PURE__*/_curry2(function either(f, g) {\n  return _isFunction(f) ? function _either() {\n    return f.apply(this, arguments) || g.apply(this, arguments);\n  } : lift(or)(f, g);\n});\nexport default either;","import _curry1 from './internal/_curry1';\nimport _isArguments from './internal/_isArguments';\nimport _isArray from './internal/_isArray';\nimport _isObject from './internal/_isObject';\nimport _isString from './internal/_isString';\n\n/**\n * Returns the empty value of its argument's type. Ramda defines the empty\n * value of Array (`[]`), Object (`{}`), String (`''`), and Arguments. Other\n * types are supported if they define `<Type>.empty`,\n * `<Type>.prototype.empty` or implement the\n * [FantasyLand Monoid spec](https://github.com/fantasyland/fantasy-land#monoid).\n *\n * Dispatches to the `empty` method of the first argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category Function\n * @sig a -> a\n * @param {*} x\n * @return {*}\n * @example\n *\n *      R.empty(Just(42));      //=> Nothing()\n *      R.empty([1, 2, 3]);     //=> []\n *      R.empty('unicorns');    //=> ''\n *      R.empty({x: 1, y: 2});  //=> {}\n */\nvar empty = /*#__PURE__*/_curry1(function empty(x) {\n  return x != null && typeof x['fantasy-land/empty'] === 'function' ? x['fantasy-land/empty']() : x != null && x.constructor != null && typeof x.constructor['fantasy-land/empty'] === 'function' ? x.constructor['fantasy-land/empty']() : x != null && typeof x.empty === 'function' ? x.empty() : x != null && x.constructor != null && typeof x.constructor.empty === 'function' ? x.constructor.empty() : _isArray(x) ? [] : _isString(x) ? '' : _isObject(x) ? {} : _isArguments(x) ? function () {\n    return arguments;\n  }() :\n  // else\n  void 0;\n});\nexport default empty;","import _curry1 from './internal/_curry1';\nimport curryN from './curryN';\n\n/**\n * Returns a new function much like the supplied one, except that the first two\n * arguments' order is reversed.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig ((a, b, c, ...) -> z) -> (b -> a -> c -> ... -> z)\n * @param {Function} fn The function to invoke with its first two parameters reversed.\n * @return {*} The result of invoking `fn` with its first two parameters' order reversed.\n * @example\n *\n *      var mergeThree = (a, b, c) => [].concat(a, b, c);\n *\n *      mergeThree(1, 2, 3); //=> [1, 2, 3]\n *\n *      R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]\n * @symb R.flip(f)(a, b, c) = f(b, a, c)\n */\nvar flip = /*#__PURE__*/_curry1(function flip(fn) {\n  return curryN(fn.length, function (a, b) {\n    var args = Array.prototype.slice.call(arguments, 0);\n    args[0] = b;\n    args[1] = a;\n    return fn.apply(this, args);\n  });\n});\nexport default flip;","import _checkForMethod from './internal/_checkForMethod';\nimport _curry2 from './internal/_curry2';\n\n/**\n * Iterate over an input `list`, calling a provided function `fn` for each\n * element in the list.\n *\n * `fn` receives one argument: *(value)*.\n *\n * Note: `R.forEach` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.forEach` method. For more\n * details on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description\n *\n * Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns\n * the original array. In some libraries this function is named `each`.\n *\n * Dispatches to the `forEach` method of the second argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.1\n * @category List\n * @sig (a -> *) -> [a] -> [a]\n * @param {Function} fn The function to invoke. Receives one argument, `value`.\n * @param {Array} list The list to iterate over.\n * @return {Array} The original list.\n * @see R.addIndex\n * @example\n *\n *      var printXPlusFive = x => console.log(x + 5);\n *      R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]\n *      // logs 6\n *      // logs 7\n *      // logs 8\n * @symb R.forEach(f, [a, b, c]) = [a, b, c]\n */\nvar forEach = /*#__PURE__*/_curry2( /*#__PURE__*/_checkForMethod('forEach', function forEach(fn, list) {\n  var len = list.length;\n  var idx = 0;\n  while (idx < len) {\n    fn(list[idx]);\n    idx += 1;\n  }\n  return list;\n}));\nexport default forEach;","import nth from './nth';\n\n/**\n * Returns the first element of the given list or string. In some libraries\n * this function is named `first`.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> a | Undefined\n * @sig String -> String\n * @param {Array|String} list\n * @return {*}\n * @see R.tail, R.init, R.last\n * @example\n *\n *      R.head(['fi', 'fo', 'fum']); //=> 'fi'\n *      R.head([]); //=> undefined\n *\n *      R.head('abc'); //=> 'a'\n *      R.head(''); //=> ''\n */\nvar head = /*#__PURE__*/nth(0);\nexport default head;","import _objectAssign from './_objectAssign';\n\nexport default typeof Object.assign === 'function' ? Object.assign : _objectAssign;","import _clone from './internal/_clone';\nimport _curry3 from './internal/_curry3';\nimport _isTransformer from './internal/_isTransformer';\nimport _reduce from './internal/_reduce';\nimport _stepCat from './internal/_stepCat';\n\n/**\n * Transforms the items of the list with the transducer and appends the\n * transformed items to the accumulator using an appropriate iterator function\n * based on the accumulator type.\n *\n * The accumulator can be an array, string, object or a transformer. Iterated\n * items will be appended to arrays and concatenated to strings. Objects will\n * be merged directly or 2-item arrays will be merged as key, value pairs.\n *\n * The accumulator can also be a transformer object that provides a 2-arity\n * reducing iterator function, step, 0-arity initial value function, init, and\n * 1-arity result extraction function result. The step function is used as the\n * iterator function in reduce. The result function is used to convert the\n * final accumulator into the return type and in most cases is R.identity. The\n * init function is used to provide the initial accumulator.\n *\n * The iteration is performed with [`R.reduce`](#reduce) after initializing the\n * transducer.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category List\n * @sig a -> (b -> b) -> [c] -> a\n * @param {*} acc The initial accumulator value.\n * @param {Function} xf The transducer function. Receives a transformer and returns a transformer.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @example\n *\n *      var numbers = [1, 2, 3, 4];\n *      var transducer = R.compose(R.map(R.add(1)), R.take(2));\n *\n *      R.into([], transducer, numbers); //=> [2, 3]\n *\n *      var intoArray = R.into([]);\n *      intoArray(transducer, numbers); //=> [2, 3]\n */\nvar into = /*#__PURE__*/_curry3(function into(acc, xf, list) {\n  return _isTransformer(acc) ? _reduce(xf(acc), acc['@@transducer/init'](), list) : _reduce(xf(_stepCat(acc)), _clone(acc, [], [], false), list);\n});\nexport default into;","import _curry1 from './internal/_curry1';\nimport empty from './empty';\nimport equals from './equals';\n\n/**\n * Returns `true` if the given value is its type's empty value; `false`\n * otherwise.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Logic\n * @sig a -> Boolean\n * @param {*} x\n * @return {Boolean}\n * @see R.empty\n * @example\n *\n *      R.isEmpty([1, 2, 3]);   //=> false\n *      R.isEmpty([]);          //=> true\n *      R.isEmpty('');          //=> true\n *      R.isEmpty(null);        //=> false\n *      R.isEmpty({});          //=> true\n *      R.isEmpty({length: 0}); //=> false\n */\nvar isEmpty = /*#__PURE__*/_curry1(function isEmpty(x) {\n  return x != null && equals(x, empty(x));\n});\nexport default isEmpty;","import _curry1 from './internal/_curry1';\nimport _isNumber from './internal/_isNumber';\n\n/**\n * Returns the number of elements in the array by returning `list.length`.\n *\n * @func\n * @memberOf R\n * @since v0.3.0\n * @category List\n * @sig [a] -> Number\n * @param {Array} list The array to inspect.\n * @return {Number} The length of the array.\n * @example\n *\n *      R.length([]); //=> 0\n *      R.length([1, 2, 3]); //=> 3\n */\nvar length = /*#__PURE__*/_curry1(function length(list) {\n  return list != null && _isNumber(list.length) ? list.length : NaN;\n});\nexport default length;","import _curry2 from './internal/_curry2';\n\n/**\n * Multiplies two numbers. Equivalent to `a * b` but curried.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Math\n * @sig Number -> Number -> Number\n * @param {Number} a The first value.\n * @param {Number} b The second value.\n * @return {Number} The result of `a * b`.\n * @see R.divide\n * @example\n *\n *      var double = R.multiply(2);\n *      var triple = R.multiply(3);\n *      double(3);       //=>  6\n *      triple(4);       //=> 12\n *      R.multiply(2, 5);  //=> 10\n */\nvar multiply = /*#__PURE__*/_curry2(function multiply(a, b) {\n  return a * b;\n});\nexport default multiply;","import _concat from './internal/_concat';\nimport _createPartialApplicator from './internal/_createPartialApplicator';\n\n/**\n * Takes a function `f` and a list of arguments, and returns a function `g`.\n * When applied, `g` returns the result of applying `f` to the arguments\n * provided initially followed by the arguments provided to `g`.\n *\n * @func\n * @memberOf R\n * @since v0.10.0\n * @category Function\n * @sig ((a, b, c, ..., n) -> x) -> [a, b, c, ...] -> ((d, e, f, ..., n) -> x)\n * @param {Function} f\n * @param {Array} args\n * @return {Function}\n * @see R.partialRight\n * @example\n *\n *      var multiply2 = (a, b) => a * b;\n *      var double = R.partial(multiply2, [2]);\n *      double(2); //=> 4\n *\n *      var greet = (salutation, title, firstName, lastName) =>\n *        salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';\n *\n *      var sayHello = R.partial(greet, ['Hello']);\n *      var sayHelloToMs = R.partial(sayHello, ['Ms.']);\n *      sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'\n * @symb R.partial(f, [a, b])(c, d) = f(a, b, c, d)\n */\nvar partial = /*#__PURE__*/_createPartialApplicator(_concat);\nexport default partial;","import _curry3 from './internal/_curry3';\nimport equals from './equals';\nimport path from './path';\n\n/**\n * Determines whether a nested path on an object has a specific value, in\n * [`R.equals`](#equals) terms. Most likely used to filter a list.\n *\n * @func\n * @memberOf R\n * @since v0.7.0\n * @category Relation\n * @typedefn Idx = String | Int\n * @sig [Idx] -> a -> {a} -> Boolean\n * @param {Array} path The path of the nested property to use\n * @param {*} val The value to compare the nested property with\n * @param {Object} obj The object to check the nested property in\n * @return {Boolean} `true` if the value equals the nested object property,\n *         `false` otherwise.\n * @example\n *\n *      var user1 = { address: { zipCode: 90210 } };\n *      var user2 = { address: { zipCode: 55555 } };\n *      var user3 = { name: 'Bob' };\n *      var users = [ user1, user2, user3 ];\n *      var isFamous = R.pathEq(['address', 'zipCode'], 90210);\n *      R.filter(isFamous, users); //=> [ user1 ]\n */\nvar pathEq = /*#__PURE__*/_curry3(function pathEq(_path, val, obj) {\n  return equals(path(_path, obj), val);\n});\nexport default pathEq;","import _curry2 from './internal/_curry2';\n\n/**\n * Returns a partial copy of an object containing only the keys specified. If\n * the key does not exist, the property is ignored.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig [k] -> {k: v} -> {k: v}\n * @param {Array} names an array of String property names to copy onto a new object\n * @param {Object} obj The object to copy from\n * @return {Object} A new object with only properties from `names` on it.\n * @see R.omit, R.props\n * @example\n *\n *      R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}\n *      R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}\n */\nvar pick = /*#__PURE__*/_curry2(function pick(names, obj) {\n  var result = {};\n  var idx = 0;\n  while (idx < names.length) {\n    if (names[idx] in obj) {\n      result[names[idx]] = obj[names[idx]];\n    }\n    idx += 1;\n  }\n  return result;\n});\nexport default pick;","import _concat from './internal/_concat';\nimport _curry2 from './internal/_curry2';\n\n/**\n * Returns a new list with the given element at the front, followed by the\n * contents of the list.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig a -> [a] -> [a]\n * @param {*} el The item to add to the head of the output list.\n * @param {Array} list The array to add to the tail of the output list.\n * @return {Array} A new array.\n * @see R.append\n * @example\n *\n *      R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']\n */\nvar prepend = /*#__PURE__*/_curry2(function prepend(el, list) {\n  return _concat([el], list);\n});\nexport default prepend;","import _curry2 from './_curry2';\nimport _xfBase from './_xfBase';\n\nvar XTap = /*#__PURE__*/function () {\n  function XTap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XTap.prototype['@@transducer/init'] = _xfBase.init;\n  XTap.prototype['@@transducer/result'] = _xfBase.result;\n  XTap.prototype['@@transducer/step'] = function (result, input) {\n    this.f(input);\n    return this.xf['@@transducer/step'](result, input);\n  };\n\n  return XTap;\n}();\n\nvar _xtap = /*#__PURE__*/_curry2(function _xtap(f, xf) {\n  return new XTap(f, xf);\n});\nexport default _xtap;","import _curry2 from './internal/_curry2';\nimport _dispatchable from './internal/_dispatchable';\nimport _xtap from './internal/_xtap';\n\n/**\n * Runs the given function with the supplied object, then returns the object.\n *\n * Acts as a transducer if a transformer is given as second parameter.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig (a -> *) -> a -> a\n * @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.\n * @param {*} x\n * @return {*} `x`.\n * @example\n *\n *      var sayX = x => console.log('x is ' + x);\n *      R.tap(sayX, 100); //=> 100\n *      // logs 'x is 100'\n * @symb R.tap(f, a) = a\n */\nvar tap = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable([], _xtap, function tap(fn, x) {\n  fn(x);\n  return x;\n}));\nexport default tap;","import _cloneRegExp from './internal/_cloneRegExp';\nimport _curry2 from './internal/_curry2';\nimport _isRegExp from './internal/_isRegExp';\nimport toString from './toString';\n\n/**\n * Determines whether a given string matches a given regular expression.\n *\n * @func\n * @memberOf R\n * @since v0.12.0\n * @category String\n * @sig RegExp -> String -> Boolean\n * @param {RegExp} pattern\n * @param {String} str\n * @return {Boolean}\n * @see R.match\n * @example\n *\n *      R.test(/^x/, 'xyz'); //=> true\n *      R.test(/^y/, 'xyz'); //=> false\n */\nvar test = /*#__PURE__*/_curry2(function test(pattern, str) {\n  if (!_isRegExp(pattern)) {\n    throw new TypeError('‘test’ requires a value of type RegExp as its first argument; received ' + toString(pattern));\n  }\n  return _cloneRegExp(pattern).test(str);\n});\nexport default test;","import _curry1 from './internal/_curry1';\nimport _has from './internal/_has';\n\n/**\n * Converts an object into an array of key, value arrays. Only the object's\n * own properties are used.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.4.0\n * @category Object\n * @sig {String: *} -> [[String,*]]\n * @param {Object} obj The object to extract from\n * @return {Array} An array of key, value arrays from the object's own properties.\n * @see R.fromPairs\n * @example\n *\n *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n */\nvar toPairs = /*#__PURE__*/_curry1(function toPairs(obj) {\n  var pairs = [];\n  for (var prop in obj) {\n    if (_has(prop, obj)) {\n      pairs[pairs.length] = [prop, obj[prop]];\n    }\n  }\n  return pairs;\n});\nexport default toPairs;","import _curry1 from './internal/_curry1';\n\nvar ws = '\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' + '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028' + '\\u2029\\uFEFF';\nvar zeroWidth = '\\u200b';\nvar hasProtoTrim = typeof String.prototype.trim === 'function';\n/**\n * Removes (strips) whitespace from both ends of the string.\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category String\n * @sig String -> String\n * @param {String} str The string to trim.\n * @return {String} Trimmed version of `str`.\n * @example\n *\n *      R.trim('   xyz  '); //=> 'xyz'\n *      R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']\n */\nvar _trim = !hasProtoTrim || /*#__PURE__*/ws.trim() || ! /*#__PURE__*/zeroWidth.trim() ? function trim(str) {\n  var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');\n  var endRx = new RegExp('[' + ws + '][' + ws + ']*$');\n  return str.replace(beginRx, '').replace(endRx, '');\n} : function trim(str) {\n  return str.trim();\n};\nvar trim = /*#__PURE__*/_curry1(_trim);\nexport default trim;","import _curry3 from './internal/_curry3';\n\n/**\n * Tests the final argument by passing it to the given predicate function. If\n * the predicate is satisfied, the function will return the result of calling\n * the `whenTrueFn` function with the same argument. If the predicate is not\n * satisfied, the argument is returned as is.\n *\n * @func\n * @memberOf R\n * @since v0.18.0\n * @category Logic\n * @sig (a -> Boolean) -> (a -> a) -> a -> a\n * @param {Function} pred       A predicate function\n * @param {Function} whenTrueFn A function to invoke when the `condition`\n *                              evaluates to a truthy value.\n * @param {*}        x          An object to test with the `pred` function and\n *                              pass to `whenTrueFn` if necessary.\n * @return {*} Either `x` or the result of applying `x` to `whenTrueFn`.\n * @see R.ifElse, R.unless\n * @example\n *\n *      // truncate :: String -> String\n *      var truncate = R.when(\n *        R.propSatisfies(R.gt(R.__, 10), 'length'),\n *        R.pipe(R.take(10), R.append('…'), R.join(''))\n *      );\n *      truncate('12345');         //=> '12345'\n *      truncate('0123456789ABC'); //=> '0123456789…'\n */\nvar when = /*#__PURE__*/_curry3(function when(pred, whenTrueFn, x) {\n  return pred(x) ? whenTrueFn(x) : x;\n});\nexport default when;","/*!\n  Copyright (c) 2017 Jed Watson.\n  Licensed under the MIT License (MIT), see\n  http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(this && this[arg] || arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tclasses.push(classNames.apply(this, arg));\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(this && this[key] || key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","import { __rest } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nexport function setContext(setter) {\n    return new ApolloLink(function (operation, forward) {\n        var request = __rest(operation, []);\n        return new Observable(function (observer) {\n            var handle;\n            var closed = false;\n            Promise.resolve(request)\n                .then(function (req) { return setter(req, operation.getContext()); })\n                .then(operation.setContext)\n                .then(function () {\n                if (closed)\n                    return;\n                handle = forward(operation).subscribe({\n                    next: observer.next.bind(observer),\n                    error: observer.error.bind(observer),\n                    complete: observer.complete.bind(observer),\n                });\n            })\n                .catch(observer.error.bind(observer));\n            return function () {\n                closed = true;\n                if (handle)\n                    handle.unsubscribe();\n            };\n        });\n    });\n}\n//# sourceMappingURL=index.js.map","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nfunction _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }\n\nvar _extends = _interopDefault(require('@babel/runtime/helpers/extends'));\nvar _objectWithoutPropertiesLoose = _interopDefault(require('@babel/runtime/helpers/objectWithoutPropertiesLoose'));\nvar React = require('react');\nvar React__default = _interopDefault(React);\nvar _inheritsLoose = _interopDefault(require('@babel/runtime/helpers/inheritsLoose'));\nvar _assertThisInitialized = _interopDefault(require('@babel/runtime/helpers/assertThisInitialized'));\n\nvar is = {\n  arr: Array.isArray,\n  obj: function obj(a) {\n    return Object.prototype.toString.call(a) === '[object Object]';\n  },\n  fun: function fun(a) {\n    return typeof a === 'function';\n  },\n  str: function str(a) {\n    return typeof a === 'string';\n  },\n  num: function num(a) {\n    return typeof a === 'number';\n  },\n  und: function und(a) {\n    return a === void 0;\n  },\n  nul: function nul(a) {\n    return a === null;\n  },\n  set: function set(a) {\n    return a instanceof Set;\n  },\n  map: function map(a) {\n    return a instanceof Map;\n  },\n  equ: function equ(a, b) {\n    if (typeof a !== typeof b) return false;\n    if (is.str(a) || is.num(a)) return a === b;\n    if (is.obj(a) && is.obj(b) && Object.keys(a).length + Object.keys(b).length === 0) return true;\n    var i;\n\n    for (i in a) {\n      if (!(i in b)) return false;\n    }\n\n    for (i in b) {\n      if (a[i] !== b[i]) return false;\n    }\n\n    return is.und(i) ? a === b : true;\n  }\n};\nfunction merge(target, lowercase) {\n  if (lowercase === void 0) {\n    lowercase = true;\n  }\n\n  return function (object) {\n    return (is.arr(object) ? object : Object.keys(object)).reduce(function (acc, element) {\n      var key = lowercase ? element[0].toLowerCase() + element.substring(1) : element;\n      acc[key] = target(key);\n      return acc;\n    }, target);\n  };\n}\nfunction useForceUpdate() {\n  var _useState = React.useState(false),\n      f = _useState[1];\n\n  var forceUpdate = React.useCallback(function () {\n    return f(function (v) {\n      return !v;\n    });\n  }, []);\n  return forceUpdate;\n}\nfunction withDefault(value, defaultValue) {\n  return is.und(value) || is.nul(value) ? defaultValue : value;\n}\nfunction toArray(a) {\n  return !is.und(a) ? is.arr(a) ? a : [a] : [];\n}\nfunction callProp(obj) {\n  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    args[_key - 1] = arguments[_key];\n  }\n\n  return is.fun(obj) ? obj.apply(void 0, args) : obj;\n}\n\nfunction getForwardProps(props) {\n  var to = props.to,\n      from = props.from,\n      config = props.config,\n      onStart = props.onStart,\n      onRest = props.onRest,\n      onFrame = props.onFrame,\n      children = props.children,\n      reset = props.reset,\n      reverse = props.reverse,\n      force = props.force,\n      immediate = props.immediate,\n      delay = props.delay,\n      attach = props.attach,\n      destroyed = props.destroyed,\n      interpolateTo = props.interpolateTo,\n      ref = props.ref,\n      lazy = props.lazy,\n      forward = _objectWithoutPropertiesLoose(props, [\"to\", \"from\", \"config\", \"onStart\", \"onRest\", \"onFrame\", \"children\", \"reset\", \"reverse\", \"force\", \"immediate\", \"delay\", \"attach\", \"destroyed\", \"interpolateTo\", \"ref\", \"lazy\"]);\n\n  return forward;\n}\n\nfunction interpolateTo(props) {\n  var forward = getForwardProps(props);\n  if (is.und(forward)) return _extends({\n    to: forward\n  }, props);\n  var rest = Object.keys(props).reduce(function (a, k) {\n    var _extends2;\n\n    return !is.und(forward[k]) ? a : _extends({}, a, (_extends2 = {}, _extends2[k] = props[k], _extends2));\n  }, {});\n  return _extends({\n    to: forward\n  }, rest);\n}\nfunction handleRef(ref, forward) {\n  if (forward) {\n    // If it's a function, assume it's a ref callback\n    if (is.fun(forward)) forward(ref);else if (is.obj(forward)) {\n      forward.current = ref;\n    }\n  }\n\n  return ref;\n}\n\nvar Animated =\n/*#__PURE__*/\nfunction () {\n  function Animated() {\n    this.payload = void 0;\n    this.children = [];\n  }\n\n  var _proto = Animated.prototype;\n\n  _proto.getAnimatedValue = function getAnimatedValue() {\n    return this.getValue();\n  };\n\n  _proto.getPayload = function getPayload() {\n    return this.payload || this;\n  };\n\n  _proto.attach = function attach() {};\n\n  _proto.detach = function detach() {};\n\n  _proto.getChildren = function getChildren() {\n    return this.children;\n  };\n\n  _proto.addChild = function addChild(child) {\n    if (this.children.length === 0) this.attach();\n    this.children.push(child);\n  };\n\n  _proto.removeChild = function removeChild(child) {\n    var index = this.children.indexOf(child);\n    this.children.splice(index, 1);\n    if (this.children.length === 0) this.detach();\n  };\n\n  return Animated;\n}();\nvar AnimatedArray =\n/*#__PURE__*/\nfunction (_Animated) {\n  _inheritsLoose(AnimatedArray, _Animated);\n\n  function AnimatedArray() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _Animated.call.apply(_Animated, [this].concat(args)) || this;\n    _this.payload = [];\n\n    _this.attach = function () {\n      return _this.payload.forEach(function (p) {\n        return p instanceof Animated && p.addChild(_assertThisInitialized(_this));\n      });\n    };\n\n    _this.detach = function () {\n      return _this.payload.forEach(function (p) {\n        return p instanceof Animated && p.removeChild(_assertThisInitialized(_this));\n      });\n    };\n\n    return _this;\n  }\n\n  return AnimatedArray;\n}(Animated);\nvar AnimatedObject =\n/*#__PURE__*/\nfunction (_Animated2) {\n  _inheritsLoose(AnimatedObject, _Animated2);\n\n  function AnimatedObject() {\n    var _this2;\n\n    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n      args[_key3] = arguments[_key3];\n    }\n\n    _this2 = _Animated2.call.apply(_Animated2, [this].concat(args)) || this;\n    _this2.payload = {};\n\n    _this2.attach = function () {\n      return Object.values(_this2.payload).forEach(function (s) {\n        return s instanceof Animated && s.addChild(_assertThisInitialized(_this2));\n      });\n    };\n\n    _this2.detach = function () {\n      return Object.values(_this2.payload).forEach(function (s) {\n        return s instanceof Animated && s.removeChild(_assertThisInitialized(_this2));\n      });\n    };\n\n    return _this2;\n  }\n\n  var _proto2 = AnimatedObject.prototype;\n\n  _proto2.getValue = function getValue(animated) {\n    if (animated === void 0) {\n      animated = false;\n    }\n\n    var payload = {};\n\n    for (var _key4 in this.payload) {\n      var value = this.payload[_key4];\n      if (animated && !(value instanceof Animated)) continue;\n      payload[_key4] = value instanceof Animated ? value[animated ? 'getAnimatedValue' : 'getValue']() : value;\n    }\n\n    return payload;\n  };\n\n  _proto2.getAnimatedValue = function getAnimatedValue() {\n    return this.getValue(true);\n  };\n\n  return AnimatedObject;\n}(Animated);\n\nvar applyAnimatedValues;\nfunction injectApplyAnimatedValues(fn, transform) {\n  applyAnimatedValues = {\n    fn: fn,\n    transform: transform\n  };\n}\nvar colorNames;\nfunction injectColorNames(names) {\n  colorNames = names;\n}\nvar requestFrame = function requestFrame(cb) {\n  return typeof window !== 'undefined' ? window.requestAnimationFrame(cb) : -1;\n};\nvar cancelFrame = function cancelFrame(id) {\n  typeof window !== 'undefined' && window.cancelAnimationFrame(id);\n};\nfunction injectFrame(raf, caf) {\n  requestFrame = raf;\n  cancelFrame = caf;\n}\nvar interpolation;\nfunction injectStringInterpolator(fn) {\n  interpolation = fn;\n}\nvar now = function now() {\n  return Date.now();\n};\nfunction injectNow(nowFn) {\n  now = nowFn;\n}\nvar defaultElement;\nfunction injectDefaultElement(el) {\n  defaultElement = el;\n}\nvar animatedApi = function animatedApi(node) {\n  return node.current;\n};\nfunction injectAnimatedApi(fn) {\n  animatedApi = fn;\n}\nvar createAnimatedStyle;\nfunction injectCreateAnimatedStyle(factory) {\n  createAnimatedStyle = factory;\n}\nvar manualFrameloop;\nfunction injectManualFrameloop(callback) {\n  manualFrameloop = callback;\n}\n\nvar Globals = /*#__PURE__*/Object.freeze({\n  get applyAnimatedValues () { return applyAnimatedValues; },\n  injectApplyAnimatedValues: injectApplyAnimatedValues,\n  get colorNames () { return colorNames; },\n  injectColorNames: injectColorNames,\n  get requestFrame () { return requestFrame; },\n  get cancelFrame () { return cancelFrame; },\n  injectFrame: injectFrame,\n  get interpolation () { return interpolation; },\n  injectStringInterpolator: injectStringInterpolator,\n  get now () { return now; },\n  injectNow: injectNow,\n  get defaultElement () { return defaultElement; },\n  injectDefaultElement: injectDefaultElement,\n  get animatedApi () { return animatedApi; },\n  injectAnimatedApi: injectAnimatedApi,\n  get createAnimatedStyle () { return createAnimatedStyle; },\n  injectCreateAnimatedStyle: injectCreateAnimatedStyle,\n  get manualFrameloop () { return manualFrameloop; },\n  injectManualFrameloop: injectManualFrameloop\n});\n\n/**\n * Wraps the `style` property with `AnimatedStyle`.\n */\n\nvar AnimatedProps =\n/*#__PURE__*/\nfunction (_AnimatedObject) {\n  _inheritsLoose(AnimatedProps, _AnimatedObject);\n\n  function AnimatedProps(props, callback) {\n    var _this;\n\n    _this = _AnimatedObject.call(this) || this;\n    _this.update = void 0;\n    _this.payload = !props.style ? props : _extends({}, props, {\n      style: createAnimatedStyle(props.style)\n    });\n    _this.update = callback;\n\n    _this.attach();\n\n    return _this;\n  }\n\n  return AnimatedProps;\n}(AnimatedObject);\n\nvar isFunctionComponent = function isFunctionComponent(val) {\n  return is.fun(val) && !(val.prototype instanceof React__default.Component);\n};\n\nvar createAnimatedComponent = function createAnimatedComponent(Component) {\n  var AnimatedComponent = React.forwardRef(function (props, ref) {\n    var forceUpdate = useForceUpdate();\n    var mounted = React.useRef(true);\n    var propsAnimated = React.useRef(null);\n    var node = React.useRef(null);\n    var attachProps = React.useCallback(function (props) {\n      var oldPropsAnimated = propsAnimated.current;\n\n      var callback = function callback() {\n        var didUpdate = false;\n\n        if (node.current) {\n          didUpdate = applyAnimatedValues.fn(node.current, propsAnimated.current.getAnimatedValue());\n        }\n\n        if (!node.current || didUpdate === false) {\n          // If no referenced node has been found, or the update target didn't have a\n          // native-responder, then forceUpdate the animation ...\n          forceUpdate();\n        }\n      };\n\n      propsAnimated.current = new AnimatedProps(props, callback);\n      oldPropsAnimated && oldPropsAnimated.detach();\n    }, []);\n    React.useEffect(function () {\n      return function () {\n        mounted.current = false;\n        propsAnimated.current && propsAnimated.current.detach();\n      };\n    }, []);\n    React.useImperativeHandle(ref, function () {\n      return animatedApi(node, mounted, forceUpdate);\n    });\n    attachProps(props);\n\n    var _getValue = propsAnimated.current.getValue(),\n        scrollTop = _getValue.scrollTop,\n        scrollLeft = _getValue.scrollLeft,\n        animatedProps = _objectWithoutPropertiesLoose(_getValue, [\"scrollTop\", \"scrollLeft\"]); // Functions cannot have refs, see:\n    // See: https://github.com/react-spring/react-spring/issues/569\n\n\n    var refFn = isFunctionComponent(Component) ? undefined : function (childRef) {\n      return node.current = handleRef(childRef, ref);\n    };\n    return React__default.createElement(Component, _extends({}, animatedProps, {\n      ref: refFn\n    }));\n  });\n  return AnimatedComponent;\n};\n\nvar active = false;\nvar controllers = new Set();\n\nvar update = function update() {\n  if (!active) return false;\n  var time = now();\n\n  for (var _iterator = controllers, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n    var _ref;\n\n    if (_isArray) {\n      if (_i >= _iterator.length) break;\n      _ref = _iterator[_i++];\n    } else {\n      _i = _iterator.next();\n      if (_i.done) break;\n      _ref = _i.value;\n    }\n\n    var controller = _ref;\n    var isActive = false;\n\n    for (var configIdx = 0; configIdx < controller.configs.length; configIdx++) {\n      var config = controller.configs[configIdx];\n      var endOfAnimation = void 0,\n          lastTime = void 0;\n\n      for (var valIdx = 0; valIdx < config.animatedValues.length; valIdx++) {\n        var animation = config.animatedValues[valIdx]; // If an animation is done, skip, until all of them conclude\n\n        if (animation.done) continue;\n        var from = config.fromValues[valIdx];\n        var to = config.toValues[valIdx];\n        var position = animation.lastPosition;\n        var isAnimated = to instanceof Animated;\n        var velocity = Array.isArray(config.initialVelocity) ? config.initialVelocity[valIdx] : config.initialVelocity;\n        if (isAnimated) to = to.getValue(); // Conclude animation if it's either immediate, or from-values match end-state\n\n        if (config.immediate) {\n          animation.setValue(to);\n          animation.done = true;\n          continue;\n        } // Break animation when string values are involved\n\n\n        if (typeof from === 'string' || typeof to === 'string') {\n          animation.setValue(to);\n          animation.done = true;\n          continue;\n        }\n\n        if (config.duration !== void 0) {\n          /** Duration easing */\n          position = from + config.easing((time - animation.startTime) / config.duration) * (to - from);\n          endOfAnimation = time >= animation.startTime + config.duration;\n        } else if (config.decay) {\n          /** Decay easing */\n          position = from + velocity / (1 - 0.998) * (1 - Math.exp(-(1 - 0.998) * (time - animation.startTime)));\n          endOfAnimation = Math.abs(animation.lastPosition - position) < 0.1;\n          if (endOfAnimation) to = position;\n        } else {\n          /** Spring easing */\n          lastTime = animation.lastTime !== void 0 ? animation.lastTime : time;\n          velocity = animation.lastVelocity !== void 0 ? animation.lastVelocity : config.initialVelocity; // If we lost a lot of frames just jump to the end.\n\n          if (time > lastTime + 64) lastTime = time; // http://gafferongames.com/game-physics/fix-your-timestep/\n\n          var numSteps = Math.floor(time - lastTime);\n\n          for (var i = 0; i < numSteps; ++i) {\n            var force = -config.tension * (position - to);\n            var damping = -config.friction * velocity;\n            var acceleration = (force + damping) / config.mass;\n            velocity = velocity + acceleration * 1 / 1000;\n            position = position + velocity * 1 / 1000;\n          } // Conditions for stopping the spring animation\n\n\n          var isOvershooting = config.clamp && config.tension !== 0 ? from < to ? position > to : position < to : false;\n          var isVelocity = Math.abs(velocity) <= config.precision;\n          var isDisplacement = config.tension !== 0 ? Math.abs(to - position) <= config.precision : true;\n          endOfAnimation = isOvershooting || isVelocity && isDisplacement;\n          animation.lastVelocity = velocity;\n          animation.lastTime = time;\n        } // Trails aren't done until their parents conclude\n\n\n        if (isAnimated && !config.toValues[valIdx].done) endOfAnimation = false;\n\n        if (endOfAnimation) {\n          // Ensure that we end up with a round value\n          if (animation.value !== to) position = to;\n          animation.done = true;\n        } else isActive = true;\n\n        animation.setValue(position);\n        animation.lastPosition = position;\n      } // Keep track of updated values only when necessary\n\n\n      if (controller.props.onFrame) controller.values[config.name] = config.interpolation.getValue();\n    } // Update callbacks in the end of the frame\n\n\n    if (controller.props.onFrame) controller.props.onFrame(controller.values); // Either call onEnd or next frame\n\n    if (!isActive) {\n      controllers.delete(controller);\n      controller.stop(true);\n    }\n  } // Loop over as long as there are controllers ...\n\n\n  if (controllers.size) {\n    if (manualFrameloop) manualFrameloop();else requestFrame(update);\n  } else {\n    active = false;\n  }\n\n  return active;\n};\n\nvar start = function start(controller) {\n  if (!controllers.has(controller)) controllers.add(controller);\n\n  if (!active) {\n    active = true;\n    if (manualFrameloop) requestFrame(manualFrameloop);else requestFrame(update);\n  }\n};\n\nvar stop = function stop(controller) {\n  if (controllers.has(controller)) controllers.delete(controller);\n};\n\nfunction createInterpolator(range, output, extrapolate) {\n  if (typeof range === 'function') {\n    return range;\n  }\n\n  if (Array.isArray(range)) {\n    return createInterpolator({\n      range: range,\n      output: output,\n      extrapolate: extrapolate\n    });\n  }\n\n  if (interpolation && typeof range.output[0] === 'string') {\n    return interpolation(range);\n  }\n\n  var config = range;\n  var outputRange = config.output;\n  var inputRange = config.range || [0, 1];\n  var extrapolateLeft = config.extrapolateLeft || config.extrapolate || 'extend';\n  var extrapolateRight = config.extrapolateRight || config.extrapolate || 'extend';\n\n  var easing = config.easing || function (t) {\n    return t;\n  };\n\n  return function (input) {\n    var range = findRange(input, inputRange);\n    return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight, config.map);\n  };\n}\n\nfunction interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight, map) {\n  var result = map ? map(input) : input; // Extrapolate\n\n  if (result < inputMin) {\n    if (extrapolateLeft === 'identity') return result;else if (extrapolateLeft === 'clamp') result = inputMin;\n  }\n\n  if (result > inputMax) {\n    if (extrapolateRight === 'identity') return result;else if (extrapolateRight === 'clamp') result = inputMax;\n  }\n\n  if (outputMin === outputMax) return outputMin;\n  if (inputMin === inputMax) return input <= inputMin ? outputMin : outputMax; // Input Range\n\n  if (inputMin === -Infinity) result = -result;else if (inputMax === Infinity) result = result - inputMin;else result = (result - inputMin) / (inputMax - inputMin); // Easing\n\n  result = easing(result); // Output Range\n\n  if (outputMin === -Infinity) result = -result;else if (outputMax === Infinity) result = result + outputMin;else result = result * (outputMax - outputMin) + outputMin;\n  return result;\n}\n\nfunction findRange(input, inputRange) {\n  for (var i = 1; i < inputRange.length - 1; ++i) {\n    if (inputRange[i] >= input) break;\n  }\n\n  return i - 1;\n}\n\nvar AnimatedInterpolation =\n/*#__PURE__*/\nfunction (_AnimatedArray) {\n  _inheritsLoose(AnimatedInterpolation, _AnimatedArray);\n\n  function AnimatedInterpolation(parents, range, output, extrapolate) {\n    var _this;\n\n    _this = _AnimatedArray.call(this) || this;\n    _this.calc = void 0;\n    _this.payload = parents instanceof AnimatedArray && !(parents instanceof AnimatedInterpolation) ? parents.getPayload() : Array.isArray(parents) ? parents : [parents];\n    _this.calc = createInterpolator(range, output, extrapolate);\n    return _this;\n  }\n\n  var _proto = AnimatedInterpolation.prototype;\n\n  _proto.getValue = function getValue() {\n    return this.calc.apply(this, this.payload.map(function (value) {\n      return value.getValue();\n    }));\n  };\n\n  _proto.updateConfig = function updateConfig(range, output, extrapolate) {\n    this.calc = createInterpolator(range, output, extrapolate);\n  };\n\n  _proto.interpolate = function interpolate(range, output, extrapolate) {\n    return new AnimatedInterpolation(this, range, output, extrapolate);\n  };\n\n  return AnimatedInterpolation;\n}(AnimatedArray);\n\nvar interpolate$1 = function interpolate(parents, range, output) {\n  return parents && new AnimatedInterpolation(parents, range, output);\n};\n\nvar config = {\n  default: {\n    tension: 170,\n    friction: 26\n  },\n  gentle: {\n    tension: 120,\n    friction: 14\n  },\n  wobbly: {\n    tension: 180,\n    friction: 12\n  },\n  stiff: {\n    tension: 210,\n    friction: 20\n  },\n  slow: {\n    tension: 280,\n    friction: 60\n  },\n  molasses: {\n    tension: 280,\n    friction: 120\n  }\n};\n\n/** API\n *  useChain(references, timeSteps, timeFrame)\n */\n\nfunction useChain(refs, timeSteps, timeFrame) {\n  if (timeFrame === void 0) {\n    timeFrame = 1000;\n  }\n\n  var previous = React.useRef();\n  React.useEffect(function () {\n    if (is.equ(refs, previous.current)) refs.forEach(function (_ref) {\n      var current = _ref.current;\n      return current && current.start();\n    });else if (timeSteps) {\n      refs.forEach(function (_ref2, index) {\n        var current = _ref2.current;\n\n        if (current) {\n          var ctrls = current.controllers;\n\n          if (ctrls.length) {\n            var t = timeFrame * timeSteps[index];\n            ctrls.forEach(function (ctrl) {\n              ctrl.queue = ctrl.queue.map(function (e) {\n                return _extends({}, e, {\n                  delay: e.delay + t\n                });\n              });\n              ctrl.start();\n            });\n          }\n        }\n      });\n    } else refs.reduce(function (q, _ref3, rI) {\n      var current = _ref3.current;\n      return q = q.then(function () {\n        return current.start();\n      });\n    }, Promise.resolve());\n    previous.current = refs;\n  });\n}\n\n/**\n * Animated works by building a directed acyclic graph of dependencies\n * transparently when you render your Animated components.\n *\n *               new Animated.Value(0)\n *     .interpolate()        .interpolate()    new Animated.Value(1)\n *         opacity               translateY      scale\n *          style                         transform\n *         View#234                         style\n *                                         View#123\n *\n * A) Top Down phase\n * When an AnimatedValue is updated, we recursively go down through this\n * graph in order to find leaf nodes: the views that we flag as needing\n * an update.\n *\n * B) Bottom Up phase\n * When a view is flagged as needing an update, we recursively go back up\n * in order to build the new value that it needs. The reason why we need\n * this two-phases process is to deal with composite props such as\n * transform which can receive values from multiple parents.\n */\nfunction addAnimatedStyles(node, styles) {\n  if ('update' in node) {\n    styles.add(node);\n  } else {\n    node.getChildren().forEach(function (child) {\n      return addAnimatedStyles(child, styles);\n    });\n  }\n}\n\nvar AnimatedValue =\n/*#__PURE__*/\nfunction (_Animated) {\n  _inheritsLoose(AnimatedValue, _Animated);\n\n  function AnimatedValue(_value) {\n    var _this;\n\n    _this = _Animated.call(this) || this;\n    _this.animatedStyles = new Set();\n    _this.value = void 0;\n    _this.startPosition = void 0;\n    _this.lastPosition = void 0;\n    _this.lastVelocity = void 0;\n    _this.startTime = void 0;\n    _this.lastTime = void 0;\n    _this.done = false;\n\n    _this.setValue = function (value, flush) {\n      if (flush === void 0) {\n        flush = true;\n      }\n\n      _this.value = value;\n      if (flush) _this.flush();\n    };\n\n    _this.value = _value;\n    _this.startPosition = _value;\n    _this.lastPosition = _value;\n    return _this;\n  }\n\n  var _proto = AnimatedValue.prototype;\n\n  _proto.flush = function flush() {\n    if (this.animatedStyles.size === 0) {\n      addAnimatedStyles(this, this.animatedStyles);\n    }\n\n    this.animatedStyles.forEach(function (animatedStyle) {\n      return animatedStyle.update();\n    });\n  };\n\n  _proto.clearStyles = function clearStyles() {\n    this.animatedStyles.clear();\n  };\n\n  _proto.getValue = function getValue() {\n    return this.value;\n  };\n\n  _proto.interpolate = function interpolate(range, output, extrapolate) {\n    return new AnimatedInterpolation(this, range, output, extrapolate);\n  };\n\n  return AnimatedValue;\n}(Animated);\n\nvar AnimatedValueArray =\n/*#__PURE__*/\nfunction (_AnimatedArray) {\n  _inheritsLoose(AnimatedValueArray, _AnimatedArray);\n\n  function AnimatedValueArray(values) {\n    var _this;\n\n    _this = _AnimatedArray.call(this) || this;\n    _this.payload = values.map(function (n) {\n      return new AnimatedValue(n);\n    });\n    return _this;\n  }\n\n  var _proto = AnimatedValueArray.prototype;\n\n  _proto.setValue = function setValue(value, flush) {\n    var _this2 = this;\n\n    if (flush === void 0) {\n      flush = true;\n    }\n\n    if (Array.isArray(value)) {\n      if (value.length === this.payload.length) {\n        value.forEach(function (v, i) {\n          return _this2.payload[i].setValue(v, flush);\n        });\n      }\n    } else {\n      this.payload.forEach(function (p) {\n        return p.setValue(value, flush);\n      });\n    }\n  };\n\n  _proto.getValue = function getValue() {\n    return this.payload.map(function (v) {\n      return v.getValue();\n    });\n  };\n\n  _proto.interpolate = function interpolate(range, output) {\n    return new AnimatedInterpolation(this, range, output);\n  };\n\n  return AnimatedValueArray;\n}(AnimatedArray);\n\nvar G = 0;\n\nvar Controller =\n/*#__PURE__*/\nfunction () {\n  function Controller() {\n    var _this = this;\n\n    this.id = void 0;\n    this.idle = true;\n    this.hasChanged = false;\n    this.guid = 0;\n    this.local = 0;\n    this.props = {};\n    this.merged = {};\n    this.animations = {};\n    this.interpolations = {};\n    this.values = {};\n    this.configs = [];\n    this.listeners = [];\n    this.queue = [];\n    this.localQueue = void 0;\n\n    this.getValues = function () {\n      return _this.interpolations;\n    };\n\n    this.id = G++;\n  }\n  /** update(props)\n   *  This function filters input props and creates an array of tasks which are executed in .start()\n   *  Each task is allowed to carry a delay, which means it can execute asnychroneously */\n\n\n  var _proto = Controller.prototype;\n\n  _proto.update = function update$$1(args) {\n    //this._id = n + this.id\n    if (!args) return this; // Extract delay and the to-prop from props\n\n    var _ref = interpolateTo(args),\n        _ref$delay = _ref.delay,\n        delay = _ref$delay === void 0 ? 0 : _ref$delay,\n        to = _ref.to,\n        props = _objectWithoutPropertiesLoose(_ref, [\"delay\", \"to\"]);\n\n    if (is.arr(to) || is.fun(to)) {\n      // If config is either a function or an array queue it up as is\n      this.queue.push(_extends({}, props, {\n        delay: delay,\n        to: to\n      }));\n    } else if (to) {\n      // Otherwise go through each key since it could be delayed individually\n      var ops = {};\n      Object.entries(to).forEach(function (_ref2) {\n        var _to;\n\n        var k = _ref2[0],\n            v = _ref2[1];\n\n        // Fetch delay and create an entry, consisting of the to-props, the delay, and basic props\n        var entry = _extends({\n          to: (_to = {}, _to[k] = v, _to),\n          delay: callProp(delay, k)\n        }, props);\n\n        var previous = ops[entry.delay] && ops[entry.delay].to;\n        ops[entry.delay] = _extends({}, ops[entry.delay], entry, {\n          to: _extends({}, previous, entry.to)\n        });\n      });\n      this.queue = Object.values(ops);\n    } // Sort queue, so that async calls go last\n\n\n    this.queue = this.queue.sort(function (a, b) {\n      return a.delay - b.delay;\n    }); // Diff the reduced props immediately (they'll contain the from-prop and some config)\n\n    this.diff(props);\n    return this;\n  }\n  /** start(onEnd)\n   *  This function either executes a queue, if present, or starts the frameloop, which animates */\n  ;\n\n  _proto.start = function start$$1(onEnd) {\n    var _this2 = this;\n\n    // If a queue is present we must excecute it\n    if (this.queue.length) {\n      this.idle = false; // Updates can interrupt trailing queues, in that case we just merge values\n\n      if (this.localQueue) {\n        this.localQueue.forEach(function (_ref3) {\n          var _ref3$from = _ref3.from,\n              from = _ref3$from === void 0 ? {} : _ref3$from,\n              _ref3$to = _ref3.to,\n              to = _ref3$to === void 0 ? {} : _ref3$to;\n          if (is.obj(from)) _this2.merged = _extends({}, from, _this2.merged);\n          if (is.obj(to)) _this2.merged = _extends({}, _this2.merged, to);\n        });\n      } // The guid helps us tracking frames, a new queue over an old one means an override\n      // We discard async calls in that caseÍ\n\n\n      var local = this.local = ++this.guid;\n      var queue = this.localQueue = this.queue;\n      this.queue = []; // Go through each entry and execute it\n\n      queue.forEach(function (_ref4, index) {\n        var delay = _ref4.delay,\n            props = _objectWithoutPropertiesLoose(_ref4, [\"delay\"]);\n\n        var cb = function cb(finished) {\n          if (index === queue.length - 1 && local === _this2.guid && finished) {\n            _this2.idle = true;\n            if (_this2.props.onRest) _this2.props.onRest(_this2.merged);\n          }\n\n          if (onEnd) onEnd();\n        }; // Entries can be delayed, ansyc or immediate\n\n\n        var async = is.arr(props.to) || is.fun(props.to);\n\n        if (delay) {\n          setTimeout(function () {\n            if (local === _this2.guid) {\n              if (async) _this2.runAsync(props, cb);else _this2.diff(props).start(cb);\n            }\n          }, delay);\n        } else if (async) _this2.runAsync(props, cb);else _this2.diff(props).start(cb);\n      });\n    } // Otherwise we kick of the frameloop\n    else {\n        if (is.fun(onEnd)) this.listeners.push(onEnd);\n        if (this.props.onStart) this.props.onStart();\n\n        start(this);\n      }\n\n    return this;\n  };\n\n  _proto.stop = function stop$$1(finished) {\n    this.listeners.forEach(function (onEnd) {\n      return onEnd(finished);\n    });\n    this.listeners = [];\n    return this;\n  }\n  /** Pause sets onEnd listeners free, but also removes the controller from the frameloop */\n  ;\n\n  _proto.pause = function pause(finished) {\n    this.stop(true);\n    if (finished) stop(this);\n    return this;\n  };\n\n  _proto.runAsync = function runAsync(_ref5, onEnd) {\n    var _this3 = this;\n\n    var delay = _ref5.delay,\n        props = _objectWithoutPropertiesLoose(_ref5, [\"delay\"]);\n\n    var local = this.local; // If \"to\" is either a function or an array it will be processed async, therefor \"to\" should be empty right now\n    // If the view relies on certain values \"from\" has to be present\n\n    var queue = Promise.resolve(undefined);\n\n    if (is.arr(props.to)) {\n      var _loop = function _loop(i) {\n        var index = i;\n\n        var fresh = _extends({}, props, interpolateTo(props.to[index]));\n\n        if (is.arr(fresh.config)) fresh.config = fresh.config[index];\n        queue = queue.then(function () {\n          //this.stop()\n          if (local === _this3.guid) return new Promise(function (r) {\n            return _this3.diff(fresh).start(r);\n          });\n        });\n      };\n\n      for (var i = 0; i < props.to.length; i++) {\n        _loop(i);\n      }\n    } else if (is.fun(props.to)) {\n      var index = 0;\n      var last;\n      queue = queue.then(function () {\n        return props.to( // next(props)\n        function (p) {\n          var fresh = _extends({}, props, interpolateTo(p));\n\n          if (is.arr(fresh.config)) fresh.config = fresh.config[index];\n          index++; //this.stop()\n\n          if (local === _this3.guid) return last = new Promise(function (r) {\n            return _this3.diff(fresh).start(r);\n          });\n          return;\n        }, // cancel()\n        function (finished) {\n          if (finished === void 0) {\n            finished = true;\n          }\n\n          return _this3.stop(finished);\n        }).then(function () {\n          return last;\n        });\n      });\n    }\n\n    queue.then(onEnd);\n  };\n\n  _proto.diff = function diff(props) {\n    var _this4 = this;\n\n    this.props = _extends({}, this.props, props);\n    var _this$props = this.props,\n        _this$props$from = _this$props.from,\n        from = _this$props$from === void 0 ? {} : _this$props$from,\n        _this$props$to = _this$props.to,\n        to = _this$props$to === void 0 ? {} : _this$props$to,\n        _this$props$config = _this$props.config,\n        config = _this$props$config === void 0 ? {} : _this$props$config,\n        reverse = _this$props.reverse,\n        attach = _this$props.attach,\n        reset = _this$props.reset,\n        immediate = _this$props.immediate; // Reverse values when requested\n\n    if (reverse) {\n      var _ref6 = [to, from];\n      from = _ref6[0];\n      to = _ref6[1];\n    } // This will collect all props that were ever set, reset merged props when necessary\n\n\n    this.merged = _extends({}, from, this.merged, to);\n    this.hasChanged = false; // Attachment handling, trailed springs can \"attach\" themselves to a previous spring\n\n    var target = attach && attach(this); // Reduces input { name: value } pairs into animated values\n\n    this.animations = Object.entries(this.merged).reduce(function (acc, _ref7) {\n      var name = _ref7[0],\n          value = _ref7[1];\n      // Issue cached entries, except on reset\n      var entry = acc[name] || {}; // Figure out what the value is supposed to be\n\n      var isNumber = is.num(value);\n      var isString = is.str(value) && !value.startsWith('#') && !/\\d/.test(value) && !colorNames[value];\n      var isArray = is.arr(value);\n      var isInterpolation = !isNumber && !isArray && !isString;\n      var fromValue = !is.und(from[name]) ? from[name] : value;\n      var toValue = isNumber || isArray ? value : isString ? value : 1;\n      var toConfig = callProp(config, name);\n      if (target) toValue = target.animations[name].parent;\n      var parent = entry.parent,\n          interpolation$$1 = entry.interpolation,\n          toValues = toArray(target ? toValue.getPayload() : toValue),\n          animatedValues;\n      var newValue = value;\n      if (isInterpolation) newValue = interpolation({\n        range: [0, 1],\n        output: [value, value]\n      })(1);\n      var currentValue = interpolation$$1 && interpolation$$1.getValue(); // Change detection flags\n\n      var isFirst = is.und(parent);\n      var isActive = !isFirst && entry.animatedValues.some(function (v) {\n        return !v.done;\n      });\n      var currentValueDiffersFromGoal = !is.equ(newValue, currentValue);\n      var hasNewGoal = !is.equ(newValue, entry.previous);\n      var hasNewConfig = !is.equ(toConfig, entry.config); // Change animation props when props indicate a new goal (new value differs from previous one)\n      // and current values differ from it. Config changes trigger a new update as well (though probably shouldn't?)\n\n      if (reset || hasNewGoal && currentValueDiffersFromGoal || hasNewConfig) {\n        var _extends2;\n\n        // Convert regular values into animated values, ALWAYS re-use if possible\n        if (isNumber || isString) parent = interpolation$$1 = entry.parent || new AnimatedValue(fromValue);else if (isArray) parent = interpolation$$1 = entry.parent || new AnimatedValueArray(fromValue);else if (isInterpolation) {\n          var prev = entry.interpolation && entry.interpolation.calc(entry.parent.value);\n          prev = prev !== void 0 && !reset ? prev : fromValue;\n\n          if (entry.parent) {\n            parent = entry.parent;\n            parent.setValue(0, false);\n          } else parent = new AnimatedValue(0);\n\n          var range = {\n            output: [prev, value]\n          };\n\n          if (entry.interpolation) {\n            interpolation$$1 = entry.interpolation;\n            entry.interpolation.updateConfig(range);\n          } else interpolation$$1 = parent.interpolate(range);\n        }\n        toValues = toArray(target ? toValue.getPayload() : toValue);\n        animatedValues = toArray(parent.getPayload());\n        if (reset && !isInterpolation) parent.setValue(fromValue, false);\n        _this4.hasChanged = true; // Reset animated values\n\n        animatedValues.forEach(function (value) {\n          value.startPosition = value.value;\n          value.lastPosition = value.value;\n          value.lastVelocity = isActive ? value.lastVelocity : undefined;\n          value.lastTime = isActive ? value.lastTime : undefined;\n          value.startTime = now();\n          value.done = false;\n          value.animatedStyles.clear();\n        }); // Set immediate values\n\n        if (callProp(immediate, name)) {\n          parent.setValue(isInterpolation ? toValue : value, false);\n        }\n\n        return _extends({}, acc, (_extends2 = {}, _extends2[name] = _extends({}, entry, {\n          name: name,\n          parent: parent,\n          interpolation: interpolation$$1,\n          animatedValues: animatedValues,\n          toValues: toValues,\n          previous: newValue,\n          config: toConfig,\n          fromValues: toArray(parent.getValue()),\n          immediate: callProp(immediate, name),\n          initialVelocity: withDefault(toConfig.velocity, 0),\n          clamp: withDefault(toConfig.clamp, false),\n          precision: withDefault(toConfig.precision, 0.01),\n          tension: withDefault(toConfig.tension, 170),\n          friction: withDefault(toConfig.friction, 26),\n          mass: withDefault(toConfig.mass, 1),\n          duration: toConfig.duration,\n          easing: withDefault(toConfig.easing, function (t) {\n            return t;\n          }),\n          decay: toConfig.decay\n        }), _extends2));\n      } else {\n        if (!currentValueDiffersFromGoal) {\n          var _extends3;\n\n          // So ... the current target value (newValue) appears to be different from the previous value,\n          // which normally constitutes an update, but the actual value (currentValue) matches the target!\n          // In order to resolve this without causing an animation update we silently flag the animation as done,\n          // which it technically is. Interpolations also needs a config update with their target set to 1.\n          if (isInterpolation) {\n            parent.setValue(1, false);\n            interpolation$$1.updateConfig({\n              output: [newValue, newValue]\n            });\n          }\n\n          parent.done = true;\n          _this4.hasChanged = true;\n          return _extends({}, acc, (_extends3 = {}, _extends3[name] = _extends({}, acc[name], {\n            previous: newValue\n          }), _extends3));\n        }\n\n        return acc;\n      }\n    }, this.animations);\n\n    if (this.hasChanged) {\n      // Make animations available to frameloop\n      this.configs = Object.values(this.animations);\n      this.values = {};\n      this.interpolations = {};\n\n      for (var key in this.animations) {\n        this.interpolations[key] = this.animations[key].interpolation;\n        this.values[key] = this.animations[key].interpolation.getValue();\n      }\n    }\n\n    return this;\n  };\n\n  _proto.destroy = function destroy() {\n    this.stop();\n    this.props = {};\n    this.merged = {};\n    this.animations = {};\n    this.interpolations = {};\n    this.values = {};\n    this.configs = [];\n    this.local = 0;\n  };\n\n  return Controller;\n}();\n\n/** API\n * const props = useSprings(number, [{ ... }, { ... }, ...])\n * const [props, set] = useSprings(number, (i, controller) => ({ ... }))\n */\n\nvar useSprings = function useSprings(length, props) {\n  var mounted = React.useRef(false);\n  var ctrl = React.useRef();\n  var isFn = is.fun(props); // The controller maintains the animation values, starts and stops animations\n\n  var _useMemo = React.useMemo(function () {\n    // Remove old controllers\n    if (ctrl.current) {\n      ctrl.current.map(function (c) {\n        return c.destroy();\n      });\n      ctrl.current = undefined;\n    }\n\n    var ref;\n    return [new Array(length).fill().map(function (_, i) {\n      var ctrl = new Controller();\n      var newProps = isFn ? callProp(props, i, ctrl) : props[i];\n      if (i === 0) ref = newProps.ref;\n      ctrl.update(newProps);\n      if (!ref) ctrl.start();\n      return ctrl;\n    }), ref];\n  }, [length]),\n      controllers = _useMemo[0],\n      ref = _useMemo[1];\n\n  ctrl.current = controllers; // The hooks reference api gets defined here ...\n\n  var api = React.useImperativeHandle(ref, function () {\n    return {\n      start: function start() {\n        return Promise.all(ctrl.current.map(function (c) {\n          return new Promise(function (r) {\n            return c.start(r);\n          });\n        }));\n      },\n      stop: function stop(finished) {\n        return ctrl.current.forEach(function (c) {\n          return c.stop(finished);\n        });\n      },\n\n      get controllers() {\n        return ctrl.current;\n      }\n\n    };\n  }); // This function updates the controllers\n\n  var updateCtrl = React.useMemo(function () {\n    return function (updateProps) {\n      return ctrl.current.map(function (c, i) {\n        c.update(isFn ? callProp(updateProps, i, c) : updateProps[i]);\n        if (!ref) c.start();\n      });\n    };\n  }, [length]); // Update controller if props aren't functional\n\n  React.useEffect(function () {\n    if (mounted.current) {\n      if (!isFn) updateCtrl(props);\n    } else if (!ref) ctrl.current.forEach(function (c) {\n      return c.start();\n    });\n  }); // Update mounted flag and destroy controller on unmount\n\n  React.useEffect(function () {\n    return mounted.current = true, function () {\n      return ctrl.current.forEach(function (c) {\n        return c.destroy();\n      });\n    };\n  }, []); // Return animated props, or, anim-props + the update-setter above\n\n  var propValues = ctrl.current.map(function (c) {\n    return c.getValues();\n  });\n  return isFn ? [propValues, updateCtrl, function (finished) {\n    return ctrl.current.forEach(function (c) {\n      return c.pause(finished);\n    });\n  }] : propValues;\n};\n\n/** API\n * const props = useSpring({ ... })\n * const [props, set] = useSpring(() => ({ ... }))\n */\n\nvar useSpring = function useSpring(props) {\n  var isFn = is.fun(props);\n\n  var _useSprings = useSprings(1, isFn ? props : [props]),\n      result = _useSprings[0],\n      set = _useSprings[1],\n      pause = _useSprings[2];\n\n  return isFn ? [result[0], set, pause] : result;\n};\n\n/** API\n * const trails = useTrail(number, { ... })\n * const [trails, set] = useTrail(number, () => ({ ... }))\n */\n\nvar useTrail = function useTrail(length, props) {\n  var mounted = React.useRef(false);\n  var isFn = is.fun(props);\n  var updateProps = callProp(props);\n  var instances = React.useRef();\n\n  var _useSprings = useSprings(length, function (i, ctrl) {\n    if (i === 0) instances.current = [];\n    instances.current.push(ctrl);\n    return _extends({}, updateProps, {\n      config: callProp(updateProps.config, i),\n      attach: i > 0 && function () {\n        return instances.current[i - 1];\n      }\n    });\n  }),\n      result = _useSprings[0],\n      set = _useSprings[1],\n      pause = _useSprings[2]; // Set up function to update controller\n\n\n  var updateCtrl = React.useMemo(function () {\n    return function (props) {\n      return set(function (i, ctrl) {\n        var last = props.reverse ? i === 0 : length - 1 === i;\n        var attachIdx = props.reverse ? i + 1 : i - 1;\n        var attachController = instances.current[attachIdx];\n        return _extends({}, props, {\n          config: callProp(props.config || updateProps.config, i),\n          attach: attachController && function () {\n            return attachController;\n          }\n        });\n      });\n    };\n  }, [length, updateProps.reverse]); // Update controller if props aren't functional\n\n  React.useEffect(function () {\n    return void (mounted.current && !isFn && updateCtrl(props));\n  }); // Update mounted flag and destroy controller on unmount\n\n  React.useEffect(function () {\n    return void (mounted.current = true);\n  }, []);\n  return isFn ? [result, updateCtrl, pause] : result;\n};\n\n/** API\n * const transitions = useTransition(items, itemKeys, { ... })\n * const [transitions, update] = useTransition(items, itemKeys, () => ({ ... }))\n */\n\nvar guid = 0;\nvar ENTER = 'enter';\nvar LEAVE = 'leave';\nvar UPDATE = 'update';\n\nvar mapKeys = function mapKeys(items, keys) {\n  return (typeof keys === 'function' ? items.map(keys) : toArray(keys)).map(String);\n};\n\nvar get = function get(props) {\n  var items = props.items,\n      _props$keys = props.keys,\n      keys = _props$keys === void 0 ? function (item) {\n    return item;\n  } : _props$keys,\n      rest = _objectWithoutPropertiesLoose(props, [\"items\", \"keys\"]);\n\n  items = toArray(items !== void 0 ? items : null);\n  return _extends({\n    items: items,\n    keys: mapKeys(items, keys)\n  }, rest);\n};\n\nfunction useTransition(input, keyTransform, config) {\n  var props = _extends({\n    items: input,\n    keys: keyTransform || function (i) {\n      return i;\n    }\n  }, config);\n\n  var _get = get(props),\n      _get$lazy = _get.lazy,\n      lazy = _get$lazy === void 0 ? false : _get$lazy,\n      _get$unique = _get.unique,\n      _get$reset = _get.reset,\n      reset = _get$reset === void 0 ? false : _get$reset,\n      enter = _get.enter,\n      leave = _get.leave,\n      update = _get.update,\n      onDestroyed = _get.onDestroyed,\n      keys = _get.keys,\n      items = _get.items,\n      onFrame = _get.onFrame,\n      _onRest = _get.onRest,\n      onStart = _get.onStart,\n      ref = _get.ref,\n      extra = _objectWithoutPropertiesLoose(_get, [\"lazy\", \"unique\", \"reset\", \"enter\", \"leave\", \"update\", \"onDestroyed\", \"keys\", \"items\", \"onFrame\", \"onRest\", \"onStart\", \"ref\"]);\n\n  var forceUpdate = useForceUpdate();\n  var mounted = React.useRef(false);\n  var state = React.useRef({\n    mounted: false,\n    first: true,\n    deleted: [],\n    current: {},\n    transitions: [],\n    prevProps: {},\n    paused: !!props.ref,\n    instances: !mounted.current && new Map(),\n    forceUpdate: forceUpdate\n  });\n  React.useImperativeHandle(props.ref, function () {\n    return {\n      start: function start() {\n        return Promise.all(Array.from(state.current.instances).map(function (_ref) {\n          var c = _ref[1];\n          return new Promise(function (r) {\n            return c.start(r);\n          });\n        }));\n      },\n      stop: function stop(finished) {\n        return Array.from(state.current.instances).forEach(function (_ref2) {\n          var c = _ref2[1];\n          return c.stop(finished);\n        });\n      },\n\n      get controllers() {\n        return Array.from(state.current.instances).map(function (_ref3) {\n          var c = _ref3[1];\n          return c;\n        });\n      }\n\n    };\n  }); // Update state\n\n  state.current = diffItems(state.current, props);\n\n  if (state.current.changed) {\n    // Update state\n    state.current.transitions.forEach(function (transition) {\n      var slot = transition.slot,\n          from = transition.from,\n          to = transition.to,\n          config = transition.config,\n          trail = transition.trail,\n          key = transition.key,\n          item = transition.item;\n      if (!state.current.instances.has(key)) state.current.instances.set(key, new Controller()); // update the map object\n\n      var ctrl = state.current.instances.get(key);\n\n      var newProps = _extends({}, extra, {\n        to: to,\n        from: from,\n        config: config,\n        ref: ref,\n        onRest: function onRest(values) {\n          if (state.current.mounted) {\n            if (transition.destroyed) {\n              // If no ref is given delete destroyed items immediately\n              if (!ref && !lazy) cleanUp(state, key);\n              if (onDestroyed) onDestroyed(item);\n            } // A transition comes to rest once all its springs conclude\n\n\n            var curInstances = Array.from(state.current.instances);\n            var active = curInstances.some(function (_ref4) {\n              var c = _ref4[1];\n              return !c.idle;\n            });\n            if (!active && (ref || lazy) && state.current.deleted.length > 0) cleanUp(state);\n            if (_onRest) _onRest(item, slot, values);\n          }\n        },\n        onStart: onStart && function () {\n          return onStart(item, slot);\n        },\n        onFrame: onFrame && function (values) {\n          return onFrame(item, slot, values);\n        },\n        delay: trail,\n        reset: reset && slot === ENTER // Update controller\n\n      });\n\n      ctrl.update(newProps);\n      if (!state.current.paused) ctrl.start();\n    });\n  }\n\n  React.useEffect(function () {\n    state.current.mounted = mounted.current = true;\n    return function () {\n      state.current.mounted = mounted.current = false;\n      Array.from(state.current.instances).map(function (_ref5) {\n        var c = _ref5[1];\n        return c.destroy();\n      });\n      state.current.instances.clear();\n    };\n  }, []);\n  return state.current.transitions.map(function (_ref6) {\n    var item = _ref6.item,\n        slot = _ref6.slot,\n        key = _ref6.key;\n    return {\n      item: item,\n      key: key,\n      state: slot,\n      props: state.current.instances.get(key).getValues()\n    };\n  });\n}\n\nfunction cleanUp(state, filterKey) {\n  var deleted = state.current.deleted;\n\n  var _loop = function _loop() {\n    if (_isArray) {\n      if (_i >= _iterator.length) return \"break\";\n      _ref8 = _iterator[_i++];\n    } else {\n      _i = _iterator.next();\n      if (_i.done) return \"break\";\n      _ref8 = _i.value;\n    }\n\n    var _ref7 = _ref8;\n    var key = _ref7.key;\n\n    var filter = function filter(t) {\n      return t.key !== key;\n    };\n\n    if (is.und(filterKey) || filterKey === key) {\n      state.current.instances.delete(key);\n      state.current.transitions = state.current.transitions.filter(filter);\n      state.current.deleted = state.current.deleted.filter(filter);\n    }\n  };\n\n  for (var _iterator = deleted, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n    var _ref8;\n\n    var _ret = _loop();\n\n    if (_ret === \"break\") break;\n  }\n\n  state.current.forceUpdate();\n}\n\nfunction diffItems(_ref9, props) {\n  var first = _ref9.first,\n      prevProps = _ref9.prevProps,\n      state = _objectWithoutPropertiesLoose(_ref9, [\"first\", \"prevProps\"]);\n\n  var _get2 = get(props),\n      items = _get2.items,\n      keys = _get2.keys,\n      initial = _get2.initial,\n      from = _get2.from,\n      enter = _get2.enter,\n      leave = _get2.leave,\n      update = _get2.update,\n      _get2$trail = _get2.trail,\n      trail = _get2$trail === void 0 ? 0 : _get2$trail,\n      unique = _get2.unique,\n      config = _get2.config,\n      _get2$order = _get2.order,\n      order = _get2$order === void 0 ? [ENTER, LEAVE, UPDATE] : _get2$order;\n\n  var _get3 = get(prevProps),\n      _keys = _get3.keys,\n      _items = _get3.items;\n\n  var current = _extends({}, state.current);\n\n  var deleted = [].concat(state.deleted); // Compare next keys with current keys\n\n  var currentKeys = Object.keys(current);\n  var currentSet = new Set(currentKeys);\n  var nextSet = new Set(keys);\n  var added = keys.filter(function (item) {\n    return !currentSet.has(item);\n  });\n  var removed = state.transitions.filter(function (item) {\n    return !item.destroyed && !nextSet.has(item.originalKey);\n  }).map(function (i) {\n    return i.originalKey;\n  });\n  var updated = keys.filter(function (item) {\n    return currentSet.has(item);\n  });\n  var delay = -trail;\n\n  while (order.length) {\n    var changeType = order.shift();\n\n    switch (changeType) {\n      case ENTER:\n        {\n          added.forEach(function (key, index) {\n            // In unique mode, remove fading out transitions if their key comes in again\n            if (unique && deleted.find(function (d) {\n              return d.originalKey === key;\n            })) deleted = deleted.filter(function (t) {\n              return t.originalKey !== key;\n            });\n            var keyIndex = keys.indexOf(key);\n            var item = items[keyIndex];\n            var slot = first && initial !== void 0 ? 'initial' : ENTER;\n            current[key] = {\n              slot: slot,\n              originalKey: key,\n              key: unique ? String(key) : guid++,\n              item: item,\n              trail: delay = delay + trail,\n              config: callProp(config, item, slot),\n              from: callProp(first ? initial !== void 0 ? initial || {} : from : from, item),\n              to: callProp(enter, item)\n            };\n          });\n          break;\n        }\n\n      case LEAVE:\n        {\n          removed.forEach(function (key) {\n            var keyIndex = _keys.indexOf(key);\n\n            var item = _items[keyIndex];\n            var slot = LEAVE;\n            deleted.unshift(_extends({}, current[key], {\n              slot: slot,\n              destroyed: true,\n              left: _keys[Math.max(0, keyIndex - 1)],\n              right: _keys[Math.min(_keys.length, keyIndex + 1)],\n              trail: delay = delay + trail,\n              config: callProp(config, item, slot),\n              to: callProp(leave, item)\n            }));\n            delete current[key];\n          });\n          break;\n        }\n\n      case UPDATE:\n        {\n          updated.forEach(function (key) {\n            var keyIndex = keys.indexOf(key);\n            var item = items[keyIndex];\n            var slot = UPDATE;\n            current[key] = _extends({}, current[key], {\n              item: item,\n              slot: slot,\n              trail: delay = delay + trail,\n              config: callProp(config, item, slot),\n              to: callProp(update, item)\n            });\n          });\n          break;\n        }\n    }\n  }\n\n  var out = keys.map(function (key) {\n    return current[key];\n  }); // This tries to restore order for deleted items by finding their last known siblings\n  // only using the left sibling to keep order placement consistent for all deleted items\n\n  deleted.forEach(function (_ref10) {\n    var left = _ref10.left,\n        right = _ref10.right,\n        item = _objectWithoutPropertiesLoose(_ref10, [\"left\", \"right\"]);\n\n    var pos; // Was it the element on the left, if yes, move there ...\n\n    if ((pos = out.findIndex(function (t) {\n      return t.originalKey === left;\n    })) !== -1) pos += 1; // And if nothing else helps, move it to the start ¯\\_(ツ)_/¯\n\n    pos = Math.max(0, pos);\n    out = [].concat(out.slice(0, pos), [item], out.slice(pos));\n  });\n  return _extends({}, state, {\n    changed: added.length || removed.length || updated.length,\n    first: first && added.length === 0,\n    transitions: out,\n    current: current,\n    deleted: deleted,\n    prevProps: props\n  });\n}\n\nvar AnimatedStyle =\n/*#__PURE__*/\nfunction (_AnimatedObject) {\n  _inheritsLoose(AnimatedStyle, _AnimatedObject);\n\n  function AnimatedStyle(style) {\n    var _this;\n\n    if (style === void 0) {\n      style = {};\n    }\n\n    _this = _AnimatedObject.call(this) || this;\n\n    if (style.transform && !(style.transform instanceof Animated)) {\n      style = applyAnimatedValues.transform(style);\n    }\n\n    _this.payload = style;\n    return _this;\n  }\n\n  return AnimatedStyle;\n}(AnimatedObject);\n\n// http://www.w3.org/TR/css3-color/#svg-color\nvar colors = {\n  transparent: 0x00000000,\n  aliceblue: 0xf0f8ffff,\n  antiquewhite: 0xfaebd7ff,\n  aqua: 0x00ffffff,\n  aquamarine: 0x7fffd4ff,\n  azure: 0xf0ffffff,\n  beige: 0xf5f5dcff,\n  bisque: 0xffe4c4ff,\n  black: 0x000000ff,\n  blanchedalmond: 0xffebcdff,\n  blue: 0x0000ffff,\n  blueviolet: 0x8a2be2ff,\n  brown: 0xa52a2aff,\n  burlywood: 0xdeb887ff,\n  burntsienna: 0xea7e5dff,\n  cadetblue: 0x5f9ea0ff,\n  chartreuse: 0x7fff00ff,\n  chocolate: 0xd2691eff,\n  coral: 0xff7f50ff,\n  cornflowerblue: 0x6495edff,\n  cornsilk: 0xfff8dcff,\n  crimson: 0xdc143cff,\n  cyan: 0x00ffffff,\n  darkblue: 0x00008bff,\n  darkcyan: 0x008b8bff,\n  darkgoldenrod: 0xb8860bff,\n  darkgray: 0xa9a9a9ff,\n  darkgreen: 0x006400ff,\n  darkgrey: 0xa9a9a9ff,\n  darkkhaki: 0xbdb76bff,\n  darkmagenta: 0x8b008bff,\n  darkolivegreen: 0x556b2fff,\n  darkorange: 0xff8c00ff,\n  darkorchid: 0x9932ccff,\n  darkred: 0x8b0000ff,\n  darksalmon: 0xe9967aff,\n  darkseagreen: 0x8fbc8fff,\n  darkslateblue: 0x483d8bff,\n  darkslategray: 0x2f4f4fff,\n  darkslategrey: 0x2f4f4fff,\n  darkturquoise: 0x00ced1ff,\n  darkviolet: 0x9400d3ff,\n  deeppink: 0xff1493ff,\n  deepskyblue: 0x00bfffff,\n  dimgray: 0x696969ff,\n  dimgrey: 0x696969ff,\n  dodgerblue: 0x1e90ffff,\n  firebrick: 0xb22222ff,\n  floralwhite: 0xfffaf0ff,\n  forestgreen: 0x228b22ff,\n  fuchsia: 0xff00ffff,\n  gainsboro: 0xdcdcdcff,\n  ghostwhite: 0xf8f8ffff,\n  gold: 0xffd700ff,\n  goldenrod: 0xdaa520ff,\n  gray: 0x808080ff,\n  green: 0x008000ff,\n  greenyellow: 0xadff2fff,\n  grey: 0x808080ff,\n  honeydew: 0xf0fff0ff,\n  hotpink: 0xff69b4ff,\n  indianred: 0xcd5c5cff,\n  indigo: 0x4b0082ff,\n  ivory: 0xfffff0ff,\n  khaki: 0xf0e68cff,\n  lavender: 0xe6e6faff,\n  lavenderblush: 0xfff0f5ff,\n  lawngreen: 0x7cfc00ff,\n  lemonchiffon: 0xfffacdff,\n  lightblue: 0xadd8e6ff,\n  lightcoral: 0xf08080ff,\n  lightcyan: 0xe0ffffff,\n  lightgoldenrodyellow: 0xfafad2ff,\n  lightgray: 0xd3d3d3ff,\n  lightgreen: 0x90ee90ff,\n  lightgrey: 0xd3d3d3ff,\n  lightpink: 0xffb6c1ff,\n  lightsalmon: 0xffa07aff,\n  lightseagreen: 0x20b2aaff,\n  lightskyblue: 0x87cefaff,\n  lightslategray: 0x778899ff,\n  lightslategrey: 0x778899ff,\n  lightsteelblue: 0xb0c4deff,\n  lightyellow: 0xffffe0ff,\n  lime: 0x00ff00ff,\n  limegreen: 0x32cd32ff,\n  linen: 0xfaf0e6ff,\n  magenta: 0xff00ffff,\n  maroon: 0x800000ff,\n  mediumaquamarine: 0x66cdaaff,\n  mediumblue: 0x0000cdff,\n  mediumorchid: 0xba55d3ff,\n  mediumpurple: 0x9370dbff,\n  mediumseagreen: 0x3cb371ff,\n  mediumslateblue: 0x7b68eeff,\n  mediumspringgreen: 0x00fa9aff,\n  mediumturquoise: 0x48d1ccff,\n  mediumvioletred: 0xc71585ff,\n  midnightblue: 0x191970ff,\n  mintcream: 0xf5fffaff,\n  mistyrose: 0xffe4e1ff,\n  moccasin: 0xffe4b5ff,\n  navajowhite: 0xffdeadff,\n  navy: 0x000080ff,\n  oldlace: 0xfdf5e6ff,\n  olive: 0x808000ff,\n  olivedrab: 0x6b8e23ff,\n  orange: 0xffa500ff,\n  orangered: 0xff4500ff,\n  orchid: 0xda70d6ff,\n  palegoldenrod: 0xeee8aaff,\n  palegreen: 0x98fb98ff,\n  paleturquoise: 0xafeeeeff,\n  palevioletred: 0xdb7093ff,\n  papayawhip: 0xffefd5ff,\n  peachpuff: 0xffdab9ff,\n  peru: 0xcd853fff,\n  pink: 0xffc0cbff,\n  plum: 0xdda0ddff,\n  powderblue: 0xb0e0e6ff,\n  purple: 0x800080ff,\n  rebeccapurple: 0x663399ff,\n  red: 0xff0000ff,\n  rosybrown: 0xbc8f8fff,\n  royalblue: 0x4169e1ff,\n  saddlebrown: 0x8b4513ff,\n  salmon: 0xfa8072ff,\n  sandybrown: 0xf4a460ff,\n  seagreen: 0x2e8b57ff,\n  seashell: 0xfff5eeff,\n  sienna: 0xa0522dff,\n  silver: 0xc0c0c0ff,\n  skyblue: 0x87ceebff,\n  slateblue: 0x6a5acdff,\n  slategray: 0x708090ff,\n  slategrey: 0x708090ff,\n  snow: 0xfffafaff,\n  springgreen: 0x00ff7fff,\n  steelblue: 0x4682b4ff,\n  tan: 0xd2b48cff,\n  teal: 0x008080ff,\n  thistle: 0xd8bfd8ff,\n  tomato: 0xff6347ff,\n  turquoise: 0x40e0d0ff,\n  violet: 0xee82eeff,\n  wheat: 0xf5deb3ff,\n  white: 0xffffffff,\n  whitesmoke: 0xf5f5f5ff,\n  yellow: 0xffff00ff,\n  yellowgreen: 0x9acd32ff\n};\n\n// const INTEGER = '[-+]?\\\\d+';\nvar NUMBER = '[-+]?\\\\d*\\\\.?\\\\d+';\nvar PERCENTAGE = NUMBER + '%';\n\nfunction call() {\n  for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) {\n    parts[_key] = arguments[_key];\n  }\n\n  return '\\\\(\\\\s*(' + parts.join(')\\\\s*,\\\\s*(') + ')\\\\s*\\\\)';\n}\n\nvar rgb = new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER));\nvar rgba = new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER));\nvar hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE));\nvar hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));\nvar hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;\nvar hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;\nvar hex6 = /^#([0-9a-fA-F]{6})$/;\nvar hex8 = /^#([0-9a-fA-F]{8})$/;\n\n/*\nhttps://github.com/react-community/normalize-css-color\n\nBSD 3-Clause License\n\nCopyright (c) 2016, React Community\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n  list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n  this list of conditions and the following disclaimer in the documentation\n  and/or other materials provided with the distribution.\n\n* Neither the name of the copyright holder nor the names of its\n  contributors may be used to endorse or promote products derived from\n  this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\nfunction normalizeColor(color) {\n  var match;\n\n  if (typeof color === 'number') {\n    return color >>> 0 === color && color >= 0 && color <= 0xffffffff ? color : null;\n  } // Ordered based on occurrences on Facebook codebase\n\n\n  if (match = hex6.exec(color)) return parseInt(match[1] + 'ff', 16) >>> 0;\n  if (colors.hasOwnProperty(color)) return colors[color];\n\n  if (match = rgb.exec(color)) {\n    return (parse255(match[1]) << 24 | // r\n    parse255(match[2]) << 16 | // g\n    parse255(match[3]) << 8 | // b\n    0x000000ff) >>> // a\n    0;\n  }\n\n  if (match = rgba.exec(color)) {\n    return (parse255(match[1]) << 24 | // r\n    parse255(match[2]) << 16 | // g\n    parse255(match[3]) << 8 | // b\n    parse1(match[4])) >>> // a\n    0;\n  }\n\n  if (match = hex3.exec(color)) {\n    return parseInt(match[1] + match[1] + // r\n    match[2] + match[2] + // g\n    match[3] + match[3] + // b\n    'ff', // a\n    16) >>> 0;\n  } // https://drafts.csswg.org/css-color-4/#hex-notation\n\n\n  if (match = hex8.exec(color)) return parseInt(match[1], 16) >>> 0;\n\n  if (match = hex4.exec(color)) {\n    return parseInt(match[1] + match[1] + // r\n    match[2] + match[2] + // g\n    match[3] + match[3] + // b\n    match[4] + match[4], // a\n    16) >>> 0;\n  }\n\n  if (match = hsl.exec(color)) {\n    return (hslToRgb(parse360(match[1]), // h\n    parsePercentage(match[2]), // s\n    parsePercentage(match[3]) // l\n    ) | 0x000000ff) >>> // a\n    0;\n  }\n\n  if (match = hsla.exec(color)) {\n    return (hslToRgb(parse360(match[1]), // h\n    parsePercentage(match[2]), // s\n    parsePercentage(match[3]) // l\n    ) | parse1(match[4])) >>> // a\n    0;\n  }\n\n  return null;\n}\n\nfunction hue2rgb(p, q, t) {\n  if (t < 0) t += 1;\n  if (t > 1) t -= 1;\n  if (t < 1 / 6) return p + (q - p) * 6 * t;\n  if (t < 1 / 2) return q;\n  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;\n  return p;\n}\n\nfunction hslToRgb(h, s, l) {\n  var q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n  var p = 2 * l - q;\n  var r = hue2rgb(p, q, h + 1 / 3);\n  var g = hue2rgb(p, q, h);\n  var b = hue2rgb(p, q, h - 1 / 3);\n  return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;\n}\n\nfunction parse255(str) {\n  var int = parseInt(str, 10);\n  if (int < 0) return 0;\n  if (int > 255) return 255;\n  return int;\n}\n\nfunction parse360(str) {\n  var int = parseFloat(str);\n  return (int % 360 + 360) % 360 / 360;\n}\n\nfunction parse1(str) {\n  var num = parseFloat(str);\n  if (num < 0) return 0;\n  if (num > 1) return 255;\n  return Math.round(num * 255);\n}\n\nfunction parsePercentage(str) {\n  // parseFloat conveniently ignores the final %\n  var int = parseFloat(str);\n  if (int < 0) return 0;\n  if (int > 100) return 1;\n  return int / 100;\n}\n\nfunction colorToRgba(input) {\n  var int32Color = normalizeColor(input);\n  if (int32Color === null) return input;\n  int32Color = int32Color || 0;\n  var r = (int32Color & 0xff000000) >>> 24;\n  var g = (int32Color & 0x00ff0000) >>> 16;\n  var b = (int32Color & 0x0000ff00) >>> 8;\n  var a = (int32Color & 0x000000ff) / 255;\n  return \"rgba(\" + r + \", \" + g + \", \" + b + \", \" + a + \")\";\n} // Problem: https://github.com/animatedjs/animated/pull/102\n// Solution: https://stackoverflow.com/questions/638565/parsing-scientific-notation-sensibly/658662\n\n\nvar stringShapeRegex = /[+\\-]?(?:0|[1-9]\\d*)(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?/g; // Covers rgb, rgba, hsl, hsla\n// Taken from https://gist.github.com/olmokramer/82ccce673f86db7cda5e\n\nvar colorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\\((-?\\d+%?[,\\s]+){2,3}\\s*[\\d\\.]+%?\\))/gi; // Covers color names (transparent, blue, etc.)\n\nvar colorNamesRegex = new RegExp(\"(\" + Object.keys(colors).join('|') + \")\", 'g');\n/**\n * Supports string shapes by extracting numbers so new values can be computed,\n * and recombines those values into new strings of the same shape.  Supports\n * things like:\n *\n *   rgba(123, 42, 99, 0.36)           // colors\n *   -45deg                            // values with units\n *   0 2px 2px 0px rgba(0, 0, 0, 0.12) // box shadows\n */\n\nvar createStringInterpolator = function createStringInterpolator(config) {\n  // Replace colors with rgba\n  var outputRange = config.output.map(function (rangeValue) {\n    return rangeValue.replace(colorRegex, colorToRgba);\n  }).map(function (rangeValue) {\n    return rangeValue.replace(colorNamesRegex, colorToRgba);\n  });\n  var outputRanges = outputRange[0].match(stringShapeRegex).map(function () {\n    return [];\n  });\n  outputRange.forEach(function (value) {\n    value.match(stringShapeRegex).forEach(function (number, i) {\n      return outputRanges[i].push(+number);\n    });\n  });\n  var interpolations = outputRange[0].match(stringShapeRegex).map(function (_value, i) {\n    return createInterpolator(_extends({}, config, {\n      output: outputRanges[i]\n    }));\n  });\n  return function (input) {\n    var i = 0;\n    return outputRange[0] // 'rgba(0, 100, 200, 0)'\n    // ->\n    // 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...'\n    .replace(stringShapeRegex, function () {\n      return interpolations[i++](input);\n    }) // rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to\n    // round the opacity (4th column).\n    .replace(/rgba\\(([0-9\\.-]+), ([0-9\\.-]+), ([0-9\\.-]+), ([0-9\\.-]+)\\)/gi, function (_, p1, p2, p3, p4) {\n      return \"rgba(\" + Math.round(p1) + \", \" + Math.round(p2) + \", \" + Math.round(p3) + \", \" + p4 + \")\";\n    });\n  };\n};\n\nvar isUnitlessNumber = {\n  animationIterationCount: true,\n  borderImageOutset: true,\n  borderImageSlice: true,\n  borderImageWidth: true,\n  boxFlex: true,\n  boxFlexGroup: true,\n  boxOrdinalGroup: true,\n  columnCount: true,\n  columns: true,\n  flex: true,\n  flexGrow: true,\n  flexPositive: true,\n  flexShrink: true,\n  flexNegative: true,\n  flexOrder: true,\n  gridRow: true,\n  gridRowEnd: true,\n  gridRowSpan: true,\n  gridRowStart: true,\n  gridColumn: true,\n  gridColumnEnd: true,\n  gridColumnSpan: true,\n  gridColumnStart: true,\n  fontWeight: true,\n  lineClamp: true,\n  lineHeight: true,\n  opacity: true,\n  order: true,\n  orphans: true,\n  tabSize: true,\n  widows: true,\n  zIndex: true,\n  zoom: true,\n  // SVG-related properties\n  fillOpacity: true,\n  floodOpacity: true,\n  stopOpacity: true,\n  strokeDasharray: true,\n  strokeDashoffset: true,\n  strokeMiterlimit: true,\n  strokeOpacity: true,\n  strokeWidth: true\n};\n\nvar prefixKey = function prefixKey(prefix, key) {\n  return prefix + key.charAt(0).toUpperCase() + key.substring(1);\n};\n\nvar prefixes = ['Webkit', 'Ms', 'Moz', 'O'];\nisUnitlessNumber = Object.keys(isUnitlessNumber).reduce(function (acc, prop) {\n  prefixes.forEach(function (prefix) {\n    return acc[prefixKey(prefix, prop)] = acc[prop];\n  });\n  return acc;\n}, isUnitlessNumber);\n\nfunction dangerousStyleValue(name, value, isCustomProperty) {\n  if (value == null || typeof value === 'boolean' || value === '') return '';\n  if (!isCustomProperty && typeof value === 'number' && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers\n\n  return ('' + value).trim();\n}\n\nvar attributeCache = {};\ninjectCreateAnimatedStyle(function (style) {\n  return new AnimatedStyle(style);\n});\ninjectDefaultElement('div');\ninjectStringInterpolator(createStringInterpolator);\ninjectColorNames(colors);\ninjectApplyAnimatedValues(function (instance, props) {\n  if (instance.nodeType && instance.setAttribute !== undefined) {\n    var style = props.style,\n        children = props.children,\n        scrollTop = props.scrollTop,\n        scrollLeft = props.scrollLeft,\n        attributes = _objectWithoutPropertiesLoose(props, [\"style\", \"children\", \"scrollTop\", \"scrollLeft\"]);\n\n    var filter = instance.nodeName === 'filter' || instance.parentNode && instance.parentNode.nodeName === 'filter';\n    if (scrollTop !== void 0) instance.scrollTop = scrollTop;\n    if (scrollLeft !== void 0) instance.scrollLeft = scrollLeft; // Set textContent, if children is an animatable value\n\n    if (children !== void 0) instance.textContent = children; // Set styles ...\n\n    for (var styleName in style) {\n      if (!style.hasOwnProperty(styleName)) continue;\n      var isCustomProperty = styleName.indexOf('--') === 0;\n      var styleValue = dangerousStyleValue(styleName, style[styleName], isCustomProperty);\n      if (styleName === 'float') styleName = 'cssFloat';\n      if (isCustomProperty) instance.style.setProperty(styleName, styleValue);else instance.style[styleName] = styleValue;\n    } // Set attributes ...\n\n\n    for (var name in attributes) {\n      // Attributes are written in dash case\n      var dashCase = filter ? name : attributeCache[name] || (attributeCache[name] = name.replace(/([A-Z])/g, function (n) {\n        return '-' + n.toLowerCase();\n      }));\n      if (typeof instance.getAttribute(dashCase) !== 'undefined') instance.setAttribute(dashCase, attributes[name]);\n    }\n\n    return;\n  } else return false;\n}, function (style) {\n  return style;\n});\n\nvar domElements = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG\n'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];\n// Extend animated with all the available THREE elements\nvar apply = merge(createAnimatedComponent, false);\nvar extendedAnimated = apply(domElements);\n\nexports.apply = apply;\nexports.config = config;\nexports.update = update;\nexports.animated = extendedAnimated;\nexports.a = extendedAnimated;\nexports.interpolate = interpolate$1;\nexports.Globals = Globals;\nexports.useSpring = useSpring;\nexports.useTrail = useTrail;\nexports.useTransition = useTransition;\nexports.useChain = useChain;\nexports.useSprings = useSprings;\n","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"react\"), require(\"prop-types\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"react\", \"prop-types\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Dropzone\"] = factory(require(\"react\"), require(\"prop-types\"));\n\telse\n\t\troot[\"Dropzone\"] = factory(root[\"react\"], root[\"prop-types\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_2__, __WEBPACK_EXTERNAL_MODULE_3__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(process) {'use strict';\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\t\n\tvar _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; };\n\t\n\tvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\t\n\tvar _react = __webpack_require__(2);\n\t\n\tvar _react2 = _interopRequireDefault(_react);\n\t\n\tvar _propTypes = __webpack_require__(3);\n\t\n\tvar _propTypes2 = _interopRequireDefault(_propTypes);\n\t\n\tvar _attrAccept = __webpack_require__(4);\n\t\n\tvar _attrAccept2 = _interopRequireDefault(_attrAccept);\n\t\n\tvar _getDataTransferItems = __webpack_require__(5);\n\t\n\tvar _getDataTransferItems2 = _interopRequireDefault(_getDataTransferItems);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\t\n\tfunction _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint prefer-template: 0 */\n\t\n\tvar supportMultiple = typeof document !== 'undefined' && document && document.createElement ? 'multiple' in document.createElement('input') : true;\n\t\n\tfunction fileAccepted(file, accept) {\n\t  // Firefox versions prior to 53 return a bogus MIME type for every file drag, so dragovers with\n\t  // that MIME type will always be accepted\n\t  return file.type === 'application/x-moz-file' || (0, _attrAccept2.default)(file, accept);\n\t}\n\t\n\tvar Dropzone = function (_React$Component) {\n\t  _inherits(Dropzone, _React$Component);\n\t\n\t  _createClass(Dropzone, null, [{\n\t    key: 'onDocumentDragOver',\n\t    value: function onDocumentDragOver(evt) {\n\t      // allow the entire document to be a drag target\n\t      evt.preventDefault();\n\t    }\n\t  }]);\n\t\n\t  function Dropzone(props, context) {\n\t    _classCallCheck(this, Dropzone);\n\t\n\t    var _this = _possibleConstructorReturn(this, (Dropzone.__proto__ || Object.getPrototypeOf(Dropzone)).call(this, props, context));\n\t\n\t    _this.renderChildren = function (children, isDragActive, isDragAccept, isDragReject) {\n\t      if (typeof children === 'function') {\n\t        return children(_extends({}, _this.state, { isDragActive: isDragActive, isDragAccept: isDragAccept, isDragReject: isDragReject }));\n\t      }\n\t      return children;\n\t    };\n\t\n\t    _this.composeHandlers = _this.composeHandlers.bind(_this);\n\t    _this.onClick = _this.onClick.bind(_this);\n\t    _this.onDocumentDrop = _this.onDocumentDrop.bind(_this);\n\t    _this.onDragEnter = _this.onDragEnter.bind(_this);\n\t    _this.onDragLeave = _this.onDragLeave.bind(_this);\n\t    _this.onDragOver = _this.onDragOver.bind(_this);\n\t    _this.onDragStart = _this.onDragStart.bind(_this);\n\t    _this.onDrop = _this.onDrop.bind(_this);\n\t    _this.onFileDialogCancel = _this.onFileDialogCancel.bind(_this);\n\t    _this.onInputElementClick = _this.onInputElementClick.bind(_this);\n\t\n\t    _this.setRef = _this.setRef.bind(_this);\n\t    _this.setRefs = _this.setRefs.bind(_this);\n\t\n\t    _this.isFileDialogActive = false;\n\t\n\t    _this.state = {\n\t      draggedFiles: [],\n\t      acceptedFiles: [],\n\t      rejectedFiles: []\n\t    };\n\t    return _this;\n\t  }\n\t\n\t  _createClass(Dropzone, [{\n\t    key: 'componentDidMount',\n\t    value: function componentDidMount() {\n\t      var preventDropOnDocument = this.props.preventDropOnDocument;\n\t\n\t      this.dragTargets = [];\n\t\n\t      if (preventDropOnDocument) {\n\t        document.addEventListener('dragover', Dropzone.onDocumentDragOver, false);\n\t        document.addEventListener('drop', this.onDocumentDrop, false);\n\t      }\n\t      this.fileInputEl.addEventListener('click', this.onInputElementClick, false);\n\t      // Tried implementing addEventListener, but didn't work out\n\t      document.body.onfocus = this.onFileDialogCancel;\n\t    }\n\t  }, {\n\t    key: 'componentWillUnmount',\n\t    value: function componentWillUnmount() {\n\t      var preventDropOnDocument = this.props.preventDropOnDocument;\n\t\n\t      if (preventDropOnDocument) {\n\t        document.removeEventListener('dragover', Dropzone.onDocumentDragOver);\n\t        document.removeEventListener('drop', this.onDocumentDrop);\n\t      }\n\t      this.fileInputEl.removeEventListener('click', this.onInputElementClick, false);\n\t      // Can be replaced with removeEventListener, if addEventListener works\n\t      document.body.onfocus = null;\n\t    }\n\t  }, {\n\t    key: 'composeHandlers',\n\t    value: function composeHandlers(handler) {\n\t      if (this.props.disabled) {\n\t        return null;\n\t      }\n\t\n\t      return handler;\n\t    }\n\t  }, {\n\t    key: 'onDocumentDrop',\n\t    value: function onDocumentDrop(evt) {\n\t      if (this.node.contains(evt.target)) {\n\t        // if we intercepted an event for our instance, let it propagate down to the instance's onDrop handler\n\t        return;\n\t      }\n\t      evt.preventDefault();\n\t      this.dragTargets = [];\n\t    }\n\t  }, {\n\t    key: 'onDragStart',\n\t    value: function onDragStart(evt) {\n\t      if (this.props.onDragStart) {\n\t        this.props.onDragStart.call(this, evt);\n\t      }\n\t    }\n\t  }, {\n\t    key: 'onDragEnter',\n\t    value: function onDragEnter(evt) {\n\t      evt.preventDefault();\n\t\n\t      // Count the dropzone and any children that are entered.\n\t      if (this.dragTargets.indexOf(evt.target) === -1) {\n\t        this.dragTargets.push(evt.target);\n\t      }\n\t\n\t      this.setState({\n\t        isDragActive: true, // Do not rely on files for the drag state. It doesn't work in Safari.\n\t        draggedFiles: (0, _getDataTransferItems2.default)(evt)\n\t      });\n\t\n\t      if (this.props.onDragEnter) {\n\t        this.props.onDragEnter.call(this, evt);\n\t      }\n\t    }\n\t  }, {\n\t    key: 'onDragOver',\n\t    value: function onDragOver(evt) {\n\t      // eslint-disable-line class-methods-use-this\n\t      evt.preventDefault();\n\t      evt.stopPropagation();\n\t      try {\n\t        evt.dataTransfer.dropEffect = 'copy'; // eslint-disable-line no-param-reassign\n\t      } catch (err) {\n\t        // continue regardless of error\n\t      }\n\t\n\t      if (this.props.onDragOver) {\n\t        this.props.onDragOver.call(this, evt);\n\t      }\n\t      return false;\n\t    }\n\t  }, {\n\t    key: 'onDragLeave',\n\t    value: function onDragLeave(evt) {\n\t      var _this2 = this;\n\t\n\t      evt.preventDefault();\n\t\n\t      // Only deactivate once the dropzone and all children have been left.\n\t      this.dragTargets = this.dragTargets.filter(function (el) {\n\t        return el !== evt.target && _this2.node.contains(el);\n\t      });\n\t      if (this.dragTargets.length > 0) {\n\t        return;\n\t      }\n\t\n\t      // Clear dragging files state\n\t      this.setState({\n\t        isDragActive: false,\n\t        draggedFiles: []\n\t      });\n\t\n\t      if (this.props.onDragLeave) {\n\t        this.props.onDragLeave.call(this, evt);\n\t      }\n\t    }\n\t  }, {\n\t    key: 'onDrop',\n\t    value: function onDrop(evt) {\n\t      var _this3 = this;\n\t\n\t      var _props = this.props,\n\t          onDrop = _props.onDrop,\n\t          onDropAccepted = _props.onDropAccepted,\n\t          onDropRejected = _props.onDropRejected,\n\t          multiple = _props.multiple,\n\t          disablePreview = _props.disablePreview,\n\t          accept = _props.accept;\n\t\n\t      var fileList = (0, _getDataTransferItems2.default)(evt);\n\t      var acceptedFiles = [];\n\t      var rejectedFiles = [];\n\t\n\t      // Stop default browser behavior\n\t      evt.preventDefault();\n\t\n\t      // Reset the counter along with the drag on a drop.\n\t      this.dragTargets = [];\n\t      this.isFileDialogActive = false;\n\t\n\t      fileList.forEach(function (file) {\n\t        if (!disablePreview) {\n\t          try {\n\t            file.preview = window.URL.createObjectURL(file); // eslint-disable-line no-param-reassign\n\t          } catch (err) {\n\t            if (process.env.NODE_ENV !== 'production') {\n\t              console.error('Failed to generate preview for file', file, err); // eslint-disable-line no-console\n\t            }\n\t          }\n\t        }\n\t\n\t        if (fileAccepted(file, accept) && _this3.fileMatchSize(file)) {\n\t          acceptedFiles.push(file);\n\t        } else {\n\t          rejectedFiles.push(file);\n\t        }\n\t      });\n\t\n\t      if (!multiple) {\n\t        // if not in multi mode add any extra accepted files to rejected.\n\t        // This will allow end users to easily ignore a multi file drop in \"single\" mode.\n\t        rejectedFiles.push.apply(rejectedFiles, _toConsumableArray(acceptedFiles.splice(1)));\n\t      }\n\t\n\t      if (onDrop) {\n\t        onDrop.call(this, acceptedFiles, rejectedFiles, evt);\n\t      }\n\t\n\t      if (rejectedFiles.length > 0 && onDropRejected) {\n\t        onDropRejected.call(this, rejectedFiles, evt);\n\t      }\n\t\n\t      if (acceptedFiles.length > 0 && onDropAccepted) {\n\t        onDropAccepted.call(this, acceptedFiles, evt);\n\t      }\n\t\n\t      // Clear files value\n\t      this.draggedFiles = null;\n\t\n\t      // Reset drag state\n\t      this.setState({\n\t        isDragActive: false,\n\t        draggedFiles: [],\n\t        acceptedFiles: acceptedFiles,\n\t        rejectedFiles: rejectedFiles\n\t      });\n\t    }\n\t  }, {\n\t    key: 'onClick',\n\t    value: function onClick(evt) {\n\t      var _props2 = this.props,\n\t          onClick = _props2.onClick,\n\t          disableClick = _props2.disableClick;\n\t\n\t      if (!disableClick) {\n\t        evt.stopPropagation();\n\t\n\t        if (onClick) {\n\t          onClick.call(this, evt);\n\t        }\n\t\n\t        // in IE11/Edge the file-browser dialog is blocking, ensure this is behind setTimeout\n\t        // this is so react can handle state changes in the onClick prop above above\n\t        // see: https://github.com/okonet/react-dropzone/issues/450\n\t        setTimeout(this.open.bind(this), 0);\n\t      }\n\t    }\n\t  }, {\n\t    key: 'onInputElementClick',\n\t    value: function onInputElementClick(evt) {\n\t      evt.stopPropagation();\n\t      if (this.props.inputProps && this.props.inputProps.onClick) {\n\t        this.props.inputProps.onClick();\n\t      }\n\t    }\n\t  }, {\n\t    key: 'onFileDialogCancel',\n\t    value: function onFileDialogCancel() {\n\t      // timeout will not recognize context of this method\n\t      var onFileDialogCancel = this.props.onFileDialogCancel;\n\t      var fileInputEl = this.fileInputEl;\n\t      var isFileDialogActive = this.isFileDialogActive;\n\t      // execute the timeout only if the onFileDialogCancel is defined and FileDialog\n\t      // is opened in the browser\n\t\n\t      if (onFileDialogCancel && isFileDialogActive) {\n\t        setTimeout(function () {\n\t          // Returns an object as FileList\n\t          var FileList = fileInputEl.files;\n\t          if (!FileList.length) {\n\t            isFileDialogActive = false;\n\t            onFileDialogCancel();\n\t          }\n\t        }, 300);\n\t      }\n\t    }\n\t  }, {\n\t    key: 'setRef',\n\t    value: function setRef(ref) {\n\t      this.node = ref;\n\t    }\n\t  }, {\n\t    key: 'setRefs',\n\t    value: function setRefs(ref) {\n\t      this.fileInputEl = ref;\n\t    }\n\t  }, {\n\t    key: 'fileMatchSize',\n\t    value: function fileMatchSize(file) {\n\t      return file.size <= this.props.maxSize && file.size >= this.props.minSize;\n\t    }\n\t  }, {\n\t    key: 'allFilesAccepted',\n\t    value: function allFilesAccepted(files) {\n\t      var _this4 = this;\n\t\n\t      return files.every(function (file) {\n\t        return fileAccepted(file, _this4.props.accept);\n\t      });\n\t    }\n\t\n\t    /**\n\t     * Open system file upload dialog.\n\t     *\n\t     * @public\n\t     */\n\t\n\t  }, {\n\t    key: 'open',\n\t    value: function open() {\n\t      this.isFileDialogActive = true;\n\t      this.fileInputEl.value = null;\n\t      this.fileInputEl.click();\n\t    }\n\t  }, {\n\t    key: 'render',\n\t    value: function render() {\n\t      var _props3 = this.props,\n\t          accept = _props3.accept,\n\t          acceptClassName = _props3.acceptClassName,\n\t          activeClassName = _props3.activeClassName,\n\t          children = _props3.children,\n\t          disabled = _props3.disabled,\n\t          disabledClassName = _props3.disabledClassName,\n\t          inputProps = _props3.inputProps,\n\t          multiple = _props3.multiple,\n\t          name = _props3.name,\n\t          rejectClassName = _props3.rejectClassName,\n\t          rest = _objectWithoutProperties(_props3, ['accept', 'acceptClassName', 'activeClassName', 'children', 'disabled', 'disabledClassName', 'inputProps', 'multiple', 'name', 'rejectClassName']);\n\t\n\t      var acceptStyle = rest.acceptStyle,\n\t          activeStyle = rest.activeStyle,\n\t          className = rest.className,\n\t          disabledStyle = rest.disabledStyle,\n\t          rejectStyle = rest.rejectStyle,\n\t          style = rest.style,\n\t          props = _objectWithoutProperties(rest, ['acceptStyle', 'activeStyle', 'className', 'disabledStyle', 'rejectStyle', 'style']);\n\t\n\t      var _state = this.state,\n\t          isDragActive = _state.isDragActive,\n\t          draggedFiles = _state.draggedFiles;\n\t\n\t      var filesCount = draggedFiles.length;\n\t      var isMultipleAllowed = multiple || filesCount <= 1;\n\t      var isDragAccept = filesCount > 0 && this.allFilesAccepted(draggedFiles);\n\t      var isDragReject = filesCount > 0 && (!isDragAccept || !isMultipleAllowed);\n\t      className = className || '';\n\t\n\t      if (isDragActive && activeClassName) {\n\t        className += ' ' + activeClassName;\n\t      }\n\t      if (isDragAccept && acceptClassName) {\n\t        className += ' ' + acceptClassName;\n\t      }\n\t      if (isDragReject && rejectClassName) {\n\t        className += ' ' + rejectClassName;\n\t      }\n\t      if (disabled && disabledClassName) {\n\t        className += ' ' + disabledClassName;\n\t      }\n\t\n\t      if (!className && !style && !activeStyle && !acceptStyle && !rejectStyle && !disabledStyle) {\n\t        style = {\n\t          width: 200,\n\t          height: 200,\n\t          borderWidth: 2,\n\t          borderColor: '#666',\n\t          borderStyle: 'dashed',\n\t          borderRadius: 5\n\t        };\n\t        activeStyle = {\n\t          borderStyle: 'solid',\n\t          borderColor: '#6c6',\n\t          backgroundColor: '#eee'\n\t        };\n\t        acceptStyle = activeStyle;\n\t        rejectStyle = {\n\t          borderStyle: 'solid',\n\t          borderColor: '#c66',\n\t          backgroundColor: '#eee'\n\t        };\n\t        disabledStyle = {\n\t          opacity: 0.5\n\t        };\n\t      }\n\t\n\t      var appliedStyle = _extends({}, style);\n\t      if (activeStyle && isDragActive) {\n\t        appliedStyle = _extends({}, style, activeStyle);\n\t      }\n\t      if (acceptStyle && isDragAccept) {\n\t        appliedStyle = _extends({}, appliedStyle, acceptStyle);\n\t      } else if (rejectStyle && isDragReject) {\n\t        appliedStyle = _extends({}, appliedStyle, rejectStyle);\n\t      }\n\t      if (disabledStyle && disabled) {\n\t        appliedStyle = _extends({}, style, disabledStyle);\n\t      }\n\t\n\t      var inputAttributes = {\n\t        accept: accept,\n\t        disabled: disabled,\n\t        type: 'file',\n\t        style: { display: 'none' },\n\t        multiple: supportMultiple && multiple,\n\t        ref: this.setRefs,\n\t        onChange: this.onDrop,\n\t        autoComplete: 'off'\n\t      };\n\t\n\t      if (name && name.length) {\n\t        inputAttributes.name = name;\n\t      }\n\t\n\t      // Remove custom properties before passing them to the wrapper div element\n\t      var customProps = ['acceptedFiles', 'preventDropOnDocument', 'disablePreview', 'disableClick', 'onDropAccepted', 'onDropRejected', 'onFileDialogCancel', 'maxSize', 'minSize'];\n\t      var divProps = _extends({}, props);\n\t      customProps.forEach(function (prop) {\n\t        return delete divProps[prop];\n\t      });\n\t\n\t      return _react2.default.createElement(\n\t        'div',\n\t        _extends({\n\t          className: className,\n\t          style: appliedStyle\n\t        }, divProps /* expand user provided props first so event handlers are never overridden */, {\n\t          onClick: this.composeHandlers(this.onClick),\n\t          onDragStart: this.composeHandlers(this.onDragStart),\n\t          onDragEnter: this.composeHandlers(this.onDragEnter),\n\t          onDragOver: this.composeHandlers(this.onDragOver),\n\t          onDragLeave: this.composeHandlers(this.onDragLeave),\n\t          onDrop: this.composeHandlers(this.onDrop),\n\t          ref: this.setRef,\n\t          'aria-disabled': disabled\n\t        }),\n\t        this.renderChildren(children, isDragActive, isDragAccept, isDragReject),\n\t        _react2.default.createElement('input', _extends({}, inputProps /* expand user provided inputProps first so inputAttributes override them */, inputAttributes))\n\t      );\n\t    }\n\t  }]);\n\t\n\t  return Dropzone;\n\t}(_react2.default.Component);\n\t\n\tDropzone.propTypes = {\n\t  /**\n\t   * Allow specific types of files. See https://github.com/okonet/attr-accept for more information.\n\t   * Keep in mind that mime type determination is not reliable accross platforms. CSV files,\n\t   * for example, are reported as text/plain under macOS but as application/vnd.ms-excel under\n\t   * Windows. In some cases there might not be a mime type set at all.\n\t   * See: https://github.com/okonet/react-dropzone/issues/276\n\t   */\n\t  accept: _propTypes2.default.string,\n\t\n\t  /**\n\t   * Contents of the dropzone\n\t   */\n\t  children: _propTypes2.default.oneOfType([_propTypes2.default.node, _propTypes2.default.func]),\n\t\n\t  /**\n\t   * Disallow clicking on the dropzone container to open file dialog\n\t   */\n\t  disableClick: _propTypes2.default.bool,\n\t\n\t  /**\n\t  * Enable/disable the dropzone entirely\n\t  */\n\t  disabled: _propTypes2.default.bool,\n\t\n\t  /**\n\t   * Enable/disable preview generation\n\t   */\n\t  disablePreview: _propTypes2.default.bool,\n\t\n\t  /**\n\t   * If false, allow dropped items to take over the current browser window\n\t   */\n\t  preventDropOnDocument: _propTypes2.default.bool,\n\t\n\t  /**\n\t   * Pass additional attributes to the `<input type=\"file\"/>` tag\n\t   */\n\t  inputProps: _propTypes2.default.object,\n\t\n\t  /**\n\t   * Allow dropping multiple files\n\t   */\n\t  multiple: _propTypes2.default.bool,\n\t\n\t  /**\n\t   * `name` attribute for the input tag\n\t   */\n\t  name: _propTypes2.default.string,\n\t\n\t  /**\n\t   * Maximum file size\n\t   */\n\t  maxSize: _propTypes2.default.number,\n\t\n\t  /**\n\t   * Minimum file size\n\t   */\n\t  minSize: _propTypes2.default.number,\n\t\n\t  /**\n\t   * className\n\t   */\n\t  className: _propTypes2.default.string,\n\t\n\t  /**\n\t   * className for active state\n\t   */\n\t  activeClassName: _propTypes2.default.string,\n\t\n\t  /**\n\t   * className for accepted state\n\t   */\n\t  acceptClassName: _propTypes2.default.string,\n\t\n\t  /**\n\t   * className for rejected state\n\t   */\n\t  rejectClassName: _propTypes2.default.string,\n\t\n\t  /**\n\t   * className for disabled state\n\t   */\n\t  disabledClassName: _propTypes2.default.string,\n\t\n\t  /**\n\t   * CSS styles to apply\n\t   */\n\t  style: _propTypes2.default.object,\n\t\n\t  /**\n\t   * CSS styles to apply when drag is active\n\t   */\n\t  activeStyle: _propTypes2.default.object,\n\t\n\t  /**\n\t   * CSS styles to apply when drop will be accepted\n\t   */\n\t  acceptStyle: _propTypes2.default.object,\n\t\n\t  /**\n\t   * CSS styles to apply when drop will be rejected\n\t   */\n\t  rejectStyle: _propTypes2.default.object,\n\t\n\t  /**\n\t   * CSS styles to apply when dropzone is disabled\n\t   */\n\t  disabledStyle: _propTypes2.default.object,\n\t\n\t  /**\n\t   * onClick callback\n\t   * @param {Event} event\n\t   */\n\t  onClick: _propTypes2.default.func,\n\t\n\t  /**\n\t   * onDrop callback\n\t   */\n\t  onDrop: _propTypes2.default.func,\n\t\n\t  /**\n\t   * onDropAccepted callback\n\t   */\n\t  onDropAccepted: _propTypes2.default.func,\n\t\n\t  /**\n\t   * onDropRejected callback\n\t   */\n\t  onDropRejected: _propTypes2.default.func,\n\t\n\t  /**\n\t   * onDragStart callback\n\t   */\n\t  onDragStart: _propTypes2.default.func,\n\t\n\t  /**\n\t   * onDragEnter callback\n\t   */\n\t  onDragEnter: _propTypes2.default.func,\n\t\n\t  /**\n\t   * onDragOver callback\n\t   */\n\t  onDragOver: _propTypes2.default.func,\n\t\n\t  /**\n\t   * onDragLeave callback\n\t   */\n\t  onDragLeave: _propTypes2.default.func,\n\t\n\t  /**\n\t   * Provide a callback on clicking the cancel button of the file dialog\n\t   */\n\t  onFileDialogCancel: _propTypes2.default.func\n\t};\n\t\n\tDropzone.defaultProps = {\n\t  preventDropOnDocument: true,\n\t  disabled: false,\n\t  disablePreview: false,\n\t  disableClick: false,\n\t  multiple: true,\n\t  maxSize: Infinity,\n\t  minSize: 0\n\t};\n\t\n\texports.default = Dropzone;\n\tmodule.exports = exports['default'];\n\t/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports) {\n\n\t// shim for using process in browser\n\tvar process = module.exports = {};\n\t\n\t// cached from whatever global is present so that test runners that stub it\n\t// don't break things.  But we need to wrap it in a try catch in case it is\n\t// wrapped in strict mode code which doesn't define any globals.  It's inside a\n\t// function because try/catches deoptimize in certain engines.\n\t\n\tvar cachedSetTimeout;\n\tvar cachedClearTimeout;\n\t\n\tfunction defaultSetTimout() {\n\t    throw new Error('setTimeout has not been defined');\n\t}\n\tfunction defaultClearTimeout () {\n\t    throw new Error('clearTimeout has not been defined');\n\t}\n\t(function () {\n\t    try {\n\t        if (typeof setTimeout === 'function') {\n\t            cachedSetTimeout = setTimeout;\n\t        } else {\n\t            cachedSetTimeout = defaultSetTimout;\n\t        }\n\t    } catch (e) {\n\t        cachedSetTimeout = defaultSetTimout;\n\t    }\n\t    try {\n\t        if (typeof clearTimeout === 'function') {\n\t            cachedClearTimeout = clearTimeout;\n\t        } else {\n\t            cachedClearTimeout = defaultClearTimeout;\n\t        }\n\t    } catch (e) {\n\t        cachedClearTimeout = defaultClearTimeout;\n\t    }\n\t} ())\n\tfunction runTimeout(fun) {\n\t    if (cachedSetTimeout === setTimeout) {\n\t        //normal enviroments in sane situations\n\t        return setTimeout(fun, 0);\n\t    }\n\t    // if setTimeout wasn't available but was latter defined\n\t    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n\t        cachedSetTimeout = setTimeout;\n\t        return setTimeout(fun, 0);\n\t    }\n\t    try {\n\t        // when when somebody has screwed with setTimeout but no I.E. maddness\n\t        return cachedSetTimeout(fun, 0);\n\t    } catch(e){\n\t        try {\n\t            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n\t            return cachedSetTimeout.call(null, fun, 0);\n\t        } catch(e){\n\t            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n\t            return cachedSetTimeout.call(this, fun, 0);\n\t        }\n\t    }\n\t\n\t\n\t}\n\tfunction runClearTimeout(marker) {\n\t    if (cachedClearTimeout === clearTimeout) {\n\t        //normal enviroments in sane situations\n\t        return clearTimeout(marker);\n\t    }\n\t    // if clearTimeout wasn't available but was latter defined\n\t    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n\t        cachedClearTimeout = clearTimeout;\n\t        return clearTimeout(marker);\n\t    }\n\t    try {\n\t        // when when somebody has screwed with setTimeout but no I.E. maddness\n\t        return cachedClearTimeout(marker);\n\t    } catch (e){\n\t        try {\n\t            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n\t            return cachedClearTimeout.call(null, marker);\n\t        } catch (e){\n\t            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n\t            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n\t            return cachedClearTimeout.call(this, marker);\n\t        }\n\t    }\n\t\n\t\n\t\n\t}\n\tvar queue = [];\n\tvar draining = false;\n\tvar currentQueue;\n\tvar queueIndex = -1;\n\t\n\tfunction cleanUpNextTick() {\n\t    if (!draining || !currentQueue) {\n\t        return;\n\t    }\n\t    draining = false;\n\t    if (currentQueue.length) {\n\t        queue = currentQueue.concat(queue);\n\t    } else {\n\t        queueIndex = -1;\n\t    }\n\t    if (queue.length) {\n\t        drainQueue();\n\t    }\n\t}\n\t\n\tfunction drainQueue() {\n\t    if (draining) {\n\t        return;\n\t    }\n\t    var timeout = runTimeout(cleanUpNextTick);\n\t    draining = true;\n\t\n\t    var len = queue.length;\n\t    while(len) {\n\t        currentQueue = queue;\n\t        queue = [];\n\t        while (++queueIndex < len) {\n\t            if (currentQueue) {\n\t                currentQueue[queueIndex].run();\n\t            }\n\t        }\n\t        queueIndex = -1;\n\t        len = queue.length;\n\t    }\n\t    currentQueue = null;\n\t    draining = false;\n\t    runClearTimeout(timeout);\n\t}\n\t\n\tprocess.nextTick = function (fun) {\n\t    var args = new Array(arguments.length - 1);\n\t    if (arguments.length > 1) {\n\t        for (var i = 1; i < arguments.length; i++) {\n\t            args[i - 1] = arguments[i];\n\t        }\n\t    }\n\t    queue.push(new Item(fun, args));\n\t    if (queue.length === 1 && !draining) {\n\t        runTimeout(drainQueue);\n\t    }\n\t};\n\t\n\t// v8 likes predictible objects\n\tfunction Item(fun, array) {\n\t    this.fun = fun;\n\t    this.array = array;\n\t}\n\tItem.prototype.run = function () {\n\t    this.fun.apply(null, this.array);\n\t};\n\tprocess.title = 'browser';\n\tprocess.browser = true;\n\tprocess.env = {};\n\tprocess.argv = [];\n\tprocess.version = ''; // empty string to avoid regexp issues\n\tprocess.versions = {};\n\t\n\tfunction noop() {}\n\t\n\tprocess.on = noop;\n\tprocess.addListener = noop;\n\tprocess.once = noop;\n\tprocess.off = noop;\n\tprocess.removeListener = noop;\n\tprocess.removeAllListeners = noop;\n\tprocess.emit = noop;\n\tprocess.prependListener = noop;\n\tprocess.prependOnceListener = noop;\n\t\n\tprocess.listeners = function (name) { return [] }\n\t\n\tprocess.binding = function (name) {\n\t    throw new Error('process.binding is not supported');\n\t};\n\t\n\tprocess.cwd = function () { return '/' };\n\tprocess.chdir = function (dir) {\n\t    throw new Error('process.chdir is not supported');\n\t};\n\tprocess.umask = function() { return 0; };\n\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_2__;\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports) {\n\n\tmodule.exports = __WEBPACK_EXTERNAL_MODULE_3__;\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\n\tmodule.exports=function(t){function n(e){if(r[e])return r[e].exports;var o=r[e]={exports:{},id:e,loaded:!1};return t[e].call(o.exports,o,o.exports,n),o.loaded=!0,o.exports}var r={};return n.m=t,n.c=r,n.p=\"\",n(0)}([function(t,n,r){\"use strict\";n.__esModule=!0,r(8),r(9),n[\"default\"]=function(t,n){if(t&&n){var r=function(){var r=Array.isArray(n)?n:n.split(\",\"),e=t.name||\"\",o=t.type||\"\",i=o.replace(/\\/.*$/,\"\");return{v:r.some(function(t){var n=t.trim();return\".\"===n.charAt(0)?e.toLowerCase().endsWith(n.toLowerCase()):/\\/\\*$/.test(n)?i===n.replace(/\\/.*$/,\"\"):o===n})}}();if(\"object\"==typeof r)return r.v}return!0},t.exports=n[\"default\"]},function(t,n){var r=t.exports={version:\"1.2.2\"};\"number\"==typeof __e&&(__e=r)},function(t,n){var r=t.exports=\"undefined\"!=typeof window&&window.Math==Math?window:\"undefined\"!=typeof self&&self.Math==Math?self:Function(\"return this\")();\"number\"==typeof __g&&(__g=r)},function(t,n,r){var e=r(2),o=r(1),i=r(4),u=r(19),c=\"prototype\",f=function(t,n){return function(){return t.apply(n,arguments)}},s=function(t,n,r){var a,p,l,y,d=t&s.G,h=t&s.P,v=d?e:t&s.S?e[n]||(e[n]={}):(e[n]||{})[c],x=d?o:o[n]||(o[n]={});d&&(r=n);for(a in r)p=!(t&s.F)&&v&&a in v,l=(p?v:r)[a],y=t&s.B&&p?f(l,e):h&&\"function\"==typeof l?f(Function.call,l):l,v&&!p&&u(v,a,l),x[a]!=l&&i(x,a,y),h&&((x[c]||(x[c]={}))[a]=l)};e.core=o,s.F=1,s.G=2,s.S=4,s.P=8,s.B=16,s.W=32,t.exports=s},function(t,n,r){var e=r(5),o=r(18);t.exports=r(22)?function(t,n,r){return e.setDesc(t,n,o(1,r))}:function(t,n,r){return t[n]=r,t}},function(t,n){var r=Object;t.exports={create:r.create,getProto:r.getPrototypeOf,isEnum:{}.propertyIsEnumerable,getDesc:r.getOwnPropertyDescriptor,setDesc:r.defineProperty,setDescs:r.defineProperties,getKeys:r.keys,getNames:r.getOwnPropertyNames,getSymbols:r.getOwnPropertySymbols,each:[].forEach}},function(t,n){var r=0,e=Math.random();t.exports=function(t){return\"Symbol(\".concat(void 0===t?\"\":t,\")_\",(++r+e).toString(36))}},function(t,n,r){var e=r(20)(\"wks\"),o=r(2).Symbol;t.exports=function(t){return e[t]||(e[t]=o&&o[t]||(o||r(6))(\"Symbol.\"+t))}},function(t,n,r){r(26),t.exports=r(1).Array.some},function(t,n,r){r(25),t.exports=r(1).String.endsWith},function(t,n){t.exports=function(t){if(\"function\"!=typeof t)throw TypeError(t+\" is not a function!\");return t}},function(t,n){var r={}.toString;t.exports=function(t){return r.call(t).slice(8,-1)}},function(t,n,r){var e=r(10);t.exports=function(t,n,r){if(e(t),void 0===n)return t;switch(r){case 1:return function(r){return t.call(n,r)};case 2:return function(r,e){return t.call(n,r,e)};case 3:return function(r,e,o){return t.call(n,r,e,o)}}return function(){return t.apply(n,arguments)}}},function(t,n){t.exports=function(t){if(void 0==t)throw TypeError(\"Can't call method on  \"+t);return t}},function(t,n,r){t.exports=function(t){var n=/./;try{\"/./\"[t](n)}catch(e){try{return n[r(7)(\"match\")]=!1,!\"/./\"[t](n)}catch(o){}}return!0}},function(t,n){t.exports=function(t){try{return!!t()}catch(n){return!0}}},function(t,n){t.exports=function(t){return\"object\"==typeof t?null!==t:\"function\"==typeof t}},function(t,n,r){var e=r(16),o=r(11),i=r(7)(\"match\");t.exports=function(t){var n;return e(t)&&(void 0!==(n=t[i])?!!n:\"RegExp\"==o(t))}},function(t,n){t.exports=function(t,n){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:n}}},function(t,n,r){var e=r(2),o=r(4),i=r(6)(\"src\"),u=\"toString\",c=Function[u],f=(\"\"+c).split(u);r(1).inspectSource=function(t){return c.call(t)},(t.exports=function(t,n,r,u){\"function\"==typeof r&&(o(r,i,t[n]?\"\"+t[n]:f.join(String(n))),\"name\"in r||(r.name=n)),t===e?t[n]=r:(u||delete t[n],o(t,n,r))})(Function.prototype,u,function(){return\"function\"==typeof this&&this[i]||c.call(this)})},function(t,n,r){var e=r(2),o=\"__core-js_shared__\",i=e[o]||(e[o]={});t.exports=function(t){return i[t]||(i[t]={})}},function(t,n,r){var e=r(17),o=r(13);t.exports=function(t,n,r){if(e(n))throw TypeError(\"String#\"+r+\" doesn't accept regex!\");return String(o(t))}},function(t,n,r){t.exports=!r(15)(function(){return 7!=Object.defineProperty({},\"a\",{get:function(){return 7}}).a})},function(t,n){var r=Math.ceil,e=Math.floor;t.exports=function(t){return isNaN(t=+t)?0:(t>0?e:r)(t)}},function(t,n,r){var e=r(23),o=Math.min;t.exports=function(t){return t>0?o(e(t),9007199254740991):0}},function(t,n,r){\"use strict\";var e=r(3),o=r(24),i=r(21),u=\"endsWith\",c=\"\"[u];e(e.P+e.F*r(14)(u),\"String\",{endsWith:function(t){var n=i(this,t,u),r=arguments,e=r.length>1?r[1]:void 0,f=o(n.length),s=void 0===e?f:Math.min(o(e),f),a=String(t);return c?c.call(n,a,s):n.slice(s-a.length,s)===a}})},function(t,n,r){var e=r(5),o=r(3),i=r(1).Array||Array,u={},c=function(t,n){e.each.call(t.split(\",\"),function(t){void 0==n&&t in i?u[t]=i[t]:t in[]&&(u[t]=r(12)(Function.call,[][t],n))})};c(\"pop,reverse,shift,keys,values,entries\",1),c(\"indexOf,every,some,forEach,map,filter,find,findIndex,includes\",3),c(\"join,slice,concat,push,splice,unshift,sort,lastIndexOf,reduce,reduceRight,copyWithin,fill\"),o(o.S,\"Array\",u)}]);\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports) {\n\n\t\"use strict\";\n\t\n\tObject.defineProperty(exports, \"__esModule\", {\n\t  value: true\n\t});\n\texports.default = getDataTransferFiles;\n\tfunction getDataTransferFiles(event) {\n\t  var dataTransferItemsList = [];\n\t  if (event.dataTransfer) {\n\t    var dt = event.dataTransfer;\n\t    if (dt.files && dt.files.length) {\n\t      dataTransferItemsList = dt.files;\n\t    } else if (dt.items && dt.items.length) {\n\t      // During the drag even the dataTransfer.files is null\n\t      // but Chrome implements some drag store, which is accesible via dataTransfer.items\n\t      dataTransferItemsList = dt.items;\n\t    }\n\t  } else if (event.target && event.target.files) {\n\t    dataTransferItemsList = event.target.files;\n\t  }\n\t  // Convert from DataTransferItemsList to the native Array\n\t  return Array.prototype.slice.call(dataTransferItemsList);\n\t}\n\tmodule.exports = exports[\"default\"];\n\n/***/ })\n/******/ ])\n});\n;\n//# sourceMappingURL=index.js.map","/* global window */\nimport ponyfill from './ponyfill.js';\n\nvar root;\n\nif (typeof self !== 'undefined') {\n  root = self;\n} else if (typeof window !== 'undefined') {\n  root = window;\n} else if (typeof global !== 'undefined') {\n  root = global;\n} else if (typeof module !== 'undefined') {\n  root = module;\n} else {\n  root = Function('return this')();\n}\n\nvar result = ponyfill(root);\nexport default result;\n","export default function symbolObservablePonyfill(root) {\n\tvar result;\n\tvar Symbol = root.Symbol;\n\n\tif (typeof Symbol === 'function') {\n\t\tif (Symbol.observable) {\n\t\t\tresult = Symbol.observable;\n\t\t} else {\n\t\t\tresult = Symbol('observable');\n\t\t\tSymbol.observable = result;\n\t\t}\n\t} else {\n\t\tresult = '@@observable';\n\t}\n\n\treturn result;\n};\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\n","import { __rest } from \"tslib\";\nimport * as PropTypes from 'prop-types';\nimport { useQuery } from \"../hooks/index.js\";\nexport function Query(props) {\n    var children = props.children, query = props.query, options = __rest(props, [\"children\", \"query\"]);\n    var result = useQuery(query, options);\n    return result ? children(result) : null;\n}\nQuery.propTypes = {\n    client: PropTypes.object,\n    children: PropTypes.func.isRequired,\n    fetchPolicy: PropTypes.string,\n    notifyOnNetworkStatusChange: PropTypes.bool,\n    onCompleted: PropTypes.func,\n    onError: PropTypes.func,\n    pollInterval: PropTypes.number,\n    query: PropTypes.object.isRequired,\n    variables: PropTypes.object,\n    ssr: PropTypes.bool,\n    partialRefetch: PropTypes.bool,\n    returnPartialData: PropTypes.bool\n};\n//# sourceMappingURL=Query.js.map","import { Router, __RouterContext, matchPath } from 'react-router';\nexport * from 'react-router';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport React from 'react';\nimport { createBrowserHistory, createHashHistory, createLocation } from 'history';\nimport PropTypes from 'prop-types';\nimport warning from 'tiny-warning';\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport invariant from 'tiny-invariant';\n\n/**\n * The public API for a <Router> that uses HTML5 history.\n */\n\nvar BrowserRouter =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(BrowserRouter, _React$Component);\n\n  function BrowserRouter() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.history = createBrowserHistory(_this.props);\n    return _this;\n  }\n\n  var _proto = BrowserRouter.prototype;\n\n  _proto.render = function render() {\n    return React.createElement(Router, {\n      history: this.history,\n      children: this.props.children\n    });\n  };\n\n  return BrowserRouter;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  BrowserRouter.propTypes = {\n    basename: PropTypes.string,\n    children: PropTypes.node,\n    forceRefresh: PropTypes.bool,\n    getUserConfirmation: PropTypes.func,\n    keyLength: PropTypes.number\n  };\n\n  BrowserRouter.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!this.props.history, \"<BrowserRouter> ignores the history prop. To use a custom history, \" + \"use `import { Router }` instead of `import { BrowserRouter as Router }`.\") : void 0;\n  };\n}\n\n/**\n * The public API for a <Router> that uses window.location.hash.\n */\n\nvar HashRouter =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(HashRouter, _React$Component);\n\n  function HashRouter() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.history = createHashHistory(_this.props);\n    return _this;\n  }\n\n  var _proto = HashRouter.prototype;\n\n  _proto.render = function render() {\n    return React.createElement(Router, {\n      history: this.history,\n      children: this.props.children\n    });\n  };\n\n  return HashRouter;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  HashRouter.propTypes = {\n    basename: PropTypes.string,\n    children: PropTypes.node,\n    getUserConfirmation: PropTypes.func,\n    hashType: PropTypes.oneOf([\"hashbang\", \"noslash\", \"slash\"])\n  };\n\n  HashRouter.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!this.props.history, \"<HashRouter> ignores the history prop. To use a custom history, \" + \"use `import { Router }` instead of `import { HashRouter as Router }`.\") : void 0;\n  };\n}\n\nvar resolveToLocation = function resolveToLocation(to, currentLocation) {\n  return typeof to === \"function\" ? to(currentLocation) : to;\n};\nvar normalizeToLocation = function normalizeToLocation(to, currentLocation) {\n  return typeof to === \"string\" ? createLocation(to, null, null, currentLocation) : to;\n};\n\nvar forwardRefShim = function forwardRefShim(C) {\n  return C;\n};\n\nvar forwardRef = React.forwardRef;\n\nif (typeof forwardRef === \"undefined\") {\n  forwardRef = forwardRefShim;\n}\n\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nvar LinkAnchor = forwardRef(function (_ref, forwardedRef) {\n  var innerRef = _ref.innerRef,\n      navigate = _ref.navigate,\n      _onClick = _ref.onClick,\n      rest = _objectWithoutPropertiesLoose(_ref, [\"innerRef\", \"navigate\", \"onClick\"]);\n\n  var target = rest.target;\n\n  var props = _extends({}, rest, {\n    onClick: function onClick(event) {\n      try {\n        if (_onClick) _onClick(event);\n      } catch (ex) {\n        event.preventDefault();\n        throw ex;\n      }\n\n      if (!event.defaultPrevented && // onClick prevented default\n      event.button === 0 && ( // ignore everything but left clicks\n      !target || target === \"_self\") && // let browser handle \"target=_blank\" etc.\n      !isModifiedEvent(event) // ignore clicks with modifier keys\n      ) {\n          event.preventDefault();\n          navigate();\n        }\n    }\n  }); // React 15 compat\n\n\n  if (forwardRefShim !== forwardRef) {\n    props.ref = forwardedRef || innerRef;\n  } else {\n    props.ref = innerRef;\n  }\n\n  return React.createElement(\"a\", props);\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  LinkAnchor.displayName = \"LinkAnchor\";\n}\n/**\n * The public API for rendering a history-aware <a>.\n */\n\n\nvar Link = forwardRef(function (_ref2, forwardedRef) {\n  var _ref2$component = _ref2.component,\n      component = _ref2$component === void 0 ? LinkAnchor : _ref2$component,\n      replace = _ref2.replace,\n      to = _ref2.to,\n      innerRef = _ref2.innerRef,\n      rest = _objectWithoutPropertiesLoose(_ref2, [\"component\", \"replace\", \"to\", \"innerRef\"]);\n\n  return React.createElement(__RouterContext.Consumer, null, function (context) {\n    !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Link> outside a <Router>\") : invariant(false) : void 0;\n    var history = context.history;\n    var location = normalizeToLocation(resolveToLocation(to, context.location), context.location);\n    var href = location ? history.createHref(location) : \"\";\n\n    var props = _extends({}, rest, {\n      href: href,\n      navigate: function navigate() {\n        var location = resolveToLocation(to, context.location);\n        var method = replace ? history.replace : history.push;\n        method(location);\n      }\n    }); // React 15 compat\n\n\n    if (forwardRefShim !== forwardRef) {\n      props.ref = forwardedRef || innerRef;\n    } else {\n      props.innerRef = innerRef;\n    }\n\n    return React.createElement(component, props);\n  });\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  var toType = PropTypes.oneOfType([PropTypes.string, PropTypes.object, PropTypes.func]);\n  var refType = PropTypes.oneOfType([PropTypes.string, PropTypes.func, PropTypes.shape({\n    current: PropTypes.any\n  })]);\n  Link.displayName = \"Link\";\n  Link.propTypes = {\n    innerRef: refType,\n    onClick: PropTypes.func,\n    replace: PropTypes.bool,\n    target: PropTypes.string,\n    to: toType.isRequired\n  };\n}\n\nvar forwardRefShim$1 = function forwardRefShim(C) {\n  return C;\n};\n\nvar forwardRef$1 = React.forwardRef;\n\nif (typeof forwardRef$1 === \"undefined\") {\n  forwardRef$1 = forwardRefShim$1;\n}\n\nfunction joinClassnames() {\n  for (var _len = arguments.length, classnames = new Array(_len), _key = 0; _key < _len; _key++) {\n    classnames[_key] = arguments[_key];\n  }\n\n  return classnames.filter(function (i) {\n    return i;\n  }).join(\" \");\n}\n/**\n * A <Link> wrapper that knows if it's \"active\" or not.\n */\n\n\nvar NavLink = forwardRef$1(function (_ref, forwardedRef) {\n  var _ref$ariaCurrent = _ref[\"aria-current\"],\n      ariaCurrent = _ref$ariaCurrent === void 0 ? \"page\" : _ref$ariaCurrent,\n      _ref$activeClassName = _ref.activeClassName,\n      activeClassName = _ref$activeClassName === void 0 ? \"active\" : _ref$activeClassName,\n      activeStyle = _ref.activeStyle,\n      classNameProp = _ref.className,\n      exact = _ref.exact,\n      isActiveProp = _ref.isActive,\n      locationProp = _ref.location,\n      strict = _ref.strict,\n      styleProp = _ref.style,\n      to = _ref.to,\n      innerRef = _ref.innerRef,\n      rest = _objectWithoutPropertiesLoose(_ref, [\"aria-current\", \"activeClassName\", \"activeStyle\", \"className\", \"exact\", \"isActive\", \"location\", \"strict\", \"style\", \"to\", \"innerRef\"]);\n\n  return React.createElement(__RouterContext.Consumer, null, function (context) {\n    !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <NavLink> outside a <Router>\") : invariant(false) : void 0;\n    var currentLocation = locationProp || context.location;\n    var toLocation = normalizeToLocation(resolveToLocation(to, currentLocation), currentLocation);\n    var path = toLocation.pathname; // Regex taken from: https://github.com/pillarjs/path-to-regexp/blob/master/index.js#L202\n\n    var escapedPath = path && path.replace(/([.+*?=^!:${}()[\\]|/\\\\])/g, \"\\\\$1\");\n    var match = escapedPath ? matchPath(currentLocation.pathname, {\n      path: escapedPath,\n      exact: exact,\n      strict: strict\n    }) : null;\n    var isActive = !!(isActiveProp ? isActiveProp(match, currentLocation) : match);\n    var className = isActive ? joinClassnames(classNameProp, activeClassName) : classNameProp;\n    var style = isActive ? _extends({}, styleProp, {}, activeStyle) : styleProp;\n\n    var props = _extends({\n      \"aria-current\": isActive && ariaCurrent || null,\n      className: className,\n      style: style,\n      to: toLocation\n    }, rest); // React 15 compat\n\n\n    if (forwardRefShim$1 !== forwardRef$1) {\n      props.ref = forwardedRef || innerRef;\n    } else {\n      props.innerRef = innerRef;\n    }\n\n    return React.createElement(Link, props);\n  });\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  NavLink.displayName = \"NavLink\";\n  var ariaCurrentType = PropTypes.oneOf([\"page\", \"step\", \"location\", \"date\", \"time\", \"true\"]);\n  NavLink.propTypes = _extends({}, Link.propTypes, {\n    \"aria-current\": ariaCurrentType,\n    activeClassName: PropTypes.string,\n    activeStyle: PropTypes.object,\n    className: PropTypes.string,\n    exact: PropTypes.bool,\n    isActive: PropTypes.func,\n    location: PropTypes.object,\n    strict: PropTypes.bool,\n    style: PropTypes.object\n  });\n}\n\nexport { BrowserRouter, HashRouter, Link, NavLink };\n//# sourceMappingURL=react-router-dom.js.map\n","function _extends() {\n  module.exports = _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  module.exports[\"default\"] = module.exports, module.exports.__esModule = true;\n  return _extends.apply(this, arguments);\n}\n\nmodule.exports = _extends;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _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\nmodule.exports = _objectWithoutPropertiesLoose;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nmodule.exports = _assertThisInitialized;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","import { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from 'react';\nimport { getApolloContext } from \"./ApolloContext.js\";\nexport var ApolloConsumer = function (props) {\n    var ApolloContext = getApolloContext();\n    return React.createElement(ApolloContext.Consumer, null, function (context) {\n        __DEV__ ? invariant(context && context.client, 'Could not find \"client\" in the context of ApolloConsumer. ' +\n            'Wrap the root component in an <ApolloProvider>.') : invariant(context && context.client, 27);\n        return props.children(context.client);\n    });\n};\n//# sourceMappingURL=ApolloConsumer.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from 'react';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport { ApolloConsumer } from \"../context/index.js\";\nfunction getDisplayName(WrappedComponent) {\n    return WrappedComponent.displayName || WrappedComponent.name || 'Component';\n}\nexport function withApollo(WrappedComponent, operationOptions) {\n    if (operationOptions === void 0) { operationOptions = {}; }\n    var withDisplayName = \"withApollo(\" + getDisplayName(WrappedComponent) + \")\";\n    var WithApollo = (function (_super) {\n        __extends(WithApollo, _super);\n        function WithApollo(props) {\n            var _this = _super.call(this, props) || this;\n            _this.setWrappedInstance = _this.setWrappedInstance.bind(_this);\n            return _this;\n        }\n        WithApollo.prototype.getWrappedInstance = function () {\n            __DEV__ ? invariant(operationOptions.withRef, \"To access the wrapped instance, you need to specify \" +\n                \"{ withRef: true } in the options\") : invariant(operationOptions.withRef, 32);\n            return this.wrappedInstance;\n        };\n        WithApollo.prototype.setWrappedInstance = function (ref) {\n            this.wrappedInstance = ref;\n        };\n        WithApollo.prototype.render = function () {\n            var _this = this;\n            return (React.createElement(ApolloConsumer, null, function (client) {\n                var props = Object.assign({}, _this.props, {\n                    client: client,\n                    ref: operationOptions.withRef\n                        ? _this.setWrappedInstance\n                        : undefined\n                });\n                return React.createElement(WrappedComponent, __assign({}, props));\n            }));\n        };\n        WithApollo.displayName = withDisplayName;\n        WithApollo.WrappedComponent = WrappedComponent;\n        return WithApollo;\n    }(React.Component));\n    return hoistNonReactStatics(WithApollo, WrappedComponent, {});\n}\n//# sourceMappingURL=withApollo.js.map"],"sourceRoot":""}