{"version":3,"file":"7119-4552e26cd5f101db138b.js","mappings":"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","sources":["webpack://@whistleout/webui/../node_modules/.pnpm/@remix-run+router@1.14.2/node_modules/@remix-run/router/dist/router.js","webpack://@whistleout/webui/../node_modules/.pnpm/classnames@2.3.2/node_modules/classnames/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/internals/array-set-length.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/internals/call-with-safe-iteration-closing.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/internals/create-iter-result-object.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/internals/define-built-ins.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/internals/does-not-exceed-safe-integer.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/internals/is-array.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/internals/iterator-create-proxy.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/internals/iterator-map.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/modules/es.array.push.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/modules/esnext.iterator.filter.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/modules/esnext.iterator.for-each.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/modules/esnext.iterator.map.js","webpack://@whistleout/webui/../node_modules/.pnpm/core-js@3.31.1/node_modules/core-js/modules/esnext.iterator.some.js","webpack://@whistleout/webui/../node_modules/.pnpm/lodash@4.17.21/node_modules/lodash/isEmpty.js","webpack://@whistleout/webui/../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/factoryWithThrowingShims.js","webpack://@whistleout/webui/../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/createClass.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/inherits.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/createSuper.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/warning.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/common/Track.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/get.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/superPropBase.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/Dom/addEventListener.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/common/Steps.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/common/Marks.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/Handle.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/KeyCode.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/utils.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/common/createSlider.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/Slider.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/Range.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/raf.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/Dom/contains.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/Dom/findDOMNode.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/ref.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/Dom/canUseDom.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/Portal.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-trigger@5.3.4_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-trigger/es/utils/alignUtil.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/isMobile.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/context.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/DomWrapper.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/hooks/useEvent.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/hooks/useLayoutEffect.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/hooks/useState.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/utils/set.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/interface.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/util/motion.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/hooks/useDomMotionEvents.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/hooks/useIsomorphicLayoutEffect.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/hooks/useStepQueue.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/CSSMotion.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/hooks/useStatus.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/hooks/useSyncState.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/hooks/useNextFrame.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/util/diff.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/CSSMotionList.js","webpack://@whistleout/webui/../node_modules/.pnpm/dom-align@1.12.4/node_modules/dom-align/dist-web/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-motion@2.9.3_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-motion/es/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-trigger@5.3.4_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-trigger/es/utils/legacyUtil.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-trigger@5.3.4_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-trigger/es/Popup/Mask.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/isEqual.js","webpack://@whistleout/webui/../node_modules/.pnpm/resize-observer-polyfill@1.5.1/node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-align@4.0.15_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-align/es/util.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-align@4.0.15_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-align/es/Align.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-align@4.0.15_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-align/es/hooks/useBuffer.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-util@5.43.0_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-util/es/Dom/isVisible.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-align@4.0.15_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-align/es/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/regeneratorRuntime.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.10/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-trigger@5.3.4_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-trigger/es/Popup/useVisibleStatus.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-trigger@5.3.4_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-trigger/es/Popup/PopupInner.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-trigger@5.3.4_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-trigger/es/Popup/useStretchStyle.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-trigger@5.3.4_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-trigger/es/Popup/MobilePopupInner.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-trigger@5.3.4_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-trigger/es/Popup/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-trigger@5.3.4_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-trigger/es/context.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-trigger@5.3.4_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-trigger/es/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-tooltip@5.3.1_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-tooltip/es/placements.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-tooltip@5.3.1_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-tooltip/es/Popup.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-tooltip@5.3.1_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-tooltip/es/Tooltip.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-tooltip@5.3.1_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-tooltip/es/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/common/SliderTooltip.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/rc-slider@9.7.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/rc-slider/es/createSliderWithTooltip.js","webpack://@whistleout/webui/../node_modules/.pnpm/react-router-dom@6.21.2_react-dom@17.0.2_react@17.0.2__react@17.0.2/node_modules/react-router-dom/dist/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/react-router@6.21.2_react@17.0.2/node_modules/react-router/dist/index.js","webpack://@whistleout/webui/../node_modules/.pnpm/react@17.0.2/node_modules/react/cjs/react-jsx-runtime.production.min.js","webpack://@whistleout/webui/../node_modules/.pnpm/react@17.0.2/node_modules/react/jsx-runtime.js"],"sourcesContent":["/**\n * @remix-run/router v1.14.2\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Actions represent the type of change to a location value.\n */\nvar Action;\n(function (Action) {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Action[\"Pop\"] = \"POP\";\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Action[\"Push\"] = \"PUSH\";\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\nconst PopStateEventType = \"popstate\";\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    initialEntries = [\"/\"],\n    initialIndex,\n    v5Compat = false\n  } = options;\n  let entries; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === \"string\" ? null : entry.state, index === 0 ? \"default\" : undefined));\n  let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);\n  let action = Action.Pop;\n  let listener = null;\n  function clampIndex(n) {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation() {\n    return entries[index];\n  }\n  function createMemoryLocation(to, state, key) {\n    if (state === void 0) {\n      state = null;\n    }\n    let location = createLocation(entries ? getCurrentLocation().pathname : \"/\", to, state, key);\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n    return location;\n  }\n  function createHref(to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  let history = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\"\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 1\n        });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta: 0\n        });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({\n          action,\n          location: nextLocation,\n          delta\n        });\n      }\n    },\n    listen(fn) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    }\n  };\n  return history;\n}\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createBrowserLocation(window, globalHistory) {\n    let {\n      pathname,\n      search,\n      hash\n    } = window.location;\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createBrowserHref(window, to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);\n}\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n  function createHashLocation(window, globalHistory) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\"\n    } = parsePath(window.location.hash.substr(1));\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\n    },\n    // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n  function createHashHref(window, to) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n  function validateHashLocation(location, to) {\n    warning(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\");\n  }\n  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);\n}\nfunction invariant(value, message) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\nfunction warning(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n    try {\n      // Welcome to debugging history!\n      //\n      // This error is thrown as a convenience, so you can more easily\n      // find the source for a warning that appears in the console by\n      // enabling \"pause on exceptions\" in your JavaScript debugger.\n      throw new Error(message);\n      // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location, index) {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index\n  };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\nfunction createLocation(current, to, state, key) {\n  if (state === void 0) {\n    state = null;\n  }\n  let location = _extends({\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\"\n  }, typeof to === \"string\" ? parsePath(to) : to, {\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: to && to.key || key || createKey()\n  });\n  return location;\n}\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nfunction createPath(_ref) {\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\"\n  } = _ref;\n  if (search && search !== \"?\") pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\") pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nfunction parsePath(path) {\n  let parsedPath = {};\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n  return parsedPath;\n}\nfunction getUrlBasedHistory(getLocation, createHref, validateLocation, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  let {\n    window = document.defaultView,\n    v5Compat = false\n  } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener = null;\n  let index = getIndex();\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState(_extends({}, globalHistory.state, {\n      idx: index\n    }), \"\");\n  }\n  function getIndex() {\n    let state = globalHistory.state || {\n      idx: null\n    };\n    return state.idx;\n  }\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({\n        action,\n        location: history.location,\n        delta\n      });\n    }\n  }\n  function push(to, state) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 1\n      });\n    }\n  }\n  function replace(to, state) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location,\n        delta: 0\n      });\n    }\n  }\n  function createURL(to) {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base = window.location.origin !== \"null\" ? window.location.origin : window.location.href;\n    let href = typeof to === \"string\" ? to : createPath(to);\n    invariant(base, \"No window.location.(origin|href) available to create URL for href: \" + href);\n    return new URL(href, base);\n  }\n  let history = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    }\n  };\n  return history;\n}\n//#endregion\n\nvar ResultType;\n(function (ResultType) {\n  ResultType[\"data\"] = \"data\";\n  ResultType[\"deferred\"] = \"deferred\";\n  ResultType[\"redirect\"] = \"redirect\";\n  ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\nconst immutableRouteKeys = new Set([\"lazy\", \"caseSensitive\", \"path\", \"id\", \"index\", \"children\"]);\nfunction isIndexRoute(route) {\n  return route.index === true;\n}\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nfunction convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  if (manifest === void 0) {\n    manifest = {};\n  }\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, index];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(route.index !== true || !route.children, \"Cannot specify children on an index route\");\n    invariant(!manifest[id], \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, mapRouteProperties(route), {\n        id\n      });\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {\n        id,\n        children: undefined\n      });\n      manifest[id] = pathOrLayoutRoute;\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);\n      }\n      return pathOrLayoutRoute;\n    }\n  });\n}\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/utils/match-routes\n */\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n  if (pathname == null) {\n    return null;\n  }\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    matches = matchRouteBranch(branches[i],\n    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    safelyDecodeURI(pathname));\n  }\n  return matches;\n}\nfunction convertRouteMatchToUiMatch(match, loaderData) {\n  let {\n    route,\n    pathname,\n    params\n  } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle\n  };\n}\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n  let flattenRoute = (route, index, relativePath) => {\n    let meta = {\n      relativePath: relativePath === undefined ? route.path || \"\" : relativePath,\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\n    if (meta.relativePath.startsWith(\"/\")) {\n      invariant(meta.relativePath.startsWith(parentPath), \"Absolute route path \\\"\" + meta.relativePath + \"\\\" nested under path \" + (\"\\\"\" + parentPath + \"\\\" is not valid. An absolute child route path \") + \"must start with the combined path of all its parent routes.\");\n      meta.relativePath = meta.relativePath.slice(parentPath.length);\n    }\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta);\n    // Add the children before adding this route to the array, so we traverse the\n    // route tree depth-first and child routes appear before their parents in\n    // the \"flattened\" version.\n    if (route.children && route.children.length > 0) {\n      invariant(\n      // Our types know better, but runtime JS may not!\n      // @ts-expect-error\n      route.index !== true, \"Index routes must not have child routes. Please remove \" + (\"all child routes from route path \\\"\" + path + \"\\\".\"));\n      flattenRoutes(route.children, branches, routesMeta, path);\n    }\n    // Routes without a path shouldn't ever match by themselves unless they are\n    // index routes, so don't add them to the list of possible branches.\n    if (route.path == null && !route.index) {\n      return;\n    }\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  };\n  routes.forEach((route, index) => {\n    var _route$path;\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !((_route$path = route.path) != null && _route$path.includes(\"?\"))) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n  return branches;\n}\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path) {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n  let [first, ...rest] = segments;\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n  let result = [];\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(...restExploded.map(subpath => subpath === \"\" ? required : [required, subpath].join(\"/\")));\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map(exploded => path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded);\n}\nfunction rankRouteBranches(branches) {\n  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first\n  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));\n}\nconst paramRe = /^:[\\w-]+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = s => s === \"*\";\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\nfunction compareIndexes(a, b) {\n  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n  return siblings ?\n  // If two routes are siblings, we should try to match the earlier sibling\n  // first. This allows people to have fine-grained control over the matching\n  // behavior by simply putting routes with identical paths in the order they\n  // want them tried.\n  a[a.length - 1] - b[b.length - 1] :\n  // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\nfunction matchRouteBranch(branch, pathname) {\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n  for (let i = 0; i < routesMeta.length; ++i) {\n    let meta = routesMeta[i];\n    let end = i === routesMeta.length - 1;\n    let remainingPathname = matchedPathname === \"/\" ? pathname : pathname.slice(matchedPathname.length) || \"/\";\n    let match = matchPath({\n      path: meta.relativePath,\n      caseSensitive: meta.caseSensitive,\n      end\n    }, remainingPathname);\n    if (!match) return null;\n    Object.assign(matchedParams, match.params);\n    let route = meta.route;\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),\n      route\n    });\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n  return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/utils/generate-path\n */\nfunction generatePath(originalPath, params) {\n  if (params === void 0) {\n    params = {};\n  }\n  let path = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(false, \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n    path = path.replace(/\\*$/, \"/*\");\n  }\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n  const stringify = p => p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n  const segments = path.split(/\\/+/).map((segment, index, array) => {\n    const isLastSegment = index === array.length - 1;\n    // only apply the splat if it's the last segment\n    if (isLastSegment && segment === \"*\") {\n      const star = \"*\";\n      // Apply the splat\n      return stringify(params[star]);\n    }\n    const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n    if (keyMatch) {\n      const [, key, optional] = keyMatch;\n      let param = params[key];\n      invariant(optional === \"?\" || param != null, \"Missing \\\":\" + key + \"\\\" param\");\n      return stringify(param);\n    }\n    // Remove any optional markers from optional static segments\n    return segment.replace(/\\?$/g, \"\");\n  })\n  // Remove empty segments\n  .filter(segment => !!segment);\n  return prefix + segments.join(\"/\");\n}\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/utils/match-path\n */\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);\n  let match = pathname.match(matcher);\n  if (!match) return null;\n  let matchedPathname = match[0];\n  let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n  let captureGroups = match.slice(1);\n  let params = compiledParams.reduce((memo, _ref, index) => {\n    let {\n      paramName,\n      isOptional\n    } = _ref;\n    // We need to compute the pathnameBase here using the raw splat value\n    // instead of using params[\"*\"] later because it will be decoded then\n    if (paramName === \"*\") {\n      let splatValue = captureGroups[index] || \"\";\n      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\\/+$/, \"$1\");\n    }\n    const value = captureGroups[index];\n    if (isOptional && !value) {\n      memo[paramName] = undefined;\n    } else {\n      memo[paramName] = safelyDecodeURIComponent(value || \"\", paramName);\n    }\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n  if (end === void 0) {\n    end = true;\n  }\n  warning(path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"), \"Route path \\\"\" + path + \"\\\" will be treated as if it were \" + (\"\\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\" because the `*` character must \") + \"always follow a `/` in the pattern. To get rid of this warning, \" + (\"please change the route path to \\\"\" + path.replace(/\\*$/, \"/*\") + \"\\\".\"));\n  let params = [];\n  let regexpSource = \"^\" + path.replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n  .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n  .replace(/[\\\\.*+^${}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n  .replace(/\\/:([\\w-]+)(\\?)?/g, (_, paramName, isOptional) => {\n    params.push({\n      paramName,\n      isOptional: isOptional != null\n    });\n    return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n  });\n  if (path.endsWith(\"*\")) {\n    params.push({\n      paramName: \"*\"\n    });\n    regexpSource += path === \"*\" || path === \"/*\" ? \"(.*)$\" // Already matched the initial /, just match the rest\n    : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else ;\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, params];\n}\nfunction safelyDecodeURI(value) {\n  try {\n    return decodeURI(value);\n  } catch (error) {\n    warning(false, \"The URL path \\\"\" + value + \"\\\" could not be decoded because it is is a \" + \"malformed URL segment. This is probably due to a bad percent \" + (\"encoding (\" + error + \").\"));\n    return value;\n  }\n}\nfunction safelyDecodeURIComponent(value, paramName) {\n  try {\n    return decodeURIComponent(value);\n  } catch (error) {\n    warning(false, \"The value for the URL param \\\"\" + paramName + \"\\\" will not be decoded because\" + (\" the string \\\"\" + value + \"\\\" is a malformed URL segment. This is probably\") + (\" due to a bad percent encoding (\" + error + \").\"));\n    return value;\n  }\n}\n/**\n * @private\n */\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\") ? basename.length - 1 : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n  return pathname.slice(startIndex) || \"/\";\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/utils/resolve-path\n */\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\n  let {\n    pathname: toPathname,\n    search = \"\",\n    hash = \"\"\n  } = typeof to === \"string\" ? parsePath(to) : to;\n  let pathname = toPathname ? toPathname.startsWith(\"/\") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;\n  return {\n    pathname,\n    search: normalizeSearch(search),\n    hash: normalizeHash(hash)\n  };\n}\nfunction resolvePathname(relativePath, fromPathname) {\n  let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n  let relativeSegments = relativePath.split(\"/\");\n  relativeSegments.forEach(segment => {\n    if (segment === \"..\") {\n      // Keep the root \"\" segment so the pathname starts at /\n      if (segments.length > 1) segments.pop();\n    } else if (segment !== \".\") {\n      segments.push(segment);\n    }\n  });\n  return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\nfunction getInvalidPathError(char, field, dest, path) {\n  return \"Cannot include a '\" + char + \"' character in a manually specified \" + (\"`to.\" + field + \"` field [\" + JSON.stringify(path) + \"].  Please separate it out to the \") + (\"`to.\" + dest + \"` field. Alternatively you may provide the full path as \") + \"a string in <Link to=\\\"...\\\"> and the router will parse it for you.\";\n}\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nfunction getPathContributingMatches(matches) {\n  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nfunction getResolveToMatches(matches, v7_relativeSplatPath) {\n  let pathMatches = getPathContributingMatches(matches);\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) => idx === matches.length - 1 ? match.pathname : match.pathnameBase);\n  }\n  return pathMatches.map(match => match.pathnameBase);\n}\n/**\n * @private\n */\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n  if (isPathRelative === void 0) {\n    isPathRelative = false;\n  }\n  let to;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = _extends({}, toArg);\n    invariant(!to.pathname || !to.pathname.includes(\"?\"), getInvalidPathError(\"?\", \"pathname\", \"search\", to));\n    invariant(!to.pathname || !to.pathname.includes(\"#\"), getInvalidPathError(\"#\", \"pathname\", \"hash\", to));\n    invariant(!to.search || !to.search.includes(\"#\"), getInvalidPathError(\"#\", \"search\", \"hash\", to));\n  }\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n  let from;\n  // Routing is relative to the current pathname if explicitly requested.\n  //\n  // If a pathname is explicitly provided in `to`, it should be relative to the\n  // route context. This is explained in `Note on `<Link to>` values` in our\n  // migration guide from v5 as a means of disambiguation between `to` values\n  // that begin with `/` and those that do not. However, this is problematic for\n  // `to` values that do not provide a pathname. `to` can simply be a search or\n  // hash string, in which case we should assume that the navigation is relative\n  // to the current location's pathname and *not* the route pathname.\n  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n      to.pathname = toSegments.join(\"/\");\n    }\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n  let path = resolvePath(to, from);\n  // Ensure the pathname has a trailing slash if the original \"to\" had one\n  let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n    path.pathname += \"/\";\n  }\n  return path;\n}\n/**\n * @private\n */\nfunction getToPathname(to) {\n  // Empty strings should be treated the same as / paths\n  return to === \"\" || to.pathname === \"\" ? \"/\" : typeof to === \"string\" ? parsePath(to).pathname : to.pathname;\n}\n/**\n * @private\n */\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\nconst normalizeHash = hash => !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n */\nconst json = function json(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n  return new Response(JSON.stringify(data), _extends({}, responseInit, {\n    headers\n  }));\n};\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n  constructor(data, responseInit) {\n    this.pendingKeysSet = new Set();\n    this.subscribers = new Set();\n    this.deferredKeys = [];\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\");\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject;\n    this.abortPromise = new Promise((_, r) => reject = r);\n    this.controller = new AbortController();\n    let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n    this.data = Object.entries(data).reduce((acc, _ref2) => {\n      let [key, value] = _ref2;\n      return Object.assign(acc, {\n        [key]: this.trackPromise(key, value)\n      });\n    }, {});\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n    this.init = responseInit;\n  }\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n    Object.defineProperty(promise, \"_tracked\", {\n      get: () => true\n    });\n    return promise;\n  }\n  onSettle(promise, key, error, data) {\n    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      return Promise.reject(error);\n    }\n    this.pendingKeysSet.delete(key);\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\"Deferred data for key \\\"\" + key + \"\\\" resolved/rejected with `undefined`, \" + \"you must resolve/reject with a value or `null`.\");\n      Object.defineProperty(promise, \"_error\", {\n        get: () => undefinedError\n      });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    this.emit(false, key);\n    return data;\n  }\n  emit(aborted, settledKey) {\n    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));\n  }\n  subscribe(fn) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n  async resolveData(signal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise(resolve => {\n        this.subscribe(aborted => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n  get unwrappedData() {\n    invariant(this.data !== null && this.done, \"Can only unwrap data on initialized and settled deferreds\");\n    return Object.entries(this.data).reduce((acc, _ref3) => {\n      let [key, value] = _ref3;\n      return Object.assign(acc, {\n        [key]: unwrapTrackedPromise(value)\n      });\n    }, {});\n  }\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\nfunction isTrackedPromise(value) {\n  return value instanceof Promise && value._tracked === true;\n}\nfunction unwrapTrackedPromise(value) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\nconst defer = function defer(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  return new DeferredData(data, responseInit);\n};\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirect = function redirect(url, init) {\n  if (init === void 0) {\n    init = 302;\n  }\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = {\n      status: responseInit\n    };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n  return new Response(null, _extends({}, responseInit, {\n    headers\n  }));\n};\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nconst redirectDocument = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nclass ErrorResponseImpl {\n  constructor(status, statusText, data, internal) {\n    if (internal === void 0) {\n      internal = false;\n    }\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nfunction isRouteErrorResponse(error) {\n  return error != null && typeof error.status === \"number\" && typeof error.statusText === \"string\" && typeof error.internal === \"boolean\" && \"data\" in error;\n}\n\nconst validMutationMethodsArr = [\"post\", \"put\", \"patch\", \"delete\"];\nconst validMutationMethods = new Set(validMutationMethodsArr);\nconst validRequestMethodsArr = [\"get\", ...validMutationMethodsArr];\nconst validRequestMethods = new Set(validRequestMethodsArr);\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined\n};\nconst IDLE_BLOCKER = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined\n};\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nconst defaultMapRouteProperties = route => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary)\n});\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Create a router and listen to history POP navigations\n */\nfunction createRouter(init) {\n  const routerWindow = init.window ? init.window : typeof window !== \"undefined\" ? window : undefined;\n  const isBrowser = typeof routerWindow !== \"undefined\" && typeof routerWindow.document !== \"undefined\" && typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let mapRouteProperties;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Routes keyed by ID\n  let manifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);\n  let inFlightDataRoutes;\n  let basename = init.basename || \"/\";\n  // Config driven behavior flags\n  let future = _extends({\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false\n  }, init.future);\n  // Cleanup function for history\n  let unlistenHistory = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialErrors = null;\n  if (initialMatches == null) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname\n    });\n    let {\n      matches,\n      route\n    } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n  let initialized;\n  let hasLazyRoutes = initialMatches.some(m => m.route.lazy);\n  let hasLoaders = initialMatches.some(m => m.route.loader);\n  if (hasLazyRoutes) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!hasLoaders) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    initialized = initialMatches.every(m => m.route.loader && m.route.loader.hydrate !== true && (loaderData && loaderData[m.route.id] !== undefined || errors && errors[m.route.id] !== undefined));\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n  let router;\n  let state = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: init.hydrationData && init.hydrationData.loaderData || {},\n    actionData: init.hydrationData && init.hydrationData.actionData || null,\n    errors: init.hydrationData && init.hydrationData.errors || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map()\n  };\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction = Action.Pop;\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n  // AbortController for the active navigation\n  let pendingNavigationController;\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions = new Map();\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener = null;\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes = [];\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads = [];\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map();\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map();\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set();\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map();\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map();\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set();\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map();\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map();\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let ignoreNextHistoryUpdate = false;\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(_ref => {\n      let {\n        action: historyAction,\n        location,\n        delta\n      } = _ref;\n      // Ignore this event if it was just us resetting the URL from a\n      // blocked POP navigation\n      if (ignoreNextHistoryUpdate) {\n        ignoreNextHistoryUpdate = false;\n        return;\n      }\n      warning(blockerFunctions.size === 0 || delta != null, \"You are trying to use a blocker on a POP navigation to a location \" + \"that was not created by @remix-run/router. This will fail silently in \" + \"production. This can happen if you are navigating outside the router \" + \"via `window.history.pushState`/`window.location.hash` instead of using \" + \"router navigation APIs.  This can also happen if you are using \" + \"createHashRouter and the user manually changes the URL.\");\n      let blockerKey = shouldBlockNavigation({\n        currentLocation: state.location,\n        nextLocation: location,\n        historyAction\n      });\n      if (blockerKey && delta != null) {\n        // Restore the URL to match the current UI, but don't update router state\n        ignoreNextHistoryUpdate = true;\n        init.history.go(delta * -1);\n        // Put the blocker into a blocked state\n        updateBlocker(blockerKey, {\n          state: \"blocked\",\n          location,\n          proceed() {\n            updateBlocker(blockerKey, {\n              state: \"proceeding\",\n              proceed: undefined,\n              reset: undefined,\n              location\n            });\n            // Re-do the same POP navigation we just blocked\n            init.history.go(delta);\n          },\n          reset() {\n            let blockers = new Map(state.blockers);\n            blockers.set(blockerKey, IDLE_BLOCKER);\n            updateState({\n              blockers\n            });\n          }\n        });\n        return;\n      }\n      return startNavigation(historyAction, location);\n    });\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () => routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(Action.Pop, state.location, {\n        initialHydration: true\n      });\n    }\n    return router;\n  }\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n  // Subscribe to state updates for the router\n  function subscribe(fn) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n  // Update our state and notify the calling context of the change\n  function updateState(newState, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state = _extends({}, state, newState);\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers = [];\n    let deletedFetchersKeys = [];\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach(subscriber => subscriber(state, {\n      deletedFetchers: deletedFetchersKeys,\n      unstable_viewTransitionOpts: opts.viewTransitionOpts,\n      unstable_flushSync: opts.flushSync === true\n    }));\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach(key => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach(key => deleteFetcher(key));\n    }\n  }\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(location, newState, _temp) {\n    var _location$state, _location$state2;\n    let {\n      flushSync\n    } = _temp === void 0 ? {} : _temp;\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === \"loading\" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;\n    let actionData;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === Action.Replace) {\n      init.history.replace(location, location.state);\n    }\n    let viewTransitionOpts;\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === Action.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location\n      };\n    }\n    updateState(_extends({}, newState, {\n      actionData,\n      loaderData,\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset,\n      blockers\n    }), {\n      viewTransitionOpts,\n      flushSync: flushSync === true\n    });\n    // Reset stateful navigation vars\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n    cancelledFetcherLoads = [];\n  }\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(to, opts) {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n    let historyAction = Action.Push;\n    if (userReplace === true) {\n      historyAction = Action.Replace;\n    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = Action.Replace;\n    }\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction\n    });\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey, IDLE_BLOCKER);\n          updateState({\n            blockers\n          });\n        }\n      });\n      return;\n    }\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.unstable_viewTransition,\n      flushSync\n    });\n  }\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({\n      revalidation: \"loading\"\n    });\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true\n      });\n      return;\n    }\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(pendingAction || state.historyAction, state.navigation.location, {\n      overrideNavigation: state.navigation\n    });\n  }\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(historyAction, location, opts) {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(routesToUse);\n      // Cancel all pending deferred on 404s since we don't keep any routes\n      cancelActiveDeferreds();\n      completeNavigation(location, {\n        matches: notFoundMatches,\n        loaderData: {},\n        errors: {\n          [route.id]: error\n        }\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial load will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {\n      completeNavigation(location, {\n        matches\n      }, {\n        flushSync\n      });\n      return;\n    }\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);\n    let pendingActionData;\n    let pendingError;\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingError = {\n        [findNearestBoundary(matches).route.id]: opts.pendingError\n      };\n    } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {\n      // Call action if we received an action submission\n      let actionOutput = await handleAction(request, location, opts.submission, matches, {\n        replace: opts.replace,\n        flushSync\n      });\n      if (actionOutput.shortCircuited) {\n        return;\n      }\n      pendingActionData = actionOutput.pendingActionData;\n      pendingError = actionOutput.pendingActionError;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // Create a GET request for the loaders\n      request = new Request(request.url, {\n        signal: request.signal\n      });\n    }\n    // Call loaders\n    let {\n      shortCircuited,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionData, pendingError);\n    if (shortCircuited) {\n      return;\n    }\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n    completeNavigation(location, _extends({\n      matches\n    }, pendingActionData ? {\n      actionData: pendingActionData\n    } : {}, {\n      loaderData,\n      errors\n    }));\n  }\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(request, location, submission, matches, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    interruptActiveLoads();\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({\n      navigation\n    }, {\n      flushSync: opts.flushSync === true\n    });\n    // Call our action and get the result\n    let result;\n    let actionMatch = getTargetMatch(matches, location);\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id\n        })\n      };\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\n      if (request.signal.aborted) {\n        return {\n          shortCircuited: true\n        };\n      }\n    }\n    if (isRedirectResult(result)) {\n      let replace;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        replace = result.location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(state, result, {\n        submission,\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n      // By default, all submissions are REPLACE navigations, but if the\n      // action threw an error that'll be rendered in an errorElement, we fall\n      // back to PUSH so that the user can use the back button to get back to\n      // the pre-submission form location to try again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n      return {\n        // Send back an empty object we can use to clear out any prior actionData\n        pendingActionData: {},\n        pendingActionError: {\n          [boundaryMatch.route.id]: result.error\n        }\n      };\n    }\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    return {\n      pendingActionData: {\n        [actionMatch.route.id]: result.data\n      }\n    };\n  }\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(request, location, matches, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionData, pendingError) {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionData, pendingError);\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));\n    pendingNavigationLoadId = ++incrementingLoadId;\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(location, _extends({\n        matches,\n        loaderData: {},\n        // Commit pending error if we're short circuiting\n        errors: pendingError || null\n      }, pendingActionData ? {\n        actionData: pendingActionData\n      } : {}, updatedFetchers ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since iot's not a \"navigation\"\n    if (!isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration)) {\n      revalidatingFetchers.forEach(rf => {\n        let fetcher = state.fetchers.get(rf.key);\n        let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);\n        state.fetchers.set(rf.key, revalidatingFetcher);\n      });\n      let actionData = pendingActionData || state.actionData;\n      updateState(_extends({\n        navigation: loadingNavigation\n      }, actionData ? Object.keys(actionData).length === 0 ? {\n        actionData: null\n      } : {\n        actionData\n      } : {}, revalidatingFetchers.length > 0 ? {\n        fetchers: new Map(state.fetchers)\n      } : {}), {\n        flushSync\n      });\n    }\n    revalidatingFetchers.forEach(rf => {\n      if (fetchControllers.has(rf.key)) {\n        abortFetcher(rf.key);\n      }\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);\n    if (request.signal.aborted) {\n      return {\n        shortCircuited: true\n      };\n    }\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    }\n    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect(results);\n    if (redirect) {\n      if (redirect.idx >= matchesToLoad.length) {\n        // If this redirect came from a fetcher make sure we mark it in\n        // fetchRedirectIds so it doesn't get revalidated on the next set of\n        // loader executions\n        let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      await startRedirectNavigation(state, redirect.result, {\n        replace\n      });\n      return {\n        shortCircuited: true\n      };\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe(aborted => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n    return _extends({\n      loaderData,\n      errors\n    }, shouldUpdateFetchers ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(key, routeId, href, opts) {\n    if (isServer) {\n      throw new Error(\"router.fetch() was called during the server render, but it shouldn't be. \" + \"You are likely calling a useFetcher() method in the body of your component. \" + \"Try moving it to a useEffect or a callback.\");\n    }\n    if (fetchControllers.has(key)) abortFetcher(key);\n    let flushSync = (opts && opts.unstable_flushSync) === true;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n    if (!matches) {\n      setFetcherError(key, routeId, getInternalRouterError(404, {\n        pathname: normalizedPath\n      }), {\n        flushSync\n      });\n      return;\n    }\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);\n    if (error) {\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    let match = getTargetMatch(matches, path);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(key, routeId, path, match, matches, flushSync, submission);\n      return;\n    }\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, {\n      routeId,\n      path\n    });\n    handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission);\n  }\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(key, routeId, path, match, requestMatches, flushSync, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n    if (!match.route.action && !match.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: submission.formMethod,\n        pathname: path,\n        routeId: routeId\n      });\n      setFetcherError(key, routeId, error, {\n        flushSync\n      });\n      return;\n    }\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync\n    });\n    // Call the action for the fetcher\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let actionResult = await callLoaderOrAction(\"action\", fetchRequest, match, requestMatches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(state, actionResult, {\n            fetcherSubmission: submission\n          });\n        }\n      }\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n    }\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches = state.navigation.state !== \"idle\" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, {\n      [match.route.id]: actionResult.data\n    }, undefined // No need to send through errors since we short circuit above\n    );\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {\n      let staleKey = rf.key;\n      let existingFetcher = state.fetchers.get(staleKey);\n      let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);\n      state.fetchers.set(staleKey, revalidatingFetcher);\n      if (fetchControllers.has(staleKey)) {\n        abortFetcher(staleKey);\n      }\n      if (rf.controller) {\n        fetchControllers.set(staleKey, rf.controller);\n      }\n    });\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));\n    abortController.signal.addEventListener(\"abort\", abortPendingFetchRevalidations);\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n    if (abortController.signal.aborted) {\n      return;\n    }\n    abortController.signal.removeEventListener(\"abort\", abortPendingFetchRevalidations);\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));\n    let redirect = findRedirect(results);\n    if (redirect) {\n      if (redirect.idx >= matchesToLoad.length) {\n        // If this redirect came from a fetcher make sure we mark it in\n        // fetchRedirectIds so it doesn't get revalidated on the next set of\n        // loader executions\n        let fetcherKey = revalidatingFetchers[redirect.idx - matchesToLoad.length].key;\n        fetchRedirectIds.add(fetcherKey);\n      }\n      return startRedirectNavigation(state, redirect.result);\n    }\n    // Process and commit output from loaders\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n    abortStaleFetchLoads(loadId);\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (state.navigation.state === \"loading\" && loadId > pendingNavigationLoadId) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers)\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),\n        fetchers: new Map(state.fetchers)\n      });\n      isRevalidationRequired = false;\n    }\n  }\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(key, routeId, path, match, matches, flushSync, submission) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {\n      flushSync\n    });\n    // Call the loader for this fetcher route match\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);\n    fetchControllers.set(key, abortController);\n    let originatingLoadId = incrementingLoadId;\n    let result = await callLoaderOrAction(\"loader\", fetchRequest, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;\n    }\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(state, result);\n        return;\n      }\n    }\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(state, redirect, _temp2) {\n    let {\n      submission,\n      fetcherSubmission,\n      replace\n    } = _temp2 === void 0 ? {} : _temp2;\n    if (redirect.revalidate) {\n      isRevalidationRequired = true;\n    }\n    let redirectLocation = createLocation(state.location, redirect.location, {\n      _isRedirect: true\n    });\n    invariant(redirectLocation, \"Expected a location on the redirect navigation\");\n    if (isBrowser) {\n      let isDocumentReload = false;\n      if (redirect.reloadDocument) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(redirect.location)) {\n        const url = init.history.createURL(redirect.location);\n        isDocumentReload =\n        // Hard reload if it's an absolute URL to a new origin\n        url.origin !== routerWindow.location.origin ||\n        // Hard reload if it's an absolute URL that does not match our basename\n        stripBasename(url.pathname, basename) == null;\n      }\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(redirect.location);\n        } else {\n          routerWindow.location.assign(redirect.location);\n        }\n        return;\n      }\n    }\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true ? Action.Replace : Action.Push;\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let {\n      formMethod,\n      formAction,\n      formEncType\n    } = state.navigation;\n    if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (redirectPreserveMethodStatusCodes.has(redirect.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: _extends({}, activeSubmission, {\n          formAction: redirect.location\n        }),\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(redirectLocation, submission);\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve this flag across redirects\n        preventScrollReset: pendingPreventScrollReset\n      });\n    }\n  }\n  async function callLoadersAndMaybeResolveData(currentMatches, matches, matchesToLoad, fetchersToLoad, request) {\n    // Call all navigation loaders and revalidating fetcher loaders in parallel,\n    // then slice off the results into separate arrays so we can handle them\n    // accordingly\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath)), ...fetchersToLoad.map(f => {\n      if (f.matches && f.match && f.controller) {\n        return callLoaderOrAction(\"loader\", createClientSideRequest(init.history, f.path, f.controller.signal), f.match, f.matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath);\n      } else {\n        let error = {\n          type: ResultType.error,\n          error: getInternalRouterError(404, {\n            pathname: f.path\n          })\n        };\n        return error;\n      }\n    })]);\n    let loaderResults = results.slice(0, matchesToLoad.length);\n    let fetcherResults = results.slice(matchesToLoad.length);\n    await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, loaderResults.map(() => request.signal), false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(f => f.match), fetcherResults, fetchersToLoad.map(f => f.controller ? f.controller.signal : null), true)]);\n    return {\n      results,\n      loaderResults,\n      fetcherResults\n    };\n  }\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.push(key);\n        abortFetcher(key);\n      }\n    });\n  }\n  function updateFetcherState(key, fetcher, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function setFetcherError(key, routeId, error, opts) {\n    if (opts === void 0) {\n      opts = {};\n    }\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState({\n      errors: {\n        [boundaryMatch.route.id]: error\n      },\n      fetchers: new Map(state.fetchers)\n    }, {\n      flushSync: (opts && opts.flushSync) === true\n    });\n  }\n  function getFetcher(key) {\n    if (future.v7_fetcherPersist) {\n      activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n      // If this fetcher was previously marked for deletion, unmark it since we\n      // have a new instance\n      if (deletedFetchers.has(key)) {\n        deletedFetchers.delete(key);\n      }\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n  function deleteFetcher(key) {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (fetchControllers.has(key) && !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    deletedFetchers.delete(key);\n    state.fetchers.delete(key);\n  }\n  function deleteFetcherAndUpdateState(key) {\n    if (future.v7_fetcherPersist) {\n      let count = (activeFetchers.get(key) || 0) - 1;\n      if (count <= 0) {\n        activeFetchers.delete(key);\n        deletedFetchers.add(key);\n      } else {\n        activeFetchers.set(key, count);\n      }\n    } else {\n      deleteFetcher(key);\n    }\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n  }\n  function abortFetcher(key) {\n    let controller = fetchControllers.get(key);\n    invariant(controller, \"Expected fetch controller: \" + key);\n    controller.abort();\n    fetchControllers.delete(key);\n  }\n  function markFetchersDone(keys) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  function markFetchRedirectsDone() {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, \"Expected fetcher: \" + key);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n  function abortStaleFetchLoads(landedId) {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, \"Expected fetcher: \" + key);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n  function getBlocker(key, fn) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n    return blocker;\n  }\n  function deleteBlocker(key) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key, newBlocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(blocker.state === \"unblocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"blocked\" || blocker.state === \"blocked\" && newBlocker.state === \"proceeding\" || blocker.state === \"blocked\" && newBlocker.state === \"unblocked\" || blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\", \"Invalid blocker state transition: \" + blocker.state + \" -> \" + newBlocker.state);\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({\n      blockers\n    });\n  }\n  function shouldBlockNavigation(_ref2) {\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = _ref2;\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({\n      currentLocation,\n      nextLocation,\n      historyAction\n    })) {\n      return blockerKey;\n    }\n  }\n  function cancelActiveDeferreds(predicate) {\n    let cancelledRouteIds = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(positions, getPosition, getKey) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({\n          restoreScrollPosition: y\n        });\n      }\n    }\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n  function getScrollKey(location, matches) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));\n      return key || location.key;\n    }\n    return location.key;\n  }\n  function saveScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n  function getSavedScrollPosition(location, matches) {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n  function _internalSetRoutes(newRoutes) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);\n  }\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: to => init.history.createHref(to),\n    encodeLocation: to => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes\n  };\n  return router;\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\nconst UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\nfunction createStaticHandler(routes, opts) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to createStaticHandler\");\n  let manifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties;\n  if (opts != null && opts.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts != null && opts.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = route => ({\n      hasErrorBoundary: detectErrorBoundary(route)\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future = _extends({\n    v7_relativeSplatPath: false\n  }, opts ? opts.future : null);\n  let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   */\n  async function query(request, _temp3) {\n    let {\n      requestContext\n    } = _temp3 === void 0 ? {} : _temp3;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, {\n        method\n      });\n      let {\n        matches: methodNotAllowedMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n      let {\n        matches: notFoundMatches,\n        route\n      } = getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let result = await queryImpl(request, location, matches, requestContext);\n    if (isResponse(result)) {\n      return result;\n    }\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return _extends({\n      location,\n      basename\n    }, result);\n  }\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   */\n  async function queryRoute(request, _temp4) {\n    let {\n      routeId,\n      requestContext\n    } = _temp4 === void 0 ? {} : _temp4;\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, {\n        method\n      });\n    } else if (!matches) {\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, {\n        pathname: location.pathname\n      });\n    }\n    let result = await queryImpl(request, location, matches, requestContext, match);\n    if (isResponse(result)) {\n      return result;\n    }\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n    if (result.loaderData) {\n      var _result$activeDeferre;\n      let data = Object.values(result.loaderData)[0];\n      if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n    return undefined;\n  }\n  async function queryImpl(request, location, matches, requestContext, routeMatch) {\n    invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, routeMatch != null);\n        return result;\n      }\n      let result = await loadRouteData(request, matches, requestContext, routeMatch);\n      return isResponse(result) ? result : _extends({}, result, {\n        actionData: null,\n        actionHeaders: {}\n      });\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction, we throw\n      // it to bail out and then return or throw here based on whether the user\n      // returned or threw\n      if (isQueryRouteResponse(e)) {\n        if (e.type === ResultType.error) {\n          throw e.response;\n        }\n        return e.response;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n  async function submit(request, matches, actionMatch, requestContext, isRouteRequest) {\n    let result;\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath, {\n        isStaticRequest: true,\n        isRouteRequest,\n        requestContext\n      });\n      if (request.signal.aborted) {\n        let method = isRouteRequest ? \"queryRoute\" : \"query\";\n        throw new Error(method + \"() call aborted: \" + request.method + \" \" + request.url);\n      }\n    }\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.status,\n        headers: {\n          Location: result.location\n        }\n      });\n    }\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, {\n        type: \"defer-action\"\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error\n      };\n    }\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: {\n          [actionMatch.route.id]: result.data\n        },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n      let context = await loadRouteData(request, matches, requestContext, undefined, {\n        [boundaryMatch.route.id]: result.error\n      });\n      // action status codes take precedence over loader status codes\n      return _extends({}, context, {\n        statusCode: isRouteErrorResponse(result.error) ? result.error.status : 500,\n        actionData: null,\n        actionHeaders: _extends({}, result.headers ? {\n          [actionMatch.route.id]: result.headers\n        } : {})\n      });\n    }\n    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal\n    });\n    let context = await loadRouteData(loaderRequest, matches, requestContext);\n    return _extends({}, context, result.statusCode ? {\n      statusCode: result.statusCode\n    } : {}, {\n      actionData: {\n        [actionMatch.route.id]: result.data\n      },\n      actionHeaders: _extends({}, result.headers ? {\n        [actionMatch.route.id]: result.headers\n      } : {})\n    });\n  }\n  async function loadRouteData(request, matches, requestContext, routeMatch, pendingActionError) {\n    let isRouteRequest = routeMatch != null;\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch == null ? void 0 : routeMatch.route.id\n      });\n    }\n    let requestMatches = routeMatch ? [routeMatch] : getLoaderMatchesUntilBoundary(matches, Object.keys(pendingActionError || {})[0]);\n    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce((acc, m) => Object.assign(acc, {\n          [m.route.id]: null\n        }), {}),\n        errors: pendingActionError || null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null\n      };\n    }\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, manifest, mapRouteProperties, basename, future.v7_relativeSplatPath, {\n      isStaticRequest: true,\n      isRouteRequest,\n      requestContext\n    }))]);\n    if (request.signal.aborted) {\n      let method = isRouteRequest ? \"queryRoute\" : \"query\";\n      throw new Error(method + \"() call aborted: \" + request.method + \" \" + request.url);\n    }\n    // Process and commit output from loaders\n    let activeDeferreds = new Map();\n    let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionError, activeDeferreds);\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));\n    matches.forEach(match => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n    return _extends({}, context, {\n      matches,\n      activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null\n    });\n  }\n  return {\n    dataRoutes,\n    query,\n    queryRoute\n  };\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nfunction getStaticContextFromError(routes, context, error) {\n  let newContext = _extends({}, context, {\n    statusCode: 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error\n    }\n  });\n  return newContext;\n}\nfunction isSubmissionNavigation(opts) {\n  return opts != null && (\"formData\" in opts && opts.formData != null || \"body\" in opts && opts.body !== undefined);\n}\nfunction normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {\n  let contextualMatches;\n  let activeRouteMatch;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n  // Resolve the relative path\n  let path = resolveTo(to ? to : \".\", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === \"path\");\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n  // Add an ?index param for matched index routes if we don't already have one\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch && activeRouteMatch.route.index && !hasNakedIndexQuery(path.search)) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n  }\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return {\n      path\n    };\n  }\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, {\n        method: opts.formMethod\n      })\n    };\n  }\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, {\n      type: \"invalid-body\"\n    })\n  });\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();\n  let formAction = stripHashFromPath(path);\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      let text = typeof opts.body === \"string\" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?\n      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n      Array.from(opts.body.entries()).reduce((acc, _ref3) => {\n        let [name, value] = _ref3;\n        return \"\" + acc + name + \"=\" + value + \"\\n\";\n      }, \"\") : String(opts.body);\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text\n        }\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n      try {\n        let json = typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined\n          }\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n  invariant(typeof FormData === \"function\", \"FormData is not available in this environment\");\n  let searchParams;\n  let formData;\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n  let submission = {\n    formMethod,\n    formAction,\n    formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined\n  };\n  if (isMutationMethod(submission.formMethod)) {\n    return {\n      path,\n      submission\n    };\n  }\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = \"?\" + searchParams;\n  return {\n    path: createPath(parsedPath),\n    submission\n  };\n}\n// Filter out all routes below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId) {\n  let boundaryMatches = matches;\n  if (boundaryId) {\n    let index = matches.findIndex(m => m.route.id === boundaryId);\n    if (index >= 0) {\n      boundaryMatches = matches.slice(0, index);\n    }\n  }\n  return boundaryMatches;\n}\nfunction getMatchesToLoad(history, state, matches, submission, location, isInitialLoad, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionData, pendingError) {\n  let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;\n  let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let {\n      route\n    } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n    if (route.loader == null) {\n      return false;\n    }\n    if (isInitialLoad) {\n      if (route.loader.hydrate) {\n        return true;\n      }\n      return state.loaderData[route.id] === undefined && (\n      // Don't re-run if the loader ran and threw an error\n      !state.errors || state.errors[route.id] === undefined);\n    }\n    // Always call the loader on new route instances and pending defer cancellations\n    if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {\n      return true;\n    }\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n    return shouldRevalidateLoader(match, _extends({\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params\n    }, submission, {\n      actionResult,\n      defaultShouldRevalidate:\n      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n      isRevalidationRequired ||\n      // Clicked the same link, resubmitted a GET form\n      currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||\n      // Search params affect all loaders\n      currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)\n    }));\n  });\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial load (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (isInitialLoad || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {\n      return;\n    }\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null\n      });\n      return;\n    }\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.includes(key)) {\n      // Always revalidate if the fetcher was cancelled\n      shouldRevalidate = true;\n    } else if (fetcher && fetcher.state !== \"idle\" && fetcher.data === undefined) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params\n      }, submission, {\n        actionResult,\n        defaultShouldRevalidate: isRevalidationRequired\n      }));\n    }\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController()\n      });\n    }\n  });\n  return [navigationMatches, revalidatingFetchers];\n}\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n  let isNew =\n  // [a] -> [a, b]\n  !currentMatch ||\n  // [a, b] -> [a, c]\n  match.route.id !== currentMatch.route.id;\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\nfunction isNewRouteInstance(currentMatch, match) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    currentPath != null && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\nfunction shouldRevalidateLoader(loaderMatch, arg) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n  return arg.defaultShouldRevalidate;\n}\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(route, mapRouteProperties, manifest) {\n  if (!route.lazy) {\n    return;\n  }\n  let lazyRoute = await route.lazy();\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue = routeToUpdate[lazyRouteProperty];\n    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&\n    // This property isn't static since it should always be updated based\n    // on the route updates\n    lazyRouteProperty !== \"hasErrorBoundary\";\n    warning(!isPropertyStaticallyDefined, \"Route \\\"\" + routeToUpdate.id + \"\\\" has a static property \\\"\" + lazyRouteProperty + \"\\\" \" + \"defined but its lazy function is also returning a value for this property. \" + (\"The lazy route property \\\"\" + lazyRouteProperty + \"\\\" will be ignored.\"));\n    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {\n      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];\n    }\n  }\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {\n    lazy: undefined\n  }));\n}\nasync function callLoaderOrAction(type, request, match, matches, manifest, mapRouteProperties, basename, v7_relativeSplatPath, opts) {\n  if (opts === void 0) {\n    opts = {};\n  }\n  let resultType;\n  let result;\n  let onReject;\n  let runHandler = handler => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject;\n    let abortPromise = new Promise((_, r) => reject = r);\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n    return Promise.race([handler({\n      request,\n      params: match.params,\n      context: opts.requestContext\n    }), abortPromise]);\n  };\n  try {\n    let handler = match.route[type];\n    if (match.route.lazy) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let values = await Promise.all([\n        // If the handler throws, don't let it immediately bubble out,\n        // since we need to let the lazy() execution finish so we know if this\n        // route has a boundary that can handle the error\n        runHandler(handler).catch(e => {\n          handlerError = e;\n        }), loadLazyRouteModule(match.route, mapRouteProperties, manifest)]);\n        if (handlerError) {\n          throw handlerError;\n        }\n        result = values[0];\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadLazyRouteModule(match.route, mapRouteProperties, manifest);\n        handler = match.route[type];\n        if (handler) {\n          // Handler still run even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return {\n            type: ResultType.data,\n            data: undefined\n          };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n    invariant(result !== undefined, \"You defined \" + (type === \"action\" ? \"an action\" : \"a loader\") + \" for route \" + (\"\\\"\" + match.route.id + \"\\\" but didn't return anything from your `\" + type + \"` \") + \"function. Please return a value or `null`.\");\n  } catch (e) {\n    resultType = ResultType.error;\n    result = e;\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n  if (isResponse(result)) {\n    let status = result.status;\n    // Process redirects\n    if (redirectStatusCodes.has(status)) {\n      let location = result.headers.get(\"Location\");\n      invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\");\n      // Support relative routing in internal redirects\n      if (!ABSOLUTE_URL_REGEX.test(location)) {\n        location = normalizeTo(new URL(request.url), matches.slice(0, matches.indexOf(match) + 1), basename, true, location, v7_relativeSplatPath);\n      } else if (!opts.isStaticRequest) {\n        // Strip off the protocol+origin for same-origin + same-basename absolute\n        // redirects. If this is a static request, we can let it go back to the\n        // browser as-is\n        let currentUrl = new URL(request.url);\n        let url = location.startsWith(\"//\") ? new URL(currentUrl.protocol + location) : new URL(location);\n        let isSameBasename = stripBasename(url.pathname, basename) != null;\n        if (url.origin === currentUrl.origin && isSameBasename) {\n          location = url.pathname + url.search + url.hash;\n        }\n      }\n      // Don't process redirects in the router during static requests requests.\n      // Instead, throw the Response and let the server handle it with an HTTP\n      // redirect.  We also update the Location header in place in this flow so\n      // basename and relative routing is taken into account\n      if (opts.isStaticRequest) {\n        result.headers.set(\"Location\", location);\n        throw result;\n      }\n      return {\n        type: ResultType.redirect,\n        status,\n        location,\n        revalidate: result.headers.get(\"X-Remix-Revalidate\") !== null,\n        reloadDocument: result.headers.get(\"X-Remix-Reload-Document\") !== null\n      };\n    }\n    // For SSR single-route requests, we want to hand Responses back directly\n    // without unwrapping.  We do this with the QueryRouteResponse wrapper\n    // interface so we can know whether it was returned or thrown\n    if (opts.isRouteRequest) {\n      let queryRouteResponse = {\n        type: resultType === ResultType.error ? ResultType.error : ResultType.data,\n        response: result\n      };\n      throw queryRouteResponse;\n    }\n    let data;\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n    if (resultType === ResultType.error) {\n      return {\n        type: resultType,\n        error: new ErrorResponseImpl(status, result.statusText, data),\n        headers: result.headers\n      };\n    }\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers\n    };\n  }\n  if (resultType === ResultType.error) {\n    return {\n      type: resultType,\n      error: result\n    };\n  }\n  if (isDeferredData(result)) {\n    var _result$init, _result$init2;\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,\n      headers: ((_result$init2 = result.init) == null ? void 0 : _result$init2.headers) && new Headers(result.init.headers)\n    };\n  }\n  return {\n    type: ResultType.data,\n    data: result\n  };\n}\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(history, location, signal, submission) {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let {\n      formMethod,\n      formEncType\n    } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({\n        \"Content-Type\": formEncType\n      });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (formEncType === \"application/x-www-form-urlencoded\" && submission.formData) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n  return new Request(url, init);\n}\nfunction convertFormDataToSearchParams(formData) {\n  let searchParams = new URLSearchParams();\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n  return searchParams;\n}\nfunction convertSearchParamsToFormData(searchParams) {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\nfunction processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds) {\n  // Fill in loaderData/errors from our loaders\n  let loaderData = {};\n  let errors = null;\n  let statusCode;\n  let foundError = false;\n  let loaderHeaders = {};\n  // Process loader results into state.loaderData/state.errors\n  results.forEach((result, index) => {\n    let id = matchesToLoad[index].route.id;\n    invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n    if (isErrorResult(result)) {\n      // Look upwards from the matched route for the closest ancestor\n      // error boundary, defaulting to the root match\n      let boundaryMatch = findNearestBoundary(matches, id);\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError) {\n        error = Object.values(pendingError)[0];\n        pendingError = undefined;\n      }\n      errors = errors || {};\n      // Prefer higher error values if lower errors bubble to the same boundary\n      if (errors[boundaryMatch.route.id] == null) {\n        errors[boundaryMatch.route.id] = error;\n      }\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n      } else {\n        loaderData[id] = result.data;\n      }\n      // Error status codes always override success status codes, but if all\n      // loaders are successful we take the deepest status code.\n      if (result.statusCode != null && result.statusCode !== 200 && !foundError) {\n        statusCode = result.statusCode;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    }\n  });\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError) {\n    errors = pendingError;\n    loaderData[Object.keys(pendingError)[0]] = undefined;\n  }\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders\n  };\n}\nfunction processLoaderData(state, matches, matchesToLoad, results, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds) {\n  let {\n    loaderData,\n    errors\n  } = processRouteLoaderData(matches, matchesToLoad, results, pendingError, activeDeferreds);\n  // Process results from our revalidating fetchers\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let {\n      key,\n      match,\n      controller\n    } = revalidatingFetchers[index];\n    invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, \"Did not find corresponding fetcher result\");\n    let result = fetcherResults[index];\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      continue;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = _extends({}, errors, {\n          [boundaryMatch.route.id]: result.error\n        });\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n  return {\n    loaderData,\n    errors\n  };\n}\nfunction mergeLoaderData(loaderData, newLoaderData, matches, errors) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(matches, routeId) {\n  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];\n  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];\n}\nfunction getShortCircuitMatches(routes) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-error-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route\n  };\n}\nfunction getInternalRouterError(status, _temp5) {\n  let {\n    pathname,\n    routeId,\n    method,\n    type\n  } = _temp5 === void 0 ? {} : _temp5;\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide a `loader` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = \"Route \\\"\" + routeId + \"\\\" does not match URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = \"No route matches URL \\\"\" + pathname + \"\\\"\";\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage = \"You made a \" + method.toUpperCase() + \" request to \\\"\" + pathname + \"\\\" but \" + (\"did not provide an `action` for route \\\"\" + routeId + \"\\\", \") + \"so there is no way to handle the request.\";\n    } else if (method) {\n      errorMessage = \"Invalid request method \\\"\" + method.toUpperCase() + \"\\\"\";\n    }\n  }\n  return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);\n}\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(results) {\n  for (let i = results.length - 1; i >= 0; i--) {\n    let result = results[i];\n    if (isRedirectResult(result)) {\n      return {\n        result,\n        idx: i\n      };\n    }\n  }\n}\nfunction stripHashFromPath(path) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath(_extends({}, parsedPath, {\n    hash: \"\"\n  }));\n}\nfunction isHashChangeOnly(a, b) {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\nfunction isDeferredResult(result) {\n  return result.type === ResultType.deferred;\n}\nfunction isErrorResult(result) {\n  return result.type === ResultType.error;\n}\nfunction isRedirectResult(result) {\n  return (result && result.type) === ResultType.redirect;\n}\nfunction isDeferredData(value) {\n  let deferred = value;\n  return deferred && typeof deferred === \"object\" && typeof deferred.data === \"object\" && typeof deferred.subscribe === \"function\" && typeof deferred.cancel === \"function\" && typeof deferred.resolveData === \"function\";\n}\nfunction isResponse(value) {\n  return value != null && typeof value.status === \"number\" && typeof value.statusText === \"string\" && typeof value.headers === \"object\" && typeof value.body !== \"undefined\";\n}\nfunction isRedirectResponse(result) {\n  if (!isResponse(result)) {\n    return false;\n  }\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\nfunction isQueryRouteResponse(obj) {\n  return obj && isResponse(obj.response) && (obj.type === ResultType.data || obj.type === ResultType.error);\n}\nfunction isValidMethod(method) {\n  return validRequestMethods.has(method.toLowerCase());\n}\nfunction isMutationMethod(method) {\n  return validMutationMethods.has(method.toLowerCase());\n}\nasync function resolveDeferredResults(currentMatches, matchesToLoad, results, signals, isFetcher, currentLoaderData) {\n  for (let index = 0; index < results.length; index++) {\n    let result = results[index];\n    let match = matchesToLoad[index];\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);\n    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n    if (isDeferredResult(result) && (isFetcher || isRevalidatingLoader)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      let signal = signals[index];\n      invariant(signal, \"Expected an AbortSignal for revalidating fetcher deferred result\");\n      await resolveDeferredData(result, signal, isFetcher).then(result => {\n        if (result) {\n          results[index] = result || results[index];\n        }\n      });\n    }\n  }\n}\nasync function resolveDeferredData(result, signal, unwrap) {\n  if (unwrap === void 0) {\n    unwrap = false;\n  }\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e\n      };\n    }\n  }\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data\n  };\n}\nfunction hasNakedIndexQuery(search) {\n  return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n}\nfunction getTargetMatch(matches, location) {\n  let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || \"\")) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\nfunction getSubmissionFromNavigation(navigation) {\n  let {\n    formMethod,\n    formAction,\n    formEncType,\n    text,\n    formData,\n    json\n  } = navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined\n    };\n  }\n}\nfunction getLoadingNavigation(location, submission) {\n  if (submission) {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text\n    };\n    return navigation;\n  } else {\n    let navigation = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined\n    };\n    return navigation;\n  }\n}\nfunction getSubmittingNavigation(location, submission) {\n  let navigation = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text\n  };\n  return navigation;\n}\nfunction getLoadingFetcher(submission, data) {\n  if (submission) {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data\n    };\n    return fetcher;\n  } else {\n    let fetcher = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data\n    };\n    return fetcher;\n  }\n}\nfunction getSubmittingFetcher(submission, existingFetcher) {\n  let fetcher = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined\n  };\n  return fetcher;\n}\nfunction getDoneFetcher(data) {\n  let fetcher = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data\n  };\n  return fetcher;\n}\nfunction restoreAppliedTransitions(_window, transitions) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\nfunction persistAppliedTransitions(_window, transitions) {\n  if (transitions.size > 0) {\n    let json = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));\n    } catch (error) {\n      warning(false, \"Failed to save applied view transitions in sessionStorage (\" + error + \").\");\n    }\n  }\n}\n//#endregion\n\nexport { AbortedDeferredError, Action, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, getResolveToMatches as UNSAFE_getResolveToMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, defer, generatePath, getStaticContextFromError, getToPathname, isDeferredData, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, redirectDocument, resolvePath, resolveTo, stripBasename };\n//# sourceMappingURL=router.js.map\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\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\tvar nativeCodeString = '[native code]';\n\n\tfunction classNames() {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tif (arg.length) {\n\t\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\t\tif (inner) {\n\t\t\t\t\t\tclasses.push(inner);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\t\t\tclasses.push(arg.toString());\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar isArray = require('../internals/is-array');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Safari < 13 does not throw an error in this case\nvar SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {\n  // makes no sense without proper strict mode support\n  if (this !== undefined) return true;\n  try {\n    // eslint-disable-next-line es/no-object-defineproperty -- safe\n    Object.defineProperty([], 'length', { writable: false }).length = 1;\n  } catch (error) {\n    return error instanceof TypeError;\n  }\n}();\n\nmodule.exports = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {\n  if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {\n    throw $TypeError('Cannot set read only .length');\n  } return O.length = length;\n} : function (O, length) {\n  return O.length = length;\n};\n","var anObject = require('../internals/an-object');\nvar iteratorClose = require('../internals/iterator-close');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n  try {\n    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n  } catch (error) {\n    iteratorClose(iterator, 'throw', error);\n  }\n};\n","// `CreateIterResultObject` abstract operation\n// https://tc39.es/ecma262/#sec-createiterresultobject\nmodule.exports = function (value, done) {\n  return { value: value, done: done };\n};\n","var defineBuiltIn = require('../internals/define-built-in');\n\nmodule.exports = function (target, src, options) {\n  for (var key in src) defineBuiltIn(target, key, src[key], options);\n  return target;\n};\n","var $TypeError = TypeError;\nvar MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991\n\nmodule.exports = function (it) {\n  if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');\n  return it;\n};\n","var classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n  return classof(argument) == 'Array';\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar create = require('../internals/object-create');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar InternalStateModule = require('../internals/internal-state');\nvar getMethod = require('../internals/get-method');\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar ITERATOR_HELPER = 'IteratorHelper';\nvar WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator';\nvar setInternalState = InternalStateModule.set;\n\nvar createIteratorProxyPrototype = function (IS_ITERATOR) {\n  var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);\n\n  return defineBuiltIns(create(IteratorPrototype), {\n    next: function next() {\n      var state = getInternalState(this);\n      // for simplification:\n      //   for `%WrapForValidIteratorPrototype%.next` our `nextHandler` returns `IterResultObject`\n      //   for `%IteratorHelperPrototype%.next` - just a value\n      if (IS_ITERATOR) return state.nextHandler();\n      try {\n        var result = state.done ? undefined : state.nextHandler();\n        return createIterResultObject(result, state.done);\n      } catch (error) {\n        state.done = true;\n        throw error;\n      }\n    },\n    'return': function () {\n      var state = getInternalState(this);\n      var iterator = state.iterator;\n      state.done = true;\n      if (IS_ITERATOR) {\n        var returnMethod = getMethod(iterator, 'return');\n        return returnMethod ? call(returnMethod, iterator) : createIterResultObject(undefined, true);\n      }\n      if (state.inner) try {\n        iteratorClose(state.inner.iterator, 'normal');\n      } catch (error) {\n        return iteratorClose(iterator, 'throw', error);\n      }\n      iteratorClose(iterator, 'normal');\n      return createIterResultObject(undefined, true);\n    }\n  });\n};\n\nvar WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);\nvar IteratorHelperPrototype = createIteratorProxyPrototype(false);\n\ncreateNonEnumerableProperty(IteratorHelperPrototype, TO_STRING_TAG, 'Iterator Helper');\n\nmodule.exports = function (nextHandler, IS_ITERATOR) {\n  var IteratorProxy = function Iterator(record, state) {\n    if (state) {\n      state.iterator = record.iterator;\n      state.next = record.next;\n    } else state = record;\n    state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;\n    state.nextHandler = nextHandler;\n    state.counter = 0;\n    state.done = false;\n    setInternalState(this, state);\n  };\n\n  IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;\n\n  return IteratorProxy;\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar getIteratorDirect = require('../internals/get-iterator-direct');\nvar createIteratorProxy = require('../internals/iterator-create-proxy');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\n\nvar IteratorProxy = createIteratorProxy(function () {\n  var iterator = this.iterator;\n  var result = anObject(call(this.next, iterator));\n  var done = this.done = !!result.done;\n  if (!done) return callWithSafeIterationClosing(iterator, this.mapper, [result.value, this.counter++], true);\n});\n\n// `Iterator.prototype.map` method\n// https://github.com/tc39/proposal-iterator-helpers\nmodule.exports = function map(mapper) {\n  anObject(this);\n  aCallable(mapper);\n  return new IteratorProxy(getIteratorDirect(this), {\n    mapper: mapper\n  });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar setArrayLength = require('../internals/array-set-length');\nvar doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');\nvar fails = require('../internals/fails');\n\nvar INCORRECT_TO_LENGTH = fails(function () {\n  return [].push.call({ length: 0x100000000 }, 1) !== 4294967297;\n});\n\n// V8 and Safari <= 15.4, FF < 23 throws InternalError\n// https://bugs.chromium.org/p/v8/issues/detail?id=12681\nvar properErrorOnNonWritableLength = function () {\n  try {\n    // eslint-disable-next-line es/no-object-defineproperty -- safe\n    Object.defineProperty([], 'length', { writable: false }).push();\n  } catch (error) {\n    return error instanceof TypeError;\n  }\n};\n\nvar FORCED = INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength();\n\n// `Array.prototype.push` method\n// https://tc39.es/ecma262/#sec-array.prototype.push\n$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {\n  // eslint-disable-next-line no-unused-vars -- required for `.length`\n  push: function push(item) {\n    var O = toObject(this);\n    var len = lengthOfArrayLike(O);\n    var argCount = arguments.length;\n    doesNotExceedSafeInteger(len + argCount);\n    for (var i = 0; i < argCount; i++) {\n      O[len] = arguments[i];\n      len++;\n    }\n    setArrayLength(O, len);\n    return len;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar getIteratorDirect = require('../internals/get-iterator-direct');\nvar createIteratorProxy = require('../internals/iterator-create-proxy');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\n\nvar IteratorProxy = createIteratorProxy(function () {\n  var iterator = this.iterator;\n  var predicate = this.predicate;\n  var next = this.next;\n  var result, done, value;\n  while (true) {\n    result = anObject(call(next, iterator));\n    done = this.done = !!result.done;\n    if (done) return;\n    value = result.value;\n    if (callWithSafeIterationClosing(iterator, predicate, [value, this.counter++], true)) return value;\n  }\n});\n\n// `Iterator.prototype.filter` method\n// https://github.com/tc39/proposal-iterator-helpers\n$({ target: 'Iterator', proto: true, real: true }, {\n  filter: function filter(predicate) {\n    anObject(this);\n    aCallable(predicate);\n    return new IteratorProxy(getIteratorDirect(this), {\n      predicate: predicate\n    });\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar iterate = require('../internals/iterate');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar getIteratorDirect = require('../internals/get-iterator-direct');\n\n// `Iterator.prototype.forEach` method\n// https://github.com/tc39/proposal-iterator-helpers\n$({ target: 'Iterator', proto: true, real: true }, {\n  forEach: function forEach(fn) {\n    anObject(this);\n    aCallable(fn);\n    var record = getIteratorDirect(this);\n    var counter = 0;\n    iterate(record, function (value) {\n      fn(value, counter++);\n    }, { IS_RECORD: true });\n  }\n});\n","var $ = require('../internals/export');\nvar map = require('../internals/iterator-map');\n\n// `Iterator.prototype.map` method\n// https://github.com/tc39/proposal-iterator-helpers\n$({ target: 'Iterator', proto: true, real: true }, {\n  map: map\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar iterate = require('../internals/iterate');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar getIteratorDirect = require('../internals/get-iterator-direct');\n\n// `Iterator.prototype.some` method\n// https://github.com/tc39/proposal-iterator-helpers\n$({ target: 'Iterator', proto: true, real: true }, {\n  some: function some(predicate) {\n    anObject(this);\n    aCallable(predicate);\n    var record = getIteratorDirect(this);\n    var counter = 0;\n    return iterate(record, function (value, stop) {\n      if (predicate(value, counter++)) return stop();\n    }, { IS_RECORD: true, INTERRUPTED: true }).stopped;\n  }\n});\n","var baseKeys = require('./_baseKeys'),\n    getTag = require('./_getTag'),\n    isArguments = require('./isArguments'),\n    isArray = require('./isArray'),\n    isArrayLike = require('./isArrayLike'),\n    isBuffer = require('./isBuffer'),\n    isPrototype = require('./_isPrototype'),\n    isTypedArray = require('./isTypedArray');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n    setTag = '[object Set]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if `value` is an empty object, collection, map, or set.\n *\n * Objects are considered empty if they have no own enumerable string keyed\n * properties.\n *\n * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n * jQuery-like collections are considered empty if they have a `length` of `0`.\n * Similarly, maps and sets are considered empty if they have a `size` of `0`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n * @example\n *\n * _.isEmpty(null);\n * // => true\n *\n * _.isEmpty(true);\n * // => true\n *\n * _.isEmpty(1);\n * // => true\n *\n * _.isEmpty([1, 2, 3]);\n * // => false\n *\n * _.isEmpty({ 'a': 1 });\n * // => false\n */\nfunction isEmpty(value) {\n  if (value == null) {\n    return true;\n  }\n  if (isArrayLike(value) &&\n      (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n        isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n    return !value.length;\n  }\n  var tag = getTag(value);\n  if (tag == mapTag || tag == setTag) {\n    return !value.size;\n  }\n  if (isPrototype(value)) {\n    return !baseKeys(value).length;\n  }\n  for (var key in value) {\n    if (hasOwnProperty.call(value, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nmodule.exports = isEmpty;\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","function _classCallCheck(a, n) {\n  if (!(a instanceof n)) throw new TypeError(\"Cannot call a class as a function\");\n}\nexport { _classCallCheck as default };","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(e, r) {\n  for (var t = 0; t < r.length; t++) {\n    var o = r[t];\n    o.enumerable = o.enumerable || !1, o.configurable = !0, \"value\" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);\n  }\n}\nfunction _createClass(e, r, t) {\n  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, \"prototype\", {\n    writable: !1\n  }), e;\n}\nexport { _createClass as default };","function _setPrototypeOf(t, e) {\n  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {\n    return t.__proto__ = e, t;\n  }, _setPrototypeOf(t, e);\n}\nexport { _setPrototypeOf as default };","import setPrototypeOf from \"./setPrototypeOf.js\";\nfunction _inherits(t, e) {\n  if (\"function\" != typeof e && null !== e) throw new TypeError(\"Super expression must either be null or a function\");\n  t.prototype = Object.create(e && e.prototype, {\n    constructor: {\n      value: t,\n      writable: !0,\n      configurable: !0\n    }\n  }), Object.defineProperty(t, \"prototype\", {\n    writable: !1\n  }), e && setPrototypeOf(t, e);\n}\nexport { _inherits as default };","function _getPrototypeOf(t) {\n  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {\n    return t.__proto__ || Object.getPrototypeOf(t);\n  }, _getPrototypeOf(t);\n}\nexport { _getPrototypeOf as default };","function _isNativeReflectConstruct() {\n  try {\n    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n  } catch (t) {}\n  return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {\n    return !!t;\n  })();\n}\nexport { _isNativeReflectConstruct as default };","function _assertThisInitialized(e) {\n  if (void 0 === e) throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  return e;\n}\nexport { _assertThisInitialized as default };","import getPrototypeOf from \"./getPrototypeOf.js\";\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct.js\";\nimport possibleConstructorReturn from \"./possibleConstructorReturn.js\";\nfunction _createSuper(t) {\n  var r = isNativeReflectConstruct();\n  return function () {\n    var e,\n      o = getPrototypeOf(t);\n    if (r) {\n      var s = getPrototypeOf(this).constructor;\n      e = Reflect.construct(o, arguments, s);\n    } else e = o.apply(this, arguments);\n    return possibleConstructorReturn(this, e);\n  };\n}\nexport { _createSuper as default };","import _typeof from \"./typeof.js\";\nimport assertThisInitialized from \"./assertThisInitialized.js\";\nfunction _possibleConstructorReturn(t, e) {\n  if (e && (\"object\" == _typeof(e) || \"function\" == typeof e)) return e;\n  if (void 0 !== e) throw new TypeError(\"Derived constructors may only return object or undefined\");\n  return assertThisInitialized(t);\n}\nexport { _possibleConstructorReturn as default };","/* eslint-disable no-console */\nvar warned = {};\nvar preWarningFns = [];\n\n/**\n * Pre warning enable you to parse content before console.error.\n * Modify to null will prevent warning.\n */\nexport var preMessage = function preMessage(fn) {\n  preWarningFns.push(fn);\n};\n\n/**\n * Warning if condition not match.\n * @param valid Condition\n * @param message Warning message\n * @example\n * ```js\n * warning(false, 'some error'); // print some error\n * warning(true, 'some error'); // print nothing\n * warning(1 === 2, 'some error'); // print some error\n * ```\n */\nexport function warning(valid, message) {\n  if (process.env.NODE_ENV !== 'production' && !valid && console !== undefined) {\n    var finalMessage = preWarningFns.reduce(function (msg, preMessageFn) {\n      return preMessageFn(msg !== null && msg !== void 0 ? msg : '', 'warning');\n    }, message);\n    if (finalMessage) {\n      console.error(\"Warning: \".concat(finalMessage));\n    }\n  }\n}\n\n/** @see Similar to {@link warning} */\nexport function note(valid, message) {\n  if (process.env.NODE_ENV !== 'production' && !valid && console !== undefined) {\n    var finalMessage = preWarningFns.reduce(function (msg, preMessageFn) {\n      return preMessageFn(msg !== null && msg !== void 0 ? msg : '', 'note');\n    }, message);\n    if (finalMessage) {\n      console.warn(\"Note: \".concat(finalMessage));\n    }\n  }\n}\nexport function resetWarned() {\n  warned = {};\n}\nexport function call(method, valid, message) {\n  if (!valid && !warned[message]) {\n    method(false, message);\n    warned[message] = true;\n  }\n}\n\n/** @see Same as {@link warning}, but only warn once for the same message */\nexport function warningOnce(valid, message) {\n  call(warning, valid, message);\n}\n\n/** @see Same as {@link warning}, but only warn once for the same message */\nexport function noteOnce(valid, message) {\n  call(note, valid, message);\n}\nwarningOnce.preMessage = preMessage;\nwarningOnce.resetWarned = resetWarned;\nwarningOnce.noteOnce = noteOnce;\nexport default warningOnce;","import _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport React from 'react';\n\nvar Track = function Track(props) {\n  var _ref, _ref2;\n\n  var className = props.className,\n      included = props.included,\n      vertical = props.vertical,\n      style = props.style;\n  var length = props.length,\n      offset = props.offset,\n      reverse = props.reverse;\n\n  if (length < 0) {\n    reverse = !reverse;\n    length = Math.abs(length);\n    offset = 100 - offset;\n  }\n\n  var positonStyle = vertical ? (_ref = {}, _defineProperty(_ref, reverse ? 'top' : 'bottom', \"\".concat(offset, \"%\")), _defineProperty(_ref, reverse ? 'bottom' : 'top', 'auto'), _defineProperty(_ref, \"height\", \"\".concat(length, \"%\")), _ref) : (_ref2 = {}, _defineProperty(_ref2, reverse ? 'right' : 'left', \"\".concat(offset, \"%\")), _defineProperty(_ref2, reverse ? 'left' : 'right', 'auto'), _defineProperty(_ref2, \"width\", \"\".concat(length, \"%\")), _ref2);\n\n  var elStyle = _objectSpread(_objectSpread({}, style), positonStyle);\n\n  return included ? /*#__PURE__*/React.createElement(\"div\", {\n    className: className,\n    style: elStyle\n  }) : null;\n};\n\nexport default Track;","import objectWithoutPropertiesLoose from \"./objectWithoutPropertiesLoose.js\";\nfunction _objectWithoutProperties(e, t) {\n  if (null == e) return {};\n  var o,\n    r,\n    i = objectWithoutPropertiesLoose(e, t);\n  if (Object.getOwnPropertySymbols) {\n    var n = Object.getOwnPropertySymbols(e);\n    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);\n  }\n  return i;\n}\nexport { _objectWithoutProperties as default };","function _arrayLikeToArray(r, a) {\n  (null == a || a > r.length) && (a = r.length);\n  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\n  return n;\n}\nexport { _arrayLikeToArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _unsupportedIterableToArray(r, a) {\n  if (r) {\n    if (\"string\" == typeof r) return arrayLikeToArray(r, a);\n    var t = {}.toString.call(r).slice(8, -1);\n    return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;\n  }\n}\nexport { _unsupportedIterableToArray as default };","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nfunction _toConsumableArray(r) {\n  return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();\n}\nexport { _toConsumableArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _arrayWithoutHoles(r) {\n  if (Array.isArray(r)) return arrayLikeToArray(r);\n}\nexport { _arrayWithoutHoles as default };","function _iterableToArray(r) {\n  if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r);\n}\nexport { _iterableToArray as default };","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableSpread as default };","import superPropBase from \"./superPropBase.js\";\nfunction _get() {\n  return _get = \"undefined\" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function (e, t, r) {\n    var p = superPropBase(e, t);\n    if (p) {\n      var n = Object.getOwnPropertyDescriptor(p, t);\n      return n.get ? n.get.call(arguments.length < 3 ? e : r) : n.value;\n    }\n  }, _get.apply(null, arguments);\n}\nexport { _get as default };","import getPrototypeOf from \"./getPrototypeOf.js\";\nfunction _superPropBase(t, o) {\n  for (; !{}.hasOwnProperty.call(t, o) && null !== (t = getPrototypeOf(t)););\n  return t;\n}\nexport { _superPropBase as default };","import ReactDOM from 'react-dom';\nexport default function addEventListenerWrap(target, eventType, cb, option) {\n  /* eslint camelcase: 2 */\n  var callback = ReactDOM.unstable_batchedUpdates ? function run(e) {\n    ReactDOM.unstable_batchedUpdates(cb, e);\n  } : cb;\n  if (target !== null && target !== void 0 && target.addEventListener) {\n    target.addEventListener(eventType, callback, option);\n  }\n  return {\n    remove: function remove() {\n      if (target !== null && target !== void 0 && target.removeEventListener) {\n        target.removeEventListener(eventType, callback, option);\n      }\n    }\n  };\n}","import _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport React from 'react';\nimport classNames from 'classnames';\nimport warning from \"rc-util/es/warning\";\n\nvar calcPoints = function calcPoints(vertical, marks, dots, step, min, max) {\n  warning(dots ? step > 0 : true, '`Slider[step]` should be a positive number in order to make Slider[dots] work.');\n  var points = Object.keys(marks).map(parseFloat).sort(function (a, b) {\n    return a - b;\n  });\n\n  if (dots && step) {\n    for (var i = min; i <= max; i += step) {\n      if (points.indexOf(i) === -1) {\n        points.push(i);\n      }\n    }\n  }\n\n  return points;\n};\n\nvar Steps = function Steps(_ref) {\n  var prefixCls = _ref.prefixCls,\n      vertical = _ref.vertical,\n      reverse = _ref.reverse,\n      marks = _ref.marks,\n      dots = _ref.dots,\n      step = _ref.step,\n      included = _ref.included,\n      lowerBound = _ref.lowerBound,\n      upperBound = _ref.upperBound,\n      max = _ref.max,\n      min = _ref.min,\n      dotStyle = _ref.dotStyle,\n      activeDotStyle = _ref.activeDotStyle;\n  var range = max - min;\n  var elements = calcPoints(vertical, marks, dots, step, min, max).map(function (point) {\n    var _classNames;\n\n    var offset = \"\".concat(Math.abs(point - min) / range * 100, \"%\");\n    var isActived = !included && point === upperBound || included && point <= upperBound && point >= lowerBound;\n    var style = vertical ? _objectSpread(_objectSpread({}, dotStyle), {}, _defineProperty({}, reverse ? 'top' : 'bottom', offset)) : _objectSpread(_objectSpread({}, dotStyle), {}, _defineProperty({}, reverse ? 'right' : 'left', offset));\n\n    if (isActived) {\n      style = _objectSpread(_objectSpread({}, style), activeDotStyle);\n    }\n\n    var pointClassName = classNames((_classNames = {}, _defineProperty(_classNames, \"\".concat(prefixCls, \"-dot\"), true), _defineProperty(_classNames, \"\".concat(prefixCls, \"-dot-active\"), isActived), _defineProperty(_classNames, \"\".concat(prefixCls, \"-dot-reverse\"), reverse), _classNames));\n    return /*#__PURE__*/React.createElement(\"span\", {\n      className: pointClassName,\n      style: style,\n      key: point\n    });\n  });\n  return /*#__PURE__*/React.createElement(\"div\", {\n    className: \"\".concat(prefixCls, \"-step\")\n  }, elements);\n};\n\nexport default Steps;","import _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport React from 'react';\nimport classNames from 'classnames';\n\nvar Marks = function Marks(_ref) {\n  var className = _ref.className,\n      vertical = _ref.vertical,\n      reverse = _ref.reverse,\n      marks = _ref.marks,\n      included = _ref.included,\n      upperBound = _ref.upperBound,\n      lowerBound = _ref.lowerBound,\n      max = _ref.max,\n      min = _ref.min,\n      onClickLabel = _ref.onClickLabel;\n  var marksKeys = Object.keys(marks);\n  var range = max - min;\n  var elements = marksKeys.map(parseFloat).sort(function (a, b) {\n    return a - b;\n  }).map(function (point) {\n    var _classNames;\n\n    var markPoint = marks[point];\n    var markPointIsObject = _typeof(markPoint) === 'object' && ! /*#__PURE__*/React.isValidElement(markPoint);\n    var markLabel = markPointIsObject ? markPoint.label : markPoint;\n\n    if (!markLabel && markLabel !== 0) {\n      return null;\n    }\n\n    var isActive = !included && point === upperBound || included && point <= upperBound && point >= lowerBound;\n    var markClassName = classNames((_classNames = {}, _defineProperty(_classNames, \"\".concat(className, \"-text\"), true), _defineProperty(_classNames, \"\".concat(className, \"-text-active\"), isActive), _classNames));\n\n    var bottomStyle = _defineProperty({\n      marginBottom: '-50%'\n    }, reverse ? 'top' : 'bottom', \"\".concat((point - min) / range * 100, \"%\"));\n\n    var leftStyle = _defineProperty({\n      transform: \"translateX(\".concat(reverse ? \"50%\" : \"-50%\", \")\"),\n      msTransform: \"translateX(\".concat(reverse ? \"50%\" : \"-50%\", \")\")\n    }, reverse ? 'right' : 'left', \"\".concat((point - min) / range * 100, \"%\"));\n\n    var style = vertical ? bottomStyle : leftStyle;\n    var markStyle = markPointIsObject ? _objectSpread(_objectSpread({}, style), markPoint.style) : style;\n    return /*#__PURE__*/React.createElement(\"span\", {\n      className: markClassName,\n      style: markStyle,\n      key: point,\n      onMouseDown: function onMouseDown(e) {\n        return onClickLabel(e, point);\n      },\n      onTouchStart: function onTouchStart(e) {\n        return onClickLabel(e, point);\n      }\n    }, markLabel);\n  });\n  return /*#__PURE__*/React.createElement(\"div\", {\n    className: className\n  }, elements);\n};\n\nexport default Marks;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _createSuper from \"@babel/runtime/helpers/esm/createSuper\";\nimport React from 'react';\nimport classNames from 'classnames';\nimport addEventListener from \"rc-util/es/Dom/addEventListener\";\n\nvar Handle = /*#__PURE__*/function (_React$Component) {\n  _inherits(Handle, _React$Component);\n\n  var _super = _createSuper(Handle);\n\n  function Handle() {\n    var _this;\n\n    _classCallCheck(this, Handle);\n\n    _this = _super.apply(this, arguments);\n    _this.state = {\n      clickFocused: false\n    };\n\n    _this.setHandleRef = function (node) {\n      _this.handle = node;\n    };\n\n    _this.handleMouseUp = function () {\n      if (document.activeElement === _this.handle) {\n        _this.setClickFocus(true);\n      }\n    };\n\n    _this.handleMouseDown = function (e) {\n      // avoid selecting text during drag\n      // https://github.com/ant-design/ant-design/issues/25010\n      e.preventDefault(); // fix https://github.com/ant-design/ant-design/issues/15324\n\n      _this.focus();\n    };\n\n    _this.handleBlur = function () {\n      _this.setClickFocus(false);\n    };\n\n    _this.handleKeyDown = function () {\n      _this.setClickFocus(false);\n    };\n\n    return _this;\n  }\n\n  _createClass(Handle, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      // mouseup won't trigger if mouse moved out of handle,\n      // so we listen on document here.\n      this.onMouseUpListener = addEventListener(document, 'mouseup', this.handleMouseUp);\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      if (this.onMouseUpListener) {\n        this.onMouseUpListener.remove();\n      }\n    }\n  }, {\n    key: \"setClickFocus\",\n    value: function setClickFocus(focused) {\n      this.setState({\n        clickFocused: focused\n      });\n    }\n  }, {\n    key: \"clickFocus\",\n    value: function clickFocus() {\n      this.setClickFocus(true);\n      this.focus();\n    }\n  }, {\n    key: \"focus\",\n    value: function focus() {\n      this.handle.focus();\n    }\n  }, {\n    key: \"blur\",\n    value: function blur() {\n      this.handle.blur();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _ref, _ref2;\n\n      var _this$props = this.props,\n          prefixCls = _this$props.prefixCls,\n          vertical = _this$props.vertical,\n          reverse = _this$props.reverse,\n          offset = _this$props.offset,\n          style = _this$props.style,\n          disabled = _this$props.disabled,\n          min = _this$props.min,\n          max = _this$props.max,\n          value = _this$props.value,\n          tabIndex = _this$props.tabIndex,\n          ariaLabel = _this$props.ariaLabel,\n          ariaLabelledBy = _this$props.ariaLabelledBy,\n          ariaValueTextFormatter = _this$props.ariaValueTextFormatter,\n          restProps = _objectWithoutProperties(_this$props, [\"prefixCls\", \"vertical\", \"reverse\", \"offset\", \"style\", \"disabled\", \"min\", \"max\", \"value\", \"tabIndex\", \"ariaLabel\", \"ariaLabelledBy\", \"ariaValueTextFormatter\"]);\n\n      var className = classNames(this.props.className, _defineProperty({}, \"\".concat(prefixCls, \"-handle-click-focused\"), this.state.clickFocused));\n      var positionStyle = vertical ? (_ref = {}, _defineProperty(_ref, reverse ? 'top' : 'bottom', \"\".concat(offset, \"%\")), _defineProperty(_ref, reverse ? 'bottom' : 'top', 'auto'), _defineProperty(_ref, \"transform\", reverse ? null : \"translateY(+50%)\"), _ref) : (_ref2 = {}, _defineProperty(_ref2, reverse ? 'right' : 'left', \"\".concat(offset, \"%\")), _defineProperty(_ref2, reverse ? 'left' : 'right', 'auto'), _defineProperty(_ref2, \"transform\", \"translateX(\".concat(reverse ? '+' : '-', \"50%)\")), _ref2);\n\n      var elStyle = _objectSpread(_objectSpread({}, style), positionStyle);\n\n      var mergedTabIndex = tabIndex || 0;\n\n      if (disabled || tabIndex === null) {\n        mergedTabIndex = null;\n      }\n\n      var ariaValueText;\n\n      if (ariaValueTextFormatter) {\n        ariaValueText = ariaValueTextFormatter(value);\n      }\n\n      return /*#__PURE__*/React.createElement(\"div\", _extends({\n        ref: this.setHandleRef,\n        tabIndex: mergedTabIndex\n      }, restProps, {\n        className: className,\n        style: elStyle,\n        onBlur: this.handleBlur,\n        onKeyDown: this.handleKeyDown,\n        onMouseDown: this.handleMouseDown // aria attribute\n        ,\n        role: \"slider\",\n        \"aria-valuemin\": min,\n        \"aria-valuemax\": max,\n        \"aria-valuenow\": value,\n        \"aria-disabled\": !!disabled,\n        \"aria-label\": ariaLabel,\n        \"aria-labelledby\": ariaLabelledBy,\n        \"aria-valuetext\": ariaValueText\n      }));\n    }\n  }]);\n\n  return Handle;\n}(React.Component);\n\nexport { Handle as default };","/**\n * @ignore\n * some key-codes definition and utils from closure-library\n * @author yiminghe@gmail.com\n */\n\nvar KeyCode = {\n  /**\n   * MAC_ENTER\n   */\n  MAC_ENTER: 3,\n  /**\n   * BACKSPACE\n   */\n  BACKSPACE: 8,\n  /**\n   * TAB\n   */\n  TAB: 9,\n  /**\n   * NUMLOCK on FF/Safari Mac\n   */\n  NUM_CENTER: 12,\n  // NUMLOCK on FF/Safari Mac\n  /**\n   * ENTER\n   */\n  ENTER: 13,\n  /**\n   * SHIFT\n   */\n  SHIFT: 16,\n  /**\n   * CTRL\n   */\n  CTRL: 17,\n  /**\n   * ALT\n   */\n  ALT: 18,\n  /**\n   * PAUSE\n   */\n  PAUSE: 19,\n  /**\n   * CAPS_LOCK\n   */\n  CAPS_LOCK: 20,\n  /**\n   * ESC\n   */\n  ESC: 27,\n  /**\n   * SPACE\n   */\n  SPACE: 32,\n  /**\n   * PAGE_UP\n   */\n  PAGE_UP: 33,\n  // also NUM_NORTH_EAST\n  /**\n   * PAGE_DOWN\n   */\n  PAGE_DOWN: 34,\n  // also NUM_SOUTH_EAST\n  /**\n   * END\n   */\n  END: 35,\n  // also NUM_SOUTH_WEST\n  /**\n   * HOME\n   */\n  HOME: 36,\n  // also NUM_NORTH_WEST\n  /**\n   * LEFT\n   */\n  LEFT: 37,\n  // also NUM_WEST\n  /**\n   * UP\n   */\n  UP: 38,\n  // also NUM_NORTH\n  /**\n   * RIGHT\n   */\n  RIGHT: 39,\n  // also NUM_EAST\n  /**\n   * DOWN\n   */\n  DOWN: 40,\n  // also NUM_SOUTH\n  /**\n   * PRINT_SCREEN\n   */\n  PRINT_SCREEN: 44,\n  /**\n   * INSERT\n   */\n  INSERT: 45,\n  // also NUM_INSERT\n  /**\n   * DELETE\n   */\n  DELETE: 46,\n  // also NUM_DELETE\n  /**\n   * ZERO\n   */\n  ZERO: 48,\n  /**\n   * ONE\n   */\n  ONE: 49,\n  /**\n   * TWO\n   */\n  TWO: 50,\n  /**\n   * THREE\n   */\n  THREE: 51,\n  /**\n   * FOUR\n   */\n  FOUR: 52,\n  /**\n   * FIVE\n   */\n  FIVE: 53,\n  /**\n   * SIX\n   */\n  SIX: 54,\n  /**\n   * SEVEN\n   */\n  SEVEN: 55,\n  /**\n   * EIGHT\n   */\n  EIGHT: 56,\n  /**\n   * NINE\n   */\n  NINE: 57,\n  /**\n   * QUESTION_MARK\n   */\n  QUESTION_MARK: 63,\n  // needs localization\n  /**\n   * A\n   */\n  A: 65,\n  /**\n   * B\n   */\n  B: 66,\n  /**\n   * C\n   */\n  C: 67,\n  /**\n   * D\n   */\n  D: 68,\n  /**\n   * E\n   */\n  E: 69,\n  /**\n   * F\n   */\n  F: 70,\n  /**\n   * G\n   */\n  G: 71,\n  /**\n   * H\n   */\n  H: 72,\n  /**\n   * I\n   */\n  I: 73,\n  /**\n   * J\n   */\n  J: 74,\n  /**\n   * K\n   */\n  K: 75,\n  /**\n   * L\n   */\n  L: 76,\n  /**\n   * M\n   */\n  M: 77,\n  /**\n   * N\n   */\n  N: 78,\n  /**\n   * O\n   */\n  O: 79,\n  /**\n   * P\n   */\n  P: 80,\n  /**\n   * Q\n   */\n  Q: 81,\n  /**\n   * R\n   */\n  R: 82,\n  /**\n   * S\n   */\n  S: 83,\n  /**\n   * T\n   */\n  T: 84,\n  /**\n   * U\n   */\n  U: 85,\n  /**\n   * V\n   */\n  V: 86,\n  /**\n   * W\n   */\n  W: 87,\n  /**\n   * X\n   */\n  X: 88,\n  /**\n   * Y\n   */\n  Y: 89,\n  /**\n   * Z\n   */\n  Z: 90,\n  /**\n   * META\n   */\n  META: 91,\n  // WIN_KEY_LEFT\n  /**\n   * WIN_KEY_RIGHT\n   */\n  WIN_KEY_RIGHT: 92,\n  /**\n   * CONTEXT_MENU\n   */\n  CONTEXT_MENU: 93,\n  /**\n   * NUM_ZERO\n   */\n  NUM_ZERO: 96,\n  /**\n   * NUM_ONE\n   */\n  NUM_ONE: 97,\n  /**\n   * NUM_TWO\n   */\n  NUM_TWO: 98,\n  /**\n   * NUM_THREE\n   */\n  NUM_THREE: 99,\n  /**\n   * NUM_FOUR\n   */\n  NUM_FOUR: 100,\n  /**\n   * NUM_FIVE\n   */\n  NUM_FIVE: 101,\n  /**\n   * NUM_SIX\n   */\n  NUM_SIX: 102,\n  /**\n   * NUM_SEVEN\n   */\n  NUM_SEVEN: 103,\n  /**\n   * NUM_EIGHT\n   */\n  NUM_EIGHT: 104,\n  /**\n   * NUM_NINE\n   */\n  NUM_NINE: 105,\n  /**\n   * NUM_MULTIPLY\n   */\n  NUM_MULTIPLY: 106,\n  /**\n   * NUM_PLUS\n   */\n  NUM_PLUS: 107,\n  /**\n   * NUM_MINUS\n   */\n  NUM_MINUS: 109,\n  /**\n   * NUM_PERIOD\n   */\n  NUM_PERIOD: 110,\n  /**\n   * NUM_DIVISION\n   */\n  NUM_DIVISION: 111,\n  /**\n   * F1\n   */\n  F1: 112,\n  /**\n   * F2\n   */\n  F2: 113,\n  /**\n   * F3\n   */\n  F3: 114,\n  /**\n   * F4\n   */\n  F4: 115,\n  /**\n   * F5\n   */\n  F5: 116,\n  /**\n   * F6\n   */\n  F6: 117,\n  /**\n   * F7\n   */\n  F7: 118,\n  /**\n   * F8\n   */\n  F8: 119,\n  /**\n   * F9\n   */\n  F9: 120,\n  /**\n   * F10\n   */\n  F10: 121,\n  /**\n   * F11\n   */\n  F11: 122,\n  /**\n   * F12\n   */\n  F12: 123,\n  /**\n   * NUMLOCK\n   */\n  NUMLOCK: 144,\n  /**\n   * SEMICOLON\n   */\n  SEMICOLON: 186,\n  // needs localization\n  /**\n   * DASH\n   */\n  DASH: 189,\n  // needs localization\n  /**\n   * EQUALS\n   */\n  EQUALS: 187,\n  // needs localization\n  /**\n   * COMMA\n   */\n  COMMA: 188,\n  // needs localization\n  /**\n   * PERIOD\n   */\n  PERIOD: 190,\n  // needs localization\n  /**\n   * SLASH\n   */\n  SLASH: 191,\n  // needs localization\n  /**\n   * APOSTROPHE\n   */\n  APOSTROPHE: 192,\n  // needs localization\n  /**\n   * SINGLE_QUOTE\n   */\n  SINGLE_QUOTE: 222,\n  // needs localization\n  /**\n   * OPEN_SQUARE_BRACKET\n   */\n  OPEN_SQUARE_BRACKET: 219,\n  // needs localization\n  /**\n   * BACKSLASH\n   */\n  BACKSLASH: 220,\n  // needs localization\n  /**\n   * CLOSE_SQUARE_BRACKET\n   */\n  CLOSE_SQUARE_BRACKET: 221,\n  // needs localization\n  /**\n   * WIN_KEY\n   */\n  WIN_KEY: 224,\n  /**\n   * MAC_FF_META\n   */\n  MAC_FF_META: 224,\n  // Firefox (Gecko) fires this for the meta key instead of 91\n  /**\n   * WIN_IME\n   */\n  WIN_IME: 229,\n  // ======================== Function ========================\n  /**\n   * whether text and modified key is entered at the same time.\n   */\n  isTextModifyingKeyEvent: function isTextModifyingKeyEvent(e) {\n    var keyCode = e.keyCode;\n    if (e.altKey && !e.ctrlKey || e.metaKey ||\n    // Function keys don't generate text\n    keyCode >= KeyCode.F1 && keyCode <= KeyCode.F12) {\n      return false;\n    }\n\n    // The following keys are quite harmless, even in combination with\n    // CTRL, ALT or SHIFT.\n    switch (keyCode) {\n      case KeyCode.ALT:\n      case KeyCode.CAPS_LOCK:\n      case KeyCode.CONTEXT_MENU:\n      case KeyCode.CTRL:\n      case KeyCode.DOWN:\n      case KeyCode.END:\n      case KeyCode.ESC:\n      case KeyCode.HOME:\n      case KeyCode.INSERT:\n      case KeyCode.LEFT:\n      case KeyCode.MAC_FF_META:\n      case KeyCode.META:\n      case KeyCode.NUMLOCK:\n      case KeyCode.NUM_CENTER:\n      case KeyCode.PAGE_DOWN:\n      case KeyCode.PAGE_UP:\n      case KeyCode.PAUSE:\n      case KeyCode.PRINT_SCREEN:\n      case KeyCode.RIGHT:\n      case KeyCode.SHIFT:\n      case KeyCode.UP:\n      case KeyCode.WIN_KEY:\n      case KeyCode.WIN_KEY_RIGHT:\n        return false;\n      default:\n        return true;\n    }\n  },\n  /**\n   * whether character is entered.\n   */\n  isCharacterKey: function isCharacterKey(keyCode) {\n    if (keyCode >= KeyCode.ZERO && keyCode <= KeyCode.NINE) {\n      return true;\n    }\n    if (keyCode >= KeyCode.NUM_ZERO && keyCode <= KeyCode.NUM_MULTIPLY) {\n      return true;\n    }\n    if (keyCode >= KeyCode.A && keyCode <= KeyCode.Z) {\n      return true;\n    }\n\n    // Safari sends zero key code for non-latin characters.\n    if (window.navigator.userAgent.indexOf('WebKit') !== -1 && keyCode === 0) {\n      return true;\n    }\n    switch (keyCode) {\n      case KeyCode.SPACE:\n      case KeyCode.QUESTION_MARK:\n      case KeyCode.NUM_PLUS:\n      case KeyCode.NUM_MINUS:\n      case KeyCode.NUM_PERIOD:\n      case KeyCode.NUM_DIVISION:\n      case KeyCode.SEMICOLON:\n      case KeyCode.DASH:\n      case KeyCode.EQUALS:\n      case KeyCode.COMMA:\n      case KeyCode.PERIOD:\n      case KeyCode.SLASH:\n      case KeyCode.APOSTROPHE:\n      case KeyCode.SINGLE_QUOTE:\n      case KeyCode.OPEN_SQUARE_BRACKET:\n      case KeyCode.BACKSLASH:\n      case KeyCode.CLOSE_SQUARE_BRACKET:\n        return true;\n      default:\n        return false;\n    }\n  }\n};\nexport default KeyCode;","import _toConsumableArray from \"@babel/runtime/helpers/esm/toConsumableArray\";\nimport { findDOMNode } from 'react-dom';\nimport keyCode from \"rc-util/es/KeyCode\";\nexport function isEventFromHandle(e, handles) {\n  try {\n    return Object.keys(handles).some(function (key) {\n      return e.target === findDOMNode(handles[key]);\n    });\n  } catch (error) {\n    return false;\n  }\n}\nexport function isValueOutOfRange(value, _ref) {\n  var min = _ref.min,\n      max = _ref.max;\n  return value < min || value > max;\n}\nexport function isNotTouchEvent(e) {\n  return e.touches.length > 1 || e.type.toLowerCase() === 'touchend' && e.touches.length > 0;\n}\nexport function getClosestPoint(val, _ref2) {\n  var marks = _ref2.marks,\n      step = _ref2.step,\n      min = _ref2.min,\n      max = _ref2.max;\n  var points = Object.keys(marks).map(parseFloat);\n\n  if (step !== null) {\n    var baseNum = Math.pow(10, getPrecision(step));\n    var maxSteps = Math.floor((max * baseNum - min * baseNum) / (step * baseNum));\n    var steps = Math.min((val - min) / step, maxSteps);\n    var closestStep = Math.round(steps) * step + min;\n    points.push(closestStep);\n  }\n\n  var diffs = points.map(function (point) {\n    return Math.abs(val - point);\n  });\n  return points[diffs.indexOf(Math.min.apply(Math, _toConsumableArray(diffs)))];\n}\nexport function getPrecision(step) {\n  var stepString = step.toString();\n  var precision = 0;\n\n  if (stepString.indexOf('.') >= 0) {\n    precision = stepString.length - stepString.indexOf('.') - 1;\n  }\n\n  return precision;\n}\nexport function getMousePosition(vertical, e) {\n  return vertical ? e.clientY : e.pageX;\n}\nexport function getTouchPosition(vertical, e) {\n  return vertical ? e.touches[0].clientY : e.touches[0].pageX;\n}\nexport function getHandleCenterPosition(vertical, handle) {\n  var coords = handle.getBoundingClientRect();\n  return vertical ? coords.top + coords.height * 0.5 : window.pageXOffset + coords.left + coords.width * 0.5;\n}\nexport function ensureValueInRange(val, _ref3) {\n  var max = _ref3.max,\n      min = _ref3.min;\n\n  if (val <= min) {\n    return min;\n  }\n\n  if (val >= max) {\n    return max;\n  }\n\n  return val;\n}\nexport function ensureValuePrecision(val, props) {\n  var step = props.step;\n  var closestPoint = isFinite(getClosestPoint(val, props)) ? getClosestPoint(val, props) : 0; // eslint-disable-line\n\n  return step === null ? closestPoint : parseFloat(closestPoint.toFixed(getPrecision(step)));\n}\nexport function pauseEvent(e) {\n  e.stopPropagation();\n  e.preventDefault();\n}\nexport function calculateNextValue(func, value, props) {\n  var operations = {\n    increase: function increase(a, b) {\n      return a + b;\n    },\n    decrease: function decrease(a, b) {\n      return a - b;\n    }\n  };\n  var indexToGet = operations[func](Object.keys(props.marks).indexOf(JSON.stringify(value)), 1);\n  var keyToGet = Object.keys(props.marks)[indexToGet];\n\n  if (props.step) {\n    return operations[func](value, props.step);\n  }\n\n  if (!!Object.keys(props.marks).length && !!props.marks[keyToGet]) {\n    return props.marks[keyToGet];\n  }\n\n  return value;\n}\nexport function getKeyboardValueMutator(e, vertical, reverse) {\n  var increase = 'increase';\n  var decrease = 'decrease';\n  var method = increase;\n\n  switch (e.keyCode) {\n    case keyCode.UP:\n      method = vertical && reverse ? decrease : increase;\n      break;\n\n    case keyCode.RIGHT:\n      method = !vertical && reverse ? decrease : increase;\n      break;\n\n    case keyCode.DOWN:\n      method = vertical && reverse ? increase : decrease;\n      break;\n\n    case keyCode.LEFT:\n      method = !vertical && reverse ? increase : decrease;\n      break;\n\n    case keyCode.END:\n      return function (value, props) {\n        return props.max;\n      };\n\n    case keyCode.HOME:\n      return function (value, props) {\n        return props.min;\n      };\n\n    case keyCode.PAGE_UP:\n      return function (value, props) {\n        return value + props.step * 2;\n      };\n\n    case keyCode.PAGE_DOWN:\n      return function (value, props) {\n        return value - props.step * 2;\n      };\n\n    default:\n      return undefined;\n  }\n\n  return function (value, props) {\n    return calculateNextValue(method, value, props);\n  };\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _toConsumableArray from \"@babel/runtime/helpers/esm/toConsumableArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _get from \"@babel/runtime/helpers/esm/get\";\nimport _getPrototypeOf from \"@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _createSuper from \"@babel/runtime/helpers/esm/createSuper\";\nimport React from 'react';\nimport addEventListener from \"rc-util/es/Dom/addEventListener\";\nimport classNames from 'classnames';\nimport warning from \"rc-util/es/warning\";\nimport Steps from './Steps';\nimport Marks from './Marks';\nimport Handle from '../Handle';\nimport * as utils from '../utils';\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nfunction noop() {}\n\nexport default function createSlider(Component) {\n  var _a; // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\n\n  return _a = /*#__PURE__*/function (_Component) {\n    _inherits(ComponentEnhancer, _Component);\n\n    var _super = _createSuper(ComponentEnhancer);\n\n    function ComponentEnhancer(props) {\n      var _this;\n\n      _classCallCheck(this, ComponentEnhancer);\n\n      _this = _super.call(this, props);\n\n      _this.onDown = function (e, position) {\n        var p = position;\n        var _this$props = _this.props,\n            draggableTrack = _this$props.draggableTrack,\n            isVertical = _this$props.vertical;\n        var bounds = _this.state.bounds;\n        var value = draggableTrack && _this.positionGetValue ? _this.positionGetValue(p) || [] : [];\n        var inPoint = utils.isEventFromHandle(e, _this.handlesRefs);\n        _this.dragTrack = draggableTrack && bounds.length >= 2 && !inPoint && !value.map(function (n, i) {\n          var v = !i ? n >= bounds[i] : true;\n          return i === value.length - 1 ? n <= bounds[i] : v;\n        }).some(function (c) {\n          return !c;\n        });\n\n        if (_this.dragTrack) {\n          _this.dragOffset = p;\n          _this.startBounds = _toConsumableArray(bounds);\n        } else {\n          if (!inPoint) {\n            _this.dragOffset = 0;\n          } else {\n            var handlePosition = utils.getHandleCenterPosition(isVertical, e.target);\n            _this.dragOffset = p - handlePosition;\n            p = handlePosition;\n          }\n\n          _this.onStart(p);\n        }\n      };\n\n      _this.onMouseDown = function (e) {\n        if (e.button !== 0) {\n          return;\n        }\n\n        _this.removeDocumentEvents();\n\n        var isVertical = _this.props.vertical;\n        var position = utils.getMousePosition(isVertical, e);\n\n        _this.onDown(e, position);\n\n        _this.addDocumentMouseEvents();\n      };\n\n      _this.onTouchStart = function (e) {\n        if (utils.isNotTouchEvent(e)) return;\n        var isVertical = _this.props.vertical;\n        var position = utils.getTouchPosition(isVertical, e);\n\n        _this.onDown(e, position);\n\n        _this.addDocumentTouchEvents();\n\n        utils.pauseEvent(e);\n      };\n\n      _this.onFocus = function (e) {\n        var _this$props2 = _this.props,\n            onFocus = _this$props2.onFocus,\n            vertical = _this$props2.vertical;\n\n        if (utils.isEventFromHandle(e, _this.handlesRefs) && !_this.dragTrack) {\n          var handlePosition = utils.getHandleCenterPosition(vertical, e.target);\n          _this.dragOffset = 0;\n\n          _this.onStart(handlePosition);\n\n          utils.pauseEvent(e);\n\n          if (onFocus) {\n            onFocus(e);\n          }\n        }\n      };\n\n      _this.onBlur = function (e) {\n        var onBlur = _this.props.onBlur;\n\n        if (!_this.dragTrack) {\n          _this.onEnd();\n        }\n\n        if (onBlur) {\n          onBlur(e);\n        }\n      };\n\n      _this.onMouseUp = function () {\n        if (_this.handlesRefs[_this.prevMovedHandleIndex]) {\n          _this.handlesRefs[_this.prevMovedHandleIndex].clickFocus();\n        }\n      };\n\n      _this.onMouseMove = function (e) {\n        if (!_this.sliderRef) {\n          _this.onEnd();\n\n          return;\n        }\n\n        var position = utils.getMousePosition(_this.props.vertical, e);\n\n        _this.onMove(e, position - _this.dragOffset, _this.dragTrack, _this.startBounds);\n      };\n\n      _this.onTouchMove = function (e) {\n        if (utils.isNotTouchEvent(e) || !_this.sliderRef) {\n          _this.onEnd();\n\n          return;\n        }\n\n        var position = utils.getTouchPosition(_this.props.vertical, e);\n\n        _this.onMove(e, position - _this.dragOffset, _this.dragTrack, _this.startBounds);\n      };\n\n      _this.onKeyDown = function (e) {\n        if (_this.sliderRef && utils.isEventFromHandle(e, _this.handlesRefs)) {\n          _this.onKeyboard(e);\n        }\n      };\n\n      _this.onClickMarkLabel = function (e, value) {\n        e.stopPropagation();\n\n        _this.onChange({\n          value: value\n        }); // eslint-disable-next-line react/no-unused-state\n\n\n        _this.setState({\n          value: value\n        }, function () {\n          return _this.onEnd(true);\n        });\n      };\n\n      _this.saveSlider = function (slider) {\n        _this.sliderRef = slider;\n      };\n\n      var step = props.step,\n          max = props.max,\n          min = props.min;\n      var isPointDiffEven = isFinite(max - min) ? (max - min) % step === 0 : true; // eslint-disable-line\n\n      warning(step && Math.floor(step) === step ? isPointDiffEven : true, \"Slider[max] - Slider[min] (\".concat(max - min, \") should be a multiple of Slider[step] (\").concat(step, \")\"));\n      _this.handlesRefs = {};\n      return _this;\n    }\n\n    _createClass(ComponentEnhancer, [{\n      key: \"componentDidMount\",\n      value: function componentDidMount() {\n        // Snapshot testing cannot handle refs, so be sure to null-check this.\n        this.document = this.sliderRef && this.sliderRef.ownerDocument;\n        var _this$props3 = this.props,\n            autoFocus = _this$props3.autoFocus,\n            disabled = _this$props3.disabled;\n\n        if (autoFocus && !disabled) {\n          this.focus();\n        }\n      }\n    }, {\n      key: \"componentWillUnmount\",\n      value: function componentWillUnmount() {\n        if (_get(_getPrototypeOf(ComponentEnhancer.prototype), \"componentWillUnmount\", this)) _get(_getPrototypeOf(ComponentEnhancer.prototype), \"componentWillUnmount\", this).call(this);\n        this.removeDocumentEvents();\n      }\n    }, {\n      key: \"getSliderStart\",\n      value: function getSliderStart() {\n        var slider = this.sliderRef;\n        var _this$props4 = this.props,\n            vertical = _this$props4.vertical,\n            reverse = _this$props4.reverse;\n        var rect = slider.getBoundingClientRect();\n\n        if (vertical) {\n          return reverse ? rect.bottom : rect.top;\n        }\n\n        return window.pageXOffset + (reverse ? rect.right : rect.left);\n      }\n    }, {\n      key: \"getSliderLength\",\n      value: function getSliderLength() {\n        var slider = this.sliderRef;\n\n        if (!slider) {\n          return 0;\n        }\n\n        var coords = slider.getBoundingClientRect();\n        return this.props.vertical ? coords.height : coords.width;\n      }\n    }, {\n      key: \"addDocumentTouchEvents\",\n      value: function addDocumentTouchEvents() {\n        // just work for Chrome iOS Safari and Android Browser\n        this.onTouchMoveListener = addEventListener(this.document, 'touchmove', this.onTouchMove);\n        this.onTouchUpListener = addEventListener(this.document, 'touchend', this.onEnd);\n      }\n    }, {\n      key: \"addDocumentMouseEvents\",\n      value: function addDocumentMouseEvents() {\n        this.onMouseMoveListener = addEventListener(this.document, 'mousemove', this.onMouseMove);\n        this.onMouseUpListener = addEventListener(this.document, 'mouseup', this.onEnd);\n      }\n    }, {\n      key: \"removeDocumentEvents\",\n      value: function removeDocumentEvents() {\n        /* eslint-disable @typescript-eslint/no-unused-expressions */\n        this.onTouchMoveListener && this.onTouchMoveListener.remove();\n        this.onTouchUpListener && this.onTouchUpListener.remove();\n        this.onMouseMoveListener && this.onMouseMoveListener.remove();\n        this.onMouseUpListener && this.onMouseUpListener.remove();\n        /* eslint-enable no-unused-expressions */\n      }\n    }, {\n      key: \"focus\",\n      value: function focus() {\n        var _this$handlesRefs$;\n\n        if (this.props.disabled) {\n          return;\n        }\n\n        (_this$handlesRefs$ = this.handlesRefs[0]) === null || _this$handlesRefs$ === void 0 ? void 0 : _this$handlesRefs$.focus();\n      }\n    }, {\n      key: \"blur\",\n      value: function blur() {\n        var _this2 = this;\n\n        if (this.props.disabled) {\n          return;\n        }\n\n        Object.keys(this.handlesRefs).forEach(function (key) {\n          var _this2$handlesRefs$ke, _this2$handlesRefs$ke2;\n\n          (_this2$handlesRefs$ke = _this2.handlesRefs[key]) === null || _this2$handlesRefs$ke === void 0 ? void 0 : (_this2$handlesRefs$ke2 = _this2$handlesRefs$ke.blur) === null || _this2$handlesRefs$ke2 === void 0 ? void 0 : _this2$handlesRefs$ke2.call(_this2$handlesRefs$ke);\n        });\n      }\n    }, {\n      key: \"calcValue\",\n      value: function calcValue(offset) {\n        var _this$props5 = this.props,\n            vertical = _this$props5.vertical,\n            min = _this$props5.min,\n            max = _this$props5.max;\n        var ratio = Math.abs(Math.max(offset, 0) / this.getSliderLength());\n        var value = vertical ? (1 - ratio) * (max - min) + min : ratio * (max - min) + min;\n        return value;\n      }\n    }, {\n      key: \"calcValueByPos\",\n      value: function calcValueByPos(position) {\n        var sign = this.props.reverse ? -1 : +1;\n        var pixelOffset = sign * (position - this.getSliderStart());\n        var nextValue = this.trimAlignValue(this.calcValue(pixelOffset));\n        return nextValue;\n      }\n    }, {\n      key: \"calcOffset\",\n      value: function calcOffset(value) {\n        var _this$props6 = this.props,\n            min = _this$props6.min,\n            max = _this$props6.max;\n        var ratio = (value - min) / (max - min);\n        return Math.max(0, ratio * 100);\n      }\n    }, {\n      key: \"saveHandle\",\n      value: function saveHandle(index, handle) {\n        this.handlesRefs[index] = handle;\n      }\n    }, {\n      key: \"render\",\n      value: function render() {\n        var _classNames;\n\n        var _this$props7 = this.props,\n            prefixCls = _this$props7.prefixCls,\n            className = _this$props7.className,\n            marks = _this$props7.marks,\n            dots = _this$props7.dots,\n            step = _this$props7.step,\n            included = _this$props7.included,\n            disabled = _this$props7.disabled,\n            vertical = _this$props7.vertical,\n            reverse = _this$props7.reverse,\n            min = _this$props7.min,\n            max = _this$props7.max,\n            children = _this$props7.children,\n            maximumTrackStyle = _this$props7.maximumTrackStyle,\n            style = _this$props7.style,\n            railStyle = _this$props7.railStyle,\n            dotStyle = _this$props7.dotStyle,\n            activeDotStyle = _this$props7.activeDotStyle;\n\n        var _get$call = _get(_getPrototypeOf(ComponentEnhancer.prototype), \"render\", this).call(this),\n            tracks = _get$call.tracks,\n            handles = _get$call.handles;\n\n        var sliderClassName = classNames(prefixCls, (_classNames = {}, _defineProperty(_classNames, \"\".concat(prefixCls, \"-with-marks\"), Object.keys(marks).length), _defineProperty(_classNames, \"\".concat(prefixCls, \"-disabled\"), disabled), _defineProperty(_classNames, \"\".concat(prefixCls, \"-vertical\"), vertical), _defineProperty(_classNames, className, className), _classNames));\n        return /*#__PURE__*/React.createElement(\"div\", {\n          ref: this.saveSlider,\n          className: sliderClassName,\n          onTouchStart: disabled ? noop : this.onTouchStart,\n          onMouseDown: disabled ? noop : this.onMouseDown,\n          onMouseUp: disabled ? noop : this.onMouseUp,\n          onKeyDown: disabled ? noop : this.onKeyDown,\n          onFocus: disabled ? noop : this.onFocus,\n          onBlur: disabled ? noop : this.onBlur,\n          style: style\n        }, /*#__PURE__*/React.createElement(\"div\", {\n          className: \"\".concat(prefixCls, \"-rail\"),\n          style: _objectSpread(_objectSpread({}, maximumTrackStyle), railStyle)\n        }), tracks, /*#__PURE__*/React.createElement(Steps, {\n          prefixCls: prefixCls,\n          vertical: vertical,\n          reverse: reverse,\n          marks: marks,\n          dots: dots,\n          step: step,\n          included: included,\n          lowerBound: this.getLowerBound(),\n          upperBound: this.getUpperBound(),\n          max: max,\n          min: min,\n          dotStyle: dotStyle,\n          activeDotStyle: activeDotStyle\n        }), handles, /*#__PURE__*/React.createElement(Marks, {\n          className: \"\".concat(prefixCls, \"-mark\"),\n          onClickLabel: disabled ? noop : this.onClickMarkLabel,\n          vertical: vertical,\n          marks: marks,\n          included: included,\n          lowerBound: this.getLowerBound(),\n          upperBound: this.getUpperBound(),\n          max: max,\n          min: min,\n          reverse: reverse\n        }), children);\n      }\n    }]);\n\n    return ComponentEnhancer;\n  }(Component), _a.displayName = \"ComponentEnhancer(\".concat(Component.displayName, \")\"), _a.defaultProps = _objectSpread(_objectSpread({}, Component.defaultProps), {}, {\n    prefixCls: 'rc-slider',\n    className: '',\n    min: 0,\n    max: 100,\n    step: 1,\n    marks: {},\n    handle: function handle(props) {\n      var index = props.index,\n          restProps = _objectWithoutProperties(props, [\"index\"]);\n\n      delete restProps.dragging;\n\n      if (restProps.value === null) {\n        return null;\n      }\n\n      return /*#__PURE__*/React.createElement(Handle, _extends({}, restProps, {\n        key: index\n      }));\n    },\n    onBeforeChange: noop,\n    onChange: noop,\n    onAfterChange: noop,\n    included: true,\n    disabled: false,\n    dots: false,\n    vertical: false,\n    reverse: false,\n    trackStyle: [{}],\n    handleStyle: [{}],\n    railStyle: {},\n    dotStyle: {},\n    activeDotStyle: {}\n  }), _a;\n}","import _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _createSuper from \"@babel/runtime/helpers/esm/createSuper\";\nimport React from 'react';\nimport warning from \"rc-util/es/warning\";\nimport Track from './common/Track';\nimport createSlider from './common/createSlider';\nimport * as utils from './utils';\n\nvar Slider = /*#__PURE__*/function (_React$Component) {\n  _inherits(Slider, _React$Component);\n\n  var _super = _createSuper(Slider);\n\n  /* eslint-enable */\n  function Slider(props) {\n    var _this;\n\n    _classCallCheck(this, Slider);\n\n    _this = _super.call(this, props);\n\n    _this.positionGetValue = function (position) {\n      return [];\n    };\n\n    _this.onEnd = function (force) {\n      var dragging = _this.state.dragging;\n\n      _this.removeDocumentEvents();\n\n      if (dragging || force) {\n        _this.props.onAfterChange(_this.getValue());\n      }\n\n      _this.setState({\n        dragging: false\n      });\n    };\n\n    var defaultValue = props.defaultValue !== undefined ? props.defaultValue : props.min;\n    var value = props.value !== undefined ? props.value : defaultValue;\n    _this.state = {\n      value: _this.trimAlignValue(value),\n      dragging: false\n    };\n    warning(!('minimumTrackStyle' in props), 'minimumTrackStyle will be deprecated, please use trackStyle instead.');\n    warning(!('maximumTrackStyle' in props), 'maximumTrackStyle will be deprecated, please use railStyle instead.');\n    return _this;\n  }\n  /**\n   * [Legacy] Used for inherit other component.\n   * It's a bad code style which should be refactor.\n   */\n\n  /* eslint-disable @typescript-eslint/no-unused-vars, class-methods-use-this */\n\n\n  _createClass(Slider, [{\n    key: \"calcValueByPos\",\n    value: function calcValueByPos(value) {\n      return 0;\n    }\n  }, {\n    key: \"calcOffset\",\n    value: function calcOffset(value) {\n      return 0;\n    }\n  }, {\n    key: \"saveHandle\",\n    value: function saveHandle(index, h) {}\n  }, {\n    key: \"removeDocumentEvents\",\n    value: function removeDocumentEvents() {}\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      var _this$props = this.props,\n          min = _this$props.min,\n          max = _this$props.max,\n          value = _this$props.value,\n          onChange = _this$props.onChange;\n\n      if (!('min' in this.props || 'max' in this.props)) {\n        return;\n      }\n\n      var theValue = value !== undefined ? value : prevState.value;\n      var nextValue = this.trimAlignValue(theValue, this.props);\n\n      if (nextValue === prevState.value) {\n        return;\n      } // eslint-disable-next-line\n\n\n      this.setState({\n        value: nextValue\n      });\n\n      if (!(min === prevProps.min && max === prevProps.max) && utils.isValueOutOfRange(theValue, this.props)) {\n        onChange(nextValue);\n      }\n    }\n  }, {\n    key: \"onChange\",\n    value: function onChange(state) {\n      var props = this.props;\n      var isNotControlled = !('value' in props);\n      var nextState = state.value > this.props.max ? _objectSpread(_objectSpread({}, state), {}, {\n        value: this.props.max\n      }) : state;\n\n      if (isNotControlled) {\n        this.setState(nextState);\n      }\n\n      var changedValue = nextState.value;\n      props.onChange(changedValue);\n    }\n  }, {\n    key: \"onStart\",\n    value: function onStart(position) {\n      this.setState({\n        dragging: true\n      });\n      var props = this.props;\n      var prevValue = this.getValue();\n      props.onBeforeChange(prevValue);\n      var value = this.calcValueByPos(position);\n      this.startValue = value;\n      this.startPosition = position;\n      if (value === prevValue) return;\n      this.prevMovedHandleIndex = 0;\n      this.onChange({\n        value: value\n      });\n    }\n  }, {\n    key: \"onMove\",\n    value: function onMove(e, position) {\n      utils.pauseEvent(e);\n      var oldValue = this.state.value;\n      var value = this.calcValueByPos(position);\n      if (value === oldValue) return;\n      this.onChange({\n        value: value\n      });\n    }\n  }, {\n    key: \"onKeyboard\",\n    value: function onKeyboard(e) {\n      var _this$props2 = this.props,\n          reverse = _this$props2.reverse,\n          vertical = _this$props2.vertical;\n      var valueMutator = utils.getKeyboardValueMutator(e, vertical, reverse);\n\n      if (valueMutator) {\n        utils.pauseEvent(e);\n        var state = this.state;\n        var oldValue = state.value;\n        var mutatedValue = valueMutator(oldValue, this.props);\n        var value = this.trimAlignValue(mutatedValue);\n        if (value === oldValue) return;\n        this.onChange({\n          value: value\n        });\n        this.props.onAfterChange(value);\n        this.onEnd();\n      }\n    }\n  }, {\n    key: \"getValue\",\n    value: function getValue() {\n      return this.state.value;\n    }\n  }, {\n    key: \"getLowerBound\",\n    value: function getLowerBound() {\n      var minPoint = this.props.startPoint || this.props.min;\n      return this.state.value > minPoint ? minPoint : this.state.value;\n    }\n  }, {\n    key: \"getUpperBound\",\n    value: function getUpperBound() {\n      if (this.state.value < this.props.startPoint) {\n        return this.props.startPoint;\n      }\n\n      return this.state.value;\n    }\n  }, {\n    key: \"trimAlignValue\",\n    value: function trimAlignValue(v) {\n      var nextProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n      if (v === null) {\n        return null;\n      }\n\n      var mergedProps = _objectSpread(_objectSpread({}, this.props), nextProps);\n\n      var val = utils.ensureValueInRange(v, mergedProps);\n      return utils.ensureValuePrecision(val, mergedProps);\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this2 = this;\n\n      var _this$props3 = this.props,\n          prefixCls = _this$props3.prefixCls,\n          vertical = _this$props3.vertical,\n          included = _this$props3.included,\n          disabled = _this$props3.disabled,\n          minimumTrackStyle = _this$props3.minimumTrackStyle,\n          trackStyle = _this$props3.trackStyle,\n          handleStyle = _this$props3.handleStyle,\n          tabIndex = _this$props3.tabIndex,\n          ariaLabelForHandle = _this$props3.ariaLabelForHandle,\n          ariaLabelledByForHandle = _this$props3.ariaLabelledByForHandle,\n          ariaValueTextFormatterForHandle = _this$props3.ariaValueTextFormatterForHandle,\n          min = _this$props3.min,\n          max = _this$props3.max,\n          startPoint = _this$props3.startPoint,\n          reverse = _this$props3.reverse,\n          handleGenerator = _this$props3.handle;\n      var _this$state = this.state,\n          value = _this$state.value,\n          dragging = _this$state.dragging;\n      var offset = this.calcOffset(value);\n      var handle = handleGenerator({\n        className: \"\".concat(prefixCls, \"-handle\"),\n        prefixCls: prefixCls,\n        vertical: vertical,\n        offset: offset,\n        value: value,\n        dragging: dragging,\n        disabled: disabled,\n        min: min,\n        max: max,\n        reverse: reverse,\n        index: 0,\n        tabIndex: tabIndex,\n        ariaLabel: ariaLabelForHandle,\n        ariaLabelledBy: ariaLabelledByForHandle,\n        ariaValueTextFormatter: ariaValueTextFormatterForHandle,\n        style: handleStyle[0] || handleStyle,\n        ref: function ref(h) {\n          return _this2.saveHandle(0, h);\n        }\n      });\n      var trackOffset = startPoint !== undefined ? this.calcOffset(startPoint) : 0;\n      var mergedTrackStyle = trackStyle[0] || trackStyle;\n      var track = /*#__PURE__*/React.createElement(Track, {\n        className: \"\".concat(prefixCls, \"-track\"),\n        vertical: vertical,\n        included: included,\n        offset: trackOffset,\n        reverse: reverse,\n        length: offset - trackOffset,\n        style: _objectSpread(_objectSpread({}, minimumTrackStyle), mergedTrackStyle)\n      });\n      return {\n        tracks: track,\n        handles: handle\n      };\n    }\n  }]);\n\n  return Slider;\n}(React.Component);\n\nexport default createSlider(Slider);","import _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _toConsumableArray from \"@babel/runtime/helpers/esm/toConsumableArray\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _createSuper from \"@babel/runtime/helpers/esm/createSuper\";\nimport React from 'react';\nimport classNames from 'classnames';\nimport Track from './common/Track';\nimport createSlider from './common/createSlider';\nimport * as utils from './utils';\n\nvar _trimAlignValue = function trimAlignValue(_ref) {\n  var value = _ref.value,\n      handle = _ref.handle,\n      bounds = _ref.bounds,\n      props = _ref.props;\n  var allowCross = props.allowCross,\n      pushable = props.pushable;\n  var thershold = Number(pushable);\n  var valInRange = utils.ensureValueInRange(value, props);\n  var valNotConflict = valInRange;\n\n  if (!allowCross && handle != null && bounds !== undefined) {\n    if (handle > 0 && valInRange <= bounds[handle - 1] + thershold) {\n      valNotConflict = bounds[handle - 1] + thershold;\n    }\n\n    if (handle < bounds.length - 1 && valInRange >= bounds[handle + 1] - thershold) {\n      valNotConflict = bounds[handle + 1] - thershold;\n    }\n  }\n\n  return utils.ensureValuePrecision(valNotConflict, props);\n};\n\nvar Range = /*#__PURE__*/function (_React$Component) {\n  _inherits(Range, _React$Component);\n\n  var _super = _createSuper(Range);\n\n  function Range(props) {\n    var _this;\n\n    _classCallCheck(this, Range);\n\n    _this = _super.call(this, props);\n\n    _this.positionGetValue = function (position) {\n      var bounds = _this.getValue();\n\n      var value = _this.calcValueByPos(position);\n\n      var closestBound = _this.getClosestBound(value);\n\n      var index = _this.getBoundNeedMoving(value, closestBound);\n\n      var prevValue = bounds[index];\n      if (value === prevValue) return null;\n\n      var nextBounds = _toConsumableArray(bounds);\n\n      nextBounds[index] = value;\n      return nextBounds;\n    };\n\n    _this.onEnd = function (force) {\n      var handle = _this.state.handle;\n\n      _this.removeDocumentEvents();\n\n      if (!handle) {\n        _this.dragTrack = false;\n      }\n\n      if (handle !== null || force) {\n        _this.props.onAfterChange(_this.getValue());\n      }\n\n      _this.setState({\n        handle: null\n      });\n    };\n\n    var count = props.count,\n        min = props.min,\n        max = props.max;\n    var initialValue = Array.apply(void 0, _toConsumableArray(Array(count + 1))).map(function () {\n      return min;\n    });\n    var defaultValue = 'defaultValue' in props ? props.defaultValue : initialValue;\n    var value = props.value !== undefined ? props.value : defaultValue;\n    var bounds = value.map(function (v, i) {\n      return _trimAlignValue({\n        value: v,\n        handle: i,\n        props: props\n      });\n    });\n    var recent = bounds[0] === max ? 0 : bounds.length - 1;\n    _this.state = {\n      handle: null,\n      recent: recent,\n      bounds: bounds\n    };\n    return _this;\n  }\n  /**\n   * [Legacy] Used for inherit other component.\n   * It's a bad code style which should be refactor.\n   */\n\n  /* eslint-disable @typescript-eslint/no-unused-vars, class-methods-use-this */\n\n\n  _createClass(Range, [{\n    key: \"calcValueByPos\",\n    value: function calcValueByPos(value) {\n      return 0;\n    }\n  }, {\n    key: \"getSliderLength\",\n    value: function getSliderLength() {\n      return 0;\n    }\n  }, {\n    key: \"calcOffset\",\n    value: function calcOffset(value) {\n      return 0;\n    }\n  }, {\n    key: \"saveHandle\",\n    value: function saveHandle(index, h) {}\n  }, {\n    key: \"removeDocumentEvents\",\n    value: function removeDocumentEvents() {}\n  }, {\n    key: \"componentDidUpdate\",\n    value: function componentDidUpdate(prevProps, prevState) {\n      var _this2 = this;\n\n      var _this$props = this.props,\n          onChange = _this$props.onChange,\n          value = _this$props.value,\n          min = _this$props.min,\n          max = _this$props.max;\n\n      if (!('min' in this.props || 'max' in this.props)) {\n        return;\n      }\n\n      if (min === prevProps.min && max === prevProps.max) {\n        return;\n      }\n\n      var currentValue = value || prevState.bounds;\n\n      if (currentValue.some(function (v) {\n        return utils.isValueOutOfRange(v, _this2.props);\n      })) {\n        var newValues = currentValue.map(function (v) {\n          return utils.ensureValueInRange(v, _this2.props);\n        });\n        onChange(newValues);\n      }\n    }\n  }, {\n    key: \"onChange\",\n    value: function onChange(state) {\n      var props = this.props;\n      var isNotControlled = !('value' in props);\n\n      if (isNotControlled) {\n        this.setState(state);\n      } else {\n        var controlledState = {};\n        ['handle', 'recent'].forEach(function (item) {\n          if (state[item] !== undefined) {\n            controlledState[item] = state[item];\n          }\n        });\n\n        if (Object.keys(controlledState).length) {\n          this.setState(controlledState);\n        }\n      }\n\n      var data = _objectSpread(_objectSpread({}, this.state), state);\n\n      var changedValue = data.bounds;\n      props.onChange(changedValue);\n    }\n  }, {\n    key: \"onStart\",\n    value: function onStart(position) {\n      var props = this.props,\n          state = this.state;\n      var bounds = this.getValue();\n      props.onBeforeChange(bounds);\n      var value = this.calcValueByPos(position);\n      this.startValue = value;\n      this.startPosition = position;\n      var closestBound = this.getClosestBound(value);\n      this.prevMovedHandleIndex = this.getBoundNeedMoving(value, closestBound);\n      this.setState({\n        handle: this.prevMovedHandleIndex,\n        recent: this.prevMovedHandleIndex\n      });\n      var prevValue = bounds[this.prevMovedHandleIndex];\n      if (value === prevValue) return;\n\n      var nextBounds = _toConsumableArray(state.bounds);\n\n      nextBounds[this.prevMovedHandleIndex] = value;\n      this.onChange({\n        bounds: nextBounds\n      });\n    }\n  }, {\n    key: \"onMove\",\n    value: function onMove(e, position, dragTrack, startBounds) {\n      utils.pauseEvent(e);\n      var state = this.state,\n          props = this.props;\n      var maxValue = props.max || 100;\n      var minValue = props.min || 0;\n\n      if (dragTrack) {\n        var pos = props.vertical ? -position : position;\n        pos = props.reverse ? -pos : pos;\n        var max = maxValue - Math.max.apply(Math, _toConsumableArray(startBounds));\n        var min = minValue - Math.min.apply(Math, _toConsumableArray(startBounds));\n        var ratio = Math.min(Math.max(pos / (this.getSliderLength() / 100), min), max);\n        var nextBounds = startBounds.map(function (v) {\n          return Math.floor(Math.max(Math.min(v + ratio, maxValue), minValue));\n        });\n\n        if (state.bounds.map(function (c, i) {\n          return c === nextBounds[i];\n        }).some(function (c) {\n          return !c;\n        })) {\n          this.onChange({\n            bounds: nextBounds\n          });\n        }\n\n        return;\n      }\n\n      var value = this.calcValueByPos(position);\n      var oldValue = state.bounds[state.handle];\n      if (value === oldValue) return;\n      this.moveTo(value);\n    }\n  }, {\n    key: \"onKeyboard\",\n    value: function onKeyboard(e) {\n      var _this$props2 = this.props,\n          reverse = _this$props2.reverse,\n          vertical = _this$props2.vertical;\n      var valueMutator = utils.getKeyboardValueMutator(e, vertical, reverse);\n\n      if (valueMutator) {\n        utils.pauseEvent(e);\n        var state = this.state,\n            props = this.props;\n        var bounds = state.bounds,\n            handle = state.handle;\n        var oldValue = bounds[handle === null ? state.recent : handle];\n        var mutatedValue = valueMutator(oldValue, props);\n\n        var value = _trimAlignValue({\n          value: mutatedValue,\n          handle: handle,\n          bounds: state.bounds,\n          props: props\n        });\n\n        if (value === oldValue) return;\n        var isFromKeyboardEvent = true;\n        this.moveTo(value, isFromKeyboardEvent);\n      }\n    }\n  }, {\n    key: \"getValue\",\n    value: function getValue() {\n      return this.state.bounds;\n    }\n  }, {\n    key: \"getClosestBound\",\n    value: function getClosestBound(value) {\n      var bounds = this.state.bounds;\n      var closestBound = 0;\n\n      for (var i = 1; i < bounds.length - 1; i += 1) {\n        if (value >= bounds[i]) {\n          closestBound = i;\n        }\n      }\n\n      if (Math.abs(bounds[closestBound + 1] - value) < Math.abs(bounds[closestBound] - value)) {\n        closestBound += 1;\n      }\n\n      return closestBound;\n    }\n  }, {\n    key: \"getBoundNeedMoving\",\n    value: function getBoundNeedMoving(value, closestBound) {\n      var _this$state = this.state,\n          bounds = _this$state.bounds,\n          recent = _this$state.recent;\n      var boundNeedMoving = closestBound;\n      var isAtTheSamePoint = bounds[closestBound + 1] === bounds[closestBound];\n\n      if (isAtTheSamePoint && bounds[recent] === bounds[closestBound]) {\n        boundNeedMoving = recent;\n      }\n\n      if (isAtTheSamePoint && value !== bounds[closestBound + 1]) {\n        boundNeedMoving = value < bounds[closestBound + 1] ? closestBound : closestBound + 1;\n      }\n\n      return boundNeedMoving;\n    }\n  }, {\n    key: \"getLowerBound\",\n    value: function getLowerBound() {\n      return this.state.bounds[0];\n    }\n  }, {\n    key: \"getUpperBound\",\n    value: function getUpperBound() {\n      var bounds = this.state.bounds;\n      return bounds[bounds.length - 1];\n    }\n    /**\n     * Returns an array of possible slider points, taking into account both\n     * `marks` and `step`. The result is cached.\n     */\n\n  }, {\n    key: \"getPoints\",\n    value: function getPoints() {\n      var _this$props3 = this.props,\n          marks = _this$props3.marks,\n          step = _this$props3.step,\n          min = _this$props3.min,\n          max = _this$props3.max;\n      var cache = this.internalPointsCache;\n\n      if (!cache || cache.marks !== marks || cache.step !== step) {\n        var pointsObject = _objectSpread({}, marks);\n\n        if (step !== null) {\n          for (var point = min; point <= max; point += step) {\n            pointsObject[point] = point;\n          }\n        }\n\n        var points = Object.keys(pointsObject).map(parseFloat);\n        points.sort(function (a, b) {\n          return a - b;\n        });\n        this.internalPointsCache = {\n          marks: marks,\n          step: step,\n          points: points\n        };\n      }\n\n      return this.internalPointsCache.points;\n    }\n  }, {\n    key: \"moveTo\",\n    value: function moveTo(value, isFromKeyboardEvent) {\n      var _this3 = this;\n\n      var state = this.state,\n          props = this.props;\n\n      var nextBounds = _toConsumableArray(state.bounds);\n\n      var handle = state.handle === null ? state.recent : state.handle;\n      nextBounds[handle] = value;\n      var nextHandle = handle;\n\n      if (props.pushable !== false) {\n        this.pushSurroundingHandles(nextBounds, nextHandle);\n      } else if (props.allowCross) {\n        nextBounds.sort(function (a, b) {\n          return a - b;\n        });\n        nextHandle = nextBounds.indexOf(value);\n      }\n\n      this.onChange({\n        recent: nextHandle,\n        handle: nextHandle,\n        bounds: nextBounds\n      });\n\n      if (isFromKeyboardEvent) {\n        // known problem: because setState is async,\n        // so trigger focus will invoke handler's onEnd and another handler's onStart too early,\n        // cause onBeforeChange and onAfterChange receive wrong value.\n        // here use setState callback to hack，but not elegant\n        this.props.onAfterChange(nextBounds);\n        this.setState({}, function () {\n          _this3.handlesRefs[nextHandle].focus();\n        });\n        this.onEnd();\n      }\n    }\n  }, {\n    key: \"pushSurroundingHandles\",\n    value: function pushSurroundingHandles(bounds, handle) {\n      var value = bounds[handle];\n      var pushable = this.props.pushable;\n      var threshold = Number(pushable);\n      var direction = 0;\n\n      if (bounds[handle + 1] - value < threshold) {\n        direction = +1; // push to right\n      }\n\n      if (value - bounds[handle - 1] < threshold) {\n        direction = -1; // push to left\n      }\n\n      if (direction === 0) {\n        return;\n      }\n\n      var nextHandle = handle + direction;\n      var diffToNext = direction * (bounds[nextHandle] - value);\n\n      if (!this.pushHandle(bounds, nextHandle, direction, threshold - diffToNext)) {\n        // revert to original value if pushing is impossible\n        // eslint-disable-next-line no-param-reassign\n        bounds[handle] = bounds[nextHandle] - direction * threshold;\n      }\n    }\n  }, {\n    key: \"pushHandle\",\n    value: function pushHandle(bounds, handle, direction, amount) {\n      var originalValue = bounds[handle];\n      var currentValue = bounds[handle];\n\n      while (direction * (currentValue - originalValue) < amount) {\n        if (!this.pushHandleOnePoint(bounds, handle, direction)) {\n          // can't push handle enough to create the needed `amount` gap, so we\n          // revert its position to the original value\n          // eslint-disable-next-line no-param-reassign\n          bounds[handle] = originalValue;\n          return false;\n        }\n\n        currentValue = bounds[handle];\n      } // the handle was pushed enough to create the needed `amount` gap\n\n\n      return true;\n    }\n  }, {\n    key: \"pushHandleOnePoint\",\n    value: function pushHandleOnePoint(bounds, handle, direction) {\n      var points = this.getPoints();\n      var pointIndex = points.indexOf(bounds[handle]);\n      var nextPointIndex = pointIndex + direction;\n\n      if (nextPointIndex >= points.length || nextPointIndex < 0) {\n        // reached the minimum or maximum available point, can't push anymore\n        return false;\n      }\n\n      var nextHandle = handle + direction;\n      var nextValue = points[nextPointIndex];\n      var pushable = this.props.pushable;\n      var threshold = Number(pushable);\n      var diffToNext = direction * (bounds[nextHandle] - nextValue);\n\n      if (!this.pushHandle(bounds, nextHandle, direction, threshold - diffToNext)) {\n        // couldn't push next handle, so we won't push this one either\n        return false;\n      } // push the handle\n      // eslint-disable-next-line no-param-reassign\n\n\n      bounds[handle] = nextValue;\n      return true;\n    }\n  }, {\n    key: \"trimAlignValue\",\n    value: function trimAlignValue(value) {\n      var _this$state2 = this.state,\n          handle = _this$state2.handle,\n          bounds = _this$state2.bounds;\n      return _trimAlignValue({\n        value: value,\n        handle: handle,\n        bounds: bounds,\n        props: this.props\n      });\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var _this4 = this;\n\n      var _this$state3 = this.state,\n          handle = _this$state3.handle,\n          bounds = _this$state3.bounds;\n      var _this$props4 = this.props,\n          prefixCls = _this$props4.prefixCls,\n          vertical = _this$props4.vertical,\n          included = _this$props4.included,\n          disabled = _this$props4.disabled,\n          min = _this$props4.min,\n          max = _this$props4.max,\n          reverse = _this$props4.reverse,\n          handleGenerator = _this$props4.handle,\n          trackStyle = _this$props4.trackStyle,\n          handleStyle = _this$props4.handleStyle,\n          tabIndex = _this$props4.tabIndex,\n          ariaLabelGroupForHandles = _this$props4.ariaLabelGroupForHandles,\n          ariaLabelledByGroupForHandles = _this$props4.ariaLabelledByGroupForHandles,\n          ariaValueTextFormatterGroupForHandles = _this$props4.ariaValueTextFormatterGroupForHandles;\n      var offsets = bounds.map(function (v) {\n        return _this4.calcOffset(v);\n      });\n      var handleClassName = \"\".concat(prefixCls, \"-handle\");\n      var handles = bounds.map(function (v, i) {\n        var _classNames;\n\n        var mergedTabIndex = tabIndex[i] || 0;\n\n        if (disabled || tabIndex[i] === null) {\n          mergedTabIndex = null;\n        }\n\n        var dragging = handle === i;\n        return handleGenerator({\n          className: classNames((_classNames = {}, _defineProperty(_classNames, handleClassName, true), _defineProperty(_classNames, \"\".concat(handleClassName, \"-\").concat(i + 1), true), _defineProperty(_classNames, \"\".concat(handleClassName, \"-dragging\"), dragging), _classNames)),\n          prefixCls: prefixCls,\n          vertical: vertical,\n          dragging: dragging,\n          offset: offsets[i],\n          value: v,\n          index: i,\n          tabIndex: mergedTabIndex,\n          min: min,\n          max: max,\n          reverse: reverse,\n          disabled: disabled,\n          style: handleStyle[i],\n          ref: function ref(h) {\n            return _this4.saveHandle(i, h);\n          },\n          ariaLabel: ariaLabelGroupForHandles[i],\n          ariaLabelledBy: ariaLabelledByGroupForHandles[i],\n          ariaValueTextFormatter: ariaValueTextFormatterGroupForHandles[i]\n        });\n      });\n      var tracks = bounds.slice(0, -1).map(function (_, index) {\n        var _classNames2;\n\n        var i = index + 1;\n        var trackClassName = classNames((_classNames2 = {}, _defineProperty(_classNames2, \"\".concat(prefixCls, \"-track\"), true), _defineProperty(_classNames2, \"\".concat(prefixCls, \"-track-\").concat(i), true), _classNames2));\n        return /*#__PURE__*/React.createElement(Track, {\n          className: trackClassName,\n          vertical: vertical,\n          reverse: reverse,\n          included: included,\n          offset: offsets[i - 1],\n          length: offsets[i] - offsets[i - 1],\n          style: trackStyle[index],\n          key: i\n        });\n      });\n      return {\n        tracks: tracks,\n        handles: handles\n      };\n    }\n  }], [{\n    key: \"getDerivedStateFromProps\",\n    value: function getDerivedStateFromProps(props, state) {\n      if (!('value' in props || 'min' in props || 'max' in props)) {\n        return null;\n      }\n\n      var value = props.value || state.bounds;\n      var nextBounds = value.map(function (v, i) {\n        return _trimAlignValue({\n          value: v,\n          handle: i,\n          bounds: state.bounds,\n          props: props\n        });\n      });\n\n      if (state.bounds.length === nextBounds.length) {\n        if (nextBounds.every(function (v, i) {\n          return v === state.bounds[i];\n        })) {\n          return null;\n        }\n      } else {\n        nextBounds = value.map(function (v, i) {\n          return _trimAlignValue({\n            value: v,\n            handle: i,\n            props: props\n          });\n        });\n      }\n\n      return _objectSpread(_objectSpread({}, state), {}, {\n        bounds: nextBounds\n      });\n    }\n  }]);\n\n  return Range;\n}(React.Component);\n/* eslint-enable */\n\n\nRange.displayName = 'Range';\nRange.defaultProps = {\n  count: 1,\n  allowCross: true,\n  pushable: false,\n  draggableTrack: false,\n  tabIndex: [],\n  ariaLabelGroupForHandles: [],\n  ariaLabelledByGroupForHandles: [],\n  ariaValueTextFormatterGroupForHandles: []\n};\nexport default createSlider(Range);","var raf = function raf(callback) {\n  return +setTimeout(callback, 16);\n};\nvar caf = function caf(num) {\n  return clearTimeout(num);\n};\nif (typeof window !== 'undefined' && 'requestAnimationFrame' in window) {\n  raf = function raf(callback) {\n    return window.requestAnimationFrame(callback);\n  };\n  caf = function caf(handle) {\n    return window.cancelAnimationFrame(handle);\n  };\n}\nvar rafUUID = 0;\nvar rafIds = new Map();\nfunction cleanup(id) {\n  rafIds.delete(id);\n}\nvar wrapperRaf = function wrapperRaf(callback) {\n  var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n  rafUUID += 1;\n  var id = rafUUID;\n  function callRef(leftTimes) {\n    if (leftTimes === 0) {\n      // Clean up\n      cleanup(id);\n\n      // Trigger\n      callback();\n    } else {\n      // Next raf\n      var realId = raf(function () {\n        callRef(leftTimes - 1);\n      });\n\n      // Bind real raf id\n      rafIds.set(id, realId);\n    }\n  }\n  callRef(times);\n  return id;\n};\nwrapperRaf.cancel = function (id) {\n  var realId = rafIds.get(id);\n  cleanup(id);\n  return caf(realId);\n};\nif (process.env.NODE_ENV !== 'production') {\n  wrapperRaf.ids = function () {\n    return rafIds;\n  };\n}\nexport default wrapperRaf;","export default function contains(root, n) {\n  if (!root) {\n    return false;\n  }\n\n  // Use native if support\n  if (root.contains) {\n    return root.contains(n);\n  }\n\n  // `document.contains` not support with IE11\n  var node = n;\n  while (node) {\n    if (node === root) {\n      return true;\n    }\n    node = node.parentNode;\n  }\n  return false;\n}","import _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport React from 'react';\nimport ReactDOM from 'react-dom';\nexport function isDOM(node) {\n  // https://developer.mozilla.org/en-US/docs/Web/API/Element\n  // Since XULElement is also subclass of Element, we only need HTMLElement and SVGElement\n  return node instanceof HTMLElement || node instanceof SVGElement;\n}\n\n/**\n * Retrieves a DOM node via a ref, and does not invoke `findDOMNode`.\n */\nexport function getDOM(node) {\n  if (node && _typeof(node) === 'object' && isDOM(node.nativeElement)) {\n    return node.nativeElement;\n  }\n  if (isDOM(node)) {\n    return node;\n  }\n  return null;\n}\n\n/**\n * Return if a node is a DOM node. Else will return by `findDOMNode`\n */\nexport default function findDOMNode(node) {\n  var domNode = getDOM(node);\n  if (domNode) {\n    return domNode;\n  }\n  if (node instanceof React.Component) {\n    var _ReactDOM$findDOMNode;\n    return (_ReactDOM$findDOMNode = ReactDOM.findDOMNode) === null || _ReactDOM$findDOMNode === void 0 ? void 0 : _ReactDOM$findDOMNode.call(ReactDOM, node);\n  }\n  return null;\n}","import _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport { isValidElement, version } from 'react';\nimport { ForwardRef, isFragment, isMemo } from 'react-is';\nimport useMemo from \"./hooks/useMemo\";\nexport var fillRef = function fillRef(ref, node) {\n  if (typeof ref === 'function') {\n    ref(node);\n  } else if (_typeof(ref) === 'object' && ref && 'current' in ref) {\n    ref.current = node;\n  }\n};\n\n/**\n * Merge refs into one ref function to support ref passing.\n */\nexport var composeRef = function composeRef() {\n  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {\n    refs[_key] = arguments[_key];\n  }\n  var refList = refs.filter(Boolean);\n  if (refList.length <= 1) {\n    return refList[0];\n  }\n  return function (node) {\n    refs.forEach(function (ref) {\n      fillRef(ref, node);\n    });\n  };\n};\nexport var useComposeRef = function useComposeRef() {\n  for (var _len2 = arguments.length, refs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n    refs[_key2] = arguments[_key2];\n  }\n  return useMemo(function () {\n    return composeRef.apply(void 0, refs);\n  }, refs, function (prev, next) {\n    return prev.length !== next.length || prev.every(function (ref, i) {\n      return ref !== next[i];\n    });\n  });\n};\nexport var supportRef = function supportRef(nodeOrComponent) {\n  var _type$prototype, _nodeOrComponent$prot;\n  var type = isMemo(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;\n\n  // Function component node\n  if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render) && type.$$typeof !== ForwardRef) {\n    return false;\n  }\n\n  // Class component\n  if (typeof nodeOrComponent === 'function' && !((_nodeOrComponent$prot = nodeOrComponent.prototype) !== null && _nodeOrComponent$prot !== void 0 && _nodeOrComponent$prot.render) && nodeOrComponent.$$typeof !== ForwardRef) {\n    return false;\n  }\n  return true;\n};\nfunction isReactElement(node) {\n  return /*#__PURE__*/isValidElement(node) && !isFragment(node);\n}\nexport var supportNodeRef = function supportNodeRef(node) {\n  return isReactElement(node) && supportRef(node);\n};\n\n/**\n * In React 19. `ref` is not a property from node.\n * But a property from `props.ref`.\n * To check if `props.ref` exist or fallback to `ref`.\n */\nexport var getNodeRef = Number(version.split('.')[0]) >= 19 ?\n// >= React 19\nfunction (node) {\n  if (isReactElement(node)) {\n    return node.props.ref;\n  }\n  return null;\n} :\n// < React 19\nfunction (node) {\n  if (isReactElement(node)) {\n    return node.ref;\n  }\n  return null;\n};","export default function canUseDom() {\n  return !!(typeof window !== 'undefined' && window.document && window.document.createElement);\n}","import { useRef, useEffect, forwardRef, useImperativeHandle } from 'react';\nimport ReactDOM from 'react-dom';\nimport canUseDom from \"./Dom/canUseDom\";\nvar Portal = /*#__PURE__*/forwardRef(function (props, ref) {\n  var didUpdate = props.didUpdate,\n    getContainer = props.getContainer,\n    children = props.children;\n  var parentRef = useRef();\n  var containerRef = useRef();\n\n  // Ref return nothing, only for wrapper check exist\n  useImperativeHandle(ref, function () {\n    return {};\n  });\n\n  // Create container in client side with sync to avoid useEffect not get ref\n  var initRef = useRef(false);\n  if (!initRef.current && canUseDom()) {\n    containerRef.current = getContainer();\n    parentRef.current = containerRef.current.parentNode;\n    initRef.current = true;\n  }\n\n  // [Legacy] Used by `rc-trigger`\n  useEffect(function () {\n    didUpdate === null || didUpdate === void 0 || didUpdate(props);\n  });\n  useEffect(function () {\n    // Restore container to original place\n    // React 18 StrictMode will unmount first and mount back for effect test:\n    // https://reactjs.org/blog/2022/03/29/react-v18.html#new-strict-mode-behaviors\n    if (containerRef.current.parentNode === null && parentRef.current !== null) {\n      parentRef.current.appendChild(containerRef.current);\n    }\n    return function () {\n      var _containerRef$current;\n      // [Legacy] This should not be handle by Portal but parent PortalWrapper instead.\n      // Since some component use `Portal` directly, we have to keep the logic here.\n      (_containerRef$current = containerRef.current) === null || _containerRef$current === void 0 || (_containerRef$current = _containerRef$current.parentNode) === null || _containerRef$current === void 0 || _containerRef$current.removeChild(containerRef.current);\n    };\n  }, []);\n  return containerRef.current ? /*#__PURE__*/ReactDOM.createPortal(children, containerRef.current) : null;\n});\nexport default Portal;","import _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\n\nfunction isPointsEq(a1, a2, isAlignPoint) {\n  if (isAlignPoint) {\n    return a1[0] === a2[0];\n  }\n\n  return a1[0] === a2[0] && a1[1] === a2[1];\n}\n\nexport function getAlignFromPlacement(builtinPlacements, placementStr, align) {\n  var baseAlign = builtinPlacements[placementStr] || {};\n  return _objectSpread(_objectSpread({}, baseAlign), align);\n}\nexport function getAlignPopupClassName(builtinPlacements, prefixCls, align, isAlignPoint) {\n  var points = align.points;\n  var placements = Object.keys(builtinPlacements);\n\n  for (var i = 0; i < placements.length; i += 1) {\n    var placement = placements[i];\n\n    if (isPointsEq(builtinPlacements[placement].points, points, isAlignPoint)) {\n      return \"\".concat(prefixCls, \"-placement-\").concat(placement);\n    }\n  }\n\n  return '';\n}","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nfunction _slicedToArray(r, e) {\n  return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest();\n}\nexport { _slicedToArray as default };","function _arrayWithHoles(r) {\n  if (Array.isArray(r)) return r;\n}\nexport { _arrayWithHoles as default };","function _iterableToArrayLimit(r, l) {\n  var t = null == r ? null : \"undefined\" != typeof Symbol && r[Symbol.iterator] || r[\"@@iterator\"];\n  if (null != t) {\n    var e,\n      n,\n      i,\n      u,\n      a = [],\n      f = !0,\n      o = !1;\n    try {\n      if (i = (t = t.call(r)).next, 0 === l) {\n        if (Object(t) !== t) return;\n        f = !1;\n      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);\n    } catch (r) {\n      o = !0, n = r;\n    } finally {\n      try {\n        if (!f && null != t[\"return\"] && (u = t[\"return\"](), Object(u) !== u)) return;\n      } finally {\n        if (o) throw n;\n      }\n    }\n    return a;\n  }\n}\nexport { _iterableToArrayLimit as default };","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableRest as default };","export default (function () {\n  if (typeof navigator === 'undefined' || typeof window === 'undefined') {\n    return false;\n  }\n  var agent = navigator.userAgent || navigator.vendor || window.opera;\n  return /(android|bb\\d+|meego).+mobile|avantgo|bada\\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(agent) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(agent === null || agent === void 0 ? void 0 : agent.substr(0, 4));\n});","import _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nvar _excluded = [\"children\"];\nimport * as React from 'react';\nexport var Context = /*#__PURE__*/React.createContext({});\nexport default function MotionProvider(_ref) {\n  var children = _ref.children,\n    props = _objectWithoutProperties(_ref, _excluded);\n  return /*#__PURE__*/React.createElement(Context.Provider, {\n    value: props\n  }, children);\n}","import _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _createSuper from \"@babel/runtime/helpers/esm/createSuper\";\nimport * as React from 'react';\nvar DomWrapper = /*#__PURE__*/function (_React$Component) {\n  _inherits(DomWrapper, _React$Component);\n  var _super = _createSuper(DomWrapper);\n  function DomWrapper() {\n    _classCallCheck(this, DomWrapper);\n    return _super.apply(this, arguments);\n  }\n  _createClass(DomWrapper, [{\n    key: \"render\",\n    value: function render() {\n      return this.props.children;\n    }\n  }]);\n  return DomWrapper;\n}(React.Component);\nexport default DomWrapper;","import * as React from 'react';\nexport default function useEvent(callback) {\n  var fnRef = React.useRef();\n  fnRef.current = callback;\n  var memoFn = React.useCallback(function () {\n    var _fnRef$current;\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return (_fnRef$current = fnRef.current) === null || _fnRef$current === void 0 ? void 0 : _fnRef$current.call.apply(_fnRef$current, [fnRef].concat(args));\n  }, []);\n  return memoFn;\n}","import * as React from 'react';\nimport canUseDom from \"../Dom/canUseDom\";\n\n/**\n * Wrap `React.useLayoutEffect` which will not throw warning message in test env\n */\nvar useInternalLayoutEffect = process.env.NODE_ENV !== 'test' && canUseDom() ? React.useLayoutEffect : React.useEffect;\nvar useLayoutEffect = function useLayoutEffect(callback, deps) {\n  var firstMountRef = React.useRef(true);\n  useInternalLayoutEffect(function () {\n    return callback(firstMountRef.current);\n  }, deps);\n\n  // We tell react that first mount has passed\n  useInternalLayoutEffect(function () {\n    firstMountRef.current = false;\n    return function () {\n      firstMountRef.current = true;\n    };\n  }, []);\n};\nexport var useLayoutUpdateEffect = function useLayoutUpdateEffect(callback, deps) {\n  useLayoutEffect(function (firstMount) {\n    if (!firstMount) {\n      return callback();\n    }\n  }, deps);\n};\nexport default useLayoutEffect;","import _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport * as React from 'react';\n/**\n * Same as React.useState but `setState` accept `ignoreDestroy` param to not to setState after destroyed.\n * We do not make this auto is to avoid real memory leak.\n * Developer should confirm it's safe to ignore themselves.\n */\nexport default function useSafeState(defaultValue) {\n  var destroyRef = React.useRef(false);\n  var _React$useState = React.useState(defaultValue),\n    _React$useState2 = _slicedToArray(_React$useState, 2),\n    value = _React$useState2[0],\n    setValue = _React$useState2[1];\n  React.useEffect(function () {\n    destroyRef.current = false;\n    return function () {\n      destroyRef.current = true;\n    };\n  }, []);\n  function safeSetState(updater, ignoreDestroy) {\n    if (ignoreDestroy && destroyRef.current) {\n      return;\n    }\n    setValue(updater);\n  }\n  return [value, safeSetState];\n}","import _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _toConsumableArray from \"@babel/runtime/helpers/esm/toConsumableArray\";\nimport _toArray from \"@babel/runtime/helpers/esm/toArray\";\nimport get from \"./get\";\nfunction internalSet(entity, paths, value, removeIfUndefined) {\n  if (!paths.length) {\n    return value;\n  }\n  var _paths = _toArray(paths),\n    path = _paths[0],\n    restPath = _paths.slice(1);\n  var clone;\n  if (!entity && typeof path === 'number') {\n    clone = [];\n  } else if (Array.isArray(entity)) {\n    clone = _toConsumableArray(entity);\n  } else {\n    clone = _objectSpread({}, entity);\n  }\n\n  // Delete prop if `removeIfUndefined` and value is undefined\n  if (removeIfUndefined && value === undefined && restPath.length === 1) {\n    delete clone[path][restPath[0]];\n  } else {\n    clone[path] = internalSet(clone[path], restPath, value, removeIfUndefined);\n  }\n  return clone;\n}\nexport default function set(entity, paths, value) {\n  var removeIfUndefined = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n  // Do nothing if `removeIfUndefined` and parent object not exist\n  if (paths.length && removeIfUndefined && value === undefined && !get(entity, paths.slice(0, -1))) {\n    return entity;\n  }\n  return internalSet(entity, paths, value, removeIfUndefined);\n}\nfunction isObject(obj) {\n  return _typeof(obj) === 'object' && obj !== null && Object.getPrototypeOf(obj) === Object.prototype;\n}\nfunction createEmpty(source) {\n  return Array.isArray(source) ? [] : {};\n}\nvar keys = typeof Reflect === 'undefined' ? Object.keys : Reflect.ownKeys;\n\n/**\n * Merge objects which will create\n */\nexport function merge() {\n  for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {\n    sources[_key] = arguments[_key];\n  }\n  var clone = createEmpty(sources[0]);\n  sources.forEach(function (src) {\n    function internalMerge(path, parentLoopSet) {\n      var loopSet = new Set(parentLoopSet);\n      var value = get(src, path);\n      var isArr = Array.isArray(value);\n      if (isArr || isObject(value)) {\n        // Only add not loop obj\n        if (!loopSet.has(value)) {\n          loopSet.add(value);\n          var originValue = get(clone, path);\n          if (isArr) {\n            // Array will always be override\n            clone = set(clone, path, []);\n          } else if (!originValue || _typeof(originValue) !== 'object') {\n            // Init container if not exist\n            clone = set(clone, path, createEmpty(value));\n          }\n          keys(value).forEach(function (key) {\n            internalMerge([].concat(_toConsumableArray(path), [key]), loopSet);\n          });\n        }\n      } else {\n        clone = set(clone, path, value);\n      }\n    }\n    internalMerge([]);\n  });\n  return clone;\n}","export var STATUS_NONE = 'none';\nexport var STATUS_APPEAR = 'appear';\nexport var STATUS_ENTER = 'enter';\nexport var STATUS_LEAVE = 'leave';\nexport var STEP_NONE = 'none';\nexport var STEP_PREPARE = 'prepare';\nexport var STEP_START = 'start';\nexport var STEP_ACTIVE = 'active';\nexport var STEP_ACTIVATED = 'end';\n/**\n * Used for disabled motion case.\n * Prepare stage will still work but start & active will be skipped.\n */\nexport var STEP_PREPARED = 'prepared';","import _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport canUseDOM from \"rc-util/es/Dom/canUseDom\";\n// ================= Transition =================\n// Event wrapper. Copy from react source code\nfunction makePrefixMap(styleProp, eventName) {\n  var prefixes = {};\n  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();\n  prefixes[\"Webkit\".concat(styleProp)] = \"webkit\".concat(eventName);\n  prefixes[\"Moz\".concat(styleProp)] = \"moz\".concat(eventName);\n  prefixes[\"ms\".concat(styleProp)] = \"MS\".concat(eventName);\n  prefixes[\"O\".concat(styleProp)] = \"o\".concat(eventName.toLowerCase());\n  return prefixes;\n}\nexport function getVendorPrefixes(domSupport, win) {\n  var prefixes = {\n    animationend: makePrefixMap('Animation', 'AnimationEnd'),\n    transitionend: makePrefixMap('Transition', 'TransitionEnd')\n  };\n  if (domSupport) {\n    if (!('AnimationEvent' in win)) {\n      delete prefixes.animationend.animation;\n    }\n    if (!('TransitionEvent' in win)) {\n      delete prefixes.transitionend.transition;\n    }\n  }\n  return prefixes;\n}\nvar vendorPrefixes = getVendorPrefixes(canUseDOM(), typeof window !== 'undefined' ? window : {});\nvar style = {};\nif (canUseDOM()) {\n  var _document$createEleme = document.createElement('div');\n  style = _document$createEleme.style;\n}\nvar prefixedEventNames = {};\nexport function getVendorPrefixedEventName(eventName) {\n  if (prefixedEventNames[eventName]) {\n    return prefixedEventNames[eventName];\n  }\n  var prefixMap = vendorPrefixes[eventName];\n  if (prefixMap) {\n    var stylePropList = Object.keys(prefixMap);\n    var len = stylePropList.length;\n    for (var i = 0; i < len; i += 1) {\n      var styleProp = stylePropList[i];\n      if (Object.prototype.hasOwnProperty.call(prefixMap, styleProp) && styleProp in style) {\n        prefixedEventNames[eventName] = prefixMap[styleProp];\n        return prefixedEventNames[eventName];\n      }\n    }\n  }\n  return '';\n}\nvar internalAnimationEndName = getVendorPrefixedEventName('animationend');\nvar internalTransitionEndName = getVendorPrefixedEventName('transitionend');\nexport var supportTransition = !!(internalAnimationEndName && internalTransitionEndName);\nexport var animationEndName = internalAnimationEndName || 'animationend';\nexport var transitionEndName = internalTransitionEndName || 'transitionend';\nexport function getTransitionName(transitionName, transitionType) {\n  if (!transitionName) return null;\n  if (_typeof(transitionName) === 'object') {\n    var type = transitionType.replace(/-\\w/g, function (match) {\n      return match[1].toUpperCase();\n    });\n    return transitionName[type];\n  }\n  return \"\".concat(transitionName, \"-\").concat(transitionType);\n}","import * as React from 'react';\nimport { useRef } from 'react';\nimport { animationEndName, transitionEndName } from \"../util/motion\";\nexport default (function (onInternalMotionEnd) {\n  var cacheElementRef = useRef();\n\n  // Remove events\n  function removeMotionEvents(element) {\n    if (element) {\n      element.removeEventListener(transitionEndName, onInternalMotionEnd);\n      element.removeEventListener(animationEndName, onInternalMotionEnd);\n    }\n  }\n\n  // Patch events\n  function patchMotionEvents(element) {\n    if (cacheElementRef.current && cacheElementRef.current !== element) {\n      removeMotionEvents(cacheElementRef.current);\n    }\n    if (element && element !== cacheElementRef.current) {\n      element.addEventListener(transitionEndName, onInternalMotionEnd);\n      element.addEventListener(animationEndName, onInternalMotionEnd);\n\n      // Save as cache in case dom removed trigger by `motionDeadline`\n      cacheElementRef.current = element;\n    }\n  }\n\n  // Clean up when removed\n  React.useEffect(function () {\n    return function () {\n      removeMotionEvents(cacheElementRef.current);\n    };\n  }, []);\n  return [patchMotionEvents, removeMotionEvents];\n});","import canUseDom from \"rc-util/es/Dom/canUseDom\";\nimport { useEffect, useLayoutEffect } from 'react';\n\n// It's safe to use `useLayoutEffect` but the warning is annoying\nvar useIsomorphicLayoutEffect = canUseDom() ? useLayoutEffect : useEffect;\nexport default useIsomorphicLayoutEffect;","import _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport useState from \"rc-util/es/hooks/useState\";\nimport * as React from 'react';\nimport { STEP_ACTIVATED, STEP_ACTIVE, STEP_NONE, STEP_PREPARE, STEP_PREPARED, STEP_START } from \"../interface\";\nimport useIsomorphicLayoutEffect from \"./useIsomorphicLayoutEffect\";\nimport useNextFrame from \"./useNextFrame\";\nvar FULL_STEP_QUEUE = [STEP_PREPARE, STEP_START, STEP_ACTIVE, STEP_ACTIVATED];\nvar SIMPLE_STEP_QUEUE = [STEP_PREPARE, STEP_PREPARED];\n\n/** Skip current step */\nexport var SkipStep = false;\n/** Current step should be update in */\nexport var DoStep = true;\nexport function isActive(step) {\n  return step === STEP_ACTIVE || step === STEP_ACTIVATED;\n}\nexport default (function (status, prepareOnly, callback) {\n  var _useState = useState(STEP_NONE),\n    _useState2 = _slicedToArray(_useState, 2),\n    step = _useState2[0],\n    setStep = _useState2[1];\n  var _useNextFrame = useNextFrame(),\n    _useNextFrame2 = _slicedToArray(_useNextFrame, 2),\n    nextFrame = _useNextFrame2[0],\n    cancelNextFrame = _useNextFrame2[1];\n  function startQueue() {\n    setStep(STEP_PREPARE, true);\n  }\n  var STEP_QUEUE = prepareOnly ? SIMPLE_STEP_QUEUE : FULL_STEP_QUEUE;\n  useIsomorphicLayoutEffect(function () {\n    if (step !== STEP_NONE && step !== STEP_ACTIVATED) {\n      var index = STEP_QUEUE.indexOf(step);\n      var nextStep = STEP_QUEUE[index + 1];\n      var result = callback(step);\n      if (result === SkipStep) {\n        // Skip when no needed\n        setStep(nextStep, true);\n      } else if (nextStep) {\n        // Do as frame for step update\n        nextFrame(function (info) {\n          function doNext() {\n            // Skip since current queue is ood\n            if (info.isCanceled()) return;\n            setStep(nextStep, true);\n          }\n          if (result === true) {\n            doNext();\n          } else {\n            // Only promise should be async\n            Promise.resolve(result).then(doNext);\n          }\n        });\n      }\n    }\n  }, [status, step]);\n  React.useEffect(function () {\n    return function () {\n      cancelNextFrame();\n    };\n  }, []);\n  return [startQueue, step];\n});","import _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport _typeof from \"@babel/runtime/helpers/esm/typeof\";\n/* eslint-disable react/default-props-match-prop-types, react/no-multi-comp, react/prop-types */\nimport classNames from 'classnames';\nimport findDOMNode from \"rc-util/es/Dom/findDOMNode\";\nimport { fillRef, supportRef } from \"rc-util/es/ref\";\nimport * as React from 'react';\nimport { useRef } from 'react';\nimport { Context } from \"./context\";\nimport DomWrapper from \"./DomWrapper\";\nimport useStatus from \"./hooks/useStatus\";\nimport { isActive } from \"./hooks/useStepQueue\";\nimport { STATUS_NONE, STEP_PREPARE, STEP_START } from \"./interface\";\nimport { getTransitionName, supportTransition } from \"./util/motion\";\n/**\n * `transitionSupport` is used for none transition test case.\n * Default we use browser transition event support check.\n */\nexport function genCSSMotion(config) {\n  var transitionSupport = config;\n  if (_typeof(config) === 'object') {\n    transitionSupport = config.transitionSupport;\n  }\n  function isSupportTransition(props, contextMotion) {\n    return !!(props.motionName && transitionSupport && contextMotion !== false);\n  }\n  var CSSMotion = /*#__PURE__*/React.forwardRef(function (props, ref) {\n    var _props$visible = props.visible,\n      visible = _props$visible === void 0 ? true : _props$visible,\n      _props$removeOnLeave = props.removeOnLeave,\n      removeOnLeave = _props$removeOnLeave === void 0 ? true : _props$removeOnLeave,\n      forceRender = props.forceRender,\n      children = props.children,\n      motionName = props.motionName,\n      leavedClassName = props.leavedClassName,\n      eventProps = props.eventProps;\n    var _React$useContext = React.useContext(Context),\n      contextMotion = _React$useContext.motion;\n    var supportMotion = isSupportTransition(props, contextMotion);\n\n    // Ref to the react node, it may be a HTMLElement\n    var nodeRef = useRef();\n    // Ref to the dom wrapper in case ref can not pass to HTMLElement\n    var wrapperNodeRef = useRef();\n    function getDomElement() {\n      try {\n        // Here we're avoiding call for findDOMNode since it's deprecated\n        // in strict mode. We're calling it only when node ref is not\n        // an instance of DOM HTMLElement. Otherwise use\n        // findDOMNode as a final resort\n        return nodeRef.current instanceof HTMLElement ? nodeRef.current : findDOMNode(wrapperNodeRef.current);\n      } catch (e) {\n        // Only happen when `motionDeadline` trigger but element removed.\n        return null;\n      }\n    }\n    var _useStatus = useStatus(supportMotion, visible, getDomElement, props),\n      _useStatus2 = _slicedToArray(_useStatus, 4),\n      status = _useStatus2[0],\n      statusStep = _useStatus2[1],\n      statusStyle = _useStatus2[2],\n      mergedVisible = _useStatus2[3];\n\n    // Record whether content has rendered\n    // Will return null for un-rendered even when `removeOnLeave={false}`\n    var renderedRef = React.useRef(mergedVisible);\n    if (mergedVisible) {\n      renderedRef.current = true;\n    }\n\n    // ====================== Refs ======================\n    var setNodeRef = React.useCallback(function (node) {\n      nodeRef.current = node;\n      fillRef(ref, node);\n    }, [ref]);\n\n    // ===================== Render =====================\n    var motionChildren;\n    var mergedProps = _objectSpread(_objectSpread({}, eventProps), {}, {\n      visible: visible\n    });\n    if (!children) {\n      // No children\n      motionChildren = null;\n    } else if (status === STATUS_NONE) {\n      // Stable children\n      if (mergedVisible) {\n        motionChildren = children(_objectSpread({}, mergedProps), setNodeRef);\n      } else if (!removeOnLeave && renderedRef.current && leavedClassName) {\n        motionChildren = children(_objectSpread(_objectSpread({}, mergedProps), {}, {\n          className: leavedClassName\n        }), setNodeRef);\n      } else if (forceRender || !removeOnLeave && !leavedClassName) {\n        motionChildren = children(_objectSpread(_objectSpread({}, mergedProps), {}, {\n          style: {\n            display: 'none'\n          }\n        }), setNodeRef);\n      } else {\n        motionChildren = null;\n      }\n    } else {\n      // In motion\n      var statusSuffix;\n      if (statusStep === STEP_PREPARE) {\n        statusSuffix = 'prepare';\n      } else if (isActive(statusStep)) {\n        statusSuffix = 'active';\n      } else if (statusStep === STEP_START) {\n        statusSuffix = 'start';\n      }\n      var motionCls = getTransitionName(motionName, \"\".concat(status, \"-\").concat(statusSuffix));\n      motionChildren = children(_objectSpread(_objectSpread({}, mergedProps), {}, {\n        className: classNames(getTransitionName(motionName, status), _defineProperty(_defineProperty({}, motionCls, motionCls && statusSuffix), motionName, typeof motionName === 'string')),\n        style: statusStyle\n      }), setNodeRef);\n    }\n\n    // Auto inject ref if child node not have `ref` props\n    if ( /*#__PURE__*/React.isValidElement(motionChildren) && supportRef(motionChildren)) {\n      var _ref = motionChildren,\n        originNodeRef = _ref.ref;\n      if (!originNodeRef) {\n        motionChildren = /*#__PURE__*/React.cloneElement(motionChildren, {\n          ref: setNodeRef\n        });\n      }\n    }\n    return /*#__PURE__*/React.createElement(DomWrapper, {\n      ref: wrapperNodeRef\n    }, motionChildren);\n  });\n  CSSMotion.displayName = 'CSSMotion';\n  return CSSMotion;\n}\nexport default genCSSMotion(supportTransition);","import _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport { useEvent } from 'rc-util';\nimport useState from \"rc-util/es/hooks/useState\";\nimport useSyncState from \"rc-util/es/hooks/useSyncState\";\nimport * as React from 'react';\nimport { useEffect, useRef } from 'react';\nimport { STATUS_APPEAR, STATUS_ENTER, STATUS_LEAVE, STATUS_NONE, STEP_ACTIVE, STEP_PREPARE, STEP_PREPARED, STEP_START } from \"../interface\";\nimport useDomMotionEvents from \"./useDomMotionEvents\";\nimport useIsomorphicLayoutEffect from \"./useIsomorphicLayoutEffect\";\nimport useStepQueue, { DoStep, isActive, SkipStep } from \"./useStepQueue\";\nexport default function useStatus(supportMotion, visible, getElement, _ref) {\n  var _ref$motionEnter = _ref.motionEnter,\n    motionEnter = _ref$motionEnter === void 0 ? true : _ref$motionEnter,\n    _ref$motionAppear = _ref.motionAppear,\n    motionAppear = _ref$motionAppear === void 0 ? true : _ref$motionAppear,\n    _ref$motionLeave = _ref.motionLeave,\n    motionLeave = _ref$motionLeave === void 0 ? true : _ref$motionLeave,\n    motionDeadline = _ref.motionDeadline,\n    motionLeaveImmediately = _ref.motionLeaveImmediately,\n    onAppearPrepare = _ref.onAppearPrepare,\n    onEnterPrepare = _ref.onEnterPrepare,\n    onLeavePrepare = _ref.onLeavePrepare,\n    onAppearStart = _ref.onAppearStart,\n    onEnterStart = _ref.onEnterStart,\n    onLeaveStart = _ref.onLeaveStart,\n    onAppearActive = _ref.onAppearActive,\n    onEnterActive = _ref.onEnterActive,\n    onLeaveActive = _ref.onLeaveActive,\n    onAppearEnd = _ref.onAppearEnd,\n    onEnterEnd = _ref.onEnterEnd,\n    onLeaveEnd = _ref.onLeaveEnd,\n    onVisibleChanged = _ref.onVisibleChanged;\n  // Used for outer render usage to avoid `visible: false & status: none` to render nothing\n  var _useState = useState(),\n    _useState2 = _slicedToArray(_useState, 2),\n    asyncVisible = _useState2[0],\n    setAsyncVisible = _useState2[1];\n  var _useSyncState = useSyncState(STATUS_NONE),\n    _useSyncState2 = _slicedToArray(_useSyncState, 2),\n    getStatus = _useSyncState2[0],\n    setStatus = _useSyncState2[1];\n  var _useState3 = useState(null),\n    _useState4 = _slicedToArray(_useState3, 2),\n    style = _useState4[0],\n    setStyle = _useState4[1];\n  var currentStatus = getStatus();\n  var mountedRef = useRef(false);\n  var deadlineRef = useRef(null);\n\n  // =========================== Dom Node ===========================\n  function getDomElement() {\n    return getElement();\n  }\n\n  // ========================== Motion End ==========================\n  var activeRef = useRef(false);\n\n  /**\n   * Clean up status & style\n   */\n  function updateMotionEndStatus() {\n    setStatus(STATUS_NONE);\n    setStyle(null, true);\n  }\n  var onInternalMotionEnd = useEvent(function (event) {\n    var status = getStatus();\n    // Do nothing since not in any transition status.\n    // This may happen when `motionDeadline` trigger.\n    if (status === STATUS_NONE) {\n      return;\n    }\n    var element = getDomElement();\n    if (event && !event.deadline && event.target !== element) {\n      // event exists\n      // not initiated by deadline\n      // transitionEnd not fired by inner elements\n      return;\n    }\n    var currentActive = activeRef.current;\n    var canEnd;\n    if (status === STATUS_APPEAR && currentActive) {\n      canEnd = onAppearEnd === null || onAppearEnd === void 0 ? void 0 : onAppearEnd(element, event);\n    } else if (status === STATUS_ENTER && currentActive) {\n      canEnd = onEnterEnd === null || onEnterEnd === void 0 ? void 0 : onEnterEnd(element, event);\n    } else if (status === STATUS_LEAVE && currentActive) {\n      canEnd = onLeaveEnd === null || onLeaveEnd === void 0 ? void 0 : onLeaveEnd(element, event);\n    }\n\n    // Only update status when `canEnd` and not destroyed\n    if (currentActive && canEnd !== false) {\n      updateMotionEndStatus();\n    }\n  });\n  var _useDomMotionEvents = useDomMotionEvents(onInternalMotionEnd),\n    _useDomMotionEvents2 = _slicedToArray(_useDomMotionEvents, 1),\n    patchMotionEvents = _useDomMotionEvents2[0];\n\n  // ============================= Step =============================\n  var getEventHandlers = function getEventHandlers(targetStatus) {\n    switch (targetStatus) {\n      case STATUS_APPEAR:\n        return _defineProperty(_defineProperty(_defineProperty({}, STEP_PREPARE, onAppearPrepare), STEP_START, onAppearStart), STEP_ACTIVE, onAppearActive);\n      case STATUS_ENTER:\n        return _defineProperty(_defineProperty(_defineProperty({}, STEP_PREPARE, onEnterPrepare), STEP_START, onEnterStart), STEP_ACTIVE, onEnterActive);\n      case STATUS_LEAVE:\n        return _defineProperty(_defineProperty(_defineProperty({}, STEP_PREPARE, onLeavePrepare), STEP_START, onLeaveStart), STEP_ACTIVE, onLeaveActive);\n      default:\n        return {};\n    }\n  };\n  var eventHandlers = React.useMemo(function () {\n    return getEventHandlers(currentStatus);\n  }, [currentStatus]);\n  var _useStepQueue = useStepQueue(currentStatus, !supportMotion, function (newStep) {\n      // Only prepare step can be skip\n      if (newStep === STEP_PREPARE) {\n        var onPrepare = eventHandlers[STEP_PREPARE];\n        if (!onPrepare) {\n          return SkipStep;\n        }\n        return onPrepare(getDomElement());\n      }\n\n      // Rest step is sync update\n      if (step in eventHandlers) {\n        var _eventHandlers$step;\n        setStyle(((_eventHandlers$step = eventHandlers[step]) === null || _eventHandlers$step === void 0 ? void 0 : _eventHandlers$step.call(eventHandlers, getDomElement(), null)) || null);\n      }\n      if (step === STEP_ACTIVE && currentStatus !== STATUS_NONE) {\n        // Patch events when motion needed\n        patchMotionEvents(getDomElement());\n        if (motionDeadline > 0) {\n          clearTimeout(deadlineRef.current);\n          deadlineRef.current = setTimeout(function () {\n            onInternalMotionEnd({\n              deadline: true\n            });\n          }, motionDeadline);\n        }\n      }\n      if (step === STEP_PREPARED) {\n        updateMotionEndStatus();\n      }\n      return DoStep;\n    }),\n    _useStepQueue2 = _slicedToArray(_useStepQueue, 2),\n    startStep = _useStepQueue2[0],\n    step = _useStepQueue2[1];\n  var active = isActive(step);\n  activeRef.current = active;\n\n  // ============================ Status ============================\n  // Update with new status\n  useIsomorphicLayoutEffect(function () {\n    setAsyncVisible(visible);\n    var isMounted = mountedRef.current;\n    mountedRef.current = true;\n\n    // if (!supportMotion) {\n    //   return;\n    // }\n\n    var nextStatus;\n\n    // Appear\n    if (!isMounted && visible && motionAppear) {\n      nextStatus = STATUS_APPEAR;\n    }\n\n    // Enter\n    if (isMounted && visible && motionEnter) {\n      nextStatus = STATUS_ENTER;\n    }\n\n    // Leave\n    if (isMounted && !visible && motionLeave || !isMounted && motionLeaveImmediately && !visible && motionLeave) {\n      nextStatus = STATUS_LEAVE;\n    }\n    var nextEventHandlers = getEventHandlers(nextStatus);\n\n    // Update to next status\n    if (nextStatus && (supportMotion || nextEventHandlers[STEP_PREPARE])) {\n      setStatus(nextStatus);\n      startStep();\n    } else {\n      // Set back in case no motion but prev status has prepare step\n      setStatus(STATUS_NONE);\n    }\n  }, [visible]);\n\n  // ============================ Effect ============================\n  // Reset when motion changed\n  useEffect(function () {\n    if (\n    // Cancel appear\n    currentStatus === STATUS_APPEAR && !motionAppear ||\n    // Cancel enter\n    currentStatus === STATUS_ENTER && !motionEnter ||\n    // Cancel leave\n    currentStatus === STATUS_LEAVE && !motionLeave) {\n      setStatus(STATUS_NONE);\n    }\n  }, [motionAppear, motionEnter, motionLeave]);\n  useEffect(function () {\n    return function () {\n      mountedRef.current = false;\n      clearTimeout(deadlineRef.current);\n    };\n  }, []);\n\n  // Trigger `onVisibleChanged`\n  var firstMountChangeRef = React.useRef(false);\n  useEffect(function () {\n    // [visible & motion not end] => [!visible & motion end] still need trigger onVisibleChanged\n    if (asyncVisible) {\n      firstMountChangeRef.current = true;\n    }\n    if (asyncVisible !== undefined && currentStatus === STATUS_NONE) {\n      // Skip first render is invisible since it's nothing changed\n      if (firstMountChangeRef.current || asyncVisible) {\n        onVisibleChanged === null || onVisibleChanged === void 0 || onVisibleChanged(asyncVisible);\n      }\n      firstMountChangeRef.current = true;\n    }\n  }, [asyncVisible, currentStatus]);\n\n  // ============================ Styles ============================\n  var mergedStyle = style;\n  if (eventHandlers[STEP_PREPARE] && step === STEP_START) {\n    mergedStyle = _objectSpread({\n      transition: 'none'\n    }, mergedStyle);\n  }\n  return [currentStatus, step, mergedStyle, asyncVisible !== null && asyncVisible !== void 0 ? asyncVisible : visible];\n}","import _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport * as React from 'react';\nimport useEvent from \"./useEvent\";\n/**\n * Same as React.useState but will always get latest state.\n * This is useful when React merge multiple state updates into one.\n * e.g. onTransitionEnd trigger multiple event at once will be merged state update in React.\n */\nexport default function useSyncState(defaultValue) {\n  var _React$useReducer = React.useReducer(function (x) {\n      return x + 1;\n    }, 0),\n    _React$useReducer2 = _slicedToArray(_React$useReducer, 2),\n    forceUpdate = _React$useReducer2[1];\n  var currentValueRef = React.useRef(defaultValue);\n  var getValue = useEvent(function () {\n    return currentValueRef.current;\n  });\n  var setValue = useEvent(function (updater) {\n    currentValueRef.current = typeof updater === 'function' ? updater(currentValueRef.current) : updater;\n    forceUpdate();\n  });\n  return [getValue, setValue];\n}","import raf from \"rc-util/es/raf\";\nimport * as React from 'react';\nexport default (function () {\n  var nextFrameRef = React.useRef(null);\n  function cancelNextFrame() {\n    raf.cancel(nextFrameRef.current);\n  }\n  function nextFrame(callback) {\n    var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;\n    cancelNextFrame();\n    var nextFrameId = raf(function () {\n      if (delay <= 1) {\n        callback({\n          isCanceled: function isCanceled() {\n            return nextFrameId !== nextFrameRef.current;\n          }\n        });\n      } else {\n        nextFrame(callback, delay - 1);\n      }\n    });\n    nextFrameRef.current = nextFrameId;\n  }\n  React.useEffect(function () {\n    return function () {\n      cancelNextFrame();\n    };\n  }, []);\n  return [nextFrame, cancelNextFrame];\n});","import _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _typeof from \"@babel/runtime/helpers/esm/typeof\";\nexport var STATUS_ADD = 'add';\nexport var STATUS_KEEP = 'keep';\nexport var STATUS_REMOVE = 'remove';\nexport var STATUS_REMOVED = 'removed';\nexport function wrapKeyToObject(key) {\n  var keyObj;\n  if (key && _typeof(key) === 'object' && 'key' in key) {\n    keyObj = key;\n  } else {\n    keyObj = {\n      key: key\n    };\n  }\n  return _objectSpread(_objectSpread({}, keyObj), {}, {\n    key: String(keyObj.key)\n  });\n}\nexport function parseKeys() {\n  var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n  return keys.map(wrapKeyToObject);\n}\nexport function diffKeys() {\n  var prevKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n  var currentKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n  var list = [];\n  var currentIndex = 0;\n  var currentLen = currentKeys.length;\n  var prevKeyObjects = parseKeys(prevKeys);\n  var currentKeyObjects = parseKeys(currentKeys);\n\n  // Check prev keys to insert or keep\n  prevKeyObjects.forEach(function (keyObj) {\n    var hit = false;\n    for (var i = currentIndex; i < currentLen; i += 1) {\n      var currentKeyObj = currentKeyObjects[i];\n      if (currentKeyObj.key === keyObj.key) {\n        // New added keys should add before current key\n        if (currentIndex < i) {\n          list = list.concat(currentKeyObjects.slice(currentIndex, i).map(function (obj) {\n            return _objectSpread(_objectSpread({}, obj), {}, {\n              status: STATUS_ADD\n            });\n          }));\n          currentIndex = i;\n        }\n        list.push(_objectSpread(_objectSpread({}, currentKeyObj), {}, {\n          status: STATUS_KEEP\n        }));\n        currentIndex += 1;\n        hit = true;\n        break;\n      }\n    }\n\n    // If not hit, it means key is removed\n    if (!hit) {\n      list.push(_objectSpread(_objectSpread({}, keyObj), {}, {\n        status: STATUS_REMOVE\n      }));\n    }\n  });\n\n  // Add rest to the list\n  if (currentIndex < currentLen) {\n    list = list.concat(currentKeyObjects.slice(currentIndex).map(function (obj) {\n      return _objectSpread(_objectSpread({}, obj), {}, {\n        status: STATUS_ADD\n      });\n    }));\n  }\n\n  /**\n   * Merge same key when it remove and add again:\n   *    [1 - add, 2 - keep, 1 - remove] -> [1 - keep, 2 - keep]\n   */\n  var keys = {};\n  list.forEach(function (_ref) {\n    var key = _ref.key;\n    keys[key] = (keys[key] || 0) + 1;\n  });\n  var duplicatedKeys = Object.keys(keys).filter(function (key) {\n    return keys[key] > 1;\n  });\n  duplicatedKeys.forEach(function (matchKey) {\n    // Remove `STATUS_REMOVE` node.\n    list = list.filter(function (_ref2) {\n      var key = _ref2.key,\n        status = _ref2.status;\n      return key !== matchKey || status !== STATUS_REMOVE;\n    });\n\n    // Update `STATUS_ADD` to `STATUS_KEEP`\n    list.forEach(function (node) {\n      if (node.key === matchKey) {\n        // eslint-disable-next-line no-param-reassign\n        node.status = STATUS_KEEP;\n      }\n    });\n  });\n  return list;\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _createSuper from \"@babel/runtime/helpers/esm/createSuper\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nvar _excluded = [\"component\", \"children\", \"onVisibleChanged\", \"onAllRemoved\"],\n  _excluded2 = [\"status\"];\n/* eslint react/prop-types: 0 */\nimport * as React from 'react';\nimport OriginCSSMotion from \"./CSSMotion\";\nimport { diffKeys, parseKeys, STATUS_ADD, STATUS_KEEP, STATUS_REMOVE, STATUS_REMOVED } from \"./util/diff\";\nimport { supportTransition } from \"./util/motion\";\nvar MOTION_PROP_NAMES = ['eventProps', 'visible', 'children', 'motionName', 'motionAppear', 'motionEnter', 'motionLeave', 'motionLeaveImmediately', 'motionDeadline', 'removeOnLeave', 'leavedClassName', 'onAppearPrepare', 'onAppearStart', 'onAppearActive', 'onAppearEnd', 'onEnterStart', 'onEnterActive', 'onEnterEnd', 'onLeaveStart', 'onLeaveActive', 'onLeaveEnd'];\n/**\n * Generate a CSSMotionList component with config\n * @param transitionSupport No need since CSSMotionList no longer depends on transition support\n * @param CSSMotion CSSMotion component\n */\nexport function genCSSMotionList(transitionSupport) {\n  var CSSMotion = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : OriginCSSMotion;\n  var CSSMotionList = /*#__PURE__*/function (_React$Component) {\n    _inherits(CSSMotionList, _React$Component);\n    var _super = _createSuper(CSSMotionList);\n    function CSSMotionList() {\n      var _this;\n      _classCallCheck(this, CSSMotionList);\n      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n      }\n      _this = _super.call.apply(_super, [this].concat(args));\n      _defineProperty(_assertThisInitialized(_this), \"state\", {\n        keyEntities: []\n      });\n      // ZombieJ: Return the count of rest keys. It's safe to refactor if need more info.\n      _defineProperty(_assertThisInitialized(_this), \"removeKey\", function (removeKey) {\n        _this.setState(function (prevState) {\n          var nextKeyEntities = prevState.keyEntities.map(function (entity) {\n            if (entity.key !== removeKey) return entity;\n            return _objectSpread(_objectSpread({}, entity), {}, {\n              status: STATUS_REMOVED\n            });\n          });\n          return {\n            keyEntities: nextKeyEntities\n          };\n        }, function () {\n          var keyEntities = _this.state.keyEntities;\n          var restKeysCount = keyEntities.filter(function (_ref) {\n            var status = _ref.status;\n            return status !== STATUS_REMOVED;\n          }).length;\n          if (restKeysCount === 0 && _this.props.onAllRemoved) {\n            _this.props.onAllRemoved();\n          }\n        });\n      });\n      return _this;\n    }\n    _createClass(CSSMotionList, [{\n      key: \"render\",\n      value: function render() {\n        var _this2 = this;\n        var keyEntities = this.state.keyEntities;\n        var _this$props = this.props,\n          component = _this$props.component,\n          children = _this$props.children,\n          _onVisibleChanged = _this$props.onVisibleChanged,\n          onAllRemoved = _this$props.onAllRemoved,\n          restProps = _objectWithoutProperties(_this$props, _excluded);\n        var Component = component || React.Fragment;\n        var motionProps = {};\n        MOTION_PROP_NAMES.forEach(function (prop) {\n          motionProps[prop] = restProps[prop];\n          delete restProps[prop];\n        });\n        delete restProps.keys;\n        return /*#__PURE__*/React.createElement(Component, restProps, keyEntities.map(function (_ref2, index) {\n          var status = _ref2.status,\n            eventProps = _objectWithoutProperties(_ref2, _excluded2);\n          var visible = status === STATUS_ADD || status === STATUS_KEEP;\n          return /*#__PURE__*/React.createElement(CSSMotion, _extends({}, motionProps, {\n            key: eventProps.key,\n            visible: visible,\n            eventProps: eventProps,\n            onVisibleChanged: function onVisibleChanged(changedVisible) {\n              _onVisibleChanged === null || _onVisibleChanged === void 0 || _onVisibleChanged(changedVisible, {\n                key: eventProps.key\n              });\n              if (!changedVisible) {\n                _this2.removeKey(eventProps.key);\n              }\n            }\n          }), function (props, ref) {\n            return children(_objectSpread(_objectSpread({}, props), {}, {\n              index: index\n            }), ref);\n          });\n        }));\n      }\n    }], [{\n      key: \"getDerivedStateFromProps\",\n      value: function getDerivedStateFromProps(_ref3, _ref4) {\n        var keys = _ref3.keys;\n        var keyEntities = _ref4.keyEntities;\n        var parsedKeyObjects = parseKeys(keys);\n        var mixedKeyEntities = diffKeys(keyEntities, parsedKeyObjects);\n        return {\n          keyEntities: mixedKeyEntities.filter(function (entity) {\n            var prevEntity = keyEntities.find(function (_ref5) {\n              var key = _ref5.key;\n              return entity.key === key;\n            });\n\n            // Remove if already mark as removed\n            if (prevEntity && prevEntity.status === STATUS_REMOVED && entity.status === STATUS_REMOVE) {\n              return false;\n            }\n            return true;\n          })\n        };\n      }\n    }]);\n    return CSSMotionList;\n  }(React.Component);\n  _defineProperty(CSSMotionList, \"defaultProps\", {\n    component: 'div'\n  });\n  return CSSMotionList;\n}\nexport default genCSSMotionList(supportTransition);","function ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    enumerableOnly && (symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    })), keys.push.apply(keys, symbols);\n  }\n  return keys;\n}\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = null != arguments[i] ? arguments[i] : {};\n    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {\n      _defineProperty(target, key, source[key]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {\n      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n    });\n  }\n  return target;\n}\nfunction _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, _typeof(obj);\n}\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\n\nvar vendorPrefix;\nvar jsCssMap = {\n  Webkit: '-webkit-',\n  Moz: '-moz-',\n  // IE did it wrong again ...\n  ms: '-ms-',\n  O: '-o-'\n};\nfunction getVendorPrefix() {\n  if (vendorPrefix !== undefined) {\n    return vendorPrefix;\n  }\n  vendorPrefix = '';\n  var style = document.createElement('p').style;\n  var testProp = 'Transform';\n  for (var key in jsCssMap) {\n    if (key + testProp in style) {\n      vendorPrefix = key;\n    }\n  }\n  return vendorPrefix;\n}\nfunction getTransitionName() {\n  return getVendorPrefix() ? \"\".concat(getVendorPrefix(), \"TransitionProperty\") : 'transitionProperty';\n}\nfunction getTransformName() {\n  return getVendorPrefix() ? \"\".concat(getVendorPrefix(), \"Transform\") : 'transform';\n}\nfunction setTransitionProperty(node, value) {\n  var name = getTransitionName();\n  if (name) {\n    node.style[name] = value;\n    if (name !== 'transitionProperty') {\n      node.style.transitionProperty = value;\n    }\n  }\n}\nfunction setTransform(node, value) {\n  var name = getTransformName();\n  if (name) {\n    node.style[name] = value;\n    if (name !== 'transform') {\n      node.style.transform = value;\n    }\n  }\n}\nfunction getTransitionProperty(node) {\n  return node.style.transitionProperty || node.style[getTransitionName()];\n}\nfunction getTransformXY(node) {\n  var style = window.getComputedStyle(node, null);\n  var transform = style.getPropertyValue('transform') || style.getPropertyValue(getTransformName());\n  if (transform && transform !== 'none') {\n    var matrix = transform.replace(/[^0-9\\-.,]/g, '').split(',');\n    return {\n      x: parseFloat(matrix[12] || matrix[4], 0),\n      y: parseFloat(matrix[13] || matrix[5], 0)\n    };\n  }\n  return {\n    x: 0,\n    y: 0\n  };\n}\nvar matrix2d = /matrix\\((.*)\\)/;\nvar matrix3d = /matrix3d\\((.*)\\)/;\nfunction setTransformXY(node, xy) {\n  var style = window.getComputedStyle(node, null);\n  var transform = style.getPropertyValue('transform') || style.getPropertyValue(getTransformName());\n  if (transform && transform !== 'none') {\n    var arr;\n    var match2d = transform.match(matrix2d);\n    if (match2d) {\n      match2d = match2d[1];\n      arr = match2d.split(',').map(function (item) {\n        return parseFloat(item, 10);\n      });\n      arr[4] = xy.x;\n      arr[5] = xy.y;\n      setTransform(node, \"matrix(\".concat(arr.join(','), \")\"));\n    } else {\n      var match3d = transform.match(matrix3d)[1];\n      arr = match3d.split(',').map(function (item) {\n        return parseFloat(item, 10);\n      });\n      arr[12] = xy.x;\n      arr[13] = xy.y;\n      setTransform(node, \"matrix3d(\".concat(arr.join(','), \")\"));\n    }\n  } else {\n    setTransform(node, \"translateX(\".concat(xy.x, \"px) translateY(\").concat(xy.y, \"px) translateZ(0)\"));\n  }\n}\n\nvar RE_NUM = /[\\-+]?(?:\\d*\\.|)\\d+(?:[eE][\\-+]?\\d+|)/.source;\nvar getComputedStyleX;\n\n// https://stackoverflow.com/a/3485654/3040605\nfunction forceRelayout(elem) {\n  var originalStyle = elem.style.display;\n  elem.style.display = 'none';\n  elem.offsetHeight; // eslint-disable-line\n  elem.style.display = originalStyle;\n}\nfunction css(el, name, v) {\n  var value = v;\n  if (_typeof(name) === 'object') {\n    for (var i in name) {\n      if (name.hasOwnProperty(i)) {\n        css(el, i, name[i]);\n      }\n    }\n    return undefined;\n  }\n  if (typeof value !== 'undefined') {\n    if (typeof value === 'number') {\n      value = \"\".concat(value, \"px\");\n    }\n    el.style[name] = value;\n    return undefined;\n  }\n  return getComputedStyleX(el, name);\n}\nfunction getClientPosition(elem) {\n  var box;\n  var x;\n  var y;\n  var doc = elem.ownerDocument;\n  var body = doc.body;\n  var docElem = doc && doc.documentElement;\n  // 根据 GBS 最新数据，A-Grade Browsers 都已支持 getBoundingClientRect 方法，不用再考虑传统的实现方式\n  box = elem.getBoundingClientRect();\n\n  // 注：jQuery 还考虑减去 docElem.clientLeft/clientTop\n  // 但测试发现，这样反而会导致当 html 和 body 有边距/边框样式时，获取的值不正确\n  // 此外，ie6 会忽略 html 的 margin 值，幸运地是没有谁会去设置 html 的 margin\n\n  x = Math.floor(box.left);\n  y = Math.floor(box.top);\n\n  // In IE, most of the time, 2 extra pixels are added to the top and left\n  // due to the implicit 2-pixel inset border.  In IE6/7 quirks mode and\n  // IE6 standards mode, this border can be overridden by setting the\n  // document element's border to zero -- thus, we cannot rely on the\n  // offset always being 2 pixels.\n\n  // In quirks mode, the offset can be determined by querying the body's\n  // clientLeft/clientTop, but in standards mode, it is found by querying\n  // the document element's clientLeft/clientTop.  Since we already called\n  // getClientBoundingRect we have already forced a reflow, so it is not\n  // too expensive just to query them all.\n\n  // ie 下应该减去窗口的边框吧，毕竟默认 absolute 都是相对窗口定位的\n  // 窗口边框标准是设 documentElement ,quirks 时设置 body\n  // 最好禁止在 body 和 html 上边框 ，但 ie < 9 html 默认有 2px ，减去\n  // 但是非 ie 不可能设置窗口边框，body html 也不是窗口 ,ie 可以通过 html,body 设置\n  // 标准 ie 下 docElem.clientTop 就是 border-top\n  // ie7 html 即窗口边框改变不了。永远为 2\n  // 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框，即使设了 border-top 也为 0\n\n  x -= docElem.clientLeft || body.clientLeft || 0;\n  y -= docElem.clientTop || body.clientTop || 0;\n  return {\n    left: x,\n    top: y\n  };\n}\nfunction getScroll(w, top) {\n  var ret = w[\"page\".concat(top ? 'Y' : 'X', \"Offset\")];\n  var method = \"scroll\".concat(top ? 'Top' : 'Left');\n  if (typeof ret !== 'number') {\n    var d = w.document;\n    // ie6,7,8 standard mode\n    ret = d.documentElement[method];\n    if (typeof ret !== 'number') {\n      // quirks mode\n      ret = d.body[method];\n    }\n  }\n  return ret;\n}\nfunction getScrollLeft(w) {\n  return getScroll(w);\n}\nfunction getScrollTop(w) {\n  return getScroll(w, true);\n}\nfunction getOffset(el) {\n  var pos = getClientPosition(el);\n  var doc = el.ownerDocument;\n  var w = doc.defaultView || doc.parentWindow;\n  pos.left += getScrollLeft(w);\n  pos.top += getScrollTop(w);\n  return pos;\n}\n\n/**\n * A crude way of determining if an object is a window\n * @member util\n */\nfunction isWindow(obj) {\n  // must use == for ie8\n  /* eslint eqeqeq:0 */\n  return obj !== null && obj !== undefined && obj == obj.window;\n}\nfunction getDocument(node) {\n  if (isWindow(node)) {\n    return node.document;\n  }\n  if (node.nodeType === 9) {\n    return node;\n  }\n  return node.ownerDocument;\n}\nfunction _getComputedStyle(elem, name, cs) {\n  var computedStyle = cs;\n  var val = '';\n  var d = getDocument(elem);\n  computedStyle = computedStyle || d.defaultView.getComputedStyle(elem, null);\n\n  // https://github.com/kissyteam/kissy/issues/61\n  if (computedStyle) {\n    val = computedStyle.getPropertyValue(name) || computedStyle[name];\n  }\n  return val;\n}\nvar _RE_NUM_NO_PX = new RegExp(\"^(\".concat(RE_NUM, \")(?!px)[a-z%]+$\"), 'i');\nvar RE_POS = /^(top|right|bottom|left)$/;\nvar CURRENT_STYLE = 'currentStyle';\nvar RUNTIME_STYLE = 'runtimeStyle';\nvar LEFT = 'left';\nvar PX = 'px';\nfunction _getComputedStyleIE(elem, name) {\n  // currentStyle maybe null\n  // http://msdn.microsoft.com/en-us/library/ms535231.aspx\n  var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name];\n\n  // 当 width/height 设置为百分比时，通过 pixelLeft 方式转换的 width/height 值\n  // 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19\n  // 在 ie 下不对，需要直接用 offset 方式\n  // borderWidth 等值也有问题，但考虑到 borderWidth 设为百分比的概率很小，这里就不考虑了\n\n  // From the awesome hack by Dean Edwards\n  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291\n  // If we're not dealing with a regular pixel number\n  // but a number that has a weird ending, we need to convert it to pixels\n  // exclude left right for relativity\n  if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) {\n    // Remember the original values\n    var style = elem.style;\n    var left = style[LEFT];\n    var rsLeft = elem[RUNTIME_STYLE][LEFT];\n\n    // prevent flashing of content\n    elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT];\n\n    // Put in the new values to get a computed value out\n    style[LEFT] = name === 'fontSize' ? '1em' : ret || 0;\n    ret = style.pixelLeft + PX;\n\n    // Revert the changed values\n    style[LEFT] = left;\n    elem[RUNTIME_STYLE][LEFT] = rsLeft;\n  }\n  return ret === '' ? 'auto' : ret;\n}\nif (typeof window !== 'undefined') {\n  getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE;\n}\nfunction getOffsetDirection(dir, option) {\n  if (dir === 'left') {\n    return option.useCssRight ? 'right' : dir;\n  }\n  return option.useCssBottom ? 'bottom' : dir;\n}\nfunction oppositeOffsetDirection(dir) {\n  if (dir === 'left') {\n    return 'right';\n  } else if (dir === 'right') {\n    return 'left';\n  } else if (dir === 'top') {\n    return 'bottom';\n  } else if (dir === 'bottom') {\n    return 'top';\n  }\n}\n\n// 设置 elem 相对 elem.ownerDocument 的坐标\nfunction setLeftTop(elem, offset, option) {\n  // set position first, in-case top/left are set even on static elem\n  if (css(elem, 'position') === 'static') {\n    elem.style.position = 'relative';\n  }\n  var presetH = -999;\n  var presetV = -999;\n  var horizontalProperty = getOffsetDirection('left', option);\n  var verticalProperty = getOffsetDirection('top', option);\n  var oppositeHorizontalProperty = oppositeOffsetDirection(horizontalProperty);\n  var oppositeVerticalProperty = oppositeOffsetDirection(verticalProperty);\n  if (horizontalProperty !== 'left') {\n    presetH = 999;\n  }\n  if (verticalProperty !== 'top') {\n    presetV = 999;\n  }\n  var originalTransition = '';\n  var originalOffset = getOffset(elem);\n  if ('left' in offset || 'top' in offset) {\n    originalTransition = getTransitionProperty(elem) || '';\n    setTransitionProperty(elem, 'none');\n  }\n  if ('left' in offset) {\n    elem.style[oppositeHorizontalProperty] = '';\n    elem.style[horizontalProperty] = \"\".concat(presetH, \"px\");\n  }\n  if ('top' in offset) {\n    elem.style[oppositeVerticalProperty] = '';\n    elem.style[verticalProperty] = \"\".concat(presetV, \"px\");\n  }\n  // force relayout\n  forceRelayout(elem);\n  var old = getOffset(elem);\n  var originalStyle = {};\n  for (var key in offset) {\n    if (offset.hasOwnProperty(key)) {\n      var dir = getOffsetDirection(key, option);\n      var preset = key === 'left' ? presetH : presetV;\n      var off = originalOffset[key] - old[key];\n      if (dir === key) {\n        originalStyle[dir] = preset + off;\n      } else {\n        originalStyle[dir] = preset - off;\n      }\n    }\n  }\n  css(elem, originalStyle);\n  // force relayout\n  forceRelayout(elem);\n  if ('left' in offset || 'top' in offset) {\n    setTransitionProperty(elem, originalTransition);\n  }\n  var ret = {};\n  for (var _key in offset) {\n    if (offset.hasOwnProperty(_key)) {\n      var _dir = getOffsetDirection(_key, option);\n      var _off = offset[_key] - originalOffset[_key];\n      if (_key === _dir) {\n        ret[_dir] = originalStyle[_dir] + _off;\n      } else {\n        ret[_dir] = originalStyle[_dir] - _off;\n      }\n    }\n  }\n  css(elem, ret);\n}\nfunction setTransform$1(elem, offset) {\n  var originalOffset = getOffset(elem);\n  var originalXY = getTransformXY(elem);\n  var resultXY = {\n    x: originalXY.x,\n    y: originalXY.y\n  };\n  if ('left' in offset) {\n    resultXY.x = originalXY.x + offset.left - originalOffset.left;\n  }\n  if ('top' in offset) {\n    resultXY.y = originalXY.y + offset.top - originalOffset.top;\n  }\n  setTransformXY(elem, resultXY);\n}\nfunction setOffset(elem, offset, option) {\n  if (option.ignoreShake) {\n    var oriOffset = getOffset(elem);\n    var oLeft = oriOffset.left.toFixed(0);\n    var oTop = oriOffset.top.toFixed(0);\n    var tLeft = offset.left.toFixed(0);\n    var tTop = offset.top.toFixed(0);\n    if (oLeft === tLeft && oTop === tTop) {\n      return;\n    }\n  }\n  if (option.useCssRight || option.useCssBottom) {\n    setLeftTop(elem, offset, option);\n  } else if (option.useCssTransform && getTransformName() in document.body.style) {\n    setTransform$1(elem, offset);\n  } else {\n    setLeftTop(elem, offset, option);\n  }\n}\nfunction each(arr, fn) {\n  for (var i = 0; i < arr.length; i++) {\n    fn(arr[i]);\n  }\n}\nfunction isBorderBoxFn(elem) {\n  return getComputedStyleX(elem, 'boxSizing') === 'border-box';\n}\nvar BOX_MODELS = ['margin', 'border', 'padding'];\nvar CONTENT_INDEX = -1;\nvar PADDING_INDEX = 2;\nvar BORDER_INDEX = 1;\nvar MARGIN_INDEX = 0;\nfunction swap(elem, options, callback) {\n  var old = {};\n  var style = elem.style;\n  var name;\n\n  // Remember the old values, and insert the new ones\n  for (name in options) {\n    if (options.hasOwnProperty(name)) {\n      old[name] = style[name];\n      style[name] = options[name];\n    }\n  }\n  callback.call(elem);\n\n  // Revert the old values\n  for (name in options) {\n    if (options.hasOwnProperty(name)) {\n      style[name] = old[name];\n    }\n  }\n}\nfunction getPBMWidth(elem, props, which) {\n  var value = 0;\n  var prop;\n  var j;\n  var i;\n  for (j = 0; j < props.length; j++) {\n    prop = props[j];\n    if (prop) {\n      for (i = 0; i < which.length; i++) {\n        var cssProp = void 0;\n        if (prop === 'border') {\n          cssProp = \"\".concat(prop).concat(which[i], \"Width\");\n        } else {\n          cssProp = prop + which[i];\n        }\n        value += parseFloat(getComputedStyleX(elem, cssProp)) || 0;\n      }\n    }\n  }\n  return value;\n}\nvar domUtils = {\n  getParent: function getParent(element) {\n    var parent = element;\n    do {\n      if (parent.nodeType === 11 && parent.host) {\n        parent = parent.host;\n      } else {\n        parent = parent.parentNode;\n      }\n    } while (parent && parent.nodeType !== 1 && parent.nodeType !== 9);\n    return parent;\n  }\n};\neach(['Width', 'Height'], function (name) {\n  domUtils[\"doc\".concat(name)] = function (refWin) {\n    var d = refWin.document;\n    return Math.max(\n    // firefox chrome documentElement.scrollHeight< body.scrollHeight\n    // ie standard mode : documentElement.scrollHeight> body.scrollHeight\n    d.documentElement[\"scroll\".concat(name)],\n    // quirks : documentElement.scrollHeight 最大等于可视窗口多一点？\n    d.body[\"scroll\".concat(name)], domUtils[\"viewport\".concat(name)](d));\n  };\n  domUtils[\"viewport\".concat(name)] = function (win) {\n    // pc browser includes scrollbar in window.innerWidth\n    var prop = \"client\".concat(name);\n    var doc = win.document;\n    var body = doc.body;\n    var documentElement = doc.documentElement;\n    var documentElementProp = documentElement[prop];\n    // 标准模式取 documentElement\n    // backcompat 取 body\n    return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp;\n  };\n});\n\n/*\n 得到元素的大小信息\n @param elem\n @param name\n @param {String} [extra]  'padding' : (css width) + padding\n 'border' : (css width) + padding + border\n 'margin' : (css width) + padding + border + margin\n */\nfunction getWH(elem, name, ex) {\n  var extra = ex;\n  if (isWindow(elem)) {\n    return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem);\n  } else if (elem.nodeType === 9) {\n    return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem);\n  }\n  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];\n  var borderBoxValue = name === 'width' ? Math.floor(elem.getBoundingClientRect().width) : Math.floor(elem.getBoundingClientRect().height);\n  var isBorderBox = isBorderBoxFn(elem);\n  var cssBoxValue = 0;\n  if (borderBoxValue === null || borderBoxValue === undefined || borderBoxValue <= 0) {\n    borderBoxValue = undefined;\n    // Fall back to computed then un computed css if necessary\n    cssBoxValue = getComputedStyleX(elem, name);\n    if (cssBoxValue === null || cssBoxValue === undefined || Number(cssBoxValue) < 0) {\n      cssBoxValue = elem.style[name] || 0;\n    }\n    // Normalize '', auto, and prepare for extra\n    cssBoxValue = Math.floor(parseFloat(cssBoxValue)) || 0;\n  }\n  if (extra === undefined) {\n    extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;\n  }\n  var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox;\n  var val = borderBoxValue || cssBoxValue;\n  if (extra === CONTENT_INDEX) {\n    if (borderBoxValueOrIsBorderBox) {\n      return val - getPBMWidth(elem, ['border', 'padding'], which);\n    }\n    return cssBoxValue;\n  } else if (borderBoxValueOrIsBorderBox) {\n    if (extra === BORDER_INDEX) {\n      return val;\n    }\n    return val + (extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which) : getPBMWidth(elem, ['margin'], which));\n  }\n  return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which);\n}\nvar cssShow = {\n  position: 'absolute',\n  visibility: 'hidden',\n  display: 'block'\n};\n\n// fix #119 : https://github.com/kissyteam/kissy/issues/119\nfunction getWHIgnoreDisplay() {\n  for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {\n    args[_key2] = arguments[_key2];\n  }\n  var val;\n  var elem = args[0];\n  // in case elem is window\n  // elem.offsetWidth === undefined\n  if (elem.offsetWidth !== 0) {\n    val = getWH.apply(undefined, args);\n  } else {\n    swap(elem, cssShow, function () {\n      val = getWH.apply(undefined, args);\n    });\n  }\n  return val;\n}\neach(['width', 'height'], function (name) {\n  var first = name.charAt(0).toUpperCase() + name.slice(1);\n  domUtils[\"outer\".concat(first)] = function (el, includeMargin) {\n    return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);\n  };\n  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];\n  domUtils[name] = function (elem, v) {\n    var val = v;\n    if (val !== undefined) {\n      if (elem) {\n        var isBorderBox = isBorderBoxFn(elem);\n        if (isBorderBox) {\n          val += getPBMWidth(elem, ['padding', 'border'], which);\n        }\n        return css(elem, name, val);\n      }\n      return undefined;\n    }\n    return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);\n  };\n});\nfunction mix(to, from) {\n  for (var i in from) {\n    if (from.hasOwnProperty(i)) {\n      to[i] = from[i];\n    }\n  }\n  return to;\n}\nvar utils = {\n  getWindow: function getWindow(node) {\n    if (node && node.document && node.setTimeout) {\n      return node;\n    }\n    var doc = node.ownerDocument || node;\n    return doc.defaultView || doc.parentWindow;\n  },\n  getDocument: getDocument,\n  offset: function offset(el, value, option) {\n    if (typeof value !== 'undefined') {\n      setOffset(el, value, option || {});\n    } else {\n      return getOffset(el);\n    }\n  },\n  isWindow: isWindow,\n  each: each,\n  css: css,\n  clone: function clone(obj) {\n    var i;\n    var ret = {};\n    for (i in obj) {\n      if (obj.hasOwnProperty(i)) {\n        ret[i] = obj[i];\n      }\n    }\n    var overflow = obj.overflow;\n    if (overflow) {\n      for (i in obj) {\n        if (obj.hasOwnProperty(i)) {\n          ret.overflow[i] = obj.overflow[i];\n        }\n      }\n    }\n    return ret;\n  },\n  mix: mix,\n  getWindowScrollLeft: function getWindowScrollLeft(w) {\n    return getScrollLeft(w);\n  },\n  getWindowScrollTop: function getWindowScrollTop(w) {\n    return getScrollTop(w);\n  },\n  merge: function merge() {\n    var ret = {};\n    for (var i = 0; i < arguments.length; i++) {\n      utils.mix(ret, i < 0 || arguments.length <= i ? undefined : arguments[i]);\n    }\n    return ret;\n  },\n  viewportWidth: 0,\n  viewportHeight: 0\n};\nmix(utils, domUtils);\n\n/**\n * 得到会导致元素显示不全的祖先元素\n */\nvar getParent = utils.getParent;\nfunction getOffsetParent(element) {\n  if (utils.isWindow(element) || element.nodeType === 9) {\n    return null;\n  }\n  // ie 这个也不是完全可行\n  /*\n   <div style=\"width: 50px;height: 100px;overflow: hidden\">\n   <div style=\"width: 50px;height: 100px;position: relative;\" id=\"d6\">\n   元素 6 高 100px 宽 50px<br/>\n   </div>\n   </div>\n   */\n  // element.offsetParent does the right thing in ie7 and below. Return parent with layout!\n  //  In other browsers it only includes elements with position absolute, relative or\n  // fixed, not elements with overflow set to auto or scroll.\n  //        if (UA.ie && ieMode < 8) {\n  //            return element.offsetParent;\n  //        }\n  // 统一的 offsetParent 方法\n  var doc = utils.getDocument(element);\n  var body = doc.body;\n  var parent;\n  var positionStyle = utils.css(element, 'position');\n  var skipStatic = positionStyle === 'fixed' || positionStyle === 'absolute';\n  if (!skipStatic) {\n    return element.nodeName.toLowerCase() === 'html' ? null : getParent(element);\n  }\n  for (parent = getParent(element); parent && parent !== body && parent.nodeType !== 9; parent = getParent(parent)) {\n    positionStyle = utils.css(parent, 'position');\n    if (positionStyle !== 'static') {\n      return parent;\n    }\n  }\n  return null;\n}\n\nvar getParent$1 = utils.getParent;\nfunction isAncestorFixed(element) {\n  if (utils.isWindow(element) || element.nodeType === 9) {\n    return false;\n  }\n  var doc = utils.getDocument(element);\n  var body = doc.body;\n  var parent = null;\n  for (parent = getParent$1(element);\n  // 修复元素位于 document.documentElement 下导致崩溃问题\n  parent && parent !== body && parent !== doc; parent = getParent$1(parent)) {\n    var positionStyle = utils.css(parent, 'position');\n    if (positionStyle === 'fixed') {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * 获得元素的显示部分的区域\n */\nfunction getVisibleRectForElement(element, alwaysByViewport) {\n  var visibleRect = {\n    left: 0,\n    right: Infinity,\n    top: 0,\n    bottom: Infinity\n  };\n  var el = getOffsetParent(element);\n  var doc = utils.getDocument(element);\n  var win = doc.defaultView || doc.parentWindow;\n  var body = doc.body;\n  var documentElement = doc.documentElement;\n\n  // Determine the size of the visible rect by climbing the dom accounting for\n  // all scrollable containers.\n  while (el) {\n    // clientWidth is zero for inline block elements in ie.\n    if ((navigator.userAgent.indexOf('MSIE') === -1 || el.clientWidth !== 0) &&\n    // body may have overflow set on it, yet we still get the entire\n    // viewport. In some browsers, el.offsetParent may be\n    // document.documentElement, so check for that too.\n    el !== body && el !== documentElement && utils.css(el, 'overflow') !== 'visible') {\n      var pos = utils.offset(el);\n      // add border\n      pos.left += el.clientLeft;\n      pos.top += el.clientTop;\n      visibleRect.top = Math.max(visibleRect.top, pos.top);\n      visibleRect.right = Math.min(visibleRect.right,\n      // consider area without scrollBar\n      pos.left + el.clientWidth);\n      visibleRect.bottom = Math.min(visibleRect.bottom, pos.top + el.clientHeight);\n      visibleRect.left = Math.max(visibleRect.left, pos.left);\n    } else if (el === body || el === documentElement) {\n      break;\n    }\n    el = getOffsetParent(el);\n  }\n\n  // Set element position to fixed\n  // make sure absolute element itself don't affect it's visible area\n  // https://github.com/ant-design/ant-design/issues/7601\n  var originalPosition = null;\n  if (!utils.isWindow(element) && element.nodeType !== 9) {\n    originalPosition = element.style.position;\n    var position = utils.css(element, 'position');\n    if (position === 'absolute') {\n      element.style.position = 'fixed';\n    }\n  }\n  var scrollX = utils.getWindowScrollLeft(win);\n  var scrollY = utils.getWindowScrollTop(win);\n  var viewportWidth = utils.viewportWidth(win);\n  var viewportHeight = utils.viewportHeight(win);\n  var documentWidth = documentElement.scrollWidth;\n  var documentHeight = documentElement.scrollHeight;\n\n  // scrollXXX on html is sync with body which means overflow: hidden on body gets wrong scrollXXX.\n  // We should cut this ourself.\n  var bodyStyle = window.getComputedStyle(body);\n  if (bodyStyle.overflowX === 'hidden') {\n    documentWidth = win.innerWidth;\n  }\n  if (bodyStyle.overflowY === 'hidden') {\n    documentHeight = win.innerHeight;\n  }\n\n  // Reset element position after calculate the visible area\n  if (element.style) {\n    element.style.position = originalPosition;\n  }\n  if (alwaysByViewport || isAncestorFixed(element)) {\n    // Clip by viewport's size.\n    visibleRect.left = Math.max(visibleRect.left, scrollX);\n    visibleRect.top = Math.max(visibleRect.top, scrollY);\n    visibleRect.right = Math.min(visibleRect.right, scrollX + viewportWidth);\n    visibleRect.bottom = Math.min(visibleRect.bottom, scrollY + viewportHeight);\n  } else {\n    // Clip by document's size.\n    var maxVisibleWidth = Math.max(documentWidth, scrollX + viewportWidth);\n    visibleRect.right = Math.min(visibleRect.right, maxVisibleWidth);\n    var maxVisibleHeight = Math.max(documentHeight, scrollY + viewportHeight);\n    visibleRect.bottom = Math.min(visibleRect.bottom, maxVisibleHeight);\n  }\n  return visibleRect.top >= 0 && visibleRect.left >= 0 && visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left ? visibleRect : null;\n}\n\nfunction adjustForViewport(elFuturePos, elRegion, visibleRect, overflow) {\n  var pos = utils.clone(elFuturePos);\n  var size = {\n    width: elRegion.width,\n    height: elRegion.height\n  };\n  if (overflow.adjustX && pos.left < visibleRect.left) {\n    pos.left = visibleRect.left;\n  }\n\n  // Left edge inside and right edge outside viewport, try to resize it.\n  if (overflow.resizeWidth && pos.left >= visibleRect.left && pos.left + size.width > visibleRect.right) {\n    size.width -= pos.left + size.width - visibleRect.right;\n  }\n\n  // Right edge outside viewport, try to move it.\n  if (overflow.adjustX && pos.left + size.width > visibleRect.right) {\n    // 保证左边界和可视区域左边界对齐\n    pos.left = Math.max(visibleRect.right - size.width, visibleRect.left);\n  }\n\n  // Top edge outside viewport, try to move it.\n  if (overflow.adjustY && pos.top < visibleRect.top) {\n    pos.top = visibleRect.top;\n  }\n\n  // Top edge inside and bottom edge outside viewport, try to resize it.\n  if (overflow.resizeHeight && pos.top >= visibleRect.top && pos.top + size.height > visibleRect.bottom) {\n    size.height -= pos.top + size.height - visibleRect.bottom;\n  }\n\n  // Bottom edge outside viewport, try to move it.\n  if (overflow.adjustY && pos.top + size.height > visibleRect.bottom) {\n    // 保证上边界和可视区域上边界对齐\n    pos.top = Math.max(visibleRect.bottom - size.height, visibleRect.top);\n  }\n  return utils.mix(pos, size);\n}\n\nfunction getRegion(node) {\n  var offset;\n  var w;\n  var h;\n  if (!utils.isWindow(node) && node.nodeType !== 9) {\n    offset = utils.offset(node);\n    w = utils.outerWidth(node);\n    h = utils.outerHeight(node);\n  } else {\n    var win = utils.getWindow(node);\n    offset = {\n      left: utils.getWindowScrollLeft(win),\n      top: utils.getWindowScrollTop(win)\n    };\n    w = utils.viewportWidth(win);\n    h = utils.viewportHeight(win);\n  }\n  offset.width = w;\n  offset.height = h;\n  return offset;\n}\n\n/**\n * 获取 node 上的 align 对齐点 相对于页面的坐标\n */\n\nfunction getAlignOffset(region, align) {\n  var V = align.charAt(0);\n  var H = align.charAt(1);\n  var w = region.width;\n  var h = region.height;\n  var x = region.left;\n  var y = region.top;\n  if (V === 'c') {\n    y += h / 2;\n  } else if (V === 'b') {\n    y += h;\n  }\n  if (H === 'c') {\n    x += w / 2;\n  } else if (H === 'r') {\n    x += w;\n  }\n  return {\n    left: x,\n    top: y\n  };\n}\n\nfunction getElFuturePos(elRegion, refNodeRegion, points, offset, targetOffset) {\n  var p1 = getAlignOffset(refNodeRegion, points[1]);\n  var p2 = getAlignOffset(elRegion, points[0]);\n  var diff = [p2.left - p1.left, p2.top - p1.top];\n  return {\n    left: Math.round(elRegion.left - diff[0] + offset[0] - targetOffset[0]),\n    top: Math.round(elRegion.top - diff[1] + offset[1] - targetOffset[1])\n  };\n}\n\n/**\n * align dom node flexibly\n * @author yiminghe@gmail.com\n */\n\n// http://yiminghe.iteye.com/blog/1124720\n\nfunction isFailX(elFuturePos, elRegion, visibleRect) {\n  return elFuturePos.left < visibleRect.left || elFuturePos.left + elRegion.width > visibleRect.right;\n}\nfunction isFailY(elFuturePos, elRegion, visibleRect) {\n  return elFuturePos.top < visibleRect.top || elFuturePos.top + elRegion.height > visibleRect.bottom;\n}\nfunction isCompleteFailX(elFuturePos, elRegion, visibleRect) {\n  return elFuturePos.left > visibleRect.right || elFuturePos.left + elRegion.width < visibleRect.left;\n}\nfunction isCompleteFailY(elFuturePos, elRegion, visibleRect) {\n  return elFuturePos.top > visibleRect.bottom || elFuturePos.top + elRegion.height < visibleRect.top;\n}\nfunction flip(points, reg, map) {\n  var ret = [];\n  utils.each(points, function (p) {\n    ret.push(p.replace(reg, function (m) {\n      return map[m];\n    }));\n  });\n  return ret;\n}\nfunction flipOffset(offset, index) {\n  offset[index] = -offset[index];\n  return offset;\n}\nfunction convertOffset(str, offsetLen) {\n  var n;\n  if (/%$/.test(str)) {\n    n = parseInt(str.substring(0, str.length - 1), 10) / 100 * offsetLen;\n  } else {\n    n = parseInt(str, 10);\n  }\n  return n || 0;\n}\nfunction normalizeOffset(offset, el) {\n  offset[0] = convertOffset(offset[0], el.width);\n  offset[1] = convertOffset(offset[1], el.height);\n}\n\n/**\n * @param el\n * @param tgtRegion 参照节点所占的区域: { left, top, width, height }\n * @param align\n */\nfunction doAlign(el, tgtRegion, align, isTgtRegionVisible) {\n  var points = align.points;\n  var offset = align.offset || [0, 0];\n  var targetOffset = align.targetOffset || [0, 0];\n  var overflow = align.overflow;\n  var source = align.source || el;\n  offset = [].concat(offset);\n  targetOffset = [].concat(targetOffset);\n  overflow = overflow || {};\n  var newOverflowCfg = {};\n  var fail = 0;\n  var alwaysByViewport = !!(overflow && overflow.alwaysByViewport);\n  // 当前节点可以被放置的显示区域\n  var visibleRect = getVisibleRectForElement(source, alwaysByViewport);\n  // 当前节点所占的区域, left/top/width/height\n  var elRegion = getRegion(source);\n  // 将 offset 转换成数值，支持百分比\n  normalizeOffset(offset, elRegion);\n  normalizeOffset(targetOffset, tgtRegion);\n  // 当前节点将要被放置的位置\n  var elFuturePos = getElFuturePos(elRegion, tgtRegion, points, offset, targetOffset);\n  // 当前节点将要所处的区域\n  var newElRegion = utils.merge(elRegion, elFuturePos);\n\n  // 如果可视区域不能完全放置当前节点时允许调整\n  if (visibleRect && (overflow.adjustX || overflow.adjustY) && isTgtRegionVisible) {\n    if (overflow.adjustX) {\n      // 如果横向不能放下\n      if (isFailX(elFuturePos, elRegion, visibleRect)) {\n        // 对齐位置反下\n        var newPoints = flip(points, /[lr]/gi, {\n          l: 'r',\n          r: 'l'\n        });\n        // 偏移量也反下\n        var newOffset = flipOffset(offset, 0);\n        var newTargetOffset = flipOffset(targetOffset, 0);\n        var newElFuturePos = getElFuturePos(elRegion, tgtRegion, newPoints, newOffset, newTargetOffset);\n        if (!isCompleteFailX(newElFuturePos, elRegion, visibleRect)) {\n          fail = 1;\n          points = newPoints;\n          offset = newOffset;\n          targetOffset = newTargetOffset;\n        }\n      }\n    }\n    if (overflow.adjustY) {\n      // 如果纵向不能放下\n      if (isFailY(elFuturePos, elRegion, visibleRect)) {\n        // 对齐位置反下\n        var _newPoints = flip(points, /[tb]/gi, {\n          t: 'b',\n          b: 't'\n        });\n        // 偏移量也反下\n        var _newOffset = flipOffset(offset, 1);\n        var _newTargetOffset = flipOffset(targetOffset, 1);\n        var _newElFuturePos = getElFuturePos(elRegion, tgtRegion, _newPoints, _newOffset, _newTargetOffset);\n        if (!isCompleteFailY(_newElFuturePos, elRegion, visibleRect)) {\n          fail = 1;\n          points = _newPoints;\n          offset = _newOffset;\n          targetOffset = _newTargetOffset;\n        }\n      }\n    }\n\n    // 如果失败，重新计算当前节点将要被放置的位置\n    if (fail) {\n      elFuturePos = getElFuturePos(elRegion, tgtRegion, points, offset, targetOffset);\n      utils.mix(newElRegion, elFuturePos);\n    }\n    var isStillFailX = isFailX(elFuturePos, elRegion, visibleRect);\n    var isStillFailY = isFailY(elFuturePos, elRegion, visibleRect);\n    // 检查反下后的位置是否可以放下了，如果仍然放不下：\n    // 1. 复原修改过的定位参数\n    if (isStillFailX || isStillFailY) {\n      var _newPoints2 = points;\n\n      // 重置对应部分的翻转逻辑\n      if (isStillFailX) {\n        _newPoints2 = flip(points, /[lr]/gi, {\n          l: 'r',\n          r: 'l'\n        });\n      }\n      if (isStillFailY) {\n        _newPoints2 = flip(points, /[tb]/gi, {\n          t: 'b',\n          b: 't'\n        });\n      }\n      points = _newPoints2;\n      offset = align.offset || [0, 0];\n      targetOffset = align.targetOffset || [0, 0];\n    }\n    // 2. 只有指定了可以调整当前方向才调整\n    newOverflowCfg.adjustX = overflow.adjustX && isStillFailX;\n    newOverflowCfg.adjustY = overflow.adjustY && isStillFailY;\n\n    // 确实要调整，甚至可能会调整高度宽度\n    if (newOverflowCfg.adjustX || newOverflowCfg.adjustY) {\n      newElRegion = adjustForViewport(elFuturePos, elRegion, visibleRect, newOverflowCfg);\n    }\n  }\n\n  // need judge to in case set fixed with in css on height auto element\n  if (newElRegion.width !== elRegion.width) {\n    utils.css(source, 'width', utils.width(source) + newElRegion.width - elRegion.width);\n  }\n  if (newElRegion.height !== elRegion.height) {\n    utils.css(source, 'height', utils.height(source) + newElRegion.height - elRegion.height);\n  }\n\n  // https://github.com/kissyteam/kissy/issues/190\n  // 相对于屏幕位置没变，而 left/top 变了\n  // 例如 <div 'relative'><el absolute></div>\n  utils.offset(source, {\n    left: newElRegion.left,\n    top: newElRegion.top\n  }, {\n    useCssRight: align.useCssRight,\n    useCssBottom: align.useCssBottom,\n    useCssTransform: align.useCssTransform,\n    ignoreShake: align.ignoreShake\n  });\n  return {\n    points: points,\n    offset: offset,\n    targetOffset: targetOffset,\n    overflow: newOverflowCfg\n  };\n}\n/**\n *  2012-04-26 yiminghe@gmail.com\n *   - 优化智能对齐算法\n *   - 慎用 resizeXX\n *\n *  2011-07-13 yiminghe@gmail.com note:\n *   - 增加智能对齐，以及大小调整选项\n **/\n\nfunction isOutOfVisibleRect(target, alwaysByViewport) {\n  var visibleRect = getVisibleRectForElement(target, alwaysByViewport);\n  var targetRegion = getRegion(target);\n  return !visibleRect || targetRegion.left + targetRegion.width <= visibleRect.left || targetRegion.top + targetRegion.height <= visibleRect.top || targetRegion.left >= visibleRect.right || targetRegion.top >= visibleRect.bottom;\n}\nfunction alignElement(el, refNode, align) {\n  var target = align.target || refNode;\n  var refNodeRegion = getRegion(target);\n  var isTargetNotOutOfVisible = !isOutOfVisibleRect(target, align.overflow && align.overflow.alwaysByViewport);\n  return doAlign(el, refNodeRegion, align, isTargetNotOutOfVisible);\n}\nalignElement.__getOffsetParent = getOffsetParent;\nalignElement.__getVisibleRectForElement = getVisibleRectForElement;\n\n/**\n * `tgtPoint`: { pageX, pageY } or { clientX, clientY }.\n * If client position provided, will internal convert to page position.\n */\n\nfunction alignPoint(el, tgtPoint, align) {\n  var pageX;\n  var pageY;\n  var doc = utils.getDocument(el);\n  var win = doc.defaultView || doc.parentWindow;\n  var scrollX = utils.getWindowScrollLeft(win);\n  var scrollY = utils.getWindowScrollTop(win);\n  var viewportWidth = utils.viewportWidth(win);\n  var viewportHeight = utils.viewportHeight(win);\n  if ('pageX' in tgtPoint) {\n    pageX = tgtPoint.pageX;\n  } else {\n    pageX = scrollX + tgtPoint.clientX;\n  }\n  if ('pageY' in tgtPoint) {\n    pageY = tgtPoint.pageY;\n  } else {\n    pageY = scrollY + tgtPoint.clientY;\n  }\n  var tgtRegion = {\n    left: pageX,\n    top: pageY,\n    width: 0,\n    height: 0\n  };\n  var pointInView = pageX >= 0 && pageX <= scrollX + viewportWidth && pageY >= 0 && pageY <= scrollY + viewportHeight;\n\n  // Provide default target point\n  var points = [align.points[0], 'cc'];\n  return doAlign(el, tgtRegion, _objectSpread2(_objectSpread2({}, align), {}, {\n    points: points\n  }), pointInView);\n}\n\nexport default alignElement;\nexport { alignElement, alignPoint };\n//# sourceMappingURL=index.js.map\n","import CSSMotion from \"./CSSMotion\";\nimport CSSMotionList from \"./CSSMotionList\";\nexport { default as Provider } from \"./context\";\nexport { CSSMotionList };\nexport default CSSMotion;","export function getMotion(_ref) {\n  var prefixCls = _ref.prefixCls,\n      motion = _ref.motion,\n      animation = _ref.animation,\n      transitionName = _ref.transitionName;\n\n  if (motion) {\n    return motion;\n  }\n\n  if (animation) {\n    return {\n      motionName: \"\".concat(prefixCls, \"-\").concat(animation)\n    };\n  }\n\n  if (transitionName) {\n    return {\n      motionName: transitionName\n    };\n  }\n\n  return null;\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport * as React from 'react';\nimport classNames from 'classnames';\nimport CSSMotion from 'rc-motion';\nimport { getMotion } from \"../utils/legacyUtil\";\nexport default function Mask(props) {\n  var prefixCls = props.prefixCls,\n      visible = props.visible,\n      zIndex = props.zIndex,\n      mask = props.mask,\n      maskMotion = props.maskMotion,\n      maskAnimation = props.maskAnimation,\n      maskTransitionName = props.maskTransitionName;\n\n  if (!mask) {\n    return null;\n  }\n\n  var motion = {};\n\n  if (maskMotion || maskTransitionName || maskAnimation) {\n    motion = _objectSpread({\n      motionAppear: true\n    }, getMotion({\n      motion: maskMotion,\n      prefixCls: prefixCls,\n      transitionName: maskTransitionName,\n      animation: maskAnimation\n    }));\n  }\n\n  return /*#__PURE__*/React.createElement(CSSMotion, _extends({}, motion, {\n    visible: visible,\n    removeOnLeave: true\n  }), function (_ref) {\n    var className = _ref.className;\n    return /*#__PURE__*/React.createElement(\"div\", {\n      style: {\n        zIndex: zIndex\n      },\n      className: classNames(\"\".concat(prefixCls, \"-mask\"), className)\n    });\n  });\n}","import _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport warning from \"./warning\";\n\n/**\n * Deeply compares two object literals.\n * @param obj1 object 1\n * @param obj2 object 2\n * @param shallow shallow compare\n * @returns\n */\nfunction isEqual(obj1, obj2) {\n  var shallow = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n  // https://github.com/mapbox/mapbox-gl-js/pull/5979/files#diff-fde7145050c47cc3a306856efd5f9c3016e86e859de9afbd02c879be5067e58f\n  var refSet = new Set();\n  function deepEqual(a, b) {\n    var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n    var circular = refSet.has(a);\n    warning(!circular, 'Warning: There may be circular references');\n    if (circular) {\n      return false;\n    }\n    if (a === b) {\n      return true;\n    }\n    if (shallow && level > 1) {\n      return false;\n    }\n    refSet.add(a);\n    var newLevel = level + 1;\n    if (Array.isArray(a)) {\n      if (!Array.isArray(b) || a.length !== b.length) {\n        return false;\n      }\n      for (var i = 0; i < a.length; i++) {\n        if (!deepEqual(a[i], b[i], newLevel)) {\n          return false;\n        }\n      }\n      return true;\n    }\n    if (a && b && _typeof(a) === 'object' && _typeof(b) === 'object') {\n      var keys = Object.keys(a);\n      if (keys.length !== Object.keys(b).length) {\n        return false;\n      }\n      return keys.every(function (key) {\n        return deepEqual(a[key], b[key], newLevel);\n      });\n    }\n    // other\n    return false;\n  }\n  return deepEqual(obj1, obj2);\n}\nexport default isEqual;","/**\r\n * A collection of shims that provide minimal functionality of the ES6 collections.\r\n *\r\n * These implementations are not meant to be used outside of the ResizeObserver\r\n * modules as they cover only a limited range of use cases.\r\n */\r\n/* eslint-disable require-jsdoc, valid-jsdoc */\r\nvar MapShim = (function () {\r\n    if (typeof Map !== 'undefined') {\r\n        return Map;\r\n    }\r\n    /**\r\n     * Returns index in provided array that matches the specified key.\r\n     *\r\n     * @param {Array<Array>} arr\r\n     * @param {*} key\r\n     * @returns {number}\r\n     */\r\n    function getIndex(arr, key) {\r\n        var result = -1;\r\n        arr.some(function (entry, index) {\r\n            if (entry[0] === key) {\r\n                result = index;\r\n                return true;\r\n            }\r\n            return false;\r\n        });\r\n        return result;\r\n    }\r\n    return /** @class */ (function () {\r\n        function class_1() {\r\n            this.__entries__ = [];\r\n        }\r\n        Object.defineProperty(class_1.prototype, \"size\", {\r\n            /**\r\n             * @returns {boolean}\r\n             */\r\n            get: function () {\r\n                return this.__entries__.length;\r\n            },\r\n            enumerable: true,\r\n            configurable: true\r\n        });\r\n        /**\r\n         * @param {*} key\r\n         * @returns {*}\r\n         */\r\n        class_1.prototype.get = function (key) {\r\n            var index = getIndex(this.__entries__, key);\r\n            var entry = this.__entries__[index];\r\n            return entry && entry[1];\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @param {*} value\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.set = function (key, value) {\r\n            var index = getIndex(this.__entries__, key);\r\n            if (~index) {\r\n                this.__entries__[index][1] = value;\r\n            }\r\n            else {\r\n                this.__entries__.push([key, value]);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.delete = function (key) {\r\n            var entries = this.__entries__;\r\n            var index = getIndex(entries, key);\r\n            if (~index) {\r\n                entries.splice(index, 1);\r\n            }\r\n        };\r\n        /**\r\n         * @param {*} key\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.has = function (key) {\r\n            return !!~getIndex(this.__entries__, key);\r\n        };\r\n        /**\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.clear = function () {\r\n            this.__entries__.splice(0);\r\n        };\r\n        /**\r\n         * @param {Function} callback\r\n         * @param {*} [ctx=null]\r\n         * @returns {void}\r\n         */\r\n        class_1.prototype.forEach = function (callback, ctx) {\r\n            if (ctx === void 0) { ctx = null; }\r\n            for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {\r\n                var entry = _a[_i];\r\n                callback.call(ctx, entry[1], entry[0]);\r\n            }\r\n        };\r\n        return class_1;\r\n    }());\r\n})();\n\n/**\r\n * Detects whether window and document objects are available in current environment.\r\n */\r\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document;\n\n// Returns global object of a current environment.\r\nvar global$1 = (function () {\r\n    if (typeof global !== 'undefined' && global.Math === Math) {\r\n        return global;\r\n    }\r\n    if (typeof self !== 'undefined' && self.Math === Math) {\r\n        return self;\r\n    }\r\n    if (typeof window !== 'undefined' && window.Math === Math) {\r\n        return window;\r\n    }\r\n    // eslint-disable-next-line no-new-func\r\n    return Function('return this')();\r\n})();\n\n/**\r\n * A shim for the requestAnimationFrame which falls back to the setTimeout if\r\n * first one is not supported.\r\n *\r\n * @returns {number} Requests' identifier.\r\n */\r\nvar requestAnimationFrame$1 = (function () {\r\n    if (typeof requestAnimationFrame === 'function') {\r\n        // It's required to use a bounded function because IE sometimes throws\r\n        // an \"Invalid calling object\" error if rAF is invoked without the global\r\n        // object on the left hand side.\r\n        return requestAnimationFrame.bind(global$1);\r\n    }\r\n    return function (callback) { return setTimeout(function () { return callback(Date.now()); }, 1000 / 60); };\r\n})();\n\n// Defines minimum timeout before adding a trailing call.\r\nvar trailingTimeout = 2;\r\n/**\r\n * Creates a wrapper function which ensures that provided callback will be\r\n * invoked only once during the specified delay period.\r\n *\r\n * @param {Function} callback - Function to be invoked after the delay period.\r\n * @param {number} delay - Delay after which to invoke callback.\r\n * @returns {Function}\r\n */\r\nfunction throttle (callback, delay) {\r\n    var leadingCall = false, trailingCall = false, lastCallTime = 0;\r\n    /**\r\n     * Invokes the original callback function and schedules new invocation if\r\n     * the \"proxy\" was called during current request.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function resolvePending() {\r\n        if (leadingCall) {\r\n            leadingCall = false;\r\n            callback();\r\n        }\r\n        if (trailingCall) {\r\n            proxy();\r\n        }\r\n    }\r\n    /**\r\n     * Callback invoked after the specified delay. It will further postpone\r\n     * invocation of the original function delegating it to the\r\n     * requestAnimationFrame.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function timeoutCallback() {\r\n        requestAnimationFrame$1(resolvePending);\r\n    }\r\n    /**\r\n     * Schedules invocation of the original function.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    function proxy() {\r\n        var timeStamp = Date.now();\r\n        if (leadingCall) {\r\n            // Reject immediately following calls.\r\n            if (timeStamp - lastCallTime < trailingTimeout) {\r\n                return;\r\n            }\r\n            // Schedule new call to be in invoked when the pending one is resolved.\r\n            // This is important for \"transitions\" which never actually start\r\n            // immediately so there is a chance that we might miss one if change\r\n            // happens amids the pending invocation.\r\n            trailingCall = true;\r\n        }\r\n        else {\r\n            leadingCall = true;\r\n            trailingCall = false;\r\n            setTimeout(timeoutCallback, delay);\r\n        }\r\n        lastCallTime = timeStamp;\r\n    }\r\n    return proxy;\r\n}\n\n// Minimum delay before invoking the update of observers.\r\nvar REFRESH_DELAY = 20;\r\n// A list of substrings of CSS properties used to find transition events that\r\n// might affect dimensions of observed elements.\r\nvar transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];\r\n// Check if MutationObserver is available.\r\nvar mutationObserverSupported = typeof MutationObserver !== 'undefined';\r\n/**\r\n * Singleton controller class which handles updates of ResizeObserver instances.\r\n */\r\nvar ResizeObserverController = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserverController.\r\n     *\r\n     * @private\r\n     */\r\n    function ResizeObserverController() {\r\n        /**\r\n         * Indicates whether DOM listeners have been added.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.connected_ = false;\r\n        /**\r\n         * Tells that controller has subscribed for Mutation Events.\r\n         *\r\n         * @private {boolean}\r\n         */\r\n        this.mutationEventsAdded_ = false;\r\n        /**\r\n         * Keeps reference to the instance of MutationObserver.\r\n         *\r\n         * @private {MutationObserver}\r\n         */\r\n        this.mutationsObserver_ = null;\r\n        /**\r\n         * A list of connected observers.\r\n         *\r\n         * @private {Array<ResizeObserverSPI>}\r\n         */\r\n        this.observers_ = [];\r\n        this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);\r\n        this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);\r\n    }\r\n    /**\r\n     * Adds observer to observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be added.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.addObserver = function (observer) {\r\n        if (!~this.observers_.indexOf(observer)) {\r\n            this.observers_.push(observer);\r\n        }\r\n        // Add listeners if they haven't been added yet.\r\n        if (!this.connected_) {\r\n            this.connect_();\r\n        }\r\n    };\r\n    /**\r\n     * Removes observer from observers list.\r\n     *\r\n     * @param {ResizeObserverSPI} observer - Observer to be removed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.removeObserver = function (observer) {\r\n        var observers = this.observers_;\r\n        var index = observers.indexOf(observer);\r\n        // Remove observer if it's present in registry.\r\n        if (~index) {\r\n            observers.splice(index, 1);\r\n        }\r\n        // Remove listeners if controller has no connected observers.\r\n        if (!observers.length && this.connected_) {\r\n            this.disconnect_();\r\n        }\r\n    };\r\n    /**\r\n     * Invokes the update of observers. It will continue running updates insofar\r\n     * it detects changes.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.refresh = function () {\r\n        var changesDetected = this.updateObservers_();\r\n        // Continue running updates if changes have been detected as there might\r\n        // be future ones caused by CSS transitions.\r\n        if (changesDetected) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Updates every observer from observers list and notifies them of queued\r\n     * entries.\r\n     *\r\n     * @private\r\n     * @returns {boolean} Returns \"true\" if any observer has detected changes in\r\n     *      dimensions of it's elements.\r\n     */\r\n    ResizeObserverController.prototype.updateObservers_ = function () {\r\n        // Collect observers that have active observations.\r\n        var activeObservers = this.observers_.filter(function (observer) {\r\n            return observer.gatherActive(), observer.hasActive();\r\n        });\r\n        // Deliver notifications in a separate cycle in order to avoid any\r\n        // collisions between observers, e.g. when multiple instances of\r\n        // ResizeObserver are tracking the same element and the callback of one\r\n        // of them changes content dimensions of the observed target. Sometimes\r\n        // this may result in notifications being blocked for the rest of observers.\r\n        activeObservers.forEach(function (observer) { return observer.broadcastActive(); });\r\n        return activeObservers.length > 0;\r\n    };\r\n    /**\r\n     * Initializes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.connect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already added.\r\n        if (!isBrowser || this.connected_) {\r\n            return;\r\n        }\r\n        // Subscription to the \"Transitionend\" event is used as a workaround for\r\n        // delayed transitions. This way it's possible to capture at least the\r\n        // final state of an element.\r\n        document.addEventListener('transitionend', this.onTransitionEnd_);\r\n        window.addEventListener('resize', this.refresh);\r\n        if (mutationObserverSupported) {\r\n            this.mutationsObserver_ = new MutationObserver(this.refresh);\r\n            this.mutationsObserver_.observe(document, {\r\n                attributes: true,\r\n                childList: true,\r\n                characterData: true,\r\n                subtree: true\r\n            });\r\n        }\r\n        else {\r\n            document.addEventListener('DOMSubtreeModified', this.refresh);\r\n            this.mutationEventsAdded_ = true;\r\n        }\r\n        this.connected_ = true;\r\n    };\r\n    /**\r\n     * Removes DOM listeners.\r\n     *\r\n     * @private\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.disconnect_ = function () {\r\n        // Do nothing if running in a non-browser environment or if listeners\r\n        // have been already removed.\r\n        if (!isBrowser || !this.connected_) {\r\n            return;\r\n        }\r\n        document.removeEventListener('transitionend', this.onTransitionEnd_);\r\n        window.removeEventListener('resize', this.refresh);\r\n        if (this.mutationsObserver_) {\r\n            this.mutationsObserver_.disconnect();\r\n        }\r\n        if (this.mutationEventsAdded_) {\r\n            document.removeEventListener('DOMSubtreeModified', this.refresh);\r\n        }\r\n        this.mutationsObserver_ = null;\r\n        this.mutationEventsAdded_ = false;\r\n        this.connected_ = false;\r\n    };\r\n    /**\r\n     * \"Transitionend\" event handler.\r\n     *\r\n     * @private\r\n     * @param {TransitionEvent} event\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {\r\n        var _b = _a.propertyName, propertyName = _b === void 0 ? '' : _b;\r\n        // Detect whether transition may affect dimensions of an element.\r\n        var isReflowProperty = transitionKeys.some(function (key) {\r\n            return !!~propertyName.indexOf(key);\r\n        });\r\n        if (isReflowProperty) {\r\n            this.refresh();\r\n        }\r\n    };\r\n    /**\r\n     * Returns instance of the ResizeObserverController.\r\n     *\r\n     * @returns {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.getInstance = function () {\r\n        if (!this.instance_) {\r\n            this.instance_ = new ResizeObserverController();\r\n        }\r\n        return this.instance_;\r\n    };\r\n    /**\r\n     * Holds reference to the controller's instance.\r\n     *\r\n     * @private {ResizeObserverController}\r\n     */\r\n    ResizeObserverController.instance_ = null;\r\n    return ResizeObserverController;\r\n}());\n\n/**\r\n * Defines non-writable/enumerable properties of the provided target object.\r\n *\r\n * @param {Object} target - Object for which to define properties.\r\n * @param {Object} props - Properties to be defined.\r\n * @returns {Object} Target object.\r\n */\r\nvar defineConfigurable = (function (target, props) {\r\n    for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\r\n        var key = _a[_i];\r\n        Object.defineProperty(target, key, {\r\n            value: props[key],\r\n            enumerable: false,\r\n            writable: false,\r\n            configurable: true\r\n        });\r\n    }\r\n    return target;\r\n});\n\n/**\r\n * Returns the global object associated with provided element.\r\n *\r\n * @param {Object} target\r\n * @returns {Object}\r\n */\r\nvar getWindowOf = (function (target) {\r\n    // Assume that the element is an instance of Node, which means that it\r\n    // has the \"ownerDocument\" property from which we can retrieve a\r\n    // corresponding global object.\r\n    var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;\r\n    // Return the local global object if it's not possible extract one from\r\n    // provided element.\r\n    return ownerGlobal || global$1;\r\n});\n\n// Placeholder of an empty content rectangle.\r\nvar emptyRect = createRectInit(0, 0, 0, 0);\r\n/**\r\n * Converts provided string to a number.\r\n *\r\n * @param {number|string} value\r\n * @returns {number}\r\n */\r\nfunction toFloat(value) {\r\n    return parseFloat(value) || 0;\r\n}\r\n/**\r\n * Extracts borders size from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @param {...string} positions - Borders positions (top, right, ...)\r\n * @returns {number}\r\n */\r\nfunction getBordersSize(styles) {\r\n    var positions = [];\r\n    for (var _i = 1; _i < arguments.length; _i++) {\r\n        positions[_i - 1] = arguments[_i];\r\n    }\r\n    return positions.reduce(function (size, position) {\r\n        var value = styles['border-' + position + '-width'];\r\n        return size + toFloat(value);\r\n    }, 0);\r\n}\r\n/**\r\n * Extracts paddings sizes from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @returns {Object} Paddings box.\r\n */\r\nfunction getPaddings(styles) {\r\n    var positions = ['top', 'right', 'bottom', 'left'];\r\n    var paddings = {};\r\n    for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {\r\n        var position = positions_1[_i];\r\n        var value = styles['padding-' + position];\r\n        paddings[position] = toFloat(value);\r\n    }\r\n    return paddings;\r\n}\r\n/**\r\n * Calculates content rectangle of provided SVG element.\r\n *\r\n * @param {SVGGraphicsElement} target - Element content rectangle of which needs\r\n *      to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getSVGContentRect(target) {\r\n    var bbox = target.getBBox();\r\n    return createRectInit(0, 0, bbox.width, bbox.height);\r\n}\r\n/**\r\n * Calculates content rectangle of provided HTMLElement.\r\n *\r\n * @param {HTMLElement} target - Element for which to calculate the content rectangle.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getHTMLElementContentRect(target) {\r\n    // Client width & height properties can't be\r\n    // used exclusively as they provide rounded values.\r\n    var clientWidth = target.clientWidth, clientHeight = target.clientHeight;\r\n    // By this condition we can catch all non-replaced inline, hidden and\r\n    // detached elements. Though elements with width & height properties less\r\n    // than 0.5 will be discarded as well.\r\n    //\r\n    // Without it we would need to implement separate methods for each of\r\n    // those cases and it's not possible to perform a precise and performance\r\n    // effective test for hidden elements. E.g. even jQuery's ':visible' filter\r\n    // gives wrong results for elements with width & height less than 0.5.\r\n    if (!clientWidth && !clientHeight) {\r\n        return emptyRect;\r\n    }\r\n    var styles = getWindowOf(target).getComputedStyle(target);\r\n    var paddings = getPaddings(styles);\r\n    var horizPad = paddings.left + paddings.right;\r\n    var vertPad = paddings.top + paddings.bottom;\r\n    // Computed styles of width & height are being used because they are the\r\n    // only dimensions available to JS that contain non-rounded values. It could\r\n    // be possible to utilize the getBoundingClientRect if only it's data wasn't\r\n    // affected by CSS transformations let alone paddings, borders and scroll bars.\r\n    var width = toFloat(styles.width), height = toFloat(styles.height);\r\n    // Width & height include paddings and borders when the 'border-box' box\r\n    // model is applied (except for IE).\r\n    if (styles.boxSizing === 'border-box') {\r\n        // Following conditions are required to handle Internet Explorer which\r\n        // doesn't include paddings and borders to computed CSS dimensions.\r\n        //\r\n        // We can say that if CSS dimensions + paddings are equal to the \"client\"\r\n        // properties then it's either IE, and thus we don't need to subtract\r\n        // anything, or an element merely doesn't have paddings/borders styles.\r\n        if (Math.round(width + horizPad) !== clientWidth) {\r\n            width -= getBordersSize(styles, 'left', 'right') + horizPad;\r\n        }\r\n        if (Math.round(height + vertPad) !== clientHeight) {\r\n            height -= getBordersSize(styles, 'top', 'bottom') + vertPad;\r\n        }\r\n    }\r\n    // Following steps can't be applied to the document's root element as its\r\n    // client[Width/Height] properties represent viewport area of the window.\r\n    // Besides, it's as well not necessary as the <html> itself neither has\r\n    // rendered scroll bars nor it can be clipped.\r\n    if (!isDocumentElement(target)) {\r\n        // In some browsers (only in Firefox, actually) CSS width & height\r\n        // include scroll bars size which can be removed at this step as scroll\r\n        // bars are the only difference between rounded dimensions + paddings\r\n        // and \"client\" properties, though that is not always true in Chrome.\r\n        var vertScrollbar = Math.round(width + horizPad) - clientWidth;\r\n        var horizScrollbar = Math.round(height + vertPad) - clientHeight;\r\n        // Chrome has a rather weird rounding of \"client\" properties.\r\n        // E.g. for an element with content width of 314.2px it sometimes gives\r\n        // the client width of 315px and for the width of 314.7px it may give\r\n        // 314px. And it doesn't happen all the time. So just ignore this delta\r\n        // as a non-relevant.\r\n        if (Math.abs(vertScrollbar) !== 1) {\r\n            width -= vertScrollbar;\r\n        }\r\n        if (Math.abs(horizScrollbar) !== 1) {\r\n            height -= horizScrollbar;\r\n        }\r\n    }\r\n    return createRectInit(paddings.left, paddings.top, width, height);\r\n}\r\n/**\r\n * Checks whether provided element is an instance of the SVGGraphicsElement.\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nvar isSVGGraphicsElement = (function () {\r\n    // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement\r\n    // interface.\r\n    if (typeof SVGGraphicsElement !== 'undefined') {\r\n        return function (target) { return target instanceof getWindowOf(target).SVGGraphicsElement; };\r\n    }\r\n    // If it's so, then check that element is at least an instance of the\r\n    // SVGElement and that it has the \"getBBox\" method.\r\n    // eslint-disable-next-line no-extra-parens\r\n    return function (target) { return (target instanceof getWindowOf(target).SVGElement &&\r\n        typeof target.getBBox === 'function'); };\r\n})();\r\n/**\r\n * Checks whether provided element is a document element (<html>).\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\r\nfunction isDocumentElement(target) {\r\n    return target === getWindowOf(target).document.documentElement;\r\n}\r\n/**\r\n * Calculates an appropriate content rectangle for provided html or svg element.\r\n *\r\n * @param {Element} target - Element content rectangle of which needs to be calculated.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction getContentRect(target) {\r\n    if (!isBrowser) {\r\n        return emptyRect;\r\n    }\r\n    if (isSVGGraphicsElement(target)) {\r\n        return getSVGContentRect(target);\r\n    }\r\n    return getHTMLElementContentRect(target);\r\n}\r\n/**\r\n * Creates rectangle with an interface of the DOMRectReadOnly.\r\n * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly\r\n *\r\n * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.\r\n * @returns {DOMRectReadOnly}\r\n */\r\nfunction createReadOnlyRect(_a) {\r\n    var x = _a.x, y = _a.y, width = _a.width, height = _a.height;\r\n    // If DOMRectReadOnly is available use it as a prototype for the rectangle.\r\n    var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;\r\n    var rect = Object.create(Constr.prototype);\r\n    // Rectangle's properties are not writable and non-enumerable.\r\n    defineConfigurable(rect, {\r\n        x: x, y: y, width: width, height: height,\r\n        top: y,\r\n        right: x + width,\r\n        bottom: height + y,\r\n        left: x\r\n    });\r\n    return rect;\r\n}\r\n/**\r\n * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.\r\n * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit\r\n *\r\n * @param {number} x - X coordinate.\r\n * @param {number} y - Y coordinate.\r\n * @param {number} width - Rectangle's width.\r\n * @param {number} height - Rectangle's height.\r\n * @returns {DOMRectInit}\r\n */\r\nfunction createRectInit(x, y, width, height) {\r\n    return { x: x, y: y, width: width, height: height };\r\n}\n\n/**\r\n * Class that is responsible for computations of the content rectangle of\r\n * provided DOM element and for keeping track of it's changes.\r\n */\r\nvar ResizeObservation = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObservation.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     */\r\n    function ResizeObservation(target) {\r\n        /**\r\n         * Broadcasted width of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastWidth = 0;\r\n        /**\r\n         * Broadcasted height of content rectangle.\r\n         *\r\n         * @type {number}\r\n         */\r\n        this.broadcastHeight = 0;\r\n        /**\r\n         * Reference to the last observed content rectangle.\r\n         *\r\n         * @private {DOMRectInit}\r\n         */\r\n        this.contentRect_ = createRectInit(0, 0, 0, 0);\r\n        this.target = target;\r\n    }\r\n    /**\r\n     * Updates content rectangle and tells whether it's width or height properties\r\n     * have changed since the last broadcast.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObservation.prototype.isActive = function () {\r\n        var rect = getContentRect(this.target);\r\n        this.contentRect_ = rect;\r\n        return (rect.width !== this.broadcastWidth ||\r\n            rect.height !== this.broadcastHeight);\r\n    };\r\n    /**\r\n     * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data\r\n     * from the corresponding properties of the last observed content rectangle.\r\n     *\r\n     * @returns {DOMRectInit} Last observed content rectangle.\r\n     */\r\n    ResizeObservation.prototype.broadcastRect = function () {\r\n        var rect = this.contentRect_;\r\n        this.broadcastWidth = rect.width;\r\n        this.broadcastHeight = rect.height;\r\n        return rect;\r\n    };\r\n    return ResizeObservation;\r\n}());\n\nvar ResizeObserverEntry = /** @class */ (function () {\r\n    /**\r\n     * Creates an instance of ResizeObserverEntry.\r\n     *\r\n     * @param {Element} target - Element that is being observed.\r\n     * @param {DOMRectInit} rectInit - Data of the element's content rectangle.\r\n     */\r\n    function ResizeObserverEntry(target, rectInit) {\r\n        var contentRect = createReadOnlyRect(rectInit);\r\n        // According to the specification following properties are not writable\r\n        // and are also not enumerable in the native implementation.\r\n        //\r\n        // Property accessors are not being used as they'd require to define a\r\n        // private WeakMap storage which may cause memory leaks in browsers that\r\n        // don't support this type of collections.\r\n        defineConfigurable(this, { target: target, contentRect: contentRect });\r\n    }\r\n    return ResizeObserverEntry;\r\n}());\n\nvar ResizeObserverSPI = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback function that is invoked\r\n     *      when one of the observed elements changes it's content dimensions.\r\n     * @param {ResizeObserverController} controller - Controller instance which\r\n     *      is responsible for the updates of observer.\r\n     * @param {ResizeObserver} callbackCtx - Reference to the public\r\n     *      ResizeObserver instance which will be passed to callback function.\r\n     */\r\n    function ResizeObserverSPI(callback, controller, callbackCtx) {\r\n        /**\r\n         * Collection of resize observations that have detected changes in dimensions\r\n         * of elements.\r\n         *\r\n         * @private {Array<ResizeObservation>}\r\n         */\r\n        this.activeObservations_ = [];\r\n        /**\r\n         * Registry of the ResizeObservation instances.\r\n         *\r\n         * @private {Map<Element, ResizeObservation>}\r\n         */\r\n        this.observations_ = new MapShim();\r\n        if (typeof callback !== 'function') {\r\n            throw new TypeError('The callback provided as parameter 1 is not a function.');\r\n        }\r\n        this.callback_ = callback;\r\n        this.controller_ = controller;\r\n        this.callbackCtx_ = callbackCtx;\r\n    }\r\n    /**\r\n     * Starts observing provided element.\r\n     *\r\n     * @param {Element} target - Element to be observed.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.observe = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is already being observed.\r\n        if (observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.set(target, new ResizeObservation(target));\r\n        this.controller_.addObserver(this);\r\n        // Force the update of observations.\r\n        this.controller_.refresh();\r\n    };\r\n    /**\r\n     * Stops observing provided element.\r\n     *\r\n     * @param {Element} target - Element to stop observing.\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.unobserve = function (target) {\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        // Do nothing if current environment doesn't have the Element interface.\r\n        if (typeof Element === 'undefined' || !(Element instanceof Object)) {\r\n            return;\r\n        }\r\n        if (!(target instanceof getWindowOf(target).Element)) {\r\n            throw new TypeError('parameter 1 is not of type \"Element\".');\r\n        }\r\n        var observations = this.observations_;\r\n        // Do nothing if element is not being observed.\r\n        if (!observations.has(target)) {\r\n            return;\r\n        }\r\n        observations.delete(target);\r\n        if (!observations.size) {\r\n            this.controller_.removeObserver(this);\r\n        }\r\n    };\r\n    /**\r\n     * Stops observing all elements.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.disconnect = function () {\r\n        this.clearActive();\r\n        this.observations_.clear();\r\n        this.controller_.removeObserver(this);\r\n    };\r\n    /**\r\n     * Collects observation instances the associated element of which has changed\r\n     * it's content rectangle.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.gatherActive = function () {\r\n        var _this = this;\r\n        this.clearActive();\r\n        this.observations_.forEach(function (observation) {\r\n            if (observation.isActive()) {\r\n                _this.activeObservations_.push(observation);\r\n            }\r\n        });\r\n    };\r\n    /**\r\n     * Invokes initial callback function with a list of ResizeObserverEntry\r\n     * instances collected from active resize observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.broadcastActive = function () {\r\n        // Do nothing if observer doesn't have active observations.\r\n        if (!this.hasActive()) {\r\n            return;\r\n        }\r\n        var ctx = this.callbackCtx_;\r\n        // Create ResizeObserverEntry instance for every active observation.\r\n        var entries = this.activeObservations_.map(function (observation) {\r\n            return new ResizeObserverEntry(observation.target, observation.broadcastRect());\r\n        });\r\n        this.callback_.call(ctx, entries, ctx);\r\n        this.clearActive();\r\n    };\r\n    /**\r\n     * Clears the collection of active observations.\r\n     *\r\n     * @returns {void}\r\n     */\r\n    ResizeObserverSPI.prototype.clearActive = function () {\r\n        this.activeObservations_.splice(0);\r\n    };\r\n    /**\r\n     * Tells whether observer has active observations.\r\n     *\r\n     * @returns {boolean}\r\n     */\r\n    ResizeObserverSPI.prototype.hasActive = function () {\r\n        return this.activeObservations_.length > 0;\r\n    };\r\n    return ResizeObserverSPI;\r\n}());\n\n// Registry of internal observers. If WeakMap is not available use current shim\r\n// for the Map collection as it has all required methods and because WeakMap\r\n// can't be fully polyfilled anyway.\r\nvar observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();\r\n/**\r\n * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation\r\n * exposing only those methods and properties that are defined in the spec.\r\n */\r\nvar ResizeObserver = /** @class */ (function () {\r\n    /**\r\n     * Creates a new instance of ResizeObserver.\r\n     *\r\n     * @param {ResizeObserverCallback} callback - Callback that is invoked when\r\n     *      dimensions of the observed elements change.\r\n     */\r\n    function ResizeObserver(callback) {\r\n        if (!(this instanceof ResizeObserver)) {\r\n            throw new TypeError('Cannot call a class as a function.');\r\n        }\r\n        if (!arguments.length) {\r\n            throw new TypeError('1 argument required, but only 0 present.');\r\n        }\r\n        var controller = ResizeObserverController.getInstance();\r\n        var observer = new ResizeObserverSPI(callback, controller, this);\r\n        observers.set(this, observer);\r\n    }\r\n    return ResizeObserver;\r\n}());\r\n// Expose public methods of ResizeObserver.\r\n[\r\n    'observe',\r\n    'unobserve',\r\n    'disconnect'\r\n].forEach(function (method) {\r\n    ResizeObserver.prototype[method] = function () {\r\n        var _a;\r\n        return (_a = observers.get(this))[method].apply(_a, arguments);\r\n    };\r\n});\n\nvar index = (function () {\r\n    // Export existing implementation if available.\r\n    if (typeof global$1.ResizeObserver !== 'undefined') {\r\n        return global$1.ResizeObserver;\r\n    }\r\n    return ResizeObserver;\r\n})();\n\nexport default index;\n","import _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport ResizeObserver from 'resize-observer-polyfill';\nimport contains from \"rc-util/es/Dom/contains\";\nexport function isSamePoint(prev, next) {\n  if (prev === next) return true;\n  if (!prev || !next) return false;\n\n  if ('pageX' in next && 'pageY' in next) {\n    return prev.pageX === next.pageX && prev.pageY === next.pageY;\n  }\n\n  if ('clientX' in next && 'clientY' in next) {\n    return prev.clientX === next.clientX && prev.clientY === next.clientY;\n  }\n\n  return false;\n}\nexport function restoreFocus(activeElement, container) {\n  // Focus back if is in the container\n  if (activeElement !== document.activeElement && contains(container, activeElement) && typeof activeElement.focus === 'function') {\n    activeElement.focus();\n  }\n}\nexport function monitorResize(element, callback) {\n  var prevWidth = null;\n  var prevHeight = null;\n\n  function onResize(_ref) {\n    var _ref2 = _slicedToArray(_ref, 1),\n        target = _ref2[0].target;\n\n    if (!document.documentElement.contains(target)) return;\n\n    var _target$getBoundingCl = target.getBoundingClientRect(),\n        width = _target$getBoundingCl.width,\n        height = _target$getBoundingCl.height;\n\n    var fixedWidth = Math.floor(width);\n    var fixedHeight = Math.floor(height);\n\n    if (prevWidth !== fixedWidth || prevHeight !== fixedHeight) {\n      // https://webkit.org/blog/9997/resizeobserver-in-webkit/\n      Promise.resolve().then(function () {\n        callback({\n          width: fixedWidth,\n          height: fixedHeight\n        });\n      });\n    }\n\n    prevWidth = fixedWidth;\n    prevHeight = fixedHeight;\n  }\n\n  var resizeObserver = new ResizeObserver(onResize);\n\n  if (element) {\n    resizeObserver.observe(element);\n  }\n\n  return function () {\n    resizeObserver.disconnect();\n  };\n}","import _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport _typeof from \"@babel/runtime/helpers/esm/typeof\";\n\n/**\n * Removed props:\n *  - childrenProps\n */\nimport { alignElement, alignPoint } from 'dom-align';\nimport isEqual from \"rc-util/es/isEqual\";\nimport addEventListener from \"rc-util/es/Dom/addEventListener\";\nimport isVisible from \"rc-util/es/Dom/isVisible\";\nimport useLayoutEffect from \"rc-util/es/hooks/useLayoutEffect\";\nimport { composeRef } from \"rc-util/es/ref\";\nimport React from 'react';\nimport useBuffer from \"./hooks/useBuffer\";\nimport { isSamePoint, monitorResize, restoreFocus } from \"./util\";\n\nfunction getElement(func) {\n  if (typeof func !== 'function') return null;\n  return func();\n}\n\nfunction getPoint(point) {\n  if (_typeof(point) !== 'object' || !point) return null;\n  return point;\n}\n\nvar Align = function Align(_ref, ref) {\n  var children = _ref.children,\n      disabled = _ref.disabled,\n      target = _ref.target,\n      align = _ref.align,\n      onAlign = _ref.onAlign,\n      monitorWindowResize = _ref.monitorWindowResize,\n      _ref$monitorBufferTim = _ref.monitorBufferTime,\n      monitorBufferTime = _ref$monitorBufferTim === void 0 ? 0 : _ref$monitorBufferTim;\n  var cacheRef = React.useRef({});\n  /** Popup node ref */\n\n  var nodeRef = React.useRef();\n  var childNode = React.Children.only(children); // ===================== Align ======================\n  // We save the props here to avoid closure makes props ood\n\n  var forceAlignPropsRef = React.useRef({});\n  forceAlignPropsRef.current.disabled = disabled;\n  forceAlignPropsRef.current.target = target;\n  forceAlignPropsRef.current.align = align;\n  forceAlignPropsRef.current.onAlign = onAlign;\n\n  var _useBuffer = useBuffer(function () {\n    var _forceAlignPropsRef$c = forceAlignPropsRef.current,\n        latestDisabled = _forceAlignPropsRef$c.disabled,\n        latestTarget = _forceAlignPropsRef$c.target,\n        latestAlign = _forceAlignPropsRef$c.align,\n        latestOnAlign = _forceAlignPropsRef$c.onAlign;\n    var source = nodeRef.current;\n\n    if (!latestDisabled && latestTarget && source) {\n      var _result;\n\n      var _element = getElement(latestTarget);\n\n      var _point = getPoint(latestTarget);\n\n      cacheRef.current.element = _element;\n      cacheRef.current.point = _point;\n      cacheRef.current.align = latestAlign; // IE lose focus after element realign\n      // We should record activeElement and restore later\n\n      var _document = document,\n          activeElement = _document.activeElement; // We only align when element is visible\n\n      if (_element && isVisible(_element)) {\n        _result = alignElement(source, _element, latestAlign);\n      } else if (_point) {\n        _result = alignPoint(source, _point, latestAlign);\n      }\n\n      restoreFocus(activeElement, source);\n\n      if (latestOnAlign && _result) {\n        latestOnAlign(source, _result);\n      }\n\n      return true;\n    }\n\n    return false;\n  }, monitorBufferTime),\n      _useBuffer2 = _slicedToArray(_useBuffer, 2),\n      _forceAlign = _useBuffer2[0],\n      cancelForceAlign = _useBuffer2[1]; // ===================== Effect =====================\n  // Handle props change\n\n\n  var _React$useState = React.useState(),\n      _React$useState2 = _slicedToArray(_React$useState, 2),\n      element = _React$useState2[0],\n      setElement = _React$useState2[1];\n\n  var _React$useState3 = React.useState(),\n      _React$useState4 = _slicedToArray(_React$useState3, 2),\n      point = _React$useState4[0],\n      setPoint = _React$useState4[1];\n\n  useLayoutEffect(function () {\n    setElement(getElement(target));\n    setPoint(getPoint(target));\n  });\n  React.useEffect(function () {\n    if (cacheRef.current.element !== element || !isSamePoint(cacheRef.current.point, point) || !isEqual(cacheRef.current.align, align)) {\n      _forceAlign();\n    }\n  }); // Watch popup element resize\n\n  React.useEffect(function () {\n    var cancelFn = monitorResize(nodeRef.current, _forceAlign);\n    return cancelFn;\n  }, [nodeRef.current]); // Watch target element resize\n\n  React.useEffect(function () {\n    var cancelFn = monitorResize(element, _forceAlign);\n    return cancelFn;\n  }, [element]); // Listen for disabled change\n\n  React.useEffect(function () {\n    if (!disabled) {\n      _forceAlign();\n    } else {\n      cancelForceAlign();\n    }\n  }, [disabled]); // Listen for window resize\n\n  React.useEffect(function () {\n    if (monitorWindowResize) {\n      var cancelFn = addEventListener(window, 'resize', _forceAlign);\n      return cancelFn.remove;\n    }\n  }, [monitorWindowResize]); // Clear all if unmount\n\n  React.useEffect(function () {\n    return function () {\n      cancelForceAlign();\n    };\n  }, []); // ====================== Ref =======================\n\n  React.useImperativeHandle(ref, function () {\n    return {\n      forceAlign: function forceAlign() {\n        return _forceAlign(true);\n      }\n    };\n  }); // ===================== Render =====================\n\n  if ( /*#__PURE__*/React.isValidElement(childNode)) {\n    childNode = /*#__PURE__*/React.cloneElement(childNode, {\n      ref: composeRef(childNode.ref, nodeRef)\n    });\n  }\n\n  return childNode;\n};\n\nvar RcAlign = /*#__PURE__*/React.forwardRef(Align);\nRcAlign.displayName = 'Align';\nexport default RcAlign;","import React from 'react';\nexport default (function (callback, buffer) {\n  var calledRef = React.useRef(false);\n  var timeoutRef = React.useRef(null);\n\n  function cancelTrigger() {\n    window.clearTimeout(timeoutRef.current);\n  }\n\n  function trigger(force) {\n    cancelTrigger();\n\n    if (!calledRef.current || force === true) {\n      if (callback(force) === false) {\n        // Not delay since callback cancelled self\n        return;\n      }\n\n      calledRef.current = true;\n      timeoutRef.current = window.setTimeout(function () {\n        calledRef.current = false;\n      }, buffer);\n    } else {\n      timeoutRef.current = window.setTimeout(function () {\n        calledRef.current = false;\n        trigger();\n      }, buffer);\n    }\n  }\n\n  return [trigger, function () {\n    calledRef.current = false;\n    cancelTrigger();\n  }];\n});","export default (function (element) {\n  if (!element) {\n    return false;\n  }\n  if (element instanceof Element) {\n    if (element.offsetParent) {\n      return true;\n    }\n    if (element.getBBox) {\n      var _getBBox = element.getBBox(),\n        width = _getBBox.width,\n        height = _getBBox.height;\n      if (width || height) {\n        return true;\n      }\n    }\n    if (element.getBoundingClientRect) {\n      var _element$getBoundingC = element.getBoundingClientRect(),\n        _width = _element$getBoundingC.width,\n        _height = _element$getBoundingC.height;\n      if (_width || _height) {\n        return true;\n      }\n    }\n  }\n  return false;\n});","// export this package's api\nimport Align from \"./Align\";\nexport default Align;","import _typeof from \"./typeof.js\";\nfunction _regeneratorRuntime() {\n  \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */\n  _regeneratorRuntime = function _regeneratorRuntime() {\n    return e;\n  };\n  var t,\n    e = {},\n    r = Object.prototype,\n    n = r.hasOwnProperty,\n    o = Object.defineProperty || function (t, e, r) {\n      t[e] = r.value;\n    },\n    i = \"function\" == typeof Symbol ? Symbol : {},\n    a = i.iterator || \"@@iterator\",\n    c = i.asyncIterator || \"@@asyncIterator\",\n    u = i.toStringTag || \"@@toStringTag\";\n  function define(t, e, r) {\n    return Object.defineProperty(t, e, {\n      value: r,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }), t[e];\n  }\n  try {\n    define({}, \"\");\n  } catch (t) {\n    define = function define(t, e, r) {\n      return t[e] = r;\n    };\n  }\n  function wrap(t, e, r, n) {\n    var i = e && e.prototype instanceof Generator ? e : Generator,\n      a = Object.create(i.prototype),\n      c = new Context(n || []);\n    return o(a, \"_invoke\", {\n      value: makeInvokeMethod(t, r, c)\n    }), a;\n  }\n  function tryCatch(t, e, r) {\n    try {\n      return {\n        type: \"normal\",\n        arg: t.call(e, r)\n      };\n    } catch (t) {\n      return {\n        type: \"throw\",\n        arg: t\n      };\n    }\n  }\n  e.wrap = wrap;\n  var h = \"suspendedStart\",\n    l = \"suspendedYield\",\n    f = \"executing\",\n    s = \"completed\",\n    y = {};\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n  var p = {};\n  define(p, a, function () {\n    return this;\n  });\n  var d = Object.getPrototypeOf,\n    v = d && d(d(values([])));\n  v && v !== r && n.call(v, a) && (p = v);\n  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);\n  function defineIteratorMethods(t) {\n    [\"next\", \"throw\", \"return\"].forEach(function (e) {\n      define(t, e, function (t) {\n        return this._invoke(e, t);\n      });\n    });\n  }\n  function AsyncIterator(t, e) {\n    function invoke(r, o, i, a) {\n      var c = tryCatch(t[r], t, o);\n      if (\"throw\" !== c.type) {\n        var u = c.arg,\n          h = u.value;\n        return h && \"object\" == _typeof(h) && n.call(h, \"__await\") ? e.resolve(h.__await).then(function (t) {\n          invoke(\"next\", t, i, a);\n        }, function (t) {\n          invoke(\"throw\", t, i, a);\n        }) : e.resolve(h).then(function (t) {\n          u.value = t, i(u);\n        }, function (t) {\n          return invoke(\"throw\", t, i, a);\n        });\n      }\n      a(c.arg);\n    }\n    var r;\n    o(this, \"_invoke\", {\n      value: function value(t, n) {\n        function callInvokeWithMethodAndArg() {\n          return new e(function (e, r) {\n            invoke(t, n, e, r);\n          });\n        }\n        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n      }\n    });\n  }\n  function makeInvokeMethod(e, r, n) {\n    var o = h;\n    return function (i, a) {\n      if (o === f) throw Error(\"Generator is already running\");\n      if (o === s) {\n        if (\"throw\" === i) throw a;\n        return {\n          value: t,\n          done: !0\n        };\n      }\n      for (n.method = i, n.arg = a;;) {\n        var c = n.delegate;\n        if (c) {\n          var u = maybeInvokeDelegate(c, n);\n          if (u) {\n            if (u === y) continue;\n            return u;\n          }\n        }\n        if (\"next\" === n.method) n.sent = n._sent = n.arg;else if (\"throw\" === n.method) {\n          if (o === h) throw o = s, n.arg;\n          n.dispatchException(n.arg);\n        } else \"return\" === n.method && n.abrupt(\"return\", n.arg);\n        o = f;\n        var p = tryCatch(e, r, n);\n        if (\"normal\" === p.type) {\n          if (o = n.done ? s : l, p.arg === y) continue;\n          return {\n            value: p.arg,\n            done: n.done\n          };\n        }\n        \"throw\" === p.type && (o = s, n.method = \"throw\", n.arg = p.arg);\n      }\n    };\n  }\n  function maybeInvokeDelegate(e, r) {\n    var n = r.method,\n      o = e.iterator[n];\n    if (o === t) return r.delegate = null, \"throw\" === n && e.iterator[\"return\"] && (r.method = \"return\", r.arg = t, maybeInvokeDelegate(e, r), \"throw\" === r.method) || \"return\" !== n && (r.method = \"throw\", r.arg = new TypeError(\"The iterator does not provide a '\" + n + \"' method\")), y;\n    var i = tryCatch(o, e.iterator, r.arg);\n    if (\"throw\" === i.type) return r.method = \"throw\", r.arg = i.arg, r.delegate = null, y;\n    var a = i.arg;\n    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, \"return\" !== r.method && (r.method = \"next\", r.arg = t), r.delegate = null, y) : a : (r.method = \"throw\", r.arg = new TypeError(\"iterator result is not an object\"), r.delegate = null, y);\n  }\n  function pushTryEntry(t) {\n    var e = {\n      tryLoc: t[0]\n    };\n    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);\n  }\n  function resetTryEntry(t) {\n    var e = t.completion || {};\n    e.type = \"normal\", delete e.arg, t.completion = e;\n  }\n  function Context(t) {\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }], t.forEach(pushTryEntry, this), this.reset(!0);\n  }\n  function values(e) {\n    if (e || \"\" === e) {\n      var r = e[a];\n      if (r) return r.call(e);\n      if (\"function\" == typeof e.next) return e;\n      if (!isNaN(e.length)) {\n        var o = -1,\n          i = function next() {\n            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;\n            return next.value = t, next.done = !0, next;\n          };\n        return i.next = i;\n      }\n    }\n    throw new TypeError(_typeof(e) + \" is not iterable\");\n  }\n  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, \"constructor\", {\n    value: GeneratorFunctionPrototype,\n    configurable: !0\n  }), o(GeneratorFunctionPrototype, \"constructor\", {\n    value: GeneratorFunction,\n    configurable: !0\n  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, \"GeneratorFunction\"), e.isGeneratorFunction = function (t) {\n    var e = \"function\" == typeof t && t.constructor;\n    return !!e && (e === GeneratorFunction || \"GeneratorFunction\" === (e.displayName || e.name));\n  }, e.mark = function (t) {\n    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, \"GeneratorFunction\")), t.prototype = Object.create(g), t;\n  }, e.awrap = function (t) {\n    return {\n      __await: t\n    };\n  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {\n    return this;\n  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {\n    void 0 === i && (i = Promise);\n    var a = new AsyncIterator(wrap(t, r, n, o), i);\n    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {\n      return t.done ? t.value : a.next();\n    });\n  }, defineIteratorMethods(g), define(g, u, \"Generator\"), define(g, a, function () {\n    return this;\n  }), define(g, \"toString\", function () {\n    return \"[object Generator]\";\n  }), e.keys = function (t) {\n    var e = Object(t),\n      r = [];\n    for (var n in e) r.push(n);\n    return r.reverse(), function next() {\n      for (; r.length;) {\n        var t = r.pop();\n        if (t in e) return next.value = t, next.done = !1, next;\n      }\n      return next.done = !0, next;\n    };\n  }, e.values = values, Context.prototype = {\n    constructor: Context,\n    reset: function reset(e) {\n      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) \"t\" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);\n    },\n    stop: function stop() {\n      this.done = !0;\n      var t = this.tryEntries[0].completion;\n      if (\"throw\" === t.type) throw t.arg;\n      return this.rval;\n    },\n    dispatchException: function dispatchException(e) {\n      if (this.done) throw e;\n      var r = this;\n      function handle(n, o) {\n        return a.type = \"throw\", a.arg = e, r.next = n, o && (r.method = \"next\", r.arg = t), !!o;\n      }\n      for (var o = this.tryEntries.length - 1; o >= 0; --o) {\n        var i = this.tryEntries[o],\n          a = i.completion;\n        if (\"root\" === i.tryLoc) return handle(\"end\");\n        if (i.tryLoc <= this.prev) {\n          var c = n.call(i, \"catchLoc\"),\n            u = n.call(i, \"finallyLoc\");\n          if (c && u) {\n            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);\n            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);\n          } else if (c) {\n            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);\n          } else {\n            if (!u) throw Error(\"try statement without catch or finally\");\n            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);\n          }\n        }\n      }\n    },\n    abrupt: function abrupt(t, e) {\n      for (var r = this.tryEntries.length - 1; r >= 0; --r) {\n        var o = this.tryEntries[r];\n        if (o.tryLoc <= this.prev && n.call(o, \"finallyLoc\") && this.prev < o.finallyLoc) {\n          var i = o;\n          break;\n        }\n      }\n      i && (\"break\" === t || \"continue\" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);\n      var a = i ? i.completion : {};\n      return a.type = t, a.arg = e, i ? (this.method = \"next\", this.next = i.finallyLoc, y) : this.complete(a);\n    },\n    complete: function complete(t, e) {\n      if (\"throw\" === t.type) throw t.arg;\n      return \"break\" === t.type || \"continue\" === t.type ? this.next = t.arg : \"return\" === t.type ? (this.rval = this.arg = t.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === t.type && e && (this.next = e), y;\n    },\n    finish: function finish(t) {\n      for (var e = this.tryEntries.length - 1; e >= 0; --e) {\n        var r = this.tryEntries[e];\n        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;\n      }\n    },\n    \"catch\": function _catch(t) {\n      for (var e = this.tryEntries.length - 1; e >= 0; --e) {\n        var r = this.tryEntries[e];\n        if (r.tryLoc === t) {\n          var n = r.completion;\n          if (\"throw\" === n.type) {\n            var o = n.arg;\n            resetTryEntry(r);\n          }\n          return o;\n        }\n      }\n      throw Error(\"illegal catch attempt\");\n    },\n    delegateYield: function delegateYield(e, r, n) {\n      return this.delegate = {\n        iterator: values(e),\n        resultName: r,\n        nextLoc: n\n      }, \"next\" === this.method && (this.arg = t), y;\n    }\n  }, e;\n}\nexport { _regeneratorRuntime as default };","function asyncGeneratorStep(n, t, e, r, o, a, c) {\n  try {\n    var i = n[a](c),\n      u = i.value;\n  } catch (n) {\n    return void e(n);\n  }\n  i.done ? t(u) : Promise.resolve(u).then(r, o);\n}\nfunction _asyncToGenerator(n) {\n  return function () {\n    var t = this,\n      e = arguments;\n    return new Promise(function (r, o) {\n      var a = n.apply(t, e);\n      function _next(n) {\n        asyncGeneratorStep(a, r, o, _next, _throw, \"next\", n);\n      }\n      function _throw(n) {\n        asyncGeneratorStep(a, r, o, _next, _throw, \"throw\", n);\n      }\n      _next(void 0);\n    });\n  };\n}\nexport { _asyncToGenerator as default };","import _regeneratorRuntime from \"@babel/runtime/helpers/esm/regeneratorRuntime\";\nimport _asyncToGenerator from \"@babel/runtime/helpers/esm/asyncToGenerator\";\nimport _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport { useEffect, useRef } from 'react';\nimport raf from \"rc-util/es/raf\";\nimport useState from \"rc-util/es/hooks/useState\";\n/**\n * Popup should follow the steps for each component work correctly:\n * measure - check for the current stretch size\n * align - let component align the position\n * aligned - re-align again in case additional className changed the size\n * afterAlign - choice next step is trigger motion or finished\n * beforeMotion - should reset motion to invisible so that CSSMotion can do normal motion\n * motion - play the motion\n * stable - everything is done\n */\n\nvar StatusQueue = ['measure', 'alignPre', 'align', null, 'motion'];\nexport default (function (visible, doMeasure) {\n  var _useState = useState(null),\n      _useState2 = _slicedToArray(_useState, 2),\n      status = _useState2[0],\n      setInternalStatus = _useState2[1];\n\n  var rafRef = useRef();\n\n  function setStatus(nextStatus) {\n    setInternalStatus(nextStatus, true);\n  }\n\n  function cancelRaf() {\n    raf.cancel(rafRef.current);\n  }\n\n  function goNextStatus(callback) {\n    cancelRaf();\n    rafRef.current = raf(function () {\n      // Only align should be manually trigger\n      setStatus(function (prev) {\n        switch (status) {\n          case 'align':\n            return 'motion';\n\n          case 'motion':\n            return 'stable';\n\n          default:\n        }\n\n        return prev;\n      });\n      callback === null || callback === void 0 ? void 0 : callback();\n    });\n  } // Init status\n\n\n  useEffect(function () {\n    setStatus('measure');\n  }, [visible]); // Go next status\n\n  useEffect(function () {\n    switch (status) {\n      case 'measure':\n        doMeasure();\n        break;\n\n      default:\n    }\n\n    if (status) {\n      rafRef.current = raf( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {\n        var index, nextStatus;\n        return _regeneratorRuntime().wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                index = StatusQueue.indexOf(status);\n                nextStatus = StatusQueue[index + 1];\n\n                if (nextStatus && index !== -1) {\n                  setStatus(nextStatus);\n                }\n\n              case 3:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee);\n      })));\n    }\n  }, [status]);\n  useEffect(function () {\n    return function () {\n      cancelRaf();\n    };\n  }, []);\n  return [status, goNextStatus];\n});","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport * as React from 'react';\nimport { useRef, useState } from 'react';\nimport Align from 'rc-align';\nimport useLayoutEffect from \"rc-util/es/hooks/useLayoutEffect\";\nimport CSSMotion from 'rc-motion';\nimport classNames from 'classnames';\nimport useVisibleStatus from \"./useVisibleStatus\";\nimport { getMotion } from \"../utils/legacyUtil\";\nimport useStretchStyle from \"./useStretchStyle\";\nvar PopupInner = /*#__PURE__*/React.forwardRef(function (props, ref) {\n  var visible = props.visible,\n      prefixCls = props.prefixCls,\n      className = props.className,\n      style = props.style,\n      children = props.children,\n      zIndex = props.zIndex,\n      stretch = props.stretch,\n      destroyPopupOnHide = props.destroyPopupOnHide,\n      forceRender = props.forceRender,\n      align = props.align,\n      point = props.point,\n      getRootDomNode = props.getRootDomNode,\n      getClassNameFromAlign = props.getClassNameFromAlign,\n      onAlign = props.onAlign,\n      onMouseEnter = props.onMouseEnter,\n      onMouseLeave = props.onMouseLeave,\n      onMouseDown = props.onMouseDown,\n      onTouchStart = props.onTouchStart,\n      onClick = props.onClick;\n  var alignRef = useRef();\n  var elementRef = useRef();\n\n  var _useState = useState(),\n      _useState2 = _slicedToArray(_useState, 2),\n      alignedClassName = _useState2[0],\n      setAlignedClassName = _useState2[1]; // ======================= Measure ========================\n\n\n  var _useStretchStyle = useStretchStyle(stretch),\n      _useStretchStyle2 = _slicedToArray(_useStretchStyle, 2),\n      stretchStyle = _useStretchStyle2[0],\n      measureStretchStyle = _useStretchStyle2[1];\n\n  function doMeasure() {\n    if (stretch) {\n      measureStretchStyle(getRootDomNode());\n    }\n  } // ======================== Status ========================\n\n\n  var _useVisibleStatus = useVisibleStatus(visible, doMeasure),\n      _useVisibleStatus2 = _slicedToArray(_useVisibleStatus, 2),\n      status = _useVisibleStatus2[0],\n      goNextStatus = _useVisibleStatus2[1]; // ======================== Aligns ========================\n\n  /**\n   * `alignedClassName` may modify `source` size,\n   * which means one time align may not move to the correct position at once.\n   *\n   * We will reset `alignTimes` for each status switch to `alignPre`\n   * and let `rc-align` to align for multiple times to ensure get final stable place.\n   * Currently we mark `alignTimes < 2` repeat align, it will increase if user report for align issue.\n   * \n   * Update:\n   * In React 18. `rc-align` effect of align may faster than ref called trigger `forceAlign`.\n   * We adjust this to `alignTimes < 2`.\n   * We need refactor `rc-align` to support mark of `forceAlign` call if this still happen.\n   */\n\n\n  var _useState3 = useState(0),\n      _useState4 = _slicedToArray(_useState3, 2),\n      alignTimes = _useState4[0],\n      setAlignTimes = _useState4[1];\n\n  var prepareResolveRef = useRef();\n  useLayoutEffect(function () {\n    if (status === 'alignPre') {\n      setAlignTimes(0);\n    }\n  }, [status]); // `target` on `rc-align` can accept as a function to get the bind element or a point.\n  // ref: https://www.npmjs.com/package/rc-align\n\n  function getAlignTarget() {\n    if (point) {\n      return point;\n    }\n\n    return getRootDomNode;\n  }\n\n  function forceAlign() {\n    var _alignRef$current;\n\n    (_alignRef$current = alignRef.current) === null || _alignRef$current === void 0 ? void 0 : _alignRef$current.forceAlign();\n  }\n\n  function onInternalAlign(popupDomNode, matchAlign) {\n    var nextAlignedClassName = getClassNameFromAlign(matchAlign);\n\n    if (alignedClassName !== nextAlignedClassName) {\n      setAlignedClassName(nextAlignedClassName);\n    } // We will retry multi times to make sure that the element has been align in the right position.\n\n\n    setAlignTimes(function (val) {\n      return val + 1;\n    });\n\n    if (status === 'align') {\n      onAlign === null || onAlign === void 0 ? void 0 : onAlign(popupDomNode, matchAlign);\n    }\n  } // Delay to go to next status\n\n\n  useLayoutEffect(function () {\n    if (status === 'align') {\n      // Repeat until not more align needed\n      if (alignTimes < 3) {\n        forceAlign();\n      } else {\n        goNextStatus(function () {\n          var _prepareResolveRef$cu;\n\n          (_prepareResolveRef$cu = prepareResolveRef.current) === null || _prepareResolveRef$cu === void 0 ? void 0 : _prepareResolveRef$cu.call(prepareResolveRef);\n        });\n      }\n    }\n  }, [alignTimes]); // ======================== Motion ========================\n\n  var motion = _objectSpread({}, getMotion(props));\n\n  ['onAppearEnd', 'onEnterEnd', 'onLeaveEnd'].forEach(function (eventName) {\n    var originHandler = motion[eventName];\n\n    motion[eventName] = function (element, event) {\n      goNextStatus();\n      return originHandler === null || originHandler === void 0 ? void 0 : originHandler(element, event);\n    };\n  });\n\n  function onShowPrepare() {\n    return new Promise(function (resolve) {\n      prepareResolveRef.current = resolve;\n    });\n  } // Go to stable directly when motion not provided\n\n\n  React.useEffect(function () {\n    if (!motion.motionName && status === 'motion') {\n      goNextStatus();\n    }\n  }, [motion.motionName, status]); // ========================= Refs =========================\n\n  React.useImperativeHandle(ref, function () {\n    return {\n      forceAlign: forceAlign,\n      getElement: function getElement() {\n        return elementRef.current;\n      }\n    };\n  }); // ======================== Render ========================\n\n  var mergedStyle = _objectSpread(_objectSpread({}, stretchStyle), {}, {\n    zIndex: zIndex,\n    opacity: status === 'motion' || status === 'stable' || !visible ? undefined : 0,\n    // Cannot interact with disappearing elements\n    // https://github.com/ant-design/ant-design/issues/35051#issuecomment-1101340714\n    pointerEvents: !visible && status !== 'stable' ? 'none' : undefined\n  }, style); // Align status\n\n\n  var alignDisabled = true;\n\n  if (align !== null && align !== void 0 && align.points && (status === 'align' || status === 'stable')) {\n    alignDisabled = false;\n  }\n\n  var childNode = children; // Wrapper when multiple children\n\n  if (React.Children.count(children) > 1) {\n    childNode = /*#__PURE__*/React.createElement(\"div\", {\n      className: \"\".concat(prefixCls, \"-content\")\n    }, children);\n  }\n\n  return /*#__PURE__*/React.createElement(CSSMotion, _extends({\n    visible: visible,\n    ref: elementRef,\n    leavedClassName: \"\".concat(prefixCls, \"-hidden\")\n  }, motion, {\n    onAppearPrepare: onShowPrepare,\n    onEnterPrepare: onShowPrepare,\n    removeOnLeave: destroyPopupOnHide,\n    forceRender: forceRender\n  }), function (_ref, motionRef) {\n    var motionClassName = _ref.className,\n        motionStyle = _ref.style;\n    var mergedClassName = classNames(prefixCls, className, alignedClassName, motionClassName);\n    return /*#__PURE__*/React.createElement(Align, {\n      target: getAlignTarget(),\n      key: \"popup\",\n      ref: alignRef,\n      monitorWindowResize: true,\n      disabled: alignDisabled,\n      align: align,\n      onAlign: onInternalAlign\n    }, /*#__PURE__*/React.createElement(\"div\", {\n      ref: motionRef,\n      className: mergedClassName,\n      onMouseEnter: onMouseEnter,\n      onMouseLeave: onMouseLeave,\n      onMouseDownCapture: onMouseDown,\n      onTouchStartCapture: onTouchStart,\n      onClick: onClick,\n      style: _objectSpread(_objectSpread({}, motionStyle), mergedStyle)\n    }, childNode));\n  });\n});\nPopupInner.displayName = 'PopupInner';\nexport default PopupInner;","import _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport * as React from 'react';\nexport default (function (stretch) {\n  var _React$useState = React.useState({\n    width: 0,\n    height: 0\n  }),\n      _React$useState2 = _slicedToArray(_React$useState, 2),\n      targetSize = _React$useState2[0],\n      setTargetSize = _React$useState2[1];\n\n  function measureStretch(element) {\n    var tgtWidth = element.offsetWidth,\n        tgtHeight = element.offsetHeight;\n\n    var _element$getBoundingC = element.getBoundingClientRect(),\n        width = _element$getBoundingC.width,\n        height = _element$getBoundingC.height; // Rect is more accurate than offset, use if near\n\n\n    if (Math.abs(tgtWidth - width) < 1 && Math.abs(tgtHeight - height) < 1) {\n      tgtWidth = width;\n      tgtHeight = height;\n    }\n\n    setTargetSize({\n      width: tgtWidth,\n      height: tgtHeight\n    });\n  } // Merge stretch style\n\n\n  var style = React.useMemo(function () {\n    var sizeStyle = {};\n\n    if (stretch) {\n      var width = targetSize.width,\n          height = targetSize.height; // Stretch with target\n\n      if (stretch.indexOf('height') !== -1 && height) {\n        sizeStyle.height = height;\n      } else if (stretch.indexOf('minHeight') !== -1 && height) {\n        sizeStyle.minHeight = height;\n      }\n\n      if (stretch.indexOf('width') !== -1 && width) {\n        sizeStyle.width = width;\n      } else if (stretch.indexOf('minWidth') !== -1 && width) {\n        sizeStyle.minWidth = width;\n      }\n    }\n\n    return sizeStyle;\n  }, [stretch, targetSize]);\n  return [style, measureStretch];\n});","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport * as React from 'react';\nimport CSSMotion from 'rc-motion';\nimport classNames from 'classnames';\nvar MobilePopupInner = /*#__PURE__*/React.forwardRef(function (props, ref) {\n  var prefixCls = props.prefixCls,\n      visible = props.visible,\n      zIndex = props.zIndex,\n      children = props.children,\n      _props$mobile = props.mobile;\n  _props$mobile = _props$mobile === void 0 ? {} : _props$mobile;\n  var popupClassName = _props$mobile.popupClassName,\n      popupStyle = _props$mobile.popupStyle,\n      _props$mobile$popupMo = _props$mobile.popupMotion,\n      popupMotion = _props$mobile$popupMo === void 0 ? {} : _props$mobile$popupMo,\n      popupRender = _props$mobile.popupRender,\n      onClick = props.onClick;\n  var elementRef = React.useRef(); // ========================= Refs =========================\n\n  React.useImperativeHandle(ref, function () {\n    return {\n      forceAlign: function forceAlign() {},\n      getElement: function getElement() {\n        return elementRef.current;\n      }\n    };\n  }); // ======================== Render ========================\n\n  var mergedStyle = _objectSpread({\n    zIndex: zIndex\n  }, popupStyle);\n\n  var childNode = children; // Wrapper when multiple children\n\n  if (React.Children.count(children) > 1) {\n    childNode = /*#__PURE__*/React.createElement(\"div\", {\n      className: \"\".concat(prefixCls, \"-content\")\n    }, children);\n  } // Mobile support additional render\n\n\n  if (popupRender) {\n    childNode = popupRender(childNode);\n  }\n\n  return /*#__PURE__*/React.createElement(CSSMotion, _extends({\n    visible: visible,\n    ref: elementRef,\n    removeOnLeave: true\n  }, popupMotion), function (_ref, motionRef) {\n    var motionClassName = _ref.className,\n        motionStyle = _ref.style;\n    var mergedClassName = classNames(prefixCls, popupClassName, motionClassName);\n    return /*#__PURE__*/React.createElement(\"div\", {\n      ref: motionRef,\n      className: mergedClassName,\n      onClick: onClick,\n      style: _objectSpread(_objectSpread({}, motionStyle), mergedStyle)\n    }, childNode);\n  });\n});\nMobilePopupInner.displayName = 'MobilePopupInner';\nexport default MobilePopupInner;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nvar _excluded = [\"visible\", \"mobile\"];\nimport * as React from 'react';\nimport { useState, useEffect } from 'react';\nimport isMobile from \"rc-util/es/isMobile\";\nimport Mask from \"./Mask\";\nimport PopupInner from \"./PopupInner\";\nimport MobilePopupInner from \"./MobilePopupInner\";\nvar Popup = /*#__PURE__*/React.forwardRef(function (_ref, ref) {\n  var visible = _ref.visible,\n      mobile = _ref.mobile,\n      props = _objectWithoutProperties(_ref, _excluded);\n\n  var _useState = useState(visible),\n      _useState2 = _slicedToArray(_useState, 2),\n      innerVisible = _useState2[0],\n      serInnerVisible = _useState2[1];\n\n  var _useState3 = useState(false),\n      _useState4 = _slicedToArray(_useState3, 2),\n      inMobile = _useState4[0],\n      setInMobile = _useState4[1];\n\n  var cloneProps = _objectSpread(_objectSpread({}, props), {}, {\n    visible: innerVisible\n  }); // We check mobile in visible changed here.\n  // And this also delay set `innerVisible` to avoid popup component render flash\n\n\n  useEffect(function () {\n    serInnerVisible(visible);\n\n    if (visible && mobile) {\n      setInMobile(isMobile());\n    }\n  }, [visible, mobile]);\n  var popupNode = inMobile ? /*#__PURE__*/React.createElement(MobilePopupInner, _extends({}, cloneProps, {\n    mobile: mobile,\n    ref: ref\n  })) : /*#__PURE__*/React.createElement(PopupInner, _extends({}, cloneProps, {\n    ref: ref\n  })); // We can use fragment directly but this may failed some selector usage. Keep as origin logic\n\n  return /*#__PURE__*/React.createElement(\"div\", null, /*#__PURE__*/React.createElement(Mask, cloneProps), popupNode);\n});\nPopup.displayName = 'Popup';\nexport default Popup;","import * as React from 'react';\nvar TriggerContext = /*#__PURE__*/React.createContext(null);\nexport default TriggerContext;","import _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _assertThisInitialized from \"@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _createSuper from \"@babel/runtime/helpers/esm/createSuper\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport * as React from 'react';\nimport ReactDOM from 'react-dom';\nimport raf from \"rc-util/es/raf\";\nimport contains from \"rc-util/es/Dom/contains\";\nimport findDOMNode from \"rc-util/es/Dom/findDOMNode\";\nimport { composeRef, supportRef } from \"rc-util/es/ref\";\nimport addEventListener from \"rc-util/es/Dom/addEventListener\";\nimport Portal from \"rc-util/es/Portal\";\nimport classNames from 'classnames';\nimport { getAlignFromPlacement, getAlignPopupClassName } from \"./utils/alignUtil\";\nimport Popup from \"./Popup\";\nimport TriggerContext from \"./context\";\n\nfunction noop() {}\n\nfunction returnEmptyString() {\n  return '';\n}\n\nfunction returnDocument(element) {\n  if (element) {\n    return element.ownerDocument;\n  }\n\n  return window.document;\n}\n\nvar ALL_HANDLERS = ['onClick', 'onMouseDown', 'onTouchStart', 'onMouseEnter', 'onMouseLeave', 'onFocus', 'onBlur', 'onContextMenu'];\n\n/**\n * Internal usage. Do not use in your code since this will be removed.\n */\nexport function generateTrigger(PortalComponent) {\n  var Trigger = /*#__PURE__*/function (_React$Component) {\n    _inherits(Trigger, _React$Component);\n\n    var _super = _createSuper(Trigger);\n\n    // ensure `getContainer` will be called only once\n    function Trigger(props) {\n      var _this;\n\n      _classCallCheck(this, Trigger);\n\n      _this = _super.call(this, props);\n\n      _defineProperty(_assertThisInitialized(_this), \"popupRef\", /*#__PURE__*/React.createRef());\n\n      _defineProperty(_assertThisInitialized(_this), \"triggerRef\", /*#__PURE__*/React.createRef());\n\n      _defineProperty(_assertThisInitialized(_this), \"portalContainer\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"attachId\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"clickOutsideHandler\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"touchOutsideHandler\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"contextMenuOutsideHandler1\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"contextMenuOutsideHandler2\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"mouseDownTimeout\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"focusTime\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"preClickTime\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"preTouchTime\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"delayTimer\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"hasPopupMouseDown\", void 0);\n\n      _defineProperty(_assertThisInitialized(_this), \"onMouseEnter\", function (e) {\n        var mouseEnterDelay = _this.props.mouseEnterDelay;\n\n        _this.fireEvents('onMouseEnter', e);\n\n        _this.delaySetPopupVisible(true, mouseEnterDelay, mouseEnterDelay ? null : e);\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onMouseMove\", function (e) {\n        _this.fireEvents('onMouseMove', e);\n\n        _this.setPoint(e);\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onMouseLeave\", function (e) {\n        _this.fireEvents('onMouseLeave', e);\n\n        _this.delaySetPopupVisible(false, _this.props.mouseLeaveDelay);\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onPopupMouseEnter\", function () {\n        _this.clearDelayTimer();\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onPopupMouseLeave\", function (e) {\n        var _this$popupRef$curren;\n\n        // https://github.com/react-component/trigger/pull/13\n        // react bug?\n        if (e.relatedTarget && !e.relatedTarget.setTimeout && contains((_this$popupRef$curren = _this.popupRef.current) === null || _this$popupRef$curren === void 0 ? void 0 : _this$popupRef$curren.getElement(), e.relatedTarget)) {\n          return;\n        }\n\n        _this.delaySetPopupVisible(false, _this.props.mouseLeaveDelay);\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onFocus\", function (e) {\n        _this.fireEvents('onFocus', e); // incase focusin and focusout\n\n\n        _this.clearDelayTimer();\n\n        if (_this.isFocusToShow()) {\n          _this.focusTime = Date.now();\n\n          _this.delaySetPopupVisible(true, _this.props.focusDelay);\n        }\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onMouseDown\", function (e) {\n        _this.fireEvents('onMouseDown', e);\n\n        _this.preClickTime = Date.now();\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onTouchStart\", function (e) {\n        _this.fireEvents('onTouchStart', e);\n\n        _this.preTouchTime = Date.now();\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onBlur\", function (e) {\n        _this.fireEvents('onBlur', e);\n\n        _this.clearDelayTimer();\n\n        if (_this.isBlurToHide()) {\n          _this.delaySetPopupVisible(false, _this.props.blurDelay);\n        }\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onContextMenu\", function (e) {\n        e.preventDefault();\n\n        _this.fireEvents('onContextMenu', e);\n\n        _this.setPopupVisible(true, e);\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onContextMenuClose\", function () {\n        if (_this.isContextMenuToShow()) {\n          _this.close();\n        }\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onClick\", function (event) {\n        _this.fireEvents('onClick', event); // focus will trigger click\n\n\n        if (_this.focusTime) {\n          var preTime;\n\n          if (_this.preClickTime && _this.preTouchTime) {\n            preTime = Math.min(_this.preClickTime, _this.preTouchTime);\n          } else if (_this.preClickTime) {\n            preTime = _this.preClickTime;\n          } else if (_this.preTouchTime) {\n            preTime = _this.preTouchTime;\n          }\n\n          if (Math.abs(preTime - _this.focusTime) < 20) {\n            return;\n          }\n\n          _this.focusTime = 0;\n        }\n\n        _this.preClickTime = 0;\n        _this.preTouchTime = 0; // Only prevent default when all the action is click.\n        // https://github.com/ant-design/ant-design/issues/17043\n        // https://github.com/ant-design/ant-design/issues/17291\n\n        if (_this.isClickToShow() && (_this.isClickToHide() || _this.isBlurToHide()) && event && event.preventDefault) {\n          event.preventDefault();\n        }\n\n        var nextVisible = !_this.state.popupVisible;\n\n        if (_this.isClickToHide() && !nextVisible || nextVisible && _this.isClickToShow()) {\n          _this.setPopupVisible(!_this.state.popupVisible, event);\n        }\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onPopupMouseDown\", function () {\n        _this.hasPopupMouseDown = true;\n        clearTimeout(_this.mouseDownTimeout);\n        _this.mouseDownTimeout = window.setTimeout(function () {\n          _this.hasPopupMouseDown = false;\n        }, 0);\n\n        if (_this.context) {\n          var _this$context;\n\n          (_this$context = _this.context).onPopupMouseDown.apply(_this$context, arguments);\n        }\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"onDocumentClick\", function (event) {\n        if (_this.props.mask && !_this.props.maskClosable) {\n          return;\n        }\n\n        var target = event.target;\n\n        var root = _this.getRootDomNode();\n\n        var popupNode = _this.getPopupDomNode();\n\n        if ( // mousedown on the target should also close popup when action is contextMenu.\n        // https://github.com/ant-design/ant-design/issues/29853\n        (!contains(root, target) || _this.isContextMenuOnly()) && !contains(popupNode, target) && !_this.hasPopupMouseDown) {\n          _this.close();\n        }\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"getRootDomNode\", function () {\n        var getTriggerDOMNode = _this.props.getTriggerDOMNode;\n\n        if (getTriggerDOMNode) {\n          return getTriggerDOMNode(_this.triggerRef.current);\n        }\n\n        try {\n          var domNode = findDOMNode(_this.triggerRef.current);\n\n          if (domNode) {\n            return domNode;\n          }\n        } catch (err) {// Do nothing\n        }\n\n        return ReactDOM.findDOMNode(_assertThisInitialized(_this));\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"getPopupClassNameFromAlign\", function (align) {\n        var className = [];\n        var _this$props = _this.props,\n            popupPlacement = _this$props.popupPlacement,\n            builtinPlacements = _this$props.builtinPlacements,\n            prefixCls = _this$props.prefixCls,\n            alignPoint = _this$props.alignPoint,\n            getPopupClassNameFromAlign = _this$props.getPopupClassNameFromAlign;\n\n        if (popupPlacement && builtinPlacements) {\n          className.push(getAlignPopupClassName(builtinPlacements, prefixCls, align, alignPoint));\n        }\n\n        if (getPopupClassNameFromAlign) {\n          className.push(getPopupClassNameFromAlign(align));\n        }\n\n        return className.join(' ');\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"getComponent\", function () {\n        var _this$props2 = _this.props,\n            prefixCls = _this$props2.prefixCls,\n            destroyPopupOnHide = _this$props2.destroyPopupOnHide,\n            popupClassName = _this$props2.popupClassName,\n            onPopupAlign = _this$props2.onPopupAlign,\n            popupMotion = _this$props2.popupMotion,\n            popupAnimation = _this$props2.popupAnimation,\n            popupTransitionName = _this$props2.popupTransitionName,\n            popupStyle = _this$props2.popupStyle,\n            mask = _this$props2.mask,\n            maskAnimation = _this$props2.maskAnimation,\n            maskTransitionName = _this$props2.maskTransitionName,\n            maskMotion = _this$props2.maskMotion,\n            zIndex = _this$props2.zIndex,\n            popup = _this$props2.popup,\n            stretch = _this$props2.stretch,\n            alignPoint = _this$props2.alignPoint,\n            mobile = _this$props2.mobile,\n            forceRender = _this$props2.forceRender,\n            onPopupClick = _this$props2.onPopupClick;\n        var _this$state = _this.state,\n            popupVisible = _this$state.popupVisible,\n            point = _this$state.point;\n\n        var align = _this.getPopupAlign();\n\n        var mouseProps = {};\n\n        if (_this.isMouseEnterToShow()) {\n          mouseProps.onMouseEnter = _this.onPopupMouseEnter;\n        }\n\n        if (_this.isMouseLeaveToHide()) {\n          mouseProps.onMouseLeave = _this.onPopupMouseLeave;\n        }\n\n        mouseProps.onMouseDown = _this.onPopupMouseDown;\n        mouseProps.onTouchStart = _this.onPopupMouseDown;\n        return /*#__PURE__*/React.createElement(Popup, _extends({\n          prefixCls: prefixCls,\n          destroyPopupOnHide: destroyPopupOnHide,\n          visible: popupVisible,\n          point: alignPoint && point,\n          className: popupClassName,\n          align: align,\n          onAlign: onPopupAlign,\n          animation: popupAnimation,\n          getClassNameFromAlign: _this.getPopupClassNameFromAlign\n        }, mouseProps, {\n          stretch: stretch,\n          getRootDomNode: _this.getRootDomNode,\n          style: popupStyle,\n          mask: mask,\n          zIndex: zIndex,\n          transitionName: popupTransitionName,\n          maskAnimation: maskAnimation,\n          maskTransitionName: maskTransitionName,\n          maskMotion: maskMotion,\n          ref: _this.popupRef,\n          motion: popupMotion,\n          mobile: mobile,\n          forceRender: forceRender,\n          onClick: onPopupClick\n        }), typeof popup === 'function' ? popup() : popup);\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"attachParent\", function (popupContainer) {\n        raf.cancel(_this.attachId);\n        var _this$props3 = _this.props,\n            getPopupContainer = _this$props3.getPopupContainer,\n            getDocument = _this$props3.getDocument;\n\n        var domNode = _this.getRootDomNode();\n\n        var mountNode;\n\n        if (!getPopupContainer) {\n          mountNode = getDocument(_this.getRootDomNode()).body;\n        } else if (domNode || getPopupContainer.length === 0) {\n          // Compatible for legacy getPopupContainer with domNode argument.\n          // If no need `domNode` argument, will call directly.\n          // https://codesandbox.io/s/eloquent-mclean-ss93m?file=/src/App.js\n          mountNode = getPopupContainer(domNode);\n        }\n\n        if (mountNode) {\n          mountNode.appendChild(popupContainer);\n        } else {\n          // Retry after frame render in case parent not ready\n          _this.attachId = raf(function () {\n            _this.attachParent(popupContainer);\n          });\n        }\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"getContainer\", function () {\n        if (!_this.portalContainer) {\n          // In React.StrictMode component will call render multiple time in first mount.\n          // When you want to refactor with FC, useRef will also init multiple time and\n          // point to different useRef instance which will create multiple element\n          // (This multiple render will not trigger effect so you can not clean up this\n          // in effect). But this is safe with class component since it always point to same class instance.\n          var getDocument = _this.props.getDocument;\n          var popupContainer = getDocument(_this.getRootDomNode()).createElement('div'); // Make sure default popup container will never cause scrollbar appearing\n          // https://github.com/react-component/trigger/issues/41\n\n          popupContainer.style.position = 'absolute';\n          popupContainer.style.top = '0';\n          popupContainer.style.left = '0';\n          popupContainer.style.width = '100%';\n          _this.portalContainer = popupContainer;\n        }\n\n        _this.attachParent(_this.portalContainer);\n\n        return _this.portalContainer;\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"setPoint\", function (point) {\n        var alignPoint = _this.props.alignPoint;\n        if (!alignPoint || !point) return;\n\n        _this.setState({\n          point: {\n            pageX: point.pageX,\n            pageY: point.pageY\n          }\n        });\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"handlePortalUpdate\", function () {\n        if (_this.state.prevPopupVisible !== _this.state.popupVisible) {\n          _this.props.afterPopupVisibleChange(_this.state.popupVisible);\n        }\n      });\n\n      _defineProperty(_assertThisInitialized(_this), \"triggerContextValue\", {\n        onPopupMouseDown: _this.onPopupMouseDown\n      });\n\n      var _popupVisible;\n\n      if ('popupVisible' in props) {\n        _popupVisible = !!props.popupVisible;\n      } else {\n        _popupVisible = !!props.defaultPopupVisible;\n      }\n\n      _this.state = {\n        prevPopupVisible: _popupVisible,\n        popupVisible: _popupVisible\n      };\n      ALL_HANDLERS.forEach(function (h) {\n        _this[\"fire\".concat(h)] = function (e) {\n          _this.fireEvents(h, e);\n        };\n      });\n      return _this;\n    }\n\n    _createClass(Trigger, [{\n      key: \"componentDidMount\",\n      value: function componentDidMount() {\n        this.componentDidUpdate();\n      }\n    }, {\n      key: \"componentDidUpdate\",\n      value: function componentDidUpdate() {\n        var props = this.props;\n        var state = this.state; // We must listen to `mousedown` or `touchstart`, edge case:\n        // https://github.com/ant-design/ant-design/issues/5804\n        // https://github.com/react-component/calendar/issues/250\n        // https://github.com/react-component/trigger/issues/50\n\n        if (state.popupVisible) {\n          var currentDocument;\n\n          if (!this.clickOutsideHandler && (this.isClickToHide() || this.isContextMenuToShow())) {\n            currentDocument = props.getDocument(this.getRootDomNode());\n            this.clickOutsideHandler = addEventListener(currentDocument, 'mousedown', this.onDocumentClick);\n          } // always hide on mobile\n\n\n          if (!this.touchOutsideHandler) {\n            currentDocument = currentDocument || props.getDocument(this.getRootDomNode());\n            this.touchOutsideHandler = addEventListener(currentDocument, 'touchstart', this.onDocumentClick);\n          } // close popup when trigger type contains 'onContextMenu' and document is scrolling.\n\n\n          if (!this.contextMenuOutsideHandler1 && this.isContextMenuToShow()) {\n            currentDocument = currentDocument || props.getDocument(this.getRootDomNode());\n            this.contextMenuOutsideHandler1 = addEventListener(currentDocument, 'scroll', this.onContextMenuClose);\n          } // close popup when trigger type contains 'onContextMenu' and window is blur.\n\n\n          if (!this.contextMenuOutsideHandler2 && this.isContextMenuToShow()) {\n            this.contextMenuOutsideHandler2 = addEventListener(window, 'blur', this.onContextMenuClose);\n          }\n\n          return;\n        }\n\n        this.clearOutsideHandler();\n      }\n    }, {\n      key: \"componentWillUnmount\",\n      value: function componentWillUnmount() {\n        this.clearDelayTimer();\n        this.clearOutsideHandler();\n        clearTimeout(this.mouseDownTimeout);\n        raf.cancel(this.attachId);\n      }\n    }, {\n      key: \"getPopupDomNode\",\n      value: function getPopupDomNode() {\n        var _this$popupRef$curren2;\n\n        // for test\n        return ((_this$popupRef$curren2 = this.popupRef.current) === null || _this$popupRef$curren2 === void 0 ? void 0 : _this$popupRef$curren2.getElement()) || null;\n      }\n    }, {\n      key: \"getPopupAlign\",\n      value: function getPopupAlign() {\n        var props = this.props;\n        var popupPlacement = props.popupPlacement,\n            popupAlign = props.popupAlign,\n            builtinPlacements = props.builtinPlacements;\n\n        if (popupPlacement && builtinPlacements) {\n          return getAlignFromPlacement(builtinPlacements, popupPlacement, popupAlign);\n        }\n\n        return popupAlign;\n      }\n    }, {\n      key: \"setPopupVisible\",\n      value:\n      /**\n       * @param popupVisible    Show or not the popup element\n       * @param event           SyntheticEvent, used for `pointAlign`\n       */\n      function setPopupVisible(popupVisible, event) {\n        var alignPoint = this.props.alignPoint;\n        var prevPopupVisible = this.state.popupVisible;\n        this.clearDelayTimer();\n\n        if (prevPopupVisible !== popupVisible) {\n          if (!('popupVisible' in this.props)) {\n            this.setState({\n              popupVisible: popupVisible,\n              prevPopupVisible: prevPopupVisible\n            });\n          }\n\n          this.props.onPopupVisibleChange(popupVisible);\n        } // Always record the point position since mouseEnterDelay will delay the show\n\n\n        if (alignPoint && event && popupVisible) {\n          this.setPoint(event);\n        }\n      }\n    }, {\n      key: \"delaySetPopupVisible\",\n      value: function delaySetPopupVisible(visible, delayS, event) {\n        var _this2 = this;\n\n        var delay = delayS * 1000;\n        this.clearDelayTimer();\n\n        if (delay) {\n          var point = event ? {\n            pageX: event.pageX,\n            pageY: event.pageY\n          } : null;\n          this.delayTimer = window.setTimeout(function () {\n            _this2.setPopupVisible(visible, point);\n\n            _this2.clearDelayTimer();\n          }, delay);\n        } else {\n          this.setPopupVisible(visible, event);\n        }\n      }\n    }, {\n      key: \"clearDelayTimer\",\n      value: function clearDelayTimer() {\n        if (this.delayTimer) {\n          clearTimeout(this.delayTimer);\n          this.delayTimer = null;\n        }\n      }\n    }, {\n      key: \"clearOutsideHandler\",\n      value: function clearOutsideHandler() {\n        if (this.clickOutsideHandler) {\n          this.clickOutsideHandler.remove();\n          this.clickOutsideHandler = null;\n        }\n\n        if (this.contextMenuOutsideHandler1) {\n          this.contextMenuOutsideHandler1.remove();\n          this.contextMenuOutsideHandler1 = null;\n        }\n\n        if (this.contextMenuOutsideHandler2) {\n          this.contextMenuOutsideHandler2.remove();\n          this.contextMenuOutsideHandler2 = null;\n        }\n\n        if (this.touchOutsideHandler) {\n          this.touchOutsideHandler.remove();\n          this.touchOutsideHandler = null;\n        }\n      }\n    }, {\n      key: \"createTwoChains\",\n      value: function createTwoChains(event) {\n        var childPros = this.props.children.props;\n        var props = this.props;\n\n        if (childPros[event] && props[event]) {\n          return this[\"fire\".concat(event)];\n        }\n\n        return childPros[event] || props[event];\n      }\n    }, {\n      key: \"isClickToShow\",\n      value: function isClickToShow() {\n        var _this$props4 = this.props,\n            action = _this$props4.action,\n            showAction = _this$props4.showAction;\n        return action.indexOf('click') !== -1 || showAction.indexOf('click') !== -1;\n      }\n    }, {\n      key: \"isContextMenuOnly\",\n      value: function isContextMenuOnly() {\n        var action = this.props.action;\n        return action === 'contextMenu' || action.length === 1 && action[0] === 'contextMenu';\n      }\n    }, {\n      key: \"isContextMenuToShow\",\n      value: function isContextMenuToShow() {\n        var _this$props5 = this.props,\n            action = _this$props5.action,\n            showAction = _this$props5.showAction;\n        return action.indexOf('contextMenu') !== -1 || showAction.indexOf('contextMenu') !== -1;\n      }\n    }, {\n      key: \"isClickToHide\",\n      value: function isClickToHide() {\n        var _this$props6 = this.props,\n            action = _this$props6.action,\n            hideAction = _this$props6.hideAction;\n        return action.indexOf('click') !== -1 || hideAction.indexOf('click') !== -1;\n      }\n    }, {\n      key: \"isMouseEnterToShow\",\n      value: function isMouseEnterToShow() {\n        var _this$props7 = this.props,\n            action = _this$props7.action,\n            showAction = _this$props7.showAction;\n        return action.indexOf('hover') !== -1 || showAction.indexOf('mouseEnter') !== -1;\n      }\n    }, {\n      key: \"isMouseLeaveToHide\",\n      value: function isMouseLeaveToHide() {\n        var _this$props8 = this.props,\n            action = _this$props8.action,\n            hideAction = _this$props8.hideAction;\n        return action.indexOf('hover') !== -1 || hideAction.indexOf('mouseLeave') !== -1;\n      }\n    }, {\n      key: \"isFocusToShow\",\n      value: function isFocusToShow() {\n        var _this$props9 = this.props,\n            action = _this$props9.action,\n            showAction = _this$props9.showAction;\n        return action.indexOf('focus') !== -1 || showAction.indexOf('focus') !== -1;\n      }\n    }, {\n      key: \"isBlurToHide\",\n      value: function isBlurToHide() {\n        var _this$props10 = this.props,\n            action = _this$props10.action,\n            hideAction = _this$props10.hideAction;\n        return action.indexOf('focus') !== -1 || hideAction.indexOf('blur') !== -1;\n      }\n    }, {\n      key: \"forcePopupAlign\",\n      value: function forcePopupAlign() {\n        if (this.state.popupVisible) {\n          var _this$popupRef$curren3;\n\n          (_this$popupRef$curren3 = this.popupRef.current) === null || _this$popupRef$curren3 === void 0 ? void 0 : _this$popupRef$curren3.forceAlign();\n        }\n      }\n    }, {\n      key: \"fireEvents\",\n      value: function fireEvents(type, e) {\n        var childCallback = this.props.children.props[type];\n\n        if (childCallback) {\n          childCallback(e);\n        }\n\n        var callback = this.props[type];\n\n        if (callback) {\n          callback(e);\n        }\n      }\n    }, {\n      key: \"close\",\n      value: function close() {\n        this.setPopupVisible(false);\n      }\n    }, {\n      key: \"render\",\n      value: function render() {\n        var popupVisible = this.state.popupVisible;\n        var _this$props11 = this.props,\n            children = _this$props11.children,\n            forceRender = _this$props11.forceRender,\n            alignPoint = _this$props11.alignPoint,\n            className = _this$props11.className,\n            autoDestroy = _this$props11.autoDestroy;\n        var child = React.Children.only(children);\n        var newChildProps = {\n          key: 'trigger'\n        }; // ============================== Visible Handlers ==============================\n        // >>> ContextMenu\n\n        if (this.isContextMenuToShow()) {\n          newChildProps.onContextMenu = this.onContextMenu;\n        } else {\n          newChildProps.onContextMenu = this.createTwoChains('onContextMenu');\n        } // >>> Click\n\n\n        if (this.isClickToHide() || this.isClickToShow()) {\n          newChildProps.onClick = this.onClick;\n          newChildProps.onMouseDown = this.onMouseDown;\n          newChildProps.onTouchStart = this.onTouchStart;\n        } else {\n          newChildProps.onClick = this.createTwoChains('onClick');\n          newChildProps.onMouseDown = this.createTwoChains('onMouseDown');\n          newChildProps.onTouchStart = this.createTwoChains('onTouchStart');\n        } // >>> Hover(enter)\n\n\n        if (this.isMouseEnterToShow()) {\n          newChildProps.onMouseEnter = this.onMouseEnter; // Point align\n\n          if (alignPoint) {\n            newChildProps.onMouseMove = this.onMouseMove;\n          }\n        } else {\n          newChildProps.onMouseEnter = this.createTwoChains('onMouseEnter');\n        } // >>> Hover(leave)\n\n\n        if (this.isMouseLeaveToHide()) {\n          newChildProps.onMouseLeave = this.onMouseLeave;\n        } else {\n          newChildProps.onMouseLeave = this.createTwoChains('onMouseLeave');\n        } // >>> Focus\n\n\n        if (this.isFocusToShow() || this.isBlurToHide()) {\n          newChildProps.onFocus = this.onFocus;\n          newChildProps.onBlur = this.onBlur;\n        } else {\n          newChildProps.onFocus = this.createTwoChains('onFocus');\n          newChildProps.onBlur = this.createTwoChains('onBlur');\n        } // =================================== Render ===================================\n\n\n        var childrenClassName = classNames(child && child.props && child.props.className, className);\n\n        if (childrenClassName) {\n          newChildProps.className = childrenClassName;\n        }\n\n        var cloneProps = _objectSpread({}, newChildProps);\n\n        if (supportRef(child)) {\n          cloneProps.ref = composeRef(this.triggerRef, child.ref);\n        }\n\n        var trigger = /*#__PURE__*/React.cloneElement(child, cloneProps);\n        var portal; // prevent unmounting after it's rendered\n\n        if (popupVisible || this.popupRef.current || forceRender) {\n          portal = /*#__PURE__*/React.createElement(PortalComponent, {\n            key: \"portal\",\n            getContainer: this.getContainer,\n            didUpdate: this.handlePortalUpdate\n          }, this.getComponent());\n        }\n\n        if (!popupVisible && autoDestroy) {\n          portal = null;\n        }\n\n        return /*#__PURE__*/React.createElement(TriggerContext.Provider, {\n          value: this.triggerContextValue\n        }, trigger, portal);\n      }\n    }], [{\n      key: \"getDerivedStateFromProps\",\n      value: function getDerivedStateFromProps(_ref, prevState) {\n        var popupVisible = _ref.popupVisible;\n        var newState = {};\n\n        if (popupVisible !== undefined && prevState.popupVisible !== popupVisible) {\n          newState.popupVisible = popupVisible;\n          newState.prevPopupVisible = prevState.popupVisible;\n        }\n\n        return newState;\n      }\n    }]);\n\n    return Trigger;\n  }(React.Component);\n\n  _defineProperty(Trigger, \"contextType\", TriggerContext);\n\n  _defineProperty(Trigger, \"defaultProps\", {\n    prefixCls: 'rc-trigger-popup',\n    getPopupClassNameFromAlign: returnEmptyString,\n    getDocument: returnDocument,\n    onPopupVisibleChange: noop,\n    afterPopupVisibleChange: noop,\n    onPopupAlign: noop,\n    popupClassName: '',\n    mouseEnterDelay: 0,\n    mouseLeaveDelay: 0.1,\n    focusDelay: 0,\n    blurDelay: 0.15,\n    popupStyle: {},\n    destroyPopupOnHide: false,\n    popupAlign: {},\n    defaultPopupVisible: false,\n    mask: false,\n    maskClosable: true,\n    action: [],\n    showAction: [],\n    hideAction: [],\n    autoDestroy: false\n  });\n\n  return Trigger;\n}\nexport default generateTrigger(Portal);","var autoAdjustOverflow = {\n  adjustX: 1,\n  adjustY: 1\n};\nvar targetOffset = [0, 0];\nexport var placements = {\n  left: {\n    points: ['cr', 'cl'],\n    overflow: autoAdjustOverflow,\n    offset: [-4, 0],\n    targetOffset: targetOffset\n  },\n  right: {\n    points: ['cl', 'cr'],\n    overflow: autoAdjustOverflow,\n    offset: [4, 0],\n    targetOffset: targetOffset\n  },\n  top: {\n    points: ['bc', 'tc'],\n    overflow: autoAdjustOverflow,\n    offset: [0, -4],\n    targetOffset: targetOffset\n  },\n  bottom: {\n    points: ['tc', 'bc'],\n    overflow: autoAdjustOverflow,\n    offset: [0, 4],\n    targetOffset: targetOffset\n  },\n  topLeft: {\n    points: ['bl', 'tl'],\n    overflow: autoAdjustOverflow,\n    offset: [0, -4],\n    targetOffset: targetOffset\n  },\n  leftTop: {\n    points: ['tr', 'tl'],\n    overflow: autoAdjustOverflow,\n    offset: [-4, 0],\n    targetOffset: targetOffset\n  },\n  topRight: {\n    points: ['br', 'tr'],\n    overflow: autoAdjustOverflow,\n    offset: [0, -4],\n    targetOffset: targetOffset\n  },\n  rightTop: {\n    points: ['tl', 'tr'],\n    overflow: autoAdjustOverflow,\n    offset: [4, 0],\n    targetOffset: targetOffset\n  },\n  bottomRight: {\n    points: ['tr', 'br'],\n    overflow: autoAdjustOverflow,\n    offset: [0, 4],\n    targetOffset: targetOffset\n  },\n  rightBottom: {\n    points: ['bl', 'br'],\n    overflow: autoAdjustOverflow,\n    offset: [4, 0],\n    targetOffset: targetOffset\n  },\n  bottomLeft: {\n    points: ['tl', 'bl'],\n    overflow: autoAdjustOverflow,\n    offset: [0, 4],\n    targetOffset: targetOffset\n  },\n  leftBottom: {\n    points: ['br', 'bl'],\n    overflow: autoAdjustOverflow,\n    offset: [-4, 0],\n    targetOffset: targetOffset\n  }\n};\nexport default placements;","import * as React from 'react';\nimport classNames from 'classnames';\nexport default function Popup(props) {\n  var showArrow = props.showArrow,\n    arrowContent = props.arrowContent,\n    children = props.children,\n    prefixCls = props.prefixCls,\n    id = props.id,\n    overlayInnerStyle = props.overlayInnerStyle,\n    className = props.className,\n    style = props.style;\n  return /*#__PURE__*/React.createElement(\"div\", {\n    className: classNames(\"\".concat(prefixCls, \"-content\"), className),\n    style: style\n  }, showArrow !== false && /*#__PURE__*/React.createElement(\"div\", {\n    className: \"\".concat(prefixCls, \"-arrow\"),\n    key: \"arrow\"\n  }, arrowContent), /*#__PURE__*/React.createElement(\"div\", {\n    className: \"\".concat(prefixCls, \"-inner\"),\n    id: id,\n    role: \"tooltip\",\n    style: overlayInnerStyle\n  }, typeof children === 'function' ? children() : children));\n}","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _typeof from \"@babel/runtime/helpers/esm/typeof\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nvar _excluded = [\"overlayClassName\", \"trigger\", \"mouseEnterDelay\", \"mouseLeaveDelay\", \"overlayStyle\", \"prefixCls\", \"children\", \"onVisibleChange\", \"afterVisibleChange\", \"transitionName\", \"animation\", \"motion\", \"placement\", \"align\", \"destroyTooltipOnHide\", \"defaultVisible\", \"getTooltipContainer\", \"overlayInnerStyle\", \"arrowContent\", \"overlay\", \"id\", \"showArrow\"];\nimport * as React from 'react';\nimport { useRef, useImperativeHandle, forwardRef } from 'react';\nimport Trigger from 'rc-trigger';\nimport { placements } from './placements';\nimport Popup from './Popup';\nvar Tooltip = function Tooltip(props, ref) {\n  var overlayClassName = props.overlayClassName,\n    _props$trigger = props.trigger,\n    trigger = _props$trigger === void 0 ? ['hover'] : _props$trigger,\n    _props$mouseEnterDela = props.mouseEnterDelay,\n    mouseEnterDelay = _props$mouseEnterDela === void 0 ? 0 : _props$mouseEnterDela,\n    _props$mouseLeaveDela = props.mouseLeaveDelay,\n    mouseLeaveDelay = _props$mouseLeaveDela === void 0 ? 0.1 : _props$mouseLeaveDela,\n    overlayStyle = props.overlayStyle,\n    _props$prefixCls = props.prefixCls,\n    prefixCls = _props$prefixCls === void 0 ? 'rc-tooltip' : _props$prefixCls,\n    children = props.children,\n    onVisibleChange = props.onVisibleChange,\n    afterVisibleChange = props.afterVisibleChange,\n    transitionName = props.transitionName,\n    animation = props.animation,\n    motion = props.motion,\n    _props$placement = props.placement,\n    placement = _props$placement === void 0 ? 'right' : _props$placement,\n    _props$align = props.align,\n    align = _props$align === void 0 ? {} : _props$align,\n    _props$destroyTooltip = props.destroyTooltipOnHide,\n    destroyTooltipOnHide = _props$destroyTooltip === void 0 ? false : _props$destroyTooltip,\n    defaultVisible = props.defaultVisible,\n    getTooltipContainer = props.getTooltipContainer,\n    overlayInnerStyle = props.overlayInnerStyle,\n    arrowContent = props.arrowContent,\n    overlay = props.overlay,\n    id = props.id,\n    _props$showArrow = props.showArrow,\n    showArrow = _props$showArrow === void 0 ? true : _props$showArrow,\n    restProps = _objectWithoutProperties(props, _excluded);\n  var domRef = useRef(null);\n  useImperativeHandle(ref, function () {\n    return domRef.current;\n  });\n  var extraProps = _objectSpread({}, restProps);\n  if ('visible' in props) {\n    extraProps.popupVisible = props.visible;\n  }\n  var getPopupElement = function getPopupElement() {\n    return /*#__PURE__*/React.createElement(Popup, {\n      showArrow: showArrow,\n      arrowContent: arrowContent,\n      key: \"content\",\n      prefixCls: prefixCls,\n      id: id,\n      overlayInnerStyle: overlayInnerStyle\n    }, overlay);\n  };\n  var destroyTooltip = false;\n  var autoDestroy = false;\n  if (typeof destroyTooltipOnHide === 'boolean') {\n    destroyTooltip = destroyTooltipOnHide;\n  } else if (destroyTooltipOnHide && _typeof(destroyTooltipOnHide) === 'object') {\n    var keepParent = destroyTooltipOnHide.keepParent;\n    destroyTooltip = keepParent === true;\n    autoDestroy = keepParent === false;\n  }\n  return /*#__PURE__*/React.createElement(Trigger, _extends({\n    popupClassName: overlayClassName,\n    prefixCls: prefixCls,\n    popup: getPopupElement,\n    action: trigger,\n    builtinPlacements: placements,\n    popupPlacement: placement,\n    ref: domRef,\n    popupAlign: align,\n    getPopupContainer: getTooltipContainer,\n    onPopupVisibleChange: onVisibleChange,\n    afterPopupVisibleChange: afterVisibleChange,\n    popupTransitionName: transitionName,\n    popupAnimation: animation,\n    popupMotion: motion,\n    defaultPopupVisible: defaultVisible,\n    destroyPopupOnHide: destroyTooltip,\n    autoDestroy: autoDestroy,\n    mouseLeaveDelay: mouseLeaveDelay,\n    popupStyle: overlayStyle,\n    mouseEnterDelay: mouseEnterDelay\n  }, extraProps), children);\n};\nexport default /*#__PURE__*/forwardRef(Tooltip);","import Tooltip from './Tooltip';\nimport Popup from './Popup';\nexport { Popup };\nexport default Tooltip;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport Tooltip from 'rc-tooltip';\nimport { composeRef } from \"rc-util/es/ref\";\nimport raf from \"rc-util/es/raf\";\nvar SliderTooltip = /*#__PURE__*/React.forwardRef(function (props, ref) {\n  var visible = props.visible,\n      overlay = props.overlay;\n  var innerRef = React.useRef(null);\n  var tooltipRef = composeRef(ref, innerRef);\n  var rafRef = React.useRef(null);\n\n  function cancelKeepAlign() {\n    raf.cancel(rafRef.current);\n  }\n\n  function keepAlign() {\n    rafRef.current = raf(function () {\n      var _innerRef$current;\n\n      (_innerRef$current = innerRef.current) === null || _innerRef$current === void 0 ? void 0 : _innerRef$current.forcePopupAlign();\n    });\n  }\n\n  React.useEffect(function () {\n    if (visible) {\n      keepAlign();\n    } else {\n      cancelKeepAlign();\n    }\n\n    return cancelKeepAlign;\n  }, [visible, overlay]);\n  return /*#__PURE__*/React.createElement(Tooltip, _extends({\n    ref: tooltipRef\n  }, props));\n});\nexport default SliderTooltip;","import Slider from './Slider';\nimport Range from './Range';\nimport Handle from './Handle';\nimport createSliderWithTooltip from './createSliderWithTooltip';\nimport SliderTooltip from './common/SliderTooltip';\nvar InternalSlider = Slider;\nInternalSlider.Range = Range;\nInternalSlider.Handle = Handle;\nInternalSlider.createSliderWithTooltip = createSliderWithTooltip;\nexport default InternalSlider;\nexport { Range, Handle, createSliderWithTooltip, SliderTooltip };","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nimport _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _classCallCheck from \"@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"@babel/runtime/helpers/esm/createClass\";\nimport _inherits from \"@babel/runtime/helpers/esm/inherits\";\nimport _createSuper from \"@babel/runtime/helpers/esm/createSuper\";\nimport React from 'react';\nimport Tooltip from './common/SliderTooltip';\nimport Handle from './Handle';\nexport default function createSliderWithTooltip(Component) {\n  var _a; // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\n\n  return _a = /*#__PURE__*/function (_React$Component) {\n    _inherits(ComponentWrapper, _React$Component);\n\n    var _super = _createSuper(ComponentWrapper);\n\n    function ComponentWrapper() {\n      var _this;\n\n      _classCallCheck(this, ComponentWrapper);\n\n      _this = _super.apply(this, arguments);\n      _this.state = {\n        visibles: {}\n      };\n\n      _this.handleTooltipVisibleChange = function (index, visible) {\n        _this.setState(function (prevState) {\n          return {\n            visibles: _objectSpread(_objectSpread({}, prevState.visibles), {}, _defineProperty({}, index, visible))\n          };\n        });\n      };\n\n      _this.handleWithTooltip = function (_ref) {\n        var value = _ref.value,\n            dragging = _ref.dragging,\n            index = _ref.index,\n            disabled = _ref.disabled,\n            restProps = _objectWithoutProperties(_ref, [\"value\", \"dragging\", \"index\", \"disabled\"]);\n\n        var _this$props = _this.props,\n            tipFormatter = _this$props.tipFormatter,\n            tipProps = _this$props.tipProps,\n            handleStyle = _this$props.handleStyle,\n            getTooltipContainer = _this$props.getTooltipContainer;\n\n        var _tipProps$prefixCls = tipProps.prefixCls,\n            prefixCls = _tipProps$prefixCls === void 0 ? 'rc-slider-tooltip' : _tipProps$prefixCls,\n            _tipProps$overlay = tipProps.overlay,\n            overlay = _tipProps$overlay === void 0 ? tipFormatter(value) : _tipProps$overlay,\n            _tipProps$placement = tipProps.placement,\n            placement = _tipProps$placement === void 0 ? 'top' : _tipProps$placement,\n            _tipProps$visible = tipProps.visible,\n            visible = _tipProps$visible === void 0 ? false : _tipProps$visible,\n            restTooltipProps = _objectWithoutProperties(tipProps, [\"prefixCls\", \"overlay\", \"placement\", \"visible\"]);\n\n        var handleStyleWithIndex;\n\n        if (Array.isArray(handleStyle)) {\n          handleStyleWithIndex = handleStyle[index] || handleStyle[0];\n        } else {\n          handleStyleWithIndex = handleStyle;\n        }\n\n        return /*#__PURE__*/React.createElement(Tooltip, _extends({}, restTooltipProps, {\n          getTooltipContainer: getTooltipContainer,\n          prefixCls: prefixCls,\n          overlay: overlay,\n          placement: placement,\n          visible: !disabled && (_this.state.visibles[index] || dragging) || visible,\n          key: index\n        }), /*#__PURE__*/React.createElement(Handle, _extends({}, restProps, {\n          style: _objectSpread({}, handleStyleWithIndex),\n          value: value,\n          onMouseEnter: function onMouseEnter() {\n            return _this.handleTooltipVisibleChange(index, true);\n          },\n          onMouseLeave: function onMouseLeave() {\n            return _this.handleTooltipVisibleChange(index, false);\n          }\n        })));\n      };\n\n      return _this;\n    }\n\n    _createClass(ComponentWrapper, [{\n      key: \"render\",\n      value: function render() {\n        return /*#__PURE__*/React.createElement(Component, _extends({}, this.props, {\n          handle: this.handleWithTooltip\n        }));\n      }\n    }]);\n\n    return ComponentWrapper;\n  }(React.Component), _a.defaultProps = {\n    tipFormatter: function tipFormatter(value) {\n      return value;\n    },\n    handleStyle: [{}],\n    tipProps: {},\n    getTooltipContainer: function getTooltipContainer(node) {\n      return node.parentNode;\n    }\n  }, _a;\n}","/**\n * React Router DOM v6.21.2\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { UNSAFE_mapRouteProperties, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, Router, UNSAFE_useRoutesImpl, UNSAFE_NavigationContext, useHref, useResolvedPath, useLocation, useNavigate, createPath, UNSAFE_useRouteId, UNSAFE_RouteContext, useMatches, useNavigation, useBlocker } from 'react-router';\nexport { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_useRouteId, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router';\nimport { stripBasename, UNSAFE_warning, createRouter, createBrowserHistory, createHashHistory, UNSAFE_ErrorResponseImpl, UNSAFE_invariant, joinPaths, IDLE_FETCHER, matchPath } from '@remix-run/router';\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\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\nconst defaultMethod = \"get\";\nconst defaultEncType = \"application/x-www-form-urlencoded\";\nfunction isHtmlElement(object) {\n  return object != null && typeof object.tagName === \"string\";\n}\nfunction isButtonElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"button\";\n}\nfunction isFormElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"form\";\n}\nfunction isInputElement(object) {\n  return isHtmlElement(object) && object.tagName.toLowerCase() === \"input\";\n}\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\nfunction shouldProcessLinkClick(event, target) {\n  return event.button === 0 && (\n  // Ignore everything but left clicks\n  !target || target === \"_self\") &&\n  // Let browser handle \"target=_blank\" etc.\n  !isModifiedEvent(event) // Ignore clicks with modifier keys\n  ;\n}\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n *   let searchParams = new URLSearchParams([\n *     ['sort', 'name'],\n *     ['sort', 'price']\n *   ]);\n *\n * you can do:\n *\n *   let searchParams = createSearchParams({\n *     sort: ['name', 'price']\n *   });\n */\nfunction createSearchParams(init) {\n  if (init === void 0) {\n    init = \"\";\n  }\n  return new URLSearchParams(typeof init === \"string\" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {\n    let value = init[key];\n    return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);\n  }, []));\n}\nfunction getSearchParamsForLocation(locationSearch, defaultSearchParams) {\n  let searchParams = createSearchParams(locationSearch);\n  if (defaultSearchParams) {\n    // Use `defaultSearchParams.forEach(...)` here instead of iterating of\n    // `defaultSearchParams.keys()` to work-around a bug in Firefox related to\n    // web extensions. Relevant Bugzilla tickets:\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1414602\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1023984\n    defaultSearchParams.forEach((_, key) => {\n      if (!searchParams.has(key)) {\n        defaultSearchParams.getAll(key).forEach(value => {\n          searchParams.append(key, value);\n        });\n      }\n    });\n  }\n  return searchParams;\n}\n// One-time check for submitter support\nlet _formDataSupportsSubmitter = null;\nfunction isFormDataSubmitterSupported() {\n  if (_formDataSupportsSubmitter === null) {\n    try {\n      new FormData(document.createElement(\"form\"),\n      // @ts-expect-error if FormData supports the submitter parameter, this will throw\n      0);\n      _formDataSupportsSubmitter = false;\n    } catch (e) {\n      _formDataSupportsSubmitter = true;\n    }\n  }\n  return _formDataSupportsSubmitter;\n}\nconst supportedFormEncTypes = new Set([\"application/x-www-form-urlencoded\", \"multipart/form-data\", \"text/plain\"]);\nfunction getFormEncType(encType) {\n  if (encType != null && !supportedFormEncTypes.has(encType)) {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"\\\"\" + encType + \"\\\" is not a valid `encType` for `<Form>`/`<fetcher.Form>` \" + (\"and will default to \\\"\" + defaultEncType + \"\\\"\")) : void 0;\n    return null;\n  }\n  return encType;\n}\nfunction getFormSubmissionInfo(target, basename) {\n  let method;\n  let action;\n  let encType;\n  let formData;\n  let body;\n  if (isFormElement(target)) {\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"enctype\")) || defaultEncType;\n    formData = new FormData(target);\n  } else if (isButtonElement(target) || isInputElement(target) && (target.type === \"submit\" || target.type === \"image\")) {\n    let form = target.form;\n    if (form == null) {\n      throw new Error(\"Cannot submit a <button> or <input type=\\\"submit\\\"> without a <form>\");\n    }\n    // <button>/<input type=\"submit\"> may override attributes of <form>\n    // When grabbing the action from the element, it will have had the basename\n    // prefixed to ensure non-JS scenarios work, so strip it since we'll\n    // re-prefix in the router\n    let attr = target.getAttribute(\"formaction\") || form.getAttribute(\"action\");\n    action = attr ? stripBasename(attr, basename) : null;\n    method = target.getAttribute(\"formmethod\") || form.getAttribute(\"method\") || defaultMethod;\n    encType = getFormEncType(target.getAttribute(\"formenctype\")) || getFormEncType(form.getAttribute(\"enctype\")) || defaultEncType;\n    // Build a FormData object populated from a form and submitter\n    formData = new FormData(form, target);\n    // If this browser doesn't support the `FormData(el, submitter)` format,\n    // then tack on the submitter value at the end.  This is a lightweight\n    // solution that is not 100% spec compliant.  For complete support in older\n    // browsers, consider using the `formdata-submitter-polyfill` package\n    if (!isFormDataSubmitterSupported()) {\n      let {\n        name,\n        type,\n        value\n      } = target;\n      if (type === \"image\") {\n        let prefix = name ? name + \".\" : \"\";\n        formData.append(prefix + \"x\", \"0\");\n        formData.append(prefix + \"y\", \"0\");\n      } else if (name) {\n        formData.append(name, value);\n      }\n    }\n  } else if (isHtmlElement(target)) {\n    throw new Error(\"Cannot submit element that is not <form>, <button>, or \" + \"<input type=\\\"submit|image\\\">\");\n  } else {\n    method = defaultMethod;\n    action = null;\n    encType = defaultEncType;\n    body = target;\n  }\n  // Send body for <Form encType=\"text/plain\" so we encode it into text\n  if (formData && encType === \"text/plain\") {\n    body = formData;\n    formData = undefined;\n  }\n  return {\n    action,\n    method: method.toLowerCase(),\n    encType,\n    formData,\n    body\n  };\n}\n\nconst _excluded = [\"onClick\", \"relative\", \"reloadDocument\", \"replace\", \"state\", \"target\", \"to\", \"preventScrollReset\", \"unstable_viewTransition\"],\n  _excluded2 = [\"aria-current\", \"caseSensitive\", \"className\", \"end\", \"style\", \"to\", \"unstable_viewTransition\", \"children\"],\n  _excluded3 = [\"fetcherKey\", \"navigate\", \"reloadDocument\", \"replace\", \"state\", \"method\", \"action\", \"onSubmit\", \"relative\", \"preventScrollReset\", \"unstable_viewTransition\"];\nfunction createBrowserRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createBrowserHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n    routes,\n    mapRouteProperties: UNSAFE_mapRouteProperties,\n    window: opts == null ? void 0 : opts.window\n  }).initialize();\n}\nfunction createHashRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createHashHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n    routes,\n    mapRouteProperties: UNSAFE_mapRouteProperties,\n    window: opts == null ? void 0 : opts.window\n  }).initialize();\n}\nfunction parseHydrationData() {\n  var _window;\n  let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData;\n  if (state && state.errors) {\n    state = _extends({}, state, {\n      errors: deserializeErrors(state.errors)\n    });\n  }\n  return state;\n}\nfunction deserializeErrors(errors) {\n  if (!errors) return null;\n  let entries = Object.entries(errors);\n  let serialized = {};\n  for (let [key, val] of entries) {\n    // Hey you!  If you change this, please change the corresponding logic in\n    // serializeErrors in react-router-dom/server.tsx :)\n    if (val && val.__type === \"RouteErrorResponse\") {\n      serialized[key] = new UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true);\n    } else if (val && val.__type === \"Error\") {\n      // Attempt to reconstruct the right type of Error (i.e., ReferenceError)\n      if (val.__subType) {\n        let ErrorConstructor = window[val.__subType];\n        if (typeof ErrorConstructor === \"function\") {\n          try {\n            // @ts-expect-error\n            let error = new ErrorConstructor(val.message);\n            // Wipe away the client-side stack trace.  Nothing to fill it in with\n            // because we don't serialize SSR stack traces for security reasons\n            error.stack = \"\";\n            serialized[key] = error;\n          } catch (e) {\n            // no-op - fall through and create a normal Error\n          }\n        }\n      }\n      if (serialized[key] == null) {\n        let error = new Error(val.message);\n        // Wipe away the client-side stack trace.  Nothing to fill it in with\n        // because we don't serialize SSR stack traces for security reasons\n        error.stack = \"\";\n        serialized[key] = error;\n      }\n    } else {\n      serialized[key] = val;\n    }\n  }\n  return serialized;\n}\nconst ViewTransitionContext = /*#__PURE__*/React.createContext({\n  isTransitioning: false\n});\nif (process.env.NODE_ENV !== \"production\") {\n  ViewTransitionContext.displayName = \"ViewTransition\";\n}\nconst FetchersContext = /*#__PURE__*/React.createContext(new Map());\nif (process.env.NODE_ENV !== \"production\") {\n  FetchersContext.displayName = \"Fetchers\";\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Components\n////////////////////////////////////////////////////////////////////////////////\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\nconst FLUSH_SYNC = \"flushSync\";\nconst flushSyncImpl = ReactDOM[FLUSH_SYNC];\nconst USE_ID = \"useId\";\nconst useIdImpl = React[USE_ID];\nfunction startTransitionSafe(cb) {\n  if (startTransitionImpl) {\n    startTransitionImpl(cb);\n  } else {\n    cb();\n  }\n}\nfunction flushSyncSafe(cb) {\n  if (flushSyncImpl) {\n    flushSyncImpl(cb);\n  } else {\n    cb();\n  }\n}\nclass Deferred {\n  constructor() {\n    this.status = \"pending\";\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = value => {\n        if (this.status === \"pending\") {\n          this.status = \"resolved\";\n          resolve(value);\n        }\n      };\n      this.reject = reason => {\n        if (this.status === \"pending\") {\n          this.status = \"rejected\";\n          reject(reason);\n        }\n      };\n    });\n  }\n}\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nfunction RouterProvider(_ref) {\n  let {\n    fallbackElement,\n    router,\n    future\n  } = _ref;\n  let [state, setStateImpl] = React.useState(router.state);\n  let [pendingState, setPendingState] = React.useState();\n  let [vtContext, setVtContext] = React.useState({\n    isTransitioning: false\n  });\n  let [renderDfd, setRenderDfd] = React.useState();\n  let [transition, setTransition] = React.useState();\n  let [interruption, setInterruption] = React.useState();\n  let fetcherData = React.useRef(new Map());\n  let {\n    v7_startTransition\n  } = future || {};\n  let optInStartTransition = React.useCallback(cb => {\n    if (v7_startTransition) {\n      startTransitionSafe(cb);\n    } else {\n      cb();\n    }\n  }, [v7_startTransition]);\n  let setState = React.useCallback((newState, _ref2) => {\n    let {\n      deletedFetchers,\n      unstable_flushSync: flushSync,\n      unstable_viewTransitionOpts: viewTransitionOpts\n    } = _ref2;\n    deletedFetchers.forEach(key => fetcherData.current.delete(key));\n    newState.fetchers.forEach((fetcher, key) => {\n      if (fetcher.data !== undefined) {\n        fetcherData.current.set(key, fetcher.data);\n      }\n    });\n    let isViewTransitionUnavailable = router.window == null || typeof router.window.document.startViewTransition !== \"function\";\n    // If this isn't a view transition or it's not available in this browser,\n    // just update and be done with it\n    if (!viewTransitionOpts || isViewTransitionUnavailable) {\n      if (flushSync) {\n        flushSyncSafe(() => setStateImpl(newState));\n      } else {\n        optInStartTransition(() => setStateImpl(newState));\n      }\n      return;\n    }\n    // flushSync + startViewTransition\n    if (flushSync) {\n      // Flush through the context to mark DOM elements as transition=ing\n      flushSyncSafe(() => {\n        // Cancel any pending transitions\n        if (transition) {\n          renderDfd && renderDfd.resolve();\n          transition.skipTransition();\n        }\n        setVtContext({\n          isTransitioning: true,\n          flushSync: true,\n          currentLocation: viewTransitionOpts.currentLocation,\n          nextLocation: viewTransitionOpts.nextLocation\n        });\n      });\n      // Update the DOM\n      let t = router.window.document.startViewTransition(() => {\n        flushSyncSafe(() => setStateImpl(newState));\n      });\n      // Clean up after the animation completes\n      t.finished.finally(() => {\n        flushSyncSafe(() => {\n          setRenderDfd(undefined);\n          setTransition(undefined);\n          setPendingState(undefined);\n          setVtContext({\n            isTransitioning: false\n          });\n        });\n      });\n      flushSyncSafe(() => setTransition(t));\n      return;\n    }\n    // startTransition + startViewTransition\n    if (transition) {\n      // Interrupting an in-progress transition, cancel and let everything flush\n      // out, and then kick off a new transition from the interruption state\n      renderDfd && renderDfd.resolve();\n      transition.skipTransition();\n      setInterruption({\n        state: newState,\n        currentLocation: viewTransitionOpts.currentLocation,\n        nextLocation: viewTransitionOpts.nextLocation\n      });\n    } else {\n      // Completed navigation update with opted-in view transitions, let 'er rip\n      setPendingState(newState);\n      setVtContext({\n        isTransitioning: true,\n        flushSync: false,\n        currentLocation: viewTransitionOpts.currentLocation,\n        nextLocation: viewTransitionOpts.nextLocation\n      });\n    }\n  }, [router.window, transition, renderDfd, fetcherData, optInStartTransition]);\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n  // When we start a view transition, create a Deferred we can use for the\n  // eventual \"completed\" render\n  React.useEffect(() => {\n    if (vtContext.isTransitioning && !vtContext.flushSync) {\n      setRenderDfd(new Deferred());\n    }\n  }, [vtContext]);\n  // Once the deferred is created, kick off startViewTransition() to update the\n  // DOM and then wait on the Deferred to resolve (indicating the DOM update has\n  // happened)\n  React.useEffect(() => {\n    if (renderDfd && pendingState && router.window) {\n      let newState = pendingState;\n      let renderPromise = renderDfd.promise;\n      let transition = router.window.document.startViewTransition(async () => {\n        optInStartTransition(() => setStateImpl(newState));\n        await renderPromise;\n      });\n      transition.finished.finally(() => {\n        setRenderDfd(undefined);\n        setTransition(undefined);\n        setPendingState(undefined);\n        setVtContext({\n          isTransitioning: false\n        });\n      });\n      setTransition(transition);\n    }\n  }, [optInStartTransition, pendingState, renderDfd, router.window]);\n  // When the new location finally renders and is committed to the DOM, this\n  // effect will run to resolve the transition\n  React.useEffect(() => {\n    if (renderDfd && pendingState && state.location.key === pendingState.location.key) {\n      renderDfd.resolve();\n    }\n  }, [renderDfd, transition, state.location, pendingState]);\n  // If we get interrupted with a new navigation during a transition, we skip\n  // the active transition, let it cleanup, then kick it off again here\n  React.useEffect(() => {\n    if (!vtContext.isTransitioning && interruption) {\n      setPendingState(interruption.state);\n      setVtContext({\n        isTransitioning: true,\n        flushSync: false,\n        currentLocation: interruption.currentLocation,\n        nextLocation: interruption.nextLocation\n      });\n      setInterruption(undefined);\n    }\n  }, [vtContext.isTransitioning, interruption]);\n  React.useEffect(() => {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(fallbackElement == null || !router.future.v7_partialHydration, \"`<RouterProvider fallbackElement>` is deprecated when using \" + \"`v7_partialHydration`, use a `HydrateFallback` component instead\") : void 0;\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: n => router.navigate(n),\n      push: (to, state, opts) => router.navigate(to, {\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      }),\n      replace: (to, state, opts) => router.navigate(to, {\n        replace: true,\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      })\n    };\n  }, [router]);\n  let basename = router.basename || \"/\";\n  let dataRouterContext = React.useMemo(() => ({\n    router,\n    navigator,\n    static: false,\n    basename\n  }), [router, navigator, basename]);\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(UNSAFE_DataRouterContext.Provider, {\n    value: dataRouterContext\n  }, /*#__PURE__*/React.createElement(UNSAFE_DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(FetchersContext.Provider, {\n    value: fetcherData.current\n  }, /*#__PURE__*/React.createElement(ViewTransitionContext.Provider, {\n    value: vtContext\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    location: state.location,\n    navigationType: state.historyAction,\n    navigator: navigator,\n    future: {\n      v7_relativeSplatPath: router.future.v7_relativeSplatPath\n    }\n  }, state.initialized || router.future.v7_partialHydration ? /*#__PURE__*/React.createElement(DataRoutes, {\n    routes: router.routes,\n    future: router.future,\n    state: state\n  }) : fallbackElement))))), null);\n}\nfunction DataRoutes(_ref3) {\n  let {\n    routes,\n    future,\n    state\n  } = _ref3;\n  return UNSAFE_useRoutesImpl(routes, undefined, state, future);\n}\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\nfunction BrowserRouter(_ref4) {\n  let {\n    basename,\n    children,\n    future,\n    window\n  } = _ref4;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({\n      window,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * A `<Router>` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\nfunction HashRouter(_ref5) {\n  let {\n    basename,\n    children,\n    future,\n    window\n  } = _ref5;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({\n      window,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * A `<Router>` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\nfunction HistoryRouter(_ref6) {\n  let {\n    basename,\n    children,\n    future,\n    history\n  } = _ref6;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\nif (process.env.NODE_ENV !== \"production\") {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\nconst isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\";\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n/**\n * The public API for rendering a history-aware `<a>`.\n */\nconst Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref7, ref) {\n  let {\n      onClick,\n      relative,\n      reloadDocument,\n      replace,\n      state,\n      target,\n      to,\n      preventScrollReset,\n      unstable_viewTransition\n    } = _ref7,\n    rest = _objectWithoutPropertiesLoose(_ref7, _excluded);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  // Rendered into <a href> for absolute URLs\n  let absoluteHref;\n  let isExternal = false;\n  if (typeof to === \"string\" && ABSOLUTE_URL_REGEX.test(to)) {\n    // Render the absolute href server- and client-side\n    absoluteHref = to;\n    // Only check for external origins client-side\n    if (isBrowser) {\n      try {\n        let currentUrl = new URL(window.location.href);\n        let targetUrl = to.startsWith(\"//\") ? new URL(currentUrl.protocol + to) : new URL(to);\n        let path = stripBasename(targetUrl.pathname, basename);\n        if (targetUrl.origin === currentUrl.origin && path != null) {\n          // Strip the protocol/origin/basename for same-origin absolute URLs\n          to = path + targetUrl.search + targetUrl.hash;\n        } else {\n          isExternal = true;\n        }\n      } catch (e) {\n        // We can't do external URL detection without a valid URL\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"<Link to=\\\"\" + to + \"\\\"> contains an invalid URL which will probably break \" + \"when clicked - please update to a valid URL path.\") : void 0;\n      }\n    }\n  }\n  // Rendered into <a href> for relative URLs\n  let href = useHref(to, {\n    relative\n  });\n  let internalOnClick = useLinkClickHandler(to, {\n    replace,\n    state,\n    target,\n    preventScrollReset,\n    relative,\n    unstable_viewTransition\n  });\n  function handleClick(event) {\n    if (onClick) onClick(event);\n    if (!event.defaultPrevented) {\n      internalOnClick(event);\n    }\n  }\n  return (\n    /*#__PURE__*/\n    // eslint-disable-next-line jsx-a11y/anchor-has-content\n    React.createElement(\"a\", _extends({}, rest, {\n      href: absoluteHref || href,\n      onClick: isExternal || reloadDocument ? onClick : handleClick,\n      ref: ref,\n      target: target\n    }))\n  );\n});\nif (process.env.NODE_ENV !== \"production\") {\n  Link.displayName = \"Link\";\n}\n/**\n * A `<Link>` wrapper that knows if it's \"active\" or not.\n */\nconst NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef(_ref8, ref) {\n  let {\n      \"aria-current\": ariaCurrentProp = \"page\",\n      caseSensitive = false,\n      className: classNameProp = \"\",\n      end = false,\n      style: styleProp,\n      to,\n      unstable_viewTransition,\n      children\n    } = _ref8,\n    rest = _objectWithoutPropertiesLoose(_ref8, _excluded2);\n  let path = useResolvedPath(to, {\n    relative: rest.relative\n  });\n  let location = useLocation();\n  let routerState = React.useContext(UNSAFE_DataRouterStateContext);\n  let {\n    navigator\n  } = React.useContext(UNSAFE_NavigationContext);\n  let isTransitioning = routerState != null &&\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  useViewTransitionState(path) && unstable_viewTransition === true;\n  let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;\n  let locationPathname = location.pathname;\n  let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;\n  if (!caseSensitive) {\n    locationPathname = locationPathname.toLowerCase();\n    nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;\n    toPathname = toPathname.toLowerCase();\n  }\n  // If the `to` has a trailing slash, look at that exact spot.  Otherwise,\n  // we're looking for a slash _after_ what's in `to`.  For example:\n  //\n  // <NavLink to=\"/users\"> and <NavLink to=\"/users/\">\n  // both want to look for a / at index 6 to match URL `/users/matt`\n  const endSlashPosition = toPathname !== \"/\" && toPathname.endsWith(\"/\") ? toPathname.length - 1 : toPathname.length;\n  let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(endSlashPosition) === \"/\";\n  let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === \"/\");\n  let renderProps = {\n    isActive,\n    isPending,\n    isTransitioning\n  };\n  let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n  let className;\n  if (typeof classNameProp === \"function\") {\n    className = classNameProp(renderProps);\n  } else {\n    // If the className prop is not a function, we use a default `active`\n    // class for <NavLink />s that are active. In v5 `active` was the default\n    // value for `activeClassName`, but we are removing that API and can still\n    // use the old default behavior for a cleaner upgrade path and keep the\n    // simple styling rules working as they currently do.\n    className = [classNameProp, isActive ? \"active\" : null, isPending ? \"pending\" : null, isTransitioning ? \"transitioning\" : null].filter(Boolean).join(\" \");\n  }\n  let style = typeof styleProp === \"function\" ? styleProp(renderProps) : styleProp;\n  return /*#__PURE__*/React.createElement(Link, _extends({}, rest, {\n    \"aria-current\": ariaCurrent,\n    className: className,\n    ref: ref,\n    style: style,\n    to: to,\n    unstable_viewTransition: unstable_viewTransition\n  }), typeof children === \"function\" ? children(renderProps) : children);\n});\nif (process.env.NODE_ENV !== \"production\") {\n  NavLink.displayName = \"NavLink\";\n}\n/**\n * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except\n * that the interaction with the server is with `fetch` instead of new document\n * requests, allowing components to add nicer UX to the page as the form is\n * submitted and returns with data.\n */\nconst Form = /*#__PURE__*/React.forwardRef((_ref9, forwardedRef) => {\n  let {\n      fetcherKey,\n      navigate,\n      reloadDocument,\n      replace,\n      state,\n      method = defaultMethod,\n      action,\n      onSubmit,\n      relative,\n      preventScrollReset,\n      unstable_viewTransition\n    } = _ref9,\n    props = _objectWithoutPropertiesLoose(_ref9, _excluded3);\n  let submit = useSubmit();\n  let formAction = useFormAction(action, {\n    relative\n  });\n  let formMethod = method.toLowerCase() === \"get\" ? \"get\" : \"post\";\n  let submitHandler = event => {\n    onSubmit && onSubmit(event);\n    if (event.defaultPrevented) return;\n    event.preventDefault();\n    let submitter = event.nativeEvent.submitter;\n    let submitMethod = (submitter == null ? void 0 : submitter.getAttribute(\"formmethod\")) || method;\n    submit(submitter || event.currentTarget, {\n      fetcherKey,\n      method: submitMethod,\n      navigate,\n      replace,\n      state,\n      relative,\n      preventScrollReset,\n      unstable_viewTransition\n    });\n  };\n  return /*#__PURE__*/React.createElement(\"form\", _extends({\n    ref: forwardedRef,\n    method: formMethod,\n    action: formAction,\n    onSubmit: reloadDocument ? onSubmit : submitHandler\n  }, props));\n});\nif (process.env.NODE_ENV !== \"production\") {\n  Form.displayName = \"Form\";\n}\n/**\n * This component will emulate the browser's scroll restoration on location\n * changes.\n */\nfunction ScrollRestoration(_ref10) {\n  let {\n    getKey,\n    storageKey\n  } = _ref10;\n  useScrollRestoration({\n    getKey,\n    storageKey\n  });\n  return null;\n}\nif (process.env.NODE_ENV !== \"production\") {\n  ScrollRestoration.displayName = \"ScrollRestoration\";\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Hooks\n////////////////////////////////////////////////////////////////////////////////\nvar DataRouterHook;\n(function (DataRouterHook) {\n  DataRouterHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n  DataRouterHook[\"UseSubmit\"] = \"useSubmit\";\n  DataRouterHook[\"UseSubmitFetcher\"] = \"useSubmitFetcher\";\n  DataRouterHook[\"UseFetcher\"] = \"useFetcher\";\n  DataRouterHook[\"useViewTransitionState\"] = \"useViewTransitionState\";\n})(DataRouterHook || (DataRouterHook = {}));\nvar DataRouterStateHook;\n(function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseFetcher\"] = \"useFetcher\";\n  DataRouterStateHook[\"UseFetchers\"] = \"useFetchers\";\n  DataRouterStateHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n})(DataRouterStateHook || (DataRouterStateHook = {}));\n// Internal hooks\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.\";\n}\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(UNSAFE_DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(UNSAFE_DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\n// External hooks\n/**\n * Handles the click behavior for router `<Link>` components. This is useful if\n * you need to create custom `<Link>` components with the same click behavior we\n * use in our exported `<Link>`.\n */\nfunction useLinkClickHandler(to, _temp) {\n  let {\n    target,\n    replace: replaceProp,\n    state,\n    preventScrollReset,\n    relative,\n    unstable_viewTransition\n  } = _temp === void 0 ? {} : _temp;\n  let navigate = useNavigate();\n  let location = useLocation();\n  let path = useResolvedPath(to, {\n    relative\n  });\n  return React.useCallback(event => {\n    if (shouldProcessLinkClick(event, target)) {\n      event.preventDefault();\n      // If the URL hasn't changed, a regular <a> will do a replace instead of\n      // a push, so do the same here unless the replace prop is explicitly set\n      let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path);\n      navigate(to, {\n        replace,\n        state,\n        preventScrollReset,\n        relative,\n        unstable_viewTransition\n      });\n    }\n  }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, unstable_viewTransition]);\n}\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\nfunction useSearchParams(defaultInit) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(typeof URLSearchParams !== \"undefined\", \"You cannot use the `useSearchParams` hook in a browser that does not \" + \"support the URLSearchParams API. If you need to support Internet \" + \"Explorer 11, we recommend you load a polyfill such as \" + \"https://github.com/ungap/url-search-params\\n\\n\" + \"If you're unsure how to load polyfills, we recommend you check out \" + \"https://polyfill.io/v3/ which provides some recommendations about how \" + \"to load polyfills only for users that need them, instead of for every \" + \"user.\") : void 0;\n  let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n  let hasSetSearchParamsRef = React.useRef(false);\n  let location = useLocation();\n  let searchParams = React.useMemo(() =>\n  // Only merge in the defaults if we haven't yet called setSearchParams.\n  // Once we call that we want those to take precedence, otherwise you can't\n  // remove a param with setSearchParams({}) if it has an initial value\n  getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current), [location.search]);\n  let navigate = useNavigate();\n  let setSearchParams = React.useCallback((nextInit, navigateOptions) => {\n    const newSearchParams = createSearchParams(typeof nextInit === \"function\" ? nextInit(searchParams) : nextInit);\n    hasSetSearchParamsRef.current = true;\n    navigate(\"?\" + newSearchParams, navigateOptions);\n  }, [navigate, searchParams]);\n  return [searchParams, setSearchParams];\n}\nfunction validateClientSideSubmission() {\n  if (typeof document === \"undefined\") {\n    throw new Error(\"You are calling submit during the server render. \" + \"Try calling submit within a `useEffect` or callback instead.\");\n  }\n}\nlet fetcherId = 0;\nlet getUniqueFetcherId = () => \"__\" + String(++fetcherId) + \"__\";\n/**\n * Returns a function that may be used to programmatically submit a form (or\n * some arbitrary data) to the server.\n */\nfunction useSubmit() {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseSubmit);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let currentRouteId = UNSAFE_useRouteId();\n  return React.useCallback(function (target, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    validateClientSideSubmission();\n    let {\n      action,\n      method,\n      encType,\n      formData,\n      body\n    } = getFormSubmissionInfo(target, basename);\n    if (options.navigate === false) {\n      let key = options.fetcherKey || getUniqueFetcherId();\n      router.fetch(key, currentRouteId, options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || method,\n        formEncType: options.encType || encType,\n        unstable_flushSync: options.unstable_flushSync\n      });\n    } else {\n      router.navigate(options.action || action, {\n        preventScrollReset: options.preventScrollReset,\n        formData,\n        body,\n        formMethod: options.method || method,\n        formEncType: options.encType || encType,\n        replace: options.replace,\n        state: options.state,\n        fromRouteId: currentRouteId,\n        unstable_flushSync: options.unstable_flushSync,\n        unstable_viewTransition: options.unstable_viewTransition\n      });\n    }\n  }, [router, basename, currentRouteId]);\n}\n// v7: Eventually we should deprecate this entirely in favor of using the\n// router method directly?\nfunction useFormAction(action, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let routeContext = React.useContext(UNSAFE_RouteContext);\n  !routeContext ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFormAction must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n  let [match] = routeContext.matches.slice(-1);\n  // Shallow clone path so we can modify it below, otherwise we modify the\n  // object referenced by useMemo inside useResolvedPath\n  let path = _extends({}, useResolvedPath(action ? action : \".\", {\n    relative\n  }));\n  // If no action was specified, browsers will persist current search params\n  // when determining the path, so match that behavior\n  // https://github.com/remix-run/remix/issues/927\n  let location = useLocation();\n  if (action == null) {\n    // Safe to write to this directly here since if action was undefined, we\n    // would have called useResolvedPath(\".\") which will never include a search\n    path.search = location.search;\n    // When grabbing search params from the URL, remove any included ?index param\n    // since it might not apply to our contextual route.  We add it back based\n    // on match.route.index below\n    let params = new URLSearchParams(path.search);\n    if (params.has(\"index\") && params.get(\"index\") === \"\") {\n      params.delete(\"index\");\n      path.search = params.toString() ? \"?\" + params.toString() : \"\";\n    }\n  }\n  if ((!action || action === \".\") && match.route.index) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n  }\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the form action.  If this is a root navigation, then just use\n  // the raw basename which allows the basename to have full control over the\n  // presence of a trailing slash on root actions\n  if (basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n  return createPath(path);\n}\n// TODO: (v7) Change the useFetcher generic default from `any` to `unknown`\n/**\n * Interacts with route loaders and actions without causing a navigation. Great\n * for any interaction that stays on the same page.\n */\nfunction useFetcher(_temp3) {\n  var _route$matches;\n  let {\n    key\n  } = _temp3 === void 0 ? {} : _temp3;\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseFetcher);\n  let state = useDataRouterState(DataRouterStateHook.UseFetcher);\n  let fetcherData = React.useContext(FetchersContext);\n  let route = React.useContext(UNSAFE_RouteContext);\n  let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id;\n  !fetcherData ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a FetchersContext\") : UNSAFE_invariant(false) : void 0;\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n  !(routeId != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  // Fetcher key handling\n  // OK to call conditionally to feature detect `useId`\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  let defaultKey = useIdImpl ? useIdImpl() : \"\";\n  let [fetcherKey, setFetcherKey] = React.useState(key || defaultKey);\n  if (key && key !== fetcherKey) {\n    setFetcherKey(key);\n  } else if (!fetcherKey) {\n    // We will only fall through here when `useId` is not available\n    setFetcherKey(getUniqueFetcherId());\n  }\n  // Registration/cleanup\n  React.useEffect(() => {\n    router.getFetcher(fetcherKey);\n    return () => {\n      // Tell the router we've unmounted - if v7_fetcherPersist is enabled this\n      // will not delete immediately but instead queue up a delete after the\n      // fetcher returns to an `idle` state\n      router.deleteFetcher(fetcherKey);\n    };\n  }, [router, fetcherKey]);\n  // Fetcher additions\n  let load = React.useCallback((href, opts) => {\n    !routeId ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"No routeId available for fetcher.load()\") : UNSAFE_invariant(false) : void 0;\n    router.fetch(fetcherKey, routeId, href, opts);\n  }, [fetcherKey, routeId, router]);\n  let submitImpl = useSubmit();\n  let submit = React.useCallback((target, opts) => {\n    submitImpl(target, _extends({}, opts, {\n      navigate: false,\n      fetcherKey\n    }));\n  }, [fetcherKey, submitImpl]);\n  let FetcherForm = React.useMemo(() => {\n    let FetcherForm = /*#__PURE__*/React.forwardRef((props, ref) => {\n      return /*#__PURE__*/React.createElement(Form, _extends({}, props, {\n        navigate: false,\n        fetcherKey: fetcherKey,\n        ref: ref\n      }));\n    });\n    if (process.env.NODE_ENV !== \"production\") {\n      FetcherForm.displayName = \"fetcher.Form\";\n    }\n    return FetcherForm;\n  }, [fetcherKey]);\n  // Exposed FetcherWithComponents\n  let fetcher = state.fetchers.get(fetcherKey) || IDLE_FETCHER;\n  let data = fetcherData.get(fetcherKey);\n  let fetcherWithComponents = React.useMemo(() => _extends({\n    Form: FetcherForm,\n    submit,\n    load\n  }, fetcher, {\n    data\n  }), [FetcherForm, submit, load, fetcher, data]);\n  return fetcherWithComponents;\n}\n/**\n * Provides all fetchers currently on the page. Useful for layouts and parent\n * routes that need to provide pending/optimistic UI regarding the fetch.\n */\nfunction useFetchers() {\n  let state = useDataRouterState(DataRouterStateHook.UseFetchers);\n  return Array.from(state.fetchers.entries()).map(_ref11 => {\n    let [key, fetcher] = _ref11;\n    return _extends({}, fetcher, {\n      key\n    });\n  });\n}\nconst SCROLL_RESTORATION_STORAGE_KEY = \"react-router-scroll-positions\";\nlet savedScrollPositions = {};\n/**\n * When rendered inside a RouterProvider, will restore scroll positions on navigations\n */\nfunction useScrollRestoration(_temp4) {\n  let {\n    getKey,\n    storageKey\n  } = _temp4 === void 0 ? {} : _temp4;\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseScrollRestoration);\n  let {\n    restoreScrollPosition,\n    preventScrollReset\n  } = useDataRouterState(DataRouterStateHook.UseScrollRestoration);\n  let {\n    basename\n  } = React.useContext(UNSAFE_NavigationContext);\n  let location = useLocation();\n  let matches = useMatches();\n  let navigation = useNavigation();\n  // Trigger manual scroll restoration while we're active\n  React.useEffect(() => {\n    window.history.scrollRestoration = \"manual\";\n    return () => {\n      window.history.scrollRestoration = \"auto\";\n    };\n  }, []);\n  // Save positions on pagehide\n  usePageHide(React.useCallback(() => {\n    if (navigation.state === \"idle\") {\n      let key = (getKey ? getKey(location, matches) : null) || location.key;\n      savedScrollPositions[key] = window.scrollY;\n    }\n    try {\n      sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));\n    } catch (error) {\n      process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"Failed to save scroll positions in sessionStorage, <ScrollRestoration /> will not work properly (\" + error + \").\") : void 0;\n    }\n    window.history.scrollRestoration = \"auto\";\n  }, [storageKey, getKey, navigation.state, location, matches]));\n  // Read in any saved scroll locations\n  if (typeof document !== \"undefined\") {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      try {\n        let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY);\n        if (sessionPositions) {\n          savedScrollPositions = JSON.parse(sessionPositions);\n        }\n      } catch (e) {\n        // no-op, use default empty object\n      }\n    }, [storageKey]);\n    // Enable scroll restoration in the router\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      let getKeyWithoutBasename = getKey && basename !== \"/\" ? (location, matches) => getKey( // Strip the basename to match useLocation()\n      _extends({}, location, {\n        pathname: stripBasename(location.pathname, basename) || location.pathname\n      }), matches) : getKey;\n      let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename);\n      return () => disableScrollRestoration && disableScrollRestoration();\n    }, [router, basename, getKey]);\n    // Restore scrolling when state.restoreScrollPosition changes\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(() => {\n      // Explicit false means don't do anything (used for submissions)\n      if (restoreScrollPosition === false) {\n        return;\n      }\n      // been here before, scroll to it\n      if (typeof restoreScrollPosition === \"number\") {\n        window.scrollTo(0, restoreScrollPosition);\n        return;\n      }\n      // try to scroll to the hash\n      if (location.hash) {\n        let el = document.getElementById(decodeURIComponent(location.hash.slice(1)));\n        if (el) {\n          el.scrollIntoView();\n          return;\n        }\n      }\n      // Don't reset if this navigation opted out\n      if (preventScrollReset === true) {\n        return;\n      }\n      // otherwise go to the top on new locations\n      window.scrollTo(0, 0);\n    }, [location, restoreScrollPosition, preventScrollReset]);\n  }\n}\n/**\n * Setup a callback to be fired on the window's `beforeunload` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction useBeforeUnload(callback, options) {\n  let {\n    capture\n  } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? {\n      capture\n    } : undefined;\n    window.addEventListener(\"beforeunload\", callback, opts);\n    return () => {\n      window.removeEventListener(\"beforeunload\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n/**\n * Setup a callback to be fired on the window's `pagehide` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.  This event is better supported than beforeunload across browsers.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction usePageHide(callback, options) {\n  let {\n    capture\n  } = options || {};\n  React.useEffect(() => {\n    let opts = capture != null ? {\n      capture\n    } : undefined;\n    window.addEventListener(\"pagehide\", callback, opts);\n    return () => {\n      window.removeEventListener(\"pagehide\", callback, opts);\n    };\n  }, [callback, capture]);\n}\n/**\n * Wrapper around useBlocker to show a window.confirm prompt to users instead\n * of building a custom UI with useBlocker.\n *\n * Warning: This has *a lot of rough edges* and behaves very differently (and\n * very incorrectly in some cases) across browsers if user click addition\n * back/forward navigations while the confirm is open.  Use at your own risk.\n */\nfunction usePrompt(_ref12) {\n  let {\n    when,\n    message\n  } = _ref12;\n  let blocker = useBlocker(when);\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\") {\n      let proceed = window.confirm(message);\n      if (proceed) {\n        // This timeout is needed to avoid a weird \"race\" on POP navigations\n        // between the `window.history` revert navigation and the result of\n        // `window.confirm`\n        setTimeout(blocker.proceed, 0);\n      } else {\n        blocker.reset();\n      }\n    }\n  }, [blocker, message]);\n  React.useEffect(() => {\n    if (blocker.state === \"blocked\" && !when) {\n      blocker.reset();\n    }\n  }, [blocker, when]);\n}\n/**\n * Return a boolean indicating if there is an active view transition to the\n * given href.  You can use this value to render CSS classes or viewTransitionName\n * styles onto your elements\n *\n * @param href The destination href\n * @param [opts.relative] Relative routing type (\"route\" | \"path\")\n */\nfunction useViewTransitionState(to, opts) {\n  if (opts === void 0) {\n    opts = {};\n  }\n  let vtContext = React.useContext(ViewTransitionContext);\n  !(vtContext != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"`unstable_useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`.  \" + \"Did you accidentally import `RouterProvider` from `react-router`?\") : UNSAFE_invariant(false) : void 0;\n  let {\n    basename\n  } = useDataRouterContext(DataRouterHook.useViewTransitionState);\n  let path = useResolvedPath(to, {\n    relative: opts.relative\n  });\n  if (!vtContext.isTransitioning) {\n    return false;\n  }\n  let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname;\n  let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname;\n  // Transition is active if we're going to or coming from the indicated\n  // destination.  This ensures that other PUSH navigations that reverse\n  // an indicated transition apply.  I.e., on the list view you have:\n  //\n  //   <NavLink to=\"/details/1\" unstable_viewTransition>\n  //\n  // If you click the breadcrumb back to the list view:\n  //\n  //   <NavLink to=\"/list\" unstable_viewTransition>\n  //\n  // We should apply the transition because it's indicated as active going\n  // from /list -> /details/1 and therefore should be active on the reverse\n  // (even though this isn't strictly a POP reverse)\n  return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;\n}\n//#endregion\n\nexport { BrowserRouter, Form, HashRouter, Link, NavLink, RouterProvider, ScrollRestoration, FetchersContext as UNSAFE_FetchersContext, ViewTransitionContext as UNSAFE_ViewTransitionContext, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useViewTransitionState as unstable_useViewTransitionState, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit };\n//# sourceMappingURL=index.js.map\n","/**\n * React Router v6.21.2\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nimport * as React from 'react';\nimport { UNSAFE_invariant, joinPaths, matchPath, UNSAFE_getResolveToMatches, UNSAFE_warning, resolveTo, parsePath, matchRoutes, Action, UNSAFE_convertRouteMatchToUiMatch, stripBasename, IDLE_BLOCKER, isRouteErrorResponse, createMemoryHistory, AbortedDeferredError, createRouter } from '@remix-run/router';\nexport { AbortedDeferredError, Action as NavigationType, createPath, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, resolvePath } from '@remix-run/router';\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nconst DataRouterContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterContext.displayName = \"DataRouter\";\n}\nconst DataRouterStateContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\nconst AwaitContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  AwaitContext.displayName = \"Await\";\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level `<Router>` API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\n\nconst NavigationContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  NavigationContext.displayName = \"Navigation\";\n}\nconst LocationContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  LocationContext.displayName = \"Location\";\n}\nconst RouteContext = /*#__PURE__*/React.createContext({\n  outlet: null,\n  matches: [],\n  isDataRoute: false\n});\nif (process.env.NODE_ENV !== \"production\") {\n  RouteContext.displayName = \"Route\";\n}\nconst RouteErrorContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  RouteErrorContext.displayName = \"RouteError\";\n}\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/hooks/use-href\n */\nfunction useHref(to, _temp) {\n  let {\n    relative\n  } = _temp === void 0 ? {} : _temp;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useHref() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    basename,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    hash,\n    pathname,\n    search\n  } = useResolvedPath(to, {\n    relative\n  });\n  let joinedPathname = pathname;\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the href.  If this is a root navigation, then just use the raw\n  // basename which allows the basename to have full control over the presence\n  // of a trailing slash on root links\n  if (basename !== \"/\") {\n    joinedPathname = pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n  return navigator.createHref({\n    pathname: joinedPathname,\n    search,\n    hash\n  });\n}\n\n/**\n * Returns true if this component is a descendant of a `<Router>`.\n *\n * @see https://reactrouter.com/hooks/use-in-router-context\n */\nfunction useInRouterContext() {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/hooks/use-location\n */\nfunction useLocation() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useLocation() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/hooks/use-navigation-type\n */\nfunction useNavigationType() {\n  return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * `<NavLink>`.\n *\n * @see https://reactrouter.com/hooks/use-match\n */\nfunction useMatch(pattern) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useMatch() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    pathname\n  } = useLocation();\n  return React.useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\n\nconst navigateEffectWarning = \"You should call navigate() in a React.useEffect(), not when \" + \"your component is first rendered.\";\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(cb) {\n  let isStatic = React.useContext(NavigationContext).static;\n  if (!isStatic) {\n    // We should be able to get rid of this once react 18.3 is released\n    // See: https://github.com/facebook/react/pull/26395\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(cb);\n  }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by `<Link>`s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/hooks/use-navigate\n */\nfunction useNavigate() {\n  let {\n    isDataRoute\n  } = React.useContext(RouteContext);\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\nfunction useNavigateUnstable() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useNavigate() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let dataRouterContext = React.useContext(DataRouterContext);\n  let {\n    basename,\n    future,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath));\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(activeRef.current, navigateEffectWarning) : void 0;\n\n    // Short circuit here since if this happens on first render the navigate\n    // is useless because we haven't wired up our history listener yet\n    if (!activeRef.current) return;\n    if (typeof to === \"number\") {\n      navigator.go(to);\n      return;\n    }\n    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === \"path\");\n\n    // If we're operating within a basename, prepend it to the pathname prior\n    // to handing off to history (but only if we're not in a data router,\n    // otherwise it'll prepend the basename inside of the router).\n    // If this is a root navigation, then we navigate to the raw basename\n    // which allows the basename to have full control over the presence of a\n    // trailing slash on root links\n    if (dataRouterContext == null && basename !== \"/\") {\n      path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n    }\n    (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);\n  }, [basename, navigator, routePathnamesJson, locationPathname, dataRouterContext]);\n  return navigate;\n}\nconst OutletContext = /*#__PURE__*/React.createContext(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/hooks/use-outlet-context\n */\nfunction useOutletContext() {\n  return React.useContext(OutletContext);\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by `<Outlet>` to render child routes.\n *\n * @see https://reactrouter.com/hooks/use-outlet\n */\nfunction useOutlet(context) {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return /*#__PURE__*/React.createElement(OutletContext.Provider, {\n      value: context\n    }, outlet);\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/hooks/use-params\n */\nfunction useParams() {\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? routeMatch.params : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/hooks/use-resolved-path\n */\nfunction useResolvedPath(to, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    future\n  } = React.useContext(NavigationContext);\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath));\n  return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === \"path\"), [to, routePathnamesJson, locationPathname, relative]);\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an `<Outlet>` to render their child route's\n * element.\n *\n * @see https://reactrouter.com/hooks/use-routes\n */\nfunction useRoutes(routes, locationArg) {\n  return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nfunction useRoutesImpl(routes, locationArg, dataRouterState, future) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of the\n  // router loaded. We can help them understand how to avoid that.\n  \"useRoutes() may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    matches: parentMatches\n  } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n  if (process.env.NODE_ENV !== \"production\") {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = parentRoute && parentRoute.path || \"\";\n    warningOnce(parentPathname, !parentRoute || parentPath.endsWith(\"*\"), \"You rendered descendant <Routes> (or called `useRoutes()`) at \" + (\"\\\"\" + parentPathname + \"\\\" (under <Route path=\\\"\" + parentPath + \"\\\">) but the \") + \"parent route path has no trailing \\\"*\\\". This means if you navigate \" + \"deeper, the parent won't match anymore and therefore the child \" + \"routes will never render.\\n\\n\" + (\"Please change the parent <Route path=\\\"\" + parentPath + \"\\\"> to <Route \") + (\"path=\\\"\" + (parentPath === \"/\" ? \"*\" : parentPath + \"/*\") + \"\\\">.\"));\n  }\n  let locationFromContext = useLocation();\n  let location;\n  if (locationArg) {\n    var _parsedLocationArg$pa;\n    let parsedLocationArg = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n    !(parentPathnameBase === \"/\" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.startsWith(parentPathnameBase))) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"When overriding the location using `<Routes location>` or `useRoutes(routes, location)`, \" + \"the location pathname must begin with the portion of the URL pathname that was \" + (\"matched by all parent routes. The current pathname base is \\\"\" + parentPathnameBase + \"\\\" \") + (\"but pathname \\\"\" + parsedLocationArg.pathname + \"\\\" was given in the `location` prop.\")) : UNSAFE_invariant(false) : void 0;\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n  let pathname = location.pathname || \"/\";\n  let remainingPathname = parentPathnameBase === \"/\" ? pathname : pathname.slice(parentPathnameBase.length) || \"/\";\n  let matches = matchRoutes(routes, {\n    pathname: remainingPathname\n  });\n  if (process.env.NODE_ENV !== \"production\") {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(parentRoute || matches != null, \"No routes matched location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \") : void 0;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(matches == null || matches[matches.length - 1].route.element !== undefined || matches[matches.length - 1].route.Component !== undefined || matches[matches.length - 1].route.lazy !== undefined, \"Matched leaf route at location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \" + \"does not have an element or Component. This means it will render an <Outlet /> with a \" + \"null value by default resulting in an \\\"empty\\\" page.\") : void 0;\n  }\n  let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {\n    params: Object.assign({}, parentParams, match.params),\n    pathname: joinPaths([parentPathnameBase,\n    // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathname).pathname : match.pathname]),\n    pathnameBase: match.pathnameBase === \"/\" ? parentPathnameBase : joinPaths([parentPathnameBase,\n    // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : match.pathnameBase])\n  })), parentMatches, dataRouterState, future);\n\n  // When a user passes in a `locationArg`, the associated routes need to\n  // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n  // to use the scoped location instead of the global location.\n  if (locationArg && renderedMatches) {\n    return /*#__PURE__*/React.createElement(LocationContext.Provider, {\n      value: {\n        location: _extends({\n          pathname: \"/\",\n          search: \"\",\n          hash: \"\",\n          state: null,\n          key: \"default\"\n        }, location),\n        navigationType: Action.Pop\n      }\n    }, renderedMatches);\n  }\n  return renderedMatches;\n}\nfunction DefaultErrorComponent() {\n  let error = useRouteError();\n  let message = isRouteErrorResponse(error) ? error.status + \" \" + error.statusText : error instanceof Error ? error.message : JSON.stringify(error);\n  let stack = error instanceof Error ? error.stack : null;\n  let lightgrey = \"rgba(200,200,200, 0.5)\";\n  let preStyles = {\n    padding: \"0.5rem\",\n    backgroundColor: lightgrey\n  };\n  let codeStyles = {\n    padding: \"2px 4px\",\n    backgroundColor: lightgrey\n  };\n  let devInfo = null;\n  if (process.env.NODE_ENV !== \"production\") {\n    console.error(\"Error handled by React Router default ErrorBoundary:\", error);\n    devInfo = /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"p\", null, \"\\uD83D\\uDCBF Hey developer \\uD83D\\uDC4B\"), /*#__PURE__*/React.createElement(\"p\", null, \"You can provide a way better UX than this when your app throws errors by providing your own \", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"ErrorBoundary\"), \" or\", \" \", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"errorElement\"), \" prop on your route.\"));\n  }\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"h2\", null, \"Unexpected Application Error!\"), /*#__PURE__*/React.createElement(\"h3\", {\n    style: {\n      fontStyle: \"italic\"\n    }\n  }, message), stack ? /*#__PURE__*/React.createElement(\"pre\", {\n    style: preStyles\n  }, stack) : null, devInfo);\n}\nconst defaultErrorElement = /*#__PURE__*/React.createElement(DefaultErrorComponent, null);\nclass RenderErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      location: props.location,\n      revalidation: props.revalidation,\n      error: props.error\n    };\n  }\n  static getDerivedStateFromError(error) {\n    return {\n      error: error\n    };\n  }\n  static getDerivedStateFromProps(props, state) {\n    // When we get into an error state, the user will likely click \"back\" to the\n    // previous page that didn't have an error. Because this wraps the entire\n    // application, that will have no effect--the error page continues to display.\n    // This gives us a mechanism to recover from the error when the location changes.\n    //\n    // Whether we're in an error state or not, we update the location in state\n    // so that when we are in an error state, it gets reset when a new location\n    // comes in and the user recovers from the error.\n    if (state.location !== props.location || state.revalidation !== \"idle\" && props.revalidation === \"idle\") {\n      return {\n        error: props.error,\n        location: props.location,\n        revalidation: props.revalidation\n      };\n    }\n\n    // If we're not changing locations, preserve the location but still surface\n    // any new errors that may come through. We retain the existing error, we do\n    // this because the error provided from the app state may be cleared without\n    // the location changing.\n    return {\n      error: props.error !== undefined ? props.error : state.error,\n      location: state.location,\n      revalidation: props.revalidation || state.revalidation\n    };\n  }\n  componentDidCatch(error, errorInfo) {\n    console.error(\"React Router caught the following error during render\", error, errorInfo);\n  }\n  render() {\n    return this.state.error !== undefined ? /*#__PURE__*/React.createElement(RouteContext.Provider, {\n      value: this.props.routeContext\n    }, /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {\n      value: this.state.error,\n      children: this.props.component\n    })) : this.props.children;\n  }\n}\nfunction RenderedRoute(_ref) {\n  let {\n    routeContext,\n    match,\n    children\n  } = _ref;\n  let dataRouterContext = React.useContext(DataRouterContext);\n\n  // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n  if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {\n    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n  }\n  return /*#__PURE__*/React.createElement(RouteContext.Provider, {\n    value: routeContext\n  }, children);\n}\nfunction _renderMatches(matches, parentMatches, dataRouterState, future) {\n  var _dataRouterState2;\n  if (parentMatches === void 0) {\n    parentMatches = [];\n  }\n  if (dataRouterState === void 0) {\n    dataRouterState = null;\n  }\n  if (future === void 0) {\n    future = null;\n  }\n  if (matches == null) {\n    var _dataRouterState;\n    if ((_dataRouterState = dataRouterState) != null && _dataRouterState.errors) {\n      // Don't bail if we have data router errors so we can render them in the\n      // boundary.  Use the pre-matched (or shimmed) matches\n      matches = dataRouterState.matches;\n    } else {\n      return null;\n    }\n  }\n  let renderedMatches = matches;\n\n  // If we have data errors, trim matches to the highest error boundary\n  let errors = (_dataRouterState2 = dataRouterState) == null ? void 0 : _dataRouterState2.errors;\n  if (errors != null) {\n    let errorIndex = renderedMatches.findIndex(m => m.route.id && (errors == null ? void 0 : errors[m.route.id]));\n    !(errorIndex >= 0) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"Could not find a matching route for errors on route IDs: \" + Object.keys(errors).join(\",\")) : UNSAFE_invariant(false) : void 0;\n    renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));\n  }\n\n  // If we're in a partial hydration mode, detect if we need to render down to\n  // a given HydrateFallback while we load the rest of the hydration data\n  let renderFallback = false;\n  let fallbackIndex = -1;\n  if (dataRouterState && future && future.v7_partialHydration) {\n    for (let i = 0; i < renderedMatches.length; i++) {\n      let match = renderedMatches[i];\n      // Track the deepest fallback up until the first route without data\n      if (match.route.HydrateFallback || match.route.hydrateFallbackElement) {\n        fallbackIndex = i;\n      }\n      if (match.route.id) {\n        let {\n          loaderData,\n          errors\n        } = dataRouterState;\n        let needsToRunLoader = match.route.loader && loaderData[match.route.id] === undefined && (!errors || errors[match.route.id] === undefined);\n        if (match.route.lazy || needsToRunLoader) {\n          // We found the first route that's not ready to render (waiting on\n          // lazy, or has a loader that hasn't run yet).  Flag that we need to\n          // render a fallback and render up until the appropriate fallback\n          renderFallback = true;\n          if (fallbackIndex >= 0) {\n            renderedMatches = renderedMatches.slice(0, fallbackIndex + 1);\n          } else {\n            renderedMatches = [renderedMatches[0]];\n          }\n          break;\n        }\n      }\n    }\n  }\n  return renderedMatches.reduceRight((outlet, match, index) => {\n    // Only data routers handle errors/fallbacks\n    let error;\n    let shouldRenderHydrateFallback = false;\n    let errorElement = null;\n    let hydrateFallbackElement = null;\n    if (dataRouterState) {\n      error = errors && match.route.id ? errors[match.route.id] : undefined;\n      errorElement = match.route.errorElement || defaultErrorElement;\n      if (renderFallback) {\n        if (fallbackIndex < 0 && index === 0) {\n          warningOnce(\"route-fallback\", false, \"No `HydrateFallback` element provided to render during initial hydration\");\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = null;\n        } else if (fallbackIndex === index) {\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = match.route.hydrateFallbackElement || null;\n        }\n      }\n    }\n    let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n    let getChildren = () => {\n      let children;\n      if (error) {\n        children = errorElement;\n      } else if (shouldRenderHydrateFallback) {\n        children = hydrateFallbackElement;\n      } else if (match.route.Component) {\n        // Note: This is a de-optimized path since React won't re-use the\n        // ReactElement since it's identity changes with each new\n        // React.createElement call.  We keep this so folks can use\n        // `<Route Component={...}>` in `<Routes>` but generally `Component`\n        // usage is only advised in `RouterProvider` when we can convert it to\n        // `element` ahead of time.\n        children = /*#__PURE__*/React.createElement(match.route.Component, null);\n      } else if (match.route.element) {\n        children = match.route.element;\n      } else {\n        children = outlet;\n      }\n      return /*#__PURE__*/React.createElement(RenderedRoute, {\n        match: match,\n        routeContext: {\n          outlet,\n          matches,\n          isDataRoute: dataRouterState != null\n        },\n        children: children\n      });\n    };\n    // Only wrap in an error boundary within data router usages when we have an\n    // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to\n    // an ancestor ErrorBoundary/errorElement\n    return dataRouterState && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {\n      location: dataRouterState.location,\n      revalidation: dataRouterState.revalidation,\n      component: errorElement,\n      error: error,\n      children: getChildren(),\n      routeContext: {\n        outlet: null,\n        matches,\n        isDataRoute: true\n      }\n    }) : getChildren();\n  }, null);\n}\nvar DataRouterHook = /*#__PURE__*/function (DataRouterHook) {\n  DataRouterHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterHook[\"UseRevalidator\"] = \"useRevalidator\";\n  DataRouterHook[\"UseNavigateStable\"] = \"useNavigate\";\n  return DataRouterHook;\n}(DataRouterHook || {});\nvar DataRouterStateHook = /*#__PURE__*/function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterStateHook[\"UseLoaderData\"] = \"useLoaderData\";\n  DataRouterStateHook[\"UseActionData\"] = \"useActionData\";\n  DataRouterStateHook[\"UseRouteError\"] = \"useRouteError\";\n  DataRouterStateHook[\"UseNavigation\"] = \"useNavigation\";\n  DataRouterStateHook[\"UseRouteLoaderData\"] = \"useRouteLoaderData\";\n  DataRouterStateHook[\"UseMatches\"] = \"useMatches\";\n  DataRouterStateHook[\"UseRevalidator\"] = \"useRevalidator\";\n  DataRouterStateHook[\"UseNavigateStable\"] = \"useNavigate\";\n  DataRouterStateHook[\"UseRouteId\"] = \"useRouteId\";\n  return DataRouterStateHook;\n}(DataRouterStateHook || {});\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.\";\n}\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\nfunction useRouteContext(hookName) {\n  let route = React.useContext(RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName) {\n  let route = useRouteContext(hookName);\n  let thisRoute = route.matches[route.matches.length - 1];\n  !thisRoute.route.id ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, hookName + \" can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nfunction useRouteId() {\n  return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nfunction useNavigation() {\n  let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n  return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nfunction useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return React.useMemo(() => ({\n    revalidate: dataRouterContext.router.revalidate,\n    state: state.revalidation\n  }), [dataRouterContext.router.revalidate, state.revalidation]);\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nfunction useMatches() {\n  let {\n    matches,\n    loaderData\n  } = useDataRouterState(DataRouterStateHook.UseMatches);\n  return React.useMemo(() => matches.map(m => UNSAFE_convertRouteMatchToUiMatch(m, loaderData)), [matches, loaderData]);\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nfunction useLoaderData() {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  if (state.errors && state.errors[routeId] != null) {\n    console.error(\"You cannot `useLoaderData` in an errorElement (routeId: \" + routeId + \")\");\n    return undefined;\n  }\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nfunction useRouteLoaderData(routeId) {\n  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nfunction useActionData() {\n  let state = useDataRouterState(DataRouterStateHook.UseActionData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  return state.actionData ? state.actionData[routeId] : undefined;\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error.  This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nfunction useRouteError() {\n  var _state$errors;\n  let error = React.useContext(RouteErrorContext);\n  let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n  // If this was a render error, we put it in a RouteError context inside\n  // of RenderErrorBoundary\n  if (error !== undefined) {\n    return error;\n  }\n\n  // Otherwise look for errors from our data router state\n  return (_state$errors = state.errors) == null ? void 0 : _state$errors[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor `<Await />` value\n */\nfunction useAsyncValue() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._data;\n}\n\n/**\n * Returns the error from the nearest ancestor `<Await />` value\n */\nfunction useAsyncError() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._error;\n}\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation.  Mostly used to avoid\n * using half-filled form data.  This does not handle hard-reloads or\n * cross-origin navigations.\n */\nfunction useBlocker(shouldBlock) {\n  let {\n    router,\n    basename\n  } = useDataRouterContext(DataRouterHook.UseBlocker);\n  let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n  let [blockerKey, setBlockerKey] = React.useState(\"\");\n  let blockerFunction = React.useCallback(arg => {\n    if (typeof shouldBlock !== \"function\") {\n      return !!shouldBlock;\n    }\n    if (basename === \"/\") {\n      return shouldBlock(arg);\n    }\n\n    // If they provided us a function and we've got an active basename, strip\n    // it from the locations we expose to the user to match the behavior of\n    // useLocation\n    let {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = arg;\n    return shouldBlock({\n      currentLocation: _extends({}, currentLocation, {\n        pathname: stripBasename(currentLocation.pathname, basename) || currentLocation.pathname\n      }),\n      nextLocation: _extends({}, nextLocation, {\n        pathname: stripBasename(nextLocation.pathname, basename) || nextLocation.pathname\n      }),\n      historyAction\n    });\n  }, [basename, shouldBlock]);\n\n  // This effect is in charge of blocker key assignment and deletion (which is\n  // tightly coupled to the key)\n  React.useEffect(() => {\n    let key = String(++blockerId);\n    setBlockerKey(key);\n    return () => router.deleteBlocker(key);\n  }, [router]);\n\n  // This effect handles assigning the blockerFunction.  This is to handle\n  // unstable blocker function identities, and happens only after the prior\n  // effect so we don't get an orphaned blockerFunction in the router with a\n  // key of \"\".  Until then we just have the IDLE_BLOCKER.\n  React.useEffect(() => {\n    if (blockerKey !== \"\") {\n      router.getBlocker(blockerKey, blockerFunction);\n    }\n  }, [router, blockerKey, blockerFunction]);\n\n  // Prefer the blocker from `state` not `router.state` since DataRouterContext\n  // is memoized so this ensures we update on blocker state updates\n  return blockerKey && state.blockers.has(blockerKey) ? state.blockers.get(blockerKey) : IDLE_BLOCKER;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable() {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n  let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(activeRef.current, navigateEffectWarning) : void 0;\n\n    // Short circuit here since if this happens on first render the navigate\n    // is useless because we haven't wired up our router subscriber yet\n    if (!activeRef.current) return;\n    if (typeof to === \"number\") {\n      router.navigate(to);\n    } else {\n      router.navigate(to, _extends({\n        fromRouteId: id\n      }, options));\n    }\n  }, [router, id]);\n  return navigate;\n}\nconst alreadyWarned = {};\nfunction warningOnce(key, cond, message) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, message) : void 0;\n  }\n}\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nfunction RouterProvider(_ref) {\n  let {\n    fallbackElement,\n    router,\n    future\n  } = _ref;\n  let [state, setStateImpl] = React.useState(router.state);\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    if (v7_startTransition && startTransitionImpl) {\n      startTransitionImpl(() => setStateImpl(newState));\n    } else {\n      setStateImpl(newState);\n    }\n  }, [setStateImpl, v7_startTransition]);\n\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n  React.useEffect(() => {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(fallbackElement == null || !router.future.v7_partialHydration, \"`<RouterProvider fallbackElement>` is deprecated when using \" + \"`v7_partialHydration`, use a `HydrateFallback` component instead\") : void 0;\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: n => router.navigate(n),\n      push: (to, state, opts) => router.navigate(to, {\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      }),\n      replace: (to, state, opts) => router.navigate(to, {\n        replace: true,\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      })\n    };\n  }, [router]);\n  let basename = router.basename || \"/\";\n  let dataRouterContext = React.useMemo(() => ({\n    router,\n    navigator,\n    static: false,\n    basename\n  }), [router, navigator, basename]);\n\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(DataRouterContext.Provider, {\n    value: dataRouterContext\n  }, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    location: state.location,\n    navigationType: state.historyAction,\n    navigator: navigator,\n    future: {\n      v7_relativeSplatPath: router.future.v7_relativeSplatPath\n    }\n  }, state.initialized || router.future.v7_partialHydration ? /*#__PURE__*/React.createElement(DataRoutes, {\n    routes: router.routes,\n    future: router.future,\n    state: state\n  }) : fallbackElement))), null);\n}\nfunction DataRoutes(_ref2) {\n  let {\n    routes,\n    future,\n    state\n  } = _ref2;\n  return useRoutesImpl(routes, undefined, state, future);\n}\n/**\n * A `<Router>` that stores all entries in memory.\n *\n * @see https://reactrouter.com/router-components/memory-router\n */\nfunction MemoryRouter(_ref3) {\n  let {\n    basename,\n    children,\n    initialEntries,\n    initialIndex,\n    future\n  } = _ref3;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history,\n    future: future\n  });\n}\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/components/navigate\n */\nfunction Navigate(_ref4) {\n  let {\n    to,\n    replace,\n    state,\n    relative\n  } = _ref4;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // TODO: This error is probably because they somehow have 2 versions of\n  // the router loaded. We can help them understand how to avoid that.\n  \"<Navigate> may be used only in the context of a <Router> component.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    future,\n    static: isStatic\n  } = React.useContext(NavigationContext);\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(!isStatic, \"<Navigate> must not be used on the initial render in a <StaticRouter>. \" + \"This is a no-op, but you should modify your code so the <Navigate> is \" + \"only ever rendered in response to some user interaction or state change.\") : void 0;\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let navigate = useNavigate();\n\n  // Resolve the path outside of the effect so that when effects run twice in\n  // StrictMode they navigate to the same place\n  let path = resolveTo(to, UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath), locationPathname, relative === \"path\");\n  let jsonPath = JSON.stringify(path);\n  React.useEffect(() => navigate(JSON.parse(jsonPath), {\n    replace,\n    state,\n    relative\n  }), [navigate, jsonPath, relative, replace, state]);\n  return null;\n}\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/components/outlet\n */\nfunction Outlet(props) {\n  return useOutlet(props.context);\n}\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/components/route\n */\nfunction Route(_props) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"A <Route> is only ever to be used as the child of <Routes> element, \" + \"never rendered directly. Please wrap your <Route> in a <Routes>.\") : UNSAFE_invariant(false) ;\n}\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a `<Router>` directly. Instead, you'll render a\n * router that is more specific to your environment such as a `<BrowserRouter>`\n * in web browsers or a `<StaticRouter>` for server rendering.\n *\n * @see https://reactrouter.com/router-components/router\n */\nfunction Router(_ref5) {\n  let {\n    basename: basenameProp = \"/\",\n    children = null,\n    location: locationProp,\n    navigationType = Action.Pop,\n    navigator,\n    static: staticProp = false,\n    future\n  } = _ref5;\n  !!useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"You cannot render a <Router> inside another <Router>.\" + \" You should never have more than one in your app.\") : UNSAFE_invariant(false) : void 0;\n\n  // Preserve trailing slashes on basename, so we can let the user control\n  // the enforcement of trailing slashes throughout the app\n  let basename = basenameProp.replace(/^\\/*/, \"/\");\n  let navigationContext = React.useMemo(() => ({\n    basename,\n    navigator,\n    static: staticProp,\n    future: _extends({\n      v7_relativeSplatPath: false\n    }, future)\n  }), [basename, future, navigator, staticProp]);\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\"\n  } = locationProp;\n  let locationContext = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n    if (trailingPathname == null) {\n      return null;\n    }\n    return {\n      location: {\n        pathname: trailingPathname,\n        search,\n        hash,\n        state,\n        key\n      },\n      navigationType\n    };\n  }, [basename, pathname, search, hash, state, key, navigationType]);\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(locationContext != null, \"<Router basename=\\\"\" + basename + \"\\\"> is not able to match the URL \" + (\"\\\"\" + pathname + search + hash + \"\\\" because it does not start with the \") + \"basename, so the <Router> won't render anything.\") : void 0;\n  if (locationContext == null) {\n    return null;\n  }\n  return /*#__PURE__*/React.createElement(NavigationContext.Provider, {\n    value: navigationContext\n  }, /*#__PURE__*/React.createElement(LocationContext.Provider, {\n    children: children,\n    value: locationContext\n  }));\n}\n/**\n * A container for a nested tree of `<Route>` elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/components/routes\n */\nfunction Routes(_ref6) {\n  let {\n    children,\n    location\n  } = _ref6;\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nfunction Await(_ref7) {\n  let {\n    children,\n    errorElement,\n    resolve\n  } = _ref7;\n  return /*#__PURE__*/React.createElement(AwaitErrorBoundary, {\n    resolve: resolve,\n    errorElement: errorElement\n  }, /*#__PURE__*/React.createElement(ResolveAwait, null, children));\n}\nvar AwaitRenderStatus = /*#__PURE__*/function (AwaitRenderStatus) {\n  AwaitRenderStatus[AwaitRenderStatus[\"pending\"] = 0] = \"pending\";\n  AwaitRenderStatus[AwaitRenderStatus[\"success\"] = 1] = \"success\";\n  AwaitRenderStatus[AwaitRenderStatus[\"error\"] = 2] = \"error\";\n  return AwaitRenderStatus;\n}(AwaitRenderStatus || {});\nconst neverSettledPromise = new Promise(() => {});\nclass AwaitErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      error: null\n    };\n  }\n  static getDerivedStateFromError(error) {\n    return {\n      error\n    };\n  }\n  componentDidCatch(error, errorInfo) {\n    console.error(\"<Await> caught the following error during render\", error, errorInfo);\n  }\n  render() {\n    let {\n      children,\n      errorElement,\n      resolve\n    } = this.props;\n    let promise = null;\n    let status = AwaitRenderStatus.pending;\n    if (!(resolve instanceof Promise)) {\n      // Didn't get a promise - provide as a resolved promise\n      status = AwaitRenderStatus.success;\n      promise = Promise.resolve();\n      Object.defineProperty(promise, \"_tracked\", {\n        get: () => true\n      });\n      Object.defineProperty(promise, \"_data\", {\n        get: () => resolve\n      });\n    } else if (this.state.error) {\n      // Caught a render error, provide it as a rejected promise\n      status = AwaitRenderStatus.error;\n      let renderError = this.state.error;\n      promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings\n      Object.defineProperty(promise, \"_tracked\", {\n        get: () => true\n      });\n      Object.defineProperty(promise, \"_error\", {\n        get: () => renderError\n      });\n    } else if (resolve._tracked) {\n      // Already tracked promise - check contents\n      promise = resolve;\n      status = promise._error !== undefined ? AwaitRenderStatus.error : promise._data !== undefined ? AwaitRenderStatus.success : AwaitRenderStatus.pending;\n    } else {\n      // Raw (untracked) promise - track it\n      status = AwaitRenderStatus.pending;\n      Object.defineProperty(resolve, \"_tracked\", {\n        get: () => true\n      });\n      promise = resolve.then(data => Object.defineProperty(resolve, \"_data\", {\n        get: () => data\n      }), error => Object.defineProperty(resolve, \"_error\", {\n        get: () => error\n      }));\n    }\n    if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\n    if (status === AwaitRenderStatus.error) {\n      // Render via our errorElement\n      return /*#__PURE__*/React.createElement(AwaitContext.Provider, {\n        value: promise,\n        children: errorElement\n      });\n    }\n    if (status === AwaitRenderStatus.success) {\n      // Render children with resolved value\n      return /*#__PURE__*/React.createElement(AwaitContext.Provider, {\n        value: promise,\n        children: children\n      });\n    }\n\n    // Throw to the suspense boundary\n    throw promise;\n  }\n}\n\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on `<Await>`\n */\nfunction ResolveAwait(_ref8) {\n  let {\n    children\n  } = _ref8;\n  let data = useAsyncValue();\n  let toRender = typeof children === \"function\" ? children(data) : children;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, toRender);\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/utils/create-routes-from-children\n */\nfunction createRoutesFromChildren(children, parentPath) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  let routes = [];\n  React.Children.forEach(children, (element, index) => {\n    if (! /*#__PURE__*/React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n    let treePath = [...parentPath, index];\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(routes, createRoutesFromChildren(element.props.children, treePath));\n      return;\n    }\n    !(element.type === Route) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"[\" + (typeof element.type === \"string\" ? element.type : element.type.name) + \"] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>\") : UNSAFE_invariant(false) : void 0;\n    !(!element.props.index || !element.props.children) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"An index route cannot have child routes.\") : UNSAFE_invariant(false) : void 0;\n    let route = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      Component: element.props.Component,\n      index: element.props.index,\n      path: element.props.path,\n      loader: element.props.loader,\n      action: element.props.action,\n      errorElement: element.props.errorElement,\n      ErrorBoundary: element.props.ErrorBoundary,\n      hasErrorBoundary: element.props.ErrorBoundary != null || element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle,\n      lazy: element.props.lazy\n    };\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children, treePath);\n    }\n    routes.push(route);\n  });\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nfunction renderMatches(matches) {\n  return _renderMatches(matches);\n}\n\nfunction mapRouteProperties(route) {\n  let updates = {\n    // Note: this check also occurs in createRoutesFromChildren so update\n    // there if you change this -- please and thank you!\n    hasErrorBoundary: route.ErrorBoundary != null || route.errorElement != null\n  };\n  if (route.Component) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.element) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `Component` and `element` on your route - \" + \"`Component` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      element: /*#__PURE__*/React.createElement(route.Component),\n      Component: undefined\n    });\n  }\n  if (route.HydrateFallback) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.hydrateFallbackElement) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `HydrateFallback` and `hydrateFallbackElement` on your route - \" + \"`HydrateFallback` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      hydrateFallbackElement: /*#__PURE__*/React.createElement(route.HydrateFallback),\n      HydrateFallback: undefined\n    });\n  }\n  if (route.ErrorBoundary) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.errorElement) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `ErrorBoundary` and `errorElement` on your route - \" + \"`ErrorBoundary` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      errorElement: /*#__PURE__*/React.createElement(route.ErrorBoundary),\n      ErrorBoundary: undefined\n    });\n  }\n  return updates;\n}\nfunction createMemoryRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createMemoryHistory({\n      initialEntries: opts == null ? void 0 : opts.initialEntries,\n      initialIndex: opts == null ? void 0 : opts.initialIndex\n    }),\n    hydrationData: opts == null ? void 0 : opts.hydrationData,\n    routes,\n    mapRouteProperties\n  }).initialize();\n}\n\nexport { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, mapRouteProperties as UNSAFE_mapRouteProperties, useRouteId as UNSAFE_useRouteId, useRoutesImpl as UNSAFE_useRoutesImpl, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };\n//# sourceMappingURL=index.js.map\n","/** @license React v17.0.2\n * react-jsx-runtime.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\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'use strict';require(\"object-assign\");var f=require(\"react\"),g=60103;exports.Fragment=60107;if(\"function\"===typeof Symbol&&Symbol.for){var h=Symbol.for;g=h(\"react.element\");exports.Fragment=h(\"react.fragment\")}var m=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,n=Object.prototype.hasOwnProperty,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,k){var b,d={},e=null,l=null;void 0!==k&&(e=\"\"+k);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(l=a.ref);for(b in a)n.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:g,type:c,key:e,ref:l,props:d,_owner:m.current}}exports.jsx=q;exports.jsxs=q;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n  module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n"],"names":["_extends","Object","assign","bind","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","Action","PopStateEventType","createBrowserHistory","options","getLocation","createHref","validateLocation","window","document","defaultView","v5Compat","globalHistory","history","action","Pop","listener","index","getIndex","state","idx","handlePop","nextIndex","delta","location","createURL","to","base","origin","href","createPath","invariant","URL","replaceState","pathname","search","hash","createLocation","usr","listen","fn","Error","addEventListener","removeEventListener","encodeLocation","url","push","Push","historyState","getHistoryState","pushState","error","DOMException","name","replace","Replace","go","n","getUrlBasedHistory","value","message","current","parsePath","Math","random","toString","substr","_ref","charAt","path","parsedPath","hashIndex","indexOf","searchIndex","ResultType","stripBasename","basename","toLowerCase","startsWith","startIndex","endsWith","nextChar","slice","Set","AbortedDeferredError","validMutationMethodsArr","validRequestMethodsArr","Symbol","hasOwn","classNames","classes","arg","argType","Array","isArray","inner","includes","join","module","exports","default","DESCRIPTORS","$TypeError","TypeError","getOwnPropertyDescriptor","SILENT_ON_NON_WRITABLE_LENGTH_SET","undefined","defineProperty","writable","O","anObject","iteratorClose","iterator","ENTRIES","done","defineBuiltIn","src","it","classof","argument","create","createNonEnumerableProperty","defineBuiltIns","wellKnownSymbol","InternalStateModule","getMethod","IteratorPrototype","createIterResultObject","TO_STRING_TAG","ITERATOR_HELPER","WRAP_FOR_VALID_ITERATOR","setInternalState","set","createIteratorProxyPrototype","IS_ITERATOR","getInternalState","getterFor","next","nextHandler","result","returnMethod","WrapForValidIteratorPrototype","IteratorHelperPrototype","IteratorProxy","record","type","counter","aCallable","getIteratorDirect","createIteratorProxy","callWithSafeIterationClosing","mapper","$","toObject","lengthOfArrayLike","setArrayLength","doesNotExceedSafeInteger","proto","arity","forced","fails","properErrorOnNonWritableLength","item","len","argCount","predicate","real","filter","iterate","forEach","IS_RECORD","map","some","stop","INTERRUPTED","stopped","baseKeys","getTag","isArguments","isArrayLike","isBuffer","isPrototype","isTypedArray","splice","tag","size","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","props","propName","componentName","propFullName","secret","err","getShim","isRequired","ReactPropTypes","array","bigint","bool","func","number","object","string","symbol","any","arrayOf","element","elementType","instanceOf","node","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","_classCallCheck","a","_defineProperties","e","r","t","o","enumerable","configurable","toPropertyKey","_createClass","_setPrototypeOf","setPrototypeOf","__proto__","_inherits","constructor","_getPrototypeOf","getPrototypeOf","_isNativeReflectConstruct","Boolean","valueOf","Reflect","construct","_assertThisInitialized","ReferenceError","_createSuper","s","warned","preWarningFns","warning","valid","note","method","warningOnce","preMessage","resetWarned","noteOnce","_ref2","className","included","vertical","style","offset","reverse","abs","positonStyle","concat","elStyle","objectWithoutPropertiesLoose","getOwnPropertySymbols","propertyIsEnumerable","_arrayLikeToArray","_unsupportedIterableToArray","from","test","_get","get","p","addEventListenerWrap","eventType","cb","option","callback","remove","prefixCls","marks","dots","step","lowerBound","upperBound","max","min","dotStyle","activeDotStyle","range","elements","points","keys","parseFloat","sort","b","calcPoints","point","_classNames","isActived","pointClassName","onClickLabel","marksKeys","markPoint","markPointIsObject","markLabel","label","isActive","markClassName","bottomStyle","marginBottom","leftStyle","transform","msTransform","markStyle","onMouseDown","onTouchStart","Handle","_React$Component","_super","_this","clickFocused","setHandleRef","handle","handleMouseUp","activeElement","setClickFocus","handleMouseDown","preventDefault","focus","handleBlur","handleKeyDown","onMouseUpListener","focused","setState","blur","ariaValueText","_this$props","disabled","tabIndex","ariaLabel","ariaLabelledBy","ariaValueTextFormatter","restProps","positionStyle","mergedTabIndex","ref","onBlur","onKeyDown","role","KeyCode","MAC_ENTER","BACKSPACE","TAB","NUM_CENTER","ENTER","SHIFT","CTRL","ALT","PAUSE","CAPS_LOCK","ESC","SPACE","PAGE_UP","PAGE_DOWN","END","HOME","LEFT","UP","RIGHT","DOWN","PRINT_SCREEN","INSERT","DELETE","ZERO","ONE","TWO","THREE","FOUR","FIVE","SIX","SEVEN","EIGHT","NINE","QUESTION_MARK","A","B","C","D","E","F","G","H","I","J","K","L","M","N","P","Q","R","S","T","U","V","W","X","Y","Z","META","WIN_KEY_RIGHT","CONTEXT_MENU","NUM_ZERO","NUM_ONE","NUM_TWO","NUM_THREE","NUM_FOUR","NUM_FIVE","NUM_SIX","NUM_SEVEN","NUM_EIGHT","NUM_NINE","NUM_MULTIPLY","NUM_PLUS","NUM_MINUS","NUM_PERIOD","NUM_DIVISION","F1","F2","F3","F4","F5","F6","F7","F8","F9","F10","F11","F12","NUMLOCK","SEMICOLON","DASH","EQUALS","COMMA","PERIOD","SLASH","APOSTROPHE","SINGLE_QUOTE","OPEN_SQUARE_BRACKET","BACKSLASH","CLOSE_SQUARE_BRACKET","WIN_KEY","MAC_FF_META","WIN_IME","isTextModifyingKeyEvent","keyCode","altKey","ctrlKey","metaKey","isCharacterKey","navigator","userAgent","isEventFromHandle","handles","findDOMNode","isValueOutOfRange","isNotTouchEvent","touches","getClosestPoint","val","baseNum","pow","getPrecision","maxSteps","floor","steps","closestStep","round","diffs","stepString","precision","getMousePosition","clientY","pageX","getTouchPosition","getHandleCenterPosition","coords","getBoundingClientRect","top","height","pageXOffset","left","width","ensureValueInRange","_ref3","ensureValuePrecision","closestPoint","isFinite","toFixed","pauseEvent","stopPropagation","getKeyboardValueMutator","increase","decrease","operations","indexToGet","JSON","stringify","keyToGet","calculateNextValue","noop","createSlider","Component","_a","_Component","ComponentEnhancer","onDown","position","draggableTrack","isVertical","bounds","positionGetValue","inPoint","handlesRefs","dragTrack","v","c","dragOffset","startBounds","handlePosition","onStart","button","removeDocumentEvents","addDocumentMouseEvents","addDocumentTouchEvents","onFocus","_this$props2","onEnd","onMouseUp","prevMovedHandleIndex","clickFocus","onMouseMove","sliderRef","onMove","onTouchMove","onKeyboard","onClickMarkLabel","onChange","saveSlider","slider","isPointDiffEven","ownerDocument","_this$props3","autoFocus","_this$props4","rect","bottom","right","onTouchMoveListener","onTouchUpListener","onMouseMoveListener","_this$handlesRefs$","_this2","_this2$handlesRefs$ke","_this2$handlesRefs$ke2","_this$props5","ratio","getSliderLength","pixelOffset","getSliderStart","trimAlignValue","calcValue","_this$props6","_this$props7","children","maximumTrackStyle","railStyle","_get$call","tracks","sliderClassName","getLowerBound","getUpperBound","displayName","defaultProps","dragging","onBeforeChange","onAfterChange","trackStyle","handleStyle","Slider","force","getValue","defaultValue","h","prevProps","prevState","theValue","nextValue","isNotControlled","nextState","changedValue","prevValue","calcValueByPos","startValue","startPosition","oldValue","valueMutator","mutatedValue","minPoint","startPoint","nextProps","mergedProps","minimumTrackStyle","ariaLabelForHandle","ariaLabelledByForHandle","ariaValueTextFormatterForHandle","handleGenerator","_this$state","calcOffset","saveHandle","trackOffset","mergedTrackStyle","_trimAlignValue","allowCross","pushable","thershold","Number","valInRange","valNotConflict","Range","closestBound","getClosestBound","getBoundNeedMoving","nextBounds","count","initialValue","recent","currentValue","controlledState","maxValue","minValue","pos","moveTo","boundNeedMoving","isAtTheSamePoint","cache","internalPointsCache","pointsObject","isFromKeyboardEvent","_this3","nextHandle","pushSurroundingHandles","threshold","direction","diffToNext","pushHandle","amount","originalValue","pushHandleOnePoint","getPoints","nextPointIndex","_this$state2","_this4","_this$state3","ariaLabelGroupForHandles","ariaLabelledByGroupForHandles","ariaValueTextFormatterGroupForHandles","offsets","handleClassName","_","_classNames2","trackClassName","every","raf","setTimeout","caf","num","clearTimeout","requestAnimationFrame","cancelAnimationFrame","rafUUID","rafIds","Map","cleanup","id","delete","wrapperRaf","callRef","leftTimes","realId","cancel","contains","root","parentNode","isDOM","HTMLElement","SVGElement","_ReactDOM$findDOMNode","domNode","nativeElement","getDOM","fillRef","composeRef","_len","refs","_key","refList","supportRef","nodeOrComponent","_type$prototype","_nodeOrComponent$prot","isMemo","render","$$typeof","ForwardRef","canUseDom","createElement","version","split","forwardRef","didUpdate","getContainer","parentRef","useRef","containerRef","useImperativeHandle","initRef","useEffect","appendChild","_containerRef$current","removeChild","isPointsEq","a1","a2","isAlignPoint","l","u","f","Context","DomWrapper","fnRef","memoFn","_fnRef$current","args","useInternalLayoutEffect","deps","firstMountRef","useSafeState","destroyRef","_React$useState2","setValue","updater","ignoreDestroy","ownKeys","STATUS_NONE","STATUS_APPEAR","STATUS_ENTER","STATUS_LEAVE","STEP_NONE","STEP_PREPARE","STEP_START","STEP_ACTIVE","STEP_ACTIVATED","STEP_PREPARED","makePrefixMap","styleProp","eventName","prefixes","domSupport","win","vendorPrefixes","animationend","transitionend","animation","transition","_document$createEleme","prefixedEventNames","getVendorPrefixedEventName","prefixMap","stylePropList","internalAnimationEndName","internalTransitionEndName","supportTransition","animationEndName","transitionEndName","getTransitionName","transitionName","transitionType","match","toUpperCase","useLayoutEffect","FULL_STEP_QUEUE","SIMPLE_STEP_QUEUE","SkipStep","config","transitionSupport","CSSMotion","_props$visible","visible","_props$removeOnLeave","removeOnLeave","forceRender","motionName","leavedClassName","eventProps","supportMotion","contextMotion","isSupportTransition","motion","nodeRef","wrapperNodeRef","_useStatus2","getElement","forceUpdate","currentValueRef","_ref$motionEnter","motionEnter","_ref$motionAppear","motionAppear","_ref$motionLeave","motionLeave","motionDeadline","motionLeaveImmediately","onAppearPrepare","onEnterPrepare","onLeavePrepare","onAppearStart","onEnterStart","onLeaveStart","onAppearActive","onEnterActive","onLeaveActive","onAppearEnd","onEnterEnd","onLeaveEnd","onVisibleChanged","_useState2","asyncVisible","setAsyncVisible","_useSyncState","x","_useSyncState2","getStatus","setStatus","_useState4","setStyle","currentStatus","mountedRef","deadlineRef","getDomElement","activeRef","updateMotionEndStatus","onInternalMotionEnd","event","status","deadline","canEnd","currentActive","patchMotionEvents","cacheElementRef","removeMotionEvents","useDomMotionEvents","getEventHandlers","targetStatus","eventHandlers","_useStepQueue2","prepareOnly","setStep","_useNextFrame","nextFrameRef","cancelNextFrame","nextFrame","delay","nextFrameId","isCanceled","useNextFrame","_useNextFrame2","STEP_QUEUE","nextStep","info","doNext","Promise","resolve","then","useStepQueue","newStep","onPrepare","_eventHandlers$step","startStep","active","nextStatus","isMounted","nextEventHandlers","firstMountChangeRef","mergedStyle","useStatus","statusStep","statusStyle","mergedVisible","renderedRef","motionChildren","setNodeRef","display","statusSuffix","motionCls","STATUS_ADD","STATUS_KEEP","STATUS_REMOVE","STATUS_REMOVED","wrapKeyToObject","keyObj","String","parseKeys","_excluded2","MOTION_PROP_NAMES","CSSMotionList","keyEntities","removeKey","entity","onAllRemoved","component","_onVisibleChanged","motionProps","prop","changedVisible","_ref4","parsedKeyObjects","mixedKeyEntities","prevKeys","currentKeys","list","currentIndex","currentLen","prevKeyObjects","currentKeyObjects","hit","currentKeyObj","obj","matchKey","diffKeys","prevEntity","find","_ref5","vendorPrefix","getMotion","Mask","zIndex","mask","maskMotion","maskAnimation","maskTransitionName","enumerableOnly","symbols","sym","_objectSpread2","_defineProperty","getOwnPropertyDescriptors","defineProperties","jsCssMap","Webkit","Moz","ms","getVendorPrefix","getTransformName","setTransitionProperty","transitionProperty","setTransform","getComputedStyleX","matrix2d","matrix3d","forceRelayout","elem","originalStyle","offsetHeight","css","el","getScroll","w","ret","d","documentElement","body","getScrollLeft","getScrollTop","getOffset","box","y","doc","docElem","clientLeft","clientTop","getClientPosition","parentWindow","isWindow","getDocument","nodeType","_RE_NUM_NO_PX","RegExp","RE_POS","CURRENT_STYLE","RUNTIME_STYLE","getOffsetDirection","dir","useCssRight","useCssBottom","oppositeOffsetDirection","setLeftTop","presetH","presetV","horizontalProperty","verticalProperty","oppositeHorizontalProperty","oppositeVerticalProperty","originalTransition","originalOffset","old","preset","off","_dir","_off","each","arr","isBorderBoxFn","getComputedStyle","cs","computedStyle","getPropertyValue","rsLeft","pixelLeft","BOX_MODELS","getPBMWidth","which","j","cssProp","domUtils","getParent","parent","host","getWH","ex","extra","viewportWidth","viewportHeight","docWidth","docHeight","borderBoxValue","isBorderBox","cssBoxValue","borderBoxValueOrIsBorderBox","refWin","documentElementProp","compatMode","cssShow","visibility","getWHIgnoreDisplay","_key2","offsetWidth","swap","mix","first","includeMargin","utils","getWindow","ignoreShake","oriOffset","oLeft","oTop","tLeft","tTop","useCssTransform","originalXY","matrix","getTransformXY","resultXY","xy","match2d","setTransformXY","setTransform$1","setOffset","clone","overflow","getWindowScrollLeft","getWindowScrollTop","merge","getOffsetParent","nodeName","getParent$1","getVisibleRectForElement","alwaysByViewport","visibleRect","Infinity","clientWidth","clientHeight","originalPosition","scrollX","scrollY","documentWidth","scrollWidth","documentHeight","scrollHeight","bodyStyle","overflowX","innerWidth","overflowY","innerHeight","isAncestorFixed","maxVisibleWidth","maxVisibleHeight","getRegion","outerWidth","outerHeight","getAlignOffset","region","align","getElFuturePos","elRegion","refNodeRegion","targetOffset","p1","p2","diff","isFailX","elFuturePos","isFailY","flip","reg","m","flipOffset","convertOffset","str","offsetLen","parseInt","substring","normalizeOffset","doAlign","tgtRegion","isTgtRegionVisible","newOverflowCfg","fail","newElRegion","adjustX","adjustY","newPoints","newOffset","newTargetOffset","isCompleteFailX","_newPoints","_newOffset","_newTargetOffset","isCompleteFailY","isStillFailX","isStillFailY","_newPoints2","resizeWidth","resizeHeight","adjustForViewport","alignElement","refNode","isTargetNotOutOfVisible","targetRegion","isOutOfVisibleRect","__getOffsetParent","__getVisibleRectForElement","MapShim","entry","class_1","__entries__","entries","has","clear","ctx","_i","isBrowser","global$1","g","self","Function","requestAnimationFrame$1","Date","now","transitionKeys","mutationObserverSupported","MutationObserver","ResizeObserverController","connected_","mutationEventsAdded_","mutationsObserver_","observers_","onTransitionEnd_","refresh","leadingCall","trailingCall","lastCallTime","resolvePending","proxy","timeoutCallback","timeStamp","throttle","addObserver","observer","connect_","removeObserver","observers","disconnect_","updateObservers_","activeObservers","gatherActive","hasActive","broadcastActive","observe","attributes","childList","characterData","subtree","disconnect","_b","propertyName","getInstance","instance_","defineConfigurable","getWindowOf","emptyRect","createRectInit","toFloat","getBordersSize","styles","positions","reduce","isSVGGraphicsElement","SVGGraphicsElement","getBBox","ResizeObservation","broadcastWidth","broadcastHeight","contentRect_","bbox","getSVGContentRect","paddings","positions_1","getPaddings","horizPad","vertPad","boxSizing","isDocumentElement","vertScrollbar","horizScrollbar","getHTMLElementContentRect","broadcastRect","ResizeObserverEntry","rectInit","Constr","contentRect","DOMRectReadOnly","ResizeObserverSPI","controller","callbackCtx","activeObservations_","observations_","callback_","controller_","callbackCtx_","Element","observations","unobserve","clearActive","observation","WeakMap","ResizeObserver","monitorResize","prevWidth","prevHeight","resizeObserver","_target$getBoundingCl","fixedWidth","fixedHeight","getPoint","Align","onAlign","monitorWindowResize","_ref$monitorBufferTim","monitorBufferTime","cacheRef","childNode","only","forceAlignPropsRef","_useBuffer","buffer","calledRef","timeoutRef","cancelTrigger","trigger","_forceAlignPropsRef$c","latestDisabled","latestTarget","latestAlign","latestOnAlign","_result","_element","_point","offsetParent","_getBBox","_element$getBoundingC","_width","_height","isVisible","tgtPoint","pageY","clientX","pointInView","alignPoint","container","restoreFocus","useBuffer","_useBuffer2","_forceAlign","cancelForceAlign","setElement","_React$useState4","setPoint","prev","obj1","obj2","shallow","refSet","deepEqual","level","circular","add","newLevel","forceAlign","RcAlign","_regeneratorRuntime","asyncIterator","toStringTag","define","wrap","Generator","makeInvokeMethod","tryCatch","GeneratorFunction","GeneratorFunctionPrototype","values","defineIteratorMethods","_invoke","AsyncIterator","invoke","__await","callInvokeWithMethodAndArg","delegate","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","resultName","nextLoc","pushTryEntry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","isNaN","isGeneratorFunction","mark","awrap","async","pop","rval","complete","finish","delegateYield","asyncGeneratorStep","_asyncToGenerator","_next","_throw","StatusQueue","PopupInner","stretch","destroyPopupOnHide","getRootDomNode","getClassNameFromAlign","onMouseEnter","onMouseLeave","onClick","alignRef","elementRef","useState","alignedClassName","setAlignedClassName","_useStretchStyle","targetSize","setTargetSize","sizeStyle","minHeight","minWidth","tgtWidth","tgtHeight","useStretchStyle","_useStretchStyle2","stretchStyle","measureStretchStyle","_useVisibleStatus","setInternalStatus","rafRef","cancelRaf","_callee","_context","useVisibleStatus","_useVisibleStatus2","goNextStatus","alignTimes","setAlignTimes","prepareResolveRef","_alignRef$current","onInternalAlign","popupDomNode","matchAlign","nextAlignedClassName","_prepareResolveRef$cu","onShowPrepare","originHandler","opacity","pointerEvents","alignDisabled","motionRef","motionClassName","motionStyle","mergedClassName","onMouseDownCapture","onTouchStartCapture","MobilePopupInner","_props$mobile","mobile","popupClassName","popupStyle","_props$mobile$popupMo","popupMotion","popupRender","Popup","innerVisible","serInnerVisible","inMobile","setInMobile","cloneProps","agent","vendor","opera","isMobile","popupNode","PortalComponent","Trigger","ALL_HANDLERS","_popupVisible","mouseEnterDelay","fireEvents","delaySetPopupVisible","mouseLeaveDelay","clearDelayTimer","_this$popupRef$curren","relatedTarget","popupRef","isFocusToShow","focusTime","focusDelay","preClickTime","preTouchTime","isBlurToHide","blurDelay","setPopupVisible","isContextMenuToShow","close","preTime","isClickToShow","isClickToHide","nextVisible","popupVisible","_this$context","hasPopupMouseDown","mouseDownTimeout","context","onPopupMouseDown","maskClosable","getPopupDomNode","isContextMenuOnly","getTriggerDOMNode","triggerRef","popupPlacement","builtinPlacements","getPopupClassNameFromAlign","placements","placement","getAlignPopupClassName","onPopupAlign","popupAnimation","popupTransitionName","popup","onPopupClick","getPopupAlign","mouseProps","isMouseEnterToShow","onPopupMouseEnter","isMouseLeaveToHide","onPopupMouseLeave","popupContainer","attachId","mountNode","getPopupContainer","attachParent","portalContainer","prevPopupVisible","afterPopupVisibleChange","defaultPopupVisible","componentDidUpdate","currentDocument","clickOutsideHandler","onDocumentClick","touchOutsideHandler","contextMenuOutsideHandler1","onContextMenuClose","contextMenuOutsideHandler2","clearOutsideHandler","_this$popupRef$curren2","popupAlign","placementStr","baseAlign","getAlignFromPlacement","onPopupVisibleChange","delayS","delayTimer","childPros","showAction","hideAction","_this$props8","_this$props9","_this$props10","_this$popupRef$curren3","childCallback","_this$props11","autoDestroy","child","newChildProps","onContextMenu","createTwoChains","childrenClassName","portal","handlePortalUpdate","getComponent","Provider","triggerContextValue","newState","autoAdjustOverflow","topLeft","leftTop","topRight","rightTop","bottomRight","rightBottom","bottomLeft","leftBottom","showArrow","arrowContent","overlayInnerStyle","Tooltip","overlayClassName","_props$trigger","_props$mouseEnterDela","_props$mouseLeaveDela","overlayStyle","_props$prefixCls","onVisibleChange","afterVisibleChange","_props$placement","_props$align","_props$destroyTooltip","destroyTooltipOnHide","defaultVisible","getTooltipContainer","overlay","_props$showArrow","domRef","extraProps","destroyTooltip","keepParent","innerRef","tooltipRef","cancelKeepAlign","_innerRef$current","forcePopupAlign","InternalSlider","createSliderWithTooltip","ComponentWrapper","visibles","handleTooltipVisibleChange","handleWithTooltip","handleStyleWithIndex","tipFormatter","tipProps","_tipProps$prefixCls","_tipProps$overlay","_tipProps$placement","_tipProps$visible","restTooltipProps","createSearchParams","init","URLSearchParams","memo","startTransitionImpl","BrowserRouter","future","historyRef","setStateImpl","v7_startTransition","navigationType","DataRouterHook","DataRouterStateHook","NavigationContext","LocationContext","useInRouterContext","useLocation","Router","basenameProp","locationProp","static","staticProp","navigationContext","v7_relativeSplatPath","locationContext","trailingPathname","Fragment","for","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ReactCurrentOwner","__self","__source","q","k","_owner","jsx","jsxs"],"sourceRoot":""}