{"version":3,"file":"js/23512-62307aab5e4051e8c6a9.js","mappings":"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","sources":["webpack://StravaModern/./node_modules/@reach/visually-hidden/dist/reach-visually-hidden.esm.js","webpack://StravaModern/./node_modules/@reach/alert/node_modules/@reach/utils/owner-document/dist/reach-utils-owner-document.esm.js","webpack://StravaModern/./node_modules/@reach/alert/node_modules/@reach/utils/can-use-dom/dist/reach-utils-can-use-dom.esm.js","webpack://StravaModern/./node_modules/@reach/alert/node_modules/@reach/utils/compose-refs/dist/reach-utils-compose-refs.esm.js","webpack://StravaModern/./node_modules/@reach/alert/node_modules/@reach/utils/type-check/dist/reach-utils-type-check.esm.js","webpack://StravaModern/./node_modules/@reach/alert/dist/reach-alert.esm.js","webpack://StravaModern/./node_modules/@reach/alert/node_modules/@reach/utils/use-previous/dist/reach-utils-use-previous.esm.js","webpack://StravaModern/./node_modules/@reach/auto-id/dist/auto-id.esm.js","webpack://StravaModern/./node_modules/@reach/descendants/dist/descendants.esm.js","webpack://StravaModern/./node_modules/@reach/dialog/node_modules/prop-types/factoryWithThrowingShims.js","webpack://StravaModern/./node_modules/@reach/dialog/node_modules/prop-types/index.js","webpack://StravaModern/./node_modules/@reach/dialog/node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://StravaModern/./node_modules/@reach/tabs/dist/tabs.esm.js","webpack://StravaModern/./node_modules/@strava/icons/LogosFacebookSmall.js","webpack://StravaModern/./node_modules/@strava/icons/LogosFacebookXsmall.js","webpack://StravaModern/./node_modules/@strava/react-hooks/src/use-local-storage/useLocalStorage.hook.js","webpack://StravaModern/./node_modules/@strava/react-hooks/src/use-safe-dispatch/useSafeDispatch.hook.js","webpack://StravaModern/./node_modules/@strava/react-hooks/src/use-safe-state/useSafeState.hook.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/constants.js","webpack://StravaModern/./node_modules/use-callback-ref/dist/es2015/useMergeRef.js","webpack://StravaModern/./node_modules/use-callback-ref/dist/es2015/useRef.js","webpack://StravaModern/./node_modules/use-callback-ref/dist/es2015/assignRef.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/FocusGuard.js","webpack://StravaModern/./node_modules/use-sidecar/dist/es2015/medium.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/medium.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/Lock.js","webpack://StravaModern/./node_modules/react-clientside-effect/lib/index.es.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/is.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/correctFocus.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/firstFocus.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/solver.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/array.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/tabOrder.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/tabUtils.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/tabbables.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/DOMutils.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/all-affected.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/getActiveElement.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/parenting.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/focusMerge.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/setFocus.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/index.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/focusInside.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/focusables.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/util.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/Trap.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/focusIsHidden.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/Combination.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/index.js","webpack://StravaModern/./node_modules/react-remove-scroll-bar/dist/es2015/constants.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/medium.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/UI.js","webpack://StravaModern/./node_modules/use-sidecar/dist/es2015/exports.js","webpack://StravaModern/./node_modules/get-nonce/dist/es2015/index.js","webpack://StravaModern/./node_modules/react-style-singleton/dist/es2015/singleton.js","webpack://StravaModern/./node_modules/react-style-singleton/dist/es2015/component.js","webpack://StravaModern/./node_modules/react-style-singleton/dist/es2015/hook.js","webpack://StravaModern/./node_modules/react-remove-scroll-bar/dist/es2015/utils.js","webpack://StravaModern/./node_modules/react-remove-scroll-bar/dist/es2015/component.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/handleScroll.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/SideEffect.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/sidecar.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/Combination.js","webpack://StravaModern/./node_modules/@reach/dialog/dist/dialog.esm.js","webpack://StravaModern/./node_modules/@strava/ui/Modal/styles.scss?b48f","webpack://StravaModern/./node_modules/@strava/ui/Modal/index.js","webpack://StravaModern/./node_modules/@strava/ui/ModalWithTabs/styles.scss?75dc","webpack://StravaModern/./node_modules/@strava/ui/ModalWithTabs/index.js","webpack://StravaModern/./node_modules/@strava/ui/Tabs/styles.scss?3265","webpack://StravaModern/./node_modules/@strava/ui/Tabs/index.js","webpack://StravaModern/./node_modules/email-validator/index.js","webpack://StravaModern/./node_modules/http-status-codes/build/es/status-codes.js","webpack://StravaModern/./node_modules/lodash-es/_baseMap.js","webpack://StravaModern/./node_modules/lodash-es/_baseSortBy.js","webpack://StravaModern/./node_modules/lodash-es/_compareAscending.js","webpack://StravaModern/./node_modules/lodash-es/_compareMultiple.js","webpack://StravaModern/./node_modules/lodash-es/_baseOrderBy.js","webpack://StravaModern/./node_modules/lodash-es/camelCase.js","webpack://StravaModern/./node_modules/lodash-es/compact.js","webpack://StravaModern/./node_modules/lodash-es/_escapeHtmlChar.js","webpack://StravaModern/./node_modules/lodash-es/escape.js","webpack://StravaModern/./node_modules/lodash-es/_createFind.js","webpack://StravaModern/./node_modules/lodash-es/findIndex.js","webpack://StravaModern/./node_modules/lodash-es/find.js","webpack://StravaModern/./node_modules/lodash-es/isNil.js","webpack://StravaModern/./node_modules/lodash-es/orderBy.js","webpack://StravaModern/./node_modules/lodash-es/last.js","webpack://StravaModern/./node_modules/lodash-es/_parent.js","webpack://StravaModern/./node_modules/lodash-es/_baseUnset.js","webpack://StravaModern/./node_modules/lodash-es/_basePullAt.js","webpack://StravaModern/./node_modules/lodash-es/remove.js","webpack://StravaModern/./node_modules/lodash-es/isString.js","webpack://StravaModern/./node_modules/lodash-es/_asciiSize.js","webpack://StravaModern/./node_modules/lodash-es/_unicodeSize.js","webpack://StravaModern/./node_modules/lodash-es/_stringSize.js","webpack://StravaModern/./node_modules/lodash-es/size.js","webpack://StravaModern/./node_modules/lodash-es/sortBy.js","webpack://StravaModern/./node_modules/lodash-es/toLower.js","webpack://StravaModern/./node_modules/lodash-es/_charsEndIndex.js","webpack://StravaModern/./node_modules/lodash-es/_charsStartIndex.js","webpack://StravaModern/./node_modules/lodash-es/trim.js","webpack://StravaModern/./node_modules/lodash-es/noop.js","webpack://StravaModern/./node_modules/lodash-es/_createSet.js","webpack://StravaModern/./node_modules/lodash-es/_baseUniq.js","webpack://StravaModern/./node_modules/lodash-es/uniqBy.js","webpack://StravaModern/./node_modules/react-intersection-observer/react-intersection-observer.m.js"],"sourcesContent":["import { forwardRef, createElement } from 'react';\nimport PropTypes from 'prop-types';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nvar _excluded = [\"as\", \"style\"];\n\n/**\n * VisuallyHidden\n *\n * Provides text for screen readers that is visually hidden.\n * It is the logical opposite of the `aria-hidden` attribute.\n */\nvar VisuallyHidden = /*#__PURE__*/forwardRef(function VisuallyHidden(_ref, ref) {\n  var _ref$as = _ref.as,\n      Comp = _ref$as === void 0 ? \"span\" : _ref$as,\n      _ref$style = _ref.style,\n      style = _ref$style === void 0 ? {} : _ref$style,\n      props = _objectWithoutPropertiesLoose(_ref, _excluded);\n\n  return /*#__PURE__*/createElement(Comp, _extends({\n    ref: ref,\n    style: _extends({\n      border: 0,\n      clip: \"rect(0 0 0 0)\",\n      height: \"1px\",\n      margin: \"-1px\",\n      overflow: \"hidden\",\n      padding: 0,\n      position: \"absolute\",\n      width: \"1px\",\n      // https://medium.com/@jessebeach/beware-smushed-off-screen-accessible-text-5952a4c2cbfe\n      whiteSpace: \"nowrap\",\n      wordWrap: \"normal\"\n    }, style)\n  }, props));\n});\n/**\n * @see Docs https://reach.tech/visually-hidden#visuallyhidden-props\n */\n\nif (process.env.NODE_ENV !== \"production\") {\n  VisuallyHidden.displayName = \"VisuallyHidden\";\n  VisuallyHidden.propTypes = {\n    as: PropTypes.any,\n    children: PropTypes.node\n  };\n} ////////////////////////////////////////////////////////////////////////////////\n\nexport default VisuallyHidden;\nexport { VisuallyHidden };\n","import { canUseDOM } from '../../can-use-dom/dist/reach-utils-can-use-dom.esm.js';\n\n/**\n * Get an element's owner document. Useful when components are used in iframes\n * or other environments like dev tools.\n *\n * @param element\n */\n\nfunction getOwnerDocument(element) {\n  return canUseDOM() ? element ? element.ownerDocument : document : null;\n}\n/**\n * TODO: Remove in 1.0\n */\n\nfunction getOwnerWindow(element) {\n  var ownerDocument = getOwnerDocument(element);\n  return ownerDocument ? ownerDocument.defaultView || window : null;\n}\n\nexport { getOwnerDocument, getOwnerWindow };\n","function canUseDOM() {\n  return !!(typeof window !== \"undefined\" && window.document && window.document.createElement);\n}\n\nexport { canUseDOM };\n","import { useCallback } from 'react';\nimport { isFunction } from '../../type-check/dist/reach-utils-type-check.esm.js';\n\nfunction _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++) arr2[i] = arr[i];\n\n  return arr2;\n}\n\nfunction _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\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it;\n\n  if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) {\n    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n      return function () {\n        if (i >= o.length) return {\n          done: true\n        };\n        return {\n          done: false,\n          value: o[i++]\n        };\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  it = o[Symbol.iterator]();\n  return it.next.bind(it);\n}\n\n/**\n * Passes or assigns an arbitrary value to a ref function or object.\n *\n * @param ref\n * @param value\n */\nfunction assignRef(ref, value) {\n  if (ref == null) return;\n\n  if (isFunction(ref)) {\n    ref(value);\n  } else {\n    try {\n      ref.current = value;\n    } catch (error) {\n      throw new Error(\"Cannot assign value \\\"\" + value + \"\\\" to ref \\\"\" + ref + \"\\\"\");\n    }\n  }\n}\n/**\n * Passes or assigns a value to multiple refs (typically a DOM node). Useful for\n * dealing with components that need an explicit ref for DOM calculations but\n * also forwards refs assigned by an app.\n *\n * @param refs Refs to fork\n */\n\nfunction useComposedRefs() {\n  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {\n    refs[_key] = arguments[_key];\n  }\n\n  return useCallback(function (node) {\n    for (var _iterator = _createForOfIteratorHelperLoose(refs), _step; !(_step = _iterator()).done;) {\n      var ref = _step.value;\n      assignRef(ref, node);\n    } // eslint-disable-next-line react-hooks/exhaustive-deps\n\n  }, refs);\n}\n\nexport { assignRef, useComposedRefs };\n","/**\n * Checks whether or not a value is a boolean.\n *\n * @param value\n */\nfunction isBoolean(value) {\n  return typeof value === \"boolean\";\n}\n/**\n * Checks whether or not a value is a function.\n *\n * @param value\n */\n\nfunction isFunction(value) {\n  // eslint-disable-next-line eqeqeq\n  return !!(value && {}.toString.call(value) == \"[object Function]\");\n}\n/**\n * Checks whether or not a value is a number.\n *\n * @param value\n */\n\nfunction isNumber(value) {\n  return typeof value === \"number\" && !isNaN(value);\n}\n/**\n * Checks whether or not a value is a string.\n *\n * @param value\n */\n\nfunction isString(value) {\n  return typeof value === \"string\";\n}\n\nexport { isBoolean, isFunction, isNumber, isString };\n","import { forwardRef, useRef, useMemo, createElement, useEffect, cloneElement } from 'react';\nimport { render } from 'react-dom';\nimport { VisuallyHidden } from '@reach/visually-hidden';\nimport { usePrevious } from '@reach/utils/use-previous';\nimport { getOwnerDocument } from '@reach/utils/owner-document';\nimport { useComposedRefs } from '@reach/utils/compose-refs';\nimport PropTypes from 'prop-types';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nvar _excluded = [\"as\", \"children\", \"type\"];\n\n/*\n * Singleton state is fine because you don't server render\n * an alert (SRs don't read them on first load anyway)\n */\nvar keys = {\n  polite: -1,\n  assertive: -1\n};\nvar elements = {\n  polite: {},\n  assertive: {}\n};\nvar liveRegions = {\n  polite: null,\n  assertive: null\n};\nvar renderTimer; ////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Alert\n *\n * Screen-reader-friendly alert messages. In many apps developers add \"alert\"\n * messages when network events or other things happen. Users with assistive\n * technologies may not know about the message unless you develop for it.\n *\n * @see Docs https://reach.tech/alert\n */\n\nvar Alert = /*#__PURE__*/forwardRef(function Alert(_ref, forwardedRef) {\n  var _ref$as = _ref.as,\n      Comp = _ref$as === void 0 ? \"div\" : _ref$as,\n      children = _ref.children,\n      _ref$type = _ref.type,\n      regionType = _ref$type === void 0 ? \"polite\" : _ref$type,\n      props = _objectWithoutPropertiesLoose(_ref, _excluded);\n\n  var ownRef = useRef(null);\n  var ref = useComposedRefs(forwardedRef, ownRef);\n  var child = useMemo(function () {\n    return /*#__PURE__*/createElement(Comp, _extends({}, props, {\n      ref: ref,\n      \"data-reach-alert\": true\n    }), children);\n  }, // eslint-disable-next-line react-hooks/exhaustive-deps\n  [children, props]);\n  useMirrorEffects(regionType, child, ownRef);\n  return child;\n});\n/**\n * @see Docs https://reach.tech/alert#alert-props\n */\n\nif (process.env.NODE_ENV !== \"production\") {\n  Alert.displayName = \"Alert\";\n  Alert.propTypes = {\n    children: PropTypes.node,\n    type: /*#__PURE__*/PropTypes.oneOf([\"assertive\", \"polite\"])\n  };\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nfunction createMirror(type, doc) {\n  var key = ++keys[type];\n\n  var mount = function mount(element) {\n    if (liveRegions[type]) {\n      elements[type][key] = element;\n      renderAlerts();\n    } else {\n      var node = doc.createElement(\"div\");\n      node.setAttribute(\"data-reach-live-\" + type, \"true\");\n      liveRegions[type] = node;\n      doc.body.appendChild(liveRegions[type]);\n      mount(element);\n    }\n  };\n\n  var update = function update(element) {\n    elements[type][key] = element;\n    renderAlerts();\n  };\n\n  var unmount = function unmount() {\n    delete elements[type][key];\n    renderAlerts();\n  };\n\n  return {\n    mount: mount,\n    update: update,\n    unmount: unmount\n  };\n}\n\nfunction renderAlerts() {\n  if (renderTimer != null) {\n    window.clearTimeout(renderTimer);\n  }\n\n  renderTimer = window.setTimeout(function () {\n    Object.keys(elements).forEach(function (elementType) {\n      var regionType = elementType;\n      var container = liveRegions[regionType];\n\n      if (container) {\n        render( /*#__PURE__*/createElement(VisuallyHidden, {\n          as: \"div\"\n        }, /*#__PURE__*/createElement(\"div\", {\n          // The status role is a type of live region and a container whose\n          // content is advisory information for the user that is not\n          // important enough to justify an alert, and is often presented as\n          // a status bar. When the role is added to an element, the browser\n          // will send out an accessible status event to assistive\n          // technology products which can then notify the user about it.\n          // https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_status_role\n          role: regionType === \"assertive\" ? \"alert\" : \"status\",\n          \"aria-live\": regionType\n        }, Object.keys(elements[regionType]).map(function (key) {\n          return /*#__PURE__*/cloneElement(elements[regionType][key], {\n            key: key,\n            ref: null\n          });\n        }))), liveRegions[regionType]);\n      }\n    });\n  }, 500);\n}\n\nfunction useMirrorEffects(regionType, element, ref) {\n  var prevType = usePrevious(regionType);\n  var mirror = useRef(null);\n  var mounted = useRef(false);\n  useEffect(function () {\n    var ownerDocument = getOwnerDocument(ref.current);\n\n    if (!mounted.current) {\n      mounted.current = true;\n      mirror.current = createMirror(regionType, ownerDocument);\n      mirror.current.mount(element);\n    } else if (prevType !== regionType) {\n      mirror.current && mirror.current.unmount();\n      mirror.current = createMirror(regionType, ownerDocument);\n      mirror.current.mount(element);\n    } else {\n      mirror.current && mirror.current.update(element);\n    }\n  }, [element, regionType, prevType, ref]);\n  useEffect(function () {\n    return function () {\n      mirror.current && mirror.current.unmount();\n    };\n  }, []);\n} ////////////////////////////////////////////////////////////////////////////////\n\nexport default Alert;\nexport { Alert };\n","import { useRef, useEffect } from 'react';\n\n/**\n * Returns the previous value of a reference after a component update.\n *\n * @param value\n */\n\nfunction usePrevious(value) {\n  var ref = useRef(null);\n  useEffect(function () {\n    ref.current = value;\n  }, [value]);\n  return ref.current;\n}\n\nexport { usePrevious };\n","import { useState, useEffect } from 'react';\nimport { useIsomorphicLayoutEffect } from '@reach/utils';\n\n/*\r\n * Welcome to @reach/auto-id!\r\n\n * Let's see if we can make sense of why this hook exists and its\r\n * implementation.\r\n *\r\n * Some background:\r\n *   1. Accessibiliy APIs rely heavily on element IDs\r\n *   2. Requiring developers to put IDs on every element in Reach UI is both\r\n *      cumbersome and error-prone\r\n *   3. With a component model, we can generate IDs for them!\r\n *\r\n * Solution 1: Generate random IDs.\r\n *\r\n * This works great as long as you don't server render your app. When React (in\r\n * the client) tries to reuse the markup from the server, the IDs won't match\r\n * and React will then recreate the entire DOM tree.\r\n *\r\n * Solution 2: Increment an integer\r\n *\r\n * This sounds great. Since we're rendering the exact same tree on the server\r\n * and client, we can increment a counter and get a deterministic result between\r\n * client and server. Also, JS integers can go up to nine-quadrillion. I'm\r\n * pretty sure the tab will be closed before an app never needs\r\n * 10 quadrillion IDs!\r\n *\r\n * Problem solved, right?\r\n *\r\n * Ah, but there's a catch! React's concurrent rendering makes this approach\r\n * non-deterministic. While the client and server will end up with the same\r\n * elements in the end, depending on suspense boundaries (and possibly some user\r\n * input during the initial render) the incrementing integers won't always match\r\n * up.\r\n *\r\n * Solution 3: Don't use IDs at all on the server; patch after first render.\r\n *\r\n * What we've done here is solution 2 with some tricks. With this approach, the\r\n * ID returned is an empty string on the first render. This way the server and\r\n * client have the same markup no matter how wild the concurrent rendering may\r\n * have gotten.\r\n *\r\n * After the render, we patch up the components with an incremented ID. This\r\n * causes a double render on any components with `useId`. Shouldn't be a problem\r\n * since the components using this hook should be small, and we're only updating\r\n * the ID attribute on the DOM, nothing big is happening.\r\n *\r\n * It doesn't have to be an incremented number, though--we could do generate\r\n * random strings instead, but incrementing a number is probably the cheapest\r\n * thing we can do.\r\n *\r\n * Additionally, we only do this patchup on the very first client render ever.\r\n * Any calls to `useId` that happen dynamically in the client will be\r\n * populated immediately with a value. So, we only get the double render after\r\n * server hydration and never again, SO BACK OFF ALRIGHT?\r\n */\nvar serverHandoffComplete = false;\nvar id = 0;\n\nvar genId = function genId() {\n  return ++id;\n};\n/**\r\n * useId\r\n *\r\n * Autogenerate IDs to facilitate WAI-ARIA and server rendering.\r\n *\r\n * Note: The returned ID will initially be `null` and will update after a\r\n * component mounts. Users may need to supply their own ID if they need\r\n * consistent values for SSR.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/auto-id\r\n */\n\n\nvar useId = function useId(idFromProps) {\n  /*\r\n   * If this instance isn't part of the initial render, we don't have to do the\r\n   * double render/patch-up dance. We can just generate the ID and return it.\r\n   */\n  var initialId = idFromProps || (serverHandoffComplete ? genId() : null);\n\n  var _useState = useState(initialId),\n      id = _useState[0],\n      setId = _useState[1];\n\n  useIsomorphicLayoutEffect(function () {\n    if (id === null) {\n      /*\r\n       * Patch the ID after render. We do this in `useLayoutEffect` to avoid any\r\n       * rendering flicker, though it'll make the first render slower (unlikely\r\n       * to matter, but you're welcome to measure your app and let us know if\r\n       * it's a problem).\r\n       */\n      setId(genId());\n    } // eslint-disable-next-line react-hooks/exhaustive-deps\n\n  }, []);\n  useEffect(function () {\n    if (serverHandoffComplete === false) {\n      /*\r\n       * Flag all future uses of `useId` to skip the update dance. This is in\r\n       * `useEffect` because it goes after `useLayoutEffect`, ensuring we don't\r\n       * accidentally bail out of the patch-up dance prematurely.\r\n       */\n      serverHandoffComplete = true;\n    }\n  }, []);\n  return id != null ? String(id) : undefined;\n};\n\nexport { useId };\n//# sourceMappingURL=auto-id.esm.js.map\n","import React, { useState, useContext, useCallback, useMemo } from 'react';\nimport { createNamedContext, usePrevious, useIsomorphicLayoutEffect, noop } from '@reach/utils';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction createDescendantContext(name, initialValue) {\n  if (initialValue === void 0) {\n    initialValue = {};\n  }\n\n  var descendants = [];\n  return createNamedContext(name, _extends({\n    descendants: descendants,\n    registerDescendant: noop,\n    unregisterDescendant: noop\n  }, initialValue));\n}\n/**\r\n * This hook registers our descendant by passing it into an array. We can then\r\n * search that array by to find its index when registering it in the component.\r\n * We use this for focus management, keyboard navigation, and typeahead\r\n * functionality for some components.\r\n *\r\n * The hook accepts the element node and (optionally) a key. The key is useful\r\n * if multiple descendants have identical text values and we need to\r\n * differentiate siblings for some reason.\r\n *\r\n * Our main goals with this are:\r\n *   1) maximum composability,\r\n *   2) minimal API friction\r\n *   3) SSR compatibility*\r\n *   4) concurrent safe\r\n *   5) index always up-to-date with the tree despite changes\r\n *   6) works with memoization of any component in the tree (hopefully)\r\n *\r\n * * As for SSR, the good news is that we don't actually need the index on the\r\n * server for most use-cases, as we are only using it to determine the order of\r\n * composed descendants for keyboard navigation. However, in the few cases where\r\n * this is not the case, we can require an explicit index from the app.\r\n */\n\nfunction useDescendant(descendant, context, indexProp) {\n  var _useState = useState(),\n      forceUpdate = _useState[1];\n\n  var _useContext = useContext(context),\n      registerDescendant = _useContext.registerDescendant,\n      unregisterDescendant = _useContext.unregisterDescendant,\n      descendants = _useContext.descendants; // This will initially return -1 because we haven't registered the descendant\n  // on the first render. After we register, this will then return the correct\n  // index on the following render and we will re-register descendants\n  // so that everything is up-to-date before the user interacts with a\n  // collection.\n\n\n  var index = indexProp !== null && indexProp !== void 0 ? indexProp : descendants.findIndex(function (item) {\n    return item.element === descendant.element;\n  });\n  var previousDescendants = usePrevious(descendants); // We also need to re-register descendants any time ANY of the other\n  // descendants have changed. My brain was melting when I wrote this and it\n  // feels a little off, but checking in render and using the result in the\n  // effect's dependency array works well enough.\n\n  var someDescendantsHaveChanged = descendants.some(function (descendant, index) {\n    var _previousDescendants$;\n\n    return descendant.element !== (previousDescendants === null || previousDescendants === void 0 ? void 0 : (_previousDescendants$ = previousDescendants[index]) === null || _previousDescendants$ === void 0 ? void 0 : _previousDescendants$.element);\n  }); // Prevent any flashing\n\n  useIsomorphicLayoutEffect(function () {\n    if (!descendant.element) forceUpdate({});\n    registerDescendant(_extends({}, descendant, {\n      index: index\n    }));\n    return function () {\n      return unregisterDescendant(descendant.element);\n    }; // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [registerDescendant, unregisterDescendant, index, someDescendantsHaveChanged].concat(Object.values(descendant)));\n  return index;\n}\nfunction useDescendantsInit() {\n  return useState([]);\n}\nfunction useDescendants(ctx) {\n  return useContext(ctx).descendants;\n}\nfunction DescendantProvider(_ref) {\n  var Ctx = _ref.context,\n      children = _ref.children,\n      items = _ref.items,\n      set = _ref.set;\n  var registerDescendant = useCallback(function (_ref2) {\n    var element = _ref2.element,\n        explicitIndex = _ref2.index,\n        rest = _objectWithoutPropertiesLoose(_ref2, [\"element\", \"index\"]);\n\n    if (!element) {\n      return;\n    }\n\n    set(function (items) {\n      var newItems;\n\n      if (explicitIndex != null) {\n        newItems = [].concat(items, [_extends({}, rest, {\n          element: element,\n          index: explicitIndex\n        })]);\n      } else if (items.length === 0) {\n        // If there are no items, register at index 0 and bail.\n        newItems = [].concat(items, [_extends({}, rest, {\n          element: element,\n          index: 0\n        })]);\n      } else if (items.find(function (item) {\n        return item.element === element;\n      })) {\n        // If the element is already registered, just use the same array\n        newItems = items;\n      } else {\n        // When registering a descendant, we need to make sure we insert in\n        // into the array in the same order that it appears in the DOM. So as\n        // new descendants are added or maybe some are removed, we always know\n        // that the array is up-to-date and correct.\n        //\n        // So here we look at our registered descendants and see if the new\n        // element we are adding appears earlier than an existing descendant's\n        // DOM node via `node.compareDocumentPosition`. If it does, we insert\n        // the new element at this index. Because `registerDescendant` will be\n        // called in an effect every time the descendants state value changes,\n        // we should be sure that this index is accurate when descendent\n        // elements come or go from our component.\n        var index = items.findIndex(function (item) {\n          if (!item.element || !element) {\n            return false;\n          } // Does this element's DOM node appear before another item in the\n          // array in our DOM tree? If so, return true to grab the index at\n          // this point in the array so we know where to insert the new\n          // element.\n\n\n          return Boolean(item.element.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_PRECEDING);\n        });\n\n        var newItem = _extends({}, rest, {\n          element: element,\n          index: index\n        }); // If an index is not found we will push the element to the end.\n\n\n        if (index === -1) {\n          newItems = [].concat(items, [newItem]);\n        } else {\n          newItems = [].concat(items.slice(0, index), [newItem], items.slice(index));\n        }\n      }\n\n      return newItems.map(function (item, index) {\n        return _extends({}, item, {\n          index: index\n        });\n      });\n    });\n  }, // set is a state setter initialized by the useDescendants hook.\n  // We can safely ignore the lint warning here because it will not change\n  // between renders.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  []);\n  var unregisterDescendant = useCallback(function (element) {\n    if (!element) {\n      return;\n    }\n\n    set(function (items) {\n      return items.filter(function (item) {\n        return element !== item.element;\n      });\n    });\n  }, // set is a state setter initialized by the useDescendants hook.\n  // We can safely ignore the lint warning here because it will not change\n  // between renders.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  []);\n  return React.createElement(Ctx.Provider, {\n    value: useMemo(function () {\n      return {\n        descendants: items,\n        registerDescendant: registerDescendant,\n        unregisterDescendant: unregisterDescendant\n      };\n    }, [items, registerDescendant, unregisterDescendant])\n  }, children);\n}\n/**\r\n * Testing this as an abstraction for compound components that use keyboard\r\n * navigation. Hoping this will help us prevent bugs and mismatched behavior\r\n * across various components, but it may also prove to be too messy of an\r\n * abstraction in the end.\r\n *\r\n * Currently used in:\r\n *   - Tabs\r\n *   - Accordion\r\n *\r\n * @param context\r\n * @param options\r\n */\n\nfunction useDescendantKeyDown(context, options) {\n  var _useContext2 = useContext(context),\n      descendants = _useContext2.descendants;\n\n  var callback = options.callback,\n      currentIndex = options.currentIndex,\n      filter = options.filter,\n      _options$key = options.key,\n      key = _options$key === void 0 ? \"index\" : _options$key,\n      _options$orientation = options.orientation,\n      orientation = _options$orientation === void 0 ? \"vertical\" : _options$orientation,\n      _options$rotate = options.rotate,\n      rotate = _options$rotate === void 0 ? true : _options$rotate,\n      _options$rtl = options.rtl,\n      rtl = _options$rtl === void 0 ? false : _options$rtl;\n  var index = currentIndex !== null && currentIndex !== void 0 ? currentIndex : -1;\n  return function handleKeyDown(event) {\n    if (![\"ArrowDown\", \"ArrowUp\", \"ArrowLeft\", \"ArrowRight\", \"PageUp\", \"PageDown\", \"Home\", \"End\"].includes(event.key)) {\n      return;\n    } // If we use a filter function, we need to re-index our descendants array\n    // so that filtered descendent elements aren't selected.\n\n\n    var selectableDescendants = filter ? descendants.filter(filter) : descendants; // Current index should map to the updated array vs. the original\n    // descendants array.\n\n    if (filter) {\n      index = selectableDescendants.findIndex(function (descendant) {\n        return descendant.index === currentIndex;\n      });\n    } // We need some options for any of this to work!\n\n\n    if (!selectableDescendants.length) {\n      return;\n    }\n\n    function getNextOption() {\n      var atBottom = index === selectableDescendants.length - 1;\n      return atBottom ? rotate ? getFirstOption() : selectableDescendants[index] : selectableDescendants[(index + 1) % selectableDescendants.length];\n    }\n\n    function getPreviousOption() {\n      var atTop = index === 0;\n      return atTop ? rotate ? getLastOption() : selectableDescendants[index] : selectableDescendants[(index - 1 + selectableDescendants.length) % selectableDescendants.length];\n    }\n\n    function getFirstOption() {\n      return selectableDescendants[0];\n    }\n\n    function getLastOption() {\n      return selectableDescendants[selectableDescendants.length - 1];\n    }\n\n    switch (event.key) {\n      case \"ArrowDown\":\n        if (orientation === \"vertical\" || orientation === \"both\") {\n          event.preventDefault();\n          var next = getNextOption();\n          callback(key === \"option\" ? next : next[key]);\n        }\n\n        break;\n\n      case \"ArrowUp\":\n        if (orientation === \"vertical\" || orientation === \"both\") {\n          event.preventDefault();\n          var prev = getPreviousOption();\n          callback(key === \"option\" ? prev : prev[key]);\n        }\n\n        break;\n\n      case \"ArrowLeft\":\n        if (orientation === \"horizontal\" || orientation === \"both\") {\n          event.preventDefault();\n          var nextOrPrev = (rtl ? getNextOption : getPreviousOption)();\n          callback(key === \"option\" ? nextOrPrev : nextOrPrev[key]);\n        }\n\n        break;\n\n      case \"ArrowRight\":\n        if (orientation === \"horizontal\" || orientation === \"both\") {\n          event.preventDefault();\n          var prevOrNext = (rtl ? getPreviousOption : getNextOption)();\n          callback(key === \"option\" ? prevOrNext : prevOrNext[key]);\n        }\n\n        break;\n\n      case \"PageUp\":\n        event.preventDefault();\n        var prevOrFirst = (event.ctrlKey ? getPreviousOption : getFirstOption)();\n        callback(key === \"option\" ? prevOrFirst : prevOrFirst[key]);\n        break;\n\n      case \"Home\":\n        event.preventDefault();\n        var first = getFirstOption();\n        callback(key === \"option\" ? first : first[key]);\n        break;\n\n      case \"PageDown\":\n        event.preventDefault();\n        var nextOrLast = (event.ctrlKey ? getNextOption : getLastOption)();\n        callback(key === \"option\" ? nextOrLast : nextOrLast[key]);\n        break;\n\n      case \"End\":\n        event.preventDefault();\n        var last = getLastOption();\n        callback(key === \"option\" ? last : last[key]);\n        break;\n    }\n  };\n}\n\nexport { DescendantProvider, createDescendantContext, useDescendant, useDescendantKeyDown, useDescendants, useDescendantsInit };\n//# sourceMappingURL=descendants.esm.js.map\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","import React, { useRef, useState, useMemo, useEffect, useContext, Children } from 'react';\nimport PropTypes from 'prop-types';\nimport { useDescendantsInit, DescendantProvider, useDescendant, createDescendantContext, useDescendants, useDescendantKeyDown } from '@reach/descendants';\nimport { forwardRefWithAs, useControlledSwitchWarning, makeId, useControlledState, noop, checkStyles, isFunction, isNumber, memoWithAs, useForkedRef, useUpdateEffect, useEventCallback, wrapEvent, createNamedContext, getElementComputedStyle, useIsomorphicLayoutEffect, boolOrBoolString, cloneValidElement } from '@reach/utils';\nimport { useId } from '@reach/auto-id';\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nvar TabsDescendantsContext = /*#__PURE__*/createDescendantContext(\"TabsDescendantsContext\");\nvar TabPanelDescendantsContext = /*#__PURE__*/createDescendantContext(\"TabPanelDescendantsContext\");\nvar TabsContext = /*#__PURE__*/createNamedContext(\"TabsContext\", {});\nvar TabsKeyboardActivation;\n\n(function (TabsKeyboardActivation) {\n  TabsKeyboardActivation[\"Auto\"] = \"auto\";\n  TabsKeyboardActivation[\"Manual\"] = \"manual\";\n})(TabsKeyboardActivation || (TabsKeyboardActivation = {}));\n\nvar TabsOrientation;\n\n(function (TabsOrientation) {\n  TabsOrientation[\"Horizontal\"] = \"horizontal\";\n  TabsOrientation[\"Vertical\"] = \"vertical\";\n})(TabsOrientation || (TabsOrientation = {})); ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * Tabs\r\n *\r\n * The parent component of the tab interface.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/tabs#tabs\r\n */\n\n\nvar Tabs = /*#__PURE__*/forwardRefWithAs(function Tabs(_ref, ref) {\n  var _props$id;\n\n  var _ref$as = _ref.as,\n      Comp = _ref$as === void 0 ? \"div\" : _ref$as,\n      children = _ref.children,\n      defaultIndex = _ref.defaultIndex,\n      _ref$orientation = _ref.orientation,\n      orientation = _ref$orientation === void 0 ? TabsOrientation.Horizontal : _ref$orientation,\n      _ref$index = _ref.index,\n      controlledIndex = _ref$index === void 0 ? undefined : _ref$index,\n      _ref$keyboardActivati = _ref.keyboardActivation,\n      keyboardActivation = _ref$keyboardActivati === void 0 ? TabsKeyboardActivation.Auto : _ref$keyboardActivati,\n      onChange = _ref.onChange,\n      _ref$readOnly = _ref.readOnly,\n      readOnly = _ref$readOnly === void 0 ? false : _ref$readOnly,\n      props = _objectWithoutPropertiesLoose(_ref, [\"as\", \"children\", \"defaultIndex\", \"orientation\", \"index\", \"keyboardActivation\", \"onChange\", \"readOnly\"]);\n\n  var isControlled = useRef(controlledIndex != null);\n  useControlledSwitchWarning(controlledIndex, \"index\", \"Tabs\");\n\n  var _id = useId(props.id);\n\n  var id = (_props$id = props.id) !== null && _props$id !== void 0 ? _props$id : makeId(\"tabs\", _id); // We only manage focus if the user caused the update vs. a new controlled\n  // index coming in.\n\n  var userInteractedRef = useRef(false);\n  var selectedPanelRef = useRef(null);\n  var isRTL = useRef(false);\n\n  var _useControlledState = useControlledState(controlledIndex, defaultIndex !== null && defaultIndex !== void 0 ? defaultIndex : 0),\n      selectedIndex = _useControlledState[0],\n      setSelectedIndex = _useControlledState[1];\n\n  var _useState = useState(-1),\n      focusedIndex = _useState[0],\n      setFocusedIndex = _useState[1];\n\n  var _useDescendantsInit = useDescendantsInit(),\n      tabs = _useDescendantsInit[0],\n      setTabs = _useDescendantsInit[1];\n\n  var context = useMemo(function () {\n    return {\n      focusedIndex: focusedIndex,\n      id: id,\n      isControlled: isControlled.current,\n      isRTL: isRTL,\n      keyboardActivation: keyboardActivation,\n      onFocusPanel: function onFocusPanel() {\n        var _selectedPanelRef$cur;\n\n        (_selectedPanelRef$cur = selectedPanelRef.current) === null || _selectedPanelRef$cur === void 0 ? void 0 : _selectedPanelRef$cur.focus();\n      },\n      onSelectTab: readOnly ? noop : function (index) {\n        userInteractedRef.current = true;\n        onChange && onChange(index);\n        setSelectedIndex(index);\n      },\n      onSelectTabWithKeyboard: readOnly ? noop : function (index) {\n        var _tabs$index$element;\n\n        userInteractedRef.current = true;\n\n        switch (keyboardActivation) {\n          case TabsKeyboardActivation.Manual:\n            (_tabs$index$element = tabs[index].element) === null || _tabs$index$element === void 0 ? void 0 : _tabs$index$element.focus();\n            return;\n\n          case TabsKeyboardActivation.Auto:\n          default:\n            onChange && onChange(index);\n            setSelectedIndex(index);\n            return;\n        }\n      },\n      orientation: orientation,\n      selectedIndex: selectedIndex,\n      selectedPanelRef: selectedPanelRef,\n      setFocusedIndex: setFocusedIndex,\n      setSelectedIndex: setSelectedIndex,\n      userInteractedRef: userInteractedRef\n    };\n  }, [focusedIndex, id, keyboardActivation, onChange, orientation, readOnly, selectedIndex, setSelectedIndex, tabs]);\n  useEffect(function () {\n    return checkStyles(\"tabs\");\n  }, []);\n  return React.createElement(DescendantProvider, {\n    context: TabsDescendantsContext,\n    items: tabs,\n    set: setTabs\n  }, React.createElement(TabsContext.Provider, {\n    value: context\n  }, React.createElement(Comp, Object.assign({}, props, {\n    ref: ref,\n    \"data-reach-tabs\": \"\",\n    \"data-orientation\": orientation,\n    id: props.id\n  }), isFunction(children) ? children({\n    focusedIndex: focusedIndex,\n    id: id,\n    selectedIndex: selectedIndex\n  }) : children)));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  Tabs.displayName = \"Tabs\";\n  Tabs.propTypes = {\n    children: PropTypes.node.isRequired,\n    onChange: PropTypes.func,\n    orientation: /*#__PURE__*/PropTypes.oneOf( /*#__PURE__*/Object.values(TabsOrientation)),\n    index: function index(props, name, compName, location, propName) {\n      var val = props[name];\n\n      if (props.index > -1 && props.onChange == null && props.readOnly !== true) {\n        return new Error(\"You provided a value prop to `\" + compName + \"` without an `onChange` handler. This will render a read-only tabs element. If the tabs should be mutable use `defaultIndex`. Otherwise, set `onChange`.\");\n      } else if (val != null && !isNumber(val)) {\n        return new Error(\"Invalid prop `\" + propName + \"` supplied to `\" + compName + \"`. Expected `number`, received `\" + (Array.isArray(val) ? \"array\" : typeof val) + \"`.\");\n      }\n\n      return null;\n    },\n    defaultIndex: PropTypes.number\n  };\n} ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * TabList\r\n *\r\n * The parent component of the tabs.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/tabs#tablist\r\n */\n\n\nvar TabListImpl = /*#__PURE__*/forwardRefWithAs(function TabList(_ref2, forwardedRef) {\n  var children = _ref2.children,\n      _ref2$as = _ref2.as,\n      Comp = _ref2$as === void 0 ? \"div\" : _ref2$as,\n      onKeyDown = _ref2.onKeyDown,\n      props = _objectWithoutPropertiesLoose(_ref2, [\"children\", \"as\", \"onKeyDown\"]);\n\n  var _useContext = useContext(TabsContext),\n      focusedIndex = _useContext.focusedIndex,\n      isControlled = _useContext.isControlled,\n      isRTL = _useContext.isRTL,\n      keyboardActivation = _useContext.keyboardActivation,\n      onSelectTabWithKeyboard = _useContext.onSelectTabWithKeyboard,\n      orientation = _useContext.orientation,\n      selectedIndex = _useContext.selectedIndex,\n      setSelectedIndex = _useContext.setSelectedIndex;\n\n  var tabs = useDescendants(TabsDescendantsContext);\n  var ownRef = useRef(null);\n  var ref = useForkedRef(forwardedRef, ownRef);\n  useEffect(function () {\n    if (ownRef.current && (ownRef.current.ownerDocument && ownRef.current.ownerDocument.dir === \"rtl\" || getElementComputedStyle(ownRef.current, \"direction\") === \"rtl\")) {\n      isRTL.current = true;\n    }\n  }, [isRTL]);\n  var handleKeyDown = useEventCallback(wrapEvent(onKeyDown, useDescendantKeyDown(TabsDescendantsContext, {\n    currentIndex: keyboardActivation === TabsKeyboardActivation.Manual ? focusedIndex : selectedIndex,\n    orientation: orientation,\n    rotate: true,\n    callback: onSelectTabWithKeyboard,\n    filter: function filter(tab) {\n      return !tab.disabled;\n    },\n    rtl: isRTL.current\n  })));\n  useIsomorphicLayoutEffect(function () {\n    var _tabs$selectedIndex;\n\n    // In the event an uncontrolled component's selected index is disabled,\n    // (this should only happen if the first tab is disabled and no default\n    // index is set), we need to override the selection to the next selectable\n    // index value.\n    if (!isControlled && boolOrBoolString((_tabs$selectedIndex = tabs[selectedIndex]) === null || _tabs$selectedIndex === void 0 ? void 0 : _tabs$selectedIndex.disabled)) {\n      var next = tabs.find(function (tab) {\n        return !tab.disabled;\n      });\n\n      if (next) {\n        setSelectedIndex(next.index);\n      }\n    }\n  }, [tabs, isControlled, selectedIndex, setSelectedIndex]);\n  return React.createElement(Comp // The element that serves as the container for the set of tabs has role\n  // `tablist`\n  // https://www.w3.org/TR/wai-aria-practices-1.2/#tabpanel\n  , Object.assign({\n    // The element that serves as the container for the set of tabs has role\n    // `tablist`\n    // https://www.w3.org/TR/wai-aria-practices-1.2/#tabpanel\n    role: \"tablist\",\n    \"aria-orientation\": orientation\n  }, props, {\n    \"data-reach-tab-list\": \"\",\n    ref: ref,\n    onKeyDown: handleKeyDown\n  }), Children.map(children, function (child, index) {\n    // TODO: Remove in 1.0\n    return cloneValidElement(child, {\n      isSelected: index === selectedIndex\n    });\n  }));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  TabListImpl.displayName = \"TabList\";\n  TabListImpl.propTypes = {\n    as: PropTypes.any,\n    children: PropTypes.node\n  };\n}\n\nvar TabList = /*#__PURE__*/memoWithAs(TabListImpl);\n\nif (process.env.NODE_ENV !== \"production\") {\n  TabList.displayName = \"TabList\";\n}\n\n/**\r\n * Tab\r\n *\r\n * The interactive element that changes the selected panel.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/tabs#tab\r\n */\n\nvar Tab = /*#__PURE__*/forwardRefWithAs(function Tab(_ref3, forwardedRef) {\n  var children = _ref3.children,\n      _ = _ref3.isSelected,\n      _ref3$as = _ref3.as,\n      Comp = _ref3$as === void 0 ? \"button\" : _ref3$as,\n      indexProp = _ref3.index,\n      disabled = _ref3.disabled,\n      onBlur = _ref3.onBlur,\n      onFocus = _ref3.onFocus,\n      props = _objectWithoutPropertiesLoose(_ref3, [\"children\", \"isSelected\", \"as\", \"index\", \"disabled\", \"onBlur\", \"onFocus\"]);\n\n  var _useContext2 = useContext(TabsContext),\n      tabsId = _useContext2.id,\n      onSelectTab = _useContext2.onSelectTab,\n      orientation = _useContext2.orientation,\n      selectedIndex = _useContext2.selectedIndex,\n      userInteractedRef = _useContext2.userInteractedRef,\n      setFocusedIndex = _useContext2.setFocusedIndex;\n\n  var ownRef = useRef(null);\n  var ref = useForkedRef(forwardedRef, ownRef);\n  var index = useDescendant({\n    element: ownRef.current,\n    disabled: !!disabled\n  }, TabsDescendantsContext, indexProp);\n  var htmlType = Comp === \"button\" && props.type == null ? \"button\" : props.type;\n  var isSelected = index === selectedIndex;\n\n  function onSelect() {\n    onSelectTab(index);\n  }\n\n  useUpdateEffect(function () {\n    if (isSelected && ownRef.current && userInteractedRef.current) {\n      userInteractedRef.current = false;\n      ownRef.current.focus();\n    }\n  }, [isSelected, userInteractedRef]);\n  var handleFocus = useEventCallback(wrapEvent(onFocus, function () {\n    setFocusedIndex(index);\n  }));\n  var handleBlur = useEventCallback(wrapEvent(onFocus, function () {\n    setFocusedIndex(-1);\n  }));\n  return React.createElement(Comp // Each element with role `tab` has the property `aria-controls` referring\n  // to its associated `tabpanel` element.\n  // https://www.w3.org/TR/wai-aria-practices-1.2/#tabpanel\n  , Object.assign({\n    \"aria-controls\": makeId(tabsId, \"panel\", index),\n    \"aria-disabled\": disabled,\n    \"aria-selected\": isSelected,\n    // Each element that serves as a tab has role `tab` and is contained\n    // within the element with role `tablist`.\n    // https://www.w3.org/TR/wai-aria-practices-1.2/#tabpanel\n    role: \"tab\",\n    tabIndex: isSelected ? 0 : -1\n  }, props, {\n    ref: ref,\n    \"data-reach-tab\": \"\",\n    \"data-orientation\": orientation,\n    \"data-selected\": isSelected ? \"\" : undefined,\n    disabled: disabled,\n    id: makeId(tabsId, \"tab\", index),\n    onClick: onSelect,\n    onFocus: handleFocus,\n    onBlur: handleBlur,\n    type: htmlType\n  }), children);\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  Tab.displayName = \"Tab\";\n  Tab.propTypes = {\n    children: PropTypes.node,\n    disabled: PropTypes.bool\n  };\n} ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * TabPanels\r\n *\r\n * The parent component of the panels.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/tabs#tabpanels\r\n */\n\n\nvar TabPanelsImpl = /*#__PURE__*/forwardRefWithAs(function TabPanels(_ref4, forwardedRef) {\n  var children = _ref4.children,\n      _ref4$as = _ref4.as,\n      Comp = _ref4$as === void 0 ? \"div\" : _ref4$as,\n      props = _objectWithoutPropertiesLoose(_ref4, [\"children\", \"as\"]);\n\n  var ownRef = useRef();\n  var ref = useForkedRef(ownRef, forwardedRef);\n\n  var _useDescendantsInit2 = useDescendantsInit(),\n      tabPanels = _useDescendantsInit2[0],\n      setTabPanels = _useDescendantsInit2[1];\n\n  return React.createElement(DescendantProvider, {\n    context: TabPanelDescendantsContext,\n    items: tabPanels,\n    set: setTabPanels\n  }, React.createElement(Comp, Object.assign({}, props, {\n    ref: ref,\n    \"data-reach-tab-panels\": \"\"\n  }), children));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  TabPanelsImpl.displayName = \"TabPanels\";\n  TabPanelsImpl.propTypes = {\n    as: PropTypes.any,\n    children: PropTypes.node\n  };\n}\n\nvar TabPanels = /*#__PURE__*/memoWithAs(TabPanelsImpl);\n\nif (process.env.NODE_ENV !== \"production\") {\n  TabPanels.displayName = \"TabPanels\";\n}\n\n/**\r\n * TabPanel\r\n *\r\n * The panel that displays when it's corresponding tab is active.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/tabs#tabpanel\r\n */\n\nvar TabPanel = /*#__PURE__*/forwardRefWithAs(function TabPanel(_ref5, forwardedRef) {\n  var children = _ref5.children,\n      ariaLabel = _ref5[\"aria-label\"],\n      _ref5$as = _ref5.as,\n      Comp = _ref5$as === void 0 ? \"div\" : _ref5$as,\n      props = _objectWithoutPropertiesLoose(_ref5, [\"children\", \"aria-label\", \"as\"]);\n\n  var _useContext3 = useContext(TabsContext),\n      selectedPanelRef = _useContext3.selectedPanelRef,\n      selectedIndex = _useContext3.selectedIndex,\n      tabsId = _useContext3.id;\n\n  var ownRef = useRef(null);\n  var index = useDescendant({\n    element: ownRef.current\n  }, TabPanelDescendantsContext);\n  var id = makeId(tabsId, \"panel\", index); // Because useDescendant will always return -1 on the first render,\n  // `isSelected` will briefly be false for all tabs. We set a tab panel's\n  // hidden attribute based `isSelected` being false, meaning that all tabs\n  // are initially hidden. This makes it impossible for consumers to do\n  // certain things, like focus an element inside the active tab panel when\n  // the page loads. So what we can do is track that a panel is \"ready\" to be\n  // hidden once effects are run (descendants work their magic in\n  // useLayoutEffect, so we can set our ref in useEffecct to run later). We\n  // can use a ref instead of state because we're always geting a re-render\n  // anyway thanks to descendants. This is a little more coupled to the\n  // implementation details of descendants than I'd like, but we'll add a test\n  // to (hopefully) catch any regressions.\n\n  var isSelected = index === selectedIndex;\n  var readyToHide = useRef(false);\n  var hidden = readyToHide.current ? !isSelected : false;\n  React.useEffect(function () {\n    readyToHide.current = true;\n  }, []);\n  var ref = useForkedRef(forwardedRef, ownRef, isSelected ? selectedPanelRef : null);\n  return React.createElement(Comp // Each element with role `tabpanel` has the property `aria-labelledby`\n  // referring to its associated tab element.\n  , Object.assign({\n    \"aria-labelledby\": makeId(tabsId, \"tab\", index),\n    hidden: hidden,\n    // Each element that contains the content panel for a tab has role\n    // `tabpanel`.\n    // https://www.w3.org/TR/wai-aria-practices-1.2/#tabpanel\n    role: \"tabpanel\",\n    tabIndex: isSelected ? 0 : -1\n  }, props, {\n    ref: ref,\n    \"data-reach-tab-panel\": \"\",\n    id: id\n  }), children);\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  TabPanel.displayName = \"TabPanel\";\n  TabPanel.propTypes = {\n    as: PropTypes.any,\n    children: PropTypes.node\n  };\n} ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * A hook that exposes data for a given `Tabs` component to its descendants.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/tabs#usetabscontext\r\n */\n\n\nfunction useTabsContext() {\n  var _useContext4 = useContext(TabsContext),\n      focusedIndex = _useContext4.focusedIndex,\n      id = _useContext4.id,\n      selectedIndex = _useContext4.selectedIndex;\n\n  return useMemo(function () {\n    return {\n      focusedIndex: focusedIndex,\n      id: id,\n      selectedIndex: selectedIndex\n    };\n  }, [focusedIndex, id, selectedIndex]);\n}\n\nexport { Tab, TabList, TabPanel, TabPanels, Tabs, TabsKeyboardActivation, TabsOrientation, useTabsContext };\n//# sourceMappingURL=tabs.esm.js.map\n","import * as React from 'react';\nimport PropTypes from 'prop-types';\n\nconst SvgLogosFacebookSmall = React.forwardRef(\n  ({ color, size, title, titleId, ...props }, ref) => (\n    <svg\n      fill={color}\n      viewBox=\"0 0 24 24\"\n      xmlns=\"http://www.w3.org/2000/svg\"\n      ref={ref}\n      width={size}\n      height={size}\n      aria-labelledby={titleId}\n      {...props}\n    >\n      {title ? <title id={titleId}>{title}</title> : null}\n      <path\n        d=\"M23 12.067C23 5.955 18.075 1 12 1S1 5.955 1 12.067C1 17.591 5.023 22.17 10.281 23v-7.734H7.488v-3.199h2.793V9.63c0-2.774 1.642-4.306 4.155-4.306 1.204 0 2.462.216 2.462.216v2.724h-1.387c-1.366 0-1.792.853-1.792 1.728v2.076h3.05l-.487 3.2h-2.563V23C18.977 22.17 23 17.591 23 12.067z\"\n        fill=\"\"\n      />\n    </svg>\n  )\n);\nSvgLogosFacebookSmall.defaultProps = {\n  color: 'currentColor',\n  size: 24,\n  title: undefined,\n  titleId: undefined\n};\nSvgLogosFacebookSmall.propTypes = {\n  color: PropTypes.string,\n  size: PropTypes.number,\n  title: PropTypes.string,\n  titleId: PropTypes.string\n};\nexport default SvgLogosFacebookSmall;\n","import * as React from 'react';\nimport PropTypes from 'prop-types';\n\nconst SvgLogosFacebookXsmall = React.forwardRef(\n  ({ color, size, title, titleId, ...props }, ref) => (\n    <svg\n      fill={color}\n      viewBox=\"0 0 16 16\"\n      xmlns=\"http://www.w3.org/2000/svg\"\n      ref={ref}\n      width={size}\n      height={size}\n      aria-labelledby={titleId}\n      {...props}\n    >\n      {title ? <title id={titleId}>{title}</title> : null}\n      <path\n        d=\"M15.5 8.046C15.5 3.878 12.142.5 8 .5 3.858.5.5 3.878.5 8.046c0 3.766 2.743 6.888 6.328 7.454v-5.273H4.924V8.046h1.904V6.383c0-1.89 1.12-2.935 2.833-2.935.82 0 1.679.147 1.679.147v1.857h-.946c-.932 0-1.222.582-1.222 1.178v1.416h2.08l-.333 2.181H9.172V15.5c3.585-.566 6.328-3.688 6.328-7.454z\"\n        fill=\"\"\n      />\n    </svg>\n  )\n);\nSvgLogosFacebookXsmall.defaultProps = {\n  color: 'currentColor',\n  size: 16,\n  title: undefined,\n  titleId: undefined\n};\nSvgLogosFacebookXsmall.propTypes = {\n  color: PropTypes.string,\n  size: PropTypes.number,\n  title: PropTypes.string,\n  titleId: PropTypes.string\n};\nexport default SvgLogosFacebookXsmall;\n","import { useEffect, useState } from 'react';\n\n// Exporting so we can test this function\n/**\n * Merges two objects, but also removes/adds fields based on defaultObj\n * fields and structure\n * @param {Object} defaultObj Object with default fields\n * @param {Object} savedObj Object Saved object\n */\nexport function mergeData(defaultObj, savedObj) {\n  const merged = {};\n\n  Object.keys(defaultObj).forEach((k) => {\n    if (!Object.prototype.hasOwnProperty.call(savedObj, k)) {\n      merged[k] = defaultObj[k];\n    }\n  });\n  Object.keys(savedObj).forEach((k) => {\n    if (Object.prototype.hasOwnProperty.call(defaultObj, k)) {\n      merged[k] = savedObj[k];\n    }\n  });\n\n  return merged;\n}\n\nexport function useLocalStorage(\n  key,\n  defaultValue = '',\n  options = { merge: false }\n) {\n  const [state, setState] = useState(() => {\n    try {\n      const value = window.localStorage.getItem(key);\n\n      if (value) {\n        const saved = JSON.parse(value);\n\n        if (options.merge) {\n          return mergeData(defaultValue, saved);\n        }\n\n        return saved;\n      }\n      return typeof defaultValue === 'function' ? defaultValue() : defaultValue;\n    } catch (e) {\n      return defaultValue;\n    }\n  });\n\n  useEffect(() => {\n    try {\n      window.localStorage.setItem(key, JSON.stringify(state));\n    } catch (e) {\n      // Noop\n    }\n  }, [key, state]);\n\n  return [state, setState];\n}\n\nexport default useLocalStorage;\n","import { useCallback, useEffect, useRef } from 'react';\n\n/**\n * This is just a wrapper function over the dispatch,\n * we want to pass any arguments back to the actual dispatch and\n * when a component un-mounts we should no longer dispatch.\n * This tells a component that it is ok to still dispatch and prevents\n * memory leaks when the component un-mounts.\n *\n * Using `safeDispatch` prevents this error:\n * \"Warning: Can’t perform a React state update on an unmounted component.\"\n *\n * This helps when we have async behavior where we call an async API call,\n * then based on the async response, we set the state. But if the component\n * unmounts before the API call resolves, we don't want to set the state.\n * */\nexport const useSafeDispatch = (dispatch) => {\n  const mountedRef = useRef(false);\n\n  useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n    };\n  }, []);\n\n  return useCallback(\n    (...args) => (mountedRef.current ? dispatch(...args) : () => {}),\n    [dispatch]\n  );\n};\n\nexport default useSafeDispatch;\n","import { useRef, useCallback, useEffect, useState } from 'react';\n\n/**\n * The `useSafeState` hook acts the same as React's `useState`,\n * where we can set the initial state, and it returns (1) the current state,\n * and (2) the state setter.\n *\n * But with `useSafeState`, it will only set the state when the component is mounted\n * in order to prevent memory leaks and avoid this warning:\n * \"Warning: Can’t perform a React state update on an unmounted component.\"\n * When a component is unmounted, we don't want to set the state.\n *\n * This helps when we have async behavior where we call an async API call,\n * then based on the async response, we set the state. But if the component\n * unmounts before the API call resolves, we don't want to set the state.\n * */\nexport const useSafeState = (initialState) => {\n  const mountedRef = useRef(false);\n  const [state, setState] = useState(initialState);\n\n  useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n    };\n  }, []);\n\n  const setSafeState = useCallback(\n    (args) => (mountedRef.current ? setState(args) : () => {}),\n    []\n  );\n\n  return [state, setSafeState];\n};\n\nexport default useSafeState;\n","/**\n * defines a focus group\n */\nexport var FOCUS_GROUP = 'data-focus-lock';\n/**\n * disables element discovery inside a group marked by key\n */\nexport var FOCUS_DISABLED = 'data-focus-lock-disabled';\n/**\n * allows uncontrolled focus within the marked area, effectively disabling focus lock for it's content\n */\nexport var FOCUS_ALLOW = 'data-no-focus-lock';\n/**\n * instructs autofocus engine to pick default autofocus inside a given node\n * can be set on the element or container\n */\nexport var FOCUS_AUTO = 'data-autofocus-inside';\n/**\n * instructs autofocus to ignore elements within a given node\n * can be set on the element or container\n */\nexport var FOCUS_NO_AUTOFOCUS = 'data-no-autofocus';\n","import { assignRef } from './assignRef';\nimport { useCallbackRef } from './useRef';\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 || null, function (newValue) { return refs.forEach(function (ref) { return assignRef(ref, newValue); }); });\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 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 { __assign } 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}\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function createSidecarMedium(options) {\n    if (options === void 0) { options = {}; }\n    var medium = innerCreateMedium(null);\n    medium.options = __assign({ async: true, ssr: false }, options);\n    return medium;\n}\n","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 { useEffect } from 'react';\nimport { hiddenGuard } from './FocusGuard';\nimport { mediumFocus, mediumBlur, mediumSidecar } from './medium';\nvar emptyArray = [];\nvar FocusLock = /*#__PURE__*/React.forwardRef(function FocusLockUI(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      hasPositiveIndices = props.hasPositiveIndices,\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      focusOptions = props.focusOptions,\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  useEffect(function () {\n    if (!disabled) {\n      // cleanup return focus on trap deactivation\n      // sideEffect/returnFocus should happen by this time\n      originalFocusedElement.current = null;\n    }\n  }, []);\n  var returnFocus = React.useCallback(function (allowDefer) {\n    var returnFocusTo = originalFocusedElement.current;\n\n    if (returnFocusTo && returnFocusTo.focus) {\n      var howToReturnFocus = typeof shouldReturnFocus === 'function' ? shouldReturnFocus(returnFocusTo) : shouldReturnFocus;\n\n      if (howToReturnFocus) {\n        var returnFocusOptions = typeof howToReturnFocus === 'object' ? howToReturnFocus : 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 returnFocusTo.focus(returnFocusOptions);\n          });\n        } else {\n          returnFocusTo.focus(returnFocusOptions);\n        }\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 && [\n  /*#__PURE__*/\n  // nearest focus guard\n  React.createElement(\"div\", {\n    key: \"guard-first\",\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 0,\n    style: hiddenGuard\n  }), // first tabbed element guard\n  hasPositiveIndices ? /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-nearest\",\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 1,\n    style: hiddenGuard\n  }) : null], !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    focusOptions: focusOptions\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, func]),\n  focusOptions: object,\n  noFocusGuards: bool,\n  hasPositiveIndices: 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  focusOptions: undefined,\n  noFocusGuards: false,\n  autoFocus: true,\n  persistentFocus: false,\n  crossFrame: true,\n  hasPositiveIndices: undefined,\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;","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 = /*#__PURE__*/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 /*#__PURE__*/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","import { FOCUS_NO_AUTOFOCUS } from '../constants';\nvar isElementHidden = function (node) {\n    // we can measure only \"elements\"\n    // consider others as \"visible\"\n    if (node.nodeType !== Node.ELEMENT_NODE) {\n        return false;\n    }\n    var computedStyle = window.getComputedStyle(node, null);\n    if (!computedStyle || !computedStyle.getPropertyValue) {\n        return false;\n    }\n    return (computedStyle.getPropertyValue('display') === 'none' || computedStyle.getPropertyValue('visibility') === 'hidden');\n};\nvar getParentNode = function (node) {\n    // DOCUMENT_FRAGMENT_NODE can also point on ShadowRoot. In this case .host will point on the next node\n    return node.parentNode && node.parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE\n        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            node.parentNode.host\n        : node.parentNode;\n};\nvar isTopNode = function (node) {\n    // @ts-ignore\n    return node === document || (node && node.nodeType === Node.DOCUMENT_NODE);\n};\nvar isVisibleUncached = function (node, checkParent) {\n    return !node || isTopNode(node) || (!isElementHidden(node) && checkParent(getParentNode(node)));\n};\nexport var isVisibleCached = function (visibilityCache, node) {\n    var cached = visibilityCache.get(node);\n    if (cached !== undefined) {\n        return cached;\n    }\n    var result = isVisibleUncached(node, isVisibleCached.bind(undefined, visibilityCache));\n    visibilityCache.set(node, result);\n    return result;\n};\nvar isAutoFocusAllowedUncached = function (node, checkParent) {\n    return node && !isTopNode(node) ? (isAutoFocusAllowed(node) ? checkParent(getParentNode(node)) : false) : true;\n};\nexport var isAutoFocusAllowedCached = function (cache, node) {\n    var cached = cache.get(node);\n    if (cached !== undefined) {\n        return cached;\n    }\n    var result = isAutoFocusAllowedUncached(node, isAutoFocusAllowedCached.bind(undefined, cache));\n    cache.set(node, result);\n    return result;\n};\nexport var getDataset = function (node) {\n    // @ts-ignore\n    return node.dataset;\n};\nexport var isHTMLButtonElement = function (node) { return node.tagName === 'BUTTON'; };\nexport var isHTMLInputElement = function (node) { return node.tagName === 'INPUT'; };\nexport var isRadioElement = function (node) {\n    return isHTMLInputElement(node) && node.type === 'radio';\n};\nexport var notHiddenInput = function (node) {\n    return !((isHTMLInputElement(node) || isHTMLButtonElement(node)) && (node.type === 'hidden' || node.disabled));\n};\nexport var isAutoFocusAllowed = function (node) {\n    var attribute = node.getAttribute(FOCUS_NO_AUTOFOCUS);\n    return ![true, 'true', ''].includes(attribute);\n};\nexport var isGuard = function (node) { var _a; return Boolean(node && ((_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.focusGuard)); };\nexport var isNotAGuard = function (node) { return !isGuard(node); };\nexport var isDefined = function (x) { return Boolean(x); };\n","import { isRadioElement } from './is';\nvar findSelectedRadio = function (node, nodes) {\n    return nodes\n        .filter(isRadioElement)\n        .filter(function (el) { return el.name === node.name; })\n        .filter(function (el) { return el.checked; })[0] || node;\n};\nexport var correctNode = function (node, nodes) {\n    if (isRadioElement(node) && node.name) {\n        return findSelectedRadio(node, nodes);\n    }\n    return node;\n};\n/**\n * giving a set of radio inputs keeps only selected (tabbable) ones\n * @param nodes\n */\nexport var correctNodes = function (nodes) {\n    // IE11 has no Set(array) constructor\n    var resultSet = new Set();\n    nodes.forEach(function (node) { return resultSet.add(correctNode(node, nodes)); });\n    // using filter to support IE11\n    return nodes.filter(function (node) { return resultSet.has(node); });\n};\n","import { correctNode } from './correctFocus';\nexport var pickFirstFocus = function (nodes) {\n    if (nodes[0] && nodes.length > 1) {\n        return correctNode(nodes[0], nodes);\n    }\n    return nodes[0];\n};\nexport var pickFocusable = function (nodes, index) {\n    if (nodes.length > 1) {\n        return nodes.indexOf(correctNode(nodes[index], nodes));\n    }\n    return index;\n};\n","import { correctNodes } from './utils/correctFocus';\nimport { pickFocusable } from './utils/firstFocus';\nimport { isGuard } from './utils/is';\nexport var NEW_FOCUS = 'NEW_FOCUS';\n/**\n * Main solver for the \"find next focus\" question\n * @param innerNodes\n * @param outerNodes\n * @param activeElement\n * @param lastNode\n * @returns {number|string|undefined|*}\n */\nexport var newFocus = function (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    // focus is inside\n    if (activeElement && innerNodes.indexOf(activeElement) >= 0) {\n        return undefined;\n    }\n    var activeIndex = activeElement !== undefined ? outerNodes.indexOf(activeElement) : -1;\n    var lastIndex = lastNode ? outerNodes.indexOf(lastNode) : activeIndex;\n    var lastNodeInside = lastNode ? innerNodes.indexOf(lastNode) : -1;\n    var indexDiff = activeIndex - lastIndex;\n    var firstNodeIndex = outerNodes.indexOf(firstFocus);\n    var lastNodeIndex = outerNodes.indexOf(lastFocus);\n    var correctedNodes = correctNodes(outerNodes);\n    var correctedIndex = activeElement !== undefined ? correctedNodes.indexOf(activeElement) : -1;\n    var correctedIndexDiff = correctedIndex - (lastNode ? correctedNodes.indexOf(lastNode) : activeIndex);\n    var returnFirstNode = pickFocusable(innerNodes, 0);\n    var returnLastNode = pickFocusable(innerNodes, cnt - 1);\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","/*\nIE11 support\n */\nexport var toArray = function (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};\nexport var asArray = function (a) { return (Array.isArray(a) ? a : [a]); };\n","import { toArray } from './array';\nexport var tabSort = function (a, b) {\n    var tabDiff = a.tabIndex - b.tabIndex;\n    var indexDiff = a.index - b.index;\n    if (tabDiff) {\n        if (!a.tabIndex) {\n            return 1;\n        }\n        if (!b.tabIndex) {\n            return -1;\n        }\n    }\n    return tabDiff || indexDiff;\n};\nexport var orderByTabIndex = function (nodes, filterNegative, keepGuards) {\n    return toArray(nodes)\n        .map(function (node, index) { 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) { return !filterNegative || data.tabIndex >= 0; })\n        .sort(tabSort);\n};\n","import { FOCUS_AUTO } from '../constants';\nimport { toArray } from './array';\nimport { tabbables } from './tabbables';\nvar queryTabbables = tabbables.join(',');\nvar queryGuardTabbables = \"\".concat(queryTabbables, \", [data-focus-guard]\");\nvar getFocusablesWithShadowDom = function (parent, withGuards) {\n    var _a;\n    return toArray(((_a = parent.shadowRoot) === null || _a === void 0 ? void 0 : _a.children) || parent.children).reduce(function (acc, child) {\n        return acc.concat(child.matches(withGuards ? queryGuardTabbables : queryTabbables) ? [child] : [], getFocusablesWithShadowDom(child));\n    }, []);\n};\nexport var getFocusables = function (parents, withGuards) {\n    return parents.reduce(function (acc, parent) {\n        return acc.concat(\n        // add all tabbables inside and within shadow DOMs in DOM order\n        getFocusablesWithShadowDom(parent, withGuards), \n        // add if node is tabbable itself\n        parent.parentNode\n            ? toArray(parent.parentNode.querySelectorAll(queryTabbables)).filter(function (node) { return node === parent; })\n            : []);\n    }, []);\n};\n/**\n * return a list of focusable nodes within an area marked as \"auto-focusable\"\n * @param parent\n */\nexport var getParentAutofocusables = function (parent) {\n    var parentFocus = parent.querySelectorAll(\"[\".concat(FOCUS_AUTO, \"]\"));\n    return toArray(parentFocus)\n        .map(function (node) { return getFocusables([node]); })\n        .reduce(function (acc, nodes) { return acc.concat(nodes); }, []);\n};\n","/**\n * list of the object to be considered as focusable\n */\nexport var tabbables = [\n    'button:enabled',\n    'select:enabled',\n    'textarea:enabled',\n    'input:enabled',\n    // elements with explicit roles will also use explicit tabindex\n    // '[role=\"button\"]',\n    'a[href]',\n    'area[href]',\n    'summary',\n    'iframe',\n    'object',\n    'embed',\n    'audio[controls]',\n    'video[controls]',\n    '[tabindex]',\n    '[contenteditable]',\n    '[autofocus]',\n];\n","import { toArray } from './array';\nimport { isAutoFocusAllowedCached, isVisibleCached, notHiddenInput } from './is';\nimport { orderByTabIndex } from './tabOrder';\nimport { getFocusables, getParentAutofocusables } from './tabUtils';\n/**\n * given list of focusable elements keeps the ones user can interact with\n * @param nodes\n * @param visibilityCache\n */\nexport var filterFocusable = function (nodes, visibilityCache) {\n    return toArray(nodes)\n        .filter(function (node) { return isVisibleCached(visibilityCache, node); })\n        .filter(function (node) { return notHiddenInput(node); });\n};\nexport var filterAutoFocusable = function (nodes, cache) {\n    if (cache === void 0) { cache = new Map(); }\n    return toArray(nodes).filter(function (node) { return isAutoFocusAllowedCached(cache, node); });\n};\n/**\n * only tabbable ones\n * (but with guards which would be ignored)\n */\nexport var getTabbableNodes = function (topNodes, visibilityCache, withGuards) {\n    return orderByTabIndex(filterFocusable(getFocusables(topNodes, withGuards), visibilityCache), true, withGuards);\n};\n/**\n * actually anything \"focusable\", not only tabbable\n * (without guards, as long as they are not expected to be focused)\n */\nexport var getAllTabbableNodes = function (topNodes, visibilityCache) {\n    return orderByTabIndex(filterFocusable(getFocusables(topNodes), visibilityCache), false);\n};\n/**\n * return list of nodes which are expected to be auto-focused\n * @param topNode\n * @param visibilityCache\n */\nexport var parentAutofocusables = function (topNode, visibilityCache) {\n    return filterFocusable(getParentAutofocusables(topNode), visibilityCache);\n};\n/*\n * Determines if element is contained in scope, including nested shadow DOMs\n */\nexport var contains = function (scope, element) {\n    return ((scope.shadowRoot\n        ? contains(scope.shadowRoot, element)\n        : Object.getPrototypeOf(scope).contains.call(scope, element)) ||\n        toArray(scope.children).some(function (child) { return contains(child, element); }));\n};\n","import { FOCUS_DISABLED, FOCUS_GROUP } from '../constants';\nimport { asArray, toArray } from './array';\n/**\n * in case of multiple nodes nested inside each other\n * keeps only top ones\n * this is O(nlogn)\n * @param nodes\n * @returns {*}\n */\nvar filterNested = function (nodes) {\n    var contained = new Set();\n    var l = nodes.length;\n    for (var i = 0; i < l; i += 1) {\n        for (var j = i + 1; j < l; j += 1) {\n            var position = nodes[i].compareDocumentPosition(nodes[j]);\n            /* eslint-disable no-bitwise */\n            if ((position & Node.DOCUMENT_POSITION_CONTAINED_BY) > 0) {\n                contained.add(j);\n            }\n            if ((position & Node.DOCUMENT_POSITION_CONTAINS) > 0) {\n                contained.add(i);\n            }\n            /* eslint-enable */\n        }\n    }\n    return nodes.filter(function (_, index) { return !contained.has(index); });\n};\n/**\n * finds top most parent for a node\n * @param node\n * @returns {*}\n */\nvar getTopParent = function (node) {\n    return node.parentNode ? getTopParent(node.parentNode) : node;\n};\n/**\n * returns all \"focus containers\" inside a given node\n * @param node\n * @returns {T}\n */\nexport var getAllAffectedNodes = function (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\n            ? filterNested(toArray(getTopParent(currentNode).querySelectorAll(\"[\".concat(FOCUS_GROUP, \"=\\\"\").concat(group, \"\\\"]:not([\").concat(FOCUS_DISABLED, \"=\\\"disabled\\\"])\"))))\n            : [currentNode]));\n        return acc;\n    }, []);\n};\n","var getNestedShadowActiveElement = function (shadowRoot) {\n    return shadowRoot.activeElement\n        ? shadowRoot.activeElement.shadowRoot\n            ? getNestedShadowActiveElement(shadowRoot.activeElement.shadowRoot)\n            : shadowRoot.activeElement\n        : undefined;\n};\n/**\n * returns active element from document or from nested shadowdoms\n */\nexport var getActiveElement = function () {\n    return (document.activeElement\n        ? document.activeElement.shadowRoot\n            ? getNestedShadowActiveElement(document.activeElement.shadowRoot)\n            : document.activeElement\n        : undefined); // eslint-disable-next-line @typescript-eslint/no-explicit-any\n};\n","import { parentAutofocusables } from './DOMutils';\nimport { contains } from './DOMutils';\nimport { asArray } from './array';\nvar getParents = function (node, parents) {\n    if (parents === void 0) { parents = []; }\n    parents.push(node);\n    if (node.parentNode) {\n        getParents(node.parentNode.host || node.parentNode, parents);\n    }\n    return parents;\n};\n/**\n * finds a parent for both nodeA and nodeB\n * @param nodeA\n * @param nodeB\n * @returns {boolean|*}\n */\nexport var getCommonParent = function (nodeA, nodeB) {\n    var parentsA = getParents(nodeA);\n    var parentsB = getParents(nodeB);\n    // tslint:disable-next-line:prefer-for-of\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};\nexport var getTopCommonParent = function (baseActiveElement, leftEntry, rightEntries) {\n    var activeElements = asArray(baseActiveElement);\n    var leftEntries = asArray(leftEntry);\n    var activeElement = activeElements[0];\n    var topCommon = false;\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 || contains(common, topCommon)) {\n                    topCommon = common;\n                }\n                else {\n                    topCommon = getCommonParent(common, topCommon);\n                }\n            }\n        });\n    });\n    // TODO: add assert here?\n    return topCommon;\n};\n/**\n * return list of nodes which are expected to be autofocused inside a given top nodes\n * @param entries\n * @param visibilityCache\n */\nexport var allParentAutofocusables = function (entries, visibilityCache) {\n    return entries.reduce(function (acc, node) { return acc.concat(parentAutofocusables(node, visibilityCache)); }, []);\n};\n","import { NEW_FOCUS, newFocus } from './solver';\nimport { filterAutoFocusable, getAllTabbableNodes, getTabbableNodes } from './utils/DOMutils';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { pickFirstFocus } from './utils/firstFocus';\nimport { getActiveElement } from './utils/getActiveElement';\nimport { getDataset, isDefined, isNotAGuard } from './utils/is';\nimport { allParentAutofocusables, getTopCommonParent } from './utils/parenting';\nvar findAutoFocused = function (autoFocusables) {\n    return function (node) { var _a; \n    // @ts-expect-error\n    return node.autofocus || !!((_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.autofocus) || autoFocusables.indexOf(node) >= 0; };\n};\nvar reorderNodes = function (srcNodes, dstNodes) {\n    var remap = new Map();\n    // no Set(dstNodes) for IE11 :(\n    dstNodes.forEach(function (entity) { return remap.set(entity.node, entity); });\n    // remap to dstNodes\n    return srcNodes.map(function (node) { return remap.get(node); }).filter(isDefined);\n};\n/**\n * given top node(s) and the last active element return the element to be focused next\n * @param topNode\n * @param lastNode\n */\nexport var getFocusMerge = function (topNode, lastNode) {\n    var activeElement = document && getActiveElement();\n    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);\n    var commonParent = getTopCommonParent(activeElement || topNode, topNode, entries);\n    var visibilityCache = new Map();\n    var anyFocusable = getAllTabbableNodes(entries, visibilityCache);\n    var innerElements = getTabbableNodes(entries, visibilityCache).filter(function (_a) {\n        var node = _a.node;\n        return isNotAGuard(node);\n    });\n    if (!innerElements[0]) {\n        innerElements = anyFocusable;\n        if (!innerElements[0]) {\n            return undefined;\n        }\n    }\n    var outerNodes = getAllTabbableNodes([commonParent], visibilityCache).map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var orderedInnerElements = reorderNodes(outerNodes, innerElements);\n    var innerNodes = orderedInnerElements.map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var newId = newFocus(innerNodes, outerNodes, activeElement, lastNode);\n    if (newId === NEW_FOCUS) {\n        var autoFocusable = filterAutoFocusable(anyFocusable.map(function (_a) {\n            var node = _a.node;\n            return node;\n        })).filter(findAutoFocused(allParentAutofocusables(entries, visibilityCache)));\n        return {\n            node: autoFocusable && autoFocusable.length\n                ? pickFirstFocus(autoFocusable)\n                : pickFirstFocus(filterAutoFocusable(innerNodes)),\n        };\n    }\n    if (newId === undefined) {\n        return newId;\n    }\n    return orderedInnerElements[newId];\n};\n","import { getFocusMerge } from './focusMerge';\nexport var focusOn = function (target, focusOptions) {\n    if ('focus' in target) {\n        target.focus(focusOptions);\n    }\n    if ('contentWindow' in target && target.contentWindow) {\n        target.contentWindow.focus();\n    }\n};\nvar guardCount = 0;\nvar lockDisabled = false;\n/**\n * Sets focus at a given node. The last focused element will help to determine which element(first or last) should be focused.\n * HTML markers (see {@link import('./constants').FOCUS_AUTO} constants) can control autofocus\n * @param topNode\n * @param lastNode\n * @param options\n */\nexport var setFocus = function (topNode, lastNode, options) {\n    if (options === void 0) { options = {}; }\n    var focusable = getFocusMerge(topNode, lastNode);\n    if (lockDisabled) {\n        return;\n    }\n    if (focusable) {\n        if (guardCount > 2) {\n            // tslint:disable-next-line:no-console\n            console.error('FocusLock: focus-fighting detected. Only one focus management system could be active. ' +\n                '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, options.focusOptions);\n        guardCount--;\n    }\n};\n","import * as constants from './constants';\nimport { focusInside } from './focusInside';\nimport { focusIsHidden } from './focusIsHidden';\nimport { getFocusMerge as focusMerge } from './focusMerge';\nimport { getFocusabledIn, getFocusableIn } from './focusables';\nimport { setFocus } from './setFocus';\nimport { focusNextElement, focusPrevElement } from './sibling';\nimport tabHook from './tabHook';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { getActiveElement } from './utils/getActiveElement';\nexport { tabHook, focusInside, focusIsHidden, focusMerge, getFocusableIn, getFocusabledIn, constants, getAllAffectedNodes, focusNextElement, focusPrevElement, getActiveElement, };\nexport default setFocus;\n//\n","import { contains } from './utils/DOMutils';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { toArray } from './utils/array';\nimport { getActiveElement } from './utils/getActiveElement';\nvar focusInFrame = function (frame) { return frame === document.activeElement; };\nvar focusInsideIframe = function (topNode) {\n    return Boolean(toArray(topNode.querySelectorAll('iframe')).some(function (node) { return focusInFrame(node); }));\n};\n/**\n * @returns {Boolean} true, if the current focus is inside given node or nodes\n */\nexport var focusInside = function (topNode) {\n    var activeElement = document && getActiveElement();\n    if (!activeElement || (activeElement.dataset && activeElement.dataset.focusGuard)) {\n        return false;\n    }\n    return getAllAffectedNodes(topNode).some(function (node) { return contains(node, activeElement) || focusInsideIframe(node); });\n};\n","import { getTabbableNodes } from './utils/DOMutils';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { isGuard, isNotAGuard } from './utils/is';\nimport { getTopCommonParent } from './utils/parenting';\n/**\n * return list of focusable elements inside a given top node\n * @deprecated use {@link getFocusableIn}. Yep, there is typo in the function name\n */\nexport var getFocusabledIn = function (topNode) {\n    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);\n    var commonParent = getTopCommonParent(topNode, topNode, entries);\n    var visibilityCache = new Map();\n    var outerNodes = getTabbableNodes([commonParent], visibilityCache, true);\n    var innerElements = getTabbableNodes(entries, visibilityCache)\n        .filter(function (_a) {\n        var node = _a.node;\n        return isNotAGuard(node);\n    })\n        .map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    return outerNodes.map(function (_a) {\n        var node = _a.node, index = _a.index;\n        return ({\n            node: node,\n            index: index,\n            lockItem: innerElements.indexOf(node) >= 0,\n            guard: isGuard(node),\n        });\n    });\n};\n/**\n * return list of focusable elements inside a given top node\n */\nexport var getFocusableIn = getFocusabledIn;\n","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};","/* eslint-disable no-mixed-operators */\nimport * 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 checkInHost = function checkInHost(check, el, boundary) {\n  return el && ( // find host equal to active element and check nested active element\n  el.host === check && (!el.activeElement || boundary.contains(el.activeElement)) // dive up\n  || el.parentNode && checkInHost(check, el.parentNode, boundary));\n};\n\nvar withinHost = function withinHost(activeElement, workingArea) {\n  return workingArea.some(function (area) {\n    return checkInHost(activeElement, area, area);\n  });\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        focusOptions = _lastActiveTrap.focusOptions;\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 && !( // active element is \"inside\" working area\n          focusInside(workingArea) || // check for shadow-dom contained elements\n          activeElement && withinHost(activeElement, 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                focusOptions: focusOptions\n              });\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);\n  document.addEventListener('focusout', onBlur);\n  window.addEventListener('blur', onWindowBlur);\n};\n\nvar detachHandler = function detachHandler() {\n  document.removeEventListener('focusin', onTrap);\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);","import { FOCUS_ALLOW } from './constants';\nimport { contains } from './utils/DOMutils';\nimport { toArray } from './utils/array';\nimport { getActiveElement } from './utils/getActiveElement';\n/**\n * focus is hidden FROM the focus-lock\n * ie contained inside a node focus-lock shall ignore\n * @returns {boolean} focus is currently is in \"allow\" area\n */\nexport var focusIsHidden = function () {\n    var activeElement = document && getActiveElement();\n    if (!activeElement) {\n        return false;\n    }\n    // this does not support setting FOCUS_ALLOW within shadow dom\n    return toArray(document.querySelectorAll(\"[\".concat(FOCUS_ALLOW, \"]\"))).some(function (node) { return contains(node, activeElement); });\n};\n","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport FocusLockUI from './Lock';\nimport FocusTrap from './Trap';\n/* that would be a BREAKING CHANGE!\n// delaying sidecar execution till the first usage\nconst RequireSideCar = (props) => {\n  // eslint-disable-next-line global-require\n  const SideCar = require('./Trap').default;\n  return <SideCar {...props} />;\n};\n*/\n\nvar FocusLockCombination = /*#__PURE__*/React.forwardRef(function FocusLockUICombination(props, ref) {\n  return /*#__PURE__*/React.createElement(FocusLockUI, _extends({\n    sideCar: FocusTrap,\n    ref: ref\n  }, props));\n});\n\nvar _ref = FocusLockUI.propTypes || {},\n    sideCar = _ref.sideCar,\n    propTypes = _objectWithoutPropertiesLoose(_ref, [\"sideCar\"]);\n\nFocusLockCombination.propTypes = process.env.NODE_ENV !== \"production\" ? propTypes : {};\nexport default FocusLockCombination;","import FocusLock from './Combination';\nexport * from './UI';\nexport default FocusLock;","export var zeroRightClassName = 'right-scroll-bar-position';\nexport var fullWidthClassName = 'width-before-scroll-bar';\nexport var noScrollbarsClassName = 'with-scroll-bars-hidden';\n/**\n * Name of a CSS variable containing the amount of \"hidden\" scrollbar\n * ! might be undefined ! use will fallback!\n */\nexport var removedBarSizeVariable = '--removed-body-scroll-bar-size';\n","import { createSidecarMedium } from 'use-sidecar';\nexport var effectCar = createSidecarMedium();\n","import { __assign, __rest } from \"tslib\";\nimport * as React from 'react';\nimport { fullWidthClassName, zeroRightClassName } from 'react-remove-scroll-bar/constants';\nimport { useMergeRefs } from 'use-callback-ref';\nimport { effectCar } from './medium';\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 = __rest(props, [\"forwardProps\", \"children\", \"className\", \"removeScrollBar\", \"enabled\", \"shards\", \"sideCar\", \"noIsolation\", \"inert\", \"allowPinchZoom\", \"as\"]);\n    var SideCar = sideCar;\n    var containerRef = useMergeRefs([ref, parentRef]);\n    var containerProps = __assign(__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), __assign(__assign({}, containerProps), { ref: containerRef }))) : (React.createElement(Container, __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","import { __assign, __rest } from \"tslib\";\nimport * as React from 'react';\nvar SideCar = function (_a) {\n    var sideCar = _a.sideCar, rest = __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, __assign({}, rest));\n};\nSideCar.isSideCarExport = true;\nexport function exportSidecar(medium, exported) {\n    medium.useMedium(exported);\n    return SideCar;\n}\n","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 { 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    // @ts-ignore\n    if (tag.styleSheet) {\n        // @ts-ignore\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';\n/**\n * create a Component to add styles on demand\n * - styles are added when first instance is mounted\n * - styles are removed when the last instance is unmounted\n * - changing styles in runtime does nothing unless dynamic is set. But with multiple components that can lead to the undefined behavior\n */\nexport var styleSingleton = function () {\n    var useStyle = styleHookSingleton();\n    var Sheet = function (_a) {\n        var styles = _a.styles, dynamic = _a.dynamic;\n        useStyle(styles, dynamic);\n        return null;\n    };\n    return Sheet;\n};\n","import * as React from 'react';\nimport { stylesheetSingleton } from './singleton';\n/**\n * creates a hook to control style singleton\n * @see {@link styleSingleton} for a safer component version\n * @example\n * ```tsx\n * const useStyle = styleHookSingleton();\n * ///\n * useStyle('body { overflow: hidden}');\n */\nexport var styleHookSingleton = function () {\n    var sheet = stylesheetSingleton();\n    return function (styles, isDynamic) {\n        React.useEffect(function () {\n            sheet.add(styles);\n            return function () {\n                sheet.remove();\n            };\n        }, [styles && isDynamic]);\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    if (process.env.NODE_ENV !== 'production') {\n        if (cs.overflowY === 'hidden') {\n            console.error('react-remove-scroll-bar: cannot calculate scrollbar size because it is removed (overflow:hidden on body');\n        }\n    }\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 [parse(left), parse(top), parse(right)];\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 { fullWidthClassName, zeroRightClassName, noScrollbarsClassName, removedBarSizeVariable } from './constants';\nimport { getGapWidth } from './utils';\nvar Style = styleSingleton();\n// important tip - once we measure scrollBar width and remove them\n// we could not repeat this operation\n// thus we are using style-singleton - only the first \"yet correct\" style will be applied.\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  .\".concat(noScrollbarsClassName, \" {\\n   overflow: hidden \").concat(important, \";\\n   padding-right: \").concat(gap, \"px \").concat(important, \";\\n  }\\n  body {\\n    overflow: hidden \").concat(important, \";\\n    overscroll-behavior: contain;\\n    \").concat([\n        allowRelative && \"position: relative \".concat(important, \";\"),\n        gapMode === 'margin' &&\n            \"\\n    padding-left: \".concat(left, \"px;\\n    padding-top: \").concat(top, \"px;\\n    padding-right: \").concat(right, \"px;\\n    margin-left:0;\\n    margin-top:0;\\n    margin-right: \").concat(gap, \"px \").concat(important, \";\\n    \"),\n        gapMode === 'padding' && \"padding-right: \".concat(gap, \"px \").concat(important, \";\"),\n    ]\n        .filter(Boolean)\n        .join(''), \"\\n  }\\n  \\n  .\").concat(zeroRightClassName, \" {\\n    right: \").concat(gap, \"px \").concat(important, \";\\n  }\\n  \\n  .\").concat(fullWidthClassName, \" {\\n    margin-right: \").concat(gap, \"px \").concat(important, \";\\n  }\\n  \\n  .\").concat(zeroRightClassName, \" .\").concat(zeroRightClassName, \" {\\n    right: 0 \").concat(important, \";\\n  }\\n  \\n  .\").concat(fullWidthClassName, \" .\").concat(fullWidthClassName, \" {\\n    margin-right: 0 \").concat(important, \";\\n  }\\n  \\n  body {\\n    \").concat(removedBarSizeVariable, \": \").concat(gap, \"px;\\n  }\\n\");\n};\n/**\n * Removes page scrollbar and blocks page scroll when mounted\n */\nexport var RemoveScrollBar = function (props) {\n    var noRelative = props.noRelative, noImportant = props.noImportant, _a = props.gapMode, gapMode = _a === void 0 ? 'margin' : _a;\n    var gap = React.useMemo(function () { return getGapWidth(gapMode); }, [gapMode]);\n    return React.createElement(Style, { styles: getStyles(gap, !noRelative, gapMode, !noImportant ? '!important' : '') });\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        // @ts-ignore\n        window.addEventListener('test', options, options);\n        // @ts-ignore\n        window.removeEventListener('test', options, options);\n    }\n    catch (err) {\n        passiveSupported = false;\n    }\n}\nexport var nonPassive = passiveSupported ? { passive: false } : false;\n","var alwaysContainsScroll = function (node) {\n    // textarea will always _contain_ scroll inside self. It only can be hidden\n    return node.tagName === 'TEXTAREA';\n};\nvar elementCanBeScrolled = function (node, overflow) {\n    var styles = window.getComputedStyle(node);\n    return (\n    // not-not-scrollable\n    styles[overflow] !== 'hidden' &&\n        // contains scroll inside self\n        !(styles.overflowY === styles.overflowX && !alwaysContainsScroll(node) && styles[overflow] === 'visible'));\n};\nvar elementCouldBeVScrolled = function (node) { return elementCanBeScrolled(node, 'overflowY'); };\nvar elementCouldBeHScrolled = function (node) { return elementCanBeScrolled(node, 'overflowX'); };\nexport var locationCouldBeScrolled = function (axis, node) {\n    var current = node;\n    do {\n        // Skip over shadow root\n        if (typeof ShadowRoot !== 'undefined' && current instanceof ShadowRoot) {\n            current = current.host;\n        }\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 [\n        scrollTop,\n        scrollHeight,\n        clientHeight,\n    ];\n};\nvar getHScrollVariables = function (_a) {\n    var scrollLeft = _a.scrollLeft, scrollWidth = _a.scrollWidth, clientWidth = _a.clientWidth;\n    return [\n        scrollLeft,\n        scrollWidth,\n        clientWidth,\n    ];\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};\nvar getDirectionFactor = function (axis, direction) {\n    /**\n     * If the element's direction is rtl (right-to-left), then scrollLeft is 0 when the scrollbar is at its rightmost position,\n     * and then increasingly negative as you scroll towards the end of the content.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollLeft\n     */\n    return axis === 'h' && direction === 'rtl' ? -1 : 1;\n};\nexport var handleScroll = function (axis, endTarget, event, sourceDelta, noOverscroll) {\n    var directionFactor = getDirectionFactor(axis, window.getComputedStyle(endTarget).direction);\n    var delta = directionFactor * 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 - directionFactor * 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 && ((noOverscroll && availableScroll === 0) || (!noOverscroll && delta > availableScroll))) {\n        shouldCancelScroll = true;\n    }\n    else if (!isDeltaPositive &&\n        ((noOverscroll && availableScrollTop === 0) || (!noOverscroll && -delta > availableScrollTop))) {\n        shouldCancelScroll = true;\n    }\n    return shouldCancelScroll;\n};\n","import { __spreadArray } from \"tslib\";\nimport * as React from 'react';\nimport { RemoveScrollBar } from 'react-remove-scroll-bar';\nimport { styleSingleton } from 'react-style-singleton';\nimport { nonPassive } from './aggresiveCapture';\nimport { handleScroll, locationCouldBeScrolled } from './handleScroll';\nexport var getTouchXY = function (event) {\n    return 'changedTouches' in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [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) { return x[0] === y[0] && x[1] === y[1]; };\nvar generateStyle = function (id) { return \"\\n  .block-interactivity-\".concat(id, \" {pointer-events: none;}\\n  .allow-interactivity-\").concat(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-\".concat(id));\n            var allow_1 = __spreadArray([props.lockRef.current], (props.shards || []).map(extractRef), true).filter(Boolean);\n            allow_1.forEach(function (el) { return el.classList.add(\"allow-interactivity-\".concat(id)); });\n            return function () {\n                document.body.classList.remove(\"block-interactivity-\".concat(id));\n                allow_1.forEach(function (el) { return el.classList.remove(\"allow-interactivity-\".concat(id)); });\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        // allow horizontal touch move on Range inputs. They will not cause any scroll\n        if ('touches' in event && moveDirection === 'h' && target.type === 'range') {\n            return false;\n        }\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 && 'changedTouches' in event && (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) { return e.name === event.type && e.target === event.target && deltaCompare(e.delta, delta); })[0];\n        // self event, and should be canceled\n        if (sourceEvent && sourceEvent.should) {\n            if (event.cancelable) {\n                event.preventDefault();\n            }\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 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation;\n            if (shouldStop) {\n                if (event.cancelable) {\n                    event.preventDefault();\n                }\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","import { __assign } from \"tslib\";\nimport * as React from 'react';\nimport { RemoveScroll } from './UI';\nimport SideCar from './sidecar';\nvar ReactRemoveScroll = React.forwardRef(function (props, ref) { return (React.createElement(RemoveScroll, __assign({}, props, { ref: ref, sideCar: SideCar }))); });\nReactRemoveScroll.classNames = RemoveScroll.classNames;\nexport default ReactRemoveScroll;\n","import React, { forwardRef, useEffect, useRef, useCallback } from 'react';\nimport Portal from '@reach/portal';\nimport { checkStyles, useForkedRef, wrapEvent, getOwnerDocument, noop, isString } from '@reach/utils';\nimport FocusLock from 'react-focus-lock';\nimport { RemoveScroll } from 'react-remove-scroll';\nimport PropTypes from 'prop-types';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nvar overlayPropTypes = {\n  allowPinchZoom: PropTypes.bool,\n  dangerouslyBypassFocusLock: PropTypes.bool,\n  dangerouslyBypassScrollLock: PropTypes.bool,\n  // TODO:\n  initialFocusRef: function initialFocusRef() {\n    return null;\n  },\n  onDismiss: PropTypes.func\n}; ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * DialogOverlay\r\n *\r\n * Low-level component if you need more control over the styles or rendering of\r\n * the dialog overlay.\r\n *\r\n * Note: You must render a `DialogContent` inside.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/dialog#dialogoverlay\r\n */\n\nvar DialogOverlay = /*#__PURE__*/forwardRef(function DialogOverlay(_ref, forwardedRef) {\n  var _ref$isOpen = _ref.isOpen,\n      isOpen = _ref$isOpen === void 0 ? true : _ref$isOpen,\n      props = _objectWithoutPropertiesLoose(_ref, [\"isOpen\"]);\n\n  useEffect(function () {\n    return checkStyles(\"dialog\");\n  }, []); // We want to ignore the immediate focus of a tooltip so it doesn't pop\n  // up again when the menu closes, only pops up when focus returns again\n  // to the tooltip (like native OS tooltips).\n\n  useEffect(function () {\n    if (isOpen) {\n      // @ts-ignore\n      window.__REACH_DISABLE_TOOLTIPS = true;\n    } else {\n      window.requestAnimationFrame(function () {\n        // Wait a frame so that this doesn't fire before tooltip does\n        // @ts-ignore\n        window.__REACH_DISABLE_TOOLTIPS = false;\n      });\n    }\n  }, [isOpen]);\n  return isOpen ? React.createElement(Portal, {\n    \"data-reach-dialog-wrapper\": \"\"\n  }, React.createElement(DialogInner, Object.assign({\n    ref: forwardedRef\n  }, props))) : null;\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  DialogOverlay.displayName = \"DialogOverlay\";\n  DialogOverlay.propTypes = /*#__PURE__*/_extends({}, overlayPropTypes, {\n    isOpen: PropTypes.bool\n  });\n} ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * DialogInner\r\n */\n\n\nvar DialogInner = /*#__PURE__*/forwardRef(function DialogInner(_ref2, forwardedRef) {\n  var allowPinchZoom = _ref2.allowPinchZoom,\n      _ref2$dangerouslyBypa = _ref2.dangerouslyBypassFocusLock,\n      dangerouslyBypassFocusLock = _ref2$dangerouslyBypa === void 0 ? false : _ref2$dangerouslyBypa,\n      _ref2$dangerouslyBypa2 = _ref2.dangerouslyBypassScrollLock,\n      dangerouslyBypassScrollLock = _ref2$dangerouslyBypa2 === void 0 ? false : _ref2$dangerouslyBypa2,\n      initialFocusRef = _ref2.initialFocusRef,\n      onClick = _ref2.onClick,\n      _ref2$onDismiss = _ref2.onDismiss,\n      onDismiss = _ref2$onDismiss === void 0 ? noop : _ref2$onDismiss,\n      onKeyDown = _ref2.onKeyDown,\n      onMouseDown = _ref2.onMouseDown,\n      _ref2$unstable_lockFo = _ref2.unstable_lockFocusAcrossFrames,\n      unstable_lockFocusAcrossFrames = _ref2$unstable_lockFo === void 0 ? true : _ref2$unstable_lockFo,\n      props = _objectWithoutPropertiesLoose(_ref2, [\"allowPinchZoom\", \"dangerouslyBypassFocusLock\", \"dangerouslyBypassScrollLock\", \"initialFocusRef\", \"onClick\", \"onDismiss\", \"onKeyDown\", \"onMouseDown\", \"unstable_lockFocusAcrossFrames\"]);\n\n  var mouseDownTarget = useRef(null);\n  var overlayNode = useRef(null);\n  var ref = useForkedRef(overlayNode, forwardedRef);\n  var activateFocusLock = useCallback(function () {\n    if (initialFocusRef && initialFocusRef.current) {\n      initialFocusRef.current.focus();\n    }\n  }, [initialFocusRef]);\n\n  function handleClick(event) {\n    if (mouseDownTarget.current === event.target) {\n      event.stopPropagation();\n      onDismiss(event);\n    }\n  }\n\n  function handleKeyDown(event) {\n    if (event.key === \"Escape\") {\n      event.stopPropagation();\n      onDismiss(event);\n    }\n  }\n\n  function handleMouseDown(event) {\n    mouseDownTarget.current = event.target;\n  }\n\n  useEffect(function () {\n    return overlayNode.current ? createAriaHider(overlayNode.current) : void null;\n  }, []);\n  return React.createElement(FocusLock, {\n    autoFocus: true,\n    returnFocus: true,\n    onActivation: activateFocusLock,\n    disabled: dangerouslyBypassFocusLock,\n    crossFrame: unstable_lockFocusAcrossFrames\n  }, React.createElement(RemoveScroll, {\n    allowPinchZoom: allowPinchZoom,\n    enabled: !dangerouslyBypassScrollLock\n  }, React.createElement(\"div\", Object.assign({}, props, {\n    ref: ref,\n    \"data-reach-dialog-overlay\": \"\",\n\n    /*\r\n     * We can ignore the `no-static-element-interactions` warning here\r\n     * because our overlay is only designed to capture any outside\r\n     * clicks, not to serve as a clickable element itself.\r\n     */\n    onClick: wrapEvent(onClick, handleClick),\n    onKeyDown: wrapEvent(onKeyDown, handleKeyDown),\n    onMouseDown: wrapEvent(onMouseDown, handleMouseDown)\n  }))));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  DialogOverlay.displayName = \"DialogOverlay\";\n  DialogOverlay.propTypes = /*#__PURE__*/_extends({}, overlayPropTypes);\n} ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * DialogContent\r\n *\r\n * Low-level component if you need more control over the styles or rendering of\r\n * the dialog content.\r\n *\r\n * Note: Must be a child of `DialogOverlay`.\r\n *\r\n * Note: You only need to use this when you are also styling `DialogOverlay`,\r\n * otherwise you can use the high-level `Dialog` component and pass the props\r\n * to it. Any props passed to `Dialog` component (besides `isOpen` and\r\n * `onDismiss`) will be spread onto `DialogContent`.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/dialog#dialogcontent\r\n */\n\n\nvar DialogContent = /*#__PURE__*/forwardRef(function DialogContent(_ref3, forwardedRef) {\n  var onClick = _ref3.onClick,\n      onKeyDown = _ref3.onKeyDown,\n      props = _objectWithoutPropertiesLoose(_ref3, [\"onClick\", \"onKeyDown\"]);\n\n  return React.createElement(\"div\", Object.assign({\n    \"aria-modal\": \"true\",\n    role: \"dialog\",\n    tabIndex: -1\n  }, props, {\n    ref: forwardedRef,\n    \"data-reach-dialog-content\": \"\",\n    onClick: wrapEvent(onClick, function (event) {\n      event.stopPropagation();\n    })\n  }));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  DialogContent.displayName = \"DialogContent\";\n  DialogContent.propTypes = {\n    \"aria-label\": ariaLabelType,\n    \"aria-labelledby\": ariaLabelType\n  };\n} ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * Dialog\r\n *\r\n * High-level component to render a modal dialog window over the top of the page\r\n * (or another dialog).\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/dialog#dialog\r\n */\n\n\nvar Dialog = /*#__PURE__*/forwardRef(function Dialog(_ref4, forwardedRef) {\n  var _ref4$allowPinchZoom = _ref4.allowPinchZoom,\n      allowPinchZoom = _ref4$allowPinchZoom === void 0 ? false : _ref4$allowPinchZoom,\n      initialFocusRef = _ref4.initialFocusRef,\n      isOpen = _ref4.isOpen,\n      _ref4$onDismiss = _ref4.onDismiss,\n      onDismiss = _ref4$onDismiss === void 0 ? noop : _ref4$onDismiss,\n      props = _objectWithoutPropertiesLoose(_ref4, [\"allowPinchZoom\", \"initialFocusRef\", \"isOpen\", \"onDismiss\"]);\n\n  return React.createElement(DialogOverlay, {\n    allowPinchZoom: allowPinchZoom,\n    initialFocusRef: initialFocusRef,\n    isOpen: isOpen,\n    onDismiss: onDismiss\n  }, React.createElement(DialogContent, Object.assign({\n    ref: forwardedRef\n  }, props)));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  Dialog.displayName = \"Dialog\";\n  Dialog.propTypes = {\n    isOpen: PropTypes.bool,\n    onDismiss: PropTypes.func,\n    \"aria-label\": ariaLabelType,\n    \"aria-labelledby\": ariaLabelType\n  };\n}\n\nfunction createAriaHider(dialogNode) {\n  var originalValues = [];\n  var rootNodes = [];\n  var ownerDocument = getOwnerDocument(dialogNode) || document;\n\n  if (!dialogNode) {\n    if (process.env.NODE_ENV !== \"production\") {\n      console.warn(\"A ref has not yet been attached to a dialog node when attempting to call `createAriaHider`.\");\n    }\n\n    return noop;\n  }\n\n  Array.prototype.forEach.call(ownerDocument.querySelectorAll(\"body > *\"), function (node) {\n    var _dialogNode$parentNod, _dialogNode$parentNod2;\n\n    var portalNode = (_dialogNode$parentNod = dialogNode.parentNode) === null || _dialogNode$parentNod === void 0 ? void 0 : (_dialogNode$parentNod2 = _dialogNode$parentNod.parentNode) === null || _dialogNode$parentNod2 === void 0 ? void 0 : _dialogNode$parentNod2.parentNode;\n\n    if (node === portalNode) {\n      return;\n    }\n\n    var attr = node.getAttribute(\"aria-hidden\");\n    var alreadyHidden = attr !== null && attr !== \"false\";\n\n    if (alreadyHidden) {\n      return;\n    }\n\n    originalValues.push(attr);\n    rootNodes.push(node);\n    node.setAttribute(\"aria-hidden\", \"true\");\n  });\n  return function () {\n    rootNodes.forEach(function (node, index) {\n      var originalValue = originalValues[index];\n\n      if (originalValue === null) {\n        node.removeAttribute(\"aria-hidden\");\n      } else {\n        node.setAttribute(\"aria-hidden\", originalValue);\n      }\n    });\n  };\n}\n\nfunction ariaLabelType(props, propName, compName, location, propFullName) {\n  var details = \"\\nSee https://www.w3.org/TR/wai-aria/#aria-label for details.\";\n\n  if (!props[\"aria-label\"] && !props[\"aria-labelledby\"]) {\n    return new Error(\"A <\" + compName + \"> must have either an `aria-label` or `aria-labelledby` prop.\\n      \" + details);\n  }\n\n  if (props[\"aria-label\"] && props[\"aria-labelledby\"]) {\n    return new Error(\"You provided both `aria-label` and `aria-labelledby` props to a <\" + compName + \">. If the a label for this component is visible on the screen, that label's component should be given a unique ID prop, and that ID should be passed as the `aria-labelledby` prop into <\" + compName + \">. If the label cannot be determined programmatically from the content of the element, an alternative label should be provided as the `aria-label` prop, which will be used as an `aria-label` on the HTML tag.\" + details);\n  } else if (props[propName] != null && !isString(props[propName])) {\n    return new Error(\"Invalid prop `\" + propName + \"` supplied to `\" + compName + \"`. Expected `string`, received `\" + (Array.isArray(propFullName) ? \"array\" : typeof propFullName) + \"`.\");\n  }\n\n  return null;\n}\n\nexport default Dialog;\nexport { Dialog, DialogContent, DialogOverlay };\n//# sourceMappingURL=dialog.esm.js.map\n","// extracted by mini-css-extract-plugin\nexport default {\"overlay\":\"Modal--overlay--datCD\",\"dialog\":\"Modal--dialog--NJuNP\",\"close-button\":\"Modal--close-button--54bUs\",\"closeButton\":\"Modal--close-button--54bUs\",\"title\":\"Modal--title--sH-CW\",\"hero-image\":\"Modal--hero-image--jNDsp\",\"heroImage\":\"Modal--hero-image--jNDsp\",\"body\":\"Modal--body--X1CY9\",\"actions\":\"Modal--actions--Ld-Kr\"};","import React from 'react';\nimport PropTypes from 'prop-types';\nimport { DialogOverlay, DialogContent } from '@reach/dialog';\n\nimport ActionsCancelNormalXsmall from '@strava/icons/ActionsCancelNormalXsmall';\nimport colors from '../colors';\nimport Button from '../Button';\n\nimport styles from './styles.scss';\n\n//\n// ModalOverlay\n//\n// Reach UI docs: https://reach.tech/dialog/#dialogoverlay\n// --------------------\n\nexport function ModalOverlay({ className, children, ...otherProps }) {\n  const classNames = [styles.overlay];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <DialogOverlay className={classNames.join(' ')} {...otherProps}>\n      {children}\n    </DialogOverlay>\n  );\n}\n\n// Override DialogContent display name so that error from prop types show 'ModalOverlay'\nDialogOverlay.displayName = 'ModalOverlay';\n\nModalOverlay.defaultProps = {\n  className: null,\n  isOpen: false,\n  onDismiss: () => {},\n  initialFocusRef: () => {},\n\n  allowPinchZoom: false,\n  dangerouslyBypassFocusLock: false,\n  dangerouslyBypassScrollLock: false\n};\n\nModalOverlay.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string,\n  isOpen: PropTypes.bool,\n  onDismiss: PropTypes.func,\n  initialFocusRef: PropTypes.func,\n  allowPinchZoom: PropTypes.bool,\n  dangerouslyBypassFocusLock: PropTypes.bool,\n  dangerouslyBypassScrollLock: PropTypes.bool\n};\n\n//\n// ModalContent\n//\n// Reach UI docs: https://reach.tech/dialog/#dialogcontent\n// --------------------\n\nexport function ModalContent({ className, children, ...otherProps }) {\n  const classNames = [styles.dialog];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <DialogContent className={classNames.join(' ')} {...otherProps}>\n      {children}\n    </DialogContent>\n  );\n}\n\n// Override DialogContent display name so that error from prop types show 'ModalContent'\nDialogContent.displayName = 'ModalContent';\n\nModalContent.defaultProps = {\n  className: null\n};\n\nModalContent.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string,\n\n  //\n  // @reach/dialog will handle prop-type validation for us, but in order for this\n  // props to show up in Storybook we need to add them here.\n  //\n  /* eslint-disable react/require-default-props */\n  'aria-label': PropTypes.string,\n  'aria-labelledby': PropTypes.string\n  /* eslint-enable react/require-default-props */\n};\n\n//\n// ModalTitle\n// --------------------\n\nexport function ModalTitle({ className, children, ...otherProps }) {\n  const classNames = [styles.title];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <h2 className={classNames.join(' ')} {...otherProps}>\n      {children}\n    </h2>\n  );\n}\n\nModalTitle.defaultProps = {\n  className: null\n};\n\nModalTitle.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string\n};\n\n//\n// ModalActions\n// --------------------\n\nexport function ModalActions({ className, children, ...otherProps }) {\n  const classNames = [styles.actions];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <div className={classNames.join(' ')} {...otherProps}>\n      {children}\n    </div>\n  );\n}\n\nModalActions.defaultProps = {\n  className: null\n};\n\nModalActions.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string\n};\n\n//\n// ModalHeroImage\n// --------------------\n\nexport function ModalHeroImage({ className, src, alt, ...otherProps }) {\n  const classNames = [styles.heroImage];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <img src={src} alt={alt} className={classNames.join(' ')} {...otherProps} />\n  );\n}\n\nModalHeroImage.defaultProps = {\n  className: null\n};\n\nModalHeroImage.propTypes = {\n  className: PropTypes.string,\n  src: PropTypes.string.isRequired,\n  alt: PropTypes.string.isRequired\n};\n\n//\n// ModalBody\n// --------------------\n\nexport function ModalBody({ className, ...otherProps }) {\n  const classNames = [styles.body];\n  if (className) {\n    classNames.push(className);\n  }\n  return <div className={classNames.join(' ')} {...otherProps} />;\n}\n\nModalBody.defaultProps = {\n  className: null\n};\n\nModalBody.propTypes = {\n  className: PropTypes.string,\n  children: PropTypes.node.isRequired\n};\n\n//\n// ModalCloseButton\n// --------------------\n\nexport function ModalCloseButton({ className, color, ...otherProps }) {\n  return (\n    <Button type=\"button\" variant=\"icon\" className={className} {...otherProps}>\n      <ActionsCancelNormalXsmall fill={color || colors.BLACK} />\n    </Button>\n  );\n}\n\nModalCloseButton.defaultProps = {\n  className: null,\n  color: null\n};\n\nModalCloseButton.propTypes = {\n  className: PropTypes.string,\n  color: PropTypes.string\n};\n\n//\n// Modal\n// --------------------\n\nfunction Modal({\n  className,\n  isOpen,\n  onDismiss,\n  hasClose,\n  children,\n  initialFocusRef,\n  ...otherProps\n}) {\n  return (\n    <ModalOverlay\n      isOpen={isOpen}\n      onDismiss={onDismiss}\n      initialFocusRef={initialFocusRef}\n    >\n      <ModalContent className={className} {...otherProps}>\n        {hasClose && (\n          <ModalCloseButton\n            className={styles.closeButton}\n            onClick={onDismiss}\n          />\n        )}\n        {children}\n      </ModalContent>\n    </ModalOverlay>\n  );\n}\n\nModal.defaultProps = {\n  className: null,\n  isOpen: false,\n  hasClose: false,\n  onDismiss: () => {},\n  initialFocusRef: () => {}\n};\n\nModal.propTypes = {\n  /**\n   * This style will be applied to ModalContent used by Modal component\n   */\n  className: PropTypes.string,\n\n  /**\n   * Whether modal is open or closed - aka visitable to the user\n   */\n  isOpen: PropTypes.bool,\n\n  /**\n   * Called when modal will be closed\n   */\n  onDismiss: PropTypes.func,\n\n  /**\n   * By default the first focusable element will receive focus when the dialog opens but you can provide a ref to focus instead.\n   */\n  initialFocusRef: PropTypes.func,\n\n  /**\n   * Whether to show close button or not\n   */\n  hasClose: PropTypes.bool,\n\n  children: PropTypes.oneOfType([\n    PropTypes.arrayOf(PropTypes.node),\n    PropTypes.node\n  ]).isRequired,\n\n  //\n  // @reach/dialog will handle prop-type validation for us, but in order for this\n  // props to show up in Storybook we need to add them here.\n  //\n  /* eslint-disable react/require-default-props */\n  'aria-label': PropTypes.string,\n  'aria-labelledby': PropTypes.string\n  /* eslint-enable react/require-default-props */\n};\n\nexport default Modal;\n","// extracted by mini-css-extract-plugin\nexport default {\"dialog\":\"ModalWithTabs--dialog--nbojY\",\"header\":\"ModalWithTabs--header--VHGe1\",\"header-title\":\"ModalWithTabs--header-title--bzlkJ\",\"headerTitle\":\"ModalWithTabs--header-title--bzlkJ\",\"header-content\":\"ModalWithTabs--header-content--XKA5+\",\"headerContent\":\"ModalWithTabs--header-content--XKA5+\",\"logo\":\"ModalWithTabs--logo--iELWj\",\"tabs\":\"ModalWithTabs--tabs--0+5QS\",\"tab-list\":\"ModalWithTabs--tab-list--WOeC2\",\"tabList\":\"ModalWithTabs--tab-list--WOeC2\",\"tab\":\"ModalWithTabs--tab--OFTLO\",\"tab-panels\":\"ModalWithTabs--tab-panels--PDSup\",\"tabPanels\":\"ModalWithTabs--tab-panels--PDSup\",\"tab-panel\":\"ModalWithTabs--tab-panel--K6jlo\",\"tabPanel\":\"ModalWithTabs--tab-panel--K6jlo\"};","import React from 'react';\nimport PropTypes from 'prop-types';\n\nimport Modal from '../Modal';\nimport { Tabs, TabList, Tab, TabPanel, TabPanels } from '../Tabs';\n\nimport styles from './styles.scss';\n\n//\n// ModalTabs\n// --------------------\n\nexport function ModalTabs({ className, children, ...otherProps }) {\n  const classNames = [styles.tabs];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <Tabs className={classNames.join(' ')} {...otherProps}>\n      {children}\n    </Tabs>\n  );\n}\n\nModalTabs.defaultProps = {\n  className: null\n};\n\nModalTabs.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string\n};\n\n//\n// ModalTabList\n// --------------------\n\nexport function ModalTabList({ className, children }) {\n  const classNames = [styles.tabList];\n  if (className) {\n    classNames.push(className);\n  }\n  return <TabList className={classNames.join(' ')}>{children}</TabList>;\n}\n\nModalTabList.defaultProps = {\n  className: null\n};\n\nModalTabList.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string\n};\n\n//\n// ModalTab\n// --------------------\n\nexport function ModalTab({ className, children, disabled }) {\n  const classNames = [styles.tab];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <Tab className={classNames.join(' ')} disabled={disabled}>\n      {children}\n    </Tab>\n  );\n}\n\nModalTab.defaultProps = {\n  className: null,\n  disabled: false\n};\n\nModalTab.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string,\n  disabled: PropTypes.bool\n};\n\n//\n// ModalTabPanels\n// --------------------\n\nexport function ModalTabPanels({ className, children }) {\n  const classNames = [styles.tabPanels];\n  if (className) {\n    classNames.push(className);\n  }\n  return <TabPanels className={classNames.join(' ')}>{children}</TabPanels>;\n}\n\nModalTabPanels.defaultProps = {\n  className: null\n};\n\nModalTabPanels.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string\n};\n\n//\n// ModalTabPanels\n// --------------------\n\nexport function ModalTabPanel({ className, children }) {\n  const classNames = [styles.tabPanel];\n  if (className) {\n    classNames.push(className);\n  }\n  return <TabPanel className={classNames.join(' ')}>{children}</TabPanel>;\n}\n\nModalTabPanel.defaultProps = {\n  className: null\n};\n\nModalTabPanel.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string\n};\n\n//\n// ModalWithTabs\n// --------------------\n\nexport default function ModalWithTabs({\n  isOpen,\n  className,\n  onDismiss,\n  children,\n  title,\n  logo,\n  ...otherProps\n}) {\n  const classNames = [styles.dialog];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <Modal\n      isOpen={isOpen}\n      className={classNames.join(' ')}\n      onDismiss={onDismiss}\n      hasClose={true}\n      {...otherProps}\n    >\n      <div className={styles.header}>\n        <div className={styles.headerContent}>\n          <h2 className={styles.headerTitle}>\n            {logo && <img src={logo} alt=\"\" className={styles.logo} />}\n            {title}\n          </h2>\n        </div>\n      </div>\n      {children}\n    </Modal>\n  );\n}\n\nModalWithTabs.defaultProps = {\n  isOpen: false,\n  className: null,\n  onDismiss: () => {},\n  logo: null\n};\n\nModalWithTabs.propTypes = {\n  children: PropTypes.node.isRequired,\n  title: PropTypes.node.isRequired,\n  logo: PropTypes.string,\n  isOpen: PropTypes.bool,\n  className: PropTypes.string,\n  onDismiss: PropTypes.func\n};\n","// extracted by mini-css-extract-plugin\nexport default {\"tab\":\"Tabs--tab--5HleF\",\"tab-selected\":\"Tabs--tab-selected--sHh7j\",\"tabSelected\":\"Tabs--tab-selected--sHh7j\"};","import React from 'react';\nimport PropTypes from 'prop-types';\nimport {\n  Tabs,\n  TabList,\n  Tab as ReachTab,\n  TabPanels,\n  TabPanel\n} from '@reach/tabs';\n\nimport './_reach.scss';\nimport styles from './styles.scss';\n\nfunction Tab(props) {\n  const classNames = [\n    styles.tab,\n    props.isSelected ? styles.tabSelected : '',\n    props.className\n  ].join(' ');\n\n  return (\n    <ReachTab {...props} className={classNames}>\n      {props.children}\n    </ReachTab>\n  );\n}\n\nTab.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string,\n  isSelected: PropTypes.bool\n};\n\nTab.defaultProps = {\n  className: null,\n  isSelected: false\n};\n\n// Exports our custom Tabs component along with the default reach-ui tab and panel components.\nexport { Tabs, TabList, Tab, TabPanels, TabPanel };\n\nexport default Tabs;\n","\"use strict\";\r\n\r\nvar tester = /^[-!#$%&'*+\\/0-9=?A-Z^_a-z{|}~](\\.?[-!#$%&'*+\\/0-9=?A-Z^_a-z`{|}~])*@[a-zA-Z0-9](-*\\.?[a-zA-Z0-9])*\\.[a-zA-Z](-?[a-zA-Z0-9])+$/;\r\n// Thanks to:\r\n// http://fightingforalostcause.net/misc/2006/compare-email-regex.php\r\n// http://thedailywtf.com/Articles/Validating_Email_Addresses.aspx\r\n// http://stackoverflow.com/questions/201323/what-is-the-best-regular-expression-for-validating-email-addresses/201378#201378\r\nexports.validate = function(email)\r\n{\r\n\tif (!email)\r\n\t\treturn false;\r\n\t\t\r\n\tif(email.length>254)\r\n\t\treturn false;\r\n\r\n\tvar valid = tester.test(email);\r\n\tif(!valid)\r\n\t\treturn false;\r\n\r\n\t// Further checking of some things regex can't handle\r\n\tvar parts = email.split(\"@\");\r\n\tif(parts[0].length>64)\r\n\t\treturn false;\r\n\r\n\tvar domainParts = parts[1].split(\".\");\r\n\tif(domainParts.some(function(part) { return part.length>63; }))\r\n\t\treturn false;\r\n\r\n\treturn true;\r\n}","// Generated file. Do not edit\nexport var StatusCodes;\n(function (StatusCodes) {\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.3\n     *\n     * The request has been received but not yet acted upon. It is non-committal, meaning that there is no way in HTTP to later send an asynchronous response indicating the outcome of processing the request. It is intended for cases where another process or server handles the request, or for batch processing.\n     */\n    StatusCodes[StatusCodes[\"ACCEPTED\"] = 202] = \"ACCEPTED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.3\n     *\n     * This error response means that the server, while working as a gateway to get a response needed to handle the request, got an invalid response.\n     */\n    StatusCodes[StatusCodes[\"BAD_GATEWAY\"] = 502] = \"BAD_GATEWAY\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.1\n     *\n     * This response means that server could not understand the request due to invalid syntax.\n     */\n    StatusCodes[StatusCodes[\"BAD_REQUEST\"] = 400] = \"BAD_REQUEST\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.8\n     *\n     * This response is sent when a request conflicts with the current state of the server.\n     */\n    StatusCodes[StatusCodes[\"CONFLICT\"] = 409] = \"CONFLICT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.2.1\n     *\n     * This interim response indicates that everything so far is OK and that the client should continue with the request or ignore it if it is already finished.\n     */\n    StatusCodes[StatusCodes[\"CONTINUE\"] = 100] = \"CONTINUE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.2\n     *\n     * The request has succeeded and a new resource has been created as a result of it. This is typically the response sent after a PUT request.\n     */\n    StatusCodes[StatusCodes[\"CREATED\"] = 201] = \"CREATED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.14\n     *\n     * This response code means the expectation indicated by the Expect request header field can't be met by the server.\n     */\n    StatusCodes[StatusCodes[\"EXPECTATION_FAILED\"] = 417] = \"EXPECTATION_FAILED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.5\n     *\n     * The request failed due to failure of a previous request.\n     */\n    StatusCodes[StatusCodes[\"FAILED_DEPENDENCY\"] = 424] = \"FAILED_DEPENDENCY\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.3\n     *\n     * The client does not have access rights to the content, i.e. they are unauthorized, so server is rejecting to give proper response. Unlike 401, the client's identity is known to the server.\n     */\n    StatusCodes[StatusCodes[\"FORBIDDEN\"] = 403] = \"FORBIDDEN\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.5\n     *\n     * This error response is given when the server is acting as a gateway and cannot get a response in time.\n     */\n    StatusCodes[StatusCodes[\"GATEWAY_TIMEOUT\"] = 504] = \"GATEWAY_TIMEOUT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.9\n     *\n     * This response would be sent when the requested content has been permenantly deleted from server, with no forwarding address. Clients are expected to remove their caches and links to the resource. The HTTP specification intends this status code to be used for \"limited-time, promotional services\". APIs should not feel compelled to indicate resources that have been deleted with this status code.\n     */\n    StatusCodes[StatusCodes[\"GONE\"] = 410] = \"GONE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.6\n     *\n     * The HTTP version used in the request is not supported by the server.\n     */\n    StatusCodes[StatusCodes[\"HTTP_VERSION_NOT_SUPPORTED\"] = 505] = \"HTTP_VERSION_NOT_SUPPORTED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2324#section-2.3.2\n     *\n     * Any attempt to brew coffee with a teapot should result in the error code \"418 I'm a teapot\". The resulting entity body MAY be short and stout.\n     */\n    StatusCodes[StatusCodes[\"IM_A_TEAPOT\"] = 418] = \"IM_A_TEAPOT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.6\n     *\n     * The 507 (Insufficient Storage) status code means the method could not be performed on the resource because the server is unable to store the representation needed to successfully complete the request. This condition is considered to be temporary. If the request which received this status code was the result of a user action, the request MUST NOT be repeated until it is requested by a separate user action.\n     */\n    StatusCodes[StatusCodes[\"INSUFFICIENT_SPACE_ON_RESOURCE\"] = 419] = \"INSUFFICIENT_SPACE_ON_RESOURCE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.6\n     *\n     * The server has an internal configuration error: the chosen variant resource is configured to engage in transparent content negotiation itself, and is therefore not a proper end point in the negotiation process.\n     */\n    StatusCodes[StatusCodes[\"INSUFFICIENT_STORAGE\"] = 507] = \"INSUFFICIENT_STORAGE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.1\n     *\n     * The server encountered an unexpected condition that prevented it from fulfilling the request.\n     */\n    StatusCodes[StatusCodes[\"INTERNAL_SERVER_ERROR\"] = 500] = \"INTERNAL_SERVER_ERROR\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.10\n     *\n     * The server rejected the request because the Content-Length header field is not defined and the server requires it.\n     */\n    StatusCodes[StatusCodes[\"LENGTH_REQUIRED\"] = 411] = \"LENGTH_REQUIRED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.4\n     *\n     * The resource that is being accessed is locked.\n     */\n    StatusCodes[StatusCodes[\"LOCKED\"] = 423] = \"LOCKED\";\n    /**\n     * @deprecated\n     * Official Documentation @ https://tools.ietf.org/rfcdiff?difftype=--hwdiff&url2=draft-ietf-webdav-protocol-06.txt\n     *\n     * A deprecated response used by the Spring Framework when a method has failed.\n     */\n    StatusCodes[StatusCodes[\"METHOD_FAILURE\"] = 420] = \"METHOD_FAILURE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.5\n     *\n     * The request method is known by the server but has been disabled and cannot be used. For example, an API may forbid DELETE-ing a resource. The two mandatory methods, GET and HEAD, must never be disabled and should not return this error code.\n     */\n    StatusCodes[StatusCodes[\"METHOD_NOT_ALLOWED\"] = 405] = \"METHOD_NOT_ALLOWED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.2\n     *\n     * This response code means that URI of requested resource has been changed. Probably, new URI would be given in the response.\n     */\n    StatusCodes[StatusCodes[\"MOVED_PERMANENTLY\"] = 301] = \"MOVED_PERMANENTLY\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.3\n     *\n     * This response code means that URI of requested resource has been changed temporarily. New changes in the URI might be made in the future. Therefore, this same URI should be used by the client in future requests.\n     */\n    StatusCodes[StatusCodes[\"MOVED_TEMPORARILY\"] = 302] = \"MOVED_TEMPORARILY\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.2\n     *\n     * A Multi-Status response conveys information about multiple resources in situations where multiple status codes might be appropriate.\n     */\n    StatusCodes[StatusCodes[\"MULTI_STATUS\"] = 207] = \"MULTI_STATUS\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.1\n     *\n     * The request has more than one possible responses. User-agent or user should choose one of them. There is no standardized way to choose one of the responses.\n     */\n    StatusCodes[StatusCodes[\"MULTIPLE_CHOICES\"] = 300] = \"MULTIPLE_CHOICES\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc6585#section-6\n     *\n     * The 511 status code indicates that the client needs to authenticate to gain network access.\n     */\n    StatusCodes[StatusCodes[\"NETWORK_AUTHENTICATION_REQUIRED\"] = 511] = \"NETWORK_AUTHENTICATION_REQUIRED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.5\n     *\n     * There is no content to send for this request, but the headers may be useful. The user-agent may update its cached headers for this resource with the new ones.\n     */\n    StatusCodes[StatusCodes[\"NO_CONTENT\"] = 204] = \"NO_CONTENT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.4\n     *\n     * This response code means returned meta-information set is not exact set as available from the origin server, but collected from a local or a third party copy. Except this condition, 200 OK response should be preferred instead of this response.\n     */\n    StatusCodes[StatusCodes[\"NON_AUTHORITATIVE_INFORMATION\"] = 203] = \"NON_AUTHORITATIVE_INFORMATION\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.6\n     *\n     * This response is sent when the web server, after performing server-driven content negotiation, doesn't find any content following the criteria given by the user agent.\n     */\n    StatusCodes[StatusCodes[\"NOT_ACCEPTABLE\"] = 406] = \"NOT_ACCEPTABLE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.4\n     *\n     * The server can not find requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 to hide the existence of a resource from an unauthorized client. This response code is probably the most famous one due to its frequent occurence on the web.\n     */\n    StatusCodes[StatusCodes[\"NOT_FOUND\"] = 404] = \"NOT_FOUND\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.2\n     *\n     * The request method is not supported by the server and cannot be handled. The only methods that servers are required to support (and therefore that must not return this code) are GET and HEAD.\n     */\n    StatusCodes[StatusCodes[\"NOT_IMPLEMENTED\"] = 501] = \"NOT_IMPLEMENTED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7232#section-4.1\n     *\n     * This is used for caching purposes. It is telling to client that response has not been modified. So, client can continue to use same cached version of response.\n     */\n    StatusCodes[StatusCodes[\"NOT_MODIFIED\"] = 304] = \"NOT_MODIFIED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.1\n     *\n     * The request has succeeded. The meaning of a success varies depending on the HTTP method:\n     * GET: The resource has been fetched and is transmitted in the message body.\n     * HEAD: The entity headers are in the message body.\n     * POST: The resource describing the result of the action is transmitted in the message body.\n     * TRACE: The message body contains the request message as received by the server\n     */\n    StatusCodes[StatusCodes[\"OK\"] = 200] = \"OK\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7233#section-4.1\n     *\n     * This response code is used because of range header sent by the client to separate download into multiple streams.\n     */\n    StatusCodes[StatusCodes[\"PARTIAL_CONTENT\"] = 206] = \"PARTIAL_CONTENT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.2\n     *\n     * This response code is reserved for future use. Initial aim for creating this code was using it for digital payment systems however this is not used currently.\n     */\n    StatusCodes[StatusCodes[\"PAYMENT_REQUIRED\"] = 402] = \"PAYMENT_REQUIRED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7538#section-3\n     *\n     * This means that the resource is now permanently located at another URI, specified by the Location: HTTP Response header. This has the same semantics as the 301 Moved Permanently HTTP response code, with the exception that the user agent must not change the HTTP method used: if a POST was used in the first request, a POST must be used in the second request.\n     */\n    StatusCodes[StatusCodes[\"PERMANENT_REDIRECT\"] = 308] = \"PERMANENT_REDIRECT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7232#section-4.2\n     *\n     * The client has indicated preconditions in its headers which the server does not meet.\n     */\n    StatusCodes[StatusCodes[\"PRECONDITION_FAILED\"] = 412] = \"PRECONDITION_FAILED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc6585#section-3\n     *\n     * The origin server requires the request to be conditional. Intended to prevent the 'lost update' problem, where a client GETs a resource's state, modifies it, and PUTs it back to the server, when meanwhile a third party has modified the state on the server, leading to a conflict.\n     */\n    StatusCodes[StatusCodes[\"PRECONDITION_REQUIRED\"] = 428] = \"PRECONDITION_REQUIRED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.1\n     *\n     * This code indicates that the server has received and is processing the request, but no response is available yet.\n     */\n    StatusCodes[StatusCodes[\"PROCESSING\"] = 102] = \"PROCESSING\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7235#section-3.2\n     *\n     * This is similar to 401 but authentication is needed to be done by a proxy.\n     */\n    StatusCodes[StatusCodes[\"PROXY_AUTHENTICATION_REQUIRED\"] = 407] = \"PROXY_AUTHENTICATION_REQUIRED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc6585#section-5\n     *\n     * The server is unwilling to process the request because its header fields are too large. The request MAY be resubmitted after reducing the size of the request header fields.\n     */\n    StatusCodes[StatusCodes[\"REQUEST_HEADER_FIELDS_TOO_LARGE\"] = 431] = \"REQUEST_HEADER_FIELDS_TOO_LARGE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.7\n     *\n     * This response is sent on an idle connection by some servers, even without any previous request by the client. It means that the server would like to shut down this unused connection. This response is used much more since some browsers, like Chrome, Firefox 27+, or IE9, use HTTP pre-connection mechanisms to speed up surfing. Also note that some servers merely shut down the connection without sending this message.\n     */\n    StatusCodes[StatusCodes[\"REQUEST_TIMEOUT\"] = 408] = \"REQUEST_TIMEOUT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.11\n     *\n     * Request entity is larger than limits defined by server; the server might close the connection or return an Retry-After header field.\n     */\n    StatusCodes[StatusCodes[\"REQUEST_TOO_LONG\"] = 413] = \"REQUEST_TOO_LONG\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.12\n     *\n     * The URI requested by the client is longer than the server is willing to interpret.\n     */\n    StatusCodes[StatusCodes[\"REQUEST_URI_TOO_LONG\"] = 414] = \"REQUEST_URI_TOO_LONG\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7233#section-4.4\n     *\n     * The range specified by the Range header field in the request can't be fulfilled; it's possible that the range is outside the size of the target URI's data.\n     */\n    StatusCodes[StatusCodes[\"REQUESTED_RANGE_NOT_SATISFIABLE\"] = 416] = \"REQUESTED_RANGE_NOT_SATISFIABLE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.3.6\n     *\n     * This response code is sent after accomplishing request to tell user agent reset document view which sent this request.\n     */\n    StatusCodes[StatusCodes[\"RESET_CONTENT\"] = 205] = \"RESET_CONTENT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.4\n     *\n     * Server sent this response to directing client to get requested resource to another URI with an GET request.\n     */\n    StatusCodes[StatusCodes[\"SEE_OTHER\"] = 303] = \"SEE_OTHER\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.6.4\n     *\n     * The server is not ready to handle the request. Common causes are a server that is down for maintenance or that is overloaded. Note that together with this response, a user-friendly page explaining the problem should be sent. This responses should be used for temporary conditions and the Retry-After: HTTP header should, if possible, contain the estimated time before the recovery of the service. The webmaster must also take care about the caching-related headers that are sent along with this response, as these temporary condition responses should usually not be cached.\n     */\n    StatusCodes[StatusCodes[\"SERVICE_UNAVAILABLE\"] = 503] = \"SERVICE_UNAVAILABLE\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.2.2\n     *\n     * This code is sent in response to an Upgrade request header by the client, and indicates the protocol the server is switching too.\n     */\n    StatusCodes[StatusCodes[\"SWITCHING_PROTOCOLS\"] = 101] = \"SWITCHING_PROTOCOLS\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.7\n     *\n     * Server sent this response to directing client to get requested resource to another URI with same method that used prior request. This has the same semantic than the 302 Found HTTP response code, with the exception that the user agent must not change the HTTP method used: if a POST was used in the first request, a POST must be used in the second request.\n     */\n    StatusCodes[StatusCodes[\"TEMPORARY_REDIRECT\"] = 307] = \"TEMPORARY_REDIRECT\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc6585#section-4\n     *\n     * The user has sent too many requests in a given amount of time (\"rate limiting\").\n     */\n    StatusCodes[StatusCodes[\"TOO_MANY_REQUESTS\"] = 429] = \"TOO_MANY_REQUESTS\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7235#section-3.1\n     *\n     * Although the HTTP standard specifies \"unauthorized\", semantically this response means \"unauthenticated\". That is, the client must authenticate itself to get the requested response.\n     */\n    StatusCodes[StatusCodes[\"UNAUTHORIZED\"] = 401] = \"UNAUTHORIZED\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7725\n     *\n     * The user-agent requested a resource that cannot legally be provided, such as a web page censored by a government.\n     */\n    StatusCodes[StatusCodes[\"UNAVAILABLE_FOR_LEGAL_REASONS\"] = 451] = \"UNAVAILABLE_FOR_LEGAL_REASONS\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc2518#section-10.3\n     *\n     * The request was well-formed but was unable to be followed due to semantic errors.\n     */\n    StatusCodes[StatusCodes[\"UNPROCESSABLE_ENTITY\"] = 422] = \"UNPROCESSABLE_ENTITY\";\n    /**\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.5.13\n     *\n     * The media format of the requested data is not supported by the server, so the server is rejecting the request.\n     */\n    StatusCodes[StatusCodes[\"UNSUPPORTED_MEDIA_TYPE\"] = 415] = \"UNSUPPORTED_MEDIA_TYPE\";\n    /**\n     * @deprecated\n     * Official Documentation @ https://tools.ietf.org/html/rfc7231#section-6.4.6\n     *\n     * Was defined in a previous version of the HTTP specification to indicate that a requested response must be accessed by a proxy. It has been deprecated due to security concerns regarding in-band configuration of a proxy.\n     */\n    StatusCodes[StatusCodes[\"USE_PROXY\"] = 305] = \"USE_PROXY\";\n    /**\n     * Official Documentation @ https://datatracker.ietf.org/doc/html/rfc7540#section-9.1.2\n     *\n     * Defined in the specification of HTTP/2 to indicate that a server is not able to produce a response for the combination of scheme and authority that are included in the request URI.\n     */\n    StatusCodes[StatusCodes[\"MISDIRECTED_REQUEST\"] = 421] = \"MISDIRECTED_REQUEST\";\n})(StatusCodes || (StatusCodes = {}));\n","import baseEach from './_baseEach.js';\nimport isArrayLike from './isArrayLike.js';\n\n/**\n * The base implementation of `_.map` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction baseMap(collection, iteratee) {\n  var index = -1,\n      result = isArrayLike(collection) ? Array(collection.length) : [];\n\n  baseEach(collection, function(value, key, collection) {\n    result[++index] = iteratee(value, key, collection);\n  });\n  return result;\n}\n\nexport default baseMap;\n","/**\n * The base implementation of `_.sortBy` which uses `comparer` to define the\n * sort order of `array` and replaces criteria objects with their corresponding\n * values.\n *\n * @private\n * @param {Array} array The array to sort.\n * @param {Function} comparer The function to define sort order.\n * @returns {Array} Returns `array`.\n */\nfunction baseSortBy(array, comparer) {\n  var length = array.length;\n\n  array.sort(comparer);\n  while (length--) {\n    array[length] = array[length].value;\n  }\n  return array;\n}\n\nexport default baseSortBy;\n","import isSymbol from './isSymbol.js';\n\n/**\n * Compares values to sort them in ascending order.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {number} Returns the sort order indicator for `value`.\n */\nfunction compareAscending(value, other) {\n  if (value !== other) {\n    var valIsDefined = value !== undefined,\n        valIsNull = value === null,\n        valIsReflexive = value === value,\n        valIsSymbol = isSymbol(value);\n\n    var othIsDefined = other !== undefined,\n        othIsNull = other === null,\n        othIsReflexive = other === other,\n        othIsSymbol = isSymbol(other);\n\n    if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||\n        (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||\n        (valIsNull && othIsDefined && othIsReflexive) ||\n        (!valIsDefined && othIsReflexive) ||\n        !valIsReflexive) {\n      return 1;\n    }\n    if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||\n        (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||\n        (othIsNull && valIsDefined && valIsReflexive) ||\n        (!othIsDefined && valIsReflexive) ||\n        !othIsReflexive) {\n      return -1;\n    }\n  }\n  return 0;\n}\n\nexport default compareAscending;\n","import compareAscending from './_compareAscending.js';\n\n/**\n * Used by `_.orderBy` to compare multiple properties of a value to another\n * and stable sort them.\n *\n * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,\n * specify an order of \"desc\" for descending or \"asc\" for ascending sort order\n * of corresponding values.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {boolean[]|string[]} orders The order to sort by for each property.\n * @returns {number} Returns the sort order indicator for `object`.\n */\nfunction compareMultiple(object, other, orders) {\n  var index = -1,\n      objCriteria = object.criteria,\n      othCriteria = other.criteria,\n      length = objCriteria.length,\n      ordersLength = orders.length;\n\n  while (++index < length) {\n    var result = compareAscending(objCriteria[index], othCriteria[index]);\n    if (result) {\n      if (index >= ordersLength) {\n        return result;\n      }\n      var order = orders[index];\n      return result * (order == 'desc' ? -1 : 1);\n    }\n  }\n  // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications\n  // that causes it, under certain circumstances, to provide the same value for\n  // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247\n  // for more details.\n  //\n  // This also ensures a stable sort in V8 and other engines.\n  // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n  return object.index - other.index;\n}\n\nexport default compareMultiple;\n","import arrayMap from './_arrayMap.js';\nimport baseIteratee from './_baseIteratee.js';\nimport baseMap from './_baseMap.js';\nimport baseSortBy from './_baseSortBy.js';\nimport baseUnary from './_baseUnary.js';\nimport compareMultiple from './_compareMultiple.js';\nimport identity from './identity.js';\n\n/**\n * The base implementation of `_.orderBy` without param guards.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n * @param {string[]} orders The sort orders of `iteratees`.\n * @returns {Array} Returns the new sorted array.\n */\nfunction baseOrderBy(collection, iteratees, orders) {\n  var index = -1;\n  iteratees = arrayMap(iteratees.length ? iteratees : [identity], baseUnary(baseIteratee));\n\n  var result = baseMap(collection, function(value, key, collection) {\n    var criteria = arrayMap(iteratees, function(iteratee) {\n      return iteratee(value);\n    });\n    return { 'criteria': criteria, 'index': ++index, 'value': value };\n  });\n\n  return baseSortBy(result, function(object, other) {\n    return compareMultiple(object, other, orders);\n  });\n}\n\nexport default baseOrderBy;\n","import capitalize from './capitalize.js';\nimport createCompounder from './_createCompounder.js';\n\n/**\n * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the camel cased string.\n * @example\n *\n * _.camelCase('Foo Bar');\n * // => 'fooBar'\n *\n * _.camelCase('--foo-bar--');\n * // => 'fooBar'\n *\n * _.camelCase('__FOO_BAR__');\n * // => 'fooBar'\n */\nvar camelCase = createCompounder(function(result, word, index) {\n  word = word.toLowerCase();\n  return result + (index ? capitalize(word) : word);\n});\n\nexport default camelCase;\n","/**\n * Creates an array with all falsey values removed. The values `false`, `null`,\n * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to compact.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * _.compact([0, 1, false, 2, '', 3]);\n * // => [1, 2, 3]\n */\nfunction compact(array) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (value) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\nexport default compact;\n","import basePropertyOf from './_basePropertyOf.js';\n\n/** Used to map characters to HTML entities. */\nvar htmlEscapes = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&quot;',\n  \"'\": '&#39;'\n};\n\n/**\n * Used by `_.escape` to convert characters to HTML entities.\n *\n * @private\n * @param {string} chr The matched character to escape.\n * @returns {string} Returns the escaped character.\n */\nvar escapeHtmlChar = basePropertyOf(htmlEscapes);\n\nexport default escapeHtmlChar;\n","import escapeHtmlChar from './_escapeHtmlChar.js';\nimport toString from './toString.js';\n\n/** Used to match HTML entities and HTML characters. */\nvar reUnescapedHtml = /[&<>\"']/g,\n    reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n/**\n * Converts the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\n * corresponding HTML entities.\n *\n * **Note:** No other characters are escaped. To escape additional\n * characters use a third-party library like [_he_](https://mths.be/he).\n *\n * Though the \">\" character is escaped for symmetry, characters like\n * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n * unless they're part of a tag or unquoted attribute value. See\n * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n * (under \"semi-related fun fact\") for more details.\n *\n * When working with HTML you should always\n * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n * XSS vectors.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escape('fred, barney, & pebbles');\n * // => 'fred, barney, &amp; pebbles'\n */\nfunction escape(string) {\n  string = toString(string);\n  return (string && reHasUnescapedHtml.test(string))\n    ? string.replace(reUnescapedHtml, escapeHtmlChar)\n    : string;\n}\n\nexport default escape;\n","import baseIteratee from './_baseIteratee.js';\nimport isArrayLike from './isArrayLike.js';\nimport keys from './keys.js';\n\n/**\n * Creates a `_.find` or `_.findLast` function.\n *\n * @private\n * @param {Function} findIndexFunc The function to find the collection index.\n * @returns {Function} Returns the new find function.\n */\nfunction createFind(findIndexFunc) {\n  return function(collection, predicate, fromIndex) {\n    var iterable = Object(collection);\n    if (!isArrayLike(collection)) {\n      var iteratee = baseIteratee(predicate, 3);\n      collection = keys(collection);\n      predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n    }\n    var index = findIndexFunc(collection, predicate, fromIndex);\n    return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;\n  };\n}\n\nexport default createFind;\n","import baseFindIndex from './_baseFindIndex.js';\nimport baseIteratee from './_baseIteratee.js';\nimport toInteger from './toInteger.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * This method is like `_.find` except that it returns the index of the first\n * element `predicate` returns truthy for instead of the element itself.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {number} Returns the index of the found element, else `-1`.\n * @example\n *\n * var users = [\n *   { 'user': 'barney',  'active': false },\n *   { 'user': 'fred',    'active': false },\n *   { 'user': 'pebbles', 'active': true }\n * ];\n *\n * _.findIndex(users, function(o) { return o.user == 'barney'; });\n * // => 0\n *\n * // The `_.matches` iteratee shorthand.\n * _.findIndex(users, { 'user': 'fred', 'active': false });\n * // => 1\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findIndex(users, ['active', false]);\n * // => 0\n *\n * // The `_.property` iteratee shorthand.\n * _.findIndex(users, 'active');\n * // => 2\n */\nfunction findIndex(array, predicate, fromIndex) {\n  var length = array == null ? 0 : array.length;\n  if (!length) {\n    return -1;\n  }\n  var index = fromIndex == null ? 0 : toInteger(fromIndex);\n  if (index < 0) {\n    index = nativeMax(length + index, 0);\n  }\n  return baseFindIndex(array, baseIteratee(predicate, 3), index);\n}\n\nexport default findIndex;\n","import createFind from './_createFind.js';\nimport findIndex from './findIndex.js';\n\n/**\n * Iterates over elements of `collection`, returning the first element\n * `predicate` returns truthy for. The predicate is invoked with three\n * arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {*} Returns the matched element, else `undefined`.\n * @example\n *\n * var users = [\n *   { 'user': 'barney',  'age': 36, 'active': true },\n *   { 'user': 'fred',    'age': 40, 'active': false },\n *   { 'user': 'pebbles', 'age': 1,  'active': true }\n * ];\n *\n * _.find(users, function(o) { return o.age < 40; });\n * // => object for 'barney'\n *\n * // The `_.matches` iteratee shorthand.\n * _.find(users, { 'age': 1, 'active': true });\n * // => object for 'pebbles'\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.find(users, ['active', false]);\n * // => object for 'fred'\n *\n * // The `_.property` iteratee shorthand.\n * _.find(users, 'active');\n * // => object for 'barney'\n */\nvar find = createFind(findIndex);\n\nexport default find;\n","/**\n * Checks if `value` is `null` or `undefined`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n * @example\n *\n * _.isNil(null);\n * // => true\n *\n * _.isNil(void 0);\n * // => true\n *\n * _.isNil(NaN);\n * // => false\n */\nfunction isNil(value) {\n  return value == null;\n}\n\nexport default isNil;\n","import baseOrderBy from './_baseOrderBy.js';\nimport isArray from './isArray.js';\n\n/**\n * This method is like `_.sortBy` except that it allows specifying the sort\n * orders of the iteratees to sort by. If `orders` is unspecified, all values\n * are sorted in ascending order. Otherwise, specify an order of \"desc\" for\n * descending or \"asc\" for ascending sort order of corresponding values.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]\n *  The iteratees to sort by.\n * @param {string[]} [orders] The sort orders of `iteratees`.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n * @returns {Array} Returns the new sorted array.\n * @example\n *\n * var users = [\n *   { 'user': 'fred',   'age': 48 },\n *   { 'user': 'barney', 'age': 34 },\n *   { 'user': 'fred',   'age': 40 },\n *   { 'user': 'barney', 'age': 36 }\n * ];\n *\n * // Sort by `user` in ascending order and by `age` in descending order.\n * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);\n * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n */\nfunction orderBy(collection, iteratees, orders, guard) {\n  if (collection == null) {\n    return [];\n  }\n  if (!isArray(iteratees)) {\n    iteratees = iteratees == null ? [] : [iteratees];\n  }\n  orders = guard ? undefined : orders;\n  if (!isArray(orders)) {\n    orders = orders == null ? [] : [orders];\n  }\n  return baseOrderBy(collection, iteratees, orders);\n}\n\nexport default orderBy;\n","/**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\nfunction last(array) {\n  var length = array == null ? 0 : array.length;\n  return length ? array[length - 1] : undefined;\n}\n\nexport default last;\n","import baseGet from './_baseGet.js';\nimport baseSlice from './_baseSlice.js';\n\n/**\n * Gets the parent value at `path` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} path The path to get the parent value of.\n * @returns {*} Returns the parent value.\n */\nfunction parent(object, path) {\n  return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n}\n\nexport default parent;\n","import castPath from './_castPath.js';\nimport last from './last.js';\nimport parent from './_parent.js';\nimport toKey from './_toKey.js';\n\n/**\n * The base implementation of `_.unset`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The property path to unset.\n * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n */\nfunction baseUnset(object, path) {\n  path = castPath(path, object);\n  object = parent(object, path);\n  return object == null || delete object[toKey(last(path))];\n}\n\nexport default baseUnset;\n","import baseUnset from './_baseUnset.js';\nimport isIndex from './_isIndex.js';\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * The base implementation of `_.pullAt` without support for individual\n * indexes or capturing the removed elements.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {number[]} indexes The indexes of elements to remove.\n * @returns {Array} Returns `array`.\n */\nfunction basePullAt(array, indexes) {\n  var length = array ? indexes.length : 0,\n      lastIndex = length - 1;\n\n  while (length--) {\n    var index = indexes[length];\n    if (length == lastIndex || index !== previous) {\n      var previous = index;\n      if (isIndex(index)) {\n        splice.call(array, index, 1);\n      } else {\n        baseUnset(array, index);\n      }\n    }\n  }\n  return array;\n}\n\nexport default basePullAt;\n","import baseIteratee from './_baseIteratee.js';\nimport basePullAt from './_basePullAt.js';\n\n/**\n * Removes all elements from `array` that `predicate` returns truthy for\n * and returns an array of the removed elements. The predicate is invoked\n * with three arguments: (value, index, array).\n *\n * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`\n * to pull elements from an array by value.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new array of removed elements.\n * @example\n *\n * var array = [1, 2, 3, 4];\n * var evens = _.remove(array, function(n) {\n *   return n % 2 == 0;\n * });\n *\n * console.log(array);\n * // => [1, 3]\n *\n * console.log(evens);\n * // => [2, 4]\n */\nfunction remove(array, predicate) {\n  var result = [];\n  if (!(array && array.length)) {\n    return result;\n  }\n  var index = -1,\n      indexes = [],\n      length = array.length;\n\n  predicate = baseIteratee(predicate, 3);\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result.push(value);\n      indexes.push(index);\n    }\n  }\n  basePullAt(array, indexes);\n  return result;\n}\n\nexport default remove;\n","import baseGetTag from './_baseGetTag.js';\nimport isArray from './isArray.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar stringTag = '[object String]';\n\n/**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\nfunction isString(value) {\n  return typeof value == 'string' ||\n    (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n}\n\nexport default isString;\n","import baseProperty from './_baseProperty.js';\n\n/**\n * Gets the size of an ASCII `string`.\n *\n * @private\n * @param {string} string The string inspect.\n * @returns {number} Returns the string size.\n */\nvar asciiSize = baseProperty('length');\n\nexport default asciiSize;\n","/** Used to compose unicode character classes. */\nvar rsAstralRange = '\\\\ud800-\\\\udfff',\n    rsComboMarksRange = '\\\\u0300-\\\\u036f',\n    reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n    rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n    rsVarRange = '\\\\ufe0e\\\\ufe0f';\n\n/** Used to compose unicode capture groups. */\nvar rsAstral = '[' + rsAstralRange + ']',\n    rsCombo = '[' + rsComboRange + ']',\n    rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n    rsNonAstral = '[^' + rsAstralRange + ']',\n    rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n    rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n    rsZWJ = '\\\\u200d';\n\n/** Used to compose unicode regexes. */\nvar reOptMod = rsModifier + '?',\n    rsOptVar = '[' + rsVarRange + ']?',\n    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n    rsSeq = rsOptVar + reOptMod + rsOptJoin,\n    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\nvar reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n/**\n * Gets the size of a Unicode `string`.\n *\n * @private\n * @param {string} string The string inspect.\n * @returns {number} Returns the string size.\n */\nfunction unicodeSize(string) {\n  var result = reUnicode.lastIndex = 0;\n  while (reUnicode.test(string)) {\n    ++result;\n  }\n  return result;\n}\n\nexport default unicodeSize;\n","import asciiSize from './_asciiSize.js';\nimport hasUnicode from './_hasUnicode.js';\nimport unicodeSize from './_unicodeSize.js';\n\n/**\n * Gets the number of symbols in `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the string size.\n */\nfunction stringSize(string) {\n  return hasUnicode(string)\n    ? unicodeSize(string)\n    : asciiSize(string);\n}\n\nexport default stringSize;\n","import baseKeys from './_baseKeys.js';\nimport getTag from './_getTag.js';\nimport isArrayLike from './isArrayLike.js';\nimport isString from './isString.js';\nimport stringSize from './_stringSize.js';\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n    setTag = '[object Set]';\n\n/**\n * Gets the size of `collection` by returning its length for array-like\n * values or the number of own enumerable string keyed properties for objects.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object|string} collection The collection to inspect.\n * @returns {number} Returns the collection size.\n * @example\n *\n * _.size([1, 2, 3]);\n * // => 3\n *\n * _.size({ 'a': 1, 'b': 2 });\n * // => 2\n *\n * _.size('pebbles');\n * // => 7\n */\nfunction size(collection) {\n  if (collection == null) {\n    return 0;\n  }\n  if (isArrayLike(collection)) {\n    return isString(collection) ? stringSize(collection) : collection.length;\n  }\n  var tag = getTag(collection);\n  if (tag == mapTag || tag == setTag) {\n    return collection.size;\n  }\n  return baseKeys(collection).length;\n}\n\nexport default size;\n","import baseFlatten from './_baseFlatten.js';\nimport baseOrderBy from './_baseOrderBy.js';\nimport baseRest from './_baseRest.js';\nimport isIterateeCall from './_isIterateeCall.js';\n\n/**\n * Creates an array of elements, sorted in ascending order by the results of\n * running each element in a collection thru each iteratee. This method\n * performs a stable sort, that is, it preserves the original sort order of\n * equal elements. The iteratees are invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {...(Function|Function[])} [iteratees=[_.identity]]\n *  The iteratees to sort by.\n * @returns {Array} Returns the new sorted array.\n * @example\n *\n * var users = [\n *   { 'user': 'fred',   'age': 48 },\n *   { 'user': 'barney', 'age': 36 },\n *   { 'user': 'fred',   'age': 40 },\n *   { 'user': 'barney', 'age': 34 }\n * ];\n *\n * _.sortBy(users, [function(o) { return o.user; }]);\n * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n *\n * _.sortBy(users, ['user', 'age']);\n * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]\n */\nvar sortBy = baseRest(function(collection, iteratees) {\n  if (collection == null) {\n    return [];\n  }\n  var length = iteratees.length;\n  if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n    iteratees = [];\n  } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n    iteratees = [iteratees[0]];\n  }\n  return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n});\n\nexport default sortBy;\n","import toString from './toString.js';\n\n/**\n * Converts `string`, as a whole, to lower case just like\n * [String#toLowerCase](https://mdn.io/toLowerCase).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the lower cased string.\n * @example\n *\n * _.toLower('--Foo-Bar--');\n * // => '--foo-bar--'\n *\n * _.toLower('fooBar');\n * // => 'foobar'\n *\n * _.toLower('__FOO_BAR__');\n * // => '__foo_bar__'\n */\nfunction toLower(value) {\n  return toString(value).toLowerCase();\n}\n\nexport default toLower;\n","import baseIndexOf from './_baseIndexOf.js';\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol\n * that is not found in the character symbols.\n *\n * @private\n * @param {Array} strSymbols The string symbols to inspect.\n * @param {Array} chrSymbols The character symbols to find.\n * @returns {number} Returns the index of the last unmatched string symbol.\n */\nfunction charsEndIndex(strSymbols, chrSymbols) {\n  var index = strSymbols.length;\n\n  while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n  return index;\n}\n\nexport default charsEndIndex;\n","import baseIndexOf from './_baseIndexOf.js';\n\n/**\n * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol\n * that is not found in the character symbols.\n *\n * @private\n * @param {Array} strSymbols The string symbols to inspect.\n * @param {Array} chrSymbols The character symbols to find.\n * @returns {number} Returns the index of the first unmatched string symbol.\n */\nfunction charsStartIndex(strSymbols, chrSymbols) {\n  var index = -1,\n      length = strSymbols.length;\n\n  while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n  return index;\n}\n\nexport default charsStartIndex;\n","import baseToString from './_baseToString.js';\nimport castSlice from './_castSlice.js';\nimport charsEndIndex from './_charsEndIndex.js';\nimport charsStartIndex from './_charsStartIndex.js';\nimport stringToArray from './_stringToArray.js';\nimport toString from './toString.js';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/**\n * Removes leading and trailing whitespace or specified characters from `string`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to trim.\n * @param {string} [chars=whitespace] The characters to trim.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the trimmed string.\n * @example\n *\n * _.trim('  abc  ');\n * // => 'abc'\n *\n * _.trim('-_-abc-_-', '_-');\n * // => 'abc'\n *\n * _.map(['  foo  ', '  bar  '], _.trim);\n * // => ['foo', 'bar']\n */\nfunction trim(string, chars, guard) {\n  string = toString(string);\n  if (string && (guard || chars === undefined)) {\n    return string.replace(reTrim, '');\n  }\n  if (!string || !(chars = baseToString(chars))) {\n    return string;\n  }\n  var strSymbols = stringToArray(string),\n      chrSymbols = stringToArray(chars),\n      start = charsStartIndex(strSymbols, chrSymbols),\n      end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n  return castSlice(strSymbols, start, end).join('');\n}\n\nexport default trim;\n","/**\n * This method returns `undefined`.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Util\n * @example\n *\n * _.times(2, _.noop);\n * // => [undefined, undefined]\n */\nfunction noop() {\n  // No operation performed.\n}\n\nexport default noop;\n","import Set from './_Set.js';\nimport noop from './noop.js';\nimport setToArray from './_setToArray.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Creates a set object of `values`.\n *\n * @private\n * @param {Array} values The values to add to the set.\n * @returns {Object} Returns the new set.\n */\nvar createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n  return new Set(values);\n};\n\nexport default createSet;\n","import SetCache from './_SetCache.js';\nimport arrayIncludes from './_arrayIncludes.js';\nimport arrayIncludesWith from './_arrayIncludesWith.js';\nimport cacheHas from './_cacheHas.js';\nimport createSet from './_createSet.js';\nimport setToArray from './_setToArray.js';\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n */\nfunction baseUniq(array, iteratee, comparator) {\n  var index = -1,\n      includes = arrayIncludes,\n      length = array.length,\n      isCommon = true,\n      result = [],\n      seen = result;\n\n  if (comparator) {\n    isCommon = false;\n    includes = arrayIncludesWith;\n  }\n  else if (length >= LARGE_ARRAY_SIZE) {\n    var set = iteratee ? null : createSet(array);\n    if (set) {\n      return setToArray(set);\n    }\n    isCommon = false;\n    includes = cacheHas;\n    seen = new SetCache;\n  }\n  else {\n    seen = iteratee ? [] : result;\n  }\n  outer:\n  while (++index < length) {\n    var value = array[index],\n        computed = iteratee ? iteratee(value) : value;\n\n    value = (comparator || value !== 0) ? value : 0;\n    if (isCommon && computed === computed) {\n      var seenIndex = seen.length;\n      while (seenIndex--) {\n        if (seen[seenIndex] === computed) {\n          continue outer;\n        }\n      }\n      if (iteratee) {\n        seen.push(computed);\n      }\n      result.push(value);\n    }\n    else if (!includes(seen, computed, comparator)) {\n      if (seen !== result) {\n        seen.push(computed);\n      }\n      result.push(value);\n    }\n  }\n  return result;\n}\n\nexport default baseUniq;\n","import baseIteratee from './_baseIteratee.js';\nimport baseUniq from './_baseUniq.js';\n\n/**\n * This method is like `_.uniq` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * uniqueness is computed. The order of result values is determined by the\n * order they occur in the array. The iteratee is invoked with one argument:\n * (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n * // => [2.1, 1.2]\n *\n * // The `_.property` iteratee shorthand.\n * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 1 }, { 'x': 2 }]\n */\nfunction uniqBy(array, iteratee) {\n  return (array && array.length) ? baseUniq(array, baseIteratee(iteratee, 2)) : [];\n}\n\nexport default uniqBy;\n","import * as React from 'react';\nimport { useEffect } from 'react';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n\n  _setPrototypeOf(subClass, superClass);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nvar observerMap = new Map();\nvar RootIds = new WeakMap();\nvar rootId = 0;\nvar unsupportedValue = undefined;\n/**\r\n * What should be the default behavior if the IntersectionObserver is unsupported?\r\n * Ideally the polyfill has been loaded, you can have the following happen:\r\n * - `undefined`: Throw an error\r\n * - `true` or `false`: Set the `inView` value to this regardless of intersection state\r\n * **/\n\nfunction defaultFallbackInView(inView) {\n  unsupportedValue = inView;\n}\n/**\r\n * Generate a unique ID for the root element\r\n * @param root\r\n */\n\nfunction getRootId(root) {\n  if (!root) return '0';\n  if (RootIds.has(root)) return RootIds.get(root);\n  rootId += 1;\n  RootIds.set(root, rootId.toString());\n  return RootIds.get(root);\n}\n/**\r\n * Convert the options to a string Id, based on the values.\r\n * Ensures we can reuse the same observer when observing elements with the same options.\r\n * @param options\r\n */\n\n\nfunction optionsToId(options) {\n  return Object.keys(options).sort().filter(function (key) {\n    return options[key] !== undefined;\n  }).map(function (key) {\n    return key + \"_\" + (key === 'root' ? getRootId(options.root) : options[key]);\n  }).toString();\n}\n\nfunction createObserver(options) {\n  // Create a unique ID for this observer instance, based on the root, root margin and threshold.\n  var id = optionsToId(options);\n  var instance = observerMap.get(id);\n\n  if (!instance) {\n    // Create a map of elements this observer is going to observe. Each element has a list of callbacks that should be triggered, once it comes into view.\n    var elements = new Map();\n    var thresholds;\n    var observer = new IntersectionObserver(function (entries) {\n      entries.forEach(function (entry) {\n        var _elements$get;\n\n        // While it would be nice if you could just look at isIntersecting to determine if the component is inside the viewport, browsers can't agree on how to use it.\n        // -Firefox ignores `threshold` when considering `isIntersecting`, so it will never be false again if `threshold` is > 0\n        var inView = entry.isIntersecting && thresholds.some(function (threshold) {\n          return entry.intersectionRatio >= threshold;\n        }); // @ts-ignore support IntersectionObserver v2\n\n        if (options.trackVisibility && typeof entry.isVisible === 'undefined') {\n          // The browser doesn't support Intersection Observer v2, falling back to v1 behavior.\n          // @ts-ignore\n          entry.isVisible = inView;\n        }\n\n        (_elements$get = elements.get(entry.target)) == null ? void 0 : _elements$get.forEach(function (callback) {\n          callback(inView, entry);\n        });\n      });\n    }, options); // Ensure we have a valid thresholds array. If not, use the threshold from the options\n\n    thresholds = observer.thresholds || (Array.isArray(options.threshold) ? options.threshold : [options.threshold || 0]);\n    instance = {\n      id: id,\n      observer: observer,\n      elements: elements\n    };\n    observerMap.set(id, instance);\n  }\n\n  return instance;\n}\n/**\r\n * @param element - DOM Element to observe\r\n * @param callback - Callback function to trigger when intersection status changes\r\n * @param options - Intersection Observer options\r\n * @param fallbackInView - Fallback inView value.\r\n * @return Function - Cleanup function that should be triggered to unregister the observer\r\n */\n\n\nfunction observe(element, callback, options, fallbackInView) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  if (fallbackInView === void 0) {\n    fallbackInView = unsupportedValue;\n  }\n\n  if (typeof window.IntersectionObserver === 'undefined' && fallbackInView !== undefined) {\n    var bounds = element.getBoundingClientRect();\n    callback(fallbackInView, {\n      isIntersecting: fallbackInView,\n      target: element,\n      intersectionRatio: typeof options.threshold === 'number' ? options.threshold : 0,\n      time: 0,\n      boundingClientRect: bounds,\n      intersectionRect: bounds,\n      rootBounds: bounds\n    });\n    return function () {// Nothing to cleanup\n    };\n  } // An observer with the same options can be reused, so lets use this fact\n\n\n  var _createObserver = createObserver(options),\n      id = _createObserver.id,\n      observer = _createObserver.observer,\n      elements = _createObserver.elements; // Register the callback listener for this element\n\n\n  var callbacks = elements.get(element) || [];\n\n  if (!elements.has(element)) {\n    elements.set(element, callbacks);\n  }\n\n  callbacks.push(callback);\n  observer.observe(element);\n  return function unobserve() {\n    // Remove the callback from the callback list\n    callbacks.splice(callbacks.indexOf(callback), 1);\n\n    if (callbacks.length === 0) {\n      // No more callback exists for element, so destroy it\n      elements[\"delete\"](element);\n      observer.unobserve(element);\n    }\n\n    if (elements.size === 0) {\n      // No more elements are being observer by this instance, so destroy it\n      observer.disconnect();\n      observerMap[\"delete\"](id);\n    }\n  };\n}\n\nvar _excluded = [\"children\", \"as\", \"triggerOnce\", \"threshold\", \"root\", \"rootMargin\", \"onChange\", \"skip\", \"trackVisibility\", \"delay\", \"initialInView\", \"fallbackInView\"];\n\nfunction isPlainChildren(props) {\n  return typeof props.children !== 'function';\n}\n/**\r\n ## Render props\r\n\n To use the `<InView>` component, you pass it a function. It will be called\r\n whenever the state changes, with the new value of `inView`. In addition to the\r\n `inView` prop, children also receive a `ref` that should be set on the\r\n containing DOM element. This is the element that the IntersectionObserver will\r\n monitor.\r\n\n If you need it, you can also access the\r\n [`IntersectionObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry)\r\n on `entry`, giving you access to all the details about the current intersection\r\n state.\r\n\n ```jsx\r\n import { InView } from 'react-intersection-observer';\r\n\n const Component = () => (\r\n <InView>\r\n {({ inView, ref, entry }) => (\r\n      <div ref={ref}>\r\n        <h2>{`Header inside viewport ${inView}.`}</h2>\r\n      </div>\r\n    )}\r\n </InView>\r\n );\r\n\n export default Component;\r\n ```\r\n\n ## Plain children\r\n\n You can pass any element to the `<InView />`, and it will handle creating the\r\n wrapping DOM element. Add a handler to the `onChange` method, and control the\r\n state in your own component. Any extra props you add to `<InView>` will be\r\n passed to the HTML element, allowing you set the `className`, `style`, etc.\r\n\n ```jsx\r\n import { InView } from 'react-intersection-observer';\r\n\n const Component = () => (\r\n <InView as=\"div\" onChange={(inView, entry) => console.log('Inview:', inView)}>\r\n <h2>Plain children are always rendered. Use onChange to monitor state.</h2>\r\n </InView>\r\n );\r\n\n export default Component;\r\n ```\r\n */\n\n\nvar InView = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(InView, _React$Component);\n\n  function InView(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this;\n    _this.node = null;\n    _this._unobserveCb = null;\n\n    _this.handleNode = function (node) {\n      if (_this.node) {\n        // Clear the old observer, before we start observing a new element\n        _this.unobserve();\n\n        if (!node && !_this.props.triggerOnce && !_this.props.skip) {\n          // Reset the state if we get a new node, and we aren't ignoring updates\n          _this.setState({\n            inView: !!_this.props.initialInView,\n            entry: undefined\n          });\n        }\n      }\n\n      _this.node = node ? node : null;\n\n      _this.observeNode();\n    };\n\n    _this.handleChange = function (inView, entry) {\n      if (inView && _this.props.triggerOnce) {\n        // If `triggerOnce` is true, we should stop observing the element.\n        _this.unobserve();\n      }\n\n      if (!isPlainChildren(_this.props)) {\n        // Store the current State, so we can pass it to the children in the next render update\n        // There's no reason to update the state for plain children, since it's not used in the rendering.\n        _this.setState({\n          inView: inView,\n          entry: entry\n        });\n      }\n\n      if (_this.props.onChange) {\n        // If the user is actively listening for onChange, always trigger it\n        _this.props.onChange(inView, entry);\n      }\n    };\n\n    _this.state = {\n      inView: !!props.initialInView,\n      entry: undefined\n    };\n    return _this;\n  }\n\n  var _proto = InView.prototype;\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    // If a IntersectionObserver option changed, reinit the observer\n    if (prevProps.rootMargin !== this.props.rootMargin || prevProps.root !== this.props.root || prevProps.threshold !== this.props.threshold || prevProps.skip !== this.props.skip || prevProps.trackVisibility !== this.props.trackVisibility || prevProps.delay !== this.props.delay) {\n      this.unobserve();\n      this.observeNode();\n    }\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.unobserve();\n    this.node = null;\n  };\n\n  _proto.observeNode = function observeNode() {\n    if (!this.node || this.props.skip) return;\n    var _this$props = this.props,\n        threshold = _this$props.threshold,\n        root = _this$props.root,\n        rootMargin = _this$props.rootMargin,\n        trackVisibility = _this$props.trackVisibility,\n        delay = _this$props.delay,\n        fallbackInView = _this$props.fallbackInView;\n    this._unobserveCb = observe(this.node, this.handleChange, {\n      threshold: threshold,\n      root: root,\n      rootMargin: rootMargin,\n      // @ts-ignore\n      trackVisibility: trackVisibility,\n      // @ts-ignore\n      delay: delay\n    }, fallbackInView);\n  };\n\n  _proto.unobserve = function unobserve() {\n    if (this._unobserveCb) {\n      this._unobserveCb();\n\n      this._unobserveCb = null;\n    }\n  };\n\n  _proto.render = function render() {\n    if (!isPlainChildren(this.props)) {\n      var _this$state = this.state,\n          inView = _this$state.inView,\n          entry = _this$state.entry;\n      return this.props.children({\n        inView: inView,\n        entry: entry,\n        ref: this.handleNode\n      });\n    }\n\n    var _this$props2 = this.props,\n        children = _this$props2.children,\n        as = _this$props2.as,\n        props = _objectWithoutPropertiesLoose(_this$props2, _excluded);\n\n    return /*#__PURE__*/React.createElement(as || 'div', _extends({\n      ref: this.handleNode\n    }, props), children);\n  };\n\n  return InView;\n}(React.Component);\nInView.displayName = 'InView';\nInView.defaultProps = {\n  threshold: 0,\n  triggerOnce: false,\n  initialInView: false\n};\n\n/**\r\n * React Hooks make it easy to monitor the `inView` state of your components. Call\r\n * the `useInView` hook with the (optional) [options](#options) you need. It will\r\n * return an array containing a `ref`, the `inView` status and the current\r\n * [`entry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry).\r\n * Assign the `ref` to the DOM element you want to monitor, and the hook will\r\n * report the status.\r\n *\r\n * @example\r\n * ```jsx\r\n * import React from 'react';\r\n * import { useInView } from 'react-intersection-observer';\r\n *\r\n * const Component = () => {\r\n *   const { ref, inView, entry } = useInView({\r\n *       threshold: 0,\r\n *   });\r\n *\r\n *   return (\r\n *     <div ref={ref}>\r\n *       <h2>{`Header inside viewport ${inView}.`}</h2>\r\n *     </div>\r\n *   );\r\n * };\r\n * ```\r\n */\n\nfunction useInView(_temp) {\n  var _ref = _temp === void 0 ? {} : _temp,\n      threshold = _ref.threshold,\n      delay = _ref.delay,\n      trackVisibility = _ref.trackVisibility,\n      rootMargin = _ref.rootMargin,\n      root = _ref.root,\n      triggerOnce = _ref.triggerOnce,\n      skip = _ref.skip,\n      initialInView = _ref.initialInView,\n      fallbackInView = _ref.fallbackInView;\n\n  var unobserve = React.useRef();\n\n  var _React$useState = React.useState({\n    inView: !!initialInView\n  }),\n      state = _React$useState[0],\n      setState = _React$useState[1];\n\n  var setRef = React.useCallback(function (node) {\n    if (unobserve.current !== undefined) {\n      unobserve.current();\n      unobserve.current = undefined;\n    } // Skip creating the observer\n\n\n    if (skip) return;\n\n    if (node) {\n      unobserve.current = observe(node, function (inView, entry) {\n        setState({\n          inView: inView,\n          entry: entry\n        });\n\n        if (entry.isIntersecting && triggerOnce && unobserve.current) {\n          // If it should only trigger once, unobserve the element after it's inView\n          unobserve.current();\n          unobserve.current = undefined;\n        }\n      }, {\n        root: root,\n        rootMargin: rootMargin,\n        threshold: threshold,\n        // @ts-ignore\n        trackVisibility: trackVisibility,\n        // @ts-ignore\n        delay: delay\n      }, fallbackInView);\n    }\n  }, // We break the rule here, because we aren't including the actual `threshold` variable\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [// If the threshold is an array, convert it to a string so it won't change between renders.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  Array.isArray(threshold) ? threshold.toString() : threshold, root, rootMargin, triggerOnce, skip, trackVisibility, fallbackInView, delay]);\n  /* eslint-disable-next-line */\n\n  useEffect(function () {\n    if (!unobserve.current && state.entry && !triggerOnce && !skip) {\n      // If we don't have a ref, then reset the state (unless the hook is set to only `triggerOnce` or `skip`)\n      // This ensures we correctly reflect the current state - If you aren't observing anything, then nothing is inView\n      setState({\n        inView: !!initialInView\n      });\n    }\n  });\n  var result = [setRef, state.inView, state.entry]; // Support object destructuring, by adding the specific values.\n\n  result.ref = result[0];\n  result.inView = result[1];\n  result.entry = result[2];\n  return result;\n}\n\nexport { InView, InView as default, defaultFallbackInView, observe, useInView };\n//# sourceMappingURL=react-intersection-observer.m.js.map\n"],"names":["_extends","Object","assign","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","_excluded","VisuallyHidden","forwardRef","_ref","ref","_ref$as","as","Comp","_ref$style","style","props","excluded","sourceKeys","keys","indexOf","_objectWithoutPropertiesLoose","createElement","border","clip","height","margin","overflow","padding","position","width","whiteSpace","wordWrap","getOwnerDocument","element","window","document","ownerDocument","_arrayLikeToArray","arr","len","arr2","Array","_createForOfIteratorHelperLoose","o","allowArrayLike","it","Symbol","iterator","isArray","minLen","n","toString","slice","constructor","name","from","test","_unsupportedIterableToArray","done","value","TypeError","next","bind","assignRef","isFunction","current","error","Error","renderTimer","polite","assertive","liveRegions","Alert","forwardedRef","children","_ref$type","type","regionType","ownRef","useRef","_len","refs","_key","useCallback","node","_step","_iterator","useComposedRefs","child","useMemo","prevType","useEffect","usePrevious","mirror","mounted","unmount","createMirror","mount","update","useMirrorEffects","doc","renderAlerts","setAttribute","body","appendChild","clearTimeout","setTimeout","forEach","elementType","render","role","map","cloneElement","serverHandoffComplete","id","genId","useId","idFromProps","initialId","_useState","useState","setId","String","undefined","createDescendantContext","initialValue","descendants","registerDescendant","unregisterDescendant","useDescendant","descendant","context","indexProp","forceUpdate","_useContext","useContext","index","findIndex","item","previousDescendants","someDescendantsHaveChanged","some","_previousDescendants$","concat","values","useDescendantsInit","useDescendants","ctx","DescendantProvider","Ctx","items","set","_ref2","explicitIndex","rest","newItems","find","Boolean","compareDocumentPosition","Node","DOCUMENT_POSITION_PRECEDING","newItem","filter","Provider","useDescendantKeyDown","options","callback","currentIndex","_options$key","_options$orientation","orientation","_options$rotate","rotate","_options$rtl","rtl","event","includes","selectableDescendants","preventDefault","getNextOption","prev","getPreviousOption","nextOrPrev","prevOrNext","prevOrFirst","ctrlKey","getFirstOption","first","nextOrLast","getLastOption","last","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","module","exports","shim","propName","componentName","location","propFullName","secret","err","getShim","isRequired","ReactPropTypes","array","bigint","bool","func","number","object","string","symbol","any","arrayOf","instanceOf","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","TabsKeyboardActivation","TabsOrientation","TabsDescendantsContext","TabPanelDescendantsContext","TabsContext","Tabs","_props$id","defaultIndex","_ref$orientation","Horizontal","_ref$index","controlledIndex","_ref$keyboardActivati","keyboardActivation","Auto","onChange","_ref$readOnly","readOnly","isControlled","_id","userInteractedRef","selectedPanelRef","isRTL","_useControlledState","selectedIndex","setSelectedIndex","focusedIndex","setFocusedIndex","_useDescendantsInit","tabs","setTabs","onFocusPanel","_selectedPanelRef$cur","focus","onSelectTab","onSelectTabWithKeyboard","_tabs$index$element","Manual","TabListImpl","_ref2$as","onKeyDown","dir","handleKeyDown","tab","disabled","_tabs$selectedIndex","Children","isSelected","TabList","Tab","_ref3","_ref3$as","onFocus","onBlur","_useContext2","tabsId","htmlType","handleFocus","handleBlur","tabIndex","onClick","TabPanelsImpl","_ref4","_ref4$as","_useDescendantsInit2","tabPanels","setTabPanels","TabPanels","TabPanel","_ref5","_ref5$as","_useContext3","readyToHide","hidden","SvgLogosFacebookSmall","React","color","size","title","titleId","fill","viewBox","xmlns","d","defaultProps","propTypes","SvgLogosFacebookXsmall","useSafeDispatch","dispatch","mountedRef","useSafeState","initialState","state","setState","args","FOCUS_GROUP","FOCUS_DISABLED","useMergeRefs","defaultValue","newValue","facade","hiddenGuard","top","left","InFocusGuard","ItoI","a","innerCreateMedium","defaults","middleware","buffer","assigned","read","useMedium","data","push","x","assignSyncMedium","cb","cbs","assignMedium","pendingQueue","executeQueue","cycle","Promise","resolve","then","createMedium","createSidecarMedium","medium","async","ssr","mediumFocus","currentTarget","mediumBlur","mediumEffect","mediumSidecar","emptyArray","FocusLock","parentRef","_extends2","_React$useState","realObserved","setObserved","observed","isActive","originalFocusedElement","noFocusGuards","persistentFocus","crossFrame","autoFocus","group","allowTextSelection","className","whiteList","hasPositiveIndices","_props$shards","shards","_props$as","Container","_props$lockProps","lockProps","containerProps","SideCar","sideCar","shouldReturnFocus","returnFocus","focusOptions","onActivationCallback","onActivation","onDeactivationCallback","onDeactivation","activeElement","allowDefer","returnFocusTo","howToReturnFocus","returnFocusOptions","setObserveNode","newObserved","hasLeadingGuards","hasTailingGuards","mergedRef","reducePropsToState","handleStateChangeOnClient","WrappedComponent","mountedInstances","emitChange","instance","SideEffect","_PureComponent","peek","_proto","componentDidMount","componentDidUpdate","componentWillUnmount","splice","PureComponent","displayName","getDisplayName","getParentNode","parentNode","nodeType","DOCUMENT_FRAGMENT_NODE","host","isTopNode","DOCUMENT_NODE","isVisibleUncached","checkParent","ELEMENT_NODE","computedStyle","getComputedStyle","getPropertyValue","isElementHidden","isVisibleCached","visibilityCache","cached","get","result","isAutoFocusAllowedCached","cache","isAutoFocusAllowed","isAutoFocusAllowedUncached","getDataset","dataset","isHTMLInputElement","tagName","isRadioElement","attribute","getAttribute","isGuard","_a","focusGuard","isNotAGuard","isDefined","correctNode","nodes","el","checked","findSelectedRadio","pickFirstFocus","pickFocusable","NEW_FOCUS","newFocus","innerNodes","outerNodes","lastNode","cnt","firstFocus","lastFocus","isOnGuard","resultSet","activeIndex","lastIndex","lastNodeInside","indexDiff","firstNodeIndex","lastNodeIndex","correctedNodes","Set","add","has","correctedIndexDiff","returnFirstNode","returnLastNode","Math","abs","toArray","ret","asArray","tabSort","b","tabDiff","orderByTabIndex","filterNegative","keepGuards","sort","queryTabbables","join","queryGuardTabbables","getFocusablesWithShadowDom","parent","withGuards","shadowRoot","reduce","acc","matches","getFocusables","parents","querySelectorAll","filterFocusable","isHTMLButtonElement","notHiddenInput","filterAutoFocusable","Map","getTabbableNodes","topNodes","getAllTabbableNodes","parentAutofocusables","topNode","parentFocus","contains","scope","getPrototypeOf","getTopParent","getAllAffectedNodes","currentNode","contained","l","j","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","_","filterNested","getNestedShadowActiveElement","getActiveElement","getParents","getCommonParent","nodeA","nodeB","parentsA","parentsB","currentParent","getTopCommonParent","baseActiveElement","leftEntry","rightEntries","activeElements","leftEntries","topCommon","entry","subEntry","common","getFocusMerge","entries","commonParent","anyFocusable","innerElements","srcNodes","dstNodes","remap","autoFocusables","orderedInnerElements","entity","newId","autoFocusable","allParentAutofocusables","autofocus","guardCount","lockDisabled","focusable","console","contentWindow","focusInsideIframe","focusInside","getFocusabledIn","lockItem","guard","deferAction","action","setImmediate","isFreeFocus","lastActiveTrap","lastActiveFocus","lastPortaledElement","focusWasOutsideWindow","defaultWhitelist","autoGuard","startIndex","end","step","allNodes","lastGuard","focusAutoGuard","extractRef","checkInHost","check","boundary","activateTrap","_lastActiveTrap","workingNode","portaledElement","workingArea","focusWhitelisted","area","withinHost","blur","newActiveElement","removeAttribute","onTrap","stopPropagation","observerNode","onWindowBlur","moveFocusInside","propsList","traps","trap","addEventListener","lastTrap","sameTrap","_ref6","removeEventListener","FocusLockCombination","zeroRightClassName","fullWidthClassName","effectCar","nothing","RemoveScroll","onScrollCapture","onWheelCapture","onTouchMoveCapture","callbacks","setCallbacks","forwardProps","removeScrollBar","enabled","noIsolation","inert","allowPinchZoom","_b","containerRef","lockRef","classNames","fullWidth","zeroRight","currentNonce","Target","isSideCarExport","makeStyleTag","tag","nonce","stylesheetSingleton","counter","stylesheet","css","styleSheet","cssText","createTextNode","head","getElementsByTagName","insertStyleTag","remove","removeChild","styleSingleton","sheet","useStyle","styles","isDynamic","dynamic","zeroGap","right","gap","parse","parseInt","getGapWidth","gapMode","offsets","cs","getOffset","documentWidth","documentElement","clientWidth","windowWidth","innerWidth","max","Style","getStyles","allowRelative","important","RemoveScrollBar","noRelative","noImportant","passiveSupported","defineProperty","nonPassive","passive","elementCanBeScrolled","overflowY","overflowX","alwaysContainsScroll","locationCouldBeScrolled","axis","ShadowRoot","elementCouldBeScrolled","getScrollVariables","elementCouldBeVScrolled","elementCouldBeHScrolled","scrollTop","scrollHeight","clientHeight","scrollLeft","scrollWidth","getHScrollVariables","getTouchXY","changedTouches","clientX","clientY","getDeltaXY","deltaX","deltaY","generateStyle","idCounter","lockStack","exported","shouldPreventQueue","touchStartRef","activeAxis","lastProps","classList","allow_1","shouldCancelEvent","touches","currentAxis","touch","touchStart","moveDirection","canBeScrolledInMainDirection","cancelingAxis","endTarget","sourceDelta","noOverscroll","directionFactor","direction","getDirectionFactor","delta","targetInLock","shouldCancelScroll","isDeltaPositive","availableScroll","availableScrollTop","elementScroll","handleScroll","shouldPrevent","_event","sourceEvent","e","y","should","cancelable","shardNodes","shouldCancel","scrollTouchStart","scrollWheel","scrollTouchMove","inst","ReactRemoveScroll","DialogOverlay","_ref$isOpen","isOpen","__REACH_DISABLE_TOOLTIPS","requestAnimationFrame","DialogInner","_ref2$dangerouslyBypa","dangerouslyBypassFocusLock","_ref2$dangerouslyBypa2","dangerouslyBypassScrollLock","initialFocusRef","_ref2$onDismiss","onDismiss","onMouseDown","_ref2$unstable_lockFo","unstable_lockFocusAcrossFrames","mouseDownTarget","overlayNode","activateFocusLock","dialogNode","originalValues","rootNodes","_dialogNode$parentNod","_dialogNode$parentNod2","attr","originalValue","createAriaHider","DialogContent","ModalOverlay","otherProps","ModalContent","ModalTitle","ModalActions","ModalHeroImage","src","alt","ModalBody","ModalCloseButton","Button","variant","ActionsCancelNormalXsmall","colors","Modal","hasClose","ModalTabs","ModalTabList","ModalTab","ModalTabPanels","ModalTabPanel","ModalWithTabs","logo","tabSelected","tester","email","parts","split","part","StatusCodes","collection","iteratee","isArrayLike","comparer","other","valIsDefined","valIsNull","valIsReflexive","valIsSymbol","isSymbol","othIsDefined","othIsNull","othIsReflexive","othIsSymbol","orders","objCriteria","criteria","othCriteria","ordersLength","iteratees","identity","camelCase","word","toLowerCase","resIndex","reUnescapedHtml","reHasUnescapedHtml","RegExp","replace","findIndexFunc","predicate","fromIndex","iterable","nativeMax","toInteger","path","indexes","previous","isObjectLike","rsAstral","rsCombo","rsFitz","rsNonAstral","rsRegional","rsSurrPair","reOptMod","rsOptVar","rsSeq","rsSymbol","reUnicode","sortBy","strSymbols","chrSymbols","reTrim","chars","start","comparator","isCommon","seen","outer","computed","seenIndex","_setPrototypeOf","p","setPrototypeOf","__proto__","observerMap","RootIds","WeakMap","rootId","unsupportedValue","optionsToId","root","observe","fallbackInView","IntersectionObserver","bounds","getBoundingClientRect","isIntersecting","intersectionRatio","threshold","time","boundingClientRect","intersectionRect","rootBounds","_createObserver","thresholds","elements","observer","_elements$get","inView","trackVisibility","isVisible","createObserver","unobserve","disconnect","isPlainChildren","InView","_React$Component","subClass","superClass","_this","_unobserveCb","handleNode","triggerOnce","skip","initialInView","observeNode","handleChange","create","prevProps","rootMargin","delay","_this$props","_this$state","_this$props2","useInView","_temp","setRef"],"sourceRoot":""}