{"version":3,"file":"libs-efdee510.b35d494e.js","mappings":"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","sources":["webpack://insurance-ui/./node_modules/has-symbols/index.js","webpack://insurance-ui/./node_modules/has-symbols/shams.js","webpack://insurance-ui/./node_modules/hasown/index.js","webpack://insurance-ui/./node_modules/history/esm/history.js","webpack://insurance-ui/./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","webpack://insurance-ui/./node_modules/intersection-observer/intersection-observer.js","webpack://insurance-ui/./node_modules/isarray/index.js"],"sourcesContent":["'use strict';\n\nvar origSymbol = typeof Symbol !== 'undefined' && Symbol;\nvar hasSymbolSham = require('./shams');\n\n/** @type {import('.')} */\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","'use strict';\n\n/** @type {import('./shams')} */\n/* eslint complexity: [2, 18], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\t/** @type {{ [k in symbol]?: unknown }} */\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (var _ in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\t// eslint-disable-next-line no-extra-parens\n\t\tvar descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(obj, sym));\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","'use strict';\n\nvar call = Function.prototype.call;\nvar $hasOwn = Object.prototype.hasOwnProperty;\nvar bind = require('function-bind');\n\n/** @type {import('.')} */\nmodule.exports = bind.call(call, $hasOwn);\n","import _extends from '@babel/runtime/helpers/esm/extends';\nimport resolvePathname from 'resolve-pathname';\nimport valueEqual from 'value-equal';\nimport warning from 'tiny-warning';\nimport invariant from 'tiny-invariant';\n\nfunction addLeadingSlash(path) {\n  return path.charAt(0) === '/' ? path : '/' + path;\n}\nfunction stripLeadingSlash(path) {\n  return path.charAt(0) === '/' ? path.substr(1) : path;\n}\nfunction hasBasename(path, prefix) {\n  return path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && '/?#'.indexOf(path.charAt(prefix.length)) !== -1;\n}\nfunction stripBasename(path, prefix) {\n  return hasBasename(path, prefix) ? path.substr(prefix.length) : path;\n}\nfunction stripTrailingSlash(path) {\n  return path.charAt(path.length - 1) === '/' ? path.slice(0, -1) : path;\n}\nfunction parsePath(path) {\n  var pathname = path || '/';\n  var search = '';\n  var hash = '';\n  var hashIndex = pathname.indexOf('#');\n\n  if (hashIndex !== -1) {\n    hash = pathname.substr(hashIndex);\n    pathname = pathname.substr(0, hashIndex);\n  }\n\n  var searchIndex = pathname.indexOf('?');\n\n  if (searchIndex !== -1) {\n    search = pathname.substr(searchIndex);\n    pathname = pathname.substr(0, searchIndex);\n  }\n\n  return {\n    pathname: pathname,\n    search: search === '?' ? '' : search,\n    hash: hash === '#' ? '' : hash\n  };\n}\nfunction createPath(location) {\n  var pathname = location.pathname,\n      search = location.search,\n      hash = location.hash;\n  var path = pathname || '/';\n  if (search && search !== '?') path += search.charAt(0) === '?' ? search : \"?\" + search;\n  if (hash && hash !== '#') path += hash.charAt(0) === '#' ? hash : \"#\" + hash;\n  return path;\n}\n\nfunction createLocation(path, state, key, currentLocation) {\n  var location;\n\n  if (typeof path === 'string') {\n    // Two-arg form: push(path, state)\n    location = parsePath(path);\n    location.state = state;\n  } else {\n    // One-arg form: push(location)\n    location = _extends({}, path);\n    if (location.pathname === undefined) location.pathname = '';\n\n    if (location.search) {\n      if (location.search.charAt(0) !== '?') location.search = '?' + location.search;\n    } else {\n      location.search = '';\n    }\n\n    if (location.hash) {\n      if (location.hash.charAt(0) !== '#') location.hash = '#' + location.hash;\n    } else {\n      location.hash = '';\n    }\n\n    if (state !== undefined && location.state === undefined) location.state = state;\n  }\n\n  try {\n    location.pathname = decodeURI(location.pathname);\n  } catch (e) {\n    if (e instanceof URIError) {\n      throw new URIError('Pathname \"' + location.pathname + '\" could not be decoded. ' + 'This is likely caused by an invalid percent-encoding.');\n    } else {\n      throw e;\n    }\n  }\n\n  if (key) location.key = key;\n\n  if (currentLocation) {\n    // Resolve incomplete/relative pathname relative to current location.\n    if (!location.pathname) {\n      location.pathname = currentLocation.pathname;\n    } else if (location.pathname.charAt(0) !== '/') {\n      location.pathname = resolvePathname(location.pathname, currentLocation.pathname);\n    }\n  } else {\n    // When there is no prior location and pathname is empty, set it to /\n    if (!location.pathname) {\n      location.pathname = '/';\n    }\n  }\n\n  return location;\n}\nfunction locationsAreEqual(a, b) {\n  return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash && a.key === b.key && valueEqual(a.state, b.state);\n}\n\nfunction createTransitionManager() {\n  var prompt = null;\n\n  function setPrompt(nextPrompt) {\n    process.env.NODE_ENV !== \"production\" ? warning(prompt == null, 'A history supports only one prompt at a time') : void 0;\n    prompt = nextPrompt;\n    return function () {\n      if (prompt === nextPrompt) prompt = null;\n    };\n  }\n\n  function confirmTransitionTo(location, action, getUserConfirmation, callback) {\n    // TODO: If another transition starts while we're still confirming\n    // the previous one, we may end up in a weird state. Figure out the\n    // best way to handle this.\n    if (prompt != null) {\n      var result = typeof prompt === 'function' ? prompt(location, action) : prompt;\n\n      if (typeof result === 'string') {\n        if (typeof getUserConfirmation === 'function') {\n          getUserConfirmation(result, callback);\n        } else {\n          process.env.NODE_ENV !== \"production\" ? warning(false, 'A history needs a getUserConfirmation function in order to use a prompt message') : void 0;\n          callback(true);\n        }\n      } else {\n        // Return false from a transition hook to cancel the transition.\n        callback(result !== false);\n      }\n    } else {\n      callback(true);\n    }\n  }\n\n  var listeners = [];\n\n  function appendListener(fn) {\n    var isActive = true;\n\n    function listener() {\n      if (isActive) fn.apply(void 0, arguments);\n    }\n\n    listeners.push(listener);\n    return function () {\n      isActive = false;\n      listeners = listeners.filter(function (item) {\n        return item !== listener;\n      });\n    };\n  }\n\n  function notifyListeners() {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    listeners.forEach(function (listener) {\n      return listener.apply(void 0, args);\n    });\n  }\n\n  return {\n    setPrompt: setPrompt,\n    confirmTransitionTo: confirmTransitionTo,\n    appendListener: appendListener,\n    notifyListeners: notifyListeners\n  };\n}\n\nvar canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\nfunction getConfirmation(message, callback) {\n  callback(window.confirm(message)); // eslint-disable-line no-alert\n}\n/**\n * Returns true if the HTML5 history API is supported. Taken from Modernizr.\n *\n * https://github.com/Modernizr/Modernizr/blob/master/LICENSE\n * https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js\n * changed to avoid false negatives for Windows Phones: https://github.com/reactjs/react-router/issues/586\n */\n\nfunction supportsHistory() {\n  var ua = window.navigator.userAgent;\n  if ((ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) && ua.indexOf('Mobile Safari') !== -1 && ua.indexOf('Chrome') === -1 && ua.indexOf('Windows Phone') === -1) return false;\n  return window.history && 'pushState' in window.history;\n}\n/**\n * Returns true if browser fires popstate on hash change.\n * IE10 and IE11 do not.\n */\n\nfunction supportsPopStateOnHashChange() {\n  return window.navigator.userAgent.indexOf('Trident') === -1;\n}\n/**\n * Returns false if using go(n) with hash history causes a full page reload.\n */\n\nfunction supportsGoWithoutReloadUsingHash() {\n  return window.navigator.userAgent.indexOf('Firefox') === -1;\n}\n/**\n * Returns true if a given popstate event is an extraneous WebKit event.\n * Accounts for the fact that Chrome on iOS fires real popstate events\n * containing undefined state when pressing the back button.\n */\n\nfunction isExtraneousPopstateEvent(event) {\n  return event.state === undefined && navigator.userAgent.indexOf('CriOS') === -1;\n}\n\nvar PopStateEvent = 'popstate';\nvar HashChangeEvent = 'hashchange';\n\nfunction getHistoryState() {\n  try {\n    return window.history.state || {};\n  } catch (e) {\n    // IE 11 sometimes throws when accessing window.history.state\n    // See https://github.com/ReactTraining/history/pull/289\n    return {};\n  }\n}\n/**\n * Creates a history object that uses the HTML5 history API including\n * pushState, replaceState, and the popstate event.\n */\n\n\nfunction createBrowserHistory(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  !canUseDOM ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Browser history needs a DOM') : invariant(false) : void 0;\n  var globalHistory = window.history;\n  var canUseHistory = supportsHistory();\n  var needsHashChangeListener = !supportsPopStateOnHashChange();\n  var _props = props,\n      _props$forceRefresh = _props.forceRefresh,\n      forceRefresh = _props$forceRefresh === void 0 ? false : _props$forceRefresh,\n      _props$getUserConfirm = _props.getUserConfirmation,\n      getUserConfirmation = _props$getUserConfirm === void 0 ? getConfirmation : _props$getUserConfirm,\n      _props$keyLength = _props.keyLength,\n      keyLength = _props$keyLength === void 0 ? 6 : _props$keyLength;\n  var basename = props.basename ? stripTrailingSlash(addLeadingSlash(props.basename)) : '';\n\n  function getDOMLocation(historyState) {\n    var _ref = historyState || {},\n        key = _ref.key,\n        state = _ref.state;\n\n    var _window$location = window.location,\n        pathname = _window$location.pathname,\n        search = _window$location.search,\n        hash = _window$location.hash;\n    var path = pathname + search + hash;\n    process.env.NODE_ENV !== \"production\" ? warning(!basename || hasBasename(path, basename), 'You are attempting to use a basename on a page whose URL path does not begin ' + 'with the basename. Expected path \"' + path + '\" to begin with \"' + basename + '\".') : void 0;\n    if (basename) path = stripBasename(path, basename);\n    return createLocation(path, state, key);\n  }\n\n  function createKey() {\n    return Math.random().toString(36).substr(2, keyLength);\n  }\n\n  var transitionManager = createTransitionManager();\n\n  function setState(nextState) {\n    _extends(history, nextState);\n\n    history.length = globalHistory.length;\n    transitionManager.notifyListeners(history.location, history.action);\n  }\n\n  function handlePopState(event) {\n    // Ignore extraneous popstate events in WebKit.\n    if (isExtraneousPopstateEvent(event)) return;\n    handlePop(getDOMLocation(event.state));\n  }\n\n  function handleHashChange() {\n    handlePop(getDOMLocation(getHistoryState()));\n  }\n\n  var forceNextPop = false;\n\n  function handlePop(location) {\n    if (forceNextPop) {\n      forceNextPop = false;\n      setState();\n    } else {\n      var action = 'POP';\n      transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n        if (ok) {\n          setState({\n            action: action,\n            location: location\n          });\n        } else {\n          revertPop(location);\n        }\n      });\n    }\n  }\n\n  function revertPop(fromLocation) {\n    var toLocation = history.location; // TODO: We could probably make this more reliable by\n    // keeping a list of keys we've seen in sessionStorage.\n    // Instead, we just default to 0 for keys we don't know.\n\n    var toIndex = allKeys.indexOf(toLocation.key);\n    if (toIndex === -1) toIndex = 0;\n    var fromIndex = allKeys.indexOf(fromLocation.key);\n    if (fromIndex === -1) fromIndex = 0;\n    var delta = toIndex - fromIndex;\n\n    if (delta) {\n      forceNextPop = true;\n      go(delta);\n    }\n  }\n\n  var initialLocation = getDOMLocation(getHistoryState());\n  var allKeys = [initialLocation.key]; // Public interface\n\n  function createHref(location) {\n    return basename + createPath(location);\n  }\n\n  function push(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to push when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'PUSH';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var href = createHref(location);\n      var key = location.key,\n          state = location.state;\n\n      if (canUseHistory) {\n        globalHistory.pushState({\n          key: key,\n          state: state\n        }, null, href);\n\n        if (forceRefresh) {\n          window.location.href = href;\n        } else {\n          var prevIndex = allKeys.indexOf(history.location.key);\n          var nextKeys = allKeys.slice(0, prevIndex + 1);\n          nextKeys.push(location.key);\n          allKeys = nextKeys;\n          setState({\n            action: action,\n            location: location\n          });\n        }\n      } else {\n        process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Browser history cannot push state in browsers that do not support HTML5 history') : void 0;\n        window.location.href = href;\n      }\n    });\n  }\n\n  function replace(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to replace when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'REPLACE';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var href = createHref(location);\n      var key = location.key,\n          state = location.state;\n\n      if (canUseHistory) {\n        globalHistory.replaceState({\n          key: key,\n          state: state\n        }, null, href);\n\n        if (forceRefresh) {\n          window.location.replace(href);\n        } else {\n          var prevIndex = allKeys.indexOf(history.location.key);\n          if (prevIndex !== -1) allKeys[prevIndex] = location.key;\n          setState({\n            action: action,\n            location: location\n          });\n        }\n      } else {\n        process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Browser history cannot replace state in browsers that do not support HTML5 history') : void 0;\n        window.location.replace(href);\n      }\n    });\n  }\n\n  function go(n) {\n    globalHistory.go(n);\n  }\n\n  function goBack() {\n    go(-1);\n  }\n\n  function goForward() {\n    go(1);\n  }\n\n  var listenerCount = 0;\n\n  function checkDOMListeners(delta) {\n    listenerCount += delta;\n\n    if (listenerCount === 1 && delta === 1) {\n      window.addEventListener(PopStateEvent, handlePopState);\n      if (needsHashChangeListener) window.addEventListener(HashChangeEvent, handleHashChange);\n    } else if (listenerCount === 0) {\n      window.removeEventListener(PopStateEvent, handlePopState);\n      if (needsHashChangeListener) window.removeEventListener(HashChangeEvent, handleHashChange);\n    }\n  }\n\n  var isBlocked = false;\n\n  function block(prompt) {\n    if (prompt === void 0) {\n      prompt = false;\n    }\n\n    var unblock = transitionManager.setPrompt(prompt);\n\n    if (!isBlocked) {\n      checkDOMListeners(1);\n      isBlocked = true;\n    }\n\n    return function () {\n      if (isBlocked) {\n        isBlocked = false;\n        checkDOMListeners(-1);\n      }\n\n      return unblock();\n    };\n  }\n\n  function listen(listener) {\n    var unlisten = transitionManager.appendListener(listener);\n    checkDOMListeners(1);\n    return function () {\n      checkDOMListeners(-1);\n      unlisten();\n    };\n  }\n\n  var history = {\n    length: globalHistory.length,\n    action: 'POP',\n    location: initialLocation,\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    goBack: goBack,\n    goForward: goForward,\n    block: block,\n    listen: listen\n  };\n  return history;\n}\n\nvar HashChangeEvent$1 = 'hashchange';\nvar HashPathCoders = {\n  hashbang: {\n    encodePath: function encodePath(path) {\n      return path.charAt(0) === '!' ? path : '!/' + stripLeadingSlash(path);\n    },\n    decodePath: function decodePath(path) {\n      return path.charAt(0) === '!' ? path.substr(1) : path;\n    }\n  },\n  noslash: {\n    encodePath: stripLeadingSlash,\n    decodePath: addLeadingSlash\n  },\n  slash: {\n    encodePath: addLeadingSlash,\n    decodePath: addLeadingSlash\n  }\n};\n\nfunction stripHash(url) {\n  var hashIndex = url.indexOf('#');\n  return hashIndex === -1 ? url : url.slice(0, hashIndex);\n}\n\nfunction getHashPath() {\n  // We can't use window.location.hash here because it's not\n  // consistent across browsers - Firefox will pre-decode it!\n  var href = window.location.href;\n  var hashIndex = href.indexOf('#');\n  return hashIndex === -1 ? '' : href.substring(hashIndex + 1);\n}\n\nfunction pushHashPath(path) {\n  window.location.hash = path;\n}\n\nfunction replaceHashPath(path) {\n  window.location.replace(stripHash(window.location.href) + '#' + path);\n}\n\nfunction createHashHistory(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  !canUseDOM ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Hash history needs a DOM') : invariant(false) : void 0;\n  var globalHistory = window.history;\n  var canGoWithoutReload = supportsGoWithoutReloadUsingHash();\n  var _props = props,\n      _props$getUserConfirm = _props.getUserConfirmation,\n      getUserConfirmation = _props$getUserConfirm === void 0 ? getConfirmation : _props$getUserConfirm,\n      _props$hashType = _props.hashType,\n      hashType = _props$hashType === void 0 ? 'slash' : _props$hashType;\n  var basename = props.basename ? stripTrailingSlash(addLeadingSlash(props.basename)) : '';\n  var _HashPathCoders$hashT = HashPathCoders[hashType],\n      encodePath = _HashPathCoders$hashT.encodePath,\n      decodePath = _HashPathCoders$hashT.decodePath;\n\n  function getDOMLocation() {\n    var path = decodePath(getHashPath());\n    process.env.NODE_ENV !== \"production\" ? warning(!basename || hasBasename(path, basename), 'You are attempting to use a basename on a page whose URL path does not begin ' + 'with the basename. Expected path \"' + path + '\" to begin with \"' + basename + '\".') : void 0;\n    if (basename) path = stripBasename(path, basename);\n    return createLocation(path);\n  }\n\n  var transitionManager = createTransitionManager();\n\n  function setState(nextState) {\n    _extends(history, nextState);\n\n    history.length = globalHistory.length;\n    transitionManager.notifyListeners(history.location, history.action);\n  }\n\n  var forceNextPop = false;\n  var ignorePath = null;\n\n  function locationsAreEqual$$1(a, b) {\n    return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash;\n  }\n\n  function handleHashChange() {\n    var path = getHashPath();\n    var encodedPath = encodePath(path);\n\n    if (path !== encodedPath) {\n      // Ensure we always have a properly-encoded hash.\n      replaceHashPath(encodedPath);\n    } else {\n      var location = getDOMLocation();\n      var prevLocation = history.location;\n      if (!forceNextPop && locationsAreEqual$$1(prevLocation, location)) return; // A hashchange doesn't always == location change.\n\n      if (ignorePath === createPath(location)) return; // Ignore this change; we already setState in push/replace.\n\n      ignorePath = null;\n      handlePop(location);\n    }\n  }\n\n  function handlePop(location) {\n    if (forceNextPop) {\n      forceNextPop = false;\n      setState();\n    } else {\n      var action = 'POP';\n      transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n        if (ok) {\n          setState({\n            action: action,\n            location: location\n          });\n        } else {\n          revertPop(location);\n        }\n      });\n    }\n  }\n\n  function revertPop(fromLocation) {\n    var toLocation = history.location; // TODO: We could probably make this more reliable by\n    // keeping a list of paths we've seen in sessionStorage.\n    // Instead, we just default to 0 for paths we don't know.\n\n    var toIndex = allPaths.lastIndexOf(createPath(toLocation));\n    if (toIndex === -1) toIndex = 0;\n    var fromIndex = allPaths.lastIndexOf(createPath(fromLocation));\n    if (fromIndex === -1) fromIndex = 0;\n    var delta = toIndex - fromIndex;\n\n    if (delta) {\n      forceNextPop = true;\n      go(delta);\n    }\n  } // Ensure the hash is encoded properly before doing anything else.\n\n\n  var path = getHashPath();\n  var encodedPath = encodePath(path);\n  if (path !== encodedPath) replaceHashPath(encodedPath);\n  var initialLocation = getDOMLocation();\n  var allPaths = [createPath(initialLocation)]; // Public interface\n\n  function createHref(location) {\n    var baseTag = document.querySelector('base');\n    var href = '';\n\n    if (baseTag && baseTag.getAttribute('href')) {\n      href = stripHash(window.location.href);\n    }\n\n    return href + '#' + encodePath(basename + createPath(location));\n  }\n\n  function push(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Hash history cannot push state; it is ignored') : void 0;\n    var action = 'PUSH';\n    var location = createLocation(path, undefined, undefined, history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var path = createPath(location);\n      var encodedPath = encodePath(basename + path);\n      var hashChanged = getHashPath() !== encodedPath;\n\n      if (hashChanged) {\n        // We cannot tell if a hashchange was caused by a PUSH, so we'd\n        // rather setState here and ignore the hashchange. The caveat here\n        // is that other hash histories in the page will consider it a POP.\n        ignorePath = path;\n        pushHashPath(encodedPath);\n        var prevIndex = allPaths.lastIndexOf(createPath(history.location));\n        var nextPaths = allPaths.slice(0, prevIndex + 1);\n        nextPaths.push(path);\n        allPaths = nextPaths;\n        setState({\n          action: action,\n          location: location\n        });\n      } else {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'Hash history cannot PUSH the same path; a new entry will not be added to the history stack') : void 0;\n        setState();\n      }\n    });\n  }\n\n  function replace(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Hash history cannot replace state; it is ignored') : void 0;\n    var action = 'REPLACE';\n    var location = createLocation(path, undefined, undefined, history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var path = createPath(location);\n      var encodedPath = encodePath(basename + path);\n      var hashChanged = getHashPath() !== encodedPath;\n\n      if (hashChanged) {\n        // We cannot tell if a hashchange was caused by a REPLACE, so we'd\n        // rather setState here and ignore the hashchange. The caveat here\n        // is that other hash histories in the page will consider it a POP.\n        ignorePath = path;\n        replaceHashPath(encodedPath);\n      }\n\n      var prevIndex = allPaths.indexOf(createPath(history.location));\n      if (prevIndex !== -1) allPaths[prevIndex] = path;\n      setState({\n        action: action,\n        location: location\n      });\n    });\n  }\n\n  function go(n) {\n    process.env.NODE_ENV !== \"production\" ? warning(canGoWithoutReload, 'Hash history go(n) causes a full page reload in this browser') : void 0;\n    globalHistory.go(n);\n  }\n\n  function goBack() {\n    go(-1);\n  }\n\n  function goForward() {\n    go(1);\n  }\n\n  var listenerCount = 0;\n\n  function checkDOMListeners(delta) {\n    listenerCount += delta;\n\n    if (listenerCount === 1 && delta === 1) {\n      window.addEventListener(HashChangeEvent$1, handleHashChange);\n    } else if (listenerCount === 0) {\n      window.removeEventListener(HashChangeEvent$1, handleHashChange);\n    }\n  }\n\n  var isBlocked = false;\n\n  function block(prompt) {\n    if (prompt === void 0) {\n      prompt = false;\n    }\n\n    var unblock = transitionManager.setPrompt(prompt);\n\n    if (!isBlocked) {\n      checkDOMListeners(1);\n      isBlocked = true;\n    }\n\n    return function () {\n      if (isBlocked) {\n        isBlocked = false;\n        checkDOMListeners(-1);\n      }\n\n      return unblock();\n    };\n  }\n\n  function listen(listener) {\n    var unlisten = transitionManager.appendListener(listener);\n    checkDOMListeners(1);\n    return function () {\n      checkDOMListeners(-1);\n      unlisten();\n    };\n  }\n\n  var history = {\n    length: globalHistory.length,\n    action: 'POP',\n    location: initialLocation,\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    goBack: goBack,\n    goForward: goForward,\n    block: block,\n    listen: listen\n  };\n  return history;\n}\n\nfunction clamp(n, lowerBound, upperBound) {\n  return Math.min(Math.max(n, lowerBound), upperBound);\n}\n/**\n * Creates a history object that stores locations in memory.\n */\n\n\nfunction createMemoryHistory(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  var _props = props,\n      getUserConfirmation = _props.getUserConfirmation,\n      _props$initialEntries = _props.initialEntries,\n      initialEntries = _props$initialEntries === void 0 ? ['/'] : _props$initialEntries,\n      _props$initialIndex = _props.initialIndex,\n      initialIndex = _props$initialIndex === void 0 ? 0 : _props$initialIndex,\n      _props$keyLength = _props.keyLength,\n      keyLength = _props$keyLength === void 0 ? 6 : _props$keyLength;\n  var transitionManager = createTransitionManager();\n\n  function setState(nextState) {\n    _extends(history, nextState);\n\n    history.length = history.entries.length;\n    transitionManager.notifyListeners(history.location, history.action);\n  }\n\n  function createKey() {\n    return Math.random().toString(36).substr(2, keyLength);\n  }\n\n  var index = clamp(initialIndex, 0, initialEntries.length - 1);\n  var entries = initialEntries.map(function (entry) {\n    return typeof entry === 'string' ? createLocation(entry, undefined, createKey()) : createLocation(entry, undefined, entry.key || createKey());\n  }); // Public interface\n\n  var createHref = createPath;\n\n  function push(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to push when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'PUSH';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var prevIndex = history.index;\n      var nextIndex = prevIndex + 1;\n      var nextEntries = history.entries.slice(0);\n\n      if (nextEntries.length > nextIndex) {\n        nextEntries.splice(nextIndex, nextEntries.length - nextIndex, location);\n      } else {\n        nextEntries.push(location);\n      }\n\n      setState({\n        action: action,\n        location: location,\n        index: nextIndex,\n        entries: nextEntries\n      });\n    });\n  }\n\n  function replace(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to replace when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'REPLACE';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      history.entries[history.index] = location;\n      setState({\n        action: action,\n        location: location\n      });\n    });\n  }\n\n  function go(n) {\n    var nextIndex = clamp(history.index + n, 0, history.entries.length - 1);\n    var action = 'POP';\n    var location = history.entries[nextIndex];\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (ok) {\n        setState({\n          action: action,\n          location: location,\n          index: nextIndex\n        });\n      } else {\n        // Mimic the behavior of DOM histories by\n        // causing a render after a cancelled POP.\n        setState();\n      }\n    });\n  }\n\n  function goBack() {\n    go(-1);\n  }\n\n  function goForward() {\n    go(1);\n  }\n\n  function canGo(n) {\n    var nextIndex = history.index + n;\n    return nextIndex >= 0 && nextIndex < history.entries.length;\n  }\n\n  function block(prompt) {\n    if (prompt === void 0) {\n      prompt = false;\n    }\n\n    return transitionManager.setPrompt(prompt);\n  }\n\n  function listen(listener) {\n    return transitionManager.appendListener(listener);\n  }\n\n  var history = {\n    length: entries.length,\n    action: 'POP',\n    location: entries[index],\n    index: index,\n    entries: entries,\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    goBack: goBack,\n    goForward: goForward,\n    canGo: canGo,\n    block: block,\n    listen: listen\n  };\n  return history;\n}\n\nexport { createBrowserHistory, createHashHistory, createMemoryHistory, createLocation, locationsAreEqual, parsePath, createPath };\n","'use strict';\n\nvar reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  '$$typeof': true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  '$$typeof': true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n  // React v16.11 and below\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  } // React v16.12 and above\n\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n(function() {\n'use strict';\n\n// Exit early if we're not running in a browser.\nif (typeof window !== 'object') {\n  return;\n}\n\n// Exit early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n/**\n * Returns the embedding frame element, if any.\n * @param {!Document} doc\n * @return {!Element}\n */\nfunction getFrameElement(doc) {\n  try {\n    return doc.defaultView && doc.defaultView.frameElement || null;\n  } catch (e) {\n    // Ignore the error.\n    return null;\n  }\n}\n\n/**\n * A local reference to the root document.\n */\nvar document = (function(startDoc) {\n  var doc = startDoc;\n  var frame = getFrameElement(doc);\n  while (frame) {\n    doc = frame.ownerDocument;\n    frame = getFrameElement(doc);\n  }\n  return doc;\n})(window.document);\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observing a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n/**\n * The signal updater for cross-origin intersection. When not null, it means\n * that the polyfill is configured to work in a cross-origin mode.\n * @type {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n */\nvar crossOriginUpdater = null;\n\n/**\n * The current cross-origin intersection. Only used in the cross-origin mode.\n * @type {DOMRect|ClientRect}\n */\nvar crossOriginRect = null;\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = ensureDOMRect(entry.rootBounds);\n  this.boundingClientRect = ensureDOMRect(entry.boundingClientRect);\n  this.intersectionRect = ensureDOMRect(entry.intersectionRect || getEmptyRect());\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    // Round the intersection ratio to avoid floating point math issues:\n    // https://github.com/w3c/IntersectionObserver/issues/324\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (\n    options.root &&\n    options.root.nodeType != 1 &&\n    options.root.nodeType != 9\n  ) {\n    throw new Error('root must be a Document or Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n\n  /** @private @const {!Array<!Document>} */\n  this._monitoringDocuments = [];\n  /** @private @const {!Array<function()>} */\n  this._monitoringUnsubscribes = [];\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Sets up the polyfill in the cross-origin mode. The result is the\n * updater function that accepts two arguments: `boundingClientRect` and\n * `intersectionRect` - just as these fields would be available to the\n * parent via `IntersectionObserverEntry`. This function should be called\n * each time the iframe receives intersection information from the parent\n * window, e.g. via messaging.\n * @return {function(DOMRect|ClientRect, DOMRect|ClientRect)}\n */\nIntersectionObserver._setupCrossOriginUpdater = function() {\n  if (!crossOriginUpdater) {\n    /**\n     * @param {DOMRect|ClientRect} boundingClientRect\n     * @param {DOMRect|ClientRect} intersectionRect\n     */\n    crossOriginUpdater = function(boundingClientRect, intersectionRect) {\n      if (!boundingClientRect || !intersectionRect) {\n        crossOriginRect = getEmptyRect();\n      } else {\n        crossOriginRect = convertFromParentRect(boundingClientRect, intersectionRect);\n      }\n      registry.forEach(function(observer) {\n        observer._checkForIntersections();\n      });\n    };\n  }\n  return crossOriginUpdater;\n};\n\n\n/**\n * Resets the cross-origin mode.\n */\nIntersectionObserver._resetCrossOriginUpdater = function() {\n  crossOriginUpdater = null;\n  crossOriginRect = null;\n};\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections(target.ownerDocument);\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n        return item.element != target;\n      });\n  this._unmonitorIntersections(target.ownerDocument);\n  if (this._observationTargets.length == 0) {\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorAllIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibility state is visible.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function(doc) {\n  var win = doc.defaultView;\n  if (!win) {\n    // Already destroyed.\n    return;\n  }\n  if (this._monitoringDocuments.indexOf(doc) != -1) {\n    // Already monitoring.\n    return;\n  }\n\n  // Private state for monitoring.\n  var callback = this._checkForIntersections;\n  var monitoringInterval = null;\n  var domObserver = null;\n\n  // If a poll interval is set, use polling instead of listening to\n  // resize and scroll events or DOM mutations.\n  if (this.POLL_INTERVAL) {\n    monitoringInterval = win.setInterval(callback, this.POLL_INTERVAL);\n  } else {\n    addEvent(win, 'resize', callback, true);\n    addEvent(doc, 'scroll', callback, true);\n    if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in win) {\n      domObserver = new win.MutationObserver(callback);\n      domObserver.observe(doc, {\n        attributes: true,\n        childList: true,\n        characterData: true,\n        subtree: true\n      });\n    }\n  }\n\n  this._monitoringDocuments.push(doc);\n  this._monitoringUnsubscribes.push(function() {\n    // Get the window object again. When a friendly iframe is destroyed, it\n    // will be null.\n    var win = doc.defaultView;\n\n    if (win) {\n      if (monitoringInterval) {\n        win.clearInterval(monitoringInterval);\n      }\n      removeEvent(win, 'resize', callback, true);\n    }\n\n    removeEvent(doc, 'scroll', callback, true);\n    if (domObserver) {\n      domObserver.disconnect();\n    }\n  });\n\n  // Also monitor the parent.\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n  if (doc != rootDoc) {\n    var frame = getFrameElement(doc);\n    if (frame) {\n      this._monitorIntersections(frame.ownerDocument);\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function(doc) {\n  var index = this._monitoringDocuments.indexOf(doc);\n  if (index == -1) {\n    return;\n  }\n\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n\n  // Check if any dependent targets are still remaining.\n  var hasDependentTargets =\n      this._observationTargets.some(function(item) {\n        var itemDoc = item.element.ownerDocument;\n        // Target is in this context.\n        if (itemDoc == doc) {\n          return true;\n        }\n        // Target is nested in this context.\n        while (itemDoc && itemDoc != rootDoc) {\n          var frame = getFrameElement(itemDoc);\n          itemDoc = frame && frame.ownerDocument;\n          if (itemDoc == doc) {\n            return true;\n          }\n        }\n        return false;\n      });\n  if (hasDependentTargets) {\n    return;\n  }\n\n  // Unsubscribe.\n  var unsubscribe = this._monitoringUnsubscribes[index];\n  this._monitoringDocuments.splice(index, 1);\n  this._monitoringUnsubscribes.splice(index, 1);\n  unsubscribe();\n\n  // Also unmonitor the parent.\n  if (doc != rootDoc) {\n    var frame = getFrameElement(doc);\n    if (frame) {\n      this._unmonitorIntersections(frame.ownerDocument);\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @param {!Document} doc\n * @private\n */\nIntersectionObserver.prototype._unmonitorAllIntersections = function() {\n  var unsubscribes = this._monitoringUnsubscribes.slice(0);\n  this._monitoringDocuments.length = 0;\n  this._monitoringUnsubscribes.length = 0;\n  for (var i = 0; i < unsubscribes.length; i++) {\n    unsubscribes[i]();\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  if (!this.root && crossOriginUpdater && !crossOriginRect) {\n    // Cross origin monitoring, but no initial data available yet.\n    return;\n  }\n\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, targetRect, rootRect);\n\n    var rootBounds = null;\n    if (!this._rootContainsTarget(target)) {\n      rootBounds = getEmptyRect();\n    } else if (!crossOriginUpdater || this.root) {\n      rootBounds = rootRect;\n    }\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootBounds,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} targetRect The bounding rect of the target.\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, targetRect, rootRect) {\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot && parent) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return null;\n\n    if (parent == this.root || parent.nodeType == /* DOCUMENT */ 9) {\n      atRoot = true;\n      if (parent == this.root || parent == document) {\n        if (crossOriginUpdater && !this.root) {\n          if (!crossOriginRect ||\n              crossOriginRect.width == 0 && crossOriginRect.height == 0) {\n            // A 0-size cross-origin intersection means no-intersection.\n            parent = null;\n            parentRect = null;\n            intersectionRect = null;\n          } else {\n            parentRect = crossOriginRect;\n          }\n        } else {\n          parentRect = rootRect;\n        }\n      } else {\n        // Check if there's a frame that can be navigated to.\n        var frame = getParentNode(parent);\n        var frameRect = frame && getBoundingClientRect(frame);\n        var frameIntersect =\n            frame &&\n            this._computeTargetAndRootIntersection(frame, frameRect, rootRect);\n        if (frameRect && frameIntersect) {\n          parent = frame;\n          parentRect = convertFromParentRect(frameRect, frameIntersect);\n        } else {\n          parent = null;\n          intersectionRect = null;\n        }\n      }\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      var doc = parent.ownerDocument;\n      if (parent != doc.body &&\n          parent != doc.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n    }\n    if (!intersectionRect) break;\n    parent = parent && getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {ClientRect} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root && !isDoc(this.root)) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var doc = isDoc(this.root) ? this.root : document;\n    var html = doc.documentElement;\n    var body = doc.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {DOMRect|ClientRect} rect The rect object to expand.\n * @return {ClientRect} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  var rootDoc =\n    (this.root && (this.root.ownerDocument || this.root)) || document;\n  return (\n    containsDeep(rootDoc, target) &&\n    (!this.root || rootDoc == target.ownerDocument)\n  );\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its execution, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detachEvent == 'function') {\n    node.detachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object|?ClientRect} The intersection rect or undefined if no\n *     intersection is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  } || null;\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {DOMRect|ClientRect} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {ClientRect} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n\n/**\n * Ensure that the result has all of the necessary fields of the DOMRect.\n * Specifically this ensures that `x` and `y` fields are set.\n *\n * @param {?DOMRect|?ClientRect} rect\n * @return {?DOMRect}\n */\nfunction ensureDOMRect(rect) {\n  // A `DOMRect` object has `x` and `y` fields.\n  if (!rect || 'x' in rect) {\n    return rect;\n  }\n  // A IE's `ClientRect` type does not have `x` and `y`. The same is the case\n  // for internally calculated Rect objects. For the purposes of\n  // `IntersectionObserver`, it's sufficient to simply mirror `left` and `top`\n  // for these fields.\n  return {\n    top: rect.top,\n    y: rect.top,\n    bottom: rect.bottom,\n    left: rect.left,\n    x: rect.left,\n    right: rect.right,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\n\n/**\n * Inverts the intersection and bounding rect from the parent (frame) BCR to\n * the local BCR space.\n * @param {DOMRect|ClientRect} parentBoundingRect The parent's bound client rect.\n * @param {DOMRect|ClientRect} parentIntersectionRect The parent's own intersection rect.\n * @return {ClientRect} The local root bounding rect for the parent's children.\n */\nfunction convertFromParentRect(parentBoundingRect, parentIntersectionRect) {\n  var top = parentIntersectionRect.top - parentBoundingRect.top;\n  var left = parentIntersectionRect.left - parentBoundingRect.left;\n  return {\n    top: top,\n    left: left,\n    height: parentIntersectionRect.height,\n    width: parentIntersectionRect.width,\n    bottom: top + parentIntersectionRect.height,\n    right: left + parentIntersectionRect.width\n  };\n}\n\n\n/**\n * Checks to see if a parent element contains a child element (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (node.nodeType == /* DOCUMENT */ 9 && node != document) {\n    // If this node is a document node, look for the embedding frame.\n    return getFrameElement(node);\n  }\n\n  // If the parent has element that is assigned through shadow root slot\n  if (parent && parent.assignedSlot) {\n    parent = parent.assignedSlot.parentNode\n  }\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n\n  return parent;\n}\n\n/**\n * Returns true if `node` is a Document.\n * @param {!Node} node\n * @returns {boolean}\n */\nfunction isDoc(node) {\n  return node && node.nodeType === 9;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}());\n","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n"],"names":["origSymbol","Symbol","hasSymbolSham","module","exports","Object","getOwnPropertySymbols","iterator","obj","sym","symObj","prototype","toString","call","_","keys","length","getOwnPropertyNames","syms","propertyIsEnumerable","getOwnPropertyDescriptor","descriptor","value","enumerable","Function","$hasOwn","hasOwnProperty","bind","addLeadingSlash","path","charAt","stripLeadingSlash","substr","stripBasename","prefix","toLowerCase","indexOf","hasBasename","stripTrailingSlash","slice","createPath","location","pathname","search","hash","createLocation","state","key","currentLocation","hashIndex","searchIndex","parsePath","undefined","decodeURI","e","URIError","locationsAreEqual","a","b","createTransitionManager","prompt","listeners","setPrompt","nextPrompt","confirmTransitionTo","action","getUserConfirmation","callback","result","appendListener","fn","isActive","listener","apply","arguments","push","filter","item","notifyListeners","_len","args","Array","_key","forEach","canUseDOM","window","document","createElement","getConfirmation","message","confirm","PopStateEvent","HashChangeEvent","getHistoryState","history","createBrowserHistory","props","ua","globalHistory","canUseHistory","navigator","userAgent","needsHashChangeListener","_props","_props$forceRefresh","forceRefresh","_props$getUserConfirm","_props$keyLength","keyLength","basename","getDOMLocation","historyState","_ref","_window$location","createKey","Math","random","transitionManager","setState","nextState","handlePopState","event","isExtraneousPopstateEvent","handlePop","handleHashChange","forceNextPop","ok","fromLocation","toLocation","toIndex","allKeys","fromIndex","delta","go","revertPop","initialLocation","createHref","n","listenerCount","checkDOMListeners","addEventListener","removeEventListener","isBlocked","href","pushState","prevIndex","nextKeys","replace","replaceState","goBack","goForward","block","unblock","listen","unlisten","HashChangeEvent$1","HashPathCoders","hashbang","encodePath","decodePath","noslash","slash","stripHash","url","getHashPath","substring","replaceHashPath","createHashHistory","_props$hashType","hashType","_HashPathCoders$hashT","ignorePath","encodedPath","prevLocation","allPaths","lastIndexOf","baseTag","querySelector","getAttribute","pushHashPath","nextPaths","clamp","lowerBound","upperBound","min","max","createMemoryHistory","_props$initialEntries","initialEntries","_props$initialIndex","initialIndex","entries","index","map","entry","nextIndex","nextEntries","splice","canGo","reactIs","REACT_STATICS","childContextTypes","contextType","contextTypes","defaultProps","displayName","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","mixins","propTypes","type","KNOWN_STATICS","name","caller","callee","arity","MEMO_STATICS","compare","TYPE_STATICS","getStatics","component","isMemo","ForwardRef","render","Memo","defineProperty","getPrototypeOf","objectPrototype","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","concat","targetStatics","sourceStatics","i","IntersectionObserverEntry","get","this","intersectionRatio","doc","frame","getFrameElement","ownerDocument","registry","crossOriginUpdater","crossOriginRect","IntersectionObserver","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","_setupCrossOriginUpdater","boundingClientRect","intersectionRect","convertFromParentRect","top","bottom","left","right","width","height","observer","_checkForIntersections","_resetCrossOriginUpdater","observe","target","_observationTargets","some","element","nodeType","Error","_registerInstance","_monitorIntersections","unobserve","_unmonitorIntersections","_unregisterInstance","disconnect","_unmonitorAllIntersections","takeRecords","records","_queuedEntries","_initThresholds","opt_threshold","threshold","isArray","sort","t","isNaN","_parseRootMargin","opt_rootMargin","margins","split","margin","parts","exec","parseFloat","unit","win","defaultView","_monitoringDocuments","monitoringInterval","domObserver","setInterval","addEvent","MutationObserver","attributes","childList","characterData","subtree","_monitoringUnsubscribes","clearInterval","removeEvent","rootDoc","root","hasDependentTargets","itemDoc","unsubscribe","unsubscribes","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","targetRect","getBoundingClientRect","rootContainsTarget","_rootContainsTarget","oldEntry","_computeTargetAndRootIntersection","rootBounds","newEntry","time","performance","now","_hasCrossedThreshold","isIntersecting","_callback","getComputedStyle","display","parent","getParentNode","atRoot","parentRect","parentComputedStyle","frameRect","frameIntersect","body","documentElement","overflow","computeRectIntersection","isDoc","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","frameElement","ensureDOMRect","targetArea","intersectionArea","Number","toFixed","opt_options","timeout","timer","options","setTimeout","rootMargin","join","node","opt_useCapture","attachEvent","detachEvent","rect1","rect2","el","err","y","x","parentBoundingRect","parentIntersectionRect","child","parentNode","assignedSlot","host","arr"],"sourceRoot":""}