{"version":3,"sources":["webpack:///../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack:///../node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack:///../node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack:///../node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack:///../node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack:///../node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack:///../node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack:///../node_modules/@babel/runtime/node_modules/regenerator-runtime/runtime.js","webpack:///../node_modules/@babel/runtime/regenerator/index.js","webpack:///../node_modules/tslib/tslib.es6.js","webpack:///../node_modules/use-sidecar/dist/es2015/medium.js","webpack:///../node_modules/react-remove-scroll/dist/es2015/medium.js","webpack:///../node_modules/use-callback-ref/dist/es2015/useMergeRef.js","webpack:///../node_modules/use-callback-ref/dist/es2015/useRef.js","webpack:///../node_modules/use-callback-ref/dist/es2015/assignRef.js","webpack:///../node_modules/react-remove-scroll/dist/es2015/UI.js","webpack:///../node_modules/react-remove-scroll-bar/dist/es2015/constants.js","webpack:///../node_modules/react-focus-lock/dist/es2015/FocusGuard.js","webpack:///../node_modules/react-focus-lock/dist/es2015/medium.js","webpack:///../node_modules/react-focus-lock/dist/es2015/Lock.js","webpack:///../node_modules/focus-lock/dist/es2015/constants.js","webpack:///../node_modules/react-focus-lock/dist/es2015/UI.js","webpack:///../node_modules/react-focus-on/dist/es2015/medium.js","webpack:///../node_modules/react-focus-on/dist/es2015/UI.js","webpack:///../node_modules/use-sidecar/dist/es2015/exports.js","webpack:///../node_modules/react-clientside-effect/lib/index.es.js","webpack:///../node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","webpack:///../node_modules/focus-lock/dist/es2015/utils/array.js","webpack:///../node_modules/focus-lock/dist/es2015/focusIsHidden.js","webpack:///../node_modules/focus-lock/dist/es2015/utils/all-affected.js","webpack:///../node_modules/focus-lock/dist/es2015/focusInside.js","webpack:///../node_modules/focus-lock/dist/es2015/utils/tabOrder.js","webpack:///../node_modules/focus-lock/dist/es2015/utils/tabbables.js","webpack:///../node_modules/focus-lock/dist/es2015/utils/tabUtils.js","webpack:///../node_modules/focus-lock/dist/es2015/utils/DOMutils.js","webpack:///../node_modules/focus-lock/dist/es2015/utils/correctFocus.js","webpack:///../node_modules/focus-lock/dist/es2015/utils/firstFocus.js","webpack:///../node_modules/focus-lock/dist/es2015/focusMerge.js","webpack:///../node_modules/focus-lock/dist/es2015/setFocus.js","webpack:///../node_modules/focus-lock/dist/es2015/index.js","webpack:///../node_modules/react-focus-lock/dist/es2015/util.js","webpack:///../node_modules/react-focus-lock/dist/es2015/Trap.js","webpack:///../node_modules/get-nonce/dist/es2015/index.js","webpack:///../node_modules/react-focus-lock/dist/es2015/sidecar.js","webpack:///../node_modules/react-style-singleton/dist/es2015/singleton.js","webpack:///../node_modules/react-style-singleton/dist/es2015/component.js","webpack:///../node_modules/react-style-singleton/dist/es2015/hook.js","webpack:///../node_modules/react-remove-scroll-bar/dist/es2015/utils.js","webpack:///../node_modules/react-remove-scroll-bar/dist/es2015/component.js","webpack:///../node_modules/react-remove-scroll/dist/es2015/handleScroll.js","webpack:///../node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js","webpack:///../node_modules/react-remove-scroll/dist/es2015/SideEffect.js","webpack:///../node_modules/react-remove-scroll/dist/es2015/sidecar.js","webpack:///../node_modules/aria-hidden/dist/es2015/index.js","webpack:///../node_modules/react-focus-on/dist/es2015/InteractivityDisabler.js","webpack:///../node_modules/react-focus-on/dist/es2015/Effect.js","webpack:///../node_modules/react-focus-on/dist/es2015/sidecar.js","webpack:///../node_modules/react-focus-on/dist/es2015/Combination.js","webpack:///../node_modules/@paypalcorp/pp-react-modal/dist/@paypalcorp/pp-react-modal.esm.js","webpack:///../node_modules/performance-now/lib/performance-now.js","webpack:///../node_modules/raf/index.js","webpack:///../node_modules/raf/node_modules/performance-now/lib/performance-now.js","webpack:///../node_modules/react-motion/lib/TransitionMotion.js","webpack:///../node_modules/react-motion/lib/mapToZero.js","webpack:///../node_modules/react-motion/lib/mergeDiff.js","webpack:///../node_modules/react-motion/lib/presets.js","webpack:///../node_modules/react-motion/lib/shouldStopAnimation.js","webpack:///../node_modules/react-motion/lib/spring.js","webpack:///../node_modules/react-motion/lib/stepper.js","webpack:///../node_modules/react-motion/lib/stripStyle.js","webpack:///../node_modules/react-router-dom/es/matchPath.js","webpack:///../node_modules/react-router-transition/es/ensureSpring.js","webpack:///../node_modules/react-router-transition/es/RouteTransition.js","webpack:///../node_modules/react-router-transition/es/AnimatedRoute.js","webpack:///../node_modules/react-router-transition/es/AnimatedSwitch.js","webpack:///../node_modules/react-router-transition/es/index.js"],"names":["_arrayLikeToArray","arr","len","length","i","arr2","Array","asyncGeneratorStep","gen","resolve","reject","_next","_throw","key","arg","info","value","error","done","Promise","then","_asyncToGenerator","fn","self","this","args","arguments","apply","err","undefined","_slicedToArray","isArray","Symbol","iterator","Object","_arr","_n","_d","_e","_s","_i","next","push","unsupportedIterableToArray","TypeError","_unsupportedIterableToArray","o","minLen","n","prototype","toString","call","slice","constructor","name","from","test","runtime","exports","Op","hasOwn","hasOwnProperty","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","obj","defineProperty","enumerable","configurable","writable","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","create","context","Context","_invoke","state","method","Error","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","type","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","forEach","AsyncIterator","PromiseImpl","previousPromise","callInvokeWithMethodAndArg","invoke","result","__await","unwrapped","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","displayName","isGeneratorFunction","genFun","ctor","mark","setPrototypeOf","__proto__","awrap","async","iter","keys","object","reverse","pop","skipTempReset","prev","charAt","stop","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","module","regeneratorRuntime","accidentalStrictMode","Function","__assign","assign","t","s","p","__rest","e","indexOf","getOwnPropertySymbols","propertyIsEnumerable","ItoI","a","innerCreateMedium","defaults","middleware","buffer","assigned","read","useMedium","data","item","filter","x","assignSyncMedium","cb","cbs","assignMedium","pendingQueue","executeQueue","cycle","createMedium","createSidecarMedium","options","medium","ssr","effectCar","useMergeRefs","refs","defaultValue","initialValue","callback","newValue","ref","current","assignRef","facade","last","nothing","RemoveScroll","props","parentRef","_a","onScrollCapture","onWheelCapture","onTouchMoveCapture","callbacks","setCallbacks","forwardProps","children","className","removeScrollBar","enabled","shards","sideCar","noIsolation","inert","allowPinchZoom","_b","as","Container","rest","SideCar","containerRef","containerProps","lockRef","only","defaultProps","classNames","fullWidth","zeroRight","hiddenGuard","width","height","padding","overflow","position","top","left","_ref","style","propTypes","mediumFocus","target","currentTarget","mediumBlur","mediumEffect","mediumSidecar","emptyArray","FocusLock","_extends2","_React$useState","realObserved","setObserved","observed","isActive","originalFocusedElement","disabled","noFocusGuards","persistentFocus","crossFrame","autoFocus","group","allowTextSelection","whiteList","_props$shards","_props$as","_props$lockProps","lockProps","shouldReturnFocus","returnFocus","onActivationCallback","onActivation","onDeactivationCallback","onDeactivation","id","document","activeElement","allowDefer","Boolean","focus","focusOptions","onFocus","event","onBlur","setObserveNode","newObserved","hasLeadingGuards","hasTailingGuards","mergedRef","tabIndex","FocusOn","setLockProps","_c","scrollLock","focusLock","shouldIgnore","restProps","Target","exportSidecar","exported","isSideCarExport","reducePropsToState","handleStateChangeOnClient","WrappedComponent","mountedInstances","emitChange","map","instance","SideEffect","_PureComponent","subClass","superClass","peek","_proto","componentDidMount","componentDidUpdate","componentWillUnmount","index","splice","render","createElement","getDisplayName","toArray","ret","asArray","querySelectorAll","some","node","contains","_typeof","reduce","acc","currentNode","getAttribute","filterNested","nodes","l","_loop","j","v","_ret","getTopParent","parentNode","focusInFrame","frame","topNode","dataset","focusGuard","array","search","tabSort","b","tabDiff","indexDiff","filterNegative","keepGuards","sort","queryTabbables","tabbables","join","queryGuardTabbables","parents","withGuards","parent","concat","getParents","getCommonParent","nodea","nodeb","parentsA","parentsB","currentParent","isVisible","nodeType","Node","DOCUMENT_NODE","computedStyle","window","getComputedStyle","getPropertyValue","DOCUMENT_FRAGMENT_NODE","host","tagName","notHiddenInput","topNodes","parentFocus","isRadio","correctNode","el","checked","findSelectedRadio","isGuard","notAGuard","innerNodes","outerNodes","lastNode","cnt","firstFocus","lastFocus","isOnGuard","resultSet","activeIndex","lastIndex","lastNodeInside","firstNodeIndex","lastNodeIndex","correctedNodes","Set","add","has","correctedIndexDiff","returnFirstNode","returnLastNode","Math","abs","baseActiveElement","leftEntry","rightEntries","activeElements","leftEntries","topCommon","subEntry","common","entries","commonParent","anyFocusable","innerElements","_ref4","srcNodes","dstNodes","remap","autoFocusables","_ref5","orderedInnerElements","Map","entity","set","get","_ref6","newId","autoFocusable","_ref7","autofocus","guardCount","lockDisabled","focusable","console","setTimeout","contentWindow","deferAction","action","setImmediate","body","lastActiveTrap","lastActiveFocus","lastPortaledElement","focusWasOutsideWindow","defaultWhitelist","autoGuard","startIndex","end","step","allNodes","lastGuard","guard","focusAutoGuard","lockItem","extractRef","element","_lastActiveTrap","workingNode","portaledElement","workingArea","focusWhitelisted","blur","newActiveElement","_ref2","_ref3","focusedIndex","removeAttribute","onTrap","stopPropagation","preventDefault","source","observerNode","onWindowBlur","moveFocusInside","focusInside","currentNonce","propsList","traps","trap","addEventListener","lastTrap","sameTrap","removeEventListener","makeStyleTag","tag","nonce","setAttribute","stylesheetSingleton","counter","stylesheet","css","styleSheet","cssText","appendChild","createTextNode","head","getElementsByTagName","insertStyleTag","remove","removeChild","styleSingleton","sheet","useStyle","styles","zeroGap","right","gap","parse","parseInt","getGapWidth","gapMode","offsets","cs","getOffset","documentWidth","documentElement","clientWidth","windowWidth","innerWidth","max","getStyles","allowRelative","important","RemoveScrollBar","setGap","noRelative","noImportant","locationCouldBeScrolled","axis","elementCouldBeScrolled","getScrollVariables","overflowY","overflowX","elementCouldBeVScrolled","elementCouldBeHScrolled","scrollTop","scrollHeight","clientHeight","scrollLeft","scrollWidth","getHScrollVariables","passiveSupported","nonPassive","passive","getTouchXY","changedTouches","clientX","clientY","getDeltaXY","deltaX","deltaY","generateStyle","idCounter","lockStack","shouldPreventQueue","touchStartRef","activeAxis","Style","lastProps","classList","allow_1","shouldCancelEvent","touches","currentAxis","touch","touchStart","moveDirection","canBeScrolledInMainDirection","cancelingAxis","endTarget","sourceDelta","noOverscroll","delta","targetInLock","shouldCancelScroll","isDeltaPositive","availableScroll","availableScrollTop","elementScroll","handleScroll","shouldPrevent","_event","sourceEvent","y","should","shardNodes","shouldCancel","scrollTouchStart","scrollWheel","scrollTouchMove","inst","defaultParent","counterMap","WeakMap","uncontrolledNodes","markerMap","lockCount","InteractivityDisabler","onEscapeKey","onClickOutside","activeNode","setActiveNode","lastEventTarget","mouseTouches","onKeyDown","defaultPrevented","code","keyCode","onMouseDown","MouseEvent","button","onTouchStart","onTouchEnd","_undo","unmounted","originalTarget","markerName","targets","markerCounter","hiddenNodes","deep","attr","alreadyHidden","counterValue","markerValue","delete","hideOthers","RequireSideCar","_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","Date","_isNativeReflectConstruct","Super","NewTarget","_React$Component","Modal","_super","_this","scrollCheck","closeButton","createRef","contentRef","idBase","random","toFixed","isMounted","headerScroll","footerScroll","setState","contents","newState","footerContents","offsetHeight","prevProps","shouldSetFocus","isOpen","_clsx3","_clsx4","_this$props","onClose","_this$props$closeButt","closeButtonLabel","hideLogo","hideTitle","title","_this$props$closeOnBa","closeOnBackgroundClick","_this$props$action","_this$props$footerCon","footerAlign","overpanel","center","headerClassName","contentClassName","footerClassName","classes","ppvx_modal","contentClasses","ppvx_modal__contents","ariaHidden","onClick","titleId","titleElement","ariaProps","role","footer","evt","handleEscape","onScroll","scrollChecker","containerElm","createPortal","Component","getNanoSeconds","hrtime","loadTime","performance","now","process","hr","getTime","root","global","vendors","suffix","raf","caf","queue","_now","cp","cancelled","round","cancel","polyfill","requestAnimationFrame","cancelAnimationFrame","moduleLoadTime","nodeLoadTime","upTime","uptime","__esModule","_extends","_createClass","defineProperties","descriptor","Constructor","protoProps","staticProps","_interopRequireDefault","_mapToZero2","_stripStyle2","_stepper4","_mergeDiff2","_performanceNow2","_raf2","_shouldStopAnimation2","_react2","_propTypes2","rehydrateStyles","mergedPropsStyles","unreadPropStyles","plainStyles","cUnreadPropStyles","mergedPropsStyle","mergeAndSync","willEnter","willLeave","didLeave","oldMergedPropsStyles","destStyles","oldCurrentStyles","oldCurrentVelocities","oldLastIdealStyles","oldLastIdealVelocities","newMergedPropsStyles","oldIndex","oldMergedPropsStyle","leavingStyle","newCurrentStyles","newCurrentVelocities","newLastIdealStyles","newLastIdealVelocities","newMergedPropsStyleCell","foundOldIndex","plainStyle","velocity","TransitionMotion","_classCallCheck","unmounting","animationID","prevTime","accumulatedTime","clearUnreadPropStyle","_mergeAndSync","currentStyles","currentVelocities","lastIdealStyles","lastIdealVelocities","unreadPropStyle","dirty","styleValue","startAnimationIfNecessary","timestamp","propStyles","shouldStopAnimationAll","currentTime","timeDelta","currentFrameCompletion","floor","framesToCatchUp","_mergeAndSync2","newMergedPropsStyle","newCurrentStyle","newCurrentVelocity","newLastIdealStyle","newLastIdealVelocity","newLastIdealStyleValue","newLastIdealVelocityValue","_stepper","val","stiffness","damping","precision","_stepper2","nextIdealX","nextIdealV","defaultState","_inherits","defaultStyles","arrayOf","shape","string","isRequired","any","objectOf","number","oneOfType","func","styleThatEntered","_props","defaultStyleCell","_mergeAndSync3","componentWillReceiveProps","hydratedStyles","renderedChildren","Children","onRemove","prevKeyIndex","nextKeyIndex","fill","nextOrderA","nextOrderB","prevOrderA","prevOrderB","pivot","noWobble","gentle","wobbly","stiff","currentStyle","currentVelocity","config","defaultConfig","_presets","_presets2","secondPerFrame","destX","k","newV","newX","reusedTuple","ensureSpring","_possibleConstructorReturn","ReferenceError","_Component","RouteTransition","_temp","_len","_key","atEnter","atLeave","styleThatLeft","renderRoute","mapStyles","wrapperComponent","renderRoutes","interpolatedStyles","runOnMount","atActive","getDefaultStyles","bool","NO_MATCH","getLocationKey","location","getMatchedRoute","pathname","find","child","exact","path","AnimatedSwitch","match","matches","nextProps","nextMatch","routeTransitionProps","Switch","Route"],"mappings":"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","file":"vendors~ppme-shared.bundle.js","sourcesContent":["export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}","import arrayWithHoles from \"./arrayWithHoles\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray\";\nimport nonIterableRest from \"./nonIterableRest\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","import arrayLikeToArray from \"./arrayLikeToArray\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","/**\n * Copyright (c) 2014-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\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","module.exports = require(\"regenerator-runtime\");\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import * as tslib_1 from \"tslib\";\nfunction ItoI(a) {\n    return a;\n}\nfunction innerCreateMedium(defaults, middleware) {\n    if (middleware === void 0) { middleware = ItoI; }\n    var buffer = [];\n    var assigned = false;\n    var medium = {\n        read: function () {\n            if (assigned) {\n                throw new Error('Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.');\n            }\n            if (buffer.length) {\n                return buffer[buffer.length - 1];\n            }\n            return defaults;\n        },\n        useMedium: function (data) {\n            var item = middleware(data, assigned);\n            buffer.push(item);\n            return function () {\n                buffer = buffer.filter(function (x) { return x !== item; });\n            };\n        },\n        assignSyncMedium: function (cb) {\n            assigned = true;\n            while (buffer.length) {\n                var cbs = buffer;\n                buffer = [];\n                cbs.forEach(cb);\n            }\n            buffer = {\n                push: function (x) { return cb(x); },\n                filter: function () { return buffer; },\n            };\n        },\n        assignMedium: function (cb) {\n            assigned = true;\n            var pendingQueue = [];\n            if (buffer.length) {\n                var cbs = buffer;\n                buffer = [];\n                cbs.forEach(cb);\n                pendingQueue = buffer;\n            }\n            var executeQueue = function () {\n                var cbs = pendingQueue;\n                pendingQueue = [];\n                cbs.forEach(cb);\n            };\n            var cycle = function () { return Promise.resolve().then(executeQueue); };\n            cycle();\n            buffer = {\n                push: function (x) {\n                    pendingQueue.push(x);\n                    cycle();\n                },\n                filter: function (filter) {\n                    pendingQueue = pendingQueue.filter(filter);\n                    return buffer;\n                },\n            };\n        },\n    };\n    return medium;\n}\nexport function createMedium(defaults, middleware) {\n    if (middleware === void 0) { middleware = ItoI; }\n    return innerCreateMedium(defaults, middleware);\n}\nexport function createSidecarMedium(options) {\n    if (options === void 0) { options = {}; }\n    var medium = innerCreateMedium(null);\n    medium.options = tslib_1.__assign({ async: true, ssr: false }, options);\n    return medium;\n}\n","import { createSidecarMedium } from 'use-sidecar';\nexport var effectCar = createSidecarMedium();\n","import { useCallbackRef } from './useRef';\nimport { assignRef } from './assignRef';\n/**\n * Merges two or more refs together providing a single interface to set their value\n * @param {RefObject|Ref} refs\n * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}\n *\n * @see {@link mergeRefs} a version without buit-in memoization\n * @see https://github.com/theKashey/use-callback-ref#usemergerefs\n * @example\n * const Component = React.forwardRef((props, ref) => {\n *   const ownRef = useRef();\n *   const domRef = useMergeRefs([ref, ownRef]); // 👈 merge together\n *   return <div ref={domRef}>...</div>\n * }\n */\nexport function useMergeRefs(refs, defaultValue) {\n    return useCallbackRef(defaultValue, function (newValue) {\n        return refs.forEach(function (ref) { return assignRef(ref, newValue); });\n    });\n}\n","import { useState } from 'react';\n/**\n * creates a MutableRef with ref change callback\n * @param initialValue - initial ref value\n * @param {Function} callback - a callback to run when value changes\n *\n * @example\n * const ref = useCallbackRef(0, (newValue, oldValue) => console.log(oldValue, '->', newValue);\n * ref.current = 1;\n * // prints 0 -> 1\n *\n * @see https://reactjs.org/docs/hooks-reference.html#useref\n * @see https://github.com/theKashey/use-callback-ref#usecallbackref---to-replace-reactuseref\n * @returns {MutableRefObject}\n */\nexport function useCallbackRef(initialValue, callback) {\n    var ref = useState(function () { return ({\n        // value\n        value: initialValue,\n        // last callback\n        callback: callback,\n        // \"memoized\" public interface\n        facade: {\n            get current() {\n                return ref.value;\n            },\n            set current(value) {\n                var last = ref.value;\n                if (last !== value) {\n                    ref.value = value;\n                    ref.callback(value, last);\n                }\n            }\n        }\n    }); })[0];\n    // update callback\n    ref.callback = callback;\n    return ref.facade;\n}\n","/**\n * Assigns a value for a given ref, no matter of the ref format\n * @param {RefObject} ref - a callback function or ref object\n * @param value - a new value\n *\n * @see https://github.com/theKashey/use-callback-ref#assignref\n * @example\n * const refObject = useRef();\n * const refFn = (ref) => {....}\n *\n * assignRef(refObject, \"refValue\");\n * assignRef(refFn, \"refValue\");\n */\nexport function assignRef(ref, value) {\n    if (typeof ref === 'function') {\n        ref(value);\n    }\n    else if (ref) {\n        ref.current = value;\n    }\n    return ref;\n}\n","import * as tslib_1 from \"tslib\";\nimport * as React from 'react';\nimport { fullWidthClassName, zeroRightClassName } from 'react-remove-scroll-bar/constants';\nimport { effectCar } from './medium';\nimport { useMergeRefs } from 'use-callback-ref';\nvar nothing = function () {\n    return;\n};\n/**\n * Removes scrollbar from the page and contain the scroll within the Lock\n */\nvar RemoveScroll = React.forwardRef(function (props, parentRef) {\n    var ref = React.useRef(null);\n    var _a = React.useState({\n        onScrollCapture: nothing,\n        onWheelCapture: nothing,\n        onTouchMoveCapture: nothing\n    }), callbacks = _a[0], setCallbacks = _a[1];\n    var forwardProps = props.forwardProps, children = props.children, className = props.className, removeScrollBar = props.removeScrollBar, enabled = props.enabled, shards = props.shards, sideCar = props.sideCar, noIsolation = props.noIsolation, inert = props.inert, allowPinchZoom = props.allowPinchZoom, _b = props.as, Container = _b === void 0 ? 'div' : _b, rest = tslib_1.__rest(props, [\"forwardProps\", \"children\", \"className\", \"removeScrollBar\", \"enabled\", \"shards\", \"sideCar\", \"noIsolation\", \"inert\", \"allowPinchZoom\", \"as\"]);\n    var SideCar = sideCar;\n    var containerRef = useMergeRefs([\n        ref,\n        parentRef\n    ]);\n    var containerProps = tslib_1.__assign({}, rest, callbacks);\n    return (React.createElement(React.Fragment, null,\n        enabled && (React.createElement(SideCar, { sideCar: effectCar, removeScrollBar: removeScrollBar, shards: shards, noIsolation: noIsolation, inert: inert, setCallbacks: setCallbacks, allowPinchZoom: !!allowPinchZoom, lockRef: ref })),\n        forwardProps ? (React.cloneElement(React.Children.only(children), tslib_1.__assign({}, containerProps, { ref: containerRef }))) : (React.createElement(Container, tslib_1.__assign({}, containerProps, { className: className, ref: containerRef }), children))));\n});\nRemoveScroll.defaultProps = {\n    enabled: true,\n    removeScrollBar: true,\n    inert: false\n};\nRemoveScroll.classNames = {\n    fullWidth: fullWidthClassName,\n    zeroRight: zeroRightClassName\n};\nexport { RemoveScroll };\n","export var zeroRightClassName = 'right-scroll-bar-position';\nexport var fullWidthClassName = 'width-before-scroll-bar';\nexport var noScrollbarsClassName = 'with-scroll-bars-hidden';\n","import * as React from 'react';\nimport PropTypes from 'prop-types';\nexport var hiddenGuard = {\n  width: '1px',\n  height: '0px',\n  padding: 0,\n  overflow: 'hidden',\n  position: 'fixed',\n  top: '1px',\n  left: '1px'\n};\n\nvar InFocusGuard = function InFocusGuard(_ref) {\n  var children = _ref.children;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-first\",\n    \"data-focus-guard\": true,\n    \"data-focus-auto-guard\": true,\n    style: hiddenGuard\n  }), children, children && /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-last\",\n    \"data-focus-guard\": true,\n    \"data-focus-auto-guard\": true,\n    style: hiddenGuard\n  }));\n};\n\nInFocusGuard.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: PropTypes.node\n} : {};\nInFocusGuard.defaultProps = {\n  children: null\n};\nexport default InFocusGuard;","import { createMedium, createSidecarMedium } from 'use-sidecar';\nexport var mediumFocus = createMedium({}, function (_ref) {\n  var target = _ref.target,\n      currentTarget = _ref.currentTarget;\n  return {\n    target: target,\n    currentTarget: currentTarget\n  };\n});\nexport var mediumBlur = createMedium();\nexport var mediumEffect = createMedium();\nexport var mediumSidecar = createSidecarMedium({\n  async: true\n});","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { node, bool, string, any, arrayOf, oneOfType, object, func } from 'prop-types';\nimport * as constants from 'focus-lock/constants';\nimport { useMergeRefs } from 'use-callback-ref';\nimport { hiddenGuard } from './FocusGuard';\nimport { mediumFocus, mediumBlur, mediumSidecar } from './medium';\nvar emptyArray = [];\nvar FocusLock = /*#__PURE__*/React.forwardRef(function (props, parentRef) {\n  var _extends2;\n\n  var _React$useState = React.useState(),\n      realObserved = _React$useState[0],\n      setObserved = _React$useState[1];\n\n  var observed = React.useRef();\n  var isActive = React.useRef(false);\n  var originalFocusedElement = React.useRef(null);\n  var children = props.children,\n      disabled = props.disabled,\n      noFocusGuards = props.noFocusGuards,\n      persistentFocus = props.persistentFocus,\n      crossFrame = props.crossFrame,\n      autoFocus = props.autoFocus,\n      allowTextSelection = props.allowTextSelection,\n      group = props.group,\n      className = props.className,\n      whiteList = props.whiteList,\n      _props$shards = props.shards,\n      shards = _props$shards === void 0 ? emptyArray : _props$shards,\n      _props$as = props.as,\n      Container = _props$as === void 0 ? 'div' : _props$as,\n      _props$lockProps = props.lockProps,\n      containerProps = _props$lockProps === void 0 ? {} : _props$lockProps,\n      SideCar = props.sideCar,\n      shouldReturnFocus = props.returnFocus,\n      onActivationCallback = props.onActivation,\n      onDeactivationCallback = props.onDeactivation;\n\n  var _React$useState2 = React.useState({}),\n      id = _React$useState2[0]; // SIDE EFFECT CALLBACKS\n\n\n  var onActivation = React.useCallback(function () {\n    originalFocusedElement.current = originalFocusedElement.current || document && document.activeElement;\n\n    if (observed.current && onActivationCallback) {\n      onActivationCallback(observed.current);\n    }\n\n    isActive.current = true;\n  }, [onActivationCallback]);\n  var onDeactivation = React.useCallback(function () {\n    isActive.current = false;\n\n    if (onDeactivationCallback) {\n      onDeactivationCallback(observed.current);\n    }\n  }, [onDeactivationCallback]);\n  var returnFocus = React.useCallback(function (allowDefer) {\n    var current = originalFocusedElement.current;\n\n    if (Boolean(shouldReturnFocus) && current && current.focus) {\n      var focusOptions = typeof shouldReturnFocus === 'object' ? shouldReturnFocus : undefined;\n      originalFocusedElement.current = null;\n\n      if (allowDefer) {\n        // React might return focus after update\n        // it's safer to defer the action\n        Promise.resolve().then(function () {\n          return current.focus(focusOptions);\n        });\n      } else {\n        current.focus(focusOptions);\n      }\n    }\n  }, [shouldReturnFocus]); // MEDIUM CALLBACKS\n\n  var onFocus = React.useCallback(function (event) {\n    if (isActive.current) {\n      mediumFocus.useMedium(event);\n    }\n  }, []);\n  var onBlur = mediumBlur.useMedium; // REF PROPAGATION\n  // not using real refs due to race conditions\n\n  var setObserveNode = React.useCallback(function (newObserved) {\n    if (observed.current !== newObserved) {\n      observed.current = newObserved;\n      setObserved(newObserved);\n    }\n  }, []);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof allowTextSelection !== 'undefined') {\n      // eslint-disable-next-line no-console\n      console.warn('React-Focus-Lock: allowTextSelection is deprecated and enabled by default');\n    }\n\n    React.useEffect(function () {\n      if (!observed.current) {\n        // eslint-disable-next-line no-console\n        console.error('FocusLock: could not obtain ref to internal node');\n      }\n    }, []);\n  }\n\n  var lockProps = _extends((_extends2 = {}, _extends2[constants.FOCUS_DISABLED] = disabled && 'disabled', _extends2[constants.FOCUS_GROUP] = group, _extends2), containerProps);\n\n  var hasLeadingGuards = noFocusGuards !== true;\n  var hasTailingGuards = hasLeadingGuards && noFocusGuards !== 'tail';\n  var mergedRef = useMergeRefs([parentRef, setObserveNode]);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, hasLeadingGuards && [/*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-first\",\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 0,\n    style: hiddenGuard\n  }),\n  /*#__PURE__*/\n  // nearest focus guard\n  React.createElement(\"div\", {\n    key: \"guard-nearest\",\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 1,\n    style: hiddenGuard\n  }) // first tabbed element guard\n  ], !disabled && /*#__PURE__*/React.createElement(SideCar, {\n    id: id,\n    sideCar: mediumSidecar,\n    observed: realObserved,\n    disabled: disabled,\n    persistentFocus: persistentFocus,\n    crossFrame: crossFrame,\n    autoFocus: autoFocus,\n    whiteList: whiteList,\n    shards: shards,\n    onActivation: onActivation,\n    onDeactivation: onDeactivation,\n    returnFocus: returnFocus\n  }), /*#__PURE__*/React.createElement(Container, _extends({\n    ref: mergedRef\n  }, lockProps, {\n    className: className,\n    onBlur: onBlur,\n    onFocus: onFocus\n  }), children), hasTailingGuards && /*#__PURE__*/React.createElement(\"div\", {\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 0,\n    style: hiddenGuard\n  }));\n});\nFocusLock.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: node,\n  disabled: bool,\n  returnFocus: oneOfType([bool, object]),\n  noFocusGuards: bool,\n  allowTextSelection: bool,\n  autoFocus: bool,\n  persistentFocus: bool,\n  crossFrame: bool,\n  group: string,\n  className: string,\n  whiteList: func,\n  shards: arrayOf(any),\n  as: oneOfType([string, func, object]),\n  lockProps: object,\n  onActivation: func,\n  onDeactivation: func,\n  sideCar: any.isRequired\n} : {};\nFocusLock.defaultProps = {\n  children: undefined,\n  disabled: false,\n  returnFocus: false,\n  noFocusGuards: false,\n  autoFocus: true,\n  persistentFocus: false,\n  crossFrame: true,\n  allowTextSelection: undefined,\n  group: undefined,\n  className: undefined,\n  whiteList: undefined,\n  shards: undefined,\n  as: 'div',\n  lockProps: {},\n  onActivation: undefined,\n  onDeactivation: undefined\n};\nexport default FocusLock;","export var FOCUS_GROUP = 'data-focus-lock';\nexport var FOCUS_DISABLED = 'data-focus-lock-disabled';\nexport var FOCUS_ALLOW = 'data-no-focus-lock';\nexport var FOCUS_AUTO = 'data-autofocus-inside';","import FocusLockUI from './Lock';\nimport AutoFocusInside from './AutoFocusInside';\nimport MoveFocusInside, { useFocusInside } from './MoveFocusInside';\nimport FreeFocusInside from './FreeFocusInside';\nimport InFocusGuard from './FocusGuard';\nexport { AutoFocusInside, MoveFocusInside, FreeFocusInside, InFocusGuard, FocusLockUI, useFocusInside };\nexport default FocusLockUI;","import { createSidecarMedium } from 'use-sidecar';\nexport var effectCar = createSidecarMedium();\nexport var focusHiddenMarker = 'data-focus-on-hidden';\n","import * as tslib_1 from \"tslib\";\nimport * as React from 'react';\nimport { RemoveScroll } from 'react-remove-scroll/UI';\nimport ReactFocusLock from 'react-focus-lock/UI';\nimport { effectCar } from './medium';\nexport var FocusOn = React.forwardRef(function (props, parentRef) {\n    var _a = React.useState(false), lockProps = _a[0], setLockProps = _a[1];\n    var children = props.children, autoFocus = props.autoFocus, shards = props.shards, _b = props.enabled, enabled = _b === void 0 ? true : _b, _c = props.scrollLock, scrollLock = _c === void 0 ? true : _c, _d = props.focusLock, focusLock = _d === void 0 ? true : _d, _e = props.returnFocus, returnFocus = _e === void 0 ? true : _e, inert = props.inert, allowPinchZoom = props.allowPinchZoom, sideCar = props.sideCar, className = props.className, shouldIgnore = props.shouldIgnore, style = props.style, as = props.as, rest = tslib_1.__rest(props, [\"children\", \"autoFocus\", \"shards\", \"enabled\", \"scrollLock\", \"focusLock\", \"returnFocus\", \"inert\", \"allowPinchZoom\", \"sideCar\", \"className\", \"shouldIgnore\", \"style\", \"as\"]);\n    var SideCar = sideCar;\n    var onActivation = lockProps.onActivation, onDeactivation = lockProps.onDeactivation, restProps = tslib_1.__rest(lockProps, [\"onActivation\", \"onDeactivation\"]);\n    return (React.createElement(React.Fragment, null,\n        React.createElement(ReactFocusLock, { ref: parentRef, sideCar: sideCar, disabled: !(lockProps && enabled && focusLock), returnFocus: returnFocus, autoFocus: autoFocus, shards: shards, onActivation: onActivation, onDeactivation: onDeactivation, className: className, as: RemoveScroll, whiteList: shouldIgnore, lockProps: tslib_1.__assign({}, restProps, { sideCar: sideCar,\n                shards: shards,\n                allowPinchZoom: allowPinchZoom,\n                as: as,\n                inert: inert,\n                style: style, enabled: enabled && scrollLock }) }, children),\n        enabled && (React.createElement(SideCar, tslib_1.__assign({}, rest, { sideCar: effectCar, setLockProps: setLockProps, shards: shards })))));\n});\nexport * from './reExports';\n","import * as tslib_1 from \"tslib\";\nimport * as React from 'react';\nvar SideCar = function (_a) {\n    var sideCar = _a.sideCar, rest = tslib_1.__rest(_a, [\"sideCar\"]);\n    if (!sideCar) {\n        throw new Error('Sidecar: please provide `sideCar` property to import the right car');\n    }\n    var Target = sideCar.read();\n    if (!Target) {\n        throw new Error('Sidecar medium not found');\n    }\n    return React.createElement(Target, tslib_1.__assign({}, rest));\n};\nSideCar.isSideCarExport = true;\nexport function exportSidecar(medium, exported) {\n    medium.useMedium(exported);\n    return SideCar;\n}\n","import _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport _defineProperty from '@babel/runtime/helpers/esm/defineProperty';\nimport React, { PureComponent } from 'react';\n\nfunction withSideEffect(reducePropsToState, handleStateChangeOnClient) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (typeof reducePropsToState !== 'function') {\n      throw new Error('Expected reducePropsToState to be a function.');\n    }\n\n    if (typeof handleStateChangeOnClient !== 'function') {\n      throw new Error('Expected handleStateChangeOnClient to be a function.');\n    }\n  }\n\n  function getDisplayName(WrappedComponent) {\n    return WrappedComponent.displayName || WrappedComponent.name || 'Component';\n  }\n\n  return function wrap(WrappedComponent) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (typeof WrappedComponent !== 'function') {\n        throw new Error('Expected WrappedComponent to be a React component.');\n      }\n    }\n\n    var mountedInstances = [];\n    var state;\n\n    function emitChange() {\n      state = reducePropsToState(mountedInstances.map(function (instance) {\n        return instance.props;\n      }));\n      handleStateChangeOnClient(state);\n    }\n\n    var SideEffect =\n    /*#__PURE__*/\n    function (_PureComponent) {\n      _inheritsLoose(SideEffect, _PureComponent);\n\n      function SideEffect() {\n        return _PureComponent.apply(this, arguments) || this;\n      }\n\n      // Try to use displayName of wrapped component\n      SideEffect.peek = function peek() {\n        return state;\n      };\n\n      var _proto = SideEffect.prototype;\n\n      _proto.componentDidMount = function componentDidMount() {\n        mountedInstances.push(this);\n        emitChange();\n      };\n\n      _proto.componentDidUpdate = function componentDidUpdate() {\n        emitChange();\n      };\n\n      _proto.componentWillUnmount = function componentWillUnmount() {\n        var index = mountedInstances.indexOf(this);\n        mountedInstances.splice(index, 1);\n        emitChange();\n      };\n\n      _proto.render = function render() {\n        return React.createElement(WrappedComponent, this.props);\n      };\n\n      return SideEffect;\n    }(PureComponent);\n\n    _defineProperty(SideEffect, \"displayName\", \"SideEffect(\" + getDisplayName(WrappedComponent) + \")\");\n\n    return SideEffect;\n  };\n}\n\nexport default withSideEffect;\n","export default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\n}","export var toArray = function toArray(a) {\n  var ret = Array(a.length);\n  for (var i = 0; i < a.length; ++i) {\n    ret[i] = a[i];\n  }\n  return ret;\n};\n\nexport var arrayFind = function arrayFind(array, search) {\n  return array.filter(function (a) {\n    return a === search;\n  })[0];\n};\n\nexport var asArray = function asArray(a) {\n  return Array.isArray(a) ? a : [a];\n};","import { toArray } from './utils/array';\nimport { FOCUS_ALLOW } from './constants';\n\nvar focusIsHidden = function focusIsHidden() {\n  return document && toArray(document.querySelectorAll('[' + FOCUS_ALLOW + ']')).some(function (node) {\n    return node.contains(document.activeElement);\n  });\n};\n\nexport default focusIsHidden;","var _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nimport { FOCUS_DISABLED, FOCUS_GROUP } from '../constants';\nimport { asArray, toArray } from './array';\n\nvar filterNested = function filterNested(nodes) {\n  var l = nodes.length;\n  for (var i = 0; i < l; i += 1) {\n    var _loop = function _loop(j) {\n      if (i !== j) {\n        if (nodes[i].contains(nodes[j])) {\n          return {\n            v: filterNested(nodes.filter(function (x) {\n              return x !== nodes[j];\n            }))\n          };\n        }\n      }\n    };\n\n    for (var j = 0; j < l; j += 1) {\n      var _ret = _loop(j);\n\n      if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === \"object\") return _ret.v;\n    }\n  }\n  return nodes;\n};\n\nvar getTopParent = function getTopParent(node) {\n  return node.parentNode ? getTopParent(node.parentNode) : node;\n};\n\nvar getAllAffectedNodes = function getAllAffectedNodes(node) {\n  var nodes = asArray(node);\n  return nodes.filter(Boolean).reduce(function (acc, currentNode) {\n    var group = currentNode.getAttribute(FOCUS_GROUP);\n    acc.push.apply(acc, group ? filterNested(toArray(getTopParent(currentNode).querySelectorAll('[' + FOCUS_GROUP + '=\"' + group + '\"]:not([' + FOCUS_DISABLED + '=\"disabled\"])'))) : [currentNode]);\n    return acc;\n  }, []);\n};\n\nexport default getAllAffectedNodes;","import getAllAffectedNodes from './utils/all-affected';\nimport { arrayFind, toArray } from './utils/array';\n\nvar focusInFrame = function focusInFrame(frame) {\n  return frame === document.activeElement;\n};\n\nvar focusInsideIframe = function focusInsideIframe(topNode) {\n  return !!arrayFind(toArray(topNode.querySelectorAll('iframe')), focusInFrame);\n};\n\nvar focusInside = function focusInside(topNode) {\n  var activeElement = document && document.activeElement;\n\n  if (!activeElement || activeElement.dataset && activeElement.dataset.focusGuard) {\n    return false;\n  }\n  return getAllAffectedNodes(topNode).reduce(function (result, node) {\n    return result || node.contains(activeElement) || focusInsideIframe(node);\n  }, false);\n};\n\nexport default focusInside;","import { toArray } from './array';\n\nexport var tabSort = function tabSort(a, b) {\n  var tabDiff = a.tabIndex - b.tabIndex;\n  var indexDiff = a.index - b.index;\n\n  if (tabDiff) {\n    if (!a.tabIndex) return 1;\n    if (!b.tabIndex) return -1;\n  }\n\n  return tabDiff || indexDiff;\n};\n\nexport var orderByTabIndex = function orderByTabIndex(nodes, filterNegative, keepGuards) {\n  return toArray(nodes).map(function (node, index) {\n    return {\n      node: node,\n      index: index,\n      tabIndex: keepGuards && node.tabIndex === -1 ? (node.dataset || {}).focusGuard ? 0 : -1 : node.tabIndex\n    };\n  }).filter(function (data) {\n    return !filterNegative || data.tabIndex >= 0;\n  }).sort(tabSort);\n};","export default ['button:enabled:not([readonly])', 'select:enabled:not([readonly])', 'textarea:enabled:not([readonly])', 'input:enabled:not([readonly])', 'a[href]', 'area[href]', 'iframe', 'object', 'embed', '[tabindex]', '[contenteditable]', '[autofocus]'];","import tabbables from './tabbables';\nimport { toArray } from './array';\nimport { FOCUS_AUTO } from '../constants';\n\nvar queryTabbables = tabbables.join(',');\nvar queryGuardTabbables = queryTabbables + ', [data-focus-guard]';\n\nexport var getFocusables = function getFocusables(parents, withGuards) {\n  return parents.reduce(function (acc, parent) {\n    return acc.concat(\n    // add all tabbables inside\n    toArray(parent.querySelectorAll(withGuards ? queryGuardTabbables : queryTabbables)),\n    // add if node is tabble itself\n    parent.parentNode ? toArray(parent.parentNode.querySelectorAll(tabbables.join(','))).filter(function (node) {\n      return node === parent;\n    }) : []);\n  }, []);\n};\n\nexport var getParentAutofocusables = function getParentAutofocusables(parent) {\n  var parentFocus = parent.querySelectorAll('[' + FOCUS_AUTO + ']');\n  return toArray(parentFocus).map(function (node) {\n    return getFocusables([node]);\n  }).reduce(function (acc, nodes) {\n    return acc.concat(nodes);\n  }, []);\n};","import { orderByTabIndex } from './tabOrder';\nimport { getFocusables, getParentAutofocusables } from './tabUtils';\nimport { toArray } from './array';\n\nvar isElementHidden = function isElementHidden(computedStyle) {\n  if (!computedStyle || !computedStyle.getPropertyValue) {\n    return false;\n  }\n  return computedStyle.getPropertyValue('display') === 'none' || computedStyle.getPropertyValue('visibility') === 'hidden';\n};\n\nexport var isVisible = function isVisible(node) {\n  return !node || node === document || node.nodeType === Node.DOCUMENT_NODE || !isElementHidden(window.getComputedStyle(node, null)) && isVisible(node.parentNode && node.parentNode.nodeType === node.DOCUMENT_FRAGMENT_NODE ? node.parentNode.host : node.parentNode);\n};\n\nexport var notHiddenInput = function notHiddenInput(node) {\n  return !((node.tagName === 'INPUT' || node.tagName === 'BUTTON') && (node.type === 'hidden' || node.disabled));\n};\n\nvar getParents = function getParents(node) {\n  var parents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n\n  parents.push(node);\n  if (node.parentNode) {\n    getParents(node.parentNode, parents);\n  }\n  return parents;\n};\n\nexport var getCommonParent = function getCommonParent(nodea, nodeb) {\n  var parentsA = getParents(nodea);\n  var parentsB = getParents(nodeb);\n\n  for (var i = 0; i < parentsA.length; i += 1) {\n    var currentParent = parentsA[i];\n    if (parentsB.indexOf(currentParent) >= 0) {\n      return currentParent;\n    }\n  }\n  return false;\n};\n\nexport var filterFocusable = function filterFocusable(nodes) {\n  return toArray(nodes).filter(function (node) {\n    return isVisible(node);\n  }).filter(function (node) {\n    return notHiddenInput(node);\n  });\n};\n\nexport var getTabbableNodes = function getTabbableNodes(topNodes, withGuards) {\n  return orderByTabIndex(filterFocusable(getFocusables(topNodes, withGuards)), true, withGuards);\n};\n\n/**\n * actually anything focusable\n */\nexport var getAllTabbableNodes = function getAllTabbableNodes(topNodes) {\n  return orderByTabIndex(filterFocusable(getFocusables(topNodes)), false);\n};\n\nexport var parentAutofocusables = function parentAutofocusables(topNode) {\n  return filterFocusable(getParentAutofocusables(topNode));\n};","var isRadio = function isRadio(node) {\n  return node.tagName === 'INPUT' && node.type === 'radio';\n};\n\nvar findSelectedRadio = function findSelectedRadio(node, nodes) {\n  return nodes.filter(isRadio).filter(function (el) {\n    return el.name === node.name;\n  }).filter(function (el) {\n    return el.checked;\n  })[0] || node;\n};\n\nexport var correctNode = function correctNode(node, nodes) {\n  if (isRadio(node) && node.name) {\n    return findSelectedRadio(node, nodes);\n  }\n  return node;\n};\n\nexport var correctNodes = function correctNodes(nodes) {\n  // IE11 has no Set constructor\n  var resultSet = new Set();\n  nodes.forEach(function (node) {\n    return resultSet.add(correctNode(node, nodes));\n  });\n  // using filter to support IE11\n  return nodes.filter(function (node) {\n    return resultSet.has(node);\n  });\n};","import { correctNode } from './correctFocus';\n\nvar pickFirstFocus = function pickFirstFocus(nodes) {\n  if (nodes[0] && nodes.length > 1) {\n    return correctNode(nodes[0], nodes);\n  }\n  return nodes[0];\n};\n\nexport var pickFocusable = function pickFocusable(nodes, index) {\n  if (nodes.length > 1) {\n    return nodes.indexOf(correctNode(nodes[index], nodes));\n  }\n  return index;\n};\n\nexport default pickFirstFocus;","import { getCommonParent, getTabbableNodes, getAllTabbableNodes, parentAutofocusables } from './utils/DOMutils';\nimport pickFirstFocus, { pickFocusable } from './utils/firstFocus';\nimport getAllAffectedNodes from './utils/all-affected';\nimport { asArray } from './utils/array';\nimport { correctNodes } from './utils/correctFocus';\n\nvar findAutoFocused = function findAutoFocused(autoFocusables) {\n  return function (node) {\n    return !!node.autofocus || node.dataset && !!node.dataset.autofocus || autoFocusables.indexOf(node) >= 0;\n  };\n};\n\nvar isGuard = function isGuard(node) {\n  return node && node.dataset && node.dataset.focusGuard;\n};\nvar notAGuard = function notAGuard(node) {\n  return !isGuard(node);\n};\n\nexport var NEW_FOCUS = 'NEW_FOCUS';\n\nexport var newFocus = function newFocus(innerNodes, outerNodes, activeElement, lastNode) {\n  var cnt = innerNodes.length;\n  var firstFocus = innerNodes[0];\n  var lastFocus = innerNodes[cnt - 1];\n  var isOnGuard = isGuard(activeElement);\n\n  // focus is inside\n  if (innerNodes.indexOf(activeElement) >= 0) {\n    return undefined;\n  }\n\n  var activeIndex = outerNodes.indexOf(activeElement);\n  var lastIndex = outerNodes.indexOf(lastNode || activeIndex);\n  var lastNodeInside = innerNodes.indexOf(lastNode);\n  var indexDiff = activeIndex - lastIndex;\n  var firstNodeIndex = outerNodes.indexOf(firstFocus);\n  var lastNodeIndex = outerNodes.indexOf(lastFocus);\n\n  var correctedNodes = correctNodes(outerNodes);\n  var correctedIndexDiff = correctedNodes.indexOf(activeElement) - correctedNodes.indexOf(lastNode || activeIndex);\n\n  var returnFirstNode = pickFocusable(innerNodes, 0);\n  var returnLastNode = pickFocusable(innerNodes, cnt - 1);\n\n  // new focus\n  if (activeIndex === -1 || lastNodeInside === -1) {\n    return NEW_FOCUS;\n  }\n  // old focus\n  if (!indexDiff && lastNodeInside >= 0) {\n    return lastNodeInside;\n  }\n  // first element\n  if (activeIndex <= firstNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {\n    return returnLastNode;\n  }\n  // last element\n  if (activeIndex >= lastNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {\n    return returnFirstNode;\n  }\n  // jump out, but not on the guard\n  if (indexDiff && Math.abs(correctedIndexDiff) > 1) {\n    return lastNodeInside;\n  }\n  // focus above lock\n  if (activeIndex <= firstNodeIndex) {\n    return returnLastNode;\n  }\n  // focus below lock\n  if (activeIndex > lastNodeIndex) {\n    return returnFirstNode;\n  }\n  // index is inside tab order, but outside Lock\n  if (indexDiff) {\n    if (Math.abs(indexDiff) > 1) {\n      return lastNodeInside;\n    }\n    return (cnt + lastNodeInside + indexDiff) % cnt;\n  }\n  // do nothing\n  return undefined;\n};\n\nvar getTopCommonParent = function getTopCommonParent(baseActiveElement, leftEntry, rightEntries) {\n  var activeElements = asArray(baseActiveElement);\n  var leftEntries = asArray(leftEntry);\n  var activeElement = activeElements[0];\n  var topCommon = null;\n  leftEntries.filter(Boolean).forEach(function (entry) {\n    topCommon = getCommonParent(topCommon || entry, entry) || topCommon;\n    rightEntries.filter(Boolean).forEach(function (subEntry) {\n      var common = getCommonParent(activeElement, subEntry);\n      if (common) {\n        if (!topCommon || common.contains(topCommon)) {\n          topCommon = common;\n        } else {\n          topCommon = getCommonParent(common, topCommon);\n        }\n      }\n    });\n  });\n  return topCommon;\n};\n\nvar allParentAutofocusables = function allParentAutofocusables(entries) {\n  return entries.reduce(function (acc, node) {\n    return acc.concat(parentAutofocusables(node));\n  }, []);\n};\n\nvar reorderNodes = function reorderNodes(srcNodes, dstNodes) {\n  var remap = new Map();\n  // no Set(dstNodes) for IE11 :(\n  dstNodes.forEach(function (entity) {\n    return remap.set(entity.node, entity);\n  });\n  // remap to dstNodes\n  return srcNodes.map(function (node) {\n    return remap.get(node);\n  }).filter(Boolean);\n};\n\nexport var getFocusabledIn = function getFocusabledIn(topNode) {\n  var entries = getAllAffectedNodes(topNode).filter(notAGuard);\n  var commonParent = getTopCommonParent(topNode, topNode, entries);\n  var outerNodes = getTabbableNodes([commonParent], true);\n  var innerElements = getTabbableNodes(entries).filter(function (_ref) {\n    var node = _ref.node;\n    return notAGuard(node);\n  }).map(function (_ref2) {\n    var node = _ref2.node;\n    return node;\n  });\n\n  return outerNodes.map(function (_ref3) {\n    var node = _ref3.node,\n        index = _ref3.index;\n    return {\n      node: node,\n      index: index,\n      lockItem: innerElements.indexOf(node) >= 0,\n      guard: isGuard(node)\n    };\n  });\n};\n\nvar getFocusMerge = function getFocusMerge(topNode, lastNode) {\n  var activeElement = document && document.activeElement;\n  var entries = getAllAffectedNodes(topNode).filter(notAGuard);\n\n  var commonParent = getTopCommonParent(activeElement || topNode, topNode, entries);\n\n  var anyFocusable = getAllTabbableNodes(entries);\n  var innerElements = getTabbableNodes(entries).filter(function (_ref4) {\n    var node = _ref4.node;\n    return notAGuard(node);\n  });\n\n  if (!innerElements[0]) {\n    innerElements = anyFocusable;\n    if (!innerElements[0]) {\n      return undefined;\n    }\n  }\n\n  var outerNodes = getAllTabbableNodes([commonParent]).map(function (_ref5) {\n    var node = _ref5.node;\n    return node;\n  });\n  var orderedInnerElements = reorderNodes(outerNodes, innerElements);\n  var innerNodes = orderedInnerElements.map(function (_ref6) {\n    var node = _ref6.node;\n    return node;\n  });\n\n  var newId = newFocus(innerNodes, outerNodes, activeElement, lastNode);\n\n  if (newId === \"NEW_FOCUS\") {\n    var autoFocusable = anyFocusable.map(function (_ref7) {\n      var node = _ref7.node;\n      return node;\n    }).filter(findAutoFocused(allParentAutofocusables(entries)));\n\n    return {\n      node: autoFocusable && autoFocusable.length ? pickFirstFocus(autoFocusable) : pickFirstFocus(innerNodes)\n    };\n  }\n\n  if (newId === undefined) {\n    return newId;\n  }\n  return orderedInnerElements[newId];\n};\n\nexport default getFocusMerge;","import getFocusMerge from './focusMerge';\n\nexport var focusOn = function focusOn(target) {\n  target.focus();\n  if (target.contentWindow) {\n    target.contentWindow.focus();\n  }\n};\n\nvar guardCount = 0;\nvar lockDisabled = false;\n\nexport default (function (topNode, lastNode) {\n  var focusable = getFocusMerge(topNode, lastNode);\n\n  if (lockDisabled) {\n    return;\n  }\n\n  if (focusable) {\n    if (guardCount > 2) {\n      // eslint-disable-next-line no-console\n      console.error('FocusLock: focus-fighting detected. Only one focus management system could be active. ' + 'See https://github.com/theKashey/focus-lock/#focus-fighting');\n      lockDisabled = true;\n      setTimeout(function () {\n        lockDisabled = false;\n      }, 1);\n      return;\n    }\n    guardCount++;\n    focusOn(focusable.node);\n    guardCount--;\n  }\n});","import tabHook from './tabHook';\nimport focusMerge, { getFocusabledIn } from './focusMerge';\nimport focusInside from './focusInside';\nimport focusIsHidden from './focusIsHidden';\nimport setFocus from './setFocus';\nimport * as constants from './constants';\nimport getAllAffectedNodes from './utils/all-affected';\n\nexport { tabHook, focusInside, focusIsHidden, focusMerge, getFocusabledIn, constants, getAllAffectedNodes };\n\nexport default setFocus;","export function deferAction(action) {\n  // Hidding setImmediate from Webpack to avoid inserting polyfill\n  var _window = window,\n      setImmediate = _window.setImmediate;\n\n  if (typeof setImmediate !== 'undefined') {\n    setImmediate(action);\n  } else {\n    setTimeout(action, 1);\n  }\n}\nexport var inlineProp = function inlineProp(name, value) {\n  var obj = {};\n  obj[name] = value;\n  return obj;\n};","import * as React from 'react';\nimport PropTypes from 'prop-types';\nimport withSideEffect from 'react-clientside-effect';\nimport moveFocusInside, { focusInside, focusIsHidden, getFocusabledIn } from 'focus-lock';\nimport { deferAction } from './util';\nimport { mediumFocus, mediumBlur, mediumEffect } from './medium';\n\nvar focusOnBody = function focusOnBody() {\n  return document && document.activeElement === document.body;\n};\n\nvar isFreeFocus = function isFreeFocus() {\n  return focusOnBody() || focusIsHidden();\n};\n\nvar lastActiveTrap = null;\nvar lastActiveFocus = null;\nvar lastPortaledElement = null;\nvar focusWasOutsideWindow = false;\n\nvar defaultWhitelist = function defaultWhitelist() {\n  return true;\n};\n\nvar focusWhitelisted = function focusWhitelisted(activeElement) {\n  return (lastActiveTrap.whiteList || defaultWhitelist)(activeElement);\n};\n\nvar recordPortal = function recordPortal(observerNode, portaledElement) {\n  lastPortaledElement = {\n    observerNode: observerNode,\n    portaledElement: portaledElement\n  };\n};\n\nvar focusIsPortaledPair = function focusIsPortaledPair(element) {\n  return lastPortaledElement && lastPortaledElement.portaledElement === element;\n};\n\nfunction autoGuard(startIndex, end, step, allNodes) {\n  var lastGuard = null;\n  var i = startIndex;\n\n  do {\n    var item = allNodes[i];\n\n    if (item.guard) {\n      if (item.node.dataset.focusAutoGuard) {\n        lastGuard = item;\n      }\n    } else if (item.lockItem) {\n      if (i !== startIndex) {\n        // we will tab to the next element\n        return;\n      }\n\n      lastGuard = null;\n    } else {\n      break;\n    }\n  } while ((i += step) !== end);\n\n  if (lastGuard) {\n    lastGuard.node.tabIndex = 0;\n  }\n}\n\nvar extractRef = function extractRef(ref) {\n  return ref && 'current' in ref ? ref.current : ref;\n};\n\nvar focusWasOutside = function focusWasOutside(crossFrameOption) {\n  if (crossFrameOption) {\n    // with cross frame return true for any value\n    return Boolean(focusWasOutsideWindow);\n  } // in other case return only of focus went a while aho\n\n\n  return focusWasOutsideWindow === 'meanwhile';\n};\n\nvar activateTrap = function activateTrap() {\n  var result = false;\n\n  if (lastActiveTrap) {\n    var _lastActiveTrap = lastActiveTrap,\n        observed = _lastActiveTrap.observed,\n        persistentFocus = _lastActiveTrap.persistentFocus,\n        autoFocus = _lastActiveTrap.autoFocus,\n        shards = _lastActiveTrap.shards,\n        crossFrame = _lastActiveTrap.crossFrame;\n    var workingNode = observed || lastPortaledElement && lastPortaledElement.portaledElement;\n    var activeElement = document && document.activeElement;\n\n    if (workingNode) {\n      var workingArea = [workingNode].concat(shards.map(extractRef).filter(Boolean));\n\n      if (!activeElement || focusWhitelisted(activeElement)) {\n        if (persistentFocus || focusWasOutside(crossFrame) || !isFreeFocus() || !lastActiveFocus && autoFocus) {\n          if (workingNode && !(focusInside(workingArea) || focusIsPortaledPair(activeElement, workingNode))) {\n            if (document && !lastActiveFocus && activeElement && !autoFocus) {\n              // Check if blur() exists, which is missing on certain elements on IE\n              if (activeElement.blur) {\n                activeElement.blur();\n              }\n\n              document.body.focus();\n            } else {\n              result = moveFocusInside(workingArea, lastActiveFocus);\n              lastPortaledElement = {};\n            }\n          }\n\n          focusWasOutsideWindow = false;\n          lastActiveFocus = document && document.activeElement;\n        }\n      }\n\n      if (document) {\n        var newActiveElement = document && document.activeElement;\n        var allNodes = getFocusabledIn(workingArea);\n        var focusedIndex = allNodes.map(function (_ref) {\n          var node = _ref.node;\n          return node;\n        }).indexOf(newActiveElement);\n\n        if (focusedIndex > -1) {\n          // remove old focus\n          allNodes.filter(function (_ref2) {\n            var guard = _ref2.guard,\n                node = _ref2.node;\n            return guard && node.dataset.focusAutoGuard;\n          }).forEach(function (_ref3) {\n            var node = _ref3.node;\n            return node.removeAttribute('tabIndex');\n          });\n          autoGuard(focusedIndex, allNodes.length, +1, allNodes);\n          autoGuard(focusedIndex, -1, -1, allNodes);\n        }\n      }\n    }\n  }\n\n  return result;\n};\n\nvar onTrap = function onTrap(event) {\n  if (activateTrap() && event) {\n    // prevent scroll jump\n    event.stopPropagation();\n    event.preventDefault();\n  }\n};\n\nvar onBlur = function onBlur() {\n  return deferAction(activateTrap);\n};\n\nvar onFocus = function onFocus(event) {\n  // detect portal\n  var source = event.target;\n  var currentNode = event.currentTarget;\n\n  if (!currentNode.contains(source)) {\n    recordPortal(currentNode, source);\n  }\n};\n\nvar FocusWatcher = function FocusWatcher() {\n  return null;\n};\n\nvar FocusTrap = function FocusTrap(_ref4) {\n  var children = _ref4.children;\n  return /*#__PURE__*/React.createElement(\"div\", {\n    onBlur: onBlur,\n    onFocus: onFocus\n  }, children);\n};\n\nFocusTrap.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: PropTypes.node.isRequired\n} : {};\n\nvar onWindowBlur = function onWindowBlur() {\n  focusWasOutsideWindow = 'just'; // using setTimeout to set  this variable after React/sidecar reaction\n\n  setTimeout(function () {\n    focusWasOutsideWindow = 'meanwhile';\n  }, 0);\n};\n\nvar attachHandler = function attachHandler() {\n  document.addEventListener('focusin', onTrap, true);\n  document.addEventListener('focusout', onBlur);\n  window.addEventListener('blur', onWindowBlur);\n};\n\nvar detachHandler = function detachHandler() {\n  document.removeEventListener('focusin', onTrap, true);\n  document.removeEventListener('focusout', onBlur);\n  window.removeEventListener('blur', onWindowBlur);\n};\n\nfunction reducePropsToState(propsList) {\n  return propsList.filter(function (_ref5) {\n    var disabled = _ref5.disabled;\n    return !disabled;\n  });\n}\n\nfunction handleStateChangeOnClient(traps) {\n  var trap = traps.slice(-1)[0];\n\n  if (trap && !lastActiveTrap) {\n    attachHandler();\n  }\n\n  var lastTrap = lastActiveTrap;\n  var sameTrap = lastTrap && trap && trap.id === lastTrap.id;\n  lastActiveTrap = trap;\n\n  if (lastTrap && !sameTrap) {\n    lastTrap.onDeactivation(); // return focus only of last trap was removed\n\n    if (!traps.filter(function (_ref6) {\n      var id = _ref6.id;\n      return id === lastTrap.id;\n    }).length) {\n      // allow defer is no other trap is awaiting restore\n      lastTrap.returnFocus(!trap);\n    }\n  }\n\n  if (trap) {\n    lastActiveFocus = null;\n\n    if (!sameTrap || lastTrap.observed !== trap.observed) {\n      trap.onActivation();\n    }\n\n    activateTrap(true);\n    deferAction(activateTrap);\n  } else {\n    detachHandler();\n    lastActiveFocus = null;\n  }\n} // bind medium\n\n\nmediumFocus.assignSyncMedium(onFocus);\nmediumBlur.assignMedium(onBlur);\nmediumEffect.assignMedium(function (cb) {\n  return cb({\n    moveFocusInside: moveFocusInside,\n    focusInside: focusInside\n  });\n});\nexport default withSideEffect(reducePropsToState, handleStateChangeOnClient)(FocusWatcher);","var currentNonce;\nexport var setNonce = function (nonce) {\n    currentNonce = nonce;\n};\nexport var getNonce = function () {\n    if (currentNonce) {\n        return currentNonce;\n    }\n    if (typeof __webpack_nonce__ !== 'undefined') {\n        return __webpack_nonce__;\n    }\n    return undefined;\n};\n","import { exportSidecar } from 'use-sidecar';\nimport FocusTrap from './Trap';\nimport { mediumSidecar } from './medium';\nexport default exportSidecar(mediumSidecar, FocusTrap);","import { getNonce } from \"get-nonce\";\nfunction makeStyleTag() {\n    if (!document)\n        return null;\n    var tag = document.createElement('style');\n    tag.type = 'text/css';\n    var nonce = getNonce();\n    if (nonce) {\n        tag.setAttribute('nonce', nonce);\n    }\n    return tag;\n}\nfunction injectStyles(tag, css) {\n    if (tag.styleSheet) {\n        tag.styleSheet.cssText = css;\n    }\n    else {\n        tag.appendChild(document.createTextNode(css));\n    }\n}\nfunction insertStyleTag(tag) {\n    var head = document.head || document.getElementsByTagName('head')[0];\n    head.appendChild(tag);\n}\nexport var stylesheetSingleton = function () {\n    var counter = 0;\n    var stylesheet = null;\n    return {\n        add: function (style) {\n            if (counter == 0) {\n                if (stylesheet = makeStyleTag()) {\n                    injectStyles(stylesheet, style);\n                    insertStyleTag(stylesheet);\n                }\n            }\n            counter++;\n        },\n        remove: function () {\n            counter--;\n            if (!counter && stylesheet) {\n                stylesheet.parentNode && stylesheet.parentNode.removeChild(stylesheet);\n                stylesheet = null;\n            }\n        }\n    };\n};\n","import { styleHookSingleton } from \"./hook\";\nexport var styleSingleton = function () {\n    var useStyle = styleHookSingleton();\n    var Sheet = function (_a) {\n        var styles = _a.styles;\n        useStyle(styles);\n        return null;\n    };\n    return Sheet;\n};\n","import * as React from 'react';\nimport { stylesheetSingleton } from \"./singleton\";\nexport var styleHookSingleton = function () {\n    var sheet = stylesheetSingleton();\n    return function (styles) {\n        React.useEffect(function () {\n            sheet.add(styles);\n            return function () {\n                sheet.remove();\n            };\n        }, []);\n    };\n};\n","export var zeroGap = {\n    left: 0,\n    top: 0,\n    right: 0,\n    gap: 0,\n};\nvar parse = function (x) { return parseInt(x || '', 10) || 0; };\nvar getOffset = function (gapMode) {\n    var cs = window.getComputedStyle(document.body);\n    var left = cs[gapMode === 'padding' ? 'paddingLeft' : 'marginLeft'];\n    var top = cs[gapMode === 'padding' ? 'paddingTop' : 'marginTop'];\n    var right = cs[gapMode === 'padding' ? 'paddingRight' : 'marginRight'];\n    return [\n        parse(left),\n        parse(top),\n        parse(right),\n    ];\n};\nexport var getGapWidth = function (gapMode) {\n    if (gapMode === void 0) { gapMode = 'margin'; }\n    if (typeof window === 'undefined') {\n        return zeroGap;\n    }\n    var offsets = getOffset(gapMode);\n    var documentWidth = document.documentElement.clientWidth;\n    var windowWidth = window.innerWidth;\n    return {\n        left: offsets[0],\n        top: offsets[1],\n        right: offsets[2],\n        gap: Math.max(0, windowWidth - documentWidth + offsets[2] - offsets[0]),\n    };\n};\n","import * as React from 'react';\nimport { styleSingleton } from 'react-style-singleton';\nimport { getGapWidth } from './utils';\nimport { fullWidthClassName, zeroRightClassName, noScrollbarsClassName } from \"./constants\";\nvar Style = styleSingleton();\nvar getStyles = function (_a, allowRelative, gapMode, important) {\n    var left = _a.left, top = _a.top, right = _a.right, gap = _a.gap;\n    if (gapMode === void 0) { gapMode = 'margin'; }\n    return \"\\n  .\" + noScrollbarsClassName + \" {\\n   overflow: hidden \" + important + \";\\n   padding-right: \" + gap + \"px \" + important + \";\\n  }\\n  body {\\n    overflow: hidden \" + important + \";\\n    \" + [\n        allowRelative && \"position: relative \" + important + \";\",\n        gapMode === 'margin' && \"\\n    padding-left: \" + left + \"px;\\n    padding-top: \" + top + \"px;\\n    padding-right: \" + right + \"px;\\n    margin-left:0;\\n    margin-top:0;\\n    margin-right: \" + gap + \"px \" + important + \";\\n    \",\n        gapMode === 'padding' && \"padding-right: \" + gap + \"px \" + important + \";\",\n    ].filter(Boolean).join('') + \"\\n  }\\n  \\n  .\" + zeroRightClassName + \" {\\n    right: \" + gap + \"px \" + important + \";\\n  }\\n  \\n  .\" + fullWidthClassName + \" {\\n    margin-right: \" + gap + \"px \" + important + \";\\n  }\\n  \\n  .\" + zeroRightClassName + \" .\" + zeroRightClassName + \" {\\n    right: 0 \" + important + \";\\n  }\\n  \\n  .\" + fullWidthClassName + \" .\" + fullWidthClassName + \" {\\n    margin-right: 0 \" + important + \";\\n  }\\n\";\n};\nexport var RemoveScrollBar = function (props) {\n    var _a = React.useState(getGapWidth(props.gapMode)), gap = _a[0], setGap = _a[1];\n    React.useEffect(function () {\n        setGap(getGapWidth(props.gapMode));\n    }, [props.gapMode]);\n    var noRelative = props.noRelative, noImportant = props.noImportant, _b = props.gapMode, gapMode = _b === void 0 ? 'margin' : _b;\n    return React.createElement(Style, { styles: getStyles(gap, !noRelative, gapMode, !noImportant ? \"!important\" : '') });\n};\n","var elementCouldBeVScrolled = function (node) {\n    var styles = window.getComputedStyle(node);\n    return (styles.overflowY !== 'hidden' && // not-not-scrollable\n        !(styles.overflowY === styles.overflowX && styles.overflowY === 'visible') // scrollable\n    );\n};\nvar elementCouldBeHScrolled = function (node) {\n    var styles = window.getComputedStyle(node);\n    return (styles.overflowX !== 'hidden' && // not-not-scrollable\n        !(styles.overflowY === styles.overflowX && styles.overflowX === 'visible') // scrollable\n    );\n};\nexport var locationCouldBeScrolled = function (axis, node) {\n    var current = node;\n    do {\n        var isScrollable = elementCouldBeScrolled(axis, current);\n        if (isScrollable) {\n            var _a = getScrollVariables(axis, current), s = _a[1], d = _a[2];\n            if (s > d) {\n                return true;\n            }\n        }\n        current = current.parentNode;\n    } while (current && current !== document.body);\n    return false;\n};\nvar getVScrollVariables = function (_a) {\n    var scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight, clientHeight = _a.clientHeight;\n    return [scrollTop, scrollHeight, clientHeight];\n};\nvar getHScrollVariables = function (_a) {\n    var scrollLeft = _a.scrollLeft, scrollWidth = _a.scrollWidth, clientWidth = _a.clientWidth;\n    return [scrollLeft, scrollWidth, clientWidth];\n};\nvar elementCouldBeScrolled = function (axis, node) {\n    return axis === 'v' ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node);\n};\nvar getScrollVariables = function (axis, node) {\n    return axis === 'v' ? getVScrollVariables(node) : getHScrollVariables(node);\n};\nexport var handleScroll = function (axis, endTarget, event, sourceDelta, noOverscroll) {\n    var delta = sourceDelta;\n    // find scrollable target\n    var target = event.target;\n    var targetInLock = endTarget.contains(target);\n    var shouldCancelScroll = false;\n    var isDeltaPositive = delta > 0;\n    var availableScroll = 0;\n    var availableScrollTop = 0;\n    do {\n        var _a = getScrollVariables(axis, target), position = _a[0], scroll_1 = _a[1], capacity = _a[2];\n        var elementScroll = scroll_1 - capacity - position;\n        if (position || elementScroll) {\n            if (elementCouldBeScrolled(axis, target)) {\n                availableScroll += elementScroll;\n                availableScrollTop += position;\n            }\n        }\n        target = target.parentNode;\n    } while (\n    // portaled content\n    (!targetInLock && target !== document.body) ||\n        // self content\n        (targetInLock && (endTarget.contains(target) || endTarget === target)));\n    if (isDeltaPositive &&\n        ((noOverscroll && availableScroll === 0) ||\n            (!noOverscroll && delta > availableScroll))) {\n        shouldCancelScroll = true;\n    }\n    else if (!isDeltaPositive &&\n        ((noOverscroll && availableScrollTop === 0) ||\n            (!noOverscroll && -delta > availableScrollTop))) {\n        shouldCancelScroll = true;\n    }\n    return shouldCancelScroll;\n};\n","var passiveSupported = false;\nif (typeof window !== 'undefined') {\n    try {\n        var options = Object.defineProperty({}, 'passive', {\n            get: function () {\n                passiveSupported = true;\n                return true;\n            }\n        });\n        window.addEventListener('test', options, options);\n        window.removeEventListener('test', options, options);\n    }\n    catch (err) {\n        passiveSupported = false;\n    }\n}\nexport var nonPassive = passiveSupported ? { passive: false } : false;\n","import * as React from 'react';\nimport { RemoveScrollBar } from 'react-remove-scroll-bar';\nimport { styleSingleton } from 'react-style-singleton';\nimport { handleScroll, locationCouldBeScrolled } from './handleScroll';\nimport { nonPassive } from './aggresiveCapture';\nexport var getTouchXY = function (event) {\n    return 'changedTouches' in event\n        ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY]\n        : [0, 0];\n};\nexport var getDeltaXY = function (event) { return [event.deltaX, event.deltaY]; };\nvar extractRef = function (ref) {\n    return ref && 'current' in ref ? ref.current : ref;\n};\nvar deltaCompare = function (x, y) {\n    return x[0] === y[0] && x[1] === y[1];\n};\nvar generateStyle = function (id) { return \"\\n  .block-interactivity-\" + id + \" {pointer-events: none;}\\n  .allow-interactivity-\" + id + \" {pointer-events: all;}\\n\"; };\nvar idCounter = 0;\nvar lockStack = [];\nexport function RemoveScrollSideCar(props) {\n    var shouldPreventQueue = React.useRef([]);\n    var touchStartRef = React.useRef([0, 0]);\n    var activeAxis = React.useRef();\n    var id = React.useState(idCounter++)[0];\n    var Style = React.useState(function () { return styleSingleton(); })[0];\n    var lastProps = React.useRef(props);\n    React.useEffect(function () {\n        lastProps.current = props;\n    }, [props]);\n    React.useEffect(function () {\n        if (props.inert) {\n            document.body.classList.add(\"block-interactivity-\" + id);\n            var allow_1 = [\n                props.lockRef.current\n            ].concat((props.shards || []).map(extractRef)).filter(Boolean);\n            allow_1.forEach(function (el) { return el.classList.add(\"allow-interactivity-\" + id); });\n            return function () {\n                document.body.classList.remove(\"block-interactivity-\" + id);\n                allow_1.forEach(function (el) {\n                    return el.classList.remove(\"allow-interactivity-\" + id);\n                });\n            };\n        }\n        return;\n    }, [props.inert, props.lockRef.current, props.shards]);\n    var shouldCancelEvent = React.useCallback(function (event, parent) {\n        if ('touches' in event && event.touches.length === 2) {\n            return !lastProps.current.allowPinchZoom;\n        }\n        var touch = getTouchXY(event);\n        var touchStart = touchStartRef.current;\n        var deltaX = 'deltaX' in event ? event.deltaX : touchStart[0] - touch[0];\n        var deltaY = 'deltaY' in event ? event.deltaY : touchStart[1] - touch[1];\n        var currentAxis;\n        var target = event.target;\n        var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? 'h' : 'v';\n        var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);\n        if (!canBeScrolledInMainDirection) {\n            return true;\n        }\n        if (canBeScrolledInMainDirection) {\n            currentAxis = moveDirection;\n        }\n        else {\n            currentAxis = moveDirection === 'v' ? 'h' : 'v';\n            canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);\n            // other axis might be not scrollable\n        }\n        if (!canBeScrolledInMainDirection) {\n            return false;\n        }\n        if (!activeAxis.current &&\n            'changedTouches' in event &&\n            (deltaX || deltaY)) {\n            activeAxis.current = currentAxis;\n        }\n        if (!currentAxis) {\n            return true;\n        }\n        var cancelingAxis = activeAxis.current || currentAxis;\n        return handleScroll(cancelingAxis, parent, event, cancelingAxis === 'h' ? deltaX : deltaY, true);\n    }, []);\n    var shouldPrevent = React.useCallback(function (_event) {\n        var event = _event;\n        if (!lockStack.length || lockStack[lockStack.length - 1] !== Style) {\n            // not the last active\n            return;\n        }\n        var delta = 'deltaY' in event ? getDeltaXY(event) : getTouchXY(event);\n        var sourceEvent = shouldPreventQueue.current.filter(function (e) {\n            return e.name === event.type &&\n                e.target === event.target &&\n                deltaCompare(e.delta, delta);\n        })[0];\n        // self event, and should be canceled\n        if (sourceEvent && sourceEvent.should) {\n            event.preventDefault();\n            return;\n        }\n        // outside or shard event\n        if (!sourceEvent) {\n            var shardNodes = (lastProps.current.shards || [])\n                .map(extractRef)\n                .filter(Boolean)\n                .filter(function (node) { return node.contains(event.target); });\n            var shouldStop = shardNodes.length > 0\n                ? shouldCancelEvent(event, shardNodes[0])\n                : !lastProps.current.noIsolation;\n            if (shouldStop) {\n                event.preventDefault();\n            }\n        }\n    }, []);\n    var shouldCancel = React.useCallback(function (name, delta, target, should) {\n        var event = { name: name, delta: delta, target: target, should: should };\n        shouldPreventQueue.current.push(event);\n        setTimeout(function () {\n            shouldPreventQueue.current = shouldPreventQueue.current.filter(function (e) { return e !== event; });\n        }, 1);\n    }, []);\n    var scrollTouchStart = React.useCallback(function (event) {\n        touchStartRef.current = getTouchXY(event);\n        activeAxis.current = undefined;\n    }, []);\n    var scrollWheel = React.useCallback(function (event) {\n        shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));\n    }, []);\n    var scrollTouchMove = React.useCallback(function (event) {\n        shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));\n    }, []);\n    React.useEffect(function () {\n        lockStack.push(Style);\n        props.setCallbacks({\n            onScrollCapture: scrollWheel,\n            onWheelCapture: scrollWheel,\n            onTouchMoveCapture: scrollTouchMove\n        });\n        document.addEventListener('wheel', shouldPrevent, nonPassive);\n        document.addEventListener('touchmove', shouldPrevent, nonPassive);\n        document.addEventListener('touchstart', scrollTouchStart, nonPassive);\n        return function () {\n            lockStack = lockStack.filter(function (inst) { return inst !== Style; });\n            document.removeEventListener('wheel', shouldPrevent, nonPassive);\n            document.removeEventListener('touchmove', shouldPrevent, nonPassive);\n            document.removeEventListener('touchstart', scrollTouchStart, nonPassive);\n        };\n    }, []);\n    var removeScrollBar = props.removeScrollBar, inert = props.inert;\n    return (React.createElement(React.Fragment, null,\n        inert ? React.createElement(Style, { styles: generateStyle(id) }) : null,\n        removeScrollBar ? React.createElement(RemoveScrollBar, { gapMode: \"margin\" }) : null));\n}\n","import { exportSidecar } from 'use-sidecar';\nimport { RemoveScrollSideCar } from './SideEffect';\nimport { effectCar } from './medium';\nexport default exportSidecar(effectCar, RemoveScrollSideCar);\n","var defaultParent = typeof document !== 'undefined' ? document.body : null;\nvar counterMap = new WeakMap();\nvar uncontrolledNodes = new WeakMap();\nvar markerMap = {};\nvar lockCount = 0;\nexport var hideOthers = function (originalTarget, parentNode, markerName) {\n    if (parentNode === void 0) { parentNode = defaultParent; }\n    if (markerName === void 0) { markerName = \"data-aria-hidden\"; }\n    var targets = Array.isArray(originalTarget) ? originalTarget : [originalTarget];\n    if (!markerMap[markerName]) {\n        markerMap[markerName] = new WeakMap();\n    }\n    var markerCounter = markerMap[markerName];\n    var hiddenNodes = [];\n    var deep = function (parent) {\n        if (!parent || targets.indexOf(parent) >= 0) {\n            return;\n        }\n        Array.prototype.forEach.call(parent.children, function (node) {\n            if (targets.some(function (target) { return node.contains(target); })) {\n                deep(node);\n            }\n            else {\n                var attr = node.getAttribute('aria-hidden');\n                var alreadyHidden = attr !== null && attr !== 'false';\n                var counterValue = (counterMap.get(node) || 0) + 1;\n                var markerValue = (markerCounter.get(node) || 0) + 1;\n                counterMap.set(node, counterValue);\n                markerCounter.set(node, markerValue);\n                hiddenNodes.push(node);\n                if (counterValue === 1 && alreadyHidden) {\n                    uncontrolledNodes.set(node, true);\n                }\n                if (markerValue === 1) {\n                    node.setAttribute(markerName, 'true');\n                }\n                if (!alreadyHidden) {\n                    node.setAttribute('aria-hidden', 'true');\n                }\n            }\n        });\n    };\n    deep(parentNode);\n    lockCount++;\n    return function () {\n        hiddenNodes.forEach(function (node) {\n            var counterValue = counterMap.get(node) - 1;\n            var markerValue = markerCounter.get(node) - 1;\n            counterMap.set(node, counterValue);\n            markerCounter.set(node, markerValue);\n            if (!counterValue) {\n                if (!uncontrolledNodes.has(node)) {\n                    node.removeAttribute('aria-hidden');\n                }\n                uncontrolledNodes.delete(node);\n            }\n            if (!markerValue) {\n                node.removeAttribute(markerName);\n            }\n        });\n        lockCount--;\n        if (!lockCount) {\n            counterMap = new WeakMap();\n            counterMap = new WeakMap();\n            uncontrolledNodes = new WeakMap();\n            markerMap = {};\n        }\n    };\n};\n","import * as React from 'react';\nimport { styleSingleton } from 'react-style-singleton';\nimport { focusHiddenMarker } from './medium';\nvar Style = styleSingleton();\nvar styles = \"\\n [\" + focusHiddenMarker + \"] {\\n   pointer-events: none !important;\\n }\\n\";\nexport var InteractivityDisabler = function () { return React.createElement(Style, { styles: styles }); };\n","import * as React from 'react';\nimport { hideOthers } from 'aria-hidden';\nimport { InteractivityDisabler } from './InteractivityDisabler';\nimport { focusHiddenMarker } from './medium';\nimport { useEffect, useRef, useState } from 'react';\nvar extractRef = function (ref) {\n    return 'current' in ref ? ref.current : ref;\n};\nexport function Effect(_a) {\n    var setLockProps = _a.setLockProps, onEscapeKey = _a.onEscapeKey, onClickOutside = _a.onClickOutside, shards = _a.shards, onActivation = _a.onActivation, onDeactivation = _a.onDeactivation, noIsolation = _a.noIsolation;\n    var _b = useState(undefined), activeNode = _b[0], setActiveNode = _b[1];\n    var lastEventTarget = useRef(null);\n    var mouseTouches = useRef(0);\n    React.useEffect(function () {\n        var onKeyDown = function (event) {\n            if (!event.defaultPrevented) {\n                if ((event.code === 'Escape' ||\n                    event.key === 'Escape' ||\n                    event.keyCode === 27) &&\n                    onEscapeKey) {\n                    onEscapeKey(event);\n                }\n            }\n        };\n        var onMouseDown = function (event) {\n            if (event.defaultPrevented ||\n                event.target === lastEventTarget.current ||\n                (event instanceof MouseEvent && event.button !== 0)) {\n                return;\n            }\n            if (shards &&\n                shards\n                    .map(extractRef)\n                    .some(function (node) {\n                    return (node && node.contains(event.target)) ||\n                        node === event.target;\n                })) {\n                return;\n            }\n            if (onClickOutside) {\n                onClickOutside(event);\n            }\n        };\n        var onTouchStart = function (event) {\n            onMouseDown(event);\n            mouseTouches.current = event.touches.length;\n        };\n        var onTouchEnd = function (event) {\n            mouseTouches.current = event.touches.length;\n        };\n        if (activeNode) {\n            document.addEventListener('keydown', onKeyDown);\n            document.addEventListener('mousedown', onMouseDown);\n            document.addEventListener('touchstart', onTouchStart);\n            document.addEventListener('touchend', onTouchEnd);\n            return function () {\n                document.removeEventListener('keydown', onKeyDown);\n                document.removeEventListener('mousedown', onMouseDown);\n                document.removeEventListener('touchstart', onTouchStart);\n                document.removeEventListener('touchend', onTouchEnd);\n            };\n        }\n    }, [activeNode, onClickOutside, onEscapeKey]);\n    useEffect(function () {\n        if (activeNode) {\n            if (onActivation) {\n                onActivation(activeNode);\n            }\n            return function () {\n                if (onDeactivation) {\n                    onDeactivation();\n                }\n            };\n        }\n    }, [!!activeNode]);\n    useEffect(function () {\n        var _undo = function () { return null; };\n        var unmounted = false;\n        var onNodeActivation = function (node) {\n            _undo = hideOthers([node].concat((shards || []).map(extractRef)), document.body, noIsolation ? undefined : focusHiddenMarker);\n            setActiveNode(function () { return node; });\n        };\n        var onNodeDeactivation = function () {\n            _undo();\n            if (!unmounted) {\n                setActiveNode(null);\n            }\n        };\n        setLockProps({\n            onMouseDown: function (e) {\n                lastEventTarget.current = e.target;\n            },\n            onTouchStart: function (e) {\n                lastEventTarget.current = e.target;\n            },\n            onActivation: onNodeActivation,\n            onDeactivation: onNodeDeactivation\n        });\n        return function () {\n            unmounted = true;\n            setLockProps(false);\n        };\n    }, []);\n    return React.createElement(InteractivityDisabler, null);\n}\n","import { exportSidecar } from 'use-sidecar';\nimport 'react-focus-lock/sidecar';\nimport 'react-remove-scroll/sidecar';\nimport { Effect } from './Effect';\nimport { effectCar } from './medium';\nexport default exportSidecar(effectCar, Effect);\n","import * as tslib_1 from \"tslib\";\nimport * as React from 'react';\nimport { FocusOn as ReactFocusOn } from './UI';\nimport SideCar from './sidecar';\nvar RequireSideCar = function (props) {\n    return React.createElement(SideCar, tslib_1.__assign({}, props));\n};\nexport var FocusOn = React.forwardRef(function (props, ref) { return React.createElement(ReactFocusOn, tslib_1.__assign({}, props, { ref: ref, sideCar: RequireSideCar })); });\n","import _extends from '@babel/runtime/helpers/esm/extends';\nimport _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';\nimport _objectSpread from '@babel/runtime/helpers/esm/objectSpread';\nimport _classCallCheck from '@babel/runtime/helpers/esm/classCallCheck';\nimport _createClass from '@babel/runtime/helpers/esm/createClass';\nimport _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';\nimport _inherits from '@babel/runtime/helpers/esm/inherits';\nimport _possibleConstructorReturn from '@babel/runtime/helpers/esm/possibleConstructorReturn';\nimport _getPrototypeOf from '@babel/runtime/helpers/esm/getPrototypeOf';\nimport _defineProperty from '@babel/runtime/helpers/esm/defineProperty';\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport { FocusOn } from 'react-focus-on';\nimport clsx from 'clsx';\nimport '../__generated__/styles/modal.css';\n\nvar styles = {\"ppvx_modal\":\"ppvx_modal___2-6-1\",\"ppvx_modal--overpanel\":\"ppvx_modal--overpanel___2-6-1\",\"ppvx_modal--sheet\":\"ppvx_modal--sheet___2-6-1\",\"ppvx_modal-backdrop\":\"ppvx_modal-backdrop___2-6-1\",\"ppvx_scrim\":\"ppvx_scrim___2-6-1\",\"ppvx_modal__contents\":\"ppvx_modal__contents___2-6-1\",\"ppvx_modal__contents--no-padding\":\"ppvx_modal__contents--no-padding___2-6-1\",\"ppvx_modal__contents--center\":\"ppvx_modal__contents--center___2-6-1\",\"ppvx_modal__screenreader\":\"ppvx_modal__screenreader___2-6-1\",\"ppvx_modal-header\":\"ppvx_modal-header___2-6-1\",\"ppvx_modal-header--gripper\":\"ppvx_modal-header--gripper___2-6-1\",\"ppvx_modal-header--divider\":\"ppvx_modal-header--divider___2-6-1\",\"ppvx_modal-header--scrolled\":\"ppvx_modal-header--scrolled___2-6-1\",\"ppvx_modal-header__action\":\"ppvx_modal-header__action___2-6-1\",\"ppvx_modal-header__title\":\"ppvx_modal-header__title___2-6-1\",\"ppvx_modal-header__close\":\"ppvx_modal-header__close___2-6-1\",\"ppvx_modal-header__close-btn\":\"ppvx_modal-header__close-btn___2-6-1\",\"ppvx_modal-content__title\":\"ppvx_modal-content__title___2-6-1\",\"ppvx_modal-header--no-logo\":\"ppvx_modal-header--no-logo___2-6-1\",\"ppvx_modal-footer\":\"ppvx_modal-footer___2-6-1\",\"ppvx_modal-footer--scrolled\":\"ppvx_modal-footer--scrolled___2-6-1\",\"ppvx_modal-footer--align_center\":\"ppvx_modal-footer--align_center___2-6-1\",\"ppvx_modal-footer--align_right\":\"ppvx_modal-footer--align_right___2-6-1\",\"ppvx_visible-only-in-context\":\"ppvx_visible-only-in-context___2-6-1\"};\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function () { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nvar uniqueId = function () {\n  return (Math.random() * 100000000).toFixed(0).toString();\n};\n\nvar Modal = /*#__PURE__*/function (_React$Component) {\n  _inherits(Modal, _React$Component);\n\n  var _super = _createSuper(Modal);\n\n  function Modal(props) {\n    var _this;\n\n    _classCallCheck(this, Modal);\n\n    _this = _super.call(this, props);\n\n    _defineProperty(_assertThisInitialized(_this), \"closeButton\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"contentRef\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"idBase\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"scrollChecker\", function () {\n      return _this.scrollCheck();\n    });\n\n    _this.closeButton = React.createRef();\n    _this.contentRef = React.createRef();\n    _this.idBase = props.id || uniqueId();\n    _this.state = {\n      isMounted: false,\n      headerScroll: false,\n      footerScroll: false\n    };\n    return _this;\n  }\n  /* istanbul ignore next */\n\n\n  _createClass(Modal, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      // eslint-disable-next-line react/no-did-mount-set-state\n      this.setState({\n        isMounted: true\n      });\n    } // jest has no way to test things like scrollTop or scrollHeight --BCC\n\n    /* istanbul ignore next */\n\n  }, {\n    key: \"scrollCheck\",\n    value: function scrollCheck() {\n      if (this.contentRef && this.contentRef.current) {\n        var contents = this.contentRef.current; // let needFocus = false\n\n        var newState = null;\n        var headerScroll = contents.scrollTop !== 0;\n\n        if (headerScroll !== this.state.headerScroll) {\n          newState = {\n            headerScroll: headerScroll\n          };\n        } // Footer is optional, may not be one to watch for!\n\n\n        if (this.props.footerContents) {\n          // Have we scrolled to the bottom\n          var footerScroll = contents.scrollTop + contents.offsetHeight !== contents.scrollHeight;\n\n          if (footerScroll !== this.state.footerScroll) {\n            newState = _objectSpread({}, newState || {}, {\n              footerScroll: footerScroll\n            });\n          }\n        }\n\n        if (newState) {\n          this.setState(newState);\n        }\n      }\n    }\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps) {\n      // We need to set the focus ONLY when the next state\n      // is open and the current state is not.\n      var shouldSetFocus = this.props.isOpen && !prevProps.isOpen;\n\n      if (this.props.isOpen) {\n        this.scrollCheck();\n      } // Skip this if rendering server-side\n\n      /* istanbul ignore next */\n\n\n      if (window && window.setTimeout) {\n        // HACK ALERT! react-on-focus fails at setting the focus\n        // if we are transitioning opacity. This causes the lightbox\n        // to set the focus on the close button but NOT indicate\n        // that fact to the user either visually or in the screen reader\n        // So I had to handle that case on a timeout --love, BCC\n        if (shouldSetFocus && this.props.isOpen && this.closeButton.current) {\n          // Store the close button as a local for the closure\n          var closeButton = this.closeButton.current;\n          window.setTimeout(function () {\n            /* istanbul ignore next */\n            closeButton.focus();\n          }, 100);\n        }\n      }\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _clsx3, _clsx4;\n\n      var _this$props = this.props,\n          children = _this$props.children,\n          onClose = _this$props.onClose,\n          className = _this$props.className,\n          _this$props$closeButt = _this$props.closeButtonLabel,\n          closeButtonLabel = _this$props$closeButt === void 0 ? 'close modal' : _this$props$closeButt,\n          isOpen = _this$props.isOpen,\n          hideLogo = _this$props.hideLogo,\n          hideTitle = _this$props.hideTitle,\n          title = _this$props.title,\n          _this$props$closeOnBa = _this$props.closeOnBackgroundClick,\n          closeOnBackgroundClick = _this$props$closeOnBa === void 0 ? true : _this$props$closeOnBa,\n          _this$props$action = _this$props.action,\n          action = _this$props$action === void 0 ? null : _this$props$action,\n          _this$props$footerCon = _this$props.footerContents,\n          footerContents = _this$props$footerCon === void 0 ? null : _this$props$footerCon,\n          footerAlign = _this$props.footerAlign,\n          overpanel = _this$props.overpanel,\n          center = _this$props.center,\n          containerRef = _this$props.containerRef,\n          headerClassName = _this$props.headerClassName,\n          contentClassName = _this$props.contentClassName,\n          footerClassName = _this$props.footerClassName,\n          rest = _objectWithoutProperties(_this$props, [\"children\", \"onClose\", \"className\", \"closeButtonLabel\", \"isOpen\", \"hideLogo\", \"hideTitle\", \"title\", \"closeOnBackgroundClick\", \"action\", \"footerContents\", \"footerAlign\", \"overpanel\", \"center\", \"containerRef\", \"headerClassName\", \"contentClassName\", \"footerClassName\"]);\n\n      var classes = clsx(styles.ppvx_modal, _defineProperty({}, styles['ppvx_modal--overpanel'], overpanel), className);\n      var contentClasses = clsx(styles.ppvx_modal__contents, _defineProperty({}, styles['ppvx_modal__contents--center'], center), contentClassName);\n      var ariaHidden = isOpen === true ? 'false' : 'true';\n      var closeButton = React.createElement(\"button\", {\n        className: styles['ppvx_modal-header__close-btn'],\n        \"aria-label\": closeButtonLabel,\n        \"aria-haspopup\": \"dialog\",\n        tabIndex: 0,\n        onClick: onClose,\n        ref: this.closeButton\n      });\n\n      var handleEscape = function (evt) {\n        evt.preventDefault();\n        onClose(evt);\n      };\n\n      var handleBackdropClick = function (evt) {\n        if (closeOnBackgroundClick) {\n          onClose(evt);\n        }\n      };\n\n      var titleId = \"header_\".concat(this.idBase);\n      var titleElement = null;\n      var ariaProps = {\n        role: 'dialog',\n        className: styles['ppvx_modal-backdrop'],\n        'aria-modal': 'true',\n        'aria-hidden': ariaHidden\n      };\n\n      if (hideTitle) {\n        // @ts-ignore\n        ariaProps['aria-label'] = title;\n      } else {\n        // @ts-ignore\n        ariaProps['aria-labelledby'] = titleId;\n        titleElement = React.createElement(\"h2\", {\n          id: titleId\n        }, title);\n      }\n\n      var footer = footerContents ? React.createElement(\"footer\", {\n        className: clsx(styles['ppvx_modal-footer'], (_clsx3 = {}, _defineProperty(_clsx3, styles['ppvx_modal-footer--scrolled'], this.state.footerScroll), _defineProperty(_clsx3, styles[\"ppvx_modal-footer--align_\".concat(footerAlign)], footerAlign), _clsx3), footerClassName)\n      }, footerContents) : null;\n      var contents = React.createElement(\"div\", ariaProps, isOpen && React.createElement(FocusOn, {\n        enabled: !!isOpen // @ts-ignore: onEscapeKey() wants an Event, but the rest of this code wants SyntheticEvent<>\n        ,\n        onEscapeKey: function onEscapeKey(evt) {\n          return handleEscape(evt);\n        },\n        onClickOutside: function onClickOutside() {\n          return handleBackdropClick();\n        }\n      }, React.createElement(\"article\", _extends({\n        className: classes\n      }, rest), React.createElement(\"header\", {\n        className: clsx(styles['ppvx_modal-header'], (_clsx4 = {}, _defineProperty(_clsx4, styles['ppvx_modal-header--no-logo'], hideLogo), _defineProperty(_clsx4, styles['ppvx_modal-header--scrolled'], this.state.headerScroll), _clsx4), headerClassName)\n      }, React.createElement(\"div\", {\n        className: styles['ppvx_modal-header__action']\n      }, action), React.createElement(\"div\", {\n        className: styles['ppvx_modal-header__close']\n      }, closeButton)), React.createElement(\"section\", {\n        className: contentClasses,\n        onScroll: this.scrollChecker,\n        ref: this.contentRef\n      }, titleElement, children), footer)));\n      var containerElm = containerRef && containerRef.current; // Delay createPortal until component is mounted to fix server side rendering\n\n      return this.state.isMounted && ReactDOM.createPortal(contents, containerElm || document.body);\n    }\n  }]);\n\n  return Modal;\n}(React.Component);\n\nexport { Modal };\n","// Generated by CoffeeScript 1.7.1\n(function() {\n  var getNanoSeconds, hrtime, loadTime;\n\n  if ((typeof performance !== \"undefined\" && performance !== null) && performance.now) {\n    module.exports = function() {\n      return performance.now();\n    };\n  } else if ((typeof process !== \"undefined\" && process !== null) && process.hrtime) {\n    module.exports = function() {\n      return (getNanoSeconds() - loadTime) / 1e6;\n    };\n    hrtime = process.hrtime;\n    getNanoSeconds = function() {\n      var hr;\n      hr = hrtime();\n      return hr[0] * 1e9 + hr[1];\n    };\n    loadTime = getNanoSeconds();\n  } else if (Date.now) {\n    module.exports = function() {\n      return Date.now() - loadTime;\n    };\n    loadTime = Date.now();\n  } else {\n    module.exports = function() {\n      return new Date().getTime() - loadTime;\n    };\n    loadTime = new Date().getTime();\n  }\n\n}).call(this);\n","var now = require('performance-now')\n  , root = typeof window === 'undefined' ? global : window\n  , vendors = ['moz', 'webkit']\n  , suffix = 'AnimationFrame'\n  , raf = root['request' + suffix]\n  , caf = root['cancel' + suffix] || root['cancelRequest' + suffix]\n\nfor(var i = 0; !raf && i < vendors.length; i++) {\n  raf = root[vendors[i] + 'Request' + suffix]\n  caf = root[vendors[i] + 'Cancel' + suffix]\n      || root[vendors[i] + 'CancelRequest' + suffix]\n}\n\n// Some versions of FF have rAF but not cAF\nif(!raf || !caf) {\n  var last = 0\n    , id = 0\n    , queue = []\n    , frameDuration = 1000 / 60\n\n  raf = function(callback) {\n    if(queue.length === 0) {\n      var _now = now()\n        , next = Math.max(0, frameDuration - (_now - last))\n      last = next + _now\n      setTimeout(function() {\n        var cp = queue.slice(0)\n        // Clear queue here to prevent\n        // callbacks from appending listeners\n        // to the current frame's queue\n        queue.length = 0\n        for(var i = 0; i < cp.length; i++) {\n          if(!cp[i].cancelled) {\n            try{\n              cp[i].callback(last)\n            } catch(e) {\n              setTimeout(function() { throw e }, 0)\n            }\n          }\n        }\n      }, Math.round(next))\n    }\n    queue.push({\n      handle: ++id,\n      callback: callback,\n      cancelled: false\n    })\n    return id\n  }\n\n  caf = function(handle) {\n    for(var i = 0; i < queue.length; i++) {\n      if(queue[i].handle === handle) {\n        queue[i].cancelled = true\n      }\n    }\n  }\n}\n\nmodule.exports = function(fn) {\n  // Wrap in a new function to prevent\n  // `cancel` potentially being assigned\n  // to the native rAF function\n  return raf.call(root, fn)\n}\nmodule.exports.cancel = function() {\n  caf.apply(root, arguments)\n}\nmodule.exports.polyfill = function(object) {\n  if (!object) {\n    object = root;\n  }\n  object.requestAnimationFrame = raf\n  object.cancelAnimationFrame = caf\n}\n","// Generated by CoffeeScript 1.12.2\n(function() {\n  var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;\n\n  if ((typeof performance !== \"undefined\" && performance !== null) && performance.now) {\n    module.exports = function() {\n      return performance.now();\n    };\n  } else if ((typeof process !== \"undefined\" && process !== null) && process.hrtime) {\n    module.exports = function() {\n      return (getNanoSeconds() - nodeLoadTime) / 1e6;\n    };\n    hrtime = process.hrtime;\n    getNanoSeconds = function() {\n      var hr;\n      hr = hrtime();\n      return hr[0] * 1e9 + hr[1];\n    };\n    moduleLoadTime = getNanoSeconds();\n    upTime = process.uptime() * 1e9;\n    nodeLoadTime = moduleLoadTime - upTime;\n  } else if (Date.now) {\n    module.exports = function() {\n      return Date.now() - loadTime;\n    };\n    loadTime = Date.now();\n  } else {\n    module.exports = function() {\n      return new Date().getTime() - loadTime;\n    };\n    loadTime = new Date().getTime();\n  }\n\n}).call(this);\n\n//# sourceMappingURL=performance-now.js.map\n","'use strict';\n\nexports.__esModule = true;\n\nvar _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\nvar _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\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _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; }\n\nvar _mapToZero = require('./mapToZero');\n\nvar _mapToZero2 = _interopRequireDefault(_mapToZero);\n\nvar _stripStyle = require('./stripStyle');\n\nvar _stripStyle2 = _interopRequireDefault(_stripStyle);\n\nvar _stepper3 = require('./stepper');\n\nvar _stepper4 = _interopRequireDefault(_stepper3);\n\nvar _mergeDiff = require('./mergeDiff');\n\nvar _mergeDiff2 = _interopRequireDefault(_mergeDiff);\n\nvar _performanceNow = require('performance-now');\n\nvar _performanceNow2 = _interopRequireDefault(_performanceNow);\n\nvar _raf = require('raf');\n\nvar _raf2 = _interopRequireDefault(_raf);\n\nvar _shouldStopAnimation = require('./shouldStopAnimation');\n\nvar _shouldStopAnimation2 = _interopRequireDefault(_shouldStopAnimation);\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar msPerFrame = 1000 / 60;\n\n// the children function & (potential) styles function asks as param an\n// Array<TransitionPlainStyle>, where each TransitionPlainStyle is of the format\n// {key: string, data?: any, style: PlainStyle}. However, the way we keep\n// internal states doesn't contain such a data structure (check the state and\n// TransitionMotionState). So when children function and others ask for such\n// data we need to generate them on the fly by combining mergedPropsStyles and\n// currentStyles/lastIdealStyles\nfunction rehydrateStyles(mergedPropsStyles, unreadPropStyles, plainStyles) {\n  // Copy the value to a `const` so that Flow understands that the const won't\n  // change and will be non-nullable in the callback below.\n  var cUnreadPropStyles = unreadPropStyles;\n  if (cUnreadPropStyles == null) {\n    return mergedPropsStyles.map(function (mergedPropsStyle, i) {\n      return {\n        key: mergedPropsStyle.key,\n        data: mergedPropsStyle.data,\n        style: plainStyles[i]\n      };\n    });\n  }\n  return mergedPropsStyles.map(function (mergedPropsStyle, i) {\n    for (var j = 0; j < cUnreadPropStyles.length; j++) {\n      if (cUnreadPropStyles[j].key === mergedPropsStyle.key) {\n        return {\n          key: cUnreadPropStyles[j].key,\n          data: cUnreadPropStyles[j].data,\n          style: plainStyles[i]\n        };\n      }\n    }\n    return { key: mergedPropsStyle.key, data: mergedPropsStyle.data, style: plainStyles[i] };\n  });\n}\n\nfunction shouldStopAnimationAll(currentStyles, destStyles, currentVelocities, mergedPropsStyles) {\n  if (mergedPropsStyles.length !== destStyles.length) {\n    return false;\n  }\n\n  for (var i = 0; i < mergedPropsStyles.length; i++) {\n    if (mergedPropsStyles[i].key !== destStyles[i].key) {\n      return false;\n    }\n  }\n\n  // we have the invariant that mergedPropsStyles and\n  // currentStyles/currentVelocities/last* are synced in terms of cells, see\n  // mergeAndSync comment for more info\n  for (var i = 0; i < mergedPropsStyles.length; i++) {\n    if (!_shouldStopAnimation2['default'](currentStyles[i], destStyles[i].style, currentVelocities[i])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n// core key merging logic\n\n// things to do: say previously merged style is {a, b}, dest style (prop) is {b,\n// c}, previous current (interpolating) style is {a, b}\n// **invariant**: current[i] corresponds to merged[i] in terms of key\n\n// steps:\n// turn merged style into {a?, b, c}\n//    add c, value of c is destStyles.c\n//    maybe remove a, aka call willLeave(a), then merged is either {b, c} or {a, b, c}\n// turn current (interpolating) style from {a, b} into {a?, b, c}\n//    maybe remove a\n//    certainly add c, value of c is willEnter(c)\n// loop over merged and construct new current\n// dest doesn't change, that's owner's\nfunction mergeAndSync(willEnter, willLeave, didLeave, oldMergedPropsStyles, destStyles, oldCurrentStyles, oldCurrentVelocities, oldLastIdealStyles, oldLastIdealVelocities) {\n  var newMergedPropsStyles = _mergeDiff2['default'](oldMergedPropsStyles, destStyles, function (oldIndex, oldMergedPropsStyle) {\n    var leavingStyle = willLeave(oldMergedPropsStyle);\n    if (leavingStyle == null) {\n      didLeave({ key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data });\n      return null;\n    }\n    if (_shouldStopAnimation2['default'](oldCurrentStyles[oldIndex], leavingStyle, oldCurrentVelocities[oldIndex])) {\n      didLeave({ key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data });\n      return null;\n    }\n    return { key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data, style: leavingStyle };\n  });\n\n  var newCurrentStyles = [];\n  var newCurrentVelocities = [];\n  var newLastIdealStyles = [];\n  var newLastIdealVelocities = [];\n  for (var i = 0; i < newMergedPropsStyles.length; i++) {\n    var newMergedPropsStyleCell = newMergedPropsStyles[i];\n    var foundOldIndex = null;\n    for (var j = 0; j < oldMergedPropsStyles.length; j++) {\n      if (oldMergedPropsStyles[j].key === newMergedPropsStyleCell.key) {\n        foundOldIndex = j;\n        break;\n      }\n    }\n    // TODO: key search code\n    if (foundOldIndex == null) {\n      var plainStyle = willEnter(newMergedPropsStyleCell);\n      newCurrentStyles[i] = plainStyle;\n      newLastIdealStyles[i] = plainStyle;\n\n      var velocity = _mapToZero2['default'](newMergedPropsStyleCell.style);\n      newCurrentVelocities[i] = velocity;\n      newLastIdealVelocities[i] = velocity;\n    } else {\n      newCurrentStyles[i] = oldCurrentStyles[foundOldIndex];\n      newLastIdealStyles[i] = oldLastIdealStyles[foundOldIndex];\n      newCurrentVelocities[i] = oldCurrentVelocities[foundOldIndex];\n      newLastIdealVelocities[i] = oldLastIdealVelocities[foundOldIndex];\n    }\n  }\n\n  return [newMergedPropsStyles, newCurrentStyles, newCurrentVelocities, newLastIdealStyles, newLastIdealVelocities];\n}\n\nvar TransitionMotion = (function (_React$Component) {\n  _inherits(TransitionMotion, _React$Component);\n\n  _createClass(TransitionMotion, null, [{\n    key: 'propTypes',\n    value: {\n      defaultStyles: _propTypes2['default'].arrayOf(_propTypes2['default'].shape({\n        key: _propTypes2['default'].string.isRequired,\n        data: _propTypes2['default'].any,\n        style: _propTypes2['default'].objectOf(_propTypes2['default'].number).isRequired\n      })),\n      styles: _propTypes2['default'].oneOfType([_propTypes2['default'].func, _propTypes2['default'].arrayOf(_propTypes2['default'].shape({\n        key: _propTypes2['default'].string.isRequired,\n        data: _propTypes2['default'].any,\n        style: _propTypes2['default'].objectOf(_propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].object])).isRequired\n      }))]).isRequired,\n      children: _propTypes2['default'].func.isRequired,\n      willEnter: _propTypes2['default'].func,\n      willLeave: _propTypes2['default'].func,\n      didLeave: _propTypes2['default'].func\n    },\n    enumerable: true\n  }, {\n    key: 'defaultProps',\n    value: {\n      willEnter: function willEnter(styleThatEntered) {\n        return _stripStyle2['default'](styleThatEntered.style);\n      },\n      // recall: returning null makes the current unmounting TransitionStyle\n      // disappear immediately\n      willLeave: function willLeave() {\n        return null;\n      },\n      didLeave: function didLeave() {}\n    },\n    enumerable: true\n  }]);\n\n  function TransitionMotion(props) {\n    var _this = this;\n\n    _classCallCheck(this, TransitionMotion);\n\n    _React$Component.call(this, props);\n    this.unmounting = false;\n    this.animationID = null;\n    this.prevTime = 0;\n    this.accumulatedTime = 0;\n    this.unreadPropStyles = null;\n\n    this.clearUnreadPropStyle = function (unreadPropStyles) {\n      var _mergeAndSync = mergeAndSync(_this.props.willEnter, _this.props.willLeave, _this.props.didLeave, _this.state.mergedPropsStyles, unreadPropStyles, _this.state.currentStyles, _this.state.currentVelocities, _this.state.lastIdealStyles, _this.state.lastIdealVelocities);\n\n      var mergedPropsStyles = _mergeAndSync[0];\n      var currentStyles = _mergeAndSync[1];\n      var currentVelocities = _mergeAndSync[2];\n      var lastIdealStyles = _mergeAndSync[3];\n      var lastIdealVelocities = _mergeAndSync[4];\n\n      for (var i = 0; i < unreadPropStyles.length; i++) {\n        var unreadPropStyle = unreadPropStyles[i].style;\n        var dirty = false;\n\n        for (var key in unreadPropStyle) {\n          if (!Object.prototype.hasOwnProperty.call(unreadPropStyle, key)) {\n            continue;\n          }\n\n          var styleValue = unreadPropStyle[key];\n          if (typeof styleValue === 'number') {\n            if (!dirty) {\n              dirty = true;\n              currentStyles[i] = _extends({}, currentStyles[i]);\n              currentVelocities[i] = _extends({}, currentVelocities[i]);\n              lastIdealStyles[i] = _extends({}, lastIdealStyles[i]);\n              lastIdealVelocities[i] = _extends({}, lastIdealVelocities[i]);\n              mergedPropsStyles[i] = {\n                key: mergedPropsStyles[i].key,\n                data: mergedPropsStyles[i].data,\n                style: _extends({}, mergedPropsStyles[i].style)\n              };\n            }\n            currentStyles[i][key] = styleValue;\n            currentVelocities[i][key] = 0;\n            lastIdealStyles[i][key] = styleValue;\n            lastIdealVelocities[i][key] = 0;\n            mergedPropsStyles[i].style[key] = styleValue;\n          }\n        }\n      }\n\n      // unlike the other 2 components, we can't detect staleness and optionally\n      // opt out of setState here. each style object's data might contain new\n      // stuff we're not/cannot compare\n      _this.setState({\n        currentStyles: currentStyles,\n        currentVelocities: currentVelocities,\n        mergedPropsStyles: mergedPropsStyles,\n        lastIdealStyles: lastIdealStyles,\n        lastIdealVelocities: lastIdealVelocities\n      });\n    };\n\n    this.startAnimationIfNecessary = function () {\n      if (_this.unmounting) {\n        return;\n      }\n\n      // TODO: when config is {a: 10} and dest is {a: 10} do we raf once and\n      // call cb? No, otherwise accidental parent rerender causes cb trigger\n      _this.animationID = _raf2['default'](function (timestamp) {\n        // https://github.com/chenglou/react-motion/pull/420\n        // > if execution passes the conditional if (this.unmounting), then\n        // executes async defaultRaf and after that component unmounts and after\n        // that the callback of defaultRaf is called, then setState will be called\n        // on unmounted component.\n        if (_this.unmounting) {\n          return;\n        }\n\n        var propStyles = _this.props.styles;\n        var destStyles = typeof propStyles === 'function' ? propStyles(rehydrateStyles(_this.state.mergedPropsStyles, _this.unreadPropStyles, _this.state.lastIdealStyles)) : propStyles;\n\n        // check if we need to animate in the first place\n        if (shouldStopAnimationAll(_this.state.currentStyles, destStyles, _this.state.currentVelocities, _this.state.mergedPropsStyles)) {\n          // no need to cancel animationID here; shouldn't have any in flight\n          _this.animationID = null;\n          _this.accumulatedTime = 0;\n          return;\n        }\n\n        var currentTime = timestamp || _performanceNow2['default']();\n        var timeDelta = currentTime - _this.prevTime;\n        _this.prevTime = currentTime;\n        _this.accumulatedTime = _this.accumulatedTime + timeDelta;\n        // more than 10 frames? prolly switched browser tab. Restart\n        if (_this.accumulatedTime > msPerFrame * 10) {\n          _this.accumulatedTime = 0;\n        }\n\n        if (_this.accumulatedTime === 0) {\n          // no need to cancel animationID here; shouldn't have any in flight\n          _this.animationID = null;\n          _this.startAnimationIfNecessary();\n          return;\n        }\n\n        var currentFrameCompletion = (_this.accumulatedTime - Math.floor(_this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame;\n        var framesToCatchUp = Math.floor(_this.accumulatedTime / msPerFrame);\n\n        var _mergeAndSync2 = mergeAndSync(_this.props.willEnter, _this.props.willLeave, _this.props.didLeave, _this.state.mergedPropsStyles, destStyles, _this.state.currentStyles, _this.state.currentVelocities, _this.state.lastIdealStyles, _this.state.lastIdealVelocities);\n\n        var newMergedPropsStyles = _mergeAndSync2[0];\n        var newCurrentStyles = _mergeAndSync2[1];\n        var newCurrentVelocities = _mergeAndSync2[2];\n        var newLastIdealStyles = _mergeAndSync2[3];\n        var newLastIdealVelocities = _mergeAndSync2[4];\n\n        for (var i = 0; i < newMergedPropsStyles.length; i++) {\n          var newMergedPropsStyle = newMergedPropsStyles[i].style;\n          var newCurrentStyle = {};\n          var newCurrentVelocity = {};\n          var newLastIdealStyle = {};\n          var newLastIdealVelocity = {};\n\n          for (var key in newMergedPropsStyle) {\n            if (!Object.prototype.hasOwnProperty.call(newMergedPropsStyle, key)) {\n              continue;\n            }\n\n            var styleValue = newMergedPropsStyle[key];\n            if (typeof styleValue === 'number') {\n              newCurrentStyle[key] = styleValue;\n              newCurrentVelocity[key] = 0;\n              newLastIdealStyle[key] = styleValue;\n              newLastIdealVelocity[key] = 0;\n            } else {\n              var newLastIdealStyleValue = newLastIdealStyles[i][key];\n              var newLastIdealVelocityValue = newLastIdealVelocities[i][key];\n              for (var j = 0; j < framesToCatchUp; j++) {\n                var _stepper = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision);\n\n                newLastIdealStyleValue = _stepper[0];\n                newLastIdealVelocityValue = _stepper[1];\n              }\n\n              var _stepper2 = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision);\n\n              var nextIdealX = _stepper2[0];\n              var nextIdealV = _stepper2[1];\n\n              newCurrentStyle[key] = newLastIdealStyleValue + (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion;\n              newCurrentVelocity[key] = newLastIdealVelocityValue + (nextIdealV - newLastIdealVelocityValue) * currentFrameCompletion;\n              newLastIdealStyle[key] = newLastIdealStyleValue;\n              newLastIdealVelocity[key] = newLastIdealVelocityValue;\n            }\n          }\n\n          newLastIdealStyles[i] = newLastIdealStyle;\n          newLastIdealVelocities[i] = newLastIdealVelocity;\n          newCurrentStyles[i] = newCurrentStyle;\n          newCurrentVelocities[i] = newCurrentVelocity;\n        }\n\n        _this.animationID = null;\n        // the amount we're looped over above\n        _this.accumulatedTime -= framesToCatchUp * msPerFrame;\n\n        _this.setState({\n          currentStyles: newCurrentStyles,\n          currentVelocities: newCurrentVelocities,\n          lastIdealStyles: newLastIdealStyles,\n          lastIdealVelocities: newLastIdealVelocities,\n          mergedPropsStyles: newMergedPropsStyles\n        });\n\n        _this.unreadPropStyles = null;\n\n        _this.startAnimationIfNecessary();\n      });\n    };\n\n    this.state = this.defaultState();\n  }\n\n  TransitionMotion.prototype.defaultState = function defaultState() {\n    var _props = this.props;\n    var defaultStyles = _props.defaultStyles;\n    var styles = _props.styles;\n    var willEnter = _props.willEnter;\n    var willLeave = _props.willLeave;\n    var didLeave = _props.didLeave;\n\n    var destStyles = typeof styles === 'function' ? styles(defaultStyles) : styles;\n\n    // this is special. for the first time around, we don't have a comparison\n    // between last (no last) and current merged props. we'll compute last so:\n    // say default is {a, b} and styles (dest style) is {b, c}, we'll\n    // fabricate last as {a, b}\n    var oldMergedPropsStyles = undefined;\n    if (defaultStyles == null) {\n      oldMergedPropsStyles = destStyles;\n    } else {\n      oldMergedPropsStyles = defaultStyles.map(function (defaultStyleCell) {\n        // TODO: key search code\n        for (var i = 0; i < destStyles.length; i++) {\n          if (destStyles[i].key === defaultStyleCell.key) {\n            return destStyles[i];\n          }\n        }\n        return defaultStyleCell;\n      });\n    }\n    var oldCurrentStyles = defaultStyles == null ? destStyles.map(function (s) {\n      return _stripStyle2['default'](s.style);\n    }) : defaultStyles.map(function (s) {\n      return _stripStyle2['default'](s.style);\n    });\n    var oldCurrentVelocities = defaultStyles == null ? destStyles.map(function (s) {\n      return _mapToZero2['default'](s.style);\n    }) : defaultStyles.map(function (s) {\n      return _mapToZero2['default'](s.style);\n    });\n\n    var _mergeAndSync3 = mergeAndSync(\n    // Because this is an old-style createReactClass component, Flow doesn't\n    // understand that the willEnter and willLeave props have default values\n    // and will always be present.\n    willEnter, willLeave, didLeave, oldMergedPropsStyles, destStyles, oldCurrentStyles, oldCurrentVelocities, oldCurrentStyles, // oldLastIdealStyles really\n    oldCurrentVelocities);\n\n    var mergedPropsStyles = _mergeAndSync3[0];\n    var currentStyles = _mergeAndSync3[1];\n    var currentVelocities = _mergeAndSync3[2];\n    var lastIdealStyles = _mergeAndSync3[3];\n    var lastIdealVelocities = _mergeAndSync3[4];\n    // oldLastIdealVelocities really\n\n    return {\n      currentStyles: currentStyles,\n      currentVelocities: currentVelocities,\n      lastIdealStyles: lastIdealStyles,\n      lastIdealVelocities: lastIdealVelocities,\n      mergedPropsStyles: mergedPropsStyles\n    };\n  };\n\n  // after checking for unreadPropStyles != null, we manually go set the\n  // non-interpolating values (those that are a number, without a spring\n  // config)\n\n  TransitionMotion.prototype.componentDidMount = function componentDidMount() {\n    this.prevTime = _performanceNow2['default']();\n    this.startAnimationIfNecessary();\n  };\n\n  TransitionMotion.prototype.componentWillReceiveProps = function componentWillReceiveProps(props) {\n    if (this.unreadPropStyles) {\n      // previous props haven't had the chance to be set yet; set them here\n      this.clearUnreadPropStyle(this.unreadPropStyles);\n    }\n\n    var styles = props.styles;\n    if (typeof styles === 'function') {\n      this.unreadPropStyles = styles(rehydrateStyles(this.state.mergedPropsStyles, this.unreadPropStyles, this.state.lastIdealStyles));\n    } else {\n      this.unreadPropStyles = styles;\n    }\n\n    if (this.animationID == null) {\n      this.prevTime = _performanceNow2['default']();\n      this.startAnimationIfNecessary();\n    }\n  };\n\n  TransitionMotion.prototype.componentWillUnmount = function componentWillUnmount() {\n    this.unmounting = true;\n    if (this.animationID != null) {\n      _raf2['default'].cancel(this.animationID);\n      this.animationID = null;\n    }\n  };\n\n  TransitionMotion.prototype.render = function render() {\n    var hydratedStyles = rehydrateStyles(this.state.mergedPropsStyles, this.unreadPropStyles, this.state.currentStyles);\n    var renderedChildren = this.props.children(hydratedStyles);\n    return renderedChildren && _react2['default'].Children.only(renderedChildren);\n  };\n\n  return TransitionMotion;\n})(_react2['default'].Component);\n\nexports['default'] = TransitionMotion;\nmodule.exports = exports['default'];\n\n// list of styles, each containing interpolating values. Part of what's passed\n// to children function. Notice that this is\n// Array<ActualInterpolatingStyleObject>, without the wrapper that is {key: ...,\n// data: ... style: ActualInterpolatingStyleObject}. Only mergedPropsStyles\n// contains the key & data info (so that we only have a single source of truth\n// for these, and to save space). Check the comment for `rehydrateStyles` to\n// see how we regenerate the entirety of what's passed to children function\n\n// the array that keeps track of currently rendered stuff! Including stuff\n// that you've unmounted but that's still animating. This is where it lives\n\n// it's possible that currentStyle's value is stale: if props is immediately\n// changed from 0 to 400 to spring(0) again, the async currentStyle is still\n// at 0 (didn't have time to tick and interpolate even once). If we naively\n// compare currentStyle with destVal it'll be 0 === 0 (no animation, stop).\n// In reality currentStyle should be 400","\n\n// currently used to initiate the velocity style object to 0\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = mapToZero;\n\nfunction mapToZero(obj) {\n  var ret = {};\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      ret[key] = 0;\n    }\n  }\n  return ret;\n}\n\nmodule.exports = exports['default'];","\n\n// core keys merging algorithm. If previous render's keys are [a, b], and the\n// next render's [c, b, d], what's the final merged keys and ordering?\n\n// - c and a must both be before b\n// - b before d\n// - ordering between a and c ambiguous\n\n// this reduces to merging two partially ordered lists (e.g. lists where not\n// every item has a definite ordering, like comparing a and c above). For the\n// ambiguous ordering we deterministically choose to place the next render's\n// item after the previous'; so c after a\n\n// this is called a topological sorting. Except the existing algorithms don't\n// work well with js bc of the amount of allocation, and isn't optimized for our\n// current use-case bc the runtime is linear in terms of edges (see wiki for\n// meaning), which is huge when two lists have many common elements\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = mergeDiff;\n\nfunction mergeDiff(prev, next, onRemove) {\n  // bookkeeping for easier access of a key's index below. This is 2 allocations +\n  // potentially triggering chrome hash map mode for objs (so it might be faster\n\n  var prevKeyIndex = {};\n  for (var i = 0; i < prev.length; i++) {\n    prevKeyIndex[prev[i].key] = i;\n  }\n  var nextKeyIndex = {};\n  for (var i = 0; i < next.length; i++) {\n    nextKeyIndex[next[i].key] = i;\n  }\n\n  // first, an overly elaborate way of merging prev and next, eliminating\n  // duplicates (in terms of keys). If there's dupe, keep the item in next).\n  // This way of writing it saves allocations\n  var ret = [];\n  for (var i = 0; i < next.length; i++) {\n    ret[i] = next[i];\n  }\n  for (var i = 0; i < prev.length; i++) {\n    if (!Object.prototype.hasOwnProperty.call(nextKeyIndex, prev[i].key)) {\n      // this is called my TM's `mergeAndSync`, which calls willLeave. We don't\n      // merge in keys that the user desires to kill\n      var fill = onRemove(i, prev[i]);\n      if (fill != null) {\n        ret.push(fill);\n      }\n    }\n  }\n\n  // now all the items all present. Core sorting logic to have the right order\n  return ret.sort(function (a, b) {\n    var nextOrderA = nextKeyIndex[a.key];\n    var nextOrderB = nextKeyIndex[b.key];\n    var prevOrderA = prevKeyIndex[a.key];\n    var prevOrderB = prevKeyIndex[b.key];\n\n    if (nextOrderA != null && nextOrderB != null) {\n      // both keys in next\n      return nextKeyIndex[a.key] - nextKeyIndex[b.key];\n    } else if (prevOrderA != null && prevOrderB != null) {\n      // both keys in prev\n      return prevKeyIndex[a.key] - prevKeyIndex[b.key];\n    } else if (nextOrderA != null) {\n      // key a in next, key b in prev\n\n      // how to determine the order between a and b? We find a \"pivot\" (term\n      // abuse), a key present in both prev and next, that is sandwiched between\n      // a and b. In the context of our above example, if we're comparing a and\n      // d, b's (the only) pivot\n      for (var i = 0; i < next.length; i++) {\n        var pivot = next[i].key;\n        if (!Object.prototype.hasOwnProperty.call(prevKeyIndex, pivot)) {\n          continue;\n        }\n\n        if (nextOrderA < nextKeyIndex[pivot] && prevOrderB > prevKeyIndex[pivot]) {\n          return -1;\n        } else if (nextOrderA > nextKeyIndex[pivot] && prevOrderB < prevKeyIndex[pivot]) {\n          return 1;\n        }\n      }\n      // pluggable. default to: next bigger than prev\n      return 1;\n    }\n    // prevOrderA, nextOrderB\n    for (var i = 0; i < next.length; i++) {\n      var pivot = next[i].key;\n      if (!Object.prototype.hasOwnProperty.call(prevKeyIndex, pivot)) {\n        continue;\n      }\n      if (nextOrderB < nextKeyIndex[pivot] && prevOrderA > prevKeyIndex[pivot]) {\n        return 1;\n      } else if (nextOrderB > nextKeyIndex[pivot] && prevOrderA < prevKeyIndex[pivot]) {\n        return -1;\n      }\n    }\n    // pluggable. default to: next bigger than prev\n    return -1;\n  });\n}\n\nmodule.exports = exports['default'];\n// to loop through and find a key's index each time), but I no longer care","\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = {\n  noWobble: { stiffness: 170, damping: 26 }, // the default, if nothing provided\n  gentle: { stiffness: 120, damping: 14 },\n  wobbly: { stiffness: 180, damping: 12 },\n  stiff: { stiffness: 210, damping: 20 }\n};\nmodule.exports = exports[\"default\"];","\n\n// usage assumption: currentStyle values have already been rendered but it says\n// nothing of whether currentStyle is stale (see unreadPropStyle)\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = shouldStopAnimation;\n\nfunction shouldStopAnimation(currentStyle, style, currentVelocity) {\n  for (var key in style) {\n    if (!Object.prototype.hasOwnProperty.call(style, key)) {\n      continue;\n    }\n\n    if (currentVelocity[key] !== 0) {\n      return false;\n    }\n\n    var styleValue = typeof style[key] === 'number' ? style[key] : style[key].val;\n    // stepper will have already taken care of rounding precision errors, so\n    // won't have such thing as 0.9999 !=== 1\n    if (currentStyle[key] !== styleValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nmodule.exports = exports['default'];","'use strict';\n\nexports.__esModule = true;\n\nvar _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\nexports['default'] = spring;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _presets = require('./presets');\n\nvar _presets2 = _interopRequireDefault(_presets);\n\nvar defaultConfig = _extends({}, _presets2['default'].noWobble, {\n  precision: 0.01\n});\n\nfunction spring(val, config) {\n  return _extends({}, defaultConfig, config, { val: val });\n}\n\nmodule.exports = exports['default'];","\n\n// stepper is used a lot. Saves allocation to return the same array wrapper.\n// This is fine and danger-free against mutations because the callsite\n// immediately destructures it and gets the numbers inside without passing the\n\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = stepper;\n\nvar reusedTuple = [0, 0];\n\nfunction stepper(secondPerFrame, x, v, destX, k, b, precision) {\n  // Spring stiffness, in kg / s^2\n\n  // for animations, destX is really spring length (spring at rest). initial\n  // position is considered as the stretched/compressed position of a spring\n  var Fspring = -k * (x - destX);\n\n  // Damping, in kg / s\n  var Fdamper = -b * v;\n\n  // usually we put mass here, but for animation purposes, specifying mass is a\n  // bit redundant. you could simply adjust k and b accordingly\n  // let a = (Fspring + Fdamper) / mass;\n  var a = Fspring + Fdamper;\n\n  var newV = v + a * secondPerFrame;\n  var newX = x + newV * secondPerFrame;\n\n  if (Math.abs(newV) < precision && Math.abs(newX - destX) < precision) {\n    reusedTuple[0] = destX;\n    reusedTuple[1] = 0;\n    return reusedTuple;\n  }\n\n  reusedTuple[0] = newX;\n  reusedTuple[1] = newV;\n  return reusedTuple;\n}\n\nmodule.exports = exports[\"default\"];\n// array reference around.","\n// turn {x: {val: 1, stiffness: 1, damping: 2}, y: 2} generated by\n// `{x: spring(1, {stiffness: 1, damping: 2}), y: 2}` into {x: 1, y: 2}\n\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = stripStyle;\n\nfunction stripStyle(style) {\n  var ret = {};\n  for (var key in style) {\n    if (!Object.prototype.hasOwnProperty.call(style, key)) {\n      continue;\n    }\n    ret[key] = typeof style[key] === 'number' ? style[key] : style[key].val;\n  }\n  return ret;\n}\n\nmodule.exports = exports['default'];","// Written in this round about way for babel-transform-imports\nimport matchPath from \"react-router/es/matchPath\";\n\nexport default matchPath;","import spring from './spring';\n\nexport default function ensureSpring(styles) {\n  return Object.keys(styles).reduce(function (acc, key) {\n    var value = styles[key];\n    acc[key] = typeof value === 'number' ? spring(value) : value;\n    return acc;\n  }, {});\n}","var _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\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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\nfunction _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; }\n\nimport React, { cloneElement, createElement, Component } from 'react';\nimport TransitionMotion from 'react-motion/lib/TransitionMotion';\nimport PropTypes from 'prop-types';\n\nimport ensureSpring from './ensureSpring';\n\nvar identity = function identity(val) {\n  return val;\n};\n\nvar RouteTransition = function (_Component) {\n  _inherits(RouteTransition, _Component);\n\n  function RouteTransition() {\n    var _ref;\n\n    var _temp, _this, _ret;\n\n    _classCallCheck(this, RouteTransition);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = RouteTransition.__proto__ || Object.getPrototypeOf(RouteTransition)).call.apply(_ref, [this].concat(args))), _this), _this.willEnter = function () {\n      return _this.props.atEnter;\n    }, _this.willLeave = function () {\n      return ensureSpring(_this.props.atLeave);\n    }, _this.didLeave = function (styleThatLeft) {\n      if (_this.props.didLeave) {\n        _this.props.didLeave(styleThatLeft);\n      }\n    }, _this.renderRoute = function (config) {\n      var props = {\n        style: _this.props.mapStyles(config.style),\n        key: config.key\n      };\n\n      return _this.props.wrapperComponent !== false ? createElement(_this.props.wrapperComponent, props, config.data) : cloneElement(config.data, props);\n    }, _this.renderRoutes = function (interpolatedStyles) {\n      return React.createElement(\n        'div',\n        { className: _this.props.className },\n        interpolatedStyles.map(_this.renderRoute)\n      );\n    }, _temp), _possibleConstructorReturn(_this, _ret);\n  }\n\n  _createClass(RouteTransition, [{\n    key: 'getDefaultStyles',\n    value: function getDefaultStyles() {\n      if (!this.props.runOnMount) {\n        return null;\n      }\n\n      if (!this.props.children) {\n        return [];\n      }\n\n      return [{\n        key: this.props.children.key,\n        data: this.props.children,\n        style: this.props.atEnter\n      }];\n    }\n\n    // there's only ever one route mounted at a time,\n    // so just return the current match\n\n  }, {\n    key: 'getStyles',\n    value: function getStyles() {\n      if (!this.props.children) {\n        return [];\n      }\n\n      return [{\n        key: this.props.children.key,\n        data: this.props.children,\n        style: ensureSpring(this.props.atActive)\n      }];\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      return React.createElement(\n        TransitionMotion,\n        {\n          defaultStyles: this.getDefaultStyles(),\n          styles: this.getStyles(),\n          willEnter: this.willEnter,\n          willLeave: this.willLeave,\n          didLeave: this.didLeave\n        },\n        this.renderRoutes\n      );\n    }\n  }]);\n\n  return RouteTransition;\n}(Component);\n\nRouteTransition.defaultProps = {\n  wrapperComponent: 'div',\n  runOnMount: false,\n  mapStyles: identity\n};\nRouteTransition.propTypes = {\n  className: PropTypes.string,\n  wrapperComponent: PropTypes.oneOfType([PropTypes.bool, PropTypes.element, PropTypes.string]),\n  atEnter: PropTypes.object.isRequired,\n  atActive: PropTypes.object.isRequired,\n  atLeave: PropTypes.object.isRequired,\n  didLeave: PropTypes.func,\n  mapStyles: PropTypes.func.isRequired,\n  runOnMount: PropTypes.bool.isRequired\n};\n\n\nexport default RouteTransition;","function _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\nimport React from 'react';\nimport { Route, matchPath } from 'react-router-dom';\n\nimport RouteTransition from './RouteTransition';\n\n/**\n * Here we only care about whether or not the pathname matches. If so,\n * we'll use the route's path as the key, otherwise we'll default it\n * to a string signifying no match.\n */\nfunction getKey(_ref, path, exact) {\n  var pathname = _ref.pathname;\n\n  return matchPath(pathname, { exact: exact, path: path }) ? 'match' : 'no-match';\n}\n\nvar AnimatedRoute = function AnimatedRoute(_ref2) {\n  var _render = _ref2.render,\n      component = _ref2.component,\n      path = _ref2.path,\n      exact = _ref2.exact,\n      routeTransitionProps = _objectWithoutProperties(_ref2, ['render', 'component', 'path', 'exact']);\n\n  return React.createElement(Route, {\n    render: function render(_ref3) {\n      var location = _ref3.location,\n          match = _ref3.match;\n      return React.createElement(\n        RouteTransition,\n        routeTransitionProps,\n        React.createElement(Route, {\n          key: getKey(location, path, exact),\n          path: path,\n          exact: exact,\n          location: location,\n          component: component,\n          render: _render\n        })\n      );\n    }\n  });\n};\n\nexport default AnimatedRoute;","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\nvar _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\nfunction _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\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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\nfunction _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; }\n\nimport React from 'react';\nimport { Route, Switch, matchPath } from 'react-router-dom';\nimport PropTypes from 'prop-types';\n\nimport RouteTransition from './RouteTransition';\n\nvar NO_MATCH = {\n  key: 'no-match'\n};\n\n/**\n * Not every location object has a `key` property (e.g. HashHistory).\n */\nfunction getLocationKey(location) {\n  return typeof location.key === 'string' ? location.key : '';\n}\n\n/**\n * Some superfluous work, but something we need to do in order\n * to persist matches/allow for nesting/etc.\n */\nfunction getMatchedRoute(children, pathname) {\n  return React.Children.toArray(children).find(function (child) {\n    return matchPath(pathname, {\n      exact: child.props.exact,\n      path: child.props.path\n    });\n  }) || NO_MATCH;\n}\n\nvar AnimatedSwitch = function (_React$Component) {\n  _inherits(AnimatedSwitch, _React$Component);\n\n  function AnimatedSwitch() {\n    var _ref;\n\n    var _temp, _this, _ret;\n\n    _classCallCheck(this, AnimatedSwitch);\n\n    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = AnimatedSwitch.__proto__ || Object.getPrototypeOf(AnimatedSwitch)).call.apply(_ref, [this].concat(args))), _this), _this.state = {\n      key: getLocationKey(_this.props.location),\n      match: getMatchedRoute(_this.props.children, _this.props.location.pathname)\n    }, _this.matches = 0, _temp), _possibleConstructorReturn(_this, _ret);\n  }\n\n  _createClass(AnimatedSwitch, [{\n    key: 'componentWillReceiveProps',\n    value: function componentWillReceiveProps(nextProps) {\n      var nextMatch = getMatchedRoute(nextProps.children, nextProps.location.pathname);\n\n      if (this.state.match.key !== nextMatch.key) {\n        this.setState({\n          match: nextMatch,\n          key: getLocationKey(nextProps.location) + ++this.matches\n        });\n      }\n    }\n  }, {\n    key: 'render',\n    value: function render() {\n      var _props = this.props,\n          children = _props.children,\n          location = _props.location,\n          match = _props.match,\n          routeTransitionProps = _objectWithoutProperties(_props, ['children', 'location', 'match']);\n\n      return React.createElement(\n        RouteTransition,\n        routeTransitionProps,\n        React.createElement(\n          Switch,\n          { key: this.state.key, location: location },\n          children\n        )\n      );\n    }\n  }]);\n\n  return AnimatedSwitch;\n}(React.Component);\n\n// inject location as a prop so we can listen for changes\n\n\nAnimatedSwitch.propTypes = {\n  location: PropTypes.shape({\n    key: PropTypes.string,\n    pathname: PropTypes.string\n  })\n};\nvar RouteWrapper = function RouteWrapper(props) {\n  return React.createElement(Route, {\n    children: function children(_ref2) {\n      var location = _ref2.location;\n      return React.createElement(AnimatedSwitch, _extends({ location: location }, props));\n    }\n  });\n};\n\nexport default RouteWrapper;","export { default as AnimatedRoute } from './AnimatedRoute';\nexport { default as AnimatedSwitch } from './AnimatedSwitch';\nexport { default as RouteTransition } from './RouteTransition';\nexport { default as spring } from './spring';"],"sourceRoot":""}