{"version":3,"file":"static/js/4203.ad3fc6ed.chunk.js","mappings":"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","sources":["../node_modules/@ant-design/icons-svg/lib/asn/QuestionCircleOutlined.js","../node_modules/@ant-design/icons/QuestionCircleOutlined.js","../node_modules/@ant-design/icons/lib/icons/QuestionCircleOutlined.js","../node_modules/compute-scroll-into-view/src/index.ts","../node_modules/lodash/_baseTrim.js","../node_modules/lodash/_trimmedEndIndex.js","../node_modules/lodash/debounce.js","../node_modules/lodash/isObject.js","../node_modules/lodash/now.js","../node_modules/lodash/toNumber.js","../node_modules/rc-checkbox/es/index.js","../node_modules/rc-drawer/es/context.js","../node_modules/rc-drawer/es/DrawerPanel.js","../node_modules/rc-drawer/es/util.js","../node_modules/rc-drawer/es/DrawerPopup.js","../node_modules/rc-drawer/es/Drawer.js","../node_modules/rc-drawer/es/index.js","../node_modules/scroll-into-view-if-needed/index.js","../node_modules/usehooks-ts/dist/esm/useBoolean/useBoolean.js","../node_modules/usehooks-ts/dist/esm/useCountdown/useCountdown.js","../node_modules/usehooks-ts/dist/esm/useCounter/useCounter.js","../node_modules/usehooks-ts/dist/esm/useInterval/useInterval.js","../node_modules/usehooks-ts/dist/esm/useIsMounted/useIsMounted.js","../node_modules/usehooks-ts/dist/esm/useIsomorphicLayoutEffect/useIsomorphicLayoutEffect.js","../node_modules/@tanstack/query-core/src/queryObserver.ts","../node_modules/@tanstack/react-query/src/QueryErrorResetBoundary.tsx","../node_modules/@tanstack/react-query/src/isRestoring.tsx","../node_modules/@tanstack/react-query/src/errorBoundaryUtils.ts","../node_modules/@tanstack/react-query/src/suspense.ts","../node_modules/@tanstack/react-query/src/useQuery.ts","../node_modules/@tanstack/react-query/src/useBaseQuery.ts","../node_modules/@tanstack/react-query/src/useSyncExternalStore.ts","../node_modules/@tanstack/react-query/src/utils.ts"],"sourcesContent":["\"use strict\";\n// This icon file is generated automatically.\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar QuestionCircleOutlined = { \"icon\": { \"tag\": \"svg\", \"attrs\": { \"viewBox\": \"64 64 896 896\", \"focusable\": \"false\" }, \"children\": [{ \"tag\": \"path\", \"attrs\": { \"d\": \"M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z\" } }, { \"tag\": \"path\", \"attrs\": { \"d\": \"M623.6 316.7C593.6 290.4 554 276 512 276s-81.6 14.5-111.6 40.7C369.2 344 352 380.7 352 420v7.6c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8V420c0-44.1 43.1-80 96-80s96 35.9 96 80c0 31.1-22 59.6-56.1 72.7-21.2 8.1-39.2 22.3-52.1 40.9-13.1 19-19.9 41.8-19.9 64.9V620c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8v-22.7a48.3 48.3 0 0130.9-44.8c59-22.7 97.1-74.7 97.1-132.5.1-39.3-17.1-76-48.3-103.3zM472 732a40 40 0 1080 0 40 40 0 10-80 0z\" } }] }, \"name\": \"question-circle\", \"theme\": \"outlined\" };\nexports.default = QuestionCircleOutlined;\n","'use strict';\n  Object.defineProperty(exports, \"__esModule\", {\n    value: true\n  });\n  exports.default = void 0;\n  \n  var _QuestionCircleOutlined = _interopRequireDefault(require('./lib/icons/QuestionCircleOutlined'));\n  \n  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n  \n  var _default = _QuestionCircleOutlined;\n  exports.default = _default;\n  module.exports = _default;","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\nvar _typeof = require(\"@babel/runtime/helpers/typeof\");\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\nvar _objectSpread2 = _interopRequireDefault(require(\"@babel/runtime/helpers/objectSpread2\"));\nvar React = _interopRequireWildcard(require(\"react\"));\nvar _QuestionCircleOutlined = _interopRequireDefault(require(\"@ant-design/icons-svg/lib/asn/QuestionCircleOutlined\"));\nvar _AntdIcon = _interopRequireDefault(require(\"../components/AntdIcon\"));\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\n// GENERATE BY ./scripts/generate.ts\n// DON NOT EDIT IT MANUALLY\n\nvar QuestionCircleOutlined = function QuestionCircleOutlined(props, ref) {\n  return /*#__PURE__*/React.createElement(_AntdIcon.default, (0, _objectSpread2.default)((0, _objectSpread2.default)({}, props), {}, {\n    ref: ref,\n    icon: _QuestionCircleOutlined.default\n  }));\n};\nQuestionCircleOutlined.displayName = 'QuestionCircleOutlined';\nvar _default = /*#__PURE__*/React.forwardRef(QuestionCircleOutlined);\nexports.default = _default;","// Compute what scrolling needs to be done on required scrolling boxes for target to be in view\n\n// The type names here are named after the spec to make it easier to find more information around what they mean:\n// To reduce churn and reduce things that need be maintained things from the official TS DOM library is used here\n// https://drafts.csswg.org/cssom-view/\n\n// For a definition on what is \"block flow direction\" exactly, check this: https://drafts.csswg.org/css-writing-modes-4/#block-flow-direction\n\n// add support for visualViewport object currently implemented in chrome\ninterface visualViewport {\n  height: number\n  width: number\n}\n\ntype ScrollLogicalPosition = 'start' | 'center' | 'end' | 'nearest'\n// This new option is tracked in this PR, which is the most likely candidate at the time: https://github.com/w3c/csswg-drafts/pull/1805\ntype ScrollMode = 'always' | 'if-needed'\n// New option that skips auto-scrolling all nodes with overflow: hidden set\n// See FF implementation: https://hg.mozilla.org/integration/fx-team/rev/c48c3ec05012#l7.18\ntype SkipOverflowHiddenElements = boolean\n\ninterface Options {\n  block?: ScrollLogicalPosition\n  inline?: ScrollLogicalPosition\n  scrollMode?: ScrollMode\n  boundary?: CustomScrollBoundary\n  skipOverflowHiddenElements?: SkipOverflowHiddenElements\n}\n\n// Custom behavior, not in any spec\ntype CustomScrollBoundaryCallback = (parent: Element) => boolean\ntype CustomScrollBoundary = Element | CustomScrollBoundaryCallback | null\ninterface CustomScrollAction {\n  el: Element\n  top: number\n  left: number\n}\n\n// @TODO better shadowdom test, 11 = document fragment\nfunction isElement(el: any): el is Element {\n  return typeof el === 'object' && el != null && el.nodeType === 1\n}\n\nfunction canOverflow(\n  overflow: string | null,\n  skipOverflowHiddenElements?: boolean\n) {\n  if (skipOverflowHiddenElements && overflow === 'hidden') {\n    return false\n  }\n\n  return overflow !== 'visible' && overflow !== 'clip'\n}\n\nfunction getFrameElement(el: Element) {\n  if (!el.ownerDocument || !el.ownerDocument.defaultView) {\n    return null\n  }\n\n  try {\n    return el.ownerDocument.defaultView.frameElement\n  } catch (e) {\n    return null\n  }\n}\n\nfunction isHiddenByFrame(el: Element): boolean {\n  const frame = getFrameElement(el)\n  if (!frame) {\n    return false\n  }\n\n  return (\n    frame.clientHeight < el.scrollHeight || frame.clientWidth < el.scrollWidth\n  )\n}\n\nfunction isScrollable(el: Element, skipOverflowHiddenElements?: boolean) {\n  if (el.clientHeight < el.scrollHeight || el.clientWidth < el.scrollWidth) {\n    const style = getComputedStyle(el, null)\n    return (\n      canOverflow(style.overflowY, skipOverflowHiddenElements) ||\n      canOverflow(style.overflowX, skipOverflowHiddenElements) ||\n      isHiddenByFrame(el)\n    )\n  }\n\n  return false\n}\n/**\n * Find out which edge to align against when logical scroll position is \"nearest\"\n * Interesting fact: \"nearest\" works similarily to \"if-needed\", if the element is fully visible it will not scroll it\n *\n * Legends:\n * ┌────────┐ ┏ ━ ━ ━ ┓\n * │ target │   frame\n * └────────┘ ┗ ━ ━ ━ ┛\n */\nfunction alignNearest(\n  scrollingEdgeStart: number,\n  scrollingEdgeEnd: number,\n  scrollingSize: number,\n  scrollingBorderStart: number,\n  scrollingBorderEnd: number,\n  elementEdgeStart: number,\n  elementEdgeEnd: number,\n  elementSize: number\n) {\n  /**\n   * If element edge A and element edge B are both outside scrolling box edge A and scrolling box edge B\n   *\n   *          ┌──┐\n   *        ┏━│━━│━┓\n   *          │  │\n   *        ┃ │  │ ┃        do nothing\n   *          │  │\n   *        ┗━│━━│━┛\n   *          └──┘\n   *\n   *  If element edge C and element edge D are both outside scrolling box edge C and scrolling box edge D\n   *\n   *    ┏ ━ ━ ━ ━ ┓\n   *   ┌───────────┐\n   *   │┃         ┃│        do nothing\n   *   └───────────┘\n   *    ┗ ━ ━ ━ ━ ┛\n   */\n  if (\n    (elementEdgeStart < scrollingEdgeStart &&\n      elementEdgeEnd > scrollingEdgeEnd) ||\n    (elementEdgeStart > scrollingEdgeStart && elementEdgeEnd < scrollingEdgeEnd)\n  ) {\n    return 0\n  }\n\n  /**\n   * If element edge A is outside scrolling box edge A and element height is less than scrolling box height\n   *\n   *          ┌──┐\n   *        ┏━│━━│━┓         ┏━┌━━┐━┓\n   *          └──┘             │  │\n   *  from  ┃      ┃     to  ┃ └──┘ ┃\n   *\n   *        ┗━ ━━ ━┛         ┗━ ━━ ━┛\n   *\n   * If element edge B is outside scrolling box edge B and element height is greater than scrolling box height\n   *\n   *        ┏━ ━━ ━┓         ┏━┌━━┐━┓\n   *                           │  │\n   *  from  ┃ ┌──┐ ┃     to  ┃ │  │ ┃\n   *          │  │             │  │\n   *        ┗━│━━│━┛         ┗━│━━│━┛\n   *          │  │             └──┘\n   *          │  │\n   *          └──┘\n   *\n   * If element edge C is outside scrolling box edge C and element width is less than scrolling box width\n   *\n   *       from                 to\n   *    ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓\n   *  ┌───┐                 ┌───┐\n   *  │ ┃ │       ┃         ┃   │     ┃\n   *  └───┘                 └───┘\n   *    ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛\n   *\n   * If element edge D is outside scrolling box edge D and element width is greater than scrolling box width\n   *\n   *       from                 to\n   *    ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓\n   *        ┌───────────┐   ┌───────────┐\n   *    ┃   │     ┃     │   ┃         ┃ │\n   *        └───────────┘   └───────────┘\n   *    ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛\n   */\n  if (\n    (elementEdgeStart <= scrollingEdgeStart && elementSize <= scrollingSize) ||\n    (elementEdgeEnd >= scrollingEdgeEnd && elementSize >= scrollingSize)\n  ) {\n    return elementEdgeStart - scrollingEdgeStart - scrollingBorderStart\n  }\n\n  /**\n   * If element edge B is outside scrolling box edge B and element height is less than scrolling box height\n   *\n   *        ┏━ ━━ ━┓         ┏━ ━━ ━┓\n   *\n   *  from  ┃      ┃     to  ┃ ┌──┐ ┃\n   *          ┌──┐             │  │\n   *        ┗━│━━│━┛         ┗━└━━┘━┛\n   *          └──┘\n   *\n   * If element edge A is outside scrolling box edge A and element height is greater than scrolling box height\n   *\n   *          ┌──┐\n   *          │  │\n   *          │  │             ┌──┐\n   *        ┏━│━━│━┓         ┏━│━━│━┓\n   *          │  │             │  │\n   *  from  ┃ └──┘ ┃     to  ┃ │  │ ┃\n   *                           │  │\n   *        ┗━ ━━ ━┛         ┗━└━━┘━┛\n   *\n   * If element edge C is outside scrolling box edge C and element width is greater than scrolling box width\n   *\n   *           from                 to\n   *        ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓\n   *  ┌───────────┐           ┌───────────┐\n   *  │     ┃     │   ┃       │ ┃         ┃\n   *  └───────────┘           └───────────┘\n   *        ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛\n   *\n   * If element edge D is outside scrolling box edge D and element width is less than scrolling box width\n   *\n   *           from                 to\n   *        ┏ ━ ━ ━ ━ ┓         ┏ ━ ━ ━ ━ ┓\n   *                ┌───┐             ┌───┐\n   *        ┃       │ ┃ │       ┃     │   ┃\n   *                └───┘             └───┘\n   *        ┗ ━ ━ ━ ━ ┛         ┗ ━ ━ ━ ━ ┛\n   *\n   */\n  if (\n    (elementEdgeEnd > scrollingEdgeEnd && elementSize < scrollingSize) ||\n    (elementEdgeStart < scrollingEdgeStart && elementSize > scrollingSize)\n  ) {\n    return elementEdgeEnd - scrollingEdgeEnd + scrollingBorderEnd\n  }\n\n  return 0\n}\n\nfunction getParentElement(element: Node): Element | null {\n  const parent = element.parentElement\n  if (parent == null) {\n    return (element.getRootNode() as ShadowRoot).host || null\n  }\n  return parent\n}\n\nexport default (target: Element, options: Options): CustomScrollAction[] => {\n  //TODO: remove this hack when microbundle will support typescript >= 4.0\n  const windowWithViewport = window as unknown as Window & {\n    visualViewport: visualViewport\n  }\n\n  const { scrollMode, block, inline, boundary, skipOverflowHiddenElements } =\n    options\n  // Allow using a callback to check the boundary\n  // The default behavior is to check if the current target matches the boundary element or not\n  // If undefined it'll check that target is never undefined (can happen as we recurse up the tree)\n  const checkBoundary =\n    typeof boundary === 'function' ? boundary : (node: any) => node !== boundary\n\n  if (!isElement(target)) {\n    throw new TypeError('Invalid target')\n  }\n\n  // Used to handle the top most element that can be scrolled\n  const scrollingElement = document.scrollingElement || document.documentElement\n\n  // Collect all the scrolling boxes, as defined in the spec: https://drafts.csswg.org/cssom-view/#scrolling-box\n  const frames: Element[] = []\n  let cursor: Element | null = target\n  while (isElement(cursor) && checkBoundary(cursor)) {\n    // Move cursor to parent\n    cursor = getParentElement(cursor)\n\n    // Stop when we reach the viewport\n    if (cursor === scrollingElement) {\n      frames.push(cursor)\n      break\n    }\n\n    // Skip document.body if it's not the scrollingElement and documentElement isn't independently scrollable\n    if (\n      cursor != null &&\n      cursor === document.body &&\n      isScrollable(cursor) &&\n      !isScrollable(document.documentElement)\n    ) {\n      continue\n    }\n\n    // Now we check if the element is scrollable, this code only runs if the loop haven't already hit the viewport or a custom boundary\n    if (cursor != null && isScrollable(cursor, skipOverflowHiddenElements)) {\n      frames.push(cursor)\n    }\n  }\n\n  // Support pinch-zooming properly, making sure elements scroll into the visual viewport\n  // Browsers that don't support visualViewport will report the layout viewport dimensions on document.documentElement.clientWidth/Height\n  // and viewport dimensions on window.innerWidth/Height\n  // https://www.quirksmode.org/mobile/viewports2.html\n  // https://bokand.github.io/viewport/index.html\n  const viewportWidth = windowWithViewport.visualViewport\n    ? windowWithViewport.visualViewport.width\n    : innerWidth\n  const viewportHeight = windowWithViewport.visualViewport\n    ? windowWithViewport.visualViewport.height\n    : innerHeight\n\n  // Newer browsers supports scroll[X|Y], page[X|Y]Offset is\n  const viewportX = window.scrollX || pageXOffset\n  const viewportY = window.scrollY || pageYOffset\n\n  const {\n    height: targetHeight,\n    width: targetWidth,\n    top: targetTop,\n    right: targetRight,\n    bottom: targetBottom,\n    left: targetLeft,\n  } = target.getBoundingClientRect()\n\n  // These values mutate as we loop through and generate scroll coordinates\n  let targetBlock: number =\n    block === 'start' || block === 'nearest'\n      ? targetTop\n      : block === 'end'\n      ? targetBottom\n      : targetTop + targetHeight / 2 // block === 'center\n  let targetInline: number =\n    inline === 'center'\n      ? targetLeft + targetWidth / 2\n      : inline === 'end'\n      ? targetRight\n      : targetLeft // inline === 'start || inline === 'nearest\n\n  // Collect new scroll positions\n  const computations: CustomScrollAction[] = []\n  // In chrome there's no longer a difference between caching the `frames.length` to a var or not, so we don't in this case (size > speed anyways)\n  for (let index = 0; index < frames.length; index++) {\n    const frame = frames[index]\n\n    // @TODO add a shouldScroll hook here that allows userland code to take control\n\n    const { height, width, top, right, bottom, left } =\n      frame.getBoundingClientRect()\n\n    // If the element is already visible we can end it here\n    // @TODO targetBlock and targetInline should be taken into account to be compliant with https://github.com/w3c/csswg-drafts/pull/1805/files#diff-3c17f0e43c20f8ecf89419d49e7ef5e0R1333\n    if (\n      scrollMode === 'if-needed' &&\n      targetTop >= 0 &&\n      targetLeft >= 0 &&\n      targetBottom <= viewportHeight &&\n      targetRight <= viewportWidth &&\n      targetTop >= top &&\n      targetBottom <= bottom &&\n      targetLeft >= left &&\n      targetRight <= right\n    ) {\n      // Break the loop and return the computations for things that are not fully visible\n      return computations\n    }\n\n    const frameStyle = getComputedStyle(frame)\n    const borderLeft = parseInt(frameStyle.borderLeftWidth as string, 10)\n    const borderTop = parseInt(frameStyle.borderTopWidth as string, 10)\n    const borderRight = parseInt(frameStyle.borderRightWidth as string, 10)\n    const borderBottom = parseInt(frameStyle.borderBottomWidth as string, 10)\n\n    let blockScroll: number = 0\n    let inlineScroll: number = 0\n\n    // The property existance checks for offfset[Width|Height] is because only HTMLElement objects have them, but any Element might pass by here\n    // @TODO find out if the \"as HTMLElement\" overrides can be dropped\n    const scrollbarWidth =\n      'offsetWidth' in frame\n        ? (frame as HTMLElement).offsetWidth -\n          (frame as HTMLElement).clientWidth -\n          borderLeft -\n          borderRight\n        : 0\n    const scrollbarHeight =\n      'offsetHeight' in frame\n        ? (frame as HTMLElement).offsetHeight -\n          (frame as HTMLElement).clientHeight -\n          borderTop -\n          borderBottom\n        : 0\n\n    const scaleX =\n      'offsetWidth' in frame\n        ? (frame as HTMLElement).offsetWidth === 0\n          ? 0\n          : width / (frame as HTMLElement).offsetWidth\n        : 0\n    const scaleY =\n      'offsetHeight' in frame\n        ? (frame as HTMLElement).offsetHeight === 0\n          ? 0\n          : height / (frame as HTMLElement).offsetHeight\n        : 0\n\n    if (scrollingElement === frame) {\n      // Handle viewport logic (document.documentElement or document.body)\n\n      if (block === 'start') {\n        blockScroll = targetBlock\n      } else if (block === 'end') {\n        blockScroll = targetBlock - viewportHeight\n      } else if (block === 'nearest') {\n        blockScroll = alignNearest(\n          viewportY,\n          viewportY + viewportHeight,\n          viewportHeight,\n          borderTop,\n          borderBottom,\n          viewportY + targetBlock,\n          viewportY + targetBlock + targetHeight,\n          targetHeight\n        )\n      } else {\n        // block === 'center' is the default\n        blockScroll = targetBlock - viewportHeight / 2\n      }\n\n      if (inline === 'start') {\n        inlineScroll = targetInline\n      } else if (inline === 'center') {\n        inlineScroll = targetInline - viewportWidth / 2\n      } else if (inline === 'end') {\n        inlineScroll = targetInline - viewportWidth\n      } else {\n        // inline === 'nearest' is the default\n        inlineScroll = alignNearest(\n          viewportX,\n          viewportX + viewportWidth,\n          viewportWidth,\n          borderLeft,\n          borderRight,\n          viewportX + targetInline,\n          viewportX + targetInline + targetWidth,\n          targetWidth\n        )\n      }\n\n      // Apply scroll position offsets and ensure they are within bounds\n      // @TODO add more test cases to cover this 100%\n      blockScroll = Math.max(0, blockScroll + viewportY)\n      inlineScroll = Math.max(0, inlineScroll + viewportX)\n    } else {\n      // Handle each scrolling frame that might exist between the target and the viewport\n\n      if (block === 'start') {\n        blockScroll = targetBlock - top - borderTop\n      } else if (block === 'end') {\n        blockScroll = targetBlock - bottom + borderBottom + scrollbarHeight\n      } else if (block === 'nearest') {\n        blockScroll = alignNearest(\n          top,\n          bottom,\n          height,\n          borderTop,\n          borderBottom + scrollbarHeight,\n          targetBlock,\n          targetBlock + targetHeight,\n          targetHeight\n        )\n      } else {\n        // block === 'center' is the default\n        blockScroll = targetBlock - (top + height / 2) + scrollbarHeight / 2\n      }\n\n      if (inline === 'start') {\n        inlineScroll = targetInline - left - borderLeft\n      } else if (inline === 'center') {\n        inlineScroll = targetInline - (left + width / 2) + scrollbarWidth / 2\n      } else if (inline === 'end') {\n        inlineScroll = targetInline - right + borderRight + scrollbarWidth\n      } else {\n        // inline === 'nearest' is the default\n        inlineScroll = alignNearest(\n          left,\n          right,\n          width,\n          borderLeft,\n          borderRight + scrollbarWidth,\n          targetInline,\n          targetInline + targetWidth,\n          targetWidth\n        )\n      }\n\n      const { scrollLeft, scrollTop } = frame\n      // Ensure scroll coordinates are not out of bounds while applying scroll offsets\n      blockScroll = Math.max(\n        0,\n        Math.min(\n          scrollTop + blockScroll / scaleY,\n          frame.scrollHeight - height / scaleY + scrollbarHeight\n        )\n      )\n      inlineScroll = Math.max(\n        0,\n        Math.min(\n          scrollLeft + inlineScroll / scaleX,\n          frame.scrollWidth - width / scaleX + scrollbarWidth\n        )\n      )\n\n      // Cache the offset so that parent frames can scroll this into view correctly\n      targetBlock += scrollTop - blockScroll\n      targetInline += scrollLeft - inlineScroll\n    }\n\n    computations.push({ el: frame, top: blockScroll, left: inlineScroll })\n  }\n\n  return computations\n}\n","var trimmedEndIndex = require('./_trimmedEndIndex');\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nmodule.exports = baseTrim;\n","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nmodule.exports = trimmedEndIndex;\n","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n","var baseTrim = require('./_baseTrim'),\n    isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","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 _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport _objectWithoutProperties from \"@babel/runtime/helpers/esm/objectWithoutProperties\";\nvar _excluded = [\"prefixCls\", \"className\", \"style\", \"checked\", \"disabled\", \"defaultChecked\", \"type\", \"onChange\"];\nimport classNames from 'classnames';\nimport useMergedState from \"rc-util/es/hooks/useMergedState\";\nimport * as React from 'react';\nimport { forwardRef, useImperativeHandle, useRef } from 'react';\nexport var Checkbox = /*#__PURE__*/forwardRef(function (props, ref) {\n  var _classNames;\n  var _props$prefixCls = props.prefixCls,\n    prefixCls = _props$prefixCls === void 0 ? 'rc-checkbox' : _props$prefixCls,\n    className = props.className,\n    style = props.style,\n    checked = props.checked,\n    disabled = props.disabled,\n    _props$defaultChecked = props.defaultChecked,\n    defaultChecked = _props$defaultChecked === void 0 ? false : _props$defaultChecked,\n    _props$type = props.type,\n    type = _props$type === void 0 ? 'checkbox' : _props$type,\n    onChange = props.onChange,\n    inputProps = _objectWithoutProperties(props, _excluded);\n  var inputRef = useRef(null);\n  var _useMergedState = useMergedState(defaultChecked, {\n      value: checked\n    }),\n    _useMergedState2 = _slicedToArray(_useMergedState, 2),\n    rawValue = _useMergedState2[0],\n    setRawValue = _useMergedState2[1];\n  useImperativeHandle(ref, function () {\n    return {\n      focus: function focus() {\n        var _inputRef$current;\n        (_inputRef$current = inputRef.current) === null || _inputRef$current === void 0 ? void 0 : _inputRef$current.focus();\n      },\n      blur: function blur() {\n        var _inputRef$current2;\n        (_inputRef$current2 = inputRef.current) === null || _inputRef$current2 === void 0 ? void 0 : _inputRef$current2.blur();\n      },\n      input: inputRef.current\n    };\n  });\n  var classString = classNames(prefixCls, className, (_classNames = {}, _defineProperty(_classNames, \"\".concat(prefixCls, \"-checked\"), rawValue), _defineProperty(_classNames, \"\".concat(prefixCls, \"-disabled\"), disabled), _classNames));\n  var handleChange = function handleChange(e) {\n    if (disabled) {\n      return;\n    }\n    if (!('checked' in props)) {\n      setRawValue(e.target.checked);\n    }\n    onChange === null || onChange === void 0 ? void 0 : onChange({\n      target: _objectSpread(_objectSpread({}, props), {}, {\n        type: type,\n        checked: e.target.checked\n      }),\n      stopPropagation: function stopPropagation() {\n        e.stopPropagation();\n      },\n      preventDefault: function preventDefault() {\n        e.preventDefault();\n      },\n      nativeEvent: e.nativeEvent\n    });\n  };\n  return /*#__PURE__*/React.createElement(\"span\", {\n    className: classString,\n    style: style\n  }, /*#__PURE__*/React.createElement(\"input\", _extends({}, inputProps, {\n    className: \"\".concat(prefixCls, \"-input\"),\n    ref: inputRef,\n    onChange: handleChange,\n    disabled: disabled,\n    checked: !!rawValue,\n    type: type\n  })), /*#__PURE__*/React.createElement(\"span\", {\n    className: \"\".concat(prefixCls, \"-inner\")\n  }));\n});\nexport default Checkbox;","import * as React from 'react';\nvar DrawerContext = /*#__PURE__*/React.createContext(null);\nexport default DrawerContext;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport classNames from 'classnames';\nimport * as React from 'react';\nvar DrawerPanel = function DrawerPanel(props) {\n  var prefixCls = props.prefixCls,\n    className = props.className,\n    style = props.style,\n    children = props.children,\n    containerRef = props.containerRef,\n    id = props.id,\n    onMouseEnter = props.onMouseEnter,\n    onMouseOver = props.onMouseOver,\n    onMouseLeave = props.onMouseLeave,\n    onClick = props.onClick,\n    onKeyDown = props.onKeyDown,\n    onKeyUp = props.onKeyUp;\n  var eventHandlers = {\n    onMouseEnter: onMouseEnter,\n    onMouseOver: onMouseOver,\n    onMouseLeave: onMouseLeave,\n    onClick: onClick,\n    onKeyDown: onKeyDown,\n    onKeyUp: onKeyUp\n  };\n  // =============================== Render ===============================\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"div\", _extends({\n    id: id,\n    className: classNames(\"\".concat(prefixCls, \"-content\"), className),\n    style: _objectSpread({}, style),\n    \"aria-modal\": \"true\",\n    role: \"dialog\",\n    ref: containerRef\n  }, eventHandlers), children));\n};\nif (process.env.NODE_ENV !== 'production') {\n  DrawerPanel.displayName = 'DrawerPanel';\n}\nexport default DrawerPanel;","import warning from \"rc-util/es/warning\";\nimport canUseDom from \"rc-util/es/Dom/canUseDom\";\nexport function parseWidthHeight(value) {\n  if (typeof value === 'string' && String(Number(value)) === value) {\n    warning(false, 'Invalid value type of `width` or `height` which should be number type instead.');\n    return Number(value);\n  }\n  return value;\n}\nexport function warnCheck(props) {\n  warning(!('wrapperClassName' in props), \"'wrapperClassName' is removed. Please use 'rootClassName' instead.\");\n  warning(canUseDom() || !props.open, \"Drawer with 'open' in SSR is not work since no place to createPortal. Please move to 'useEffect' instead.\");\n}","import _defineProperty from \"@babel/runtime/helpers/esm/defineProperty\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport classNames from 'classnames';\nimport CSSMotion from 'rc-motion';\nimport KeyCode from \"rc-util/es/KeyCode\";\nimport pickAttrs from \"rc-util/es/pickAttrs\";\nimport * as React from 'react';\nimport DrawerContext from './context';\nimport DrawerPanel from './DrawerPanel';\nimport { parseWidthHeight } from './util';\nvar sentinelStyle = {\n  width: 0,\n  height: 0,\n  overflow: 'hidden',\n  outline: 'none',\n  position: 'absolute'\n};\nfunction DrawerPopup(props, ref) {\n  var _ref, _pushConfig$distance, _pushConfig, _classNames;\n  var prefixCls = props.prefixCls,\n    open = props.open,\n    placement = props.placement,\n    inline = props.inline,\n    push = props.push,\n    forceRender = props.forceRender,\n    autoFocus = props.autoFocus,\n    keyboard = props.keyboard,\n    rootClassName = props.rootClassName,\n    rootStyle = props.rootStyle,\n    zIndex = props.zIndex,\n    className = props.className,\n    id = props.id,\n    style = props.style,\n    motion = props.motion,\n    width = props.width,\n    height = props.height,\n    children = props.children,\n    contentWrapperStyle = props.contentWrapperStyle,\n    mask = props.mask,\n    maskClosable = props.maskClosable,\n    maskMotion = props.maskMotion,\n    maskClassName = props.maskClassName,\n    maskStyle = props.maskStyle,\n    afterOpenChange = props.afterOpenChange,\n    onClose = props.onClose,\n    onMouseEnter = props.onMouseEnter,\n    onMouseOver = props.onMouseOver,\n    onMouseLeave = props.onMouseLeave,\n    onClick = props.onClick,\n    onKeyDown = props.onKeyDown,\n    onKeyUp = props.onKeyUp;\n  // ================================ Refs ================================\n  var panelRef = React.useRef();\n  var sentinelStartRef = React.useRef();\n  var sentinelEndRef = React.useRef();\n  React.useImperativeHandle(ref, function () {\n    return panelRef.current;\n  });\n  var onPanelKeyDown = function onPanelKeyDown(event) {\n    var keyCode = event.keyCode,\n      shiftKey = event.shiftKey;\n    switch (keyCode) {\n      // Tab active\n      case KeyCode.TAB:\n        {\n          if (keyCode === KeyCode.TAB) {\n            if (!shiftKey && document.activeElement === sentinelEndRef.current) {\n              var _sentinelStartRef$cur;\n              (_sentinelStartRef$cur = sentinelStartRef.current) === null || _sentinelStartRef$cur === void 0 ? void 0 : _sentinelStartRef$cur.focus({\n                preventScroll: true\n              });\n            } else if (shiftKey && document.activeElement === sentinelStartRef.current) {\n              var _sentinelEndRef$curre;\n              (_sentinelEndRef$curre = sentinelEndRef.current) === null || _sentinelEndRef$curre === void 0 ? void 0 : _sentinelEndRef$curre.focus({\n                preventScroll: true\n              });\n            }\n          }\n          break;\n        }\n      // Close\n      case KeyCode.ESC:\n        {\n          if (onClose && keyboard) {\n            event.stopPropagation();\n            onClose(event);\n          }\n          break;\n        }\n    }\n  };\n  // ========================== Control ===========================\n  // Auto Focus\n  React.useEffect(function () {\n    if (open && autoFocus) {\n      var _panelRef$current;\n      (_panelRef$current = panelRef.current) === null || _panelRef$current === void 0 ? void 0 : _panelRef$current.focus({\n        preventScroll: true\n      });\n    }\n  }, [open]);\n  // ============================ Push ============================\n  var _React$useState = React.useState(false),\n    _React$useState2 = _slicedToArray(_React$useState, 2),\n    pushed = _React$useState2[0],\n    setPushed = _React$useState2[1];\n  var parentContext = React.useContext(DrawerContext);\n  // Merge push distance\n  var pushConfig;\n  if (push === false) {\n    pushConfig = {\n      distance: 0\n    };\n  } else if (push === true) {\n    pushConfig = {};\n  } else {\n    pushConfig = push || {};\n  }\n  var pushDistance = (_ref = (_pushConfig$distance = (_pushConfig = pushConfig) === null || _pushConfig === void 0 ? void 0 : _pushConfig.distance) !== null && _pushConfig$distance !== void 0 ? _pushConfig$distance : parentContext === null || parentContext === void 0 ? void 0 : parentContext.pushDistance) !== null && _ref !== void 0 ? _ref : 180;\n  var mergedContext = React.useMemo(function () {\n    return {\n      pushDistance: pushDistance,\n      push: function push() {\n        setPushed(true);\n      },\n      pull: function pull() {\n        setPushed(false);\n      }\n    };\n  }, [pushDistance]);\n  // ========================= ScrollLock =========================\n  // Tell parent to push\n  React.useEffect(function () {\n    if (open) {\n      var _parentContext$push;\n      parentContext === null || parentContext === void 0 ? void 0 : (_parentContext$push = parentContext.push) === null || _parentContext$push === void 0 ? void 0 : _parentContext$push.call(parentContext);\n    } else {\n      var _parentContext$pull;\n      parentContext === null || parentContext === void 0 ? void 0 : (_parentContext$pull = parentContext.pull) === null || _parentContext$pull === void 0 ? void 0 : _parentContext$pull.call(parentContext);\n    }\n  }, [open]);\n  // Clean up\n  React.useEffect(function () {\n    return function () {\n      var _parentContext$pull2;\n      parentContext === null || parentContext === void 0 ? void 0 : (_parentContext$pull2 = parentContext.pull) === null || _parentContext$pull2 === void 0 ? void 0 : _parentContext$pull2.call(parentContext);\n    };\n  }, []);\n  // ============================ Mask ============================\n  var maskNode = mask && /*#__PURE__*/React.createElement(CSSMotion, _extends({\n    key: \"mask\"\n  }, maskMotion, {\n    visible: open\n  }), function (_ref2, maskRef) {\n    var motionMaskClassName = _ref2.className,\n      motionMaskStyle = _ref2.style;\n    return /*#__PURE__*/React.createElement(\"div\", {\n      className: classNames(\"\".concat(prefixCls, \"-mask\"), motionMaskClassName, maskClassName),\n      style: _objectSpread(_objectSpread({}, motionMaskStyle), maskStyle),\n      onClick: maskClosable && open ? onClose : undefined,\n      ref: maskRef\n    });\n  });\n  // =========================== Panel ============================\n  var motionProps = typeof motion === 'function' ? motion(placement) : motion;\n  var wrapperStyle = {};\n  if (pushed && pushDistance) {\n    switch (placement) {\n      case 'top':\n        wrapperStyle.transform = \"translateY(\".concat(pushDistance, \"px)\");\n        break;\n      case 'bottom':\n        wrapperStyle.transform = \"translateY(\".concat(-pushDistance, \"px)\");\n        break;\n      case 'left':\n        wrapperStyle.transform = \"translateX(\".concat(pushDistance, \"px)\");\n        break;\n      default:\n        wrapperStyle.transform = \"translateX(\".concat(-pushDistance, \"px)\");\n        break;\n    }\n  }\n  if (placement === 'left' || placement === 'right') {\n    wrapperStyle.width = parseWidthHeight(width);\n  } else {\n    wrapperStyle.height = parseWidthHeight(height);\n  }\n  var eventHandlers = {\n    onMouseEnter: onMouseEnter,\n    onMouseOver: onMouseOver,\n    onMouseLeave: onMouseLeave,\n    onClick: onClick,\n    onKeyDown: onKeyDown,\n    onKeyUp: onKeyUp\n  };\n  var panelNode = /*#__PURE__*/React.createElement(CSSMotion, _extends({\n    key: \"panel\"\n  }, motionProps, {\n    visible: open,\n    forceRender: forceRender,\n    onVisibleChanged: function onVisibleChanged(nextVisible) {\n      afterOpenChange === null || afterOpenChange === void 0 ? void 0 : afterOpenChange(nextVisible);\n    },\n    removeOnLeave: false,\n    leavedClassName: \"\".concat(prefixCls, \"-content-wrapper-hidden\")\n  }), function (_ref3, motionRef) {\n    var motionClassName = _ref3.className,\n      motionStyle = _ref3.style;\n    return /*#__PURE__*/React.createElement(\"div\", _extends({\n      className: classNames(\"\".concat(prefixCls, \"-content-wrapper\"), motionClassName),\n      style: _objectSpread(_objectSpread(_objectSpread({}, wrapperStyle), motionStyle), contentWrapperStyle)\n    }, pickAttrs(props, {\n      data: true\n    })), /*#__PURE__*/React.createElement(DrawerPanel, _extends({\n      id: id,\n      containerRef: motionRef,\n      prefixCls: prefixCls,\n      className: className,\n      style: style\n    }, eventHandlers), children));\n  });\n  // =========================== Render ===========================\n  var containerStyle = _objectSpread({}, rootStyle);\n  if (zIndex) {\n    containerStyle.zIndex = zIndex;\n  }\n  return /*#__PURE__*/React.createElement(DrawerContext.Provider, {\n    value: mergedContext\n  }, /*#__PURE__*/React.createElement(\"div\", {\n    className: classNames(prefixCls, \"\".concat(prefixCls, \"-\").concat(placement), rootClassName, (_classNames = {}, _defineProperty(_classNames, \"\".concat(prefixCls, \"-open\"), open), _defineProperty(_classNames, \"\".concat(prefixCls, \"-inline\"), inline), _classNames)),\n    style: containerStyle,\n    tabIndex: -1,\n    ref: panelRef,\n    onKeyDown: onPanelKeyDown\n  }, maskNode, /*#__PURE__*/React.createElement(\"div\", {\n    tabIndex: 0,\n    ref: sentinelStartRef,\n    style: sentinelStyle,\n    \"aria-hidden\": \"true\",\n    \"data-sentinel\": \"start\"\n  }), panelNode, /*#__PURE__*/React.createElement(\"div\", {\n    tabIndex: 0,\n    ref: sentinelEndRef,\n    style: sentinelStyle,\n    \"aria-hidden\": \"true\",\n    \"data-sentinel\": \"end\"\n  })));\n}\nvar RefDrawerPopup = /*#__PURE__*/React.forwardRef(DrawerPopup);\nif (process.env.NODE_ENV !== 'production') {\n  RefDrawerPopup.displayName = 'DrawerPopup';\n}\nexport default RefDrawerPopup;","import _objectSpread from \"@babel/runtime/helpers/esm/objectSpread2\";\nimport _slicedToArray from \"@babel/runtime/helpers/esm/slicedToArray\";\nimport * as React from 'react';\nimport Portal from '@rc-component/portal';\nimport useLayoutEffect from \"rc-util/es/hooks/useLayoutEffect\";\nimport DrawerPopup from './DrawerPopup';\nimport { warnCheck } from './util';\nvar Drawer = function Drawer(props) {\n  var _props$open = props.open,\n    open = _props$open === void 0 ? false : _props$open,\n    _props$prefixCls = props.prefixCls,\n    prefixCls = _props$prefixCls === void 0 ? 'rc-drawer' : _props$prefixCls,\n    _props$placement = props.placement,\n    placement = _props$placement === void 0 ? 'right' : _props$placement,\n    _props$autoFocus = props.autoFocus,\n    autoFocus = _props$autoFocus === void 0 ? true : _props$autoFocus,\n    _props$keyboard = props.keyboard,\n    keyboard = _props$keyboard === void 0 ? true : _props$keyboard,\n    _props$width = props.width,\n    width = _props$width === void 0 ? 378 : _props$width,\n    _props$mask = props.mask,\n    mask = _props$mask === void 0 ? true : _props$mask,\n    _props$maskClosable = props.maskClosable,\n    maskClosable = _props$maskClosable === void 0 ? true : _props$maskClosable,\n    getContainer = props.getContainer,\n    forceRender = props.forceRender,\n    afterOpenChange = props.afterOpenChange,\n    destroyOnClose = props.destroyOnClose,\n    onMouseEnter = props.onMouseEnter,\n    onMouseOver = props.onMouseOver,\n    onMouseLeave = props.onMouseLeave,\n    onClick = props.onClick,\n    onKeyDown = props.onKeyDown,\n    onKeyUp = props.onKeyUp;\n  var _React$useState = React.useState(false),\n    _React$useState2 = _slicedToArray(_React$useState, 2),\n    animatedVisible = _React$useState2[0],\n    setAnimatedVisible = _React$useState2[1];\n  // ============================= Warn =============================\n  if (process.env.NODE_ENV !== 'production') {\n    warnCheck(props);\n  }\n  // ============================= Open =============================\n  var _React$useState3 = React.useState(false),\n    _React$useState4 = _slicedToArray(_React$useState3, 2),\n    mounted = _React$useState4[0],\n    setMounted = _React$useState4[1];\n  useLayoutEffect(function () {\n    setMounted(true);\n  }, []);\n  var mergedOpen = mounted ? open : false;\n  // ============================ Focus =============================\n  var panelRef = React.useRef();\n  var lastActiveRef = React.useRef();\n  useLayoutEffect(function () {\n    if (mergedOpen) {\n      lastActiveRef.current = document.activeElement;\n    }\n  }, [mergedOpen]);\n  // ============================= Open =============================\n  var internalAfterOpenChange = function internalAfterOpenChange(nextVisible) {\n    var _panelRef$current;\n    setAnimatedVisible(nextVisible);\n    afterOpenChange === null || afterOpenChange === void 0 ? void 0 : afterOpenChange(nextVisible);\n    if (!nextVisible && lastActiveRef.current && !((_panelRef$current = panelRef.current) === null || _panelRef$current === void 0 ? void 0 : _panelRef$current.contains(lastActiveRef.current))) {\n      var _lastActiveRef$curren;\n      (_lastActiveRef$curren = lastActiveRef.current) === null || _lastActiveRef$curren === void 0 ? void 0 : _lastActiveRef$curren.focus({\n        preventScroll: true\n      });\n    }\n  };\n  // ============================ Render ============================\n  if (!forceRender && !animatedVisible && !mergedOpen && destroyOnClose) {\n    return null;\n  }\n  var eventHandlers = {\n    onMouseEnter: onMouseEnter,\n    onMouseOver: onMouseOver,\n    onMouseLeave: onMouseLeave,\n    onClick: onClick,\n    onKeyDown: onKeyDown,\n    onKeyUp: onKeyUp\n  };\n  var drawerPopupProps = _objectSpread(_objectSpread({}, props), {}, {\n    open: mergedOpen,\n    prefixCls: prefixCls,\n    placement: placement,\n    autoFocus: autoFocus,\n    keyboard: keyboard,\n    width: width,\n    mask: mask,\n    maskClosable: maskClosable,\n    inline: getContainer === false,\n    afterOpenChange: internalAfterOpenChange,\n    ref: panelRef\n  }, eventHandlers);\n  return /*#__PURE__*/React.createElement(Portal, {\n    open: mergedOpen || forceRender || animatedVisible,\n    autoDestroy: false,\n    getContainer: getContainer,\n    autoLock: mask && (mergedOpen || animatedVisible)\n  }, /*#__PURE__*/React.createElement(DrawerPopup, drawerPopupProps));\n};\nif (process.env.NODE_ENV !== 'production') {\n  Drawer.displayName = 'Drawer';\n}\nexport default Drawer;","// export this package's api\nimport Drawer from './Drawer';\nexport default Drawer;","\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = void 0;\nvar _computeScrollIntoView = _interopRequireDefault(require(\"compute-scroll-into-view\"));\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\nfunction isOptionsObject(options) {\n  return options === Object(options) && Object.keys(options).length !== 0;\n}\nfunction defaultBehavior(actions, behavior) {\n  if (behavior === void 0) {\n    behavior = 'auto';\n  }\n  var canSmoothScroll = ('scrollBehavior' in document.body.style);\n  actions.forEach(function (_ref) {\n    var el = _ref.el,\n      top = _ref.top,\n      left = _ref.left;\n    if (el.scroll && canSmoothScroll) {\n      el.scroll({\n        top: top,\n        left: left,\n        behavior: behavior\n      });\n    } else {\n      el.scrollTop = top;\n      el.scrollLeft = left;\n    }\n  });\n}\nfunction getOptions(options) {\n  if (options === false) {\n    return {\n      block: 'end',\n      inline: 'nearest'\n    };\n  }\n  if (isOptionsObject(options)) {\n    return options;\n  }\n  return {\n    block: 'start',\n    inline: 'nearest'\n  };\n}\nfunction scrollIntoView(target, options) {\n  var isTargetAttached = target.isConnected || target.ownerDocument.documentElement.contains(target);\n  if (isOptionsObject(options) && typeof options.behavior === 'function') {\n    return options.behavior(isTargetAttached ? (0, _computeScrollIntoView[\"default\"])(target, options) : []);\n  }\n  if (!isTargetAttached) {\n    return;\n  }\n  var computeOptions = getOptions(options);\n  return defaultBehavior((0, _computeScrollIntoView[\"default\"])(target, computeOptions), computeOptions.behavior);\n}\nvar _default = scrollIntoView;\nexports[\"default\"] = _default;\nmodule.exports = exports.default;","import { useCallback, useState } from 'react';\nfunction useBoolean(defaultValue) {\n    const [value, setValue] = useState(!!defaultValue);\n    const setTrue = useCallback(() => setValue(true), []);\n    const setFalse = useCallback(() => setValue(false), []);\n    const toggle = useCallback(() => setValue(x => !x), []);\n    return { value, setValue, setTrue, setFalse, toggle };\n}\nexport default useBoolean;\n","import { useCallback } from 'react';\nimport { useBoolean, useCounter, useInterval } from '..';\nfunction useCountdown(countdownOption) {\n    let isDeprecated = false;\n    let countStart, intervalMs, isIncrement, countStop;\n    if ('seconds' in countdownOption) {\n        console.warn('[useCountdown:DEPRECATED] new interface is already available (see https://usehooks-ts.com/react-hook/use-countdown), the old version will retire on usehooks-ts@3.');\n        isDeprecated = true;\n        countStart = countdownOption.seconds;\n        intervalMs = countdownOption.interval;\n        isIncrement = countdownOption.isIncrement;\n    }\n    else {\n        ;\n        ({ countStart, intervalMs, isIncrement, countStop } = countdownOption);\n    }\n    intervalMs = intervalMs !== null && intervalMs !== void 0 ? intervalMs : 1000;\n    isIncrement = isIncrement !== null && isIncrement !== void 0 ? isIncrement : false;\n    countStop = countStop !== null && countStop !== void 0 ? countStop : 0;\n    const { count, increment, decrement, reset: resetCounter, } = useCounter(countStart);\n    const { value: isCountdownRunning, setTrue: startCountdown, setFalse: stopCountdown, } = useBoolean(false);\n    const resetCountdown = () => {\n        stopCountdown();\n        resetCounter();\n    };\n    const countdownCallback = useCallback(() => {\n        if (count === countStop) {\n            stopCountdown();\n            return;\n        }\n        if (isIncrement) {\n            increment();\n        }\n        else {\n            decrement();\n        }\n    }, [count, countStop, decrement, increment, isIncrement, stopCountdown]);\n    useInterval(countdownCallback, isCountdownRunning ? intervalMs : null);\n    return isDeprecated\n        ? [\n            count,\n            {\n                start: startCountdown,\n                stop: stopCountdown,\n                reset: resetCountdown,\n            },\n        ]\n        : [\n            count,\n            {\n                startCountdown,\n                stopCountdown,\n                resetCountdown,\n            },\n        ];\n}\nexport default useCountdown;\n","import { useState } from 'react';\nfunction useCounter(initialValue) {\n    const [count, setCount] = useState(initialValue || 0);\n    const increment = () => setCount(x => x + 1);\n    const decrement = () => setCount(x => x - 1);\n    const reset = () => setCount(initialValue || 0);\n    return {\n        count,\n        increment,\n        decrement,\n        reset,\n        setCount,\n    };\n}\nexport default useCounter;\n","import { useEffect, useRef } from 'react';\nimport { useIsomorphicLayoutEffect } from '..';\nfunction useInterval(callback, delay) {\n    const savedCallback = useRef(callback);\n    useIsomorphicLayoutEffect(() => {\n        savedCallback.current = callback;\n    }, [callback]);\n    useEffect(() => {\n        if (!delay && delay !== 0) {\n            return;\n        }\n        const id = setInterval(() => savedCallback.current(), delay);\n        return () => clearInterval(id);\n    }, [delay]);\n}\nexport default useInterval;\n","import { useCallback, useEffect, useRef } from 'react';\nfunction useIsMounted() {\n    const isMounted = useRef(false);\n    useEffect(() => {\n        isMounted.current = true;\n        return () => {\n            isMounted.current = false;\n        };\n    }, []);\n    return useCallback(() => isMounted.current, []);\n}\nexport default useIsMounted;\n","import { useEffect, useLayoutEffect } from 'react';\nconst useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;\nexport default useIsomorphicLayoutEffect;\n","import {\n  isServer,\n  isValidTimeout,\n  noop,\n  replaceData,\n  shallowEqualObjects,\n  timeUntilStale,\n} from './utils'\nimport { notifyManager } from './notifyManager'\nimport { focusManager } from './focusManager'\nimport { Subscribable } from './subscribable'\nimport { canFetch, isCancelledError } from './retryer'\nimport type {\n  PlaceholderDataFunction,\n  QueryKey,\n  QueryObserverBaseResult,\n  QueryObserverOptions,\n  QueryObserverResult,\n  QueryOptions,\n  RefetchOptions,\n} from './types'\nimport type { Action, FetchOptions, Query, QueryState } from './query'\nimport type { QueryClient } from './queryClient'\nimport type { DefaultedQueryObserverOptions, RefetchPageFilters } from './types'\n\ntype QueryObserverListener<TData, TError> = (\n  result: QueryObserverResult<TData, TError>,\n) => void\n\nexport interface NotifyOptions {\n  cache?: boolean\n  listeners?: boolean\n  onError?: boolean\n  onSuccess?: boolean\n}\n\nexport interface ObserverFetchOptions extends FetchOptions {\n  throwOnError?: boolean\n}\n\nexport class QueryObserver<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> extends Subscribable<QueryObserverListener<TData, TError>> {\n  options: QueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >\n\n  private client: QueryClient\n  private currentQuery!: Query<TQueryFnData, TError, TQueryData, TQueryKey>\n  private currentQueryInitialState!: QueryState<TQueryData, TError>\n  private currentResult!: QueryObserverResult<TData, TError>\n  private currentResultState?: QueryState<TQueryData, TError>\n  private currentResultOptions?: QueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >\n  private previousQueryResult?: QueryObserverResult<TData, TError>\n  private selectError: TError | null\n  private selectFn?: (data: TQueryData) => TData\n  private selectResult?: TData\n  private staleTimeoutId?: ReturnType<typeof setTimeout>\n  private refetchIntervalId?: ReturnType<typeof setInterval>\n  private currentRefetchInterval?: number | false\n  private trackedProps!: Set<keyof QueryObserverResult>\n\n  constructor(\n    client: QueryClient,\n    options: QueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    >,\n  ) {\n    super()\n\n    this.client = client\n    this.options = options\n    this.trackedProps = new Set()\n    this.selectError = null\n    this.bindMethods()\n    this.setOptions(options)\n  }\n\n  protected bindMethods(): void {\n    this.remove = this.remove.bind(this)\n    this.refetch = this.refetch.bind(this)\n  }\n\n  protected onSubscribe(): void {\n    if (this.listeners.size === 1) {\n      this.currentQuery.addObserver(this)\n\n      if (shouldFetchOnMount(this.currentQuery, this.options)) {\n        this.executeFetch()\n      }\n\n      this.updateTimers()\n    }\n  }\n\n  protected onUnsubscribe(): void {\n    if (!this.hasListeners()) {\n      this.destroy()\n    }\n  }\n\n  shouldFetchOnReconnect(): boolean {\n    return shouldFetchOn(\n      this.currentQuery,\n      this.options,\n      this.options.refetchOnReconnect,\n    )\n  }\n\n  shouldFetchOnWindowFocus(): boolean {\n    return shouldFetchOn(\n      this.currentQuery,\n      this.options,\n      this.options.refetchOnWindowFocus,\n    )\n  }\n\n  destroy(): void {\n    this.listeners = new Set()\n    this.clearStaleTimeout()\n    this.clearRefetchInterval()\n    this.currentQuery.removeObserver(this)\n  }\n\n  setOptions(\n    options?: QueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    >,\n    notifyOptions?: NotifyOptions,\n  ): void {\n    const prevOptions = this.options\n    const prevQuery = this.currentQuery\n\n    this.options = this.client.defaultQueryOptions(options)\n\n    if (\n      process.env.NODE_ENV !== 'production' &&\n      typeof options?.isDataEqual !== 'undefined'\n    ) {\n      this.client\n        .getLogger()\n        .error(\n          `The isDataEqual option has been deprecated and will be removed in the next major version. You can achieve the same functionality by passing a function as the structuralSharing option`,\n        )\n    }\n\n    if (!shallowEqualObjects(prevOptions, this.options)) {\n      this.client.getQueryCache().notify({\n        type: 'observerOptionsUpdated',\n        query: this.currentQuery,\n        observer: this,\n      })\n    }\n\n    if (\n      typeof this.options.enabled !== 'undefined' &&\n      typeof this.options.enabled !== 'boolean'\n    ) {\n      throw new Error('Expected enabled to be a boolean')\n    }\n\n    // Keep previous query key if the user does not supply one\n    if (!this.options.queryKey) {\n      this.options.queryKey = prevOptions.queryKey\n    }\n\n    this.updateQuery()\n\n    const mounted = this.hasListeners()\n\n    // Fetch if there are subscribers\n    if (\n      mounted &&\n      shouldFetchOptionally(\n        this.currentQuery,\n        prevQuery,\n        this.options,\n        prevOptions,\n      )\n    ) {\n      this.executeFetch()\n    }\n\n    // Update result\n    this.updateResult(notifyOptions)\n\n    // Update stale interval if needed\n    if (\n      mounted &&\n      (this.currentQuery !== prevQuery ||\n        this.options.enabled !== prevOptions.enabled ||\n        this.options.staleTime !== prevOptions.staleTime)\n    ) {\n      this.updateStaleTimeout()\n    }\n\n    const nextRefetchInterval = this.computeRefetchInterval()\n\n    // Update refetch interval if needed\n    if (\n      mounted &&\n      (this.currentQuery !== prevQuery ||\n        this.options.enabled !== prevOptions.enabled ||\n        nextRefetchInterval !== this.currentRefetchInterval)\n    ) {\n      this.updateRefetchInterval(nextRefetchInterval)\n    }\n  }\n\n  getOptimisticResult(\n    options: DefaultedQueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    >,\n  ): QueryObserverResult<TData, TError> {\n    const query = this.client.getQueryCache().build(this.client, options)\n\n    const result = this.createResult(query, options)\n\n    if (shouldAssignObserverCurrentProperties(this, result, options)) {\n      // this assigns the optimistic result to the current Observer\n      // because if the query function changes, useQuery will be performing\n      // an effect where it would fetch again.\n      // When the fetch finishes, we perform a deep data cloning in order\n      // to reuse objects references. This deep data clone is performed against\n      // the `observer.currentResult.data` property\n      // When QueryKey changes, we refresh the query and get new `optimistic`\n      // result, while we leave the `observer.currentResult`, so when new data\n      // arrives, it finds the old `observer.currentResult` which is related\n      // to the old QueryKey. Which means that currentResult and selectData are\n      // out of sync already.\n      // To solve this, we move the cursor of the currentResult everytime\n      // an observer reads an optimistic value.\n\n      // When keeping the previous data, the result doesn't change until new\n      // data arrives.\n      this.currentResult = result\n      this.currentResultOptions = this.options\n      this.currentResultState = this.currentQuery.state\n    }\n    return result\n  }\n\n  getCurrentResult(): QueryObserverResult<TData, TError> {\n    return this.currentResult\n  }\n\n  trackResult(\n    result: QueryObserverResult<TData, TError>,\n  ): QueryObserverResult<TData, TError> {\n    const trackedResult = {} as QueryObserverResult<TData, TError>\n\n    Object.keys(result).forEach((key) => {\n      Object.defineProperty(trackedResult, key, {\n        configurable: false,\n        enumerable: true,\n        get: () => {\n          this.trackedProps.add(key as keyof QueryObserverResult)\n          return result[key as keyof QueryObserverResult]\n        },\n      })\n    })\n\n    return trackedResult\n  }\n\n  getCurrentQuery(): Query<TQueryFnData, TError, TQueryData, TQueryKey> {\n    return this.currentQuery\n  }\n\n  remove(): void {\n    this.client.getQueryCache().remove(this.currentQuery)\n  }\n\n  refetch<TPageData>({\n    refetchPage,\n    ...options\n  }: RefetchOptions & RefetchPageFilters<TPageData> = {}): Promise<\n    QueryObserverResult<TData, TError>\n  > {\n    return this.fetch({\n      ...options,\n      meta: { refetchPage },\n    })\n  }\n\n  fetchOptimistic(\n    options: QueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    >,\n  ): Promise<QueryObserverResult<TData, TError>> {\n    const defaultedOptions = this.client.defaultQueryOptions(options)\n\n    const query = this.client\n      .getQueryCache()\n      .build(this.client, defaultedOptions)\n    query.isFetchingOptimistic = true\n\n    return query.fetch().then(() => this.createResult(query, defaultedOptions))\n  }\n\n  protected fetch(\n    fetchOptions: ObserverFetchOptions,\n  ): Promise<QueryObserverResult<TData, TError>> {\n    return this.executeFetch({\n      ...fetchOptions,\n      cancelRefetch: fetchOptions.cancelRefetch ?? true,\n    }).then(() => {\n      this.updateResult()\n      return this.currentResult\n    })\n  }\n\n  private executeFetch(\n    fetchOptions?: ObserverFetchOptions,\n  ): Promise<TQueryData | undefined> {\n    // Make sure we reference the latest query as the current one might have been removed\n    this.updateQuery()\n\n    // Fetch\n    let promise: Promise<TQueryData | undefined> = this.currentQuery.fetch(\n      this.options as QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey>,\n      fetchOptions,\n    )\n\n    if (!fetchOptions?.throwOnError) {\n      promise = promise.catch(noop)\n    }\n\n    return promise\n  }\n\n  private updateStaleTimeout(): void {\n    this.clearStaleTimeout()\n\n    if (\n      isServer ||\n      this.currentResult.isStale ||\n      !isValidTimeout(this.options.staleTime)\n    ) {\n      return\n    }\n\n    const time = timeUntilStale(\n      this.currentResult.dataUpdatedAt,\n      this.options.staleTime,\n    )\n\n    // The timeout is sometimes triggered 1 ms before the stale time expiration.\n    // To mitigate this issue we always add 1 ms to the timeout.\n    const timeout = time + 1\n\n    this.staleTimeoutId = setTimeout(() => {\n      if (!this.currentResult.isStale) {\n        this.updateResult()\n      }\n    }, timeout)\n  }\n\n  private computeRefetchInterval() {\n    return typeof this.options.refetchInterval === 'function'\n      ? this.options.refetchInterval(this.currentResult.data, this.currentQuery)\n      : this.options.refetchInterval ?? false\n  }\n\n  private updateRefetchInterval(nextInterval: number | false): void {\n    this.clearRefetchInterval()\n\n    this.currentRefetchInterval = nextInterval\n\n    if (\n      isServer ||\n      this.options.enabled === false ||\n      !isValidTimeout(this.currentRefetchInterval) ||\n      this.currentRefetchInterval === 0\n    ) {\n      return\n    }\n\n    this.refetchIntervalId = setInterval(() => {\n      if (\n        this.options.refetchIntervalInBackground ||\n        focusManager.isFocused()\n      ) {\n        this.executeFetch()\n      }\n    }, this.currentRefetchInterval)\n  }\n\n  private updateTimers(): void {\n    this.updateStaleTimeout()\n    this.updateRefetchInterval(this.computeRefetchInterval())\n  }\n\n  private clearStaleTimeout(): void {\n    if (this.staleTimeoutId) {\n      clearTimeout(this.staleTimeoutId)\n      this.staleTimeoutId = undefined\n    }\n  }\n\n  private clearRefetchInterval(): void {\n    if (this.refetchIntervalId) {\n      clearInterval(this.refetchIntervalId)\n      this.refetchIntervalId = undefined\n    }\n  }\n\n  protected createResult(\n    query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n    options: QueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      TQueryData,\n      TQueryKey\n    >,\n  ): QueryObserverResult<TData, TError> {\n    const prevQuery = this.currentQuery\n    const prevOptions = this.options\n    const prevResult = this.currentResult as\n      | QueryObserverResult<TData, TError>\n      | undefined\n    const prevResultState = this.currentResultState\n    const prevResultOptions = this.currentResultOptions\n    const queryChange = query !== prevQuery\n    const queryInitialState = queryChange\n      ? query.state\n      : this.currentQueryInitialState\n    const prevQueryResult = queryChange\n      ? this.currentResult\n      : this.previousQueryResult\n\n    const { state } = query\n    let { dataUpdatedAt, error, errorUpdatedAt, fetchStatus, status } = state\n    let isPreviousData = false\n    let isPlaceholderData = false\n    let data: TData | undefined\n\n    // Optimistically set result in fetching state if needed\n    if (options._optimisticResults) {\n      const mounted = this.hasListeners()\n\n      const fetchOnMount = !mounted && shouldFetchOnMount(query, options)\n\n      const fetchOptionally =\n        mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions)\n\n      if (fetchOnMount || fetchOptionally) {\n        fetchStatus = canFetch(query.options.networkMode)\n          ? 'fetching'\n          : 'paused'\n        if (!dataUpdatedAt) {\n          status = 'loading'\n        }\n      }\n      if (options._optimisticResults === 'isRestoring') {\n        fetchStatus = 'idle'\n      }\n    }\n\n    // Keep previous data if needed\n    if (\n      options.keepPreviousData &&\n      !state.dataUpdatedAt &&\n      prevQueryResult?.isSuccess &&\n      status !== 'error'\n    ) {\n      data = prevQueryResult.data\n      dataUpdatedAt = prevQueryResult.dataUpdatedAt\n      status = prevQueryResult.status\n      isPreviousData = true\n    }\n    // Select data if needed\n    else if (options.select && typeof state.data !== 'undefined') {\n      // Memoize select result\n      if (\n        prevResult &&\n        state.data === prevResultState?.data &&\n        options.select === this.selectFn\n      ) {\n        data = this.selectResult\n      } else {\n        try {\n          this.selectFn = options.select\n          data = options.select(state.data)\n          data = replaceData(prevResult?.data, data, options)\n          this.selectResult = data\n          this.selectError = null\n        } catch (selectError) {\n          if (process.env.NODE_ENV !== 'production') {\n            this.client.getLogger().error(selectError)\n          }\n          this.selectError = selectError as TError\n        }\n      }\n    }\n    // Use query data\n    else {\n      data = state.data as unknown as TData\n    }\n\n    // Show placeholder data if needed\n    if (\n      typeof options.placeholderData !== 'undefined' &&\n      typeof data === 'undefined' &&\n      status === 'loading'\n    ) {\n      let placeholderData\n\n      // Memoize placeholder data\n      if (\n        prevResult?.isPlaceholderData &&\n        options.placeholderData === prevResultOptions?.placeholderData\n      ) {\n        placeholderData = prevResult.data\n      } else {\n        placeholderData =\n          typeof options.placeholderData === 'function'\n            ? (options.placeholderData as PlaceholderDataFunction<TQueryData>)()\n            : options.placeholderData\n        if (options.select && typeof placeholderData !== 'undefined') {\n          try {\n            placeholderData = options.select(placeholderData)\n            this.selectError = null\n          } catch (selectError) {\n            if (process.env.NODE_ENV !== 'production') {\n              this.client.getLogger().error(selectError)\n            }\n            this.selectError = selectError as TError\n          }\n        }\n      }\n\n      if (typeof placeholderData !== 'undefined') {\n        status = 'success'\n        data = replaceData(prevResult?.data, placeholderData, options) as TData\n        isPlaceholderData = true\n      }\n    }\n\n    if (this.selectError) {\n      error = this.selectError as any\n      data = this.selectResult\n      errorUpdatedAt = Date.now()\n      status = 'error'\n    }\n\n    const isFetching = fetchStatus === 'fetching'\n    const isLoading = status === 'loading'\n    const isError = status === 'error'\n\n    const result: QueryObserverBaseResult<TData, TError> = {\n      status,\n      fetchStatus,\n      isLoading,\n      isSuccess: status === 'success',\n      isError,\n      isInitialLoading: isLoading && isFetching,\n      data,\n      dataUpdatedAt,\n      error,\n      errorUpdatedAt,\n      failureCount: state.fetchFailureCount,\n      failureReason: state.fetchFailureReason,\n      errorUpdateCount: state.errorUpdateCount,\n      isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,\n      isFetchedAfterMount:\n        state.dataUpdateCount > queryInitialState.dataUpdateCount ||\n        state.errorUpdateCount > queryInitialState.errorUpdateCount,\n      isFetching,\n      isRefetching: isFetching && !isLoading,\n      isLoadingError: isError && state.dataUpdatedAt === 0,\n      isPaused: fetchStatus === 'paused',\n      isPlaceholderData,\n      isPreviousData,\n      isRefetchError: isError && state.dataUpdatedAt !== 0,\n      isStale: isStale(query, options),\n      refetch: this.refetch,\n      remove: this.remove,\n    }\n\n    return result as QueryObserverResult<TData, TError>\n  }\n\n  updateResult(notifyOptions?: NotifyOptions): void {\n    const prevResult = this.currentResult as\n      | QueryObserverResult<TData, TError>\n      | undefined\n\n    const nextResult = this.createResult(this.currentQuery, this.options)\n    this.currentResultState = this.currentQuery.state\n    this.currentResultOptions = this.options\n\n    // Only notify and update result if something has changed\n    if (shallowEqualObjects(nextResult, prevResult)) {\n      return\n    }\n\n    this.currentResult = nextResult\n\n    // Determine which callbacks to trigger\n    const defaultNotifyOptions: NotifyOptions = { cache: true }\n\n    const shouldNotifyListeners = (): boolean => {\n      if (!prevResult) {\n        return true\n      }\n\n      const { notifyOnChangeProps } = this.options\n      const notifyOnChangePropsValue =\n        typeof notifyOnChangeProps === 'function'\n          ? notifyOnChangeProps()\n          : notifyOnChangeProps\n\n      if (\n        notifyOnChangePropsValue === 'all' ||\n        (!notifyOnChangePropsValue && !this.trackedProps.size)\n      ) {\n        return true\n      }\n\n      const includedProps = new Set(\n        notifyOnChangePropsValue ?? this.trackedProps,\n      )\n\n      if (this.options.useErrorBoundary) {\n        includedProps.add('error')\n      }\n\n      return Object.keys(this.currentResult).some((key) => {\n        const typedKey = key as keyof QueryObserverResult\n        const changed = this.currentResult[typedKey] !== prevResult[typedKey]\n        return changed && includedProps.has(typedKey)\n      })\n    }\n\n    if (notifyOptions?.listeners !== false && shouldNotifyListeners()) {\n      defaultNotifyOptions.listeners = true\n    }\n\n    this.notify({ ...defaultNotifyOptions, ...notifyOptions })\n  }\n\n  private updateQuery(): void {\n    const query = this.client.getQueryCache().build(this.client, this.options)\n\n    if (query === this.currentQuery) {\n      return\n    }\n\n    const prevQuery = this.currentQuery as\n      | Query<TQueryFnData, TError, TQueryData, TQueryKey>\n      | undefined\n    this.currentQuery = query\n    this.currentQueryInitialState = query.state\n    this.previousQueryResult = this.currentResult\n\n    if (this.hasListeners()) {\n      prevQuery?.removeObserver(this)\n      query.addObserver(this)\n    }\n  }\n\n  onQueryUpdate(action: Action<TData, TError>): void {\n    const notifyOptions: NotifyOptions = {}\n\n    if (action.type === 'success') {\n      notifyOptions.onSuccess = !action.manual\n    } else if (action.type === 'error' && !isCancelledError(action.error)) {\n      notifyOptions.onError = true\n    }\n\n    this.updateResult(notifyOptions)\n\n    if (this.hasListeners()) {\n      this.updateTimers()\n    }\n  }\n\n  private notify(notifyOptions: NotifyOptions): void {\n    notifyManager.batch(() => {\n      // First trigger the configuration callbacks\n      if (notifyOptions.onSuccess) {\n        this.options.onSuccess?.(this.currentResult.data!)\n        this.options.onSettled?.(this.currentResult.data!, null)\n      } else if (notifyOptions.onError) {\n        this.options.onError?.(this.currentResult.error!)\n        this.options.onSettled?.(undefined, this.currentResult.error!)\n      }\n\n      // Then trigger the listeners\n      if (notifyOptions.listeners) {\n        this.listeners.forEach(({ listener }) => {\n          listener(this.currentResult)\n        })\n      }\n\n      // Then the cache listeners\n      if (notifyOptions.cache) {\n        this.client.getQueryCache().notify({\n          query: this.currentQuery,\n          type: 'observerResultsUpdated',\n        })\n      }\n    })\n  }\n}\n\nfunction shouldLoadOnMount(\n  query: Query<any, any, any, any>,\n  options: QueryObserverOptions<any, any, any, any>,\n): boolean {\n  return (\n    options.enabled !== false &&\n    !query.state.dataUpdatedAt &&\n    !(query.state.status === 'error' && options.retryOnMount === false)\n  )\n}\n\nfunction shouldFetchOnMount(\n  query: Query<any, any, any, any>,\n  options: QueryObserverOptions<any, any, any, any, any>,\n): boolean {\n  return (\n    shouldLoadOnMount(query, options) ||\n    (query.state.dataUpdatedAt > 0 &&\n      shouldFetchOn(query, options, options.refetchOnMount))\n  )\n}\n\nfunction shouldFetchOn(\n  query: Query<any, any, any, any>,\n  options: QueryObserverOptions<any, any, any, any, any>,\n  field: typeof options['refetchOnMount'] &\n    typeof options['refetchOnWindowFocus'] &\n    typeof options['refetchOnReconnect'],\n) {\n  if (options.enabled !== false) {\n    const value = typeof field === 'function' ? field(query) : field\n\n    return value === 'always' || (value !== false && isStale(query, options))\n  }\n  return false\n}\n\nfunction shouldFetchOptionally(\n  query: Query<any, any, any, any>,\n  prevQuery: Query<any, any, any, any>,\n  options: QueryObserverOptions<any, any, any, any, any>,\n  prevOptions: QueryObserverOptions<any, any, any, any, any>,\n): boolean {\n  return (\n    options.enabled !== false &&\n    (query !== prevQuery || prevOptions.enabled === false) &&\n    (!options.suspense || query.state.status !== 'error') &&\n    isStale(query, options)\n  )\n}\n\nfunction isStale(\n  query: Query<any, any, any, any>,\n  options: QueryObserverOptions<any, any, any, any, any>,\n): boolean {\n  return query.isStaleByTime(options.staleTime)\n}\n\n// this function would decide if we will update the observer's 'current'\n// properties after an optimistic reading via getOptimisticResult\nfunction shouldAssignObserverCurrentProperties<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n  optimisticResult: QueryObserverResult<TData, TError>,\n  options: DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n) {\n  // it is important to keep this condition like this for three reasons:\n  // 1. It will get removed in the v5\n  // 2. it reads: don't update the properties if we want to keep the previous\n  // data.\n  // 3. The opposite condition (!options.keepPreviousData) would fallthrough\n  // and will result in a bad decision\n  if (options.keepPreviousData) {\n    return false\n  }\n\n  // this means we want to put some placeholder data when pending and queryKey\n  // changed.\n  if (options.placeholderData !== undefined) {\n    // re-assign properties only if current data is placeholder data\n    // which means that data did not arrive yet, so, if there is some cached data\n    // we need to \"prepare\" to receive it\n    return optimisticResult.isPlaceholderData\n  }\n\n  // if the newly created result isn't what the observer is holding as current,\n  // then we'll need to update the properties as well\n  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {\n    return true\n  }\n\n  // basically, just keep previous properties if nothing changed\n  return false\n}\n","'use client'\nimport * as React from 'react'\n\n// CONTEXT\n\nexport interface QueryErrorResetBoundaryValue {\n  clearReset: () => void\n  isReset: () => boolean\n  reset: () => void\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n  let isReset = false\n  return {\n    clearReset: () => {\n      isReset = false\n    },\n    reset: () => {\n      isReset = true\n    },\n    isReset: () => {\n      return isReset\n    },\n  }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n  React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport interface QueryErrorResetBoundaryProps {\n  children:\n    | ((value: QueryErrorResetBoundaryValue) => React.ReactNode)\n    | React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n  children,\n}: QueryErrorResetBoundaryProps) => {\n  const [value] = React.useState(() => createValue())\n  return (\n    <QueryErrorResetBoundaryContext.Provider value={value}>\n      {typeof children === 'function'\n        ? (children as Function)(value)\n        : children}\n    </QueryErrorResetBoundaryContext.Provider>\n  )\n}\n","'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n","'use client'\nimport * as React from 'react'\nimport { shouldThrowError } from './utils'\nimport type {\n  DefaultedQueryObserverOptions,\n  Query,\n  QueryKey,\n  QueryObserverResult,\n  UseErrorBoundary,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensurePreventErrorBoundaryRetry = <\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>(\n  options: DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n  if (options.suspense || options.useErrorBoundary) {\n    // Prevent retrying failed query if the error boundary has not been reset yet\n    if (!errorResetBoundary.isReset()) {\n      options.retryOnMount = false\n    }\n  }\n}\n\nexport const useClearResetErrorBoundary = (\n  errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n  React.useEffect(() => {\n    errorResetBoundary.clearReset()\n  }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n  TData,\n  TError,\n  TQueryFnData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>({\n  result,\n  errorResetBoundary,\n  useErrorBoundary,\n  query,\n}: {\n  result: QueryObserverResult<TData, TError>\n  errorResetBoundary: QueryErrorResetBoundaryValue\n  useErrorBoundary: UseErrorBoundary<\n    TQueryFnData,\n    TError,\n    TQueryData,\n    TQueryKey\n  >\n  query: Query<TQueryFnData, TError, TQueryData, TQueryKey>\n}) => {\n  return (\n    result.isError &&\n    !errorResetBoundary.isReset() &&\n    !result.isFetching &&\n    shouldThrowError(useErrorBoundary, [result.error, query])\n  )\n}\n","import type { DefaultedQueryObserverOptions } from '@tanstack/query-core'\nimport type { QueryObserver } from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\nimport type { QueryObserverResult } from '@tanstack/query-core'\nimport type { QueryKey } from '@tanstack/query-core'\n\nexport const ensureStaleTime = (\n  defaultedOptions: DefaultedQueryObserverOptions<any, any, any, any, any>,\n) => {\n  if (defaultedOptions.suspense) {\n    // Always set stale time when using suspense to prevent\n    // fetching again when directly mounting after suspending\n    if (typeof defaultedOptions.staleTime !== 'number') {\n      defaultedOptions.staleTime = 1000\n    }\n  }\n}\n\nexport const willFetch = (\n  result: QueryObserverResult<any, any>,\n  isRestoring: boolean,\n) => result.isLoading && result.isFetching && !isRestoring\n\nexport const shouldSuspend = (\n  defaultedOptions:\n    | DefaultedQueryObserverOptions<any, any, any, any, any>\n    | undefined,\n  result: QueryObserverResult<any, any>,\n  isRestoring: boolean,\n) => defaultedOptions?.suspense && willFetch(result, isRestoring)\n\nexport const fetchOptimistic = <\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>(\n  defaultedOptions: DefaultedQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  observer: QueryObserver<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n  errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n  observer\n    .fetchOptimistic(defaultedOptions)\n    .then(({ data }) => {\n      defaultedOptions.onSuccess?.(data as TData)\n      defaultedOptions.onSettled?.(data, null)\n    })\n    .catch((error) => {\n      errorResetBoundary.clearReset()\n      defaultedOptions.onError?.(error)\n      defaultedOptions.onSettled?.(undefined, error)\n    })\n","'use client'\nimport { QueryObserver, parseQueryArgs } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type { QueryFunction, QueryKey } from '@tanstack/query-core'\nimport type {\n  DefinedUseQueryResult,\n  UseQueryOptions,\n  UseQueryResult,\n} from './types'\n\n// HOOK\n\nexport function useQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: Omit<\n    UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n    'initialData'\n  > & { initialData?: () => undefined },\n): UseQueryResult<TData, TError>\n\nexport function useQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: Omit<\n    UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n    'initialData'\n  > & { initialData: TQueryFnData | (() => TQueryFnData) },\n): DefinedUseQueryResult<TData, TError>\n\nexport function useQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UseQueryResult<TData, TError>\n\nexport function useQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  queryKey: TQueryKey,\n  options?: Omit<\n    UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n    'queryKey' | 'initialData'\n  > & { initialData?: () => undefined },\n): UseQueryResult<TData, TError>\n\nexport function useQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  queryKey: TQueryKey,\n  options?: Omit<\n    UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n    'queryKey' | 'initialData'\n  > & { initialData: TQueryFnData | (() => TQueryFnData) },\n): DefinedUseQueryResult<TData, TError>\n\nexport function useQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  queryKey: TQueryKey,\n  options?: Omit<\n    UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n    'queryKey'\n  >,\n): UseQueryResult<TData, TError>\n\nexport function useQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  queryKey: TQueryKey,\n  queryFn: QueryFunction<TQueryFnData, TQueryKey>,\n  options?: Omit<\n    UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n    'queryKey' | 'queryFn' | 'initialData'\n  > & { initialData?: () => undefined },\n): UseQueryResult<TData, TError>\n\nexport function useQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  queryKey: TQueryKey,\n  queryFn: QueryFunction<TQueryFnData, TQueryKey>,\n  options?: Omit<\n    UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n    'queryKey' | 'queryFn' | 'initialData'\n  > & { initialData: TQueryFnData | (() => TQueryFnData) },\n): DefinedUseQueryResult<TData, TError>\n\nexport function useQuery<\n  TQueryFnData = unknown,\n  TError = unknown,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  queryKey: TQueryKey,\n  queryFn: QueryFunction<TQueryFnData, TQueryKey>,\n  options?: Omit<\n    UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n    'queryKey' | 'queryFn'\n  >,\n): UseQueryResult<TData, TError>\n\nexport function useQuery<\n  TQueryFnData,\n  TError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n>(\n  arg1: TQueryKey | UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  arg2?:\n    | QueryFunction<TQueryFnData, TQueryKey>\n    | UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n  arg3?: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,\n): UseQueryResult<TData, TError> {\n  const parsedOptions = parseQueryArgs(arg1, arg2, arg3)\n  return useBaseQuery(parsedOptions, QueryObserver)\n}\n","'use client'\nimport * as React from 'react'\n\nimport { notifyManager } from '@tanstack/query-core'\nimport { useSyncExternalStore } from './useSyncExternalStore'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './isRestoring'\nimport {\n  ensurePreventErrorBoundaryRetry,\n  getHasError,\n  useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport { ensureStaleTime, fetchOptimistic, shouldSuspend } from './suspense'\nimport type { QueryKey, QueryObserver } from '@tanstack/query-core'\nimport type { UseBaseQueryOptions } from './types'\n\nexport function useBaseQuery<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryData,\n  TQueryKey extends QueryKey,\n>(\n  options: UseBaseQueryOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryData,\n    TQueryKey\n  >,\n  Observer: typeof QueryObserver,\n) {\n  const queryClient = useQueryClient({ context: options.context })\n  const isRestoring = useIsRestoring()\n  const errorResetBoundary = useQueryErrorResetBoundary()\n  const defaultedOptions = queryClient.defaultQueryOptions(options)\n\n  // Make sure results are optimistically set in fetching state before subscribing or updating options\n  defaultedOptions._optimisticResults = isRestoring\n    ? 'isRestoring'\n    : 'optimistic'\n\n  // Include callbacks in batch renders\n  if (defaultedOptions.onError) {\n    defaultedOptions.onError = notifyManager.batchCalls(\n      defaultedOptions.onError,\n    )\n  }\n\n  if (defaultedOptions.onSuccess) {\n    defaultedOptions.onSuccess = notifyManager.batchCalls(\n      defaultedOptions.onSuccess,\n    )\n  }\n\n  if (defaultedOptions.onSettled) {\n    defaultedOptions.onSettled = notifyManager.batchCalls(\n      defaultedOptions.onSettled,\n    )\n  }\n\n  ensureStaleTime(defaultedOptions)\n  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary)\n\n  useClearResetErrorBoundary(errorResetBoundary)\n\n  const [observer] = React.useState(\n    () =>\n      new Observer<TQueryFnData, TError, TData, TQueryData, TQueryKey>(\n        queryClient,\n        defaultedOptions,\n      ),\n  )\n\n  const result = observer.getOptimisticResult(defaultedOptions)\n\n  useSyncExternalStore(\n    React.useCallback(\n      (onStoreChange) => {\n        const unsubscribe = isRestoring\n          ? () => undefined\n          : observer.subscribe(notifyManager.batchCalls(onStoreChange))\n\n        // Update result to make sure we did not miss any query updates\n        // between creating the observer and subscribing to it.\n        observer.updateResult()\n\n        return unsubscribe\n      },\n      [observer, isRestoring],\n    ),\n    () => observer.getCurrentResult(),\n    () => observer.getCurrentResult(),\n  )\n\n  React.useEffect(() => {\n    // Do not notify on updates because of changes in the options because\n    // these changes should already be reflected in the optimistic result.\n    observer.setOptions(defaultedOptions, { listeners: false })\n  }, [defaultedOptions, observer])\n\n  // Handle suspense\n  if (shouldSuspend(defaultedOptions, result, isRestoring)) {\n    throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n  }\n\n  // Handle error boundary\n  if (\n    getHasError({\n      result,\n      errorResetBoundary,\n      useErrorBoundary: defaultedOptions.useErrorBoundary,\n      query: observer.getCurrentQuery(),\n    })\n  ) {\n    throw result.error\n  }\n\n  // Handle result property usage tracking\n  return !defaultedOptions.notifyOnChangeProps\n    ? observer.trackResult(result)\n    : result\n}\n","'use client'\n// Temporary workaround due to an issue with react-native uSES - https://github.com/TanStack/query/pull/3601\nimport { useSyncExternalStore as uSES } from 'use-sync-external-store/shim/index.js'\n\nexport const useSyncExternalStore = uSES\n","export function shouldThrowError<T extends (...args: any[]) => boolean>(\n  _useErrorBoundary: boolean | T | undefined,\n  params: Parameters<T>,\n): boolean {\n  // Allow useErrorBoundary function to override throwing behavior on a per-error basis\n  if (typeof _useErrorBoundary === 'function') {\n    return _useErrorBoundary(...params)\n  }\n\n  return !!_useErrorBoundary\n}\n"],"names":["Object","defineProperty","exports","value","obj","_default","require","__esModule","module","_interopRequireDefault","_typeof","_objectSpread2","React","nodeInterop","default","cache","_getRequireWildcardCache","has","get","newObj","hasPropertyDescriptor","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","_interopRequireWildcard","_QuestionCircleOutlined","_AntdIcon","WeakMap","cacheBabelInterop","cacheNodeInterop","QuestionCircleOutlined","props","ref","createElement","icon","displayName","forwardRef","t","nodeType","e","n","clientHeight","scrollHeight","clientWidth","scrollWidth","i","getComputedStyle","overflowY","overflowX","ownerDocument","defaultView","frameElement","r","o","l","d","window","scrollMode","block","f","inline","h","boundary","u","skipOverflowHiddenElements","s","TypeError","c","a","g","document","scrollingElement","documentElement","m","p","parentElement","getRootNode","host","push","body","w","visualViewport","width","innerWidth","v","height","innerHeight","W","scrollX","pageXOffset","H","scrollY","pageYOffset","b","getBoundingClientRect","y","E","M","top","V","right","x","bottom","I","left","C","R","T","k","length","B","D","O","X","Y","L","S","j","N","q","parseInt","borderLeftWidth","z","borderTopWidth","A","borderRightWidth","F","borderBottomWidth","G","J","K","offsetWidth","P","offsetHeight","Q","U","Math","max","Z","scrollLeft","$","scrollTop","min","el","trimmedEndIndex","reTrimStart","string","slice","replace","reWhitespace","index","test","charAt","isObject","now","toNumber","nativeMax","nativeMin","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","invokeFunc","time","args","thisArg","undefined","apply","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","setTimeout","timeWaiting","remainingWait","debounced","isInvoking","arguments","this","leadingEdge","clearTimeout","cancel","flush","type","root","Date","baseTrim","isSymbol","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","other","valueOf","isBinary","_excluded","Checkbox","_classNames","_props$prefixCls","prefixCls","className","style","checked","disabled","_props$defaultChecked","defaultChecked","_props$type","onChange","inputProps","_objectWithoutProperties","inputRef","useRef","_useMergedState","useMergedState","_useMergedState2","_slicedToArray","rawValue","setRawValue","useImperativeHandle","focus","_inputRef$current","current","blur","_inputRef$current2","input","classString","classNames","_defineProperty","concat","_extends","target","_objectSpread","stopPropagation","preventDefault","nativeEvent","children","containerRef","id","eventHandlers","onMouseEnter","onMouseOver","onMouseLeave","onClick","onKeyDown","onKeyUp","role","parseWidthHeight","String","Number","warning","sentinelStyle","overflow","outline","position","DrawerPopup","_ref","_pushConfig$distance","_pushConfig","open","placement","forceRender","autoFocus","keyboard","rootClassName","rootStyle","zIndex","motion","contentWrapperStyle","mask","maskClosable","maskMotion","maskClassName","maskStyle","afterOpenChange","onClose","panelRef","sentinelStartRef","sentinelEndRef","_panelRef$current","preventScroll","_React$useState","_React$useState2","pushed","setPushed","parentContext","DrawerContext","pushDistance","distance","mergedContext","pull","_parentContext$push","_parentContext$pull","_parentContext$pull2","maskNode","CSSMotion","visible","_ref2","maskRef","motionMaskClassName","motionMaskStyle","motionProps","wrapperStyle","transform","panelNode","onVisibleChanged","nextVisible","removeOnLeave","leavedClassName","_ref3","motionRef","motionClassName","motionStyle","pickAttrs","data","DrawerPanel","containerStyle","Provider","tabIndex","event","keyCode","shiftKey","KeyCode","TAB","_sentinelStartRef$cur","activeElement","_sentinelEndRef$curre","ESC","_props$open","_props$placement","_props$autoFocus","_props$keyboard","_props$width","_props$mask","_props$maskClosable","getContainer","destroyOnClose","animatedVisible","setAnimatedVisible","_React$useState3","_React$useState4","mounted","setMounted","useLayoutEffect","mergedOpen","lastActiveRef","drawerPopupProps","_lastActiveRef$curren","contains","Portal","autoDestroy","autoLock","_computeScrollIntoView","isOptionsObject","keys","isTargetAttached","isConnected","behavior","computeOptions","getOptions","actions","canSmoothScroll","forEach","scroll","defaultBehavior","defaultValue","_useState","useState","_useState2","setValue","setTrue","useCallback","setFalse","toggle","countdownOption","countStart","intervalMs","isIncrement","countStop","isDeprecated","console","warn","seconds","interval","_useCounter","useCounter","count","increment","decrement","resetCounter","reset","_useBoolean","useBoolean","isCountdownRunning","startCountdown","stopCountdown","resetCountdown","countdownCallback","useInterval","start","stop","initialValue","setCount","callback","delay","savedCallback","useIsomorphicLayoutEffect","useEffect","setInterval","clearInterval","QueryObserver","_Subscribable","_inherits","_super","_createSuper","client","_this","_classCallCheck","trackedProps","Set","selectError","bindMethods","setOptions","_createClass","remove","bind","refetch","listeners","size","currentQuery","addObserver","shouldFetchOnMount","executeFetch","updateTimers","hasListeners","destroy","shouldFetchOn","refetchOnReconnect","refetchOnWindowFocus","clearStaleTimeout","clearRefetchInterval","removeObserver","notifyOptions","prevOptions","prevQuery","defaultQueryOptions","shallowEqualObjects","getQueryCache","notify","query","observer","enabled","Error","queryKey","updateQuery","shouldFetchOptionally","updateResult","staleTime","updateStaleTimeout","nextRefetchInterval","computeRefetchInterval","currentRefetchInterval","updateRefetchInterval","build","createResult","optimisticResult","keepPreviousData","placeholderData","isPlaceholderData","getCurrentResult","shouldAssignObserverCurrentProperties","currentResult","currentResultOptions","currentResultState","state","_this2","trackedResult","configurable","enumerable","add","refetchPage","fetch","meta","_this3","defaultedOptions","isFetchingOptimistic","then","fetchOptions","_fetchOptions$cancelR","_this4","cancelRefetch","promise","throwOnError","catch","noop","_this5","isServer","isStale","isValidTimeout","timeout","timeUntilStale","dataUpdatedAt","staleTimeoutId","_this$options$refetch","refetchInterval","nextInterval","_this6","refetchIntervalId","refetchIntervalInBackground","focusManager","isFocused","prevResult","prevResultState","prevResultOptions","queryChange","queryInitialState","currentQueryInitialState","prevQueryResult","previousQueryResult","error","errorUpdatedAt","fetchStatus","status","isPreviousData","_optimisticResults","fetchOnMount","fetchOptionally","canFetch","networkMode","isSuccess","select","selectFn","selectResult","replaceData","process","isFetching","isLoading","isError","isInitialLoading","failureCount","fetchFailureCount","failureReason","fetchFailureReason","errorUpdateCount","isFetched","dataUpdateCount","isFetchedAfterMount","isRefetching","isLoadingError","isPaused","isRefetchError","_this7","nextResult","defaultNotifyOptions","notifyOnChangeProps","notifyOnChangePropsValue","includedProps","useErrorBoundary","some","typedKey","shouldNotifyListeners","action","onSuccess","manual","isCancelledError","onError","_this8","notifyManager","batch","_this$options$onSucce","_this$options","_this$options$onSettl","_this$options2","onSettled","_this$options$onError","_this$options3","_this$options$onSettl2","_this$options4","listener","Subscribable","retryOnMount","shouldLoadOnMount","refetchOnMount","field","suspense","isStaleByTime","createValue","clearReset","isReset","QueryErrorResetBoundaryContext","useQueryErrorResetBoundary","IsRestoringContext","useIsRestoring","errorResetBoundary","useClearResetErrorBoundary","getHasError","ensureStaleTime","shouldSuspend","isRestoring","willFetch","fetchOptimistic","useQuery","arg1","arg2","arg3","Observer","ensurePreventErrorBoundaryRetry","queryClient","getOptimisticResult","useSyncExternalStore","onStoreChange","unsubscribe","subscribe","batchCalls","trackResult","useBaseQuery","useSyncExternalStore$1","shouldThrowError","_useErrorBoundary","params","_toConsumableArray"],"sourceRoot":""}