{"version":3,"file":"5c5b310f185a997e0da452c22fd5fa58105acf86-6ca47b30a6404f94665e.js","mappings":"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","sources":["webpack://events-page-builder/./node_modules/@restart/hooks/esm/useCallbackRef.js","webpack://events-page-builder/./node_modules/@restart/hooks/esm/useCommittedRef.js","webpack://events-page-builder/./node_modules/@restart/hooks/esm/useEventCallback.js","webpack://events-page-builder/./node_modules/@restart/hooks/esm/useIsomorphicEffect.js","webpack://events-page-builder/./node_modules/@restart/hooks/esm/useMergedRefs.js","webpack://events-page-builder/./node_modules/@restart/hooks/esm/useMounted.js","webpack://events-page-builder/./node_modules/@restart/hooks/esm/usePrevious.js","webpack://events-page-builder/./node_modules/@restart/hooks/esm/useWillUnmount.js","webpack://events-page-builder/./node_modules/@restart/hooks/esm/useUpdatedRef.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/DataKey.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/useRTGTransitionProps.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/RTGTransition.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/ImperativeTransition.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/activeElement.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/Modal.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/ModalManager.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/getScrollbarWidth.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/NoopTransition.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/useWaitForDOMRef.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/useWindow.js","webpack://events-page-builder/./node_modules/@restart/ui/esm/utils.js","webpack://events-page-builder/./node_modules/classnames/index.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/AbstractModalHeader.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/removeClass.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/BootstrapModalManager.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/addClass.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/CloseButton.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/Fade.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/ModalContext.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/ThemeProvider.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/TransitionWrapper.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/divWithClassName.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/safeFindDOMNode.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/transitionEndListener.js","webpack://events-page-builder/./node_modules/react-bootstrap/esm/triggerBrowserReflow.js","webpack://events-page-builder/./node_modules/react-transition-group/esm/config.js","webpack://events-page-builder/./node_modules/react-transition-group/esm/TransitionGroupContext.js","webpack://events-page-builder/./node_modules/react-transition-group/esm/Transition.js","webpack://events-page-builder/./node_modules/react-transition-group/esm/utils/reflow.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/addEventListener.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/canUseDOM.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/contains.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/getComputedStyle.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/ownerWindow.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/hyphenate.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/hyphenateStyle.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/isTransform.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/css.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/hasClass.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/listen.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/ownerDocument.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/querySelectorAll.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/removeEventListener.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/transitionEnd.js","webpack://events-page-builder/./node_modules/dom-helpers/esm/triggerEvent.js"],"sourcesContent":["import { useState } from 'react';\n\n/**\n * A convenience hook around `useState` designed to be paired with\n * the component [callback ref](https://reactjs.org/docs/refs-and-the-dom.html#callback-refs) api.\n * Callback refs are useful over `useRef()` when you need to respond to the ref being set\n * instead of lazily accessing it in an effect.\n *\n * ```ts\n * const [element, attachRef] = useCallbackRef<HTMLDivElement>()\n *\n * useEffect(() => {\n *   if (!element) return\n *\n *   const calendar = new FullCalendar.Calendar(element)\n *\n *   return () => {\n *     calendar.destroy()\n *   }\n * }, [element])\n *\n * return <div ref={attachRef} />\n * ```\n *\n * @category refs\n */\nexport default function useCallbackRef() {\n  return useState(null);\n}","import { useEffect, useRef } from 'react';\n\n/**\n * Creates a `Ref` whose value is updated in an effect, ensuring the most recent\n * value is the one rendered with. Generally only required for Concurrent mode usage\n * where previous work in `render()` may be discarded before being used.\n *\n * This is safe to access in an event handler.\n *\n * @param value The `Ref` value\n */\nfunction useCommittedRef(value) {\n  const ref = useRef(value);\n  useEffect(() => {\n    ref.current = value;\n  }, [value]);\n  return ref;\n}\nexport default useCommittedRef;","import { useCallback } from 'react';\nimport useCommittedRef from './useCommittedRef';\nexport default function useEventCallback(fn) {\n  const ref = useCommittedRef(fn);\n  return useCallback(function () {\n    return ref.current && ref.current(...arguments);\n  }, [ref]);\n}","import { useEffect, useLayoutEffect } from 'react';\nconst isReactNative = typeof global !== 'undefined' &&\n// @ts-ignore\nglobal.navigator &&\n// @ts-ignore\nglobal.navigator.product === 'ReactNative';\nconst isDOM = typeof document !== 'undefined';\n\n/**\n * Is `useLayoutEffect` in a DOM or React Native environment, otherwise resolves to useEffect\n * Only useful to avoid the console warning.\n *\n * PREFER `useEffect` UNLESS YOU KNOW WHAT YOU ARE DOING.\n *\n * @category effects\n */\nexport default isDOM || isReactNative ? useLayoutEffect : useEffect;","import { useMemo } from 'react';\nconst toFnRef = ref => !ref || typeof ref === 'function' ? ref : value => {\n  ref.current = value;\n};\nexport function mergeRefs(refA, refB) {\n  const a = toFnRef(refA);\n  const b = toFnRef(refB);\n  return value => {\n    if (a) a(value);\n    if (b) b(value);\n  };\n}\n\n/**\n * Create and returns a single callback ref composed from two other Refs.\n *\n * ```tsx\n * const Button = React.forwardRef((props, ref) => {\n *   const [element, attachRef] = useCallbackRef<HTMLButtonElement>();\n *   const mergedRef = useMergedRefs(ref, attachRef);\n *\n *   return <button ref={mergedRef} {...props}/>\n * })\n * ```\n *\n * @param refA A Callback or mutable Ref\n * @param refB A Callback or mutable Ref\n * @category refs\n */\nfunction useMergedRefs(refA, refB) {\n  return useMemo(() => mergeRefs(refA, refB), [refA, refB]);\n}\nexport default useMergedRefs;","import { useRef, useEffect } from 'react';\n\n/**\n * Track whether a component is current mounted. Generally less preferable than\n * properlly canceling effects so they don't run after a component is unmounted,\n * but helpful in cases where that isn't feasible, such as a `Promise` resolution.\n *\n * @returns a function that returns the current isMounted state of the component\n *\n * ```ts\n * const [data, setData] = useState(null)\n * const isMounted = useMounted()\n *\n * useEffect(() => {\n *   fetchdata().then((newData) => {\n *      if (isMounted()) {\n *        setData(newData);\n *      }\n *   })\n * })\n * ```\n */\nexport default function useMounted() {\n  const mounted = useRef(true);\n  const isMounted = useRef(() => mounted.current);\n  useEffect(() => {\n    mounted.current = true;\n    return () => {\n      mounted.current = false;\n    };\n  }, []);\n  return isMounted.current;\n}","import { useEffect, useRef } from 'react';\n\n/**\n * Store the last of some value. Tracked via a `Ref` only updating it\n * after the component renders.\n *\n * Helpful if you need to compare a prop value to it's previous value during render.\n *\n * ```ts\n * function Component(props) {\n *   const lastProps = usePrevious(props)\n *\n *   if (lastProps.foo !== props.foo)\n *     resetValueFromProps(props.foo)\n * }\n * ```\n *\n * @param value the value to track\n */\nexport default function usePrevious(value) {\n  const ref = useRef(null);\n  useEffect(() => {\n    ref.current = value;\n  });\n  return ref.current;\n}","import useUpdatedRef from './useUpdatedRef';\nimport { useEffect } from 'react';\n\n/**\n * Attach a callback that fires when a component unmounts\n *\n * @param fn Handler to run when the component unmounts\n * @category effects\n */\nexport default function useWillUnmount(fn) {\n  const onUnmount = useUpdatedRef(fn);\n  useEffect(() => () => onUnmount.current(), []);\n}","import { useRef } from 'react';\n\n/**\n * Returns a ref that is immediately updated with the new value\n *\n * @param value The Ref value\n * @category refs\n */\nexport default function useUpdatedRef(value) {\n  const valueRef = useRef(value);\n  valueRef.current = value;\n  return valueRef;\n}","export const ATTRIBUTE_PREFIX = \"data-rr-ui-\";\nexport const PROPERTY_PREFIX = \"rrUi\";\nexport function dataAttr(property) {\n  return \"\".concat(ATTRIBUTE_PREFIX).concat(property);\n}\nexport function dataProp(property) {\n  return \"\".concat(PROPERTY_PREFIX).concat(property);\n}","const _excluded = [\"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"addEndListener\", \"children\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\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  return target;\n}\nimport { cloneElement, useCallback, useRef } from 'react';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\n/**\n * Normalizes RTG transition callbacks with nodeRef to better support\n * strict mode.\n *\n * @param props Transition props.\n * @returns Normalized transition props.\n */\nexport default function useRTGTransitionProps(_ref) {\n  let {\n      onEnter,\n      onEntering,\n      onEntered,\n      onExit,\n      onExiting,\n      onExited,\n      addEndListener,\n      children\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const nodeRef = useRef(null);\n  const mergedRef = useMergedRefs(nodeRef, typeof children === 'function' ? null : children.ref);\n  const normalize = callback => param => {\n    if (callback && nodeRef.current) {\n      callback(nodeRef.current, param);\n    }\n  };\n\n  /* eslint-disable react-hooks/exhaustive-deps */\n  const handleEnter = useCallback(normalize(onEnter), [onEnter]);\n  const handleEntering = useCallback(normalize(onEntering), [onEntering]);\n  const handleEntered = useCallback(normalize(onEntered), [onEntered]);\n  const handleExit = useCallback(normalize(onExit), [onExit]);\n  const handleExiting = useCallback(normalize(onExiting), [onExiting]);\n  const handleExited = useCallback(normalize(onExited), [onExited]);\n  const handleAddEndListener = useCallback(normalize(addEndListener), [addEndListener]);\n  /* eslint-enable react-hooks/exhaustive-deps */\n\n  return Object.assign({}, props, {\n    nodeRef\n  }, onEnter && {\n    onEnter: handleEnter\n  }, onEntering && {\n    onEntering: handleEntering\n  }, onEntered && {\n    onEntered: handleEntered\n  }, onExit && {\n    onExit: handleExit\n  }, onExiting && {\n    onExiting: handleExiting\n  }, onExited && {\n    onExited: handleExited\n  }, addEndListener && {\n    addEndListener: handleAddEndListener\n  }, {\n    children: typeof children === 'function' ? (status, innerProps) =>\n    // TODO: Types for RTG missing innerProps, so need to cast.\n    children(status, Object.assign({}, innerProps, {\n      ref: mergedRef\n    })) : /*#__PURE__*/cloneElement(children, {\n      ref: mergedRef\n    })\n  });\n}","const _excluded = [\"component\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\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  return target;\n}\nimport * as React from 'react';\nimport useRTGTransitionProps from './useRTGTransitionProps';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n// Normalizes Transition callbacks when nodeRef is used.\nconst RTGTransition = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n      component: Component\n    } = _ref,\n    props = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const transitionProps = useRTGTransitionProps(props);\n  return /*#__PURE__*/_jsx(Component, Object.assign({\n    ref: ref\n  }, transitionProps));\n});\nexport default RTGTransition;","import useMergedRefs from '@restart/hooks/useMergedRefs';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport useIsomorphicEffect from '@restart/hooks/useIsomorphicEffect';\nimport React, { useRef, cloneElement, useState } from 'react';\nimport NoopTransition from './NoopTransition';\nimport RTGTransition from './RTGTransition';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport function useTransition(_ref) {\n  let {\n    in: inProp,\n    onTransition\n  } = _ref;\n  const ref = useRef(null);\n  const isInitialRef = useRef(true);\n  const handleTransition = useEventCallback(onTransition);\n  useIsomorphicEffect(() => {\n    if (!ref.current) {\n      return undefined;\n    }\n    let stale = false;\n    handleTransition({\n      in: inProp,\n      element: ref.current,\n      initial: isInitialRef.current,\n      isStale: () => stale\n    });\n    return () => {\n      stale = true;\n    };\n  }, [inProp, handleTransition]);\n  useIsomorphicEffect(() => {\n    isInitialRef.current = false;\n    // this is for strict mode\n    return () => {\n      isInitialRef.current = true;\n    };\n  }, []);\n  return ref;\n}\n/**\n * Adapts an imperative transition function to a subset of the RTG `<Transition>` component API.\n *\n * ImperativeTransition does not support mounting options or `appear` at the moment, meaning\n * that it always acts like: `mountOnEnter={true} unmountOnExit={true} appear={true}`\n */\nexport default function ImperativeTransition(_ref2) {\n  let {\n    children,\n    in: inProp,\n    onExited,\n    onEntered,\n    transition\n  } = _ref2;\n  const [exited, setExited] = useState(!inProp);\n\n  // TODO: I think this needs to be in an effect\n  if (inProp && exited) {\n    setExited(false);\n  }\n  const ref = useTransition({\n    in: !!inProp,\n    onTransition: options => {\n      const onFinish = () => {\n        if (options.isStale()) return;\n        if (options.in) {\n          onEntered == null ? void 0 : onEntered(options.element, options.initial);\n        } else {\n          setExited(true);\n          onExited == null ? void 0 : onExited(options.element);\n        }\n      };\n      Promise.resolve(transition(options)).then(onFinish, error => {\n        if (!options.in) setExited(true);\n        throw error;\n      });\n    }\n  });\n  const combinedRef = useMergedRefs(ref, children.ref);\n  return exited && !inProp ? null : /*#__PURE__*/cloneElement(children, {\n    ref: combinedRef\n  });\n}\nexport function renderTransition(component, runTransition, props) {\n  if (component) {\n    return /*#__PURE__*/_jsx(RTGTransition, Object.assign({}, props, {\n      component: component\n    }));\n  }\n  if (runTransition) {\n    return /*#__PURE__*/_jsx(ImperativeTransition, Object.assign({}, props, {\n      transition: runTransition\n    }));\n  }\n  return /*#__PURE__*/_jsx(NoopTransition, Object.assign({}, props));\n}","import ownerDocument from './ownerDocument';\n/**\n * Returns the actively focused element safely.\n *\n * @param doc the document to check\n */\n\nexport default function activeElement(doc) {\n  if (doc === void 0) {\n    doc = ownerDocument();\n  }\n\n  // Support: IE 9 only\n  // IE9 throws an \"Unspecified error\" accessing document.activeElement from an <iframe>\n  try {\n    var active = doc.activeElement; // IE11 returns a seemingly empty object in some cases when accessing\n    // document.activeElement from an <iframe>\n\n    if (!active || !active.nodeName) return null;\n    return active;\n  } catch (e) {\n    /* ie throws if no active element */\n    return doc.body;\n  }\n}","const _excluded = [\"show\", \"role\", \"className\", \"style\", \"children\", \"backdrop\", \"keyboard\", \"onBackdropClick\", \"onEscapeKeyDown\", \"transition\", \"runTransition\", \"backdropTransition\", \"runBackdropTransition\", \"autoFocus\", \"enforceFocus\", \"restoreFocus\", \"restoreFocusOptions\", \"renderDialog\", \"renderBackdrop\", \"manager\", \"container\", \"onShow\", \"onHide\", \"onExit\", \"onExited\", \"onExiting\", \"onEnter\", \"onEntering\", \"onEntered\"];\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\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  return target;\n}\n/* eslint-disable @typescript-eslint/no-use-before-define, react/prop-types */\n\nimport activeElement from 'dom-helpers/activeElement';\nimport contains from 'dom-helpers/contains';\nimport canUseDOM from 'dom-helpers/canUseDOM';\nimport listen from 'dom-helpers/listen';\nimport { useState, useRef, useCallback, useImperativeHandle, forwardRef, useEffect } from 'react';\nimport * as React from 'react';\nimport ReactDOM from 'react-dom';\nimport useMounted from '@restart/hooks/useMounted';\nimport useWillUnmount from '@restart/hooks/useWillUnmount';\nimport usePrevious from '@restart/hooks/usePrevious';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport ModalManager from './ModalManager';\nimport useWaitForDOMRef from './useWaitForDOMRef';\nimport useWindow from './useWindow';\nimport { renderTransition } from './ImperativeTransition';\nimport { isEscKey } from './utils';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { Fragment as _Fragment } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nlet manager;\nfunction getManager(window) {\n  if (!manager) manager = new ModalManager({\n    ownerDocument: window == null ? void 0 : window.document\n  });\n  return manager;\n}\nfunction useModalManager(provided) {\n  const window = useWindow();\n  const modalManager = provided || getManager(window);\n  const modal = useRef({\n    dialog: null,\n    backdrop: null\n  });\n  return Object.assign(modal.current, {\n    add: () => modalManager.add(modal.current),\n    remove: () => modalManager.remove(modal.current),\n    isTopModal: () => modalManager.isTopModal(modal.current),\n    setDialogRef: useCallback(ref => {\n      modal.current.dialog = ref;\n    }, []),\n    setBackdropRef: useCallback(ref => {\n      modal.current.backdrop = ref;\n    }, [])\n  });\n}\nconst Modal = /*#__PURE__*/forwardRef((_ref, ref) => {\n  let {\n      show = false,\n      role = 'dialog',\n      className,\n      style,\n      children,\n      backdrop = true,\n      keyboard = true,\n      onBackdropClick,\n      onEscapeKeyDown,\n      transition,\n      runTransition,\n      backdropTransition,\n      runBackdropTransition,\n      autoFocus = true,\n      enforceFocus = true,\n      restoreFocus = true,\n      restoreFocusOptions,\n      renderDialog,\n      renderBackdrop = props => /*#__PURE__*/_jsx(\"div\", Object.assign({}, props)),\n      manager: providedManager,\n      container: containerRef,\n      onShow,\n      onHide = () => {},\n      onExit,\n      onExited,\n      onExiting,\n      onEnter,\n      onEntering,\n      onEntered\n    } = _ref,\n    rest = _objectWithoutPropertiesLoose(_ref, _excluded);\n  const ownerWindow = useWindow();\n  const container = useWaitForDOMRef(containerRef);\n  const modal = useModalManager(providedManager);\n  const isMounted = useMounted();\n  const prevShow = usePrevious(show);\n  const [exited, setExited] = useState(!show);\n  const lastFocusRef = useRef(null);\n  useImperativeHandle(ref, () => modal, [modal]);\n  if (canUseDOM && !prevShow && show) {\n    lastFocusRef.current = activeElement(ownerWindow == null ? void 0 : ownerWindow.document);\n  }\n\n  // TODO: I think this needs to be in an effect\n  if (show && exited) {\n    setExited(false);\n  }\n  const handleShow = useEventCallback(() => {\n    modal.add();\n    removeKeydownListenerRef.current = listen(document, 'keydown', handleDocumentKeyDown);\n    removeFocusListenerRef.current = listen(document, 'focus',\n    // the timeout is necessary b/c this will run before the new modal is mounted\n    // and so steals focus from it\n    () => setTimeout(handleEnforceFocus), true);\n    if (onShow) {\n      onShow();\n    }\n\n    // autofocus after onShow to not trigger a focus event for previous\n    // modals before this one is shown.\n    if (autoFocus) {\n      var _modal$dialog$ownerDo, _modal$dialog;\n      const currentActiveElement = activeElement((_modal$dialog$ownerDo = (_modal$dialog = modal.dialog) == null ? void 0 : _modal$dialog.ownerDocument) != null ? _modal$dialog$ownerDo : ownerWindow == null ? void 0 : ownerWindow.document);\n      if (modal.dialog && currentActiveElement && !contains(modal.dialog, currentActiveElement)) {\n        lastFocusRef.current = currentActiveElement;\n        modal.dialog.focus();\n      }\n    }\n  });\n  const handleHide = useEventCallback(() => {\n    modal.remove();\n    removeKeydownListenerRef.current == null ? void 0 : removeKeydownListenerRef.current();\n    removeFocusListenerRef.current == null ? void 0 : removeFocusListenerRef.current();\n    if (restoreFocus) {\n      var _lastFocusRef$current;\n      // Support: <=IE11 doesn't support `focus()` on svg elements (RB: #917)\n      (_lastFocusRef$current = lastFocusRef.current) == null ? void 0 : _lastFocusRef$current.focus == null ? void 0 : _lastFocusRef$current.focus(restoreFocusOptions);\n      lastFocusRef.current = null;\n    }\n  });\n\n  // TODO: try and combine these effects: https://github.com/react-bootstrap/react-overlays/pull/794#discussion_r409954120\n\n  // Show logic when:\n  //  - show is `true` _and_ `container` has resolved\n  useEffect(() => {\n    if (!show || !container) return;\n    handleShow();\n  }, [show, container, /* should never change: */handleShow]);\n\n  // Hide cleanup logic when:\n  //  - `exited` switches to true\n  //  - component unmounts;\n  useEffect(() => {\n    if (!exited) return;\n    handleHide();\n  }, [exited, handleHide]);\n  useWillUnmount(() => {\n    handleHide();\n  });\n\n  // --------------------------------\n\n  const handleEnforceFocus = useEventCallback(() => {\n    if (!enforceFocus || !isMounted() || !modal.isTopModal()) {\n      return;\n    }\n    const currentActiveElement = activeElement(ownerWindow == null ? void 0 : ownerWindow.document);\n    if (modal.dialog && currentActiveElement && !contains(modal.dialog, currentActiveElement)) {\n      modal.dialog.focus();\n    }\n  });\n  const handleBackdropClick = useEventCallback(e => {\n    if (e.target !== e.currentTarget) {\n      return;\n    }\n    onBackdropClick == null ? void 0 : onBackdropClick(e);\n    if (backdrop === true) {\n      onHide();\n    }\n  });\n  const handleDocumentKeyDown = useEventCallback(e => {\n    if (keyboard && isEscKey(e) && modal.isTopModal()) {\n      onEscapeKeyDown == null ? void 0 : onEscapeKeyDown(e);\n      if (!e.defaultPrevented) {\n        onHide();\n      }\n    }\n  });\n  const removeFocusListenerRef = useRef();\n  const removeKeydownListenerRef = useRef();\n  const handleHidden = function () {\n    setExited(true);\n    onExited == null ? void 0 : onExited(...arguments);\n  };\n  if (!container) {\n    return null;\n  }\n  const dialogProps = Object.assign({\n    role,\n    ref: modal.setDialogRef,\n    // apparently only works on the dialog role element\n    'aria-modal': role === 'dialog' ? true : undefined\n  }, rest, {\n    style,\n    className,\n    tabIndex: -1\n  });\n  let dialog = renderDialog ? renderDialog(dialogProps) : /*#__PURE__*/_jsx(\"div\", Object.assign({}, dialogProps, {\n    children: /*#__PURE__*/React.cloneElement(children, {\n      role: 'document'\n    })\n  }));\n  dialog = renderTransition(transition, runTransition, {\n    unmountOnExit: true,\n    mountOnEnter: true,\n    appear: true,\n    in: !!show,\n    onExit,\n    onExiting,\n    onExited: handleHidden,\n    onEnter,\n    onEntering,\n    onEntered,\n    children: dialog\n  });\n  let backdropElement = null;\n  if (backdrop) {\n    backdropElement = renderBackdrop({\n      ref: modal.setBackdropRef,\n      onClick: handleBackdropClick\n    });\n    backdropElement = renderTransition(backdropTransition, runBackdropTransition, {\n      in: !!show,\n      appear: true,\n      mountOnEnter: true,\n      unmountOnExit: true,\n      children: backdropElement\n    });\n  }\n  return /*#__PURE__*/_jsx(_Fragment, {\n    children: /*#__PURE__*/ReactDOM.createPortal( /*#__PURE__*/_jsxs(_Fragment, {\n      children: [backdropElement, dialog]\n    }), container)\n  });\n});\nModal.displayName = 'Modal';\nexport default Object.assign(Modal, {\n  Manager: ModalManager\n});","import css from 'dom-helpers/css';\nimport { dataAttr } from './DataKey';\nimport getBodyScrollbarWidth from './getScrollbarWidth';\nexport const OPEN_DATA_ATTRIBUTE = dataAttr('modal-open');\n\n/**\n * Manages a stack of Modals as well as ensuring\n * body scrolling is is disabled and padding accounted for\n */\nclass ModalManager {\n  constructor() {\n    let {\n      ownerDocument,\n      handleContainerOverflow = true,\n      isRTL = false\n    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    this.handleContainerOverflow = handleContainerOverflow;\n    this.isRTL = isRTL;\n    this.modals = [];\n    this.ownerDocument = ownerDocument;\n  }\n  getScrollbarWidth() {\n    return getBodyScrollbarWidth(this.ownerDocument);\n  }\n  getElement() {\n    return (this.ownerDocument || document).body;\n  }\n  setModalAttributes(_modal) {\n    // For overriding\n  }\n  removeModalAttributes(_modal) {\n    // For overriding\n  }\n  setContainerStyle(containerState) {\n    const style = {\n      overflow: 'hidden'\n    };\n\n    // we are only interested in the actual `style` here\n    // because we will override it\n    const paddingProp = this.isRTL ? 'paddingLeft' : 'paddingRight';\n    const container = this.getElement();\n    containerState.style = {\n      overflow: container.style.overflow,\n      [paddingProp]: container.style[paddingProp]\n    };\n    if (containerState.scrollBarWidth) {\n      // use computed style, here to get the real padding\n      // to add our scrollbar width\n      style[paddingProp] = \"\".concat(parseInt(css(container, paddingProp) || '0', 10) + containerState.scrollBarWidth, \"px\");\n    }\n    container.setAttribute(OPEN_DATA_ATTRIBUTE, '');\n    css(container, style);\n  }\n  reset() {\n    [...this.modals].forEach(m => this.remove(m));\n  }\n  removeContainerStyle(containerState) {\n    const container = this.getElement();\n    container.removeAttribute(OPEN_DATA_ATTRIBUTE);\n    Object.assign(container.style, containerState.style);\n  }\n  add(modal) {\n    let modalIdx = this.modals.indexOf(modal);\n    if (modalIdx !== -1) {\n      return modalIdx;\n    }\n    modalIdx = this.modals.length;\n    this.modals.push(modal);\n    this.setModalAttributes(modal);\n    if (modalIdx !== 0) {\n      return modalIdx;\n    }\n    this.state = {\n      scrollBarWidth: this.getScrollbarWidth(),\n      style: {}\n    };\n    if (this.handleContainerOverflow) {\n      this.setContainerStyle(this.state);\n    }\n    return modalIdx;\n  }\n  remove(modal) {\n    const modalIdx = this.modals.indexOf(modal);\n    if (modalIdx === -1) {\n      return;\n    }\n    this.modals.splice(modalIdx, 1);\n\n    // if that was the last modal in a container,\n    // clean up the container\n    if (!this.modals.length && this.handleContainerOverflow) {\n      this.removeContainerStyle(this.state);\n    }\n    this.removeModalAttributes(modal);\n  }\n  isTopModal(modal) {\n    return !!this.modals.length && this.modals[this.modals.length - 1] === modal;\n  }\n}\nexport default ModalManager;","/**\n * Get the width of the vertical window scrollbar if it's visible\n */\nexport default function getBodyScrollbarWidth() {\n  let ownerDocument = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;\n  const window = ownerDocument.defaultView;\n  return Math.abs(window.innerWidth - ownerDocument.documentElement.clientWidth);\n}","import useEventCallback from '@restart/hooks/useEventCallback';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\nimport { cloneElement, useEffect, useRef } from 'react';\nfunction NoopTransition(_ref) {\n  let {\n    children,\n    in: inProp,\n    onExited,\n    mountOnEnter,\n    unmountOnExit\n  } = _ref;\n  const ref = useRef(null);\n  const hasEnteredRef = useRef(inProp);\n  const handleExited = useEventCallback(onExited);\n  useEffect(() => {\n    if (inProp) hasEnteredRef.current = true;else {\n      handleExited(ref.current);\n    }\n  }, [inProp, handleExited]);\n  const combinedRef = useMergedRefs(ref, children.ref);\n  const child = /*#__PURE__*/cloneElement(children, {\n    ref: combinedRef\n  });\n  if (inProp) return child;\n  if (unmountOnExit) {\n    return null;\n  }\n  if (!hasEnteredRef.current && mountOnEnter) {\n    return null;\n  }\n  return child;\n}\nexport default NoopTransition;","import ownerDocument from 'dom-helpers/ownerDocument';\nimport canUseDOM from 'dom-helpers/canUseDOM';\nimport { useState, useEffect } from 'react';\nimport useWindow from './useWindow';\nexport const resolveContainerRef = (ref, document) => {\n  if (!canUseDOM) return null;\n  if (ref == null) return (document || ownerDocument()).body;\n  if (typeof ref === 'function') ref = ref();\n  if (ref && 'current' in ref) ref = ref.current;\n  if (ref && ('nodeType' in ref || ref.getBoundingClientRect)) return ref;\n  return null;\n};\nexport default function useWaitForDOMRef(ref, onResolved) {\n  const window = useWindow();\n  const [resolvedRef, setRef] = useState(() => resolveContainerRef(ref, window == null ? void 0 : window.document));\n  if (!resolvedRef) {\n    const earlyRef = resolveContainerRef(ref);\n    if (earlyRef) setRef(earlyRef);\n  }\n  useEffect(() => {\n    if (onResolved && resolvedRef) {\n      onResolved(resolvedRef);\n    }\n  }, [onResolved, resolvedRef]);\n  useEffect(() => {\n    const nextRef = resolveContainerRef(ref);\n    if (nextRef !== resolvedRef) {\n      setRef(nextRef);\n    }\n  }, [ref, resolvedRef]);\n  return resolvedRef;\n}","import { createContext, useContext } from 'react';\nimport canUseDOM from 'dom-helpers/canUseDOM';\nconst Context = /*#__PURE__*/createContext(canUseDOM ? window : undefined);\nexport const WindowProvider = Context.Provider;\n\n/**\n * The document \"window\" placed in React context. Helpful for determining\n * SSR context, or when rendering into an iframe.\n *\n * @returns the current window\n */\nexport default function useWindow() {\n  return useContext(Context);\n}","/* eslint-disable import/prefer-default-export */\nexport function isEscKey(e) {\n  return e.code === 'Escape' || e.keyCode === 27;\n}","/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n  'use strict';\n\n  var hasOwn = {}.hasOwnProperty;\n  function classNames() {\n    var classes = '';\n    for (var i = 0; i < arguments.length; i++) {\n      var arg = arguments[i];\n      if (arg) {\n        classes = appendClass(classes, parseValue(arg));\n      }\n    }\n    return classes;\n  }\n  function parseValue(arg) {\n    if (typeof arg === 'string' || typeof arg === 'number') {\n      return arg;\n    }\n    if (typeof arg !== 'object') {\n      return '';\n    }\n    if (Array.isArray(arg)) {\n      return classNames.apply(null, arg);\n    }\n    if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n      return arg.toString();\n    }\n    var classes = '';\n    for (var key in arg) {\n      if (hasOwn.call(arg, key) && arg[key]) {\n        classes = appendClass(classes, key);\n      }\n    }\n    return classes;\n  }\n  function appendClass(value, newClass) {\n    if (!newClass) {\n      return value;\n    }\n    if (value) {\n      return value + ' ' + newClass;\n    }\n    return value + newClass;\n  }\n  if (typeof module !== 'undefined' && module.exports) {\n    classNames.default = classNames;\n    module.exports = classNames;\n  } else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n    // register as 'classnames', consistent with npm package name\n    define('classnames', [], function () {\n      return classNames;\n    });\n  } else {\n    window.classNames = classNames;\n  }\n})();","\"use client\";\n\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport useEventCallback from '@restart/hooks/useEventCallback';\nimport CloseButton from './CloseButton';\nimport ModalContext from './ModalContext';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nimport { jsxs as _jsxs } from \"react/jsx-runtime\";\nconst AbstractModalHeader = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n    closeLabel = 'Close',\n    closeVariant,\n    closeButton = false,\n    onHide,\n    children,\n    ...props\n  } = _ref;\n  const context = useContext(ModalContext);\n  const handleClick = useEventCallback(() => {\n    context == null ? void 0 : context.onHide();\n    onHide == null ? void 0 : onHide();\n  });\n  return /*#__PURE__*/_jsxs(\"div\", {\n    ref: ref,\n    ...props,\n    children: [children, closeButton && /*#__PURE__*/_jsx(CloseButton, {\n      \"aria-label\": closeLabel,\n      variant: closeVariant,\n      onClick: handleClick\n    })]\n  });\n});\nexport default AbstractModalHeader;","function replaceClassName(origClass, classToRemove) {\n  return origClass.replace(new RegExp(\"(^|\\\\s)\" + classToRemove + \"(?:\\\\s|$)\", 'g'), '$1').replace(/\\s+/g, ' ').replace(/^\\s*|\\s*$/g, '');\n}\n/**\n * Removes a CSS class from a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\n\nexport default function removeClass(element, className) {\n  if (element.classList) {\n    element.classList.remove(className);\n  } else if (typeof element.className === 'string') {\n    element.className = replaceClassName(element.className, className);\n  } else {\n    element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));\n  }\n}","import addClass from 'dom-helpers/addClass';\nimport css from 'dom-helpers/css';\nimport qsa from 'dom-helpers/querySelectorAll';\nimport removeClass from 'dom-helpers/removeClass';\nimport ModalManager from '@restart/ui/ModalManager';\nconst Selector = {\n  FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top',\n  STICKY_CONTENT: '.sticky-top',\n  NAVBAR_TOGGLER: '.navbar-toggler'\n};\nclass BootstrapModalManager extends ModalManager {\n  adjustAndStore(prop, element, adjust) {\n    const actual = element.style[prop];\n    // TODO: DOMStringMap and CSSStyleDeclaration aren't strictly compatible\n    // @ts-ignore\n    element.dataset[prop] = actual;\n    css(element, {\n      [prop]: \"\".concat(parseFloat(css(element, prop)) + adjust, \"px\")\n    });\n  }\n  restore(prop, element) {\n    const value = element.dataset[prop];\n    if (value !== undefined) {\n      delete element.dataset[prop];\n      css(element, {\n        [prop]: value\n      });\n    }\n  }\n  setContainerStyle(containerState) {\n    super.setContainerStyle(containerState);\n    const container = this.getElement();\n    addClass(container, 'modal-open');\n    if (!containerState.scrollBarWidth) return;\n    const paddingProp = this.isRTL ? 'paddingLeft' : 'paddingRight';\n    const marginProp = this.isRTL ? 'marginLeft' : 'marginRight';\n    qsa(container, Selector.FIXED_CONTENT).forEach(el => this.adjustAndStore(paddingProp, el, containerState.scrollBarWidth));\n    qsa(container, Selector.STICKY_CONTENT).forEach(el => this.adjustAndStore(marginProp, el, -containerState.scrollBarWidth));\n    qsa(container, Selector.NAVBAR_TOGGLER).forEach(el => this.adjustAndStore(marginProp, el, containerState.scrollBarWidth));\n  }\n  removeContainerStyle(containerState) {\n    super.removeContainerStyle(containerState);\n    const container = this.getElement();\n    removeClass(container, 'modal-open');\n    const paddingProp = this.isRTL ? 'paddingLeft' : 'paddingRight';\n    const marginProp = this.isRTL ? 'marginLeft' : 'marginRight';\n    qsa(container, Selector.FIXED_CONTENT).forEach(el => this.restore(paddingProp, el));\n    qsa(container, Selector.STICKY_CONTENT).forEach(el => this.restore(marginProp, el));\n    qsa(container, Selector.NAVBAR_TOGGLER).forEach(el => this.restore(marginProp, el));\n  }\n}\nlet sharedManager;\nexport function getSharedManager(options) {\n  if (!sharedManager) sharedManager = new BootstrapModalManager(options);\n  return sharedManager;\n}\nexport default BootstrapModalManager;","import hasClass from './hasClass';\n/**\n * Adds a CSS class to a given element.\n * \n * @param element the element\n * @param className the CSS class name\n */\n\nexport default function addClass(element, className) {\n  if (element.classList) element.classList.add(className);else if (!hasClass(element, className)) if (typeof element.className === 'string') element.className = element.className + \" \" + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + \" \" + className);\n}","import PropTypes from 'prop-types';\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst propTypes = {\n  /** An accessible label indicating the relevant information about the Close Button. */\n  'aria-label': PropTypes.string,\n  /** A callback fired after the Close Button is clicked. */\n  onClick: PropTypes.func,\n  /**\n   * Render different color variant for the button.\n   *\n   * Omitting this will render the default dark color.\n   */\n  variant: PropTypes.oneOf(['white'])\n};\nconst CloseButton = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n    className,\n    variant,\n    'aria-label': ariaLabel = 'Close',\n    ...props\n  } = _ref;\n  return /*#__PURE__*/_jsx(\"button\", {\n    ref: ref,\n    type: \"button\",\n    className: classNames('btn-close', variant && \"btn-close-\".concat(variant), className),\n    \"aria-label\": ariaLabel,\n    ...props\n  });\n});\nCloseButton.displayName = 'CloseButton';\nCloseButton.propTypes = propTypes;\nexport default CloseButton;","import classNames from 'classnames';\nimport * as React from 'react';\nimport { useCallback } from 'react';\nimport { ENTERED, ENTERING } from 'react-transition-group/Transition';\nimport transitionEndListener from './transitionEndListener';\nimport triggerBrowserReflow from './triggerBrowserReflow';\nimport TransitionWrapper from './TransitionWrapper';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst fadeStyles = {\n  [ENTERING]: 'show',\n  [ENTERED]: 'show'\n};\nconst Fade = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n    className,\n    children,\n    transitionClasses = {},\n    onEnter,\n    ...rest\n  } = _ref;\n  const props = {\n    in: false,\n    timeout: 300,\n    mountOnEnter: false,\n    unmountOnExit: false,\n    appear: false,\n    ...rest\n  };\n  const handleEnter = useCallback((node, isAppearing) => {\n    triggerBrowserReflow(node);\n    onEnter == null ? void 0 : onEnter(node, isAppearing);\n  }, [onEnter]);\n  return /*#__PURE__*/_jsx(TransitionWrapper, {\n    ref: ref,\n    addEndListener: transitionEndListener,\n    ...props,\n    onEnter: handleEnter,\n    childRef: children.ref,\n    children: (status, innerProps) => /*#__PURE__*/React.cloneElement(children, {\n      ...innerProps,\n      className: classNames('fade', className, children.props.className, fadeStyles[status], transitionClasses[status])\n    })\n  });\n});\nFade.displayName = 'Fade';\nexport default Fade;","\"use client\";\n\nimport * as React from 'react';\nconst ModalContext = /*#__PURE__*/React.createContext({\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onHide() {}\n});\nexport default ModalContext;","\"use client\";\n\nimport * as React from 'react';\nimport { useContext, useMemo } from 'react';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport const DEFAULT_BREAKPOINTS = ['xxl', 'xl', 'lg', 'md', 'sm', 'xs'];\nexport const DEFAULT_MIN_BREAKPOINT = 'xs';\nconst ThemeContext = /*#__PURE__*/React.createContext({\n  prefixes: {},\n  breakpoints: DEFAULT_BREAKPOINTS,\n  minBreakpoint: DEFAULT_MIN_BREAKPOINT\n});\nconst {\n  Consumer,\n  Provider\n} = ThemeContext;\nfunction ThemeProvider(_ref) {\n  let {\n    prefixes = {},\n    breakpoints = DEFAULT_BREAKPOINTS,\n    minBreakpoint = DEFAULT_MIN_BREAKPOINT,\n    dir,\n    children\n  } = _ref;\n  const contextValue = useMemo(() => ({\n    prefixes: {\n      ...prefixes\n    },\n    breakpoints,\n    minBreakpoint,\n    dir\n  }), [prefixes, breakpoints, minBreakpoint, dir]);\n  return /*#__PURE__*/_jsx(Provider, {\n    value: contextValue,\n    children: children\n  });\n}\nexport function useBootstrapPrefix(prefix, defaultPrefix) {\n  const {\n    prefixes\n  } = useContext(ThemeContext);\n  return prefix || prefixes[defaultPrefix] || defaultPrefix;\n}\nexport function useBootstrapBreakpoints() {\n  const {\n    breakpoints\n  } = useContext(ThemeContext);\n  return breakpoints;\n}\nexport function useBootstrapMinBreakpoint() {\n  const {\n    minBreakpoint\n  } = useContext(ThemeContext);\n  return minBreakpoint;\n}\nexport function useIsRTL() {\n  const {\n    dir\n  } = useContext(ThemeContext);\n  return dir === 'rtl';\n}\nfunction createBootstrapComponent(Component, opts) {\n  if (typeof opts === 'string') opts = {\n    prefix: opts\n  };\n  const isClassy = Component.prototype && Component.prototype.isReactComponent;\n  // If it's a functional component make sure we don't break it with a ref\n  const {\n    prefix,\n    forwardRefAs = isClassy ? 'ref' : 'innerRef'\n  } = opts;\n  const Wrapped = /*#__PURE__*/React.forwardRef((_ref2, ref) => {\n    let {\n      ...props\n    } = _ref2;\n    props[forwardRefAs] = ref;\n    const bsPrefix = useBootstrapPrefix(props.bsPrefix, prefix);\n    return /*#__PURE__*/_jsx(Component, {\n      ...props,\n      bsPrefix: bsPrefix\n    });\n  });\n  Wrapped.displayName = \"Bootstrap(\".concat(Component.displayName || Component.name, \")\");\n  return Wrapped;\n}\nexport { createBootstrapComponent, Consumer as ThemeConsumer };\nexport default ThemeProvider;","\"use client\";\n\nimport React, { useCallback, useRef } from 'react';\nimport Transition from 'react-transition-group/Transition';\nimport useMergedRefs from '@restart/hooks/useMergedRefs';\nimport safeFindDOMNode from './safeFindDOMNode';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\n// Normalizes Transition callbacks when nodeRef is used.\nconst TransitionWrapper = /*#__PURE__*/React.forwardRef((_ref, ref) => {\n  let {\n    onEnter,\n    onEntering,\n    onEntered,\n    onExit,\n    onExiting,\n    onExited,\n    addEndListener,\n    children,\n    childRef,\n    ...props\n  } = _ref;\n  const nodeRef = useRef(null);\n  const mergedRef = useMergedRefs(nodeRef, childRef);\n  const attachRef = r => {\n    mergedRef(safeFindDOMNode(r));\n  };\n  const normalize = callback => param => {\n    if (callback && nodeRef.current) {\n      callback(nodeRef.current, param);\n    }\n  };\n\n  /* eslint-disable react-hooks/exhaustive-deps */\n  const handleEnter = useCallback(normalize(onEnter), [onEnter]);\n  const handleEntering = useCallback(normalize(onEntering), [onEntering]);\n  const handleEntered = useCallback(normalize(onEntered), [onEntered]);\n  const handleExit = useCallback(normalize(onExit), [onExit]);\n  const handleExiting = useCallback(normalize(onExiting), [onExiting]);\n  const handleExited = useCallback(normalize(onExited), [onExited]);\n  const handleAddEndListener = useCallback(normalize(addEndListener), [addEndListener]);\n  /* eslint-enable react-hooks/exhaustive-deps */\n\n  return /*#__PURE__*/_jsx(Transition, {\n    ref: ref,\n    ...props,\n    onEnter: handleEnter,\n    onEntered: handleEntered,\n    onEntering: handleEntering,\n    onExit: handleExit,\n    onExited: handleExited,\n    onExiting: handleExiting,\n    addEndListener: handleAddEndListener,\n    nodeRef: nodeRef,\n    children: typeof children === 'function' ? (status, innerProps) =>\n    // TODO: Types for RTG missing innerProps, so need to cast.\n    children(status, {\n      ...innerProps,\n      ref: attachRef\n    }) : /*#__PURE__*/React.cloneElement(children, {\n      ref: attachRef\n    })\n  });\n});\nexport default TransitionWrapper;","import * as React from 'react';\nimport classNames from 'classnames';\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nexport default (className => /*#__PURE__*/React.forwardRef((p, ref) => /*#__PURE__*/_jsx(\"div\", {\n  ...p,\n  ref: ref,\n  className: classNames(p.className, className)\n})));","import ReactDOM from 'react-dom';\nexport default function safeFindDOMNode(componentOrElement) {\n  if (componentOrElement && 'setState' in componentOrElement) {\n    return ReactDOM.findDOMNode(componentOrElement);\n  }\n  return componentOrElement != null ? componentOrElement : null;\n}","import css from 'dom-helpers/css';\nimport transitionEnd from 'dom-helpers/transitionEnd';\nfunction parseDuration(node, property) {\n  const str = css(node, property) || '';\n  const mult = str.indexOf('ms') === -1 ? 1000 : 1;\n  return parseFloat(str) * mult;\n}\nexport default function transitionEndListener(element, handler) {\n  const duration = parseDuration(element, 'transitionDuration');\n  const delay = parseDuration(element, 'transitionDelay');\n  const remove = transitionEnd(element, e => {\n    if (e.target === element) {\n      remove();\n      handler(e);\n    }\n  }, duration + delay);\n}","// reading a dimension prop will cause the browser to recalculate,\n// which will let our animations work\nexport default function triggerBrowserReflow(node) {\n  // eslint-disable-next-line @typescript-eslint/no-unused-expressions\n  node.offsetHeight;\n}","export default {\n  disabled: false\n};","import React from 'react';\nexport default React.createContext(null);","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nimport config from './config';\nimport { timeoutsShape } from './utils/PropTypes';\nimport TransitionGroupContext from './TransitionGroupContext';\nimport { forceReflow } from './utils/reflow';\nexport var UNMOUNTED = 'unmounted';\nexport var EXITED = 'exited';\nexport var ENTERING = 'entering';\nexport var ENTERED = 'entered';\nexport var EXITING = 'exiting';\n/**\n * The Transition component lets you describe a transition from one component\n * state to another _over time_ with a simple declarative API. Most commonly\n * it's used to animate the mounting and unmounting of a component, but can also\n * be used to describe in-place transition states as well.\n *\n * ---\n *\n * **Note**: `Transition` is a platform-agnostic base component. If you're using\n * transitions in CSS, you'll probably want to use\n * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)\n * instead. It inherits all the features of `Transition`, but contains\n * additional features necessary to play nice with CSS transitions (hence the\n * name of the component).\n *\n * ---\n *\n * By default the `Transition` component does not alter the behavior of the\n * component it renders, it only tracks \"enter\" and \"exit\" states for the\n * components. It's up to you to give meaning and effect to those states. For\n * example we can add styles to a component when it enters or exits:\n *\n * ```jsx\n * import { Transition } from 'react-transition-group';\n *\n * const duration = 300;\n *\n * const defaultStyle = {\n *   transition: `opacity ${duration}ms ease-in-out`,\n *   opacity: 0,\n * }\n *\n * const transitionStyles = {\n *   entering: { opacity: 1 },\n *   entered:  { opacity: 1 },\n *   exiting:  { opacity: 0 },\n *   exited:  { opacity: 0 },\n * };\n *\n * const Fade = ({ in: inProp }) => (\n *   <Transition in={inProp} timeout={duration}>\n *     {state => (\n *       <div style={{\n *         ...defaultStyle,\n *         ...transitionStyles[state]\n *       }}>\n *         I'm a fade Transition!\n *       </div>\n *     )}\n *   </Transition>\n * );\n * ```\n *\n * There are 4 main states a Transition can be in:\n *  - `'entering'`\n *  - `'entered'`\n *  - `'exiting'`\n *  - `'exited'`\n *\n * Transition state is toggled via the `in` prop. When `true` the component\n * begins the \"Enter\" stage. During this stage, the component will shift from\n * its current transition state, to `'entering'` for the duration of the\n * transition and then to the `'entered'` stage once it's complete. Let's take\n * the following example (we'll use the\n * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):\n *\n * ```jsx\n * function App() {\n *   const [inProp, setInProp] = useState(false);\n *   return (\n *     <div>\n *       <Transition in={inProp} timeout={500}>\n *         {state => (\n *           // ...\n *         )}\n *       </Transition>\n *       <button onClick={() => setInProp(true)}>\n *         Click to Enter\n *       </button>\n *     </div>\n *   );\n * }\n * ```\n *\n * When the button is clicked the component will shift to the `'entering'` state\n * and stay there for 500ms (the value of `timeout`) before it finally switches\n * to `'entered'`.\n *\n * When `in` is `false` the same thing happens except the state moves from\n * `'exiting'` to `'exited'`.\n */\n\nvar Transition = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Transition, _React$Component);\n  function Transition(props, context) {\n    var _this;\n    _this = _React$Component.call(this, props, context) || this;\n    var parentGroup = context; // In the context of a TransitionGroup all enters are really appears\n\n    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n    var initialStatus;\n    _this.appearStatus = null;\n    if (props.in) {\n      if (appear) {\n        initialStatus = EXITED;\n        _this.appearStatus = ENTERING;\n      } else {\n        initialStatus = ENTERED;\n      }\n    } else {\n      if (props.unmountOnExit || props.mountOnEnter) {\n        initialStatus = UNMOUNTED;\n      } else {\n        initialStatus = EXITED;\n      }\n    }\n    _this.state = {\n      status: initialStatus\n    };\n    _this.nextCallback = null;\n    return _this;\n  }\n  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n    var nextIn = _ref.in;\n    if (nextIn && prevState.status === UNMOUNTED) {\n      return {\n        status: EXITED\n      };\n    }\n    return null;\n  } // getSnapshotBeforeUpdate(prevProps) {\n  //   let nextStatus = null\n  //   if (prevProps !== this.props) {\n  //     const { status } = this.state\n  //     if (this.props.in) {\n  //       if (status !== ENTERING && status !== ENTERED) {\n  //         nextStatus = ENTERING\n  //       }\n  //     } else {\n  //       if (status === ENTERING || status === ENTERED) {\n  //         nextStatus = EXITING\n  //       }\n  //     }\n  //   }\n  //   return { nextStatus }\n  // }\n  ;\n  var _proto = Transition.prototype;\n  _proto.componentDidMount = function componentDidMount() {\n    this.updateStatus(true, this.appearStatus);\n  };\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    var nextStatus = null;\n    if (prevProps !== this.props) {\n      var status = this.state.status;\n      if (this.props.in) {\n        if (status !== ENTERING && status !== ENTERED) {\n          nextStatus = ENTERING;\n        }\n      } else {\n        if (status === ENTERING || status === ENTERED) {\n          nextStatus = EXITING;\n        }\n      }\n    }\n    this.updateStatus(false, nextStatus);\n  };\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    this.cancelNextCallback();\n  };\n  _proto.getTimeouts = function getTimeouts() {\n    var timeout = this.props.timeout;\n    var exit, enter, appear;\n    exit = enter = appear = timeout;\n    if (timeout != null && typeof timeout !== 'number') {\n      exit = timeout.exit;\n      enter = timeout.enter; // TODO: remove fallback for next major\n\n      appear = timeout.appear !== undefined ? timeout.appear : enter;\n    }\n    return {\n      exit: exit,\n      enter: enter,\n      appear: appear\n    };\n  };\n  _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n    if (mounting === void 0) {\n      mounting = false;\n    }\n    if (nextStatus !== null) {\n      // nextStatus will always be ENTERING or EXITING.\n      this.cancelNextCallback();\n      if (nextStatus === ENTERING) {\n        if (this.props.unmountOnExit || this.props.mountOnEnter) {\n          var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this); // https://github.com/reactjs/react-transition-group/pull/749\n          // With unmountOnExit or mountOnEnter, the enter animation should happen at the transition between `exited` and `entering`.\n          // To make the animation happen,  we have to separate each rendering and avoid being processed as batched.\n\n          if (node) forceReflow(node);\n        }\n        this.performEnter(mounting);\n      } else {\n        this.performExit();\n      }\n    } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n      this.setState({\n        status: UNMOUNTED\n      });\n    }\n  };\n  _proto.performEnter = function performEnter(mounting) {\n    var _this2 = this;\n    var enter = this.props.enter;\n    var appearing = this.context ? this.context.isMounting : mounting;\n    var _ref2 = this.props.nodeRef ? [appearing] : [ReactDOM.findDOMNode(this), appearing],\n      maybeNode = _ref2[0],\n      maybeAppearing = _ref2[1];\n    var timeouts = this.getTimeouts();\n    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED\n    // if we are mounting and running this it means appear _must_ be set\n\n    if (!mounting && !enter || config.disabled) {\n      this.safeSetState({\n        status: ENTERED\n      }, function () {\n        _this2.props.onEntered(maybeNode);\n      });\n      return;\n    }\n    this.props.onEnter(maybeNode, maybeAppearing);\n    this.safeSetState({\n      status: ENTERING\n    }, function () {\n      _this2.props.onEntering(maybeNode, maybeAppearing);\n      _this2.onTransitionEnd(enterTimeout, function () {\n        _this2.safeSetState({\n          status: ENTERED\n        }, function () {\n          _this2.props.onEntered(maybeNode, maybeAppearing);\n        });\n      });\n    });\n  };\n  _proto.performExit = function performExit() {\n    var _this3 = this;\n    var exit = this.props.exit;\n    var timeouts = this.getTimeouts();\n    var maybeNode = this.props.nodeRef ? undefined : ReactDOM.findDOMNode(this); // no exit animation skip right to EXITED\n\n    if (!exit || config.disabled) {\n      this.safeSetState({\n        status: EXITED\n      }, function () {\n        _this3.props.onExited(maybeNode);\n      });\n      return;\n    }\n    this.props.onExit(maybeNode);\n    this.safeSetState({\n      status: EXITING\n    }, function () {\n      _this3.props.onExiting(maybeNode);\n      _this3.onTransitionEnd(timeouts.exit, function () {\n        _this3.safeSetState({\n          status: EXITED\n        }, function () {\n          _this3.props.onExited(maybeNode);\n        });\n      });\n    });\n  };\n  _proto.cancelNextCallback = function cancelNextCallback() {\n    if (this.nextCallback !== null) {\n      this.nextCallback.cancel();\n      this.nextCallback = null;\n    }\n  };\n  _proto.safeSetState = function safeSetState(nextState, callback) {\n    // This shouldn't be necessary, but there are weird race conditions with\n    // setState callbacks and unmounting in testing, so always make sure that\n    // we can cancel any pending setState callbacks after we unmount.\n    callback = this.setNextCallback(callback);\n    this.setState(nextState, callback);\n  };\n  _proto.setNextCallback = function setNextCallback(callback) {\n    var _this4 = this;\n    var active = true;\n    this.nextCallback = function (event) {\n      if (active) {\n        active = false;\n        _this4.nextCallback = null;\n        callback(event);\n      }\n    };\n    this.nextCallback.cancel = function () {\n      active = false;\n    };\n    return this.nextCallback;\n  };\n  _proto.onTransitionEnd = function onTransitionEnd(timeout, handler) {\n    this.setNextCallback(handler);\n    var node = this.props.nodeRef ? this.props.nodeRef.current : ReactDOM.findDOMNode(this);\n    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;\n    if (!node || doesNotHaveTimeoutOrListener) {\n      setTimeout(this.nextCallback, 0);\n      return;\n    }\n    if (this.props.addEndListener) {\n      var _ref3 = this.props.nodeRef ? [this.nextCallback] : [node, this.nextCallback],\n        maybeNode = _ref3[0],\n        maybeNextCallback = _ref3[1];\n      this.props.addEndListener(maybeNode, maybeNextCallback);\n    }\n    if (timeout != null) {\n      setTimeout(this.nextCallback, timeout);\n    }\n  };\n  _proto.render = function render() {\n    var status = this.state.status;\n    if (status === UNMOUNTED) {\n      return null;\n    }\n    var _this$props = this.props,\n      children = _this$props.children,\n      _in = _this$props.in,\n      _mountOnEnter = _this$props.mountOnEnter,\n      _unmountOnExit = _this$props.unmountOnExit,\n      _appear = _this$props.appear,\n      _enter = _this$props.enter,\n      _exit = _this$props.exit,\n      _timeout = _this$props.timeout,\n      _addEndListener = _this$props.addEndListener,\n      _onEnter = _this$props.onEnter,\n      _onEntering = _this$props.onEntering,\n      _onEntered = _this$props.onEntered,\n      _onExit = _this$props.onExit,\n      _onExiting = _this$props.onExiting,\n      _onExited = _this$props.onExited,\n      _nodeRef = _this$props.nodeRef,\n      childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\", \"in\", \"mountOnEnter\", \"unmountOnExit\", \"appear\", \"enter\", \"exit\", \"timeout\", \"addEndListener\", \"onEnter\", \"onEntering\", \"onEntered\", \"onExit\", \"onExiting\", \"onExited\", \"nodeRef\"]);\n    return /*#__PURE__*/(\n      // allows for nested Transitions\n      React.createElement(TransitionGroupContext.Provider, {\n        value: null\n      }, typeof children === 'function' ? children(status, childProps) : React.cloneElement(React.Children.only(children), childProps))\n    );\n  };\n  return Transition;\n}(React.Component);\nTransition.contextType = TransitionGroupContext;\n// Name the function so it is clearer in the documentation\n\nfunction noop() {}\nTransition.defaultProps = {\n  in: false,\n  mountOnEnter: false,\n  unmountOnExit: false,\n  appear: false,\n  enter: true,\n  exit: true,\n  onEnter: noop,\n  onEntering: noop,\n  onEntered: noop,\n  onExit: noop,\n  onExiting: noop,\n  onExited: noop\n};\nTransition.UNMOUNTED = UNMOUNTED;\nTransition.EXITED = EXITED;\nTransition.ENTERING = ENTERING;\nTransition.ENTERED = ENTERED;\nTransition.EXITING = EXITING;\nexport default Transition;","export var forceReflow = function forceReflow(node) {\n  return node.scrollTop;\n};","/* eslint-disable no-return-assign */\nimport canUseDOM from './canUseDOM';\nexport var optionsSupported = false;\nexport var onceSupported = false;\n\ntry {\n  var options = {\n    get passive() {\n      return optionsSupported = true;\n    },\n\n    get once() {\n      // eslint-disable-next-line no-multi-assign\n      return onceSupported = optionsSupported = true;\n    }\n\n  };\n\n  if (canUseDOM) {\n    window.addEventListener('test', options, options);\n    window.removeEventListener('test', options, true);\n  }\n} catch (e) {\n  /* */\n}\n\n/**\n * An `addEventListener` ponyfill, supports the `once` option\n * \n * @param node the element\n * @param eventName the event name\n * @param handle the handler\n * @param options event options\n */\nfunction addEventListener(node, eventName, handler, options) {\n  if (options && typeof options !== 'boolean' && !onceSupported) {\n    var once = options.once,\n        capture = options.capture;\n    var wrappedHandler = handler;\n\n    if (!onceSupported && once) {\n      wrappedHandler = handler.__once || function onceHandler(event) {\n        this.removeEventListener(eventName, onceHandler, capture);\n        handler.call(this, event);\n      };\n\n      handler.__once = wrappedHandler;\n    }\n\n    node.addEventListener(eventName, wrappedHandler, optionsSupported ? options : capture);\n  }\n\n  node.addEventListener(eventName, handler, options);\n}\n\nexport default addEventListener;","export default !!(typeof window !== 'undefined' && window.document && window.document.createElement);","/* eslint-disable no-bitwise, no-cond-assign */\n\n/**\n * Checks if an element contains another given element.\n * \n * @param context the context element\n * @param node the element to check\n */\nexport default function contains(context, node) {\n  // HTML DOM and SVG DOM may have different support levels,\n  // so we need to check on context instead of a document root element.\n  if (context.contains) return context.contains(node);\n  if (context.compareDocumentPosition) return context === node || !!(context.compareDocumentPosition(node) & 16);\n}","import ownerWindow from './ownerWindow';\n/**\n * Returns one or all computed style properties of an element.\n * \n * @param node the element\n * @param psuedoElement the style property\n */\n\nexport default function getComputedStyle(node, psuedoElement) {\n  return ownerWindow(node).getComputedStyle(node, psuedoElement);\n}","import ownerDocument from './ownerDocument';\n/**\n * Returns the owner window of a given element.\n * \n * @param node the element\n */\n\nexport default function ownerWindow(node) {\n  var doc = ownerDocument(node);\n  return doc && doc.defaultView || window;\n}","var rUpper = /([A-Z])/g;\nexport default function hyphenate(string) {\n  return string.replace(rUpper, '-$1').toLowerCase();\n}","/**\n * Copyright 2013-2014, Facebook, Inc.\n * All rights reserved.\n * https://github.com/facebook/react/blob/2aeb8a2a6beb00617a4217f7f8284924fa2ad819/src/vendor/core/hyphenateStyleName.js\n */\nimport hyphenate from './hyphenate';\nvar msPattern = /^ms-/;\nexport default function hyphenateStyleName(string) {\n  return hyphenate(string).replace(msPattern, '-ms-');\n}","var supportedTransforms = /^((translate|rotate|scale)(X|Y|Z|3d)?|matrix(3d)?|perspective|skew(X|Y)?)$/i;\nexport default function isTransform(value) {\n  return !!(value && supportedTransforms.test(value));\n}","import getComputedStyle from './getComputedStyle';\nimport hyphenate from './hyphenateStyle';\nimport isTransform from './isTransform';\n\nfunction style(node, property) {\n  var css = '';\n  var transforms = '';\n\n  if (typeof property === 'string') {\n    return node.style.getPropertyValue(hyphenate(property)) || getComputedStyle(node).getPropertyValue(hyphenate(property));\n  }\n\n  Object.keys(property).forEach(function (key) {\n    var value = property[key];\n\n    if (!value && value !== 0) {\n      node.style.removeProperty(hyphenate(key));\n    } else if (isTransform(key)) {\n      transforms += key + \"(\" + value + \") \";\n    } else {\n      css += hyphenate(key) + \": \" + value + \";\";\n    }\n  });\n\n  if (transforms) {\n    css += \"transform: \" + transforms + \";\";\n  }\n\n  node.style.cssText += \";\" + css;\n}\n\nexport default style;","/**\n * Checks if a given element has a CSS class.\n * \n * @param element the element\n * @param className the CSS class name\n */\nexport default function hasClass(element, className) {\n  if (element.classList) return !!className && element.classList.contains(className);\n  return (\" \" + (element.className.baseVal || element.className) + \" \").indexOf(\" \" + className + \" \") !== -1;\n}","import addEventListener from './addEventListener';\nimport removeEventListener from './removeEventListener';\n\nfunction listen(node, eventName, handler, options) {\n  addEventListener(node, eventName, handler, options);\n  return function () {\n    removeEventListener(node, eventName, handler, options);\n  };\n}\n\nexport default listen;","/**\n * Returns the owner document of a given element.\n * \n * @param node the element\n */\nexport default function ownerDocument(node) {\n  return node && node.ownerDocument || document;\n}","var toArray = Function.prototype.bind.call(Function.prototype.call, [].slice);\n/**\n * Runs `querySelectorAll` on a given element.\n * \n * @param element the element\n * @param selector the selector\n */\n\nexport default function qsa(element, selector) {\n  return toArray(element.querySelectorAll(selector));\n}","/**\n * A `removeEventListener` ponyfill\n * \n * @param node the element\n * @param eventName the event name\n * @param handle the handler\n * @param options event options\n */\nfunction removeEventListener(node, eventName, handler, options) {\n  var capture = options && typeof options !== 'boolean' ? options.capture : options;\n  node.removeEventListener(eventName, handler, capture);\n\n  if (handler.__once) {\n    node.removeEventListener(eventName, handler.__once, capture);\n  }\n}\n\nexport default removeEventListener;","import css from './css';\nimport listen from './listen';\nimport triggerEvent from './triggerEvent';\n\nfunction parseDuration(node) {\n  var str = css(node, 'transitionDuration') || '';\n  var mult = str.indexOf('ms') === -1 ? 1000 : 1;\n  return parseFloat(str) * mult;\n}\n\nfunction emulateTransitionEnd(element, duration, padding) {\n  if (padding === void 0) {\n    padding = 5;\n  }\n\n  var called = false;\n  var handle = setTimeout(function () {\n    if (!called) triggerEvent(element, 'transitionend', true);\n  }, duration + padding);\n  var remove = listen(element, 'transitionend', function () {\n    called = true;\n  }, {\n    once: true\n  });\n  return function () {\n    clearTimeout(handle);\n    remove();\n  };\n}\n\nexport default function transitionEnd(element, handler, duration, padding) {\n  if (duration == null) duration = parseDuration(element) || 0;\n  var removeEmulate = emulateTransitionEnd(element, duration, padding);\n  var remove = listen(element, 'transitionend', handler);\n  return function () {\n    removeEmulate();\n    remove();\n  };\n}","/**\n * Triggers an event on a given element.\n * \n * @param node the element\n * @param eventName the event name to trigger\n * @param bubbles whether the event should bubble up\n * @param cancelable whether the event should be cancelable\n */\nexport default function triggerEvent(node, eventName, bubbles, cancelable) {\n  if (bubbles === void 0) {\n    bubbles = false;\n  }\n\n  if (cancelable === void 0) {\n    cancelable = true;\n  }\n\n  if (node) {\n    var event = document.createEvent('HTMLEvents');\n    event.initEvent(eventName, bubbles, cancelable);\n    node.dispatchEvent(event);\n  }\n}"],"names":["useCallbackRef","useState","value","ref","useRef","useEffect","current","useEventCallback","fn","useCallback","arguments","isReactNative","g","navigator","product","isDOM","document","useLayoutEffect","toFnRef","refA","refB","useMemo","a","b","mergeRefs","useMounted","mounted","isMounted","usePrevious","useWillUnmount","onUnmount","valueRef","useUpdatedRef","ATTRIBUTE_PREFIX","PROPERTY_PREFIX","dataAttr","property","concat","dataProp","_excluded","useRTGTransitionProps","_ref","onEnter","onEntering","onEntered","onExit","onExiting","onExited","addEndListener","children","props","source","excluded","key","i","target","sourceKeys","Object","keys","length","indexOf","_objectWithoutPropertiesLoose","nodeRef","mergedRef","useMergedRefs","normalize","callback","param","handleEnter","handleEntering","handleEntered","handleExit","handleExiting","handleExited","handleAddEndListener","assign","status","innerProps","cloneElement","component","Component","transitionProps","ImperativeTransition","_ref2","in","inProp","transition","exited","setExited","onTransition","isInitialRef","handleTransition","useIsomorphicEffect","stale","element","initial","isStale","useTransition","options","Promise","resolve","then","error","combinedRef","renderTransition","runTransition","NoopTransition","activeElement","doc","ownerDocument","active","nodeName","e","body","manager","useModalManager","provided","window","useWindow","modalManager","ModalManager","getManager","modal","dialog","backdrop","add","remove","isTopModal","setDialogRef","setBackdropRef","Modal","forwardRef","show","role","className","style","keyboard","onBackdropClick","onEscapeKeyDown","backdropTransition","runBackdropTransition","autoFocus","enforceFocus","restoreFocus","restoreFocusOptions","renderDialog","renderBackdrop","providedManager","container","containerRef","onShow","onHide","rest","ownerWindow","useWaitForDOMRef","prevShow","lastFocusRef","useImperativeHandle","canUseDOM","handleShow","removeKeydownListenerRef","listen","handleDocumentKeyDown","removeFocusListenerRef","setTimeout","handleEnforceFocus","_modal$dialog$ownerDo","_modal$dialog","currentActiveElement","contains","focus","handleHide","_lastFocusRef$current","handleBackdropClick","currentTarget","defaultPrevented","dialogProps","undefined","tabIndex","unmountOnExit","mountOnEnter","appear","backdropElement","onClick","displayName","Manager","OPEN_DATA_ATTRIBUTE","constructor","handleContainerOverflow","isRTL","this","modals","getScrollbarWidth","defaultView","Math","abs","innerWidth","documentElement","clientWidth","getBodyScrollbarWidth","getElement","setModalAttributes","_modal","removeModalAttributes","setContainerStyle","containerState","overflow","paddingProp","scrollBarWidth","parseInt","css","setAttribute","reset","forEach","m","removeContainerStyle","removeAttribute","modalIdx","push","state","splice","hasEnteredRef","child","resolveContainerRef","getBoundingClientRect","onResolved","resolvedRef","setRef","earlyRef","nextRef","Context","createContext","Provider","useContext","isEscKey","code","keyCode","hasOwn","hasOwnProperty","classNames","classes","arg","appendClass","parseValue","Array","isArray","apply","toString","prototype","includes","call","newClass","module","exports","default","AbstractModalHeader","closeLabel","closeVariant","closeButton","context","handleClick","variant","replaceClassName","origClass","classToRemove","replace","RegExp","Selector","BootstrapModalManager","adjustAndStore","prop","adjust","actual","dataset","parseFloat","restore","super","classList","hasClass","baseVal","marginProp","el","sharedManager","getSharedManager","propTypes","CloseButton","ariaLabel","type","fadeStyles","Fade","transitionClasses","timeout","node","isAppearing","childRef","ModalContext","DEFAULT_BREAKPOINTS","DEFAULT_MIN_BREAKPOINT","ThemeContext","prefixes","breakpoints","minBreakpoint","Consumer","useBootstrapPrefix","prefix","defaultPrefix","useBootstrapBreakpoints","useBootstrapMinBreakpoint","useIsRTL","dir","TransitionWrapper","attachRef","r","p","safeFindDOMNode","componentOrElement","parseDuration","str","mult","transitionEndListener","handler","duration","delay","triggerBrowserReflow","offsetHeight","UNMOUNTED","EXITED","ENTERING","ENTERED","EXITING","Transition","_React$Component","_this","initialStatus","isMounting","enter","appearStatus","nextCallback","getDerivedStateFromProps","prevState","_proto","componentDidMount","updateStatus","componentDidUpdate","prevProps","nextStatus","componentWillUnmount","cancelNextCallback","getTimeouts","exit","mounting","scrollTop","forceReflow","performEnter","performExit","setState","_this2","appearing","maybeNode","maybeAppearing","timeouts","enterTimeout","config","safeSetState","onTransitionEnd","_this3","cancel","nextState","setNextCallback","_this4","event","doesNotHaveTimeoutOrListener","_ref3","maybeNextCallback","render","_this$props","childProps","TransitionGroupContext","only","noop","contextType","defaultProps","optionsSupported","onceSupported","passive","once","addEventListener","removeEventListener","eventName","capture","wrappedHandler","__once","onceHandler","createElement","compareDocumentPosition","getComputedStyle","psuedoElement","rUpper","msPattern","hyphenateStyleName","string","toLowerCase","hyphenate","supportedTransforms","transforms","getPropertyValue","test","isTransform","removeProperty","cssText","toArray","Function","bind","slice","qsa","selector","querySelectorAll","emulateTransitionEnd","padding","called","handle","bubbles","cancelable","createEvent","initEvent","dispatchEvent","triggerEvent","clearTimeout","transitionEnd","removeEmulate"],"sourceRoot":""}