{"version":3,"file":"5232-c62f624b3277b83dd4a2.js","mappings":"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","sources":["webpack://@whistleout/webui/../node_modules/.pnpm/@remix-run+router@1.0.3/node_modules/@remix-run/router/dist/router.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/createClass.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/inherits.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/createSuper.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/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.0/node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/get.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/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.0/node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/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.0/node_modules/@babel/runtime/helpers/esm/regeneratorRuntime.js","webpack://@whistleout/webui/../node_modules/.pnpm/@babel+runtime@7.26.0/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.4.3_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.4.3_react@17.0.2/node_modules/react-router/dist/index.js"],"sourcesContent":["/**\n * @remix-run/router v1.0.3\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\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nvar Action;\n\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\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\n  Action[\"Replace\"] = \"REPLACE\";\n})(Action || (Action = {}));\n\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 */\n\nfunction createMemoryHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  let {\n    initialEntries = [\"/\"],\n    initialIndex,\n    v5Compat = false\n  } = options;\n  let entries; // Declare so we can access from createMemoryLocation\n\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\n  function clampIndex(n) {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n\n  function getCurrentLocation() {\n    return entries[index];\n  }\n\n  function createMemoryLocation(to, state, key) {\n    if (state === void 0) {\n      state = null;\n    }\n\n    let location = createLocation(entries ? getCurrentLocation().pathname : \"/\", to, state, key);\n    warning$1(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in memory history: \" + JSON.stringify(to));\n    return location;\n  }\n\n  let history = {\n    get index() {\n      return index;\n    },\n\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return getCurrentLocation();\n    },\n\n    createHref(to) {\n      return typeof to === \"string\" ? to : createPath(to);\n    },\n\n    encodeLocation(location) {\n      return location;\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\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation\n        });\n      }\n    },\n\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n\n      if (v5Compat && listener) {\n        listener({\n          action,\n          location: nextLocation\n        });\n      }\n    },\n\n    go(delta) {\n      action = Action.Pop;\n      index = clampIndex(index + delta);\n\n      if (listener) {\n        listener({\n          action,\n          location: getCurrentLocation()\n        });\n      }\n    },\n\n    listen(fn) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\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 */\n\nfunction createBrowserHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\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    }, // state defaults to `null` because `window.history.state` does\n    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || \"default\");\n  }\n\n  function createBrowserHref(window, to) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\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 */\n\nfunction createHashHistory(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  function createHashLocation(window, globalHistory) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\"\n    } = parsePath(window.location.hash.substr(1));\n    return createLocation(\"\", {\n      pathname,\n      search,\n      hash\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\n  function createHashHref(window, to) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n\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\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n\n  function validateHashLocation(location, to) {\n    warning$1(location.pathname.charAt(0) === \"/\", \"relative pathnames are not supported in hash history.push(\" + JSON.stringify(to) + \")\");\n  }\n\n  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\nfunction warning$1(cond, message) {\n  if (!cond) {\n    // eslint-disable-next-line no-console\n    if (typeof console !== \"undefined\") console.warn(message);\n\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\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 */\n\n\nfunction getHistoryState(location) {\n  return {\n    usr: location.state,\n    key: location.key\n  };\n}\n/**\n * Creates a Location object with a unique key from the given Path\n */\n\n\nfunction createLocation(current, to, state, key) {\n  if (state === void 0) {\n    state = null;\n  }\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\n  return location;\n}\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\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 */\n\nfunction parsePath(path) {\n  let parsedPath = {};\n\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    let searchIndex = path.indexOf(\"?\");\n\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\nfunction createURL(location) {\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 = typeof window !== \"undefined\" && typeof window.location !== \"undefined\" && window.location.origin !== \"null\" ? window.location.origin : \"unknown://unknown\";\n  let href = typeof location === \"string\" ? location : createPath(location);\n  return new URL(href, base);\n}\n\nfunction getUrlBasedHistory(getLocation, createHref, validateLocation, options) {\n  if (options === void 0) {\n    options = {};\n  }\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\n  function handlePop() {\n    action = Action.Pop;\n\n    if (listener) {\n      listener({\n        action,\n        location: history.location\n      });\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    let historyState = getHistoryState(location);\n    let url = history.createHref(location); // try...catch because iOS limits us to 100 pushState calls :/\n\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\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\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location\n      });\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    let historyState = getHistoryState(location);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n\n    if (v5Compat && listener) {\n      listener({\n        action,\n        location: history.location\n      });\n    }\n  }\n\n  let history = {\n    get action() {\n      return action;\n    },\n\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n\n    listen(fn) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n\n    createHref(to) {\n      return createHref(window, to);\n    },\n\n    encodeLocation(location) {\n      // Encode a Location the same way window.location would\n      let url = createURL(createPath(location));\n      return _extends({}, location, {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash\n      });\n    },\n\n    push,\n    replace,\n\n    go(n) {\n      return globalHistory.go(n);\n    }\n\n  };\n  return history;\n} //#endregion\n\nvar ResultType;\n\n(function (ResultType) {\n  ResultType[\"data\"] = \"data\";\n  ResultType[\"deferred\"] = \"deferred\";\n  ResultType[\"redirect\"] = \"redirect\";\n  ResultType[\"error\"] = \"error\";\n})(ResultType || (ResultType = {}));\n\nfunction isIndexRoute(route) {\n  return route.index === true;\n} // Walk the route tree generating unique IDs where necessary so we are working\n// solely with AgnosticDataRouteObject's within the Router\n\n\nfunction convertRoutesToDataRoutes(routes, parentPath, allIds) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n\n  if (allIds === void 0) {\n    allIds = new Set();\n  }\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(!allIds.has(id), \"Found a route id collision on id \\\"\" + id + \"\\\".  Route \" + \"id's must be globally unique within Data Router usages\");\n    allIds.add(id);\n\n    if (isIndexRoute(route)) {\n      let indexRoute = _extends({}, route, {\n        id\n      });\n\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute = _extends({}, route, {\n        id,\n        children: route.children ? convertRoutesToDataRoutes(route.children, treePath, allIds) : undefined\n      });\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/docs/en/v6/utils/match-routes\n */\n\nfunction matchRoutes(routes, locationArg, basename) {\n  if (basename === void 0) {\n    basename = \"/\";\n  }\n\n  let location = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n  let pathname = stripBasename(location.pathname || \"/\", basename);\n\n  if (pathname == null) {\n    return null;\n  }\n\n  let branches = flattenRoutes(routes);\n  rankRouteBranches(branches);\n  let matches = null;\n\n  for (let i = 0; matches == null && i < branches.length; ++i) {\n    matches = matchRouteBranch(branches[i], // 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\n  return matches;\n}\n\nfunction flattenRoutes(routes, branches, parentsMeta, parentPath) {\n  if (branches === void 0) {\n    branches = [];\n  }\n\n  if (parentsMeta === void 0) {\n    parentsMeta = [];\n  }\n\n  if (parentPath === void 0) {\n    parentPath = \"\";\n  }\n\n  routes.forEach((route, index) => {\n    let meta = {\n      relativePath: route.path || \"\",\n      caseSensitive: route.caseSensitive === true,\n      childrenIndex: index,\n      route\n    };\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\n    let path = joinPaths([parentPath, meta.relativePath]);\n    let routesMeta = parentsMeta.concat(meta); // 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\n    if (route.children && route.children.length > 0) {\n      invariant( // 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    } // 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\n\n    if (route.path == null && !route.index) {\n      return;\n    }\n\n    branches.push({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta\n    });\n  });\n  return branches;\n}\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}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\n\nconst isSplat = s => s === \"*\";\n\nfunction computeScore(path, index) {\n  let segments = path.split(\"/\");\n  let initialScore = segments.length;\n\n  if (segments.some(isSplat)) {\n    initialScore += splatPenalty;\n  }\n\n  if (index) {\n    initialScore += indexRouteValue;\n  }\n\n  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === \"\" ? emptySegmentValue : staticSegmentValue), initialScore);\n}\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 ? // 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] : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n  // so they sort equally.\n  0;\n}\n\nfunction matchRouteBranch(branch, pathname) {\n  let {\n    routesMeta\n  } = branch;\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches = [];\n\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\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/docs/en/v6/utils/generate-path\n */\n\n\nfunction generatePath(path, params) {\n  if (params === void 0) {\n    params = {};\n  }\n\n  return path.replace(/:(\\w+)/g, (_, key) => {\n    invariant(params[key] != null, \"Missing \\\":\" + key + \"\\\" param\");\n    return params[key];\n  }).replace(/(\\/?)\\*/, (_, prefix, __, str) => {\n    const star = \"*\";\n\n    if (params[star] == null) {\n      // If no splat was provided, trim the trailing slash _unless_ it's\n      // the entire path\n      return str === \"/*\" ? \"/\" : \"\";\n    } // Apply the splat\n\n\n    return \"\" + prefix + params[star];\n  });\n}\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/docs/en/v6/utils/match-path\n */\n\nfunction matchPath(pattern, pathname) {\n  if (typeof pattern === \"string\") {\n    pattern = {\n      path: pattern,\n      caseSensitive: false,\n      end: true\n    };\n  }\n\n  let [matcher, paramNames] = 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 = paramNames.reduce((memo, paramName, index) => {\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\n    memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || \"\", paramName);\n    return memo;\n  }, {});\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern\n  };\n}\n\nfunction compilePath(path, caseSensitive, end) {\n  if (caseSensitive === void 0) {\n    caseSensitive = false;\n  }\n\n  if (end === void 0) {\n    end = true;\n  }\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 paramNames = [];\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) => {\n    paramNames.push(paramName);\n    return \"([^\\\\/]+)\";\n  });\n\n  if (path.endsWith(\"*\")) {\n    paramNames.push(\"*\");\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\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n  return [matcher, paramNames];\n}\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}\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 */\n\n\nfunction stripBasename(pathname, basename) {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\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\n\n  let startIndex = basename.endsWith(\"/\") ? basename.length - 1 : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(startIndex) || \"/\";\n}\nfunction invariant(value, message) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\n/**\n * @private\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\n    try {\n      // Welcome to debugging React Router!\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n}\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/docs/en/v6/utils/resolve-path\n */\n\nfunction resolvePath(to, fromPathname) {\n  if (fromPathname === void 0) {\n    fromPathname = \"/\";\n  }\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}\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}\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 */\n\n\nfunction getPathContributingMatches(matches) {\n  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);\n}\n/**\n * @private\n */\n\nfunction resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {\n  if (isPathRelative === void 0) {\n    isPathRelative = false;\n  }\n\n  let to;\n\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\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n  let from; // 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\n  if (isPathRelative || toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    if (toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\"); // Each leading .. segment means \"go up one route\" instead of \"go up one\n      // URL segment\".  This is a key difference from how <a href> works and a\n      // major reason we call this a \"to\" value instead of a \"href\".\n\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    } // If there are more \"..\" segments than parent routes, resolve relative to\n    // the root / URL.\n\n\n    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n  }\n\n  let path = resolvePath(to, from); // Ensure the pathname has a trailing slash if the original \"to\" had one\n\n  let hasExplicitTrailingSlash = toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\"); // Or if this was a link to the current path which has a trailing slash\n\n  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n\n  if (!path.pathname.endsWith(\"/\") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n/**\n * @private\n */\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 */\n\nconst joinPaths = paths => paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n/**\n * @private\n */\n\nconst normalizePathname = pathname => pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n/**\n * @private\n */\n\nconst normalizeSearch = search => !search || search === \"?\" ? \"\" : search.startsWith(\"?\") ? search : \"?\" + search;\n/**\n * @private\n */\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 */\n\nconst json = function json(data, init) {\n  if (init === void 0) {\n    init = {};\n  }\n\n  let responseInit = typeof init === \"number\" ? {\n    status: init\n  } : init;\n  let headers = new Headers(responseInit.headers);\n\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n\n  return new Response(JSON.stringify(data), _extends({}, responseInit, {\n    headers\n  }));\n};\nclass AbortedDeferredError extends Error {}\nclass DeferredData {\n  constructor(data) {\n    this.pendingKeys = new Set();\n    this.subscriber = undefined;\n    invariant(data && typeof data === \"object\" && !Array.isArray(data), \"defer() only accepts plain objects\"); // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n\n    let reject;\n    this.abortPromise = new Promise((_, r) => reject = r);\n    this.controller = new AbortController();\n\n    let onAbort = () => reject(new AbortedDeferredError(\"Deferred data aborted\"));\n\n    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener(\"abort\", onAbort);\n\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n    this.data = Object.entries(data).reduce((acc, _ref) => {\n      let [key, value] = _ref;\n      return Object.assign(acc, {\n        [key]: this.trackPromise(key, value)\n      });\n    }, {});\n  }\n\n  trackPromise(key, value) {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n\n    this.pendingKeys.add(key); // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n\n    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, null, data), error => this.onSettle(promise, key, error)); // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n\n    promise.catch(() => {});\n    Object.defineProperty(promise, \"_tracked\", {\n      get: () => true\n    });\n    return promise;\n  }\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\n    this.pendingKeys.delete(key);\n\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n\n    const subscriber = this.subscriber;\n\n    if (error) {\n      Object.defineProperty(promise, \"_error\", {\n        get: () => error\n      });\n      subscriber && subscriber(false);\n      return Promise.reject(error);\n    }\n\n    Object.defineProperty(promise, \"_data\", {\n      get: () => data\n    });\n    subscriber && subscriber(false);\n    return data;\n  }\n\n  subscribe(fn) {\n    this.subscriber = fn;\n  }\n\n  cancel() {\n    this.controller.abort();\n    this.pendingKeys.forEach((v, k) => this.pendingKeys.delete(k));\n    let subscriber = this.subscriber;\n    subscriber && subscriber(true);\n  }\n\n  async resolveData(signal) {\n    let aborted = false;\n\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise(resolve => {\n        this.subscribe(aborted => {\n          signal.removeEventListener(\"abort\", onAbort);\n\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n\n    return aborted;\n  }\n\n  get done() {\n    return this.pendingKeys.size === 0;\n  }\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, _ref2) => {\n      let [key, value] = _ref2;\n      return Object.assign(acc, {\n        [key]: unwrapTrackedPromise(value)\n      });\n    }, {});\n  }\n\n}\n\nfunction isTrackedPromise(value) {\n  return value instanceof Promise && value._tracked === true;\n}\n\nfunction unwrapTrackedPromise(value) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n\n  if (value._error) {\n    throw value._error;\n  }\n\n  return value._data;\n}\n\nfunction defer(data) {\n  return new DeferredData(data);\n}\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\n\nconst redirect = function redirect(url, init) {\n  if (init === void 0) {\n    init = 302;\n  }\n\n  let responseInit = init;\n\n  if (typeof responseInit === \"number\") {\n    responseInit = {\n      status: responseInit\n    };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\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 * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n */\n\nclass ErrorResponse {\n  constructor(status, statusText, data) {\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.data = data;\n  }\n\n}\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response throw from an action/loader\n */\n\nfunction isRouteErrorResponse(e) {\n  return e instanceof ErrorResponse;\n}\n\nconst IDLE_NAVIGATION = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined\n};\nconst IDLE_FETCHER = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined\n};\nconst isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\";\nconst isServer = !isBrowser; //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\n\nfunction createRouter(init) {\n  invariant(init.routes.length > 0, \"You must provide a non-empty routes array to createRouter\");\n  let dataRoutes = convertRoutesToDataRoutes(init.routes); // Cleanup function for history\n\n  let unlistenHistory = null; // Externally-provided functions to call on all state changes\n\n  let subscribers = new Set(); // Externally-provided object to hold scroll restoration locations during routing\n\n  let savedScrollPositions = null; // Externally-provided function to get scroll restoration keys\n\n  let getScrollRestorationKey = null; // Externally-provided function to get current scroll position\n\n  let getScrollPosition = null; // 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\n  let initialScrollRestored = false;\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, init.basename);\n  let initialErrors = null;\n\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 {\n      matches,\n      route,\n      error\n    } = getNotFoundMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = {\n      [route.id]: error\n    };\n  }\n\n  let initialized = !initialMatches.some(m => m.route.loader) || init.hydrationData != null;\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    restoreScrollPosition: 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  }; // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n\n  let pendingAction = Action.Pop; // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n\n  let pendingPreventScrollReset = false; // AbortController for the active navigation\n\n  let pendingNavigationController; // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n\n  let isUninterruptedRevalidation = false; // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidate()\n  //  - X-Remix-Revalidate (from redirect)\n\n  let isRevalidationRequired = false; // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n\n  let cancelledDeferredRoutes = []; // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n\n  let cancelledFetcherLoads = []; // AbortControllers for any in-flight fetchers\n\n  let fetchControllers = new Map(); // Track loads based on the order in which they started\n\n  let incrementingLoadId = 0; // 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\n  let pendingNavigationLoadId = -1; // Fetchers that triggered data reloads as a result of their actions\n\n  let fetchReloadIds = new Map(); // Fetchers that triggered redirect navigations from their actions\n\n  let fetchRedirectIds = new Set(); // Most recent href/match for fetcher.load calls for fetchers\n\n  let fetchLoadMatches = new Map(); // 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\n  let activeDeferreds = new Map(); // 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\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      } = _ref;\n      return startNavigation(historyAction, location);\n    }); // Kick off initial data load if needed.  Use Pop to avoid modifying history\n\n    if (!state.initialized) {\n      startNavigation(Action.Pop, state.location);\n    }\n\n    return router;\n  } // Clean up a router and it's side effects\n\n\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n  } // Subscribe to state updates for the router\n\n\n  function subscribe(fn) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  } // Update our state and notify the calling context of the change\n\n\n  function updateState(newState) {\n    state = _extends({}, state, newState);\n    subscribers.forEach(subscriber => subscriber(state));\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\n\n  function completeNavigation(location, newState) {\n    var _state$navigation$for;\n\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a submission\n    // - We're past the submitting state and into the loading state\n    // - The location we've finished loading is different from the submission\n    //   location, indicating we redirected from the action (avoids false\n    //   positives for loading/submissionRedirect when actionData returned\n    //   on a prior submission)\n    let isActionReload = state.actionData != null && state.navigation.formMethod != null && state.navigation.state === \"loading\" && ((_state$navigation$for = state.navigation.formAction) == null ? void 0 : _state$navigation$for.split(\"?\")[0]) === location.pathname; // Always preserve any existing loaderData from re-used routes\n\n    let newLoaderData = newState.loaderData ? {\n      loaderData: mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [])\n    } : {};\n    updateState(_extends({}, isActionReload ? {} : {\n      actionData: null\n    }, newState, newLoaderData, {\n      historyAction: pendingAction,\n      location,\n      initialized: true,\n      navigation: IDLE_NAVIGATION,\n      revalidation: \"idle\",\n      // Don't restore on submission navigations\n      restoreScrollPosition: state.navigation.formData ? false : getSavedScrollPosition(location, newState.matches || state.matches),\n      preventScrollReset: pendingPreventScrollReset\n    }));\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    } // Reset stateful navigation vars\n\n\n    pendingAction = Action.Pop;\n    pendingPreventScrollReset = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n    cancelledFetcherLoads = [];\n  } // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n\n\n  async function navigate(to, opts) {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n\n    let {\n      path,\n      submission,\n      error\n    } = normalizeNavigateOptions(to, opts);\n    let location = createLocation(state.location, path, opts && opts.state); // 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\n    location = init.history.encodeLocation(location);\n    let historyAction = (opts && opts.replace) === true || submission != null ? Action.Replace : Action.Push;\n    let preventScrollReset = opts && \"preventScrollReset\" in opts ? opts.preventScrollReset === true : undefined;\n    return await startNavigation(historyAction, location, {\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    });\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\n\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({\n      revalidation: \"loading\"\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\n    if (state.navigation.state === \"submitting\") {\n      return;\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\n\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true\n      });\n      return;\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\n\n    startNavigation(pendingAction || state.historyAction, state.navigation.location, {\n      overrideNavigation: state.navigation\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\n\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; // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches = matchRoutes(dataRoutes, location, init.basename); // Short circuit with a 404 on the root error boundary if we match nothing\n\n    if (!matches) {\n      let {\n        matches: notFoundMatches,\n        route,\n        error\n      } = getNotFoundMatches(dataRoutes); // Cancel all pending deferred on 404s since we don't keep any routes\n\n      cancelActiveDeferreds();\n      completeNavigation(location, {\n        matches: notFoundMatches,\n        loaderData: {},\n        errors: {\n          [route.id]: error\n        }\n      });\n      return;\n    } // Short circuit if it's only a hash change\n\n\n    if (isHashChangeOnly(state.location, location)) {\n      completeNavigation(location, {\n        matches\n      });\n      return;\n    } // Create a controller/Request for this navigation\n\n\n    pendingNavigationController = new AbortController();\n    let request = createRequest(location, pendingNavigationController.signal, opts && opts.submission);\n    let pendingActionData;\n    let pendingError;\n\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) {\n      // Call action if we received an action submission\n      let actionOutput = await handleAction(request, location, opts.submission, matches, {\n        replace: opts.replace\n      });\n\n      if (actionOutput.shortCircuited) {\n        return;\n      }\n\n      pendingActionData = actionOutput.pendingActionData;\n      pendingError = actionOutput.pendingActionError;\n\n      let navigation = _extends({\n        state: \"loading\",\n        location\n      }, opts.submission);\n\n      loadingNavigation = navigation;\n    } // Call loaders\n\n\n    let {\n      shortCircuited,\n      loaderData,\n      errors\n    } = await handleLoaders(request, location, matches, loadingNavigation, opts && opts.submission, opts && opts.replace, pendingActionData, pendingError);\n\n    if (shortCircuited) {\n      return;\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\n\n    pendingNavigationController = null;\n    completeNavigation(location, {\n      matches,\n      loaderData,\n      errors\n    });\n  } // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n\n\n  async function handleAction(request, location, submission, matches, opts) {\n    interruptActiveLoads(); // Put us in a submitting state\n\n    let navigation = _extends({\n      state: \"submitting\",\n      location\n    }, submission);\n\n    updateState({\n      navigation\n    }); // Call our action and get the result\n\n    let result;\n    let actionMatch = getTargetMatch(matches, location);\n\n    if (!actionMatch.route.action) {\n      result = getMethodNotAllowedResult(location);\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, router.basename);\n\n      if (request.signal.aborted) {\n        return {\n          shortCircuited: true\n        };\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      let redirectNavigation = _extends({\n        state: \"loading\",\n        location: createLocation(state.location, result.location)\n      }, submission);\n\n      await startRedirectNavigation(result, redirectNavigation, opts && opts.replace);\n      return {\n        shortCircuited: true\n      };\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); // 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\n      if ((opts && opts.replace) !== true) {\n        pendingAction = Action.Push;\n      }\n\n      return {\n        pendingActionError: {\n          [boundaryMatch.route.id]: result.error\n        }\n      };\n    }\n\n    if (isDeferredResult(result)) {\n      throw new Error(\"defer() is not supported in actions\");\n    }\n\n    return {\n      pendingActionData: {\n        [actionMatch.route.id]: result.data\n      }\n    };\n  } // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n\n\n  async function handleLoaders(request, location, matches, overrideNavigation, submission, replace, pendingActionData, pendingError) {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation = overrideNavigation;\n\n    if (!loadingNavigation) {\n      let navigation = {\n        state: \"loading\",\n        location,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      loadingNavigation = navigation;\n    }\n\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, pendingActionData, pendingError, fetchLoadMatches); // 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\n    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId)); // Short circuit if we have no loaders to run\n\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      completeNavigation(location, {\n        matches,\n        loaderData: mergeLoaderData(state.loaderData, {}, matches),\n        // Commit pending error if we're short circuiting\n        errors: pendingError || null,\n        actionData: pendingActionData || null\n      });\n      return {\n        shortCircuited: true\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\n\n    if (!isUninterruptedRevalidation) {\n      revalidatingFetchers.forEach(_ref2 => {\n        let [key] = _ref2;\n        let fetcher = state.fetchers.get(key);\n        let revalidatingFetcher = {\n          state: \"loading\",\n          data: fetcher && fetcher.data,\n          formMethod: undefined,\n          formAction: undefined,\n          formEncType: undefined,\n          formData: undefined\n        };\n        state.fetchers.set(key, revalidatingFetcher);\n      });\n      updateState(_extends({\n        navigation: loadingNavigation,\n        actionData: pendingActionData || state.actionData || null\n      }, revalidatingFetchers.length > 0 ? {\n        fetchers: new Map(state.fetchers)\n      } : {}));\n    }\n\n    pendingNavigationLoadId = ++incrementingLoadId;\n    revalidatingFetchers.forEach(_ref3 => {\n      let [key] = _ref3;\n      return fetchControllers.set(key, pendingNavigationController);\n    });\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, request);\n\n    if (request.signal.aborted) {\n      return {\n        shortCircuited: true\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\n\n    revalidatingFetchers.forEach(_ref4 => {\n      let [key] = _ref4;\n      return fetchControllers.delete(key);\n    }); // If any loaders returned a redirect Response, start a new REPLACE navigation\n\n    let redirect = findRedirect(results);\n\n    if (redirect) {\n      let redirectNavigation = getLoaderRedirect(state, redirect);\n      await startRedirectNavigation(redirect, redirectNavigation, replace);\n      return {\n        shortCircuited: true\n      };\n    } // Process and commit output from loaders\n\n\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, matches, matchesToLoad, loaderResults, pendingError, revalidatingFetchers, fetcherResults, activeDeferreds); // Wire up subscribers to update loaderData as promises settle\n\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    markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    return _extends({\n      loaderData,\n      errors\n    }, didAbortFetchLoads || revalidatingFetchers.length > 0 ? {\n      fetchers: new Map(state.fetchers)\n    } : {});\n  }\n\n  function getFetcher(key) {\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  } // Trigger a fetcher load/submit for the given fetcher key\n\n\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\n    if (fetchControllers.has(key)) abortFetcher(key);\n    let matches = matchRoutes(dataRoutes, href, init.basename);\n\n    if (!matches) {\n      setFetcherError(key, routeId, new ErrorResponse(404, \"Not Found\", null));\n      return;\n    }\n\n    let {\n      path,\n      submission\n    } = normalizeNavigateOptions(href, opts, true);\n    let match = getTargetMatch(matches, path);\n\n    if (submission) {\n      handleFetcherAction(key, routeId, path, match, matches, submission);\n      return;\n    } // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n\n\n    fetchLoadMatches.set(key, [path, match, matches]);\n    handleFetcherLoader(key, routeId, path, match, matches);\n  } // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n\n\n  async function handleFetcherAction(key, routeId, path, match, requestMatches, submission) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n\n    if (!match.route.action) {\n      let {\n        error\n      } = getMethodNotAllowedResult(path);\n      setFetcherError(key, routeId, error);\n      return;\n    } // Put this fetcher into it's submitting state\n\n\n    let existingFetcher = state.fetchers.get(key);\n\n    let fetcher = _extends({\n      state: \"submitting\"\n    }, submission, {\n      data: existingFetcher && existingFetcher.data\n    });\n\n    state.fetchers.set(key, fetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }); // Call the action for the fetcher\n\n    let abortController = new AbortController();\n    let fetchRequest = createRequest(path, abortController.signal, submission);\n    fetchControllers.set(key, abortController);\n    let actionResult = await callLoaderOrAction(\"action\", fetchRequest, match, requestMatches, router.basename);\n\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by ou 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\n      return;\n    }\n\n    if (isRedirectResult(actionResult)) {\n      fetchControllers.delete(key);\n      fetchRedirectIds.add(key);\n\n      let loadingFetcher = _extends({\n        state: \"loading\"\n      }, submission, {\n        data: undefined\n      });\n\n      state.fetchers.set(key, loadingFetcher);\n      updateState({\n        fetchers: new Map(state.fetchers)\n      });\n\n      let redirectNavigation = _extends({\n        state: \"loading\",\n        location: createLocation(state.location, actionResult.location)\n      }, submission);\n\n      await startRedirectNavigation(actionResult, redirectNavigation);\n      return;\n    } // Process any non-redirect errors thrown\n\n\n    if (isErrorResult(actionResult)) {\n      setFetcherError(key, routeId, actionResult.error);\n      return;\n    }\n\n    if (isDeferredResult(actionResult)) {\n      invariant(false, \"defer() is not supported in actions\");\n    } // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n\n\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createRequest(nextLocation, abortController.signal);\n    let matches = state.navigation.state !== \"idle\" ? matchRoutes(dataRoutes, state.navigation.location, init.basename) : state.matches;\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n\n    let loadFetcher = _extends({\n      state: \"loading\",\n      data: actionResult.data\n    }, submission);\n\n    state.fetchers.set(key, loadFetcher);\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(state, matches, submission, nextLocation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, {\n      [match.route.id]: actionResult.data\n    }, undefined, // No need to send through errors since we short circuit above\n    fetchLoadMatches); // 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\n    revalidatingFetchers.filter(_ref5 => {\n      let [staleKey] = _ref5;\n      return staleKey !== key;\n    }).forEach(_ref6 => {\n      let [staleKey] = _ref6;\n      let existingFetcher = state.fetchers.get(staleKey);\n      let revalidatingFetcher = {\n        state: \"loading\",\n        data: existingFetcher && existingFetcher.data,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      state.fetchers.set(staleKey, revalidatingFetcher);\n      fetchControllers.set(staleKey, abortController);\n    });\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\n    let {\n      results,\n      loaderResults,\n      fetcherResults\n    } = await callLoadersAndMaybeResolveData(state.matches, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);\n\n    if (abortController.signal.aborted) {\n      return;\n    }\n\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach(_ref7 => {\n      let [staleKey] = _ref7;\n      return fetchControllers.delete(staleKey);\n    });\n    let redirect = findRedirect(results);\n\n    if (redirect) {\n      let redirectNavigation = getLoaderRedirect(state, redirect);\n      await startRedirectNavigation(redirect, redirectNavigation);\n      return;\n    } // Process and commit output from loaders\n\n\n    let {\n      loaderData,\n      errors\n    } = processLoaderData(state, state.matches, matchesToLoad, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);\n    let doneFetcher = {\n      state: \"idle\",\n      data: actionResult.data,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined\n    };\n    state.fetchers.set(key, doneFetcher);\n    let didAbortFetchLoads = abortStaleFetchLoads(loadId); // 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\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(_extends({\n        errors,\n        loaderData: mergeLoaderData(state.loaderData, loaderData, matches)\n      }, didAbortFetchLoads ? {\n        fetchers: new Map(state.fetchers)\n      } : {}));\n      isRevalidationRequired = false;\n    }\n  } // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n\n\n  async function handleFetcherLoader(key, routeId, path, match, matches) {\n    let existingFetcher = state.fetchers.get(key); // Put this fetcher into it's loading state\n\n    let loadingFetcher = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      data: existingFetcher && existingFetcher.data\n    };\n    state.fetchers.set(key, loadingFetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    }); // Call the loader for this fetcher route match\n\n    let abortController = new AbortController();\n    let fetchRequest = createRequest(path, abortController.signal);\n    fetchControllers.set(key, abortController);\n    let result = await callLoaderOrAction(\"loader\", fetchRequest, match, matches, router.basename); // Deferred isn't supported or 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\n    if (isDeferredResult(result)) {\n      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;\n    } // We can delete this so long as we weren't aborted by ou our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n\n\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n\n    if (fetchRequest.signal.aborted) {\n      return;\n    } // If the loader threw a redirect Response, start a new REPLACE navigation\n\n\n    if (isRedirectResult(result)) {\n      let redirectNavigation = getLoaderRedirect(state, result);\n      await startRedirectNavigation(result, redirectNavigation);\n      return;\n    } // Process any non-redirect errors thrown\n\n\n    if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, routeId);\n      state.fetchers.delete(key); // TODO: In remix, this would reset to IDLE_NAVIGATION if it was a catch -\n      // do we need to behave any differently with our non-redirect errors?\n      // What if it was a non-redirect Response?\n\n      updateState({\n        fetchers: new Map(state.fetchers),\n        errors: {\n          [boundaryMatch.route.id]: result.error\n        }\n      });\n      return;\n    }\n\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\"); // Put the fetcher back into an idle state\n\n    let doneFetcher = {\n      state: \"idle\",\n      data: result.data,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined\n    };\n    state.fetchers.set(key, doneFetcher);\n    updateState({\n      fetchers: new Map(state.fetchers)\n    });\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\n\n  async function startRedirectNavigation(redirect, navigation, replace) {\n    if (redirect.revalidate) {\n      isRevalidationRequired = true;\n    }\n\n    invariant(navigation.location, \"Expected a location on the redirect navigation\"); // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n\n    pendingNavigationController = null;\n    let redirectHistoryAction = replace === true ? Action.Replace : Action.Push;\n    await startNavigation(redirectHistoryAction, navigation.location, {\n      overrideNavigation: navigation\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, router.basename)), ...fetchersToLoad.map(_ref8 => {\n      let [, href, match, fetchMatches] = _ref8;\n      return callLoaderOrAction(\"loader\", createRequest(href, request.signal), match, fetchMatches, router.basename);\n    })]);\n    let loaderResults = results.slice(0, matchesToLoad.length);\n    let fetcherResults = results.slice(matchesToLoad.length);\n    await Promise.all([resolveDeferredResults(currentMatches, matchesToLoad, loaderResults, request.signal, false, state.loaderData), resolveDeferredResults(currentMatches, fetchersToLoad.map(_ref9 => {\n      let [,, match] = _ref9;\n      return match;\n    }), fetcherResults, request.signal, true)]);\n    return {\n      results,\n      loaderResults,\n      fetcherResults\n    };\n  }\n\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true; // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds()); // Abort in-flight fetcher loads\n\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.push(key);\n        abortFetcher(key);\n      }\n    });\n  }\n\n  function setFetcherError(key, routeId, error) {\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  }\n\n  function deleteFetcher(key) {\n    if (fetchControllers.has(key)) abortFetcher(key);\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n    state.fetchers.delete(key);\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\n  function markFetchersDone(keys) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = {\n        state: \"idle\",\n        data: fetcher.data,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  function markFetchRedirectsDone() {\n    let doneKeys = [];\n\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, \"Expected fetcher: \" + key);\n\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n      }\n    }\n\n    markFetchersDone(doneKeys);\n  }\n\n  function abortStaleFetchLoads(landedId) {\n    let yeetedKeys = [];\n\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\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\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  } // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n\n\n  function enableScrollRestoration(positions, getPosition, getKey) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n\n    getScrollRestorationKey = getKey || (location => location.key); // 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\n\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n\n      if (y != null) {\n        updateState({\n          restoreScrollPosition: y\n        });\n      }\n    }\n\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n\n  function saveScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollRestorationKey && getScrollPosition) {\n      let userMatches = matches.map(m => createUseMatchesMatch(m, state.loaderData));\n      let key = getScrollRestorationKey(location, userMatches) || location.key;\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n\n  function getSavedScrollPosition(location, matches) {\n    if (savedScrollPositions && getScrollRestorationKey && getScrollPosition) {\n      let userMatches = matches.map(m => createUseMatchesMatch(m, state.loaderData));\n      let key = getScrollRestorationKey(location, userMatches) || location.key;\n      let y = savedScrollPositions[key];\n\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n\n    return null;\n  }\n\n  router = {\n    get basename() {\n      return init.basename;\n    },\n\n    get state() {\n      return state;\n    },\n\n    get routes() {\n      return dataRoutes;\n    },\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    getFetcher,\n    deleteFetcher,\n    dispose,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds\n  };\n  return router;\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nconst validActionMethods = new Set([\"POST\", \"PUT\", \"PATCH\", \"DELETE\"]);\nconst validRequestMethods = new Set([\"GET\", \"HEAD\", ...validActionMethods]);\nfunction unstable_createStaticHandler(routes) {\n  invariant(routes.length > 0, \"You must provide a non-empty routes array to unstable_createStaticHandler\");\n  let dataRoutes = convertRoutesToDataRoutes(routes);\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\n  async function query(request) {\n    let url = new URL(request.url);\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location);\n\n    if (!validRequestMethods.has(request.method)) {\n      let {\n        matches: methodNotAllowedMatches,\n        route,\n        error\n      } = getMethodNotAllowedMatches(dataRoutes);\n      return {\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      };\n    } else if (!matches) {\n      let {\n        matches: notFoundMatches,\n        route,\n        error\n      } = getNotFoundMatches(dataRoutes);\n      return {\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      };\n    }\n\n    let result = await queryImpl(request, location, matches);\n\n    if (result instanceof Response) {\n      return result;\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\n\n    return _extends({\n      location\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 thrown Response (such as a\n   * 404 or 405) will have a custom X-Remix-Router-Error: \"yes\" header on it\n   * in order to differentiate from responses thrown from user actions/loaders.\n   */\n\n\n  async function queryRoute(request, routeId) {\n    let url = new URL(request.url);\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location);\n\n    if (!validRequestMethods.has(request.method)) {\n      throw createRouterErrorResponse(null, {\n        status: 405,\n        statusText: \"Method Not Allowed\"\n      });\n    } else if (!matches) {\n      throw createRouterErrorResponse(null, {\n        status: 404,\n        statusText: \"Not Found\"\n      });\n    }\n\n    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);\n\n    if (!match) {\n      throw createRouterErrorResponse(null, {\n        status: 404,\n        statusText: \"Not Found\"\n      });\n    }\n\n    let result = await queryImpl(request, location, matches, match);\n\n    if (result instanceof Response) {\n      return result;\n    }\n\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n\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    } // Pick off the right state value to return\n\n\n    let routeData = [result.actionData, result.loaderData].find(v => v);\n    return Object.values(routeData || {})[0];\n  }\n\n  async function queryImpl(request, location, matches, routeMatch) {\n    invariant(request.signal, \"query()/queryRoute() requests must contain an AbortController signal\");\n\n    try {\n      if (validActionMethods.has(request.method)) {\n        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), routeMatch != null);\n        return result;\n      }\n\n      let result = await loadRouteData(request, matches, routeMatch);\n      return result instanceof Response ? 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 && !isRedirectResponse(e.response)) {\n          throw e.response;\n        }\n\n        return e.response;\n      } // Redirects are always returned since they don't propagate to catch\n      // boundaries\n\n\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n\n      throw e;\n    }\n  }\n\n  async function submit(request, matches, actionMatch, isRouteRequest) {\n    let result;\n\n    if (!actionMatch.route.action) {\n      if (isRouteRequest) {\n        throw createRouterErrorResponse(null, {\n          status: 405,\n          statusText: \"Method Not Allowed\"\n        });\n      }\n\n      result = getMethodNotAllowedResult(request.url);\n    } else {\n      result = await callLoaderOrAction(\"action\", request, actionMatch, matches, undefined, // Basename not currently supported in static handlers\n      true, isRouteRequest);\n\n      if (request.signal.aborted) {\n        let method = isRouteRequest ? \"queryRoute\" : \"query\";\n        throw new Error(method + \"() call aborted\");\n      }\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\n    if (isDeferredResult(result)) {\n      throw new Error(\"defer() is not supported in actions\");\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        let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n        return {\n          matches: [actionMatch],\n          loaderData: {},\n          actionData: null,\n          errors: {\n            [boundaryMatch.route.id]: result.error\n          },\n          // Note: statusCode + headers are unused here since queryRoute will\n          // return the raw Response or value\n          statusCode: 500,\n          loaderHeaders: {},\n          actionHeaders: {}\n        };\n      }\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      };\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, undefined, {\n        [boundaryMatch.route.id]: result.error\n      }); // action status codes take precedence over loader status codes\n\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\n    let context = await loadRouteData(request, matches);\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\n  async function loadRouteData(request, matches, routeMatch, pendingActionError) {\n    let isRouteRequest = routeMatch != null;\n    let requestMatches = routeMatch ? [routeMatch] : getLoaderMatchesUntilBoundary(matches, Object.keys(pendingActionError || {})[0]);\n    let matchesToLoad = requestMatches.filter(m => m.route.loader); // Short circuit if we have no loaders to run\n\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        loaderData: {},\n        errors: pendingActionError || null,\n        statusCode: 200,\n        loaderHeaders: {}\n      };\n    }\n\n    let results = await Promise.all([...matchesToLoad.map(match => callLoaderOrAction(\"loader\", request, match, matches, undefined, // Basename not currently supported in static handlers\n    true, isRouteRequest))]);\n\n    if (request.signal.aborted) {\n      let method = isRouteRequest ? \"queryRoute\" : \"query\";\n      throw new Error(method + \"() call aborted\");\n    } // Can't do anything with these without the Remix side of things, so just\n    // cancel them for now\n\n\n    results.forEach(result => {\n      if (isDeferredResult(result)) {\n        result.deferredData.cancel();\n      }\n    }); // Process and commit output from loaders\n\n    let context = processRouteLoaderData(matches, matchesToLoad, results, pendingActionError);\n    return _extends({}, context, {\n      matches\n    });\n  }\n\n  function createRouterErrorResponse(body, init) {\n    return new Response(body, _extends({}, init, {\n      headers: _extends({}, init.headers, {\n        \"X-Remix-Router-Error\": \"yes\"\n      })\n    }));\n  }\n\n  return {\n    dataRoutes,\n    query,\n    queryRoute\n  };\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\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 */\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\n  return newContext;\n} // Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\n\nfunction normalizeNavigateOptions(to, opts, isFetcher) {\n  if (isFetcher === void 0) {\n    isFetcher = false;\n  }\n\n  let path = typeof to === \"string\" ? to : createPath(to); // Return location verbatim on non-submission navigations\n\n  if (!opts || !(\"formMethod\" in opts) && !(\"formData\" in opts)) {\n    return {\n      path\n    };\n  } // Create a Submission on non-GET navigations\n\n\n  if (opts.formMethod != null && opts.formMethod !== \"get\") {\n    return {\n      path,\n      submission: {\n        formMethod: opts.formMethod,\n        formAction: stripHashFromPath(path),\n        formEncType: opts && opts.formEncType || \"application/x-www-form-urlencoded\",\n        formData: opts.formData\n      }\n    };\n  } // No formData to flatten for GET submission\n\n\n  if (!opts.formData) {\n    return {\n      path\n    };\n  } // Flatten submission onto URLSearchParams for GET submissions\n\n\n  let parsedPath = parsePath(path);\n\n  try {\n    let searchParams = convertFormDataToSearchParams(opts.formData); // Since fetcher GET submissions only run a single loader (as opposed to\n    // navigation GET submissions which run all loaders), we need to preserve\n    // any incoming ?index params\n\n    if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n      searchParams.append(\"index\", \"\");\n    }\n\n    parsedPath.search = \"?\" + searchParams;\n  } catch (e) {\n    return {\n      path,\n      error: new ErrorResponse(400, \"Bad Request\", \"Cannot submit binary form data using GET\")\n    };\n  }\n\n  return {\n    path: createPath(parsedPath)\n  };\n}\n\nfunction getLoaderRedirect(state, redirect) {\n  let {\n    formMethod,\n    formAction,\n    formEncType,\n    formData\n  } = state.navigation;\n  let navigation = {\n    state: \"loading\",\n    location: createLocation(state.location, redirect.location),\n    formMethod: formMethod || undefined,\n    formAction: formAction || undefined,\n    formEncType: formEncType || undefined,\n    formData: formData || undefined\n  };\n  return navigation;\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\n\n\nfunction getLoaderMatchesUntilBoundary(matches, boundaryId) {\n  let boundaryMatches = matches;\n\n  if (boundaryId) {\n    let index = matches.findIndex(m => m.route.id === boundaryId);\n\n    if (index >= 0) {\n      boundaryMatches = matches.slice(0, index);\n    }\n  }\n\n  return boundaryMatches;\n}\n\nfunction getMatchesToLoad(state, matches, submission, location, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, pendingActionData, pendingError, fetchLoadMatches) {\n  let actionResult = pendingError ? Object.values(pendingError)[0] : pendingActionData ? Object.values(pendingActionData)[0] : null; // Pick navigation matches that are net-new or qualify for revalidation\n\n  let boundaryId = pendingError ? Object.keys(pendingError)[0] : undefined;\n  let boundaryMatches = getLoaderMatchesUntilBoundary(matches, boundaryId);\n  let navigationMatches = boundaryMatches.filter((match, index) => match.route.loader != null && (isNewLoader(state.loaderData, state.matches[index], match) || // If this route had a pending deferred cancelled it must be revalidated\n  cancelledDeferredRoutes.some(id => id === match.route.id) || shouldRevalidateLoader(state.location, state.matches[index], submission, location, match, isRevalidationRequired, actionResult))); // Pick fetcher.loads that need to be revalidated\n\n  let revalidatingFetchers = [];\n  fetchLoadMatches && fetchLoadMatches.forEach((_ref10, key) => {\n    let [href, match, fetchMatches] = _ref10;\n\n    // This fetcher was cancelled from a prior action submission - force reload\n    if (cancelledFetcherLoads.includes(key)) {\n      revalidatingFetchers.push([key, href, match, fetchMatches]);\n    } else if (isRevalidationRequired) {\n      let shouldRevalidate = shouldRevalidateLoader(href, match, submission, href, match, isRevalidationRequired, actionResult);\n\n      if (shouldRevalidate) {\n        revalidatingFetchers.push([key, href, match, fetchMatches]);\n      }\n    }\n  });\n  return [navigationMatches, revalidatingFetchers];\n}\n\nfunction isNewLoader(currentLoaderData, currentMatch, match) {\n  let isNew = // [a] -> [a, b]\n  !currentMatch || // [a, b] -> [a, c]\n  match.route.id !== currentMatch.route.id; // 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\n  let isMissingData = currentLoaderData[match.route.id] === undefined; // Always load if this is a net-new route or we don't yet have data\n\n  return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(currentMatch, match) {\n  let currentPath = currentMatch.route.path;\n  return (// param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname || // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    currentPath && currentPath.endsWith(\"*\") && currentMatch.params[\"*\"] !== match.params[\"*\"]\n  );\n}\n\nfunction shouldRevalidateLoader(currentLocation, currentMatch, submission, location, match, isRevalidationRequired, actionResult) {\n  let currentUrl = createURL(currentLocation);\n  let currentParams = currentMatch.params;\n  let nextUrl = createURL(location);\n  let nextParams = match.params; // This is the default implementation as to 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  // Note that fetchers always provide the same current/next locations so the\n  // URL-based checks here don't apply to fetcher shouldRevalidate calls\n\n  let defaultShouldRevalidate = isNewRouteInstance(currentMatch, match) || // Clicked the same link, resubmitted a GET form\n  currentUrl.toString() === nextUrl.toString() || // Search params affect all loaders\n  currentUrl.search !== nextUrl.search || // Forced revalidation due to submission, useRevalidate, or X-Remix-Revalidate\n  isRevalidationRequired;\n\n  if (match.route.shouldRevalidate) {\n    let routeChoice = match.route.shouldRevalidate(_extends({\n      currentUrl,\n      currentParams,\n      nextUrl,\n      nextParams\n    }, submission, {\n      actionResult,\n      defaultShouldRevalidate\n    }));\n\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n\n  return defaultShouldRevalidate;\n}\n\nasync function callLoaderOrAction(type, request, match, matches, basename, isStaticRequest, isRouteRequest) {\n  if (isStaticRequest === void 0) {\n    isStaticRequest = false;\n  }\n\n  if (isRouteRequest === void 0) {\n    isRouteRequest = false;\n  }\n\n  let resultType;\n  let result; // Setup a promise we can race against so that abort signals short circuit\n\n  let reject;\n  let abortPromise = new Promise((_, r) => reject = r);\n\n  let onReject = () => reject();\n\n  request.signal.addEventListener(\"abort\", onReject);\n\n  try {\n    let handler = match.route[type];\n    invariant(handler, \"Could not find the \" + type + \" to run on the \\\"\" + match.route.id + \"\\\" route\");\n    result = await Promise.race([handler({\n      request,\n      params: match.params\n    }), abortPromise]);\n  } catch (e) {\n    resultType = ResultType.error;\n    result = e;\n  } finally {\n    request.signal.removeEventListener(\"abort\", onReject);\n  }\n\n  if (result instanceof Response) {\n    let status = result.status; // Process redirects\n\n    if (status >= 300 && status <= 399) {\n      let location = result.headers.get(\"Location\");\n      invariant(location, \"Redirects returned/thrown from loaders/actions must have a Location header\"); // Support relative routing in redirects\n\n      let activeMatches = matches.slice(0, matches.indexOf(match) + 1);\n      let routePathnames = getPathContributingMatches(activeMatches).map(match => match.pathnameBase);\n      let requestPath = createURL(request.url).pathname;\n      let resolvedLocation = resolveTo(location, routePathnames, requestPath);\n      invariant(createPath(resolvedLocation), \"Unable to resolve redirect location: \" + result.headers.get(\"Location\")); // Prepend the basename to the redirect location if we have one\n\n      if (basename) {\n        let path = resolvedLocation.pathname;\n        resolvedLocation.pathname = path === \"/\" ? basename : joinPaths([basename, path]);\n      }\n\n      location = createPath(resolvedLocation); // 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\n      if (isStaticRequest) {\n        result.headers.set(\"Location\", location);\n        throw result;\n      }\n\n      return {\n        type: ResultType.redirect,\n        status,\n        location,\n        revalidate: result.headers.get(\"X-Remix-Revalidate\") !== null\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\n\n    if (isRouteRequest) {\n      // eslint-disable-next-line no-throw-literal\n      throw {\n        type: resultType || ResultType.data,\n        response: result\n      };\n    }\n\n    let data;\n    let contentType = result.headers.get(\"Content-Type\");\n\n    if (contentType && contentType.startsWith(\"application/json\")) {\n      data = await result.json();\n    } else {\n      data = await result.text();\n    }\n\n    if (resultType === ResultType.error) {\n      return {\n        type: resultType,\n        error: new ErrorResponse(status, result.statusText, data),\n        headers: result.headers\n      };\n    }\n\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers\n    };\n  }\n\n  if (resultType === ResultType.error) {\n    return {\n      type: resultType,\n      error: result\n    };\n  }\n\n  if (result instanceof DeferredData) {\n    return {\n      type: ResultType.deferred,\n      deferredData: result\n    };\n  }\n\n  return {\n    type: ResultType.data,\n    data: result\n  };\n}\n\nfunction createRequest(location, signal, submission) {\n  let url = createURL(stripHashFromPath(location)).toString();\n  let init = {\n    signal\n  };\n\n  if (submission) {\n    let {\n      formMethod,\n      formEncType,\n      formData\n    } = submission;\n    init.method = formMethod.toUpperCase();\n    init.body = formEncType === \"application/x-www-form-urlencoded\" ? convertFormDataToSearchParams(formData) : formData;\n  } // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n\n\n  return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData) {\n  let searchParams = new URLSearchParams();\n\n  for (let [key, value] of formData.entries()) {\n    invariant(typeof value === \"string\", 'File inputs are not supported with encType \"application/x-www-form-urlencoded\", ' + 'please use \"multipart/form-data\" instead.');\n    searchParams.append(key, value);\n  }\n\n  return searchParams;\n}\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 = {}; // Process loader results into state.loaderData/state.errors\n\n  results.forEach((result, index) => {\n    let id = matchesToLoad[index].route.id;\n    invariant(!isRedirectResult(result), \"Cannot handle redirect results in processLoaderData\");\n\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; // 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\n      if (pendingError) {\n        error = Object.values(pendingError)[0];\n        pendingError = undefined;\n      }\n\n      errors = Object.assign(errors || {}, {\n        [boundaryMatch.route.id]: error\n      }); // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;\n      }\n\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else if (isDeferredResult(result)) {\n      activeDeferreds && activeDeferreds.set(id, result.deferredData);\n      loaderData[id] = result.deferredData.data; // TODO: Add statusCode/headers once we wire up streaming in Remix\n    } else {\n      loaderData[id] = result.data; // Error status codes always override success status codes, but if all\n      // loaders are successful we take the deepest status code.\n\n      if (result.statusCode != null && result.statusCode !== 200 && !foundError) {\n        statusCode = result.statusCode;\n      }\n\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    }\n  }); // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here\n\n  if (pendingError) {\n    errors = pendingError;\n  }\n\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders\n  };\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); // Process results from our revalidating fetchers\n\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let [key,, match] = revalidatingFetchers[index];\n    invariant(fetcherResults !== undefined && fetcherResults[index] !== undefined, \"Did not find corresponding fetcher result\");\n    let result = fetcherResults[index]; // Process fetcher non-redirect errors\n\n    if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match.route.id);\n\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = _extends({}, errors, {\n          [boundaryMatch.route.id]: result.error\n        });\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      throw new Error(\"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      throw new Error(\"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = {\n        state: \"idle\",\n        data: result.data,\n        formMethod: undefined,\n        formAction: undefined,\n        formEncType: undefined,\n        formData: undefined\n      };\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  return {\n    loaderData,\n    errors\n  };\n}\n\nfunction mergeLoaderData(loaderData, newLoaderData, matches) {\n  let mergedLoaderData = _extends({}, newLoaderData);\n\n  matches.forEach(match => {\n    let id = match.route.id;\n\n    if (newLoaderData[id] === undefined && loaderData[id] !== undefined) {\n      mergedLoaderData[id] = loaderData[id];\n    }\n  });\n  return mergedLoaderData;\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\n\n\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}\n\nfunction getShortCircuitMatches(routes, status, statusText) {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route = routes.find(r => r.index || !r.path || r.path === \"/\") || {\n    id: \"__shim-\" + status + \"-route__\"\n  };\n  return {\n    matches: [{\n      params: {},\n      pathname: \"\",\n      pathnameBase: \"\",\n      route\n    }],\n    route,\n    error: new ErrorResponse(status, statusText, null)\n  };\n}\n\nfunction getNotFoundMatches(routes) {\n  return getShortCircuitMatches(routes, 404, \"Not Found\");\n}\n\nfunction getMethodNotAllowedMatches(routes) {\n  return getShortCircuitMatches(routes, 405, \"Method Not Allowed\");\n}\n\nfunction getMethodNotAllowedResult(path) {\n  let href = typeof path === \"string\" ? path : createPath(path);\n  console.warn(\"You're trying to submit to a route that does not have an action.  To \" + \"fix this, please add an `action` function to the route for \" + (\"[\" + href + \"]\"));\n  return {\n    type: ResultType.error,\n    error: new ErrorResponse(405, \"Method Not Allowed\", \"\")\n  };\n} // Find any returned redirect errors, starting from the lowest match\n\n\nfunction findRedirect(results) {\n  for (let i = results.length - 1; i >= 0; i--) {\n    let result = results[i];\n\n    if (isRedirectResult(result)) {\n      return result;\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}\n\nfunction isHashChangeOnly(a, b) {\n  return a.pathname === b.pathname && a.search === b.search && a.hash !== b.hash;\n}\n\nfunction isDeferredResult(result) {\n  return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result) {\n  return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result) {\n  return (result && result.type) === ResultType.redirect;\n}\n\nfunction isRedirectResponse(result) {\n  if (!(result instanceof Response)) {\n    return false;\n  }\n\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\n\nfunction isQueryRouteResponse(obj) {\n  return obj && obj.response instanceof Response && (obj.type === ResultType.data || ResultType.error);\n}\n\nasync function resolveDeferredResults(currentMatches, matchesToLoad, results, signal, isFetcher, currentLoaderData) {\n  for (let index = 0; index < results.length; index++) {\n    let result = results[index];\n    let match = matchesToLoad[index];\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\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      await resolveDeferredData(result, signal, isFetcher).then(result => {\n        if (result) {\n          results[index] = result || results[index];\n        }\n      });\n    }\n  }\n}\n\nasync function resolveDeferredData(result, signal, unwrap) {\n  if (unwrap === void 0) {\n    unwrap = false;\n  }\n\n  let aborted = await result.deferredData.resolveData(signal);\n\n  if (aborted) {\n    return;\n  }\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\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data\n  };\n}\n\nfunction hasNakedIndexQuery(search) {\n  return new URLSearchParams(search).getAll(\"index\").some(v => v === \"\");\n} // Note: This should match the format exported by useMatches, so if you change\n// this please also change that :)  Eventually we'll DRY this up\n\n\nfunction createUseMatchesMatch(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}\n\nfunction getTargetMatch(matches, location) {\n  let search = typeof location === \"string\" ? parsePath(location).search : location.search;\n\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  } // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n\n\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n} //#endregion\n\nexport { AbortedDeferredError, Action, ErrorResponse, IDLE_FETCHER, IDLE_NAVIGATION, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, getPathContributingMatches as UNSAFE_getPathContributingMatches, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, defer, generatePath, getStaticContextFromError, getToPathname, invariant, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, resolvePath, resolveTo, stripBasename, unstable_createStaticHandler, warning };\n//# sourceMappingURL=router.js.map\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 s = Object.getOwnPropertySymbols(e);\n    for (r = 0; r < s.length; r++) o = s[r], t.includes(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.4.3\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_enhanceManualRouteObjects, Router, useHref, useResolvedPath, useLocation, UNSAFE_DataRouterStateContext, useNavigate, createPath, UNSAFE_NavigationContext, UNSAFE_RouteContext, useMatches, useNavigation, UNSAFE_DataRouterContext } from 'react-router';\nexport { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, RouterProvider, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_DataStaticRouterContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_enhanceManualRouteObjects, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, renderMatches, resolvePath, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router';\nimport { createRouter, createBrowserHistory, createHashHistory, invariant, joinPaths } 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\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\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}\n\nfunction isModifiedEvent(event) {\n  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\n\nfunction shouldProcessLinkClick(event, target) {\n  return event.button === 0 && ( // Ignore everything but left clicks\n  !target || target === \"_self\") && // 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 */\n\nfunction createSearchParams(init) {\n  if (init === void 0) {\n    init = \"\";\n  }\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\n  for (let key of defaultSearchParams.keys()) {\n    if (!searchParams.has(key)) {\n      defaultSearchParams.getAll(key).forEach(value => {\n        searchParams.append(key, value);\n      });\n    }\n  }\n\n  return searchParams;\n}\nfunction getFormSubmissionInfo(target, defaultAction, options) {\n  let method;\n  let action;\n  let encType;\n  let formData;\n\n  if (isFormElement(target)) {\n    let submissionTrigger = options.submissionTrigger;\n    method = options.method || target.getAttribute(\"method\") || defaultMethod;\n    action = options.action || target.getAttribute(\"action\") || defaultAction;\n    encType = options.encType || target.getAttribute(\"enctype\") || defaultEncType;\n    formData = new FormData(target);\n\n    if (submissionTrigger && submissionTrigger.name) {\n      formData.append(submissionTrigger.name, submissionTrigger.value);\n    }\n  } else if (isButtonElement(target) || isInputElement(target) && (target.type === \"submit\" || target.type === \"image\")) {\n    let form = target.form;\n\n    if (form == null) {\n      throw new Error(\"Cannot submit a <button> or <input type=\\\"submit\\\"> without a <form>\");\n    } // <button>/<input type=\"submit\"> may override attributes of <form>\n\n\n    method = options.method || target.getAttribute(\"formmethod\") || form.getAttribute(\"method\") || defaultMethod;\n    action = options.action || target.getAttribute(\"formaction\") || form.getAttribute(\"action\") || defaultAction;\n    encType = options.encType || target.getAttribute(\"formenctype\") || form.getAttribute(\"enctype\") || defaultEncType;\n    formData = new FormData(form); // Include name + value from a <button>, appending in case the button name\n    // matches an existing input name\n\n    if (target.name) {\n      formData.append(target.name, target.value);\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 = options.method || defaultMethod;\n    action = options.action || defaultAction;\n    encType = options.encType || defaultEncType;\n\n    if (target instanceof FormData) {\n      formData = target;\n    } else {\n      formData = new FormData();\n\n      if (target instanceof URLSearchParams) {\n        for (let [name, value] of target) {\n          formData.append(name, value);\n        }\n      } else if (target != null) {\n        for (let name of Object.keys(target)) {\n          formData.append(name, target[name]);\n        }\n      }\n    }\n  }\n\n  let {\n    protocol,\n    host\n  } = window.location;\n  let url = new URL(action, protocol + \"//\" + host);\n  return {\n    url,\n    method,\n    encType,\n    formData\n  };\n}\n\nconst _excluded = [\"onClick\", \"relative\", \"reloadDocument\", \"replace\", \"state\", \"target\", \"to\", \"preventScrollReset\"],\n      _excluded2 = [\"aria-current\", \"caseSensitive\", \"className\", \"end\", \"style\", \"to\", \"children\"],\n      _excluded3 = [\"reloadDocument\", \"replace\", \"method\", \"action\", \"onSubmit\", \"fetcherKey\", \"routeId\", \"relative\"];\n//#region Routers\n////////////////////////////////////////////////////////////////////////////////\n\nfunction createBrowserRouter(routes, opts) {\n  var _window;\n\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    history: createBrowserHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || ((_window = window) == null ? void 0 : _window.__staticRouterHydrationData),\n    routes: UNSAFE_enhanceManualRouteObjects(routes)\n  }).initialize();\n}\nfunction createHashRouter(routes, opts) {\n  var _window2;\n\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    history: createHashHistory({\n      window: opts == null ? void 0 : opts.window\n    }),\n    hydrationData: (opts == null ? void 0 : opts.hydrationData) || ((_window2 = window) == null ? void 0 : _window2.__staticRouterHydrationData),\n    routes: UNSAFE_enhanceManualRouteObjects(routes)\n  }).initialize();\n}\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\n\nfunction BrowserRouter(_ref) {\n  let {\n    basename,\n    children,\n    window\n  } = _ref;\n  let historyRef = React.useRef();\n\n  if (historyRef.current == null) {\n    historyRef.current = createBrowserHistory({\n      window,\n      v5Compat: true\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history\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 */\n\nfunction HashRouter(_ref2) {\n  let {\n    basename,\n    children,\n    window\n  } = _ref2;\n  let historyRef = React.useRef();\n\n  if (historyRef.current == null) {\n    historyRef.current = createHashHistory({\n      window,\n      v5Compat: true\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history\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 */\n\nfunction HistoryRouter(_ref3) {\n  let {\n    basename,\n    children,\n    history\n  } = _ref3;\n  const [state, setState] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history\n  });\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\n/**\n * The public API for rendering a history-aware <a>.\n */\n\nconst Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref4, ref) {\n  let {\n    onClick,\n    relative,\n    reloadDocument,\n    replace,\n    state,\n    target,\n    to,\n    preventScrollReset\n  } = _ref4,\n      rest = _objectWithoutPropertiesLoose(_ref4, _excluded);\n\n  let href = useHref(to, {\n    relative\n  });\n  let internalOnClick = useLinkClickHandler(to, {\n    replace,\n    state,\n    target,\n    preventScrollReset,\n    relative\n  });\n\n  function handleClick(event) {\n    if (onClick) onClick(event);\n\n    if (!event.defaultPrevented) {\n      internalOnClick(event);\n    }\n  }\n\n  return (\n    /*#__PURE__*/\n    // eslint-disable-next-line jsx-a11y/anchor-has-content\n    React.createElement(\"a\", _extends({}, rest, {\n      href: href,\n      onClick: reloadDocument ? onClick : handleClick,\n      ref: ref,\n      target: target\n    }))\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 */\n\n\nconst NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef(_ref5, ref) {\n  let {\n    \"aria-current\": ariaCurrentProp = \"page\",\n    caseSensitive = false,\n    className: classNameProp = \"\",\n    end = false,\n    style: styleProp,\n    to,\n    children\n  } = _ref5,\n      rest = _objectWithoutPropertiesLoose(_ref5, _excluded2);\n\n  let path = useResolvedPath(to, {\n    relative: rest.relative\n  });\n  let location = useLocation();\n  let routerState = React.useContext(UNSAFE_DataRouterStateContext);\n  let toPathname = path.pathname;\n  let locationPathname = location.pathname;\n  let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;\n\n  if (!caseSensitive) {\n    locationPathname = locationPathname.toLowerCase();\n    nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;\n    toPathname = toPathname.toLowerCase();\n  }\n\n  let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === \"/\";\n  let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === \"/\");\n  let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n  let className;\n\n  if (typeof classNameProp === \"function\") {\n    className = classNameProp({\n      isActive,\n      isPending\n    });\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].filter(Boolean).join(\" \");\n  }\n\n  let style = typeof styleProp === \"function\" ? styleProp({\n    isActive,\n    isPending\n  }) : 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  }), typeof children === \"function\" ? children({\n    isActive,\n    isPending\n  }) : children);\n});\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 */\n\n\nconst Form = /*#__PURE__*/React.forwardRef((props, ref) => {\n  return /*#__PURE__*/React.createElement(FormImpl, _extends({}, props, {\n    ref: ref\n  }));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  Form.displayName = \"Form\";\n}\n\nconst FormImpl = /*#__PURE__*/React.forwardRef((_ref6, forwardedRef) => {\n  let {\n    reloadDocument,\n    replace,\n    method = defaultMethod,\n    action,\n    onSubmit,\n    fetcherKey,\n    routeId,\n    relative\n  } = _ref6,\n      props = _objectWithoutPropertiesLoose(_ref6, _excluded3);\n\n  let submit = useSubmitImpl(fetcherKey, routeId);\n  let formMethod = method.toLowerCase() === \"get\" ? \"get\" : \"post\";\n  let formAction = useFormAction(action, {\n    relative\n  });\n\n  let submitHandler = event => {\n    onSubmit && onSubmit(event);\n    if (event.defaultPrevented) return;\n    event.preventDefault();\n    let submitter = event.nativeEvent.submitter;\n    submit(submitter || event.currentTarget, {\n      method,\n      replace,\n      relative\n    });\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});\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 */\n\n\nfunction ScrollRestoration(_ref7) {\n  let {\n    getKey,\n    storageKey\n  } = _ref7;\n  useScrollRestoration({\n    getKey,\n    storageKey\n  });\n  return null;\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  ScrollRestoration.displayName = \"ScrollRestoration\";\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Hooks\n////////////////////////////////////////////////////////////////////////////////\n\n\nvar DataRouterHook;\n\n(function (DataRouterHook) {\n  DataRouterHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n  DataRouterHook[\"UseSubmitImpl\"] = \"useSubmitImpl\";\n  DataRouterHook[\"UseFetcher\"] = \"useFetcher\";\n})(DataRouterHook || (DataRouterHook = {}));\n\nvar DataRouterStateHook;\n\n(function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseFetchers\"] = \"useFetchers\";\n  DataRouterStateHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n})(DataRouterStateHook || (DataRouterStateHook = {}));\n\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.\";\n}\n\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(UNSAFE_DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;\n  return ctx;\n}\n\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(UNSAFE_DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;\n  return state;\n}\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 */\n\n\nfunction useLinkClickHandler(to, _temp) {\n  let {\n    target,\n    replace: replaceProp,\n    state,\n    preventScrollReset,\n    relative\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(); // 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\n      let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path);\n      navigate(to, {\n        replace,\n        state,\n        preventScrollReset,\n        relative\n      });\n    }\n  }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative]);\n}\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\n\nfunction useSearchParams(defaultInit) {\n  process.env.NODE_ENV !== \"production\" ? 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 location = useLocation();\n  let searchParams = React.useMemo(() => getSearchParamsForLocation(location.search, 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    navigate(\"?\" + newSearchParams, navigateOptions);\n  }, [navigate, searchParams]);\n  return [searchParams, setSearchParams];\n}\n/**\n * Returns a function that may be used to programmatically submit a form (or\n * some arbitrary data) to the server.\n */\n\nfunction useSubmit() {\n  return useSubmitImpl();\n}\n\nfunction useSubmitImpl(fetcherKey, routeId) {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseSubmitImpl);\n  let defaultAction = useFormAction();\n  return React.useCallback(function (target, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\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\n    let {\n      method,\n      encType,\n      formData,\n      url\n    } = getFormSubmissionInfo(target, defaultAction, options);\n    let href = url.pathname + url.search;\n    let opts = {\n      replace: options.replace,\n      formData,\n      formMethod: method,\n      formEncType: encType\n    };\n\n    if (fetcherKey) {\n      !(routeId != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"No routeId available for useFetcher()\") : invariant(false) : void 0;\n      router.fetch(fetcherKey, routeId, href, opts);\n    } else {\n      router.navigate(href, opts);\n    }\n  }, [defaultAction, router, fetcherKey, routeId]);\n}\n\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\" ? invariant(false, \"useFormAction must be used inside a RouteContext\") : invariant(false) : void 0;\n  let [match] = routeContext.matches.slice(-1);\n  let resolvedAction = action != null ? action : \".\"; // Shallow clone path so we can modify it below, otherwise we modify the\n  // object referenced by useMemo inside useResolvedPath\n\n  let path = _extends({}, useResolvedPath(resolvedAction, {\n    relative\n  })); // Previously we set the default action to \".\". The problem with this is that\n  // `useResolvedPath(\".\")` excludes search params and the hash of the resolved\n  // URL. This is the intended behavior of when \".\" is specifically provided as\n  // the form action, but inconsistent w/ browsers when the action is omitted.\n  // https://github.com/remix-run/remix/issues/927\n\n\n  let location = useLocation();\n\n  if (action == null) {\n    // Safe to write to these directly here since if action was undefined, we\n    // would have called useResolvedPath(\".\") which will never include a search\n    // or hash\n    path.search = location.search;\n    path.hash = location.hash; // When grabbing search params from the URL, remove the automatically\n    // inserted ?index param so we match the useResolvedPath search behavior\n    // which would not include ?index\n\n    if (match.route.index) {\n      let params = new URLSearchParams(path.search);\n      params.delete(\"index\");\n      path.search = params.toString() ? \"?\" + params.toString() : \"\";\n    }\n  }\n\n  if ((!action || action === \".\") && match.route.index) {\n    path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\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\n\n  if (basename !== \"/\") {\n    path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\nfunction createFetcherForm(fetcherKey, routeId) {\n  let FetcherForm = /*#__PURE__*/React.forwardRef((props, ref) => {\n    return /*#__PURE__*/React.createElement(FormImpl, _extends({}, props, {\n      ref: ref,\n      fetcherKey: fetcherKey,\n      routeId: routeId\n    }));\n  });\n\n  if (process.env.NODE_ENV !== \"production\") {\n    FetcherForm.displayName = \"fetcher.Form\";\n  }\n\n  return FetcherForm;\n}\n\nlet fetcherId = 0;\n/**\n * Interacts with route loaders and actions without causing a navigation. Great\n * for any interaction that stays on the same page.\n */\n\nfunction useFetcher() {\n  var _route$matches;\n\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseFetcher);\n  let route = React.useContext(UNSAFE_RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useFetcher must be used inside a RouteContext\") : invariant(false) : void 0;\n  let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id;\n  !(routeId != null) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useFetcher can only be used on routes that contain a unique \\\"id\\\"\") : invariant(false) : void 0;\n  let [fetcherKey] = React.useState(() => String(++fetcherId));\n  let [Form] = React.useState(() => {\n    !routeId ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"No routeId available for fetcher.Form()\") : invariant(false) : void 0;\n    return createFetcherForm(fetcherKey, routeId);\n  });\n  let [load] = React.useState(() => href => {\n    !router ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"No router available for fetcher.load()\") : invariant(false) : void 0;\n    !routeId ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"No routeId available for fetcher.load()\") : invariant(false) : void 0;\n    router.fetch(fetcherKey, routeId, href);\n  });\n  let submit = useSubmitImpl(fetcherKey, routeId);\n  let fetcher = router.getFetcher(fetcherKey);\n  let fetcherWithComponents = React.useMemo(() => _extends({\n    Form,\n    submit,\n    load\n  }, fetcher), [fetcher, Form, submit, load]);\n  React.useEffect(() => {\n    // Is this busted when the React team gets real weird and calls effects\n    // twice on mount?  We really just need to garbage collect here when this\n    // fetcher is no longer around.\n    return () => {\n      if (!router) {\n        console.warn(\"No fetcher available to clean up from useFetcher()\");\n        return;\n      }\n\n      router.deleteFetcher(fetcherKey);\n    };\n  }, [router, fetcherKey]);\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 */\n\nfunction useFetchers() {\n  let state = useDataRouterState(DataRouterStateHook.UseFetchers);\n  return [...state.fetchers.values()];\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 */\n\nfunction useScrollRestoration(_temp3) {\n  let {\n    getKey,\n    storageKey\n  } = _temp3 === void 0 ? {} : _temp3;\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseScrollRestoration);\n  let {\n    restoreScrollPosition,\n    preventScrollReset\n  } = useDataRouterState(DataRouterStateHook.UseScrollRestoration);\n  let location = useLocation();\n  let matches = useMatches();\n  let navigation = useNavigation(); // Trigger manual scroll restoration while we're active\n\n  React.useEffect(() => {\n    window.history.scrollRestoration = \"manual\";\n    return () => {\n      window.history.scrollRestoration = \"auto\";\n    };\n  }, []); // Save positions on unload\n\n  useBeforeUnload(React.useCallback(() => {\n    if (navigation.state === \"idle\") {\n      let key = (getKey ? getKey(location, matches) : null) || location.key;\n      savedScrollPositions[key] = window.scrollY;\n    }\n\n    sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));\n    window.history.scrollRestoration = \"auto\";\n  }, [storageKey, getKey, navigation.state, location, matches])); // Read in any saved scroll locations\n\n  React.useLayoutEffect(() => {\n    try {\n      let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY);\n\n      if (sessionPositions) {\n        savedScrollPositions = JSON.parse(sessionPositions);\n      }\n    } catch (e) {// no-op, use default empty object\n    }\n  }, [storageKey]); // Enable scroll restoration in the router\n\n  React.useLayoutEffect(() => {\n    let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKey);\n    return () => disableScrollRestoration && disableScrollRestoration();\n  }, [router, getKey]); // Restore scrolling when state.restoreScrollPosition changes\n\n  React.useLayoutEffect(() => {\n    // Explicit false means don't do anything (used for submissions)\n    if (restoreScrollPosition === false) {\n      return;\n    } // been here before, scroll to it\n\n\n    if (typeof restoreScrollPosition === \"number\") {\n      window.scrollTo(0, restoreScrollPosition);\n      return;\n    } // try to scroll to the hash\n\n\n    if (location.hash) {\n      let el = document.getElementById(location.hash.slice(1));\n\n      if (el) {\n        el.scrollIntoView();\n        return;\n      }\n    } // Opt out of scroll reset if this link requested it\n\n\n    if (preventScrollReset === true) {\n      return;\n    } // otherwise go to the top on new locations\n\n\n    window.scrollTo(0, 0);\n  }, [location, restoreScrollPosition, preventScrollReset]);\n}\n\nfunction useBeforeUnload(callback) {\n  React.useEffect(() => {\n    window.addEventListener(\"beforeunload\", callback);\n    return () => {\n      window.removeEventListener(\"beforeunload\", callback);\n    };\n  }, [callback]);\n} //#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Utils\n////////////////////////////////////////////////////////////////////////////////\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\n    try {\n      // Welcome to debugging React Router!\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); // eslint-disable-next-line no-empty\n    } catch (e) {}\n  }\n} //#endregion\n\nexport { BrowserRouter, Form, HashRouter, Link, NavLink, ScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit };\n//# sourceMappingURL=index.js.map\n","/**\n * React Router v6.4.3\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 { invariant, joinPaths, matchPath, UNSAFE_getPathContributingMatches, warning, resolveTo, parsePath, matchRoutes, Action, isRouteErrorResponse, createMemoryHistory, stripBasename, AbortedDeferredError, createRouter } from '@remix-run/router';\nexport { AbortedDeferredError, Action as NavigationType, createPath, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, resolvePath } from '@remix-run/router';\nimport * as React from 'react';\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\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\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/**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\n\nfunction isPolyfill(x, y) {\n  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare\n  ;\n}\n\nconst is = typeof Object.is === \"function\" ? Object.is : isPolyfill; // Intentionally not using named imports because Rollup uses dynamic\n// dispatch for CommonJS interop named imports.\n\nconst {\n  useState,\n  useEffect,\n  useLayoutEffect,\n  useDebugValue\n} = React;\nlet didWarnOld18Alpha = false;\nlet didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works\n// because of a very particular set of implementation details and assumptions\n// -- change any one of them and it will break. The most important assumption\n// is that updates are always synchronous, because concurrent rendering is\n// only available in versions of React that also have a built-in\n// useSyncExternalStore API. And we only use this shim when the built-in API\n// does not exist.\n//\n// Do not assume that the clever hacks used by this hook also work in general.\n// The point of this shim is to replace the need for hacks by other libraries.\n\nfunction useSyncExternalStore$2(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of\n// React do not expose a way to check if we're hydrating. So users of the shim\n// will need to track that themselves and return the correct value\n// from `getSnapshot`.\ngetServerSnapshot) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!didWarnOld18Alpha) {\n      if (\"startTransition\" in React) {\n        didWarnOld18Alpha = true;\n        console.error(\"You are using an outdated, pre-release alpha of React 18 that \" + \"does not support useSyncExternalStore. The \" + \"use-sync-external-store shim will not work correctly. Upgrade \" + \"to a newer pre-release.\");\n      }\n    }\n  } // Read the current snapshot from the store on every render. Again, this\n  // breaks the rules of React, and only works here because of specific\n  // implementation details, most importantly that updates are\n  // always synchronous.\n\n\n  const value = getSnapshot();\n\n  if (process.env.NODE_ENV !== \"production\") {\n    if (!didWarnUncachedGetSnapshot) {\n      const cachedValue = getSnapshot();\n\n      if (!is(value, cachedValue)) {\n        console.error(\"The result of getSnapshot should be cached to avoid an infinite loop\");\n        didWarnUncachedGetSnapshot = true;\n      }\n    }\n  } // Because updates are synchronous, we don't queue them. Instead we force a\n  // re-render whenever the subscribed state changes by updating an some\n  // arbitrary useState hook. Then, during render, we call getSnapshot to read\n  // the current value.\n  //\n  // Because we don't actually use the state returned by the useState hook, we\n  // can save a bit of memory by storing other stuff in that slot.\n  //\n  // To implement the early bailout, we need to track some things on a mutable\n  // object. Usually, we would put that in a useRef hook, but we can stash it in\n  // our useState hook instead.\n  //\n  // To force a re-render, we call forceUpdate({inst}). That works because the\n  // new object always fails an equality check.\n\n\n  const [{\n    inst\n  }, forceUpdate] = useState({\n    inst: {\n      value,\n      getSnapshot\n    }\n  }); // Track the latest getSnapshot function with a ref. This needs to be updated\n  // in the layout phase so we can access it during the tearing check that\n  // happens on subscribe.\n\n  useLayoutEffect(() => {\n    inst.value = value;\n    inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the\n    // commit phase if there was an interleaved mutation. In concurrent mode\n    // this can happen all the time, but even in synchronous mode, an earlier\n    // effect may have mutated the store.\n\n    if (checkIfSnapshotChanged(inst)) {\n      // Force a re-render.\n      forceUpdate({\n        inst\n      });\n    } // eslint-disable-next-line react-hooks/exhaustive-deps\n\n  }, [subscribe, value, getSnapshot]);\n  useEffect(() => {\n    // Check for changes right before subscribing. Subsequent changes will be\n    // detected in the subscription handler.\n    if (checkIfSnapshotChanged(inst)) {\n      // Force a re-render.\n      forceUpdate({\n        inst\n      });\n    }\n\n    const handleStoreChange = () => {\n      // TODO: Because there is no cross-renderer API for batching updates, it's\n      // up to the consumer of this library to wrap their subscription event\n      // with unstable_batchedUpdates. Should we try to detect when this isn't\n      // the case and print a warning in development?\n      // The store changed. Check if the snapshot changed since the last time we\n      // read from the store.\n      if (checkIfSnapshotChanged(inst)) {\n        // Force a re-render.\n        forceUpdate({\n          inst\n        });\n      }\n    }; // Subscribe to the store and return a clean-up function.\n\n\n    return subscribe(handleStoreChange); // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [subscribe]);\n  useDebugValue(value);\n  return value;\n}\n\nfunction checkIfSnapshotChanged(inst) {\n  const latestGetSnapshot = inst.getSnapshot;\n  const prevValue = inst.value;\n\n  try {\n    const nextValue = latestGetSnapshot();\n    return !is(prevValue, nextValue);\n  } catch (error) {\n    return true;\n  }\n}\n\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 * @flow\n */\nfunction useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {\n  // Note: The shim does not use getServerSnapshot, because pre-18 versions of\n  // React do not expose a way to check if we're hydrating. So users of the shim\n  // will need to track that themselves and return the correct value\n  // from `getSnapshot`.\n  return getSnapshot();\n}\n\n/**\n * Inlined into the react-router repo since use-sync-external-store does not\n * provide a UMD-compatible package, so we need this to be able to distribute\n * UMD react-router bundles\n */\nconst canUseDOM = !!(typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\");\nconst isServerEnvironment = !canUseDOM;\nconst shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore$2;\nconst useSyncExternalStore = \"useSyncExternalStore\" in React ? (module => module.useSyncExternalStore)(React) : shim;\n\n// Contexts for data routers\nconst DataStaticRouterContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  DataStaticRouterContext.displayName = \"DataStaticRouterContext\";\n}\n\nconst DataRouterContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterContext.displayName = \"DataRouter\";\n}\n\nconst DataRouterStateContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\n\nconst AwaitContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  AwaitContext.displayName = \"Await\";\n}\n\nconst NavigationContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  NavigationContext.displayName = \"Navigation\";\n}\n\nconst LocationContext = /*#__PURE__*/React.createContext(null);\n\nif (process.env.NODE_ENV !== \"production\") {\n  LocationContext.displayName = \"Location\";\n}\n\nconst RouteContext = /*#__PURE__*/React.createContext({\n  outlet: null,\n  matches: []\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  RouteContext.displayName = \"Route\";\n}\n\nconst RouteErrorContext = /*#__PURE__*/React.createContext(null);\n\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/docs/en/v6/hooks/use-href\n */\n\nfunction useHref(to, _temp) {\n  let {\n    relative\n  } = _temp === void 0 ? {} : _temp;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : 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; // 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\n  if (basename !== \"/\") {\n    joinedPathname = pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({\n    pathname: joinedPathname,\n    search,\n    hash\n  });\n}\n/**\n * Returns true if this component is a descendant of a <Router>.\n *\n * @see https://reactrouter.com/docs/en/v6/hooks/use-in-router-context\n */\n\nfunction useInRouterContext() {\n  return React.useContext(LocationContext) != null;\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/docs/en/v6/hooks/use-location\n */\n\nfunction useLocation() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  return React.useContext(LocationContext).location;\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/docs/en/v6/hooks/use-navigation-type\n */\n\nfunction useNavigationType() {\n  return React.useContext(LocationContext).navigationType;\n}\n/**\n * Returns true if the URL for the given \"to\" value 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/docs/en/v6/hooks/use-match\n */\n\nfunction useMatch(pattern) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  let {\n    pathname\n  } = useLocation();\n  return React.useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);\n}\n/**\n * The interface for the navigate() function returned from useNavigate().\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/docs/en/v6/hooks/use-navigate\n */\nfunction useNavigate() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  let {\n    basename,\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_getPathContributingMatches(matches).map(match => match.pathnameBase));\n  let activeRef = React.useRef(false);\n  React.useEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    process.env.NODE_ENV !== \"production\" ? warning(activeRef.current, \"You should call navigate() in a React.useEffect(), not when \" + \"your component is first rendered.\") : void 0;\n    if (!activeRef.current) return;\n\n    if (typeof to === \"number\") {\n      navigator.go(to);\n      return;\n    }\n\n    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === \"path\"); // If we're operating within a basename, prepend it to the pathname prior\n    // to handing off to history.  If this is a root navigation, then we\n    // navigate to the raw basename which allows the basename to have full\n    // control over the presence of a trailing slash on root links\n\n    if (basename !== \"/\") {\n      path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n    }\n\n    (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);\n  }, [basename, navigator, routePathnamesJson, locationPathname]);\n  return navigate;\n}\nconst OutletContext = /*#__PURE__*/React.createContext(null);\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/docs/en/v6/hooks/use-outlet-context\n */\n\nfunction useOutletContext() {\n  return React.useContext(OutletContext);\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/docs/en/v6/hooks/use-outlet\n */\n\nfunction useOutlet(context) {\n  let outlet = React.useContext(RouteContext).outlet;\n\n  if (outlet) {\n    return /*#__PURE__*/React.createElement(OutletContext.Provider, {\n      value: context\n    }, outlet);\n  }\n\n  return outlet;\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/docs/en/v6/hooks/use-params\n */\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 * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/docs/en/v6/hooks/use-resolved-path\n */\n\nfunction useResolvedPath(to, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getPathContributingMatches(matches).map(match => match.pathnameBase));\n  return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === \"path\"), [to, routePathnamesJson, locationPathname, relative]);\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/docs/en/v6/hooks/use-routes\n */\n\nfunction useRoutes(routes, locationArg) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  let dataRouterStateContext = React.useContext(DataRouterStateContext);\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\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\n  let locationFromContext = useLocation();\n  let location;\n\n  if (locationArg) {\n    var _parsedLocationArg$pa;\n\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\" ? 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.\")) : invariant(false) : void 0;\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\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\n  if (process.env.NODE_ENV !== \"production\") {\n    process.env.NODE_ENV !== \"production\" ? warning(parentRoute || matches != null, \"No routes matched location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \") : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(matches == null || matches[matches.length - 1].route.element !== undefined, \"Matched leaf route at location \\\"\" + location.pathname + location.search + location.hash + \"\\\" does not have an element. \" + \"This means it will render an <Outlet /> with a null value by default resulting in an \\\"empty\\\" page.\") : void 0;\n  }\n\n  let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {\n    params: Object.assign({}, parentParams, match.params),\n    pathname: joinPaths([parentPathnameBase, match.pathname]),\n    pathnameBase: match.pathnameBase === \"/\" ? parentPathnameBase : joinPaths([parentPathnameBase, match.pathnameBase])\n  })), parentMatches, dataRouterStateContext || undefined); // 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\n\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\n  return renderedMatches;\n}\n\nfunction DefaultErrorElement() {\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  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"h2\", null, \"Unhandled Thrown Error!\"), /*#__PURE__*/React.createElement(\"h3\", {\n    style: {\n      fontStyle: \"italic\"\n    }\n  }, message), stack ? /*#__PURE__*/React.createElement(\"pre\", {\n    style: preStyles\n  }, stack) : 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\\xA0\", /*#__PURE__*/React.createElement(\"code\", {\n    style: codeStyles\n  }, \"errorElement\"), \" props on\\xA0\", /*#__PURE__*/React.createElement(\"code\", {\n    style: codeStyles\n  }, \"<Route>\")));\n}\n\nclass RenderErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      location: props.location,\n      error: props.error\n    };\n  }\n\n  static getDerivedStateFromError(error) {\n    return {\n      error: error\n    };\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) {\n      return {\n        error: props.error,\n        location: props.location\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\n\n    return {\n      error: props.error || state.error,\n      location: state.location\n    };\n  }\n\n  componentDidCatch(error, errorInfo) {\n    console.error(\"React Router caught the following error during render\", error, errorInfo);\n  }\n\n  render() {\n    return this.state.error ? /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {\n      value: this.state.error,\n      children: this.props.component\n    }) : this.props.children;\n  }\n\n}\n\nfunction RenderedRoute(_ref) {\n  let {\n    routeContext,\n    match,\n    children\n  } = _ref;\n  let dataStaticRouterContext = React.useContext(DataStaticRouterContext); // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n\n  if (dataStaticRouterContext && match.route.errorElement) {\n    dataStaticRouterContext._deepestRenderedBoundaryId = match.route.id;\n  }\n\n  return /*#__PURE__*/React.createElement(RouteContext.Provider, {\n    value: routeContext\n  }, children);\n}\n\nfunction _renderMatches(matches, parentMatches, dataRouterState) {\n  if (parentMatches === void 0) {\n    parentMatches = [];\n  }\n\n  if (matches == null) {\n    if (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\n  let renderedMatches = matches; // If we have data errors, trim matches to the highest error boundary\n\n  let errors = dataRouterState == null ? void 0 : dataRouterState.errors;\n\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\" ? invariant(false, \"Could not find a matching route for the current errors: \" + errors) : invariant(false) : void 0;\n    renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));\n  }\n\n  return renderedMatches.reduceRight((outlet, match, index) => {\n    let error = match.route.id ? errors == null ? void 0 : errors[match.route.id] : null; // Only data routers handle errors\n\n    let errorElement = dataRouterState ? match.route.errorElement || /*#__PURE__*/React.createElement(DefaultErrorElement, null) : null;\n\n    let getChildren = () => /*#__PURE__*/React.createElement(RenderedRoute, {\n      match: match,\n      routeContext: {\n        outlet,\n        matches: parentMatches.concat(renderedMatches.slice(0, index + 1))\n      }\n    }, error ? errorElement : match.route.element !== undefined ? match.route.element : outlet); // Only wrap in an error boundary within data router usages when we have an\n    // errorElement on this route.  Otherwise let it bubble up to an ancestor\n    // errorElement\n\n\n    return dataRouterState && (match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {\n      location: dataRouterState.location,\n      component: errorElement,\n      error: error,\n      children: getChildren()\n    }) : getChildren();\n  }, null);\n}\nvar DataRouterHook;\n\n(function (DataRouterHook) {\n  DataRouterHook[\"UseRevalidator\"] = \"useRevalidator\";\n})(DataRouterHook || (DataRouterHook = {}));\n\nvar DataRouterStateHook;\n\n(function (DataRouterStateHook) {\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 || (DataRouterStateHook = {}));\n\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/en/main/routers/picking-a-router.\";\n}\n\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;\n  return ctx;\n}\n\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? invariant(false, getDataRouterConsoleError(hookName)) : invariant(false) : void 0;\n  return state;\n}\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\n\n\nfunction useNavigation() {\n  let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n  return state.navigation;\n}\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\n\nfunction useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return {\n    revalidate: dataRouterContext.router.revalidate,\n    state: 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 */\n\nfunction useMatches() {\n  let {\n    matches,\n    loaderData\n  } = useDataRouterState(DataRouterStateHook.UseMatches);\n  return React.useMemo(() => matches.map(match => {\n    let {\n      pathname,\n      params\n    } = match; // Note: This structure matches that created by createUseMatchesMatch\n    // in the @remix-run/router , so if you change this please also change\n    // that :)  Eventually we'll DRY this up\n\n    return {\n      id: match.route.id,\n      pathname,\n      params,\n      data: loaderData[match.route.id],\n      handle: match.route.handle\n    };\n  }), [matches, loaderData]);\n}\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\n\nfunction useLoaderData() {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let route = React.useContext(RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useLoaderData must be used inside a RouteContext\") : invariant(false) : void 0;\n  let thisRoute = route.matches[route.matches.length - 1];\n  !thisRoute.route.id ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useLoaderData can only be used on routes that contain a unique \\\"id\\\"\") : invariant(false) : void 0;\n  return state.loaderData[thisRoute.route.id];\n}\n/**\n * Returns the loaderData for the given routeId\n */\n\nfunction useRouteLoaderData(routeId) {\n  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n  return state.loaderData[routeId];\n}\n/**\n * Returns the action data for the nearest ancestor Route action\n */\n\nfunction useActionData() {\n  let state = useDataRouterState(DataRouterStateHook.UseActionData);\n  let route = React.useContext(RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useActionData must be used inside a RouteContext\") : invariant(false) : void 0;\n  return Object.values((state == null ? void 0 : state.actionData) || {})[0];\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 * errorElement to display a proper error message.\n */\n\nfunction useRouteError() {\n  var _state$errors;\n\n  let error = React.useContext(RouteErrorContext);\n  let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n  let route = React.useContext(RouteContext);\n  let thisRoute = route.matches[route.matches.length - 1]; // If this was a render error, we put it in a RouteError context inside\n  // of RenderErrorBoundary\n\n  if (error) {\n    return error;\n  }\n\n  !route ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useRouteError must be used inside a RouteContext\") : invariant(false) : void 0;\n  !thisRoute.route.id ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"useRouteError can only be used on routes that contain a unique \\\"id\\\"\") : invariant(false) : void 0; // Otherwise look for errors from our data router state\n\n  return (_state$errors = state.errors) == null ? void 0 : _state$errors[thisRoute.route.id];\n}\n/**\n * Returns the happy-path data from the nearest ancestor <Await /> value\n */\n\nfunction useAsyncValue() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._data;\n}\n/**\n * Returns the error from the nearest ancestor <Await /> value\n */\n\nfunction useAsyncError() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._error;\n}\nconst alreadyWarned = {};\n\nfunction warningOnce(key, cond, message) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    process.env.NODE_ENV !== \"production\" ? warning(false, message) : void 0;\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  } = _ref;\n  // Sync router state to our component state to force re-renders\n  let state = useSyncExternalStore(router.subscribe, () => router.state, // We have to provide this so React@18 doesn't complain during hydration,\n  // but we pass our serialized hydration data into the router so state here\n  // is already synced with what the server saw\n  () => router.state);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\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  return /*#__PURE__*/React.createElement(DataRouterContext.Provider, {\n    value: {\n      router,\n      navigator,\n      static: false,\n      // Do we need this?\n      basename\n    }\n  }, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(Router, {\n    basename: router.basename,\n    location: router.state.location,\n    navigationType: router.state.historyAction,\n    navigator: navigator\n  }, router.state.initialized ? /*#__PURE__*/React.createElement(Routes, null) : fallbackElement)));\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/docs/en/v6/routers/memory-router\n */\nfunction MemoryRouter(_ref2) {\n  let {\n    basename,\n    children,\n    initialEntries,\n    initialIndex\n  } = _ref2;\n  let historyRef = React.useRef();\n\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setState] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  React.useLayoutEffect(() => history.listen(setState), [history]);\n  return /*#__PURE__*/React.createElement(Router, {\n    basename: basename,\n    children: children,\n    location: state.location,\n    navigationType: state.action,\n    navigator: history\n  });\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/docs/en/v6/components/navigate\n */\nfunction Navigate(_ref3) {\n  let {\n    to,\n    replace,\n    state,\n    relative\n  } = _ref3;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? 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.\") : invariant(false) : void 0;\n  process.env.NODE_ENV !== \"production\" ? warning(!React.useContext(NavigationContext).static, \"<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 dataRouterState = React.useContext(DataRouterStateContext);\n  let navigate = useNavigate();\n  React.useEffect(() => {\n    // Avoid kicking off multiple navigations if we're in the middle of a\n    // data-router navigation, since components get re-rendered when we enter\n    // a submitting/loading state\n    if (dataRouterState && dataRouterState.navigation.state !== \"idle\") {\n      return;\n    }\n\n    navigate(to, {\n      replace,\n      state,\n      relative\n    });\n  });\n  return null;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/docs/en/v6/components/outlet\n */\nfunction Outlet(props) {\n  return useOutlet(props.context);\n}\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/docs/en/v6/components/route\n */\nfunction Route(_props) {\n  process.env.NODE_ENV !== \"production\" ? 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>.\") : invariant(false) ;\n}\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/docs/en/v6/routers/router\n */\nfunction Router(_ref4) {\n  let {\n    basename: basenameProp = \"/\",\n    children = null,\n    location: locationProp,\n    navigationType = Action.Pop,\n    navigator,\n    static: staticProp = false\n  } = _ref4;\n  !!useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You cannot render a <Router> inside another <Router>.\" + \" You should never have more than one in your app.\") : invariant(false) : void 0; // Preserve trailing slashes on basename, so we can let the user control\n  // the enforcement of trailing slashes throughout the app\n\n  let basename = basenameProp.replace(/^\\/*/, \"/\");\n  let navigationContext = React.useMemo(() => ({\n    basename,\n    navigator,\n    static: staticProp\n  }), [basename, navigator, staticProp]);\n\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\"\n  } = locationProp;\n  let location = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      pathname: trailingPathname,\n      search,\n      hash,\n      state,\n      key\n    };\n  }, [basename, pathname, search, hash, state, key]);\n  process.env.NODE_ENV !== \"production\" ? warning(location != 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\n  if (location == null) {\n    return null;\n  }\n\n  return /*#__PURE__*/React.createElement(NavigationContext.Provider, {\n    value: navigationContext\n  }, /*#__PURE__*/React.createElement(LocationContext.Provider, {\n    children: children,\n    value: {\n      location,\n      navigationType\n    }\n  }));\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/docs/en/v6/components/routes\n */\nfunction Routes(_ref5) {\n  let {\n    children,\n    location\n  } = _ref5;\n  let dataRouterContext = React.useContext(DataRouterContext); // When in a DataRouterContext _without_ children, we use the router routes\n  // directly.  If we have children, then we're in a descendant tree and we\n  // need to use child routes.\n\n  let routes = dataRouterContext && !children ? dataRouterContext.router.routes : createRoutesFromChildren(children);\n  return useRoutes(routes, location);\n}\n\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nfunction Await(_ref6) {\n  let {\n    children,\n    errorElement,\n    resolve\n  } = _ref6;\n  return /*#__PURE__*/React.createElement(AwaitErrorBoundary, {\n    resolve: resolve,\n    errorElement: errorElement\n  }, /*#__PURE__*/React.createElement(ResolveAwait, null, children));\n}\nvar AwaitRenderStatus;\n\n(function (AwaitRenderStatus) {\n  AwaitRenderStatus[AwaitRenderStatus[\"pending\"] = 0] = \"pending\";\n  AwaitRenderStatus[AwaitRenderStatus[\"success\"] = 1] = \"success\";\n  AwaitRenderStatus[AwaitRenderStatus[\"error\"] = 2] = \"error\";\n})(AwaitRenderStatus || (AwaitRenderStatus = {}));\n\nconst neverSettledPromise = new Promise(() => {});\n\nclass AwaitErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      error: null\n    };\n  }\n\n  static getDerivedStateFromError(error) {\n    return {\n      error\n    };\n  }\n\n  componentDidCatch(error, errorInfo) {\n    console.error(\"<Await> caught the following error during render\", error, errorInfo);\n  }\n\n  render() {\n    let {\n      children,\n      errorElement,\n      resolve\n    } = this.props;\n    let promise = null;\n    let status = AwaitRenderStatus.pending;\n\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\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\n    if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\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\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    } // Throw to the suspense boundary\n\n\n    throw promise;\n  }\n\n}\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on <Await>\n */\n\n\nfunction ResolveAwait(_ref7) {\n  let {\n    children\n  } = _ref7;\n  let data = useAsyncValue();\n\n  if (typeof children === \"function\") {\n    return children(data);\n  }\n\n  return /*#__PURE__*/React.createElement(React.Fragment, null, children);\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/docs/en/v6/utils/create-routes-from-children\n */\n\n\nfunction createRoutesFromChildren(children, parentPath) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\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\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(routes, createRoutesFromChildren(element.props.children, parentPath));\n      return;\n    }\n\n    !(element.type === Route) ? process.env.NODE_ENV !== \"production\" ? 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>\") : invariant(false) : void 0;\n    !(!element.props.index || !element.props.children) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"An index route cannot have child routes.\") : invariant(false) : void 0;\n    let treePath = [...parentPath, index];\n    let route = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\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      hasErrorBoundary: element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle\n    };\n\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children, treePath);\n    }\n\n    routes.push(route);\n  });\n  return routes;\n}\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\n\nfunction renderMatches(matches) {\n  return _renderMatches(matches);\n}\n/**\n * @private\n * Walk the route tree and add hasErrorBoundary if it's not provided, so that\n * users providing manual route arrays can just specify errorElement\n */\n\nfunction enhanceManualRouteObjects(routes) {\n  return routes.map(route => {\n    let routeClone = _extends({}, route);\n\n    if (routeClone.hasErrorBoundary == null) {\n      routeClone.hasErrorBoundary = routeClone.errorElement != null;\n    }\n\n    if (routeClone.children) {\n      routeClone.children = enhanceManualRouteObjects(routeClone.children);\n    }\n\n    return routeClone;\n  });\n}\n\nfunction createMemoryRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\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: enhanceManualRouteObjects(routes)\n  }).initialize();\n} ///////////////////////////////////////////////////////////////////////////////\n\nexport { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, DataStaticRouterContext as UNSAFE_DataStaticRouterContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, enhanceManualRouteObjects as UNSAFE_enhanceManualRouteObjects, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };\n//# sourceMappingURL=index.js.map\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","handlePop","location","pathname","search","hash","createLocation","state","usr","listen","fn","Error","addEventListener","removeEventListener","to","createPath","encodeLocation","url","createURL","push","Push","historyState","getHistoryState","pushState","error","replace","Replace","replaceState","go","n","getUrlBasedHistory","current","parsePath","Math","random","toString","substr","_ref","charAt","path","parsedPath","hashIndex","indexOf","searchIndex","base","origin","href","URL","ResultType","stripBasename","basename","toLowerCase","startsWith","startIndex","endsWith","nextChar","slice","invariant","value","message","createElement","validActionMethods","Set","_classCallCheck","a","TypeError","_defineProperties","e","r","t","o","enumerable","configurable","writable","defineProperty","toPropertyKey","_createClass","_setPrototypeOf","setPrototypeOf","__proto__","_inherits","create","constructor","_getPrototypeOf","getPrototypeOf","_isNativeReflectConstruct","Boolean","valueOf","Reflect","construct","_assertThisInitialized","ReferenceError","_createSuper","s","warned","preWarningFns","warning","valid","note","method","warningOnce","preMessage","resetWarned","noteOnce","props","_ref2","className","included","vertical","style","offset","reverse","abs","positonStyle","concat","elStyle","objectWithoutPropertiesLoose","getOwnPropertySymbols","includes","propertyIsEnumerable","_arrayLikeToArray","Array","_unsupportedIterableToArray","name","from","test","isArray","Symbol","iterator","_get","get","p","getOwnPropertyDescriptor","addEventListenerWrap","eventType","cb","option","callback","remove","prefixCls","marks","dots","step","lowerBound","upperBound","max","min","dotStyle","activeDotStyle","range","elements","points","keys","map","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","node","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","O","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","some","findDOMNode","isValueOutOfRange","isNotTouchEvent","touches","type","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","func","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","forEach","_this2$handlesRefs$ke","_this2$handlesRefs$ke2","_this$props5","ratio","getSliderLength","pixelOffset","getSliderStart","trimAlignValue","calcValue","_this$props6","index","_this$props7","children","maximumTrackStyle","railStyle","_get$call","tracks","sliderClassName","getLowerBound","getUpperBound","displayName","defaultProps","dragging","onBeforeChange","onAfterChange","trackStyle","handleStyle","Slider","force","getValue","defaultValue","undefined","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","item","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","set","cancel","contains","root","parentNode","isDOM","HTMLElement","SVGElement","_ReactDOM$findDOMNode","domNode","nativeElement","getDOM","fillRef","composeRef","_len","refs","_key","refList","filter","supportRef","nodeOrComponent","_type$prototype","_nodeOrComponent$prot","isMemo","render","$$typeof","ForwardRef","canUseDom","version","forwardRef","didUpdate","getContainer","parentRef","useRef","containerRef","useImperativeHandle","initRef","useEffect","appendChild","_containerRef$current","removeChild","isPointsEq","a1","a2","isAlignPoint","l","u","f","next","done","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","len","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","element","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","result","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","object","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","split","getTransformXY","resultXY","xy","match2d","join","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","size","resizeWidth","resizeHeight","adjustForViewport","alignElement","refNode","isTargetNotOutOfVisible","targetRegion","isOutOfVisibleRect","__getOffsetParent","__getVisibleRectForElement","MapShim","getIndex","entry","class_1","__entries__","entries","splice","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","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","arg","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","stop","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","err","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","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","DataRouterHook","DataRouterStateHook","createSearchParams","init","URLSearchParams","memo","BrowserRouter","historyRef","navigationType","is","useDebugValue","NavigationContext","LocationContext","useInRouterContext","useLocation","AwaitRenderStatus","Router","basenameProp","locationProp","static","staticProp","navigationContext","trailingPathname","Provider"],"sourceRoot":""}