@neynar/ui 0.4.0 → 1.0.0

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingPortal.js

@@ -0,0 +1,176 @@
+"use client";
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { isNode } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useId } from "../../../../utils/esm/useId.js";
+import { useIsoLayoutEffect } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { FocusGuard } from "../../utils/FocusGuard.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { createAttribute } from "../utils/createAttribute.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { ownerVisuallyHidden } from "../../utils/constants.js";
+import { jsxs, jsx } from "react/jsx-runtime";
+import { enableFocusInside, isOutsideEvent, getPreviousTabbable, getNextTabbable, disableFocusInside } from "../utils/tabbable.js";
+import { EMPTY_OBJECT } from "../../../../utils/esm/empty.js";
+import { focusOut } from "../../utils/reason-parts.js";
+const PortalContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") PortalContext.displayName = "PortalContext";
+const usePortalContext = () => React.useContext(PortalContext);
+const attr = createAttribute("portal");
+function useFloatingPortalNode(props = {}) {
+  const {
+    ref,
+    container: containerProp,
+    componentProps = EMPTY_OBJECT,
+    elementProps,
+    elementState
+  } = props;
+  const uniqueId = useId();
+  const portalContext = usePortalContext();
+  const parentPortalNode = portalContext?.portalNode;
+  const [containerElement, setContainerElement] = React.useState(null);
+  const [portalNode, setPortalNode] = React.useState(null);
+  const containerRef = React.useRef(null);
+  useIsoLayoutEffect(() => {
+    if (containerProp === null) {
+      if (containerRef.current) {
+        containerRef.current = null;
+        setPortalNode(null);
+        setContainerElement(null);
+      }
+      return;
+    }
+    if (uniqueId == null) {
+      return;
+    }
+    const resolvedContainer = (containerProp && (isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
+    if (resolvedContainer == null) {
+      if (containerRef.current) {
+        containerRef.current = null;
+        setPortalNode(null);
+        setContainerElement(null);
+      }
+      return;
+    }
+    if (containerRef.current !== resolvedContainer) {
+      containerRef.current = resolvedContainer;
+      setPortalNode(null);
+      setContainerElement(resolvedContainer);
+    }
+  }, [containerProp, parentPortalNode, uniqueId]);
+  const portalElement = useRenderElement("div", componentProps, {
+    ref: [ref, setPortalNode],
+    state: elementState,
+    props: [{
+      id: uniqueId,
+      [attr]: ""
+    }, elementProps]
+  });
+  const portalSubtree = containerElement && portalElement ? /* @__PURE__ */ ReactDOM.createPortal(portalElement, containerElement) : null;
+  return {
+    portalNode,
+    portalSubtree
+  };
+}
+const FloatingPortal = /* @__PURE__ */ React.forwardRef(function FloatingPortal2(componentProps, forwardedRef) {
+  const {
+    children,
+    container,
+    className,
+    render,
+    renderGuards,
+    ...elementProps
+  } = componentProps;
+  const {
+    portalNode,
+    portalSubtree
+  } = useFloatingPortalNode({
+    container,
+    ref: forwardedRef,
+    componentProps,
+    elementProps
+  });
+  const beforeOutsideRef = React.useRef(null);
+  const afterOutsideRef = React.useRef(null);
+  const beforeInsideRef = React.useRef(null);
+  const afterInsideRef = React.useRef(null);
+  const [focusManagerState, setFocusManagerState] = React.useState(null);
+  const modal = focusManagerState?.modal;
+  const open = focusManagerState?.open;
+  const shouldRenderGuards = typeof renderGuards === "boolean" ? renderGuards : !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
+  React.useEffect(() => {
+    if (!portalNode || modal) {
+      return void 0;
+    }
+    function onFocus(event) {
+      if (portalNode && isOutsideEvent(event)) {
+        const focusing = event.type === "focusin";
+        const manageFocus = focusing ? enableFocusInside : disableFocusInside;
+        manageFocus(portalNode);
+      }
+    }
+    portalNode.addEventListener("focusin", onFocus, true);
+    portalNode.addEventListener("focusout", onFocus, true);
+    return () => {
+      portalNode.removeEventListener("focusin", onFocus, true);
+      portalNode.removeEventListener("focusout", onFocus, true);
+    };
+  }, [portalNode, modal]);
+  React.useEffect(() => {
+    if (!portalNode || open) {
+      return;
+    }
+    enableFocusInside(portalNode);
+  }, [open, portalNode]);
+  const portalContextValue = React.useMemo(() => ({
+    beforeOutsideRef,
+    afterOutsideRef,
+    beforeInsideRef,
+    afterInsideRef,
+    portalNode,
+    setFocusManagerState
+  }), [portalNode]);
+  return /* @__PURE__ */ jsxs(React.Fragment, {
+    children: [portalSubtree, /* @__PURE__ */ jsxs(PortalContext.Provider, {
+      value: portalContextValue,
+      children: [shouldRenderGuards && portalNode && /* @__PURE__ */ jsx(FocusGuard, {
+        "data-type": "outside",
+        ref: beforeOutsideRef,
+        onFocus: (event) => {
+          if (isOutsideEvent(event, portalNode)) {
+            beforeInsideRef.current?.focus();
+          } else {
+            const domReference = focusManagerState ? focusManagerState.domReference : null;
+            const prevTabbable = getPreviousTabbable(domReference);
+            prevTabbable?.focus();
+          }
+        }
+      }), shouldRenderGuards && portalNode && /* @__PURE__ */ jsx("span", {
+        "aria-owns": portalNode.id,
+        style: ownerVisuallyHidden
+      }), portalNode && /* @__PURE__ */ ReactDOM.createPortal(children, portalNode), shouldRenderGuards && portalNode && /* @__PURE__ */ jsx(FocusGuard, {
+        "data-type": "outside",
+        ref: afterOutsideRef,
+        onFocus: (event) => {
+          if (isOutsideEvent(event, portalNode)) {
+            afterInsideRef.current?.focus();
+          } else {
+            const domReference = focusManagerState ? focusManagerState.domReference : null;
+            const nextTabbable = getNextTabbable(domReference);
+            nextTabbable?.focus();
+            if (focusManagerState?.closeOnFocusOut) {
+              focusManagerState?.onOpenChange(false, createChangeEventDetails(focusOut, event.nativeEvent));
+            }
+          }
+        }
+      })]
+    })]
+  });
+});
+if (process.env.NODE_ENV !== "production") FloatingPortal.displayName = "FloatingPortal";
+export {
+  FloatingPortal,
+  useFloatingPortalNode,
+  usePortalContext
+};
+//# sourceMappingURL=FloatingPortal.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingPortal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingPortal.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingPortal.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { isNode } from '@floating-ui/utils/dom';\nimport { useId } from '@base-ui/utils/useId';\nimport { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';\nimport { FocusGuard } from \"../../utils/FocusGuard.js\";\nimport { enableFocusInside, disableFocusInside, getPreviousTabbable, getNextTabbable, isOutsideEvent } from \"../utils.js\";\nimport { createChangeEventDetails } from \"../../utils/createBaseUIEventDetails.js\";\nimport { REASONS } from \"../../utils/reasons.js\";\nimport { createAttribute } from \"../utils/createAttribute.js\";\nimport { useRenderElement } from \"../../utils/useRenderElement.js\";\nimport { EMPTY_OBJECT, ownerVisuallyHidden } from \"../../utils/constants.js\";\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nconst PortalContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") PortalContext.displayName = \"PortalContext\";\nexport const usePortalContext = () => React.useContext(PortalContext);\nconst attr = createAttribute('portal');\nexport function useFloatingPortalNode(props = {}) {\n  const {\n    ref,\n    container: containerProp,\n    componentProps = EMPTY_OBJECT,\n    elementProps,\n    elementState\n  } = props;\n  const uniqueId = useId();\n  const portalContext = usePortalContext();\n  const parentPortalNode = portalContext?.portalNode;\n  const [containerElement, setContainerElement] = React.useState(null);\n  const [portalNode, setPortalNode] = React.useState(null);\n  const containerRef = React.useRef(null);\n  useIsoLayoutEffect(() => {\n    // Wait for the container to be resolved if explicitly `null`.\n    if (containerProp === null) {\n      if (containerRef.current) {\n        containerRef.current = null;\n        setPortalNode(null);\n        setContainerElement(null);\n      }\n      return;\n    }\n\n    // React 17 does not use React.useId().\n    if (uniqueId == null) {\n      return;\n    }\n    const resolvedContainer = (containerProp && (isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;\n    if (resolvedContainer == null) {\n      if (containerRef.current) {\n        containerRef.current = null;\n        setPortalNode(null);\n        setContainerElement(null);\n      }\n      return;\n    }\n    if (containerRef.current !== resolvedContainer) {\n      containerRef.current = resolvedContainer;\n      setPortalNode(null);\n      setContainerElement(resolvedContainer);\n    }\n  }, [containerProp, parentPortalNode, uniqueId]);\n  const portalElement = useRenderElement('div', componentProps, {\n    ref: [ref, setPortalNode],\n    state: elementState,\n    props: [{\n      id: uniqueId,\n      [attr]: ''\n    }, elementProps]\n  });\n\n  // This `createPortal` call injects `portalElement` into the `container`.\n  // Another call inside `FloatingPortal`/`FloatingPortalLite` then injects the children into `portalElement`.\n  const portalSubtree = containerElement && portalElement ? /*#__PURE__*/ReactDOM.createPortal(portalElement, containerElement) : null;\n  return {\n    portalNode,\n    portalSubtree\n  };\n}\n\n/**\n * Portals the floating element into a given container element — by default,\n * outside of the app root and into the body.\n * This is necessary to ensure the floating element can appear outside any\n * potential parent containers that cause clipping (such as `overflow: hidden`),\n * while retaining its location in the React tree.\n * @see https://floating-ui.com/docs/FloatingPortal\n * @internal\n */\nexport const FloatingPortal = /*#__PURE__*/React.forwardRef(function FloatingPortal(componentProps, forwardedRef) {\n  const {\n    children,\n    container,\n    className,\n    render,\n    renderGuards,\n    ...elementProps\n  } = componentProps;\n  const {\n    portalNode,\n    portalSubtree\n  } = useFloatingPortalNode({\n    container,\n    ref: forwardedRef,\n    componentProps,\n    elementProps\n  });\n  const beforeOutsideRef = React.useRef(null);\n  const afterOutsideRef = React.useRef(null);\n  const beforeInsideRef = React.useRef(null);\n  const afterInsideRef = React.useRef(null);\n  const [focusManagerState, setFocusManagerState] = React.useState(null);\n  const modal = focusManagerState?.modal;\n  const open = focusManagerState?.open;\n  const shouldRenderGuards = typeof renderGuards === 'boolean' ? renderGuards : !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;\n\n  // https://codesandbox.io/s/tabbable-portal-f4tng?file=/src/TabbablePortal.tsx\n  React.useEffect(() => {\n    if (!portalNode || modal) {\n      return undefined;\n    }\n\n    // Make sure elements inside the portal element are tabbable only when the\n    // portal has already been focused, either by tabbing into a focus trap\n    // element outside or using the mouse.\n    function onFocus(event) {\n      if (portalNode && isOutsideEvent(event)) {\n        const focusing = event.type === 'focusin';\n        const manageFocus = focusing ? enableFocusInside : disableFocusInside;\n        manageFocus(portalNode);\n      }\n    }\n\n    // Listen to the event on the capture phase so they run before the focus\n    // trap elements onFocus prop is called.\n    portalNode.addEventListener('focusin', onFocus, true);\n    portalNode.addEventListener('focusout', onFocus, true);\n    return () => {\n      portalNode.removeEventListener('focusin', onFocus, true);\n      portalNode.removeEventListener('focusout', onFocus, true);\n    };\n  }, [portalNode, modal]);\n  React.useEffect(() => {\n    if (!portalNode || open) {\n      return;\n    }\n    enableFocusInside(portalNode);\n  }, [open, portalNode]);\n  const portalContextValue = React.useMemo(() => ({\n    beforeOutsideRef,\n    afterOutsideRef,\n    beforeInsideRef,\n    afterInsideRef,\n    portalNode,\n    setFocusManagerState\n  }), [portalNode]);\n  return /*#__PURE__*/_jsxs(React.Fragment, {\n    children: [portalSubtree, /*#__PURE__*/_jsxs(PortalContext.Provider, {\n      value: portalContextValue,\n      children: [shouldRenderGuards && portalNode && /*#__PURE__*/_jsx(FocusGuard, {\n        \"data-type\": \"outside\",\n        ref: beforeOutsideRef,\n        onFocus: event => {\n          if (isOutsideEvent(event, portalNode)) {\n            beforeInsideRef.current?.focus();\n          } else {\n            const domReference = focusManagerState ? focusManagerState.domReference : null;\n            const prevTabbable = getPreviousTabbable(domReference);\n            prevTabbable?.focus();\n          }\n        }\n      }), shouldRenderGuards && portalNode && /*#__PURE__*/_jsx(\"span\", {\n        \"aria-owns\": portalNode.id,\n        style: ownerVisuallyHidden\n      }), portalNode && /*#__PURE__*/ReactDOM.createPortal(children, portalNode), shouldRenderGuards && portalNode && /*#__PURE__*/_jsx(FocusGuard, {\n        \"data-type\": \"outside\",\n        ref: afterOutsideRef,\n        onFocus: event => {\n          if (isOutsideEvent(event, portalNode)) {\n            afterInsideRef.current?.focus();\n          } else {\n            const domReference = focusManagerState ? focusManagerState.domReference : null;\n            const nextTabbable = getNextTabbable(domReference);\n            nextTabbable?.focus();\n            if (focusManagerState?.closeOnFocusOut) {\n              focusManagerState?.onOpenChange(false, createChangeEventDetails(REASONS.focusOut, event.nativeEvent));\n            }\n          }\n        }\n      })]\n    })]\n  });\n});\nif (process.env.NODE_ENV !== \"production\") FloatingPortal.displayName = \"FloatingPortal\";"],"names":[],"mappings":";;;;;;;;;;;;;;;AAeA;AACA;AACY;AACZ;AACO;AACL;AAAM;AACJ;AACW;AACM;AACjB;AACA;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AAEE;AACE;AACE;AACA;AACA;AAAwB;AAE1B;AAAA;AAIF;AACE;AAAA;AAEF;AACA;AACE;AACE;AACA;AACA;AAAwB;AAE1B;AAAA;AAEF;AACE;AACA;AACA;AAAqC;AACvC;AAEF;AAA8D;AACpC;AACjB;AACC;AACF;AACI;AACK;AAKjB;AACA;AAAO;AACL;AACA;AAEJ;AAWY;AACV;AAAM;AACJ;AACA;AACA;AACA;AACA;AACG;AAEL;AAAM;AACJ;AACA;AACwB;AACxB;AACK;AACL;AACA;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAGA;AACE;AACE;AAAO;AAMT;AACE;AACE;AACA;AACA;AAAsB;AACxB;AAKF;AACA;AACA;AACE;AACA;AAAwD;AAC1D;AAEF;AACE;AACE;AAAA;AAEF;AAA4B;AAE9B;AAAgD;AAC9C;AACA;AACA;AACA;AACA;AACA;AAEF;AAA0C;AAC6B;AAC5D;AACsE;AAC9D;AACR;AAEH;AACE;AAA8B;AAE9B;AACA;AACA;AAAmB;AACrB;AACF;AACgE;AACxC;AACjB;AACqI;AAC/H;AACR;AAEH;AACE;AAA6B;AAE7B;AACA;AACA;AACA;AACE;AAAoG;AACtG;AACF;AACF;AACA;AACF;AAEN;AACA;;;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingRootStore.js

@@ -0,0 +1,64 @@
+import { createEventEmitter } from "../utils/createEventEmitter.js";
+import { ReactStore } from "../../../../utils/esm/store/ReactStore.js";
+import { createSelector } from "../../../../utils/esm/store/createSelector.js";
+import { isClickLikeEvent } from "../utils/event.js";
+const selectors = {
+  open: createSelector((state) => state.open),
+  domReferenceElement: createSelector((state) => state.domReferenceElement),
+  referenceElement: createSelector((state) => state.positionReference ?? state.referenceElement),
+  floatingElement: createSelector((state) => state.floatingElement),
+  floatingId: createSelector((state) => state.floatingId)
+};
+class FloatingRootStore extends ReactStore {
+  constructor(options) {
+    const {
+      nested,
+      noEmit,
+      onOpenChange,
+      triggerElements,
+      ...initialState
+    } = options;
+    super({
+      ...initialState,
+      positionReference: initialState.referenceElement,
+      domReferenceElement: initialState.referenceElement
+    }, {
+      onOpenChange,
+      dataRef: {
+        current: {}
+      },
+      events: createEventEmitter(),
+      nested,
+      noEmit,
+      triggerElements
+    }, selectors);
+  }
+  /**
+   * Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.
+   *
+   * @param newOpen The new open state.
+   * @param eventDetails Details about the event that triggered the open state change.
+   */
+  setOpen = (newOpen, eventDetails) => {
+    if (!newOpen || !this.state.open || // Prevent a pending hover-open from overwriting a click-open event, while allowing
+    // click events to upgrade a hover-open.
+    isClickLikeEvent(eventDetails.event)) {
+      this.context.dataRef.current.openEvent = newOpen ? eventDetails.event : void 0;
+    }
+    if (!this.context.noEmit) {
+      const details = {
+        open: newOpen,
+        reason: eventDetails.reason,
+        nativeEvent: eventDetails.event,
+        nested: this.context.nested,
+        triggerElement: eventDetails.trigger
+      };
+      this.context.events.emit("openchange", details);
+    }
+    this.context.onOpenChange?.(newOpen, eventDetails);
+  };
+}
+export {
+  FloatingRootStore
+};
+//# sourceMappingURL=FloatingRootStore.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingRootStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingRootStore.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingRootStore.js"],"sourcesContent":["import { createSelector, ReactStore } from '@base-ui/utils/store';\nimport { createEventEmitter } from \"../utils/createEventEmitter.js\";\nimport { isClickLikeEvent } from \"../utils.js\";\nconst selectors = {\n  open: createSelector(state => state.open),\n  domReferenceElement: createSelector(state => state.domReferenceElement),\n  referenceElement: createSelector(state => state.positionReference ?? state.referenceElement),\n  floatingElement: createSelector(state => state.floatingElement),\n  floatingId: createSelector(state => state.floatingId)\n};\nexport class FloatingRootStore extends ReactStore {\n  constructor(options) {\n    const {\n      nested,\n      noEmit,\n      onOpenChange,\n      triggerElements,\n      ...initialState\n    } = options;\n    super({\n      ...initialState,\n      positionReference: initialState.referenceElement,\n      domReferenceElement: initialState.referenceElement\n    }, {\n      onOpenChange,\n      dataRef: {\n        current: {}\n      },\n      events: createEventEmitter(),\n      nested,\n      noEmit,\n      triggerElements\n    }, selectors);\n  }\n\n  /**\n   * Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.\n   *\n   * @param newOpen The new open state.\n   * @param eventDetails Details about the event that triggered the open state change.\n   */\n  setOpen = (newOpen, eventDetails) => {\n    if (!newOpen || !this.state.open ||\n    // Prevent a pending hover-open from overwriting a click-open event, while allowing\n    // click events to upgrade a hover-open.\n    isClickLikeEvent(eventDetails.event)) {\n      this.context.dataRef.current.openEvent = newOpen ? eventDetails.event : undefined;\n    }\n    if (!this.context.noEmit) {\n      const details = {\n        open: newOpen,\n        reason: eventDetails.reason,\n        nativeEvent: eventDetails.event,\n        nested: this.context.nested,\n        triggerElement: eventDetails.trigger\n      };\n      this.context.events.emit('openchange', details);\n    }\n    this.context.onOpenChange?.(newOpen, eventDetails);\n  };\n}"],"names":[],"mappings":";;;;AAGA,MAAM,YAAY;AAAA,EAChB,MAAM,eAAe,WAAS,MAAM,IAAI;AAAA,EACxC,qBAAqB,eAAe,WAAS,MAAM,mBAAmB;AAAA,EACtE,kBAAkB,eAAe,WAAS,MAAM,qBAAqB,MAAM,gBAAgB;AAAA,EAC3F,iBAAiB,eAAe,WAAS,MAAM,eAAe;AAAA,EAC9D,YAAY,eAAe,WAAS,MAAM,UAAU;AACtD;AACO,MAAM,0BAA0B,WAAW;AAAA,EAChD,YAAY,SAAS;AACnB,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,GAAG;AAAA,IACT,IAAQ;AACJ,UAAM;AAAA,MACJ,GAAG;AAAA,MACH,mBAAmB,aAAa;AAAA,MAChC,qBAAqB,aAAa;AAAA,IACxC,GAAO;AAAA,MACD;AAAA,MACA,SAAS;AAAA,QACP,SAAS,CAAA;AAAA,MACjB;AAAA,MACM,QAAQ,mBAAkB;AAAA,MAC1B;AAAA,MACA;AAAA,MACA;AAAA,IACN,GAAO,SAAS;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,UAAU,CAAC,SAAS,iBAAiB;AACnC,QAAI,CAAC,WAAW,CAAC,KAAK,MAAM;AAAA;AAAA,IAG5B,iBAAiB,aAAa,KAAK,GAAG;AACpC,WAAK,QAAQ,QAAQ,QAAQ,YAAY,UAAU,aAAa,QAAQ;AAAA,IAC1E;AACA,QAAI,CAAC,KAAK,QAAQ,QAAQ;AACxB,YAAM,UAAU;AAAA,QACd,MAAM;AAAA,QACN,QAAQ,aAAa;AAAA,QACrB,aAAa,aAAa;AAAA,QAC1B,QAAQ,KAAK,QAAQ;AAAA,QACrB,gBAAgB,aAAa;AAAA,MACrC;AACM,WAAK,QAAQ,OAAO,KAAK,cAAc,OAAO;AAAA,IAChD;AACA,SAAK,QAAQ,eAAe,SAAS,YAAY;AAAA,EACnD;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingTree.js

@@ -0,0 +1,68 @@
+"use client";
+import * as React from "react";
+import { useId } from "../../../../utils/esm/useId.js";
+import { useIsoLayoutEffect } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { useRefWithInit } from "../../../../utils/esm/useRefWithInit.js";
+import { FloatingTreeStore } from "./FloatingTreeStore.js";
+import { jsx } from "react/jsx-runtime";
+const FloatingNodeContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") FloatingNodeContext.displayName = "FloatingNodeContext";
+const FloatingTreeContext = /* @__PURE__ */ React.createContext(null);
+if (process.env.NODE_ENV !== "production") FloatingTreeContext.displayName = "FloatingTreeContext";
+const useFloatingParentNodeId = () => React.useContext(FloatingNodeContext)?.id || null;
+const useFloatingTree = (externalTree) => {
+  const contextTree = React.useContext(FloatingTreeContext);
+  return externalTree ?? contextTree;
+};
+function useFloatingNodeId(externalTree) {
+  const id = useId();
+  const tree = useFloatingTree(externalTree);
+  const parentId = useFloatingParentNodeId();
+  useIsoLayoutEffect(() => {
+    if (!id) {
+      return void 0;
+    }
+    const node = {
+      id,
+      parentId
+    };
+    tree?.addNode(node);
+    return () => {
+      tree?.removeNode(node);
+    };
+  }, [tree, id, parentId]);
+  return id;
+}
+function FloatingNode(props) {
+  const {
+    children,
+    id
+  } = props;
+  const parentId = useFloatingParentNodeId();
+  return /* @__PURE__ */ jsx(FloatingNodeContext.Provider, {
+    value: React.useMemo(() => ({
+      id,
+      parentId
+    }), [id, parentId]),
+    children
+  });
+}
+function FloatingTree(props) {
+  const {
+    children,
+    externalTree
+  } = props;
+  const tree = useRefWithInit(() => externalTree ?? new FloatingTreeStore()).current;
+  return /* @__PURE__ */ jsx(FloatingTreeContext.Provider, {
+    value: tree,
+    children
+  });
+}
+export {
+  FloatingNode,
+  FloatingTree,
+  useFloatingNodeId,
+  useFloatingParentNodeId,
+  useFloatingTree
+};
+//# sourceMappingURL=FloatingTree.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingTree.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingTree.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useId } from '@base-ui/utils/useId';\nimport { useIsoLayoutEffect } from '@base-ui/utils/useIsoLayoutEffect';\nimport { useRefWithInit } from '@base-ui/utils/useRefWithInit';\nimport { FloatingTreeStore } from \"./FloatingTreeStore.js\";\nimport { jsx as _jsx } from \"react/jsx-runtime\";\nconst FloatingNodeContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") FloatingNodeContext.displayName = \"FloatingNodeContext\";\nconst FloatingTreeContext = /*#__PURE__*/React.createContext(null);\n\n/**\n * Returns the parent node id for nested floating elements, if available.\n * Returns `null` for top-level floating elements.\n */\nif (process.env.NODE_ENV !== \"production\") FloatingTreeContext.displayName = \"FloatingTreeContext\";\nexport const useFloatingParentNodeId = () => React.useContext(FloatingNodeContext)?.id || null;\n\n/**\n * Returns the nearest floating tree context, if available.\n */\nexport const useFloatingTree = externalTree => {\n  const contextTree = React.useContext(FloatingTreeContext);\n  return externalTree ?? contextTree;\n};\n\n/**\n * Registers a node into the `FloatingTree`, returning its id.\n * @see https://floating-ui.com/docs/FloatingTree\n */\nexport function useFloatingNodeId(externalTree) {\n  const id = useId();\n  const tree = useFloatingTree(externalTree);\n  const parentId = useFloatingParentNodeId();\n  useIsoLayoutEffect(() => {\n    if (!id) {\n      return undefined;\n    }\n    const node = {\n      id,\n      parentId\n    };\n    tree?.addNode(node);\n    return () => {\n      tree?.removeNode(node);\n    };\n  }, [tree, id, parentId]);\n  return id;\n}\n/**\n * Provides parent node context for nested floating elements.\n * @see https://floating-ui.com/docs/FloatingTree\n * @internal\n */\nexport function FloatingNode(props) {\n  const {\n    children,\n    id\n  } = props;\n  const parentId = useFloatingParentNodeId();\n  return /*#__PURE__*/_jsx(FloatingNodeContext.Provider, {\n    value: React.useMemo(() => ({\n      id,\n      parentId\n    }), [id, parentId]),\n    children: children\n  });\n}\n/**\n * Provides context for nested floating elements when they are not children of\n * each other on the DOM.\n * This is not necessary in all cases, except when there must be explicit communication between parent and child floating elements. It is necessary for:\n * - The `bubbles` option in the `useDismiss()` Hook\n * - Nested virtual list navigation\n * - Nested floating elements that each open on hover\n * - Custom communication between parent and child floating elements\n * @see https://floating-ui.com/docs/FloatingTree\n * @internal\n */\nexport function FloatingTree(props) {\n  const {\n    children,\n    externalTree\n  } = props;\n  const tree = useRefWithInit(() => externalTree ?? new FloatingTreeStore()).current;\n  return /*#__PURE__*/_jsx(FloatingTreeContext.Provider, {\n    value: tree,\n    children: children\n  });\n}"],"names":[],"mappings":";;;;;;;AAQA;AACA;AACA;AAMA;AACY;AAKA;AACV;AACA;AACF;AAMO;AACL;AACA;AACA;AACA;AACE;AACE;AAAO;AAET;AAAa;AACX;AACA;AAEF;AACA;AACE;AAAqB;AACvB;AAEF;AACF;AAMO;AACL;AAAM;AACJ;AACA;AAEF;AACA;AAAuD;AACzB;AAC1B;AACA;AACgB;AAClB;AAEJ;AAYO;AACL;AAAM;AACJ;AACA;AAEF;AACA;AAAuD;AAC9C;AACP;AAEJ;;;;;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingTreeStore.js

@@ -0,0 +1,20 @@
+import { createEventEmitter } from "../utils/createEventEmitter.js";
+class FloatingTreeStore {
+  nodesRef = {
+    current: []
+  };
+  events = createEventEmitter();
+  addNode(node) {
+    this.nodesRef.current.push(node);
+  }
+  removeNode(node) {
+    const index = this.nodesRef.current.findIndex((n) => n === node);
+    if (index !== -1) {
+      this.nodesRef.current.splice(index, 1);
+    }
+  }
+}
+export {
+  FloatingTreeStore
+};
+//# sourceMappingURL=FloatingTreeStore.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingTreeStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FloatingTreeStore.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/components/FloatingTreeStore.js"],"sourcesContent":["import { createEventEmitter } from \"../utils/createEventEmitter.js\";\n\n/**\n * Stores and manages floating elements in a tree structure.\n * This is a backing store for the `FloatingTree` component.\n */\nexport class FloatingTreeStore {\n  nodesRef = {\n    current: []\n  };\n  events = createEventEmitter();\n  addNode(node) {\n    this.nodesRef.current.push(node);\n  }\n  removeNode(node) {\n    const index = this.nodesRef.current.findIndex(n => n === node);\n    if (index !== -1) {\n      this.nodesRef.current.splice(index, 1);\n    }\n  }\n}"],"names":[],"mappings":";AAMO,MAAM,kBAAkB;AAAA,EAC7B,WAAW;AAAA,IACT,SAAS,CAAA;AAAA,EACb;AAAA,EACE,SAAS,mBAAkB;AAAA,EAC3B,QAAQ,MAAM;AACZ,SAAK,SAAS,QAAQ,KAAK,IAAI;AAAA,EACjC;AAAA,EACA,WAAW,MAAM;AACf,UAAM,QAAQ,KAAK,SAAS,QAAQ,UAAU,OAAK,MAAM,IAAI;AAC7D,QAAI,UAAU,IAAI;AAChB,WAAK,SAAS,QAAQ,OAAO,OAAO,CAAC;AAAA,IACvC;AAAA,EACF;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useClick.js

@@ -0,0 +1,98 @@
+"use client";
+import * as React from "react";
+import { useAnimationFrame } from "../../../../utils/esm/useAnimationFrame.js";
+import { useTimeout } from "../../../../utils/esm/useTimeout.js";
+import { createChangeEventDetails } from "../../utils/createBaseUIEventDetails.js";
+import { isMouseLikePointerType, isClickLikeEvent } from "../utils/event.js";
+import { isTypeableElement } from "../utils/element.js";
+import { EMPTY_OBJECT } from "../../../../utils/esm/empty.js";
+import { triggerPress } from "../../utils/reason-parts.js";
+function useClick(context, props = {}) {
+  const store = "rootStore" in context ? context.rootStore : context;
+  const dataRef = store.context.dataRef;
+  const {
+    enabled = true,
+    event: eventOption = "click",
+    toggle = true,
+    ignoreMouse = false,
+    stickIfOpen = true,
+    touchOpenDelay = 0
+  } = props;
+  const pointerTypeRef = React.useRef(void 0);
+  const frame = useAnimationFrame();
+  const touchOpenTimeout = useTimeout();
+  const reference = React.useMemo(() => ({
+    onPointerDown(event) {
+      pointerTypeRef.current = event.pointerType;
+    },
+    onMouseDown(event) {
+      const pointerType = pointerTypeRef.current;
+      const nativeEvent = event.nativeEvent;
+      const open = store.select("open");
+      if (event.button !== 0 || eventOption === "click" || isMouseLikePointerType(pointerType, true) && ignoreMouse) {
+        return;
+      }
+      const openEvent = dataRef.current.openEvent;
+      const openEventType = openEvent?.type;
+      const hasClickedOnInactiveTrigger = store.select("domReferenceElement") !== event.currentTarget;
+      const nextOpen = open && hasClickedOnInactiveTrigger || !(open && toggle && (openEvent && stickIfOpen ? openEventType === "click" || openEventType === "mousedown" : true));
+      if (isTypeableElement(nativeEvent.target)) {
+        const details = createChangeEventDetails(triggerPress, nativeEvent, nativeEvent.target);
+        if (nextOpen && pointerType === "touch" && touchOpenDelay > 0) {
+          touchOpenTimeout.start(touchOpenDelay, () => {
+            store.setOpen(true, details);
+          });
+        } else {
+          store.setOpen(nextOpen, details);
+        }
+        return;
+      }
+      const eventCurrentTarget = event.currentTarget;
+      frame.request(() => {
+        const details = createChangeEventDetails(triggerPress, nativeEvent, eventCurrentTarget);
+        if (nextOpen && pointerType === "touch" && touchOpenDelay > 0) {
+          touchOpenTimeout.start(touchOpenDelay, () => {
+            store.setOpen(true, details);
+          });
+        } else {
+          store.setOpen(nextOpen, details);
+        }
+      });
+    },
+    onClick(event) {
+      if (eventOption === "mousedown-only") {
+        return;
+      }
+      const pointerType = pointerTypeRef.current;
+      if (eventOption === "mousedown" && pointerType) {
+        pointerTypeRef.current = void 0;
+        return;
+      }
+      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) {
+        return;
+      }
+      const open = store.select("open");
+      const openEvent = dataRef.current.openEvent;
+      const hasClickedOnInactiveTrigger = store.select("domReferenceElement") !== event.currentTarget;
+      const nextOpen = open && hasClickedOnInactiveTrigger || !(open && toggle && (openEvent && stickIfOpen ? isClickLikeEvent(openEvent) : true));
+      const details = createChangeEventDetails(triggerPress, event.nativeEvent, event.currentTarget);
+      if (nextOpen && pointerType === "touch" && touchOpenDelay > 0) {
+        touchOpenTimeout.start(touchOpenDelay, () => {
+          store.setOpen(true, details);
+        });
+      } else {
+        store.setOpen(nextOpen, details);
+      }
+    },
+    onKeyDown() {
+      pointerTypeRef.current = void 0;
+    }
+  }), [dataRef, eventOption, ignoreMouse, store, stickIfOpen, toggle, frame, touchOpenTimeout, touchOpenDelay]);
+  return React.useMemo(() => enabled ? {
+    reference
+  } : EMPTY_OBJECT, [enabled, reference]);
+}
+export {
+  useClick
+};
+//# sourceMappingURL=useClick.js.map

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useClick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useClick.js","sources":["../../../../../../../node_modules/@base-ui/react/esm/floating-ui-react/hooks/useClick.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useAnimationFrame } from '@base-ui/utils/useAnimationFrame';\nimport { useTimeout } from '@base-ui/utils/useTimeout';\nimport { EMPTY_OBJECT } from \"../../utils/constants.js\";\nimport { isClickLikeEvent, isMouseLikePointerType, isTypeableElement } from \"../utils.js\";\nimport { createChangeEventDetails } from \"../../utils/createBaseUIEventDetails.js\";\nimport { REASONS } from \"../../utils/reasons.js\";\n/**\n * Opens or closes the floating element when clicking the reference element.\n * @see https://floating-ui.com/docs/useClick\n */\nexport function useClick(context, props = {}) {\n  const store = 'rootStore' in context ? context.rootStore : context;\n  const dataRef = store.context.dataRef;\n  const {\n    enabled = true,\n    event: eventOption = 'click',\n    toggle = true,\n    ignoreMouse = false,\n    stickIfOpen = true,\n    touchOpenDelay = 0\n  } = props;\n  const pointerTypeRef = React.useRef(undefined);\n  const frame = useAnimationFrame();\n  const touchOpenTimeout = useTimeout();\n  const reference = React.useMemo(() => ({\n    onPointerDown(event) {\n      pointerTypeRef.current = event.pointerType;\n    },\n    onMouseDown(event) {\n      const pointerType = pointerTypeRef.current;\n      const nativeEvent = event.nativeEvent;\n      const open = store.select('open');\n\n      // Ignore all buttons except for the \"main\" button.\n      // https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/button\n      if (event.button !== 0 || eventOption === 'click' || isMouseLikePointerType(pointerType, true) && ignoreMouse) {\n        return;\n      }\n      const openEvent = dataRef.current.openEvent;\n      const openEventType = openEvent?.type;\n      const hasClickedOnInactiveTrigger = store.select('domReferenceElement') !== event.currentTarget;\n      const nextOpen = open && hasClickedOnInactiveTrigger || !(open && toggle && (openEvent && stickIfOpen ? openEventType === 'click' || openEventType === 'mousedown' : true));\n\n      // Animations sometimes won't run on a typeable element if using a rAF.\n      // Focus is always set on these elements. For touch, we may delay opening.\n      if (isTypeableElement(nativeEvent.target)) {\n        const details = createChangeEventDetails(REASONS.triggerPress, nativeEvent, nativeEvent.target);\n        if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {\n          touchOpenTimeout.start(touchOpenDelay, () => {\n            store.setOpen(true, details);\n          });\n        } else {\n          store.setOpen(nextOpen, details);\n        }\n        return;\n      }\n\n      // Capture the currentTarget before the rAF.\n      // as React sets it to null after the event handler completes.\n      const eventCurrentTarget = event.currentTarget;\n\n      // Wait until focus is set on the element. This is an alternative to\n      // `event.preventDefault()` to avoid :focus-visible from appearing when using a pointer.\n      frame.request(() => {\n        const details = createChangeEventDetails(REASONS.triggerPress, nativeEvent, eventCurrentTarget);\n        if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {\n          touchOpenTimeout.start(touchOpenDelay, () => {\n            store.setOpen(true, details);\n          });\n        } else {\n          store.setOpen(nextOpen, details);\n        }\n      });\n    },\n    onClick(event) {\n      if (eventOption === 'mousedown-only') {\n        return;\n      }\n      const pointerType = pointerTypeRef.current;\n      if (eventOption === 'mousedown' && pointerType) {\n        pointerTypeRef.current = undefined;\n        return;\n      }\n      if (isMouseLikePointerType(pointerType, true) && ignoreMouse) {\n        return;\n      }\n      const open = store.select('open');\n      const openEvent = dataRef.current.openEvent;\n      const hasClickedOnInactiveTrigger = store.select('domReferenceElement') !== event.currentTarget;\n      const nextOpen = open && hasClickedOnInactiveTrigger || !(open && toggle && (openEvent && stickIfOpen ? isClickLikeEvent(openEvent) : true));\n      const details = createChangeEventDetails(REASONS.triggerPress, event.nativeEvent, event.currentTarget);\n      if (nextOpen && pointerType === 'touch' && touchOpenDelay > 0) {\n        touchOpenTimeout.start(touchOpenDelay, () => {\n          store.setOpen(true, details);\n        });\n      } else {\n        store.setOpen(nextOpen, details);\n      }\n    },\n    onKeyDown() {\n      pointerTypeRef.current = undefined;\n    }\n  }), [dataRef, eventOption, ignoreMouse, store, stickIfOpen, toggle, frame, touchOpenTimeout, touchOpenDelay]);\n  return React.useMemo(() => enabled ? {\n    reference\n  } : EMPTY_OBJECT, [enabled, reference]);\n}"],"names":[],"mappings":";;;;;;;;;AAaO;AACL;AACA;AACA;AAAM;AACM;AACW;AACZ;AACK;AACA;AACG;AAEnB;AACA;AACA;AACA;AAAuC;AAEnC;AAA+B;AACjC;AAEE;AACA;AACA;AAIA;AACE;AAAA;AAEF;AACA;AACA;AACA;AAIA;AACE;AACA;AACE;AACE;AAA2B;AAC5B;AAED;AAA+B;AAEjC;AAAA;AAKF;AAIA;AACE;AACA;AACE;AACE;AAA2B;AAC5B;AAED;AAA+B;AACjC;AACD;AACH;AAEE;AACE;AAAA;AAEF;AACA;AACE;AACA;AAAA;AAEF;AACE;AAAA;AAEF;AACA;AACA;AACA;AACA;AACA;AACE;AACE;AAA2B;AAC5B;AAED;AAA+B;AACjC;AACF;AAEE;AAAyB;AAC3B;AAEF;AAAqC;AACnC;AAEJ;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/react/esm/floating-ui-react/hooks/useClientPoint.js

@@ -0,0 +1,168 @@
+import * as React from "react";
+import { getWindow } from "../../../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useStableCallback } from "../../../../utils/esm/useStableCallback.js";
+import { useIsoLayoutEffect } from "../../../../utils/esm/useIsoLayoutEffect.js";
+import { isMouseLikePointerType } from "../utils/event.js";
+import { getTarget, contains } from "../utils/element.js";
+function createVirtualElement(domElement, data) {
+  let offsetX = null;
+  let offsetY = null;
+  let isAutoUpdateEvent = false;
+  return {
+    contextElement: domElement || void 0,
+    getBoundingClientRect() {
+      const domRect = domElement?.getBoundingClientRect() || {
+        width: 0,
+        height: 0,
+        x: 0,
+        y: 0
+      };
+      const isXAxis = data.axis === "x" || data.axis === "both";
+      const isYAxis = data.axis === "y" || data.axis === "both";
+      const canTrackCursorOnAutoUpdate = ["mouseenter", "mousemove"].includes(data.dataRef.current.openEvent?.type || "") && data.pointerType !== "touch";
+      let width = domRect.width;
+      let height = domRect.height;
+      let x = domRect.x;
+      let y = domRect.y;
+      if (offsetX == null && data.x && isXAxis) {
+        offsetX = domRect.x - data.x;
+      }
+      if (offsetY == null && data.y && isYAxis) {
+        offsetY = domRect.y - data.y;
+      }
+      x -= offsetX || 0;
+      y -= offsetY || 0;
+      width = 0;
+      height = 0;
+      if (!isAutoUpdateEvent || canTrackCursorOnAutoUpdate) {
+        width = data.axis === "y" ? domRect.width : 0;
+        height = data.axis === "x" ? domRect.height : 0;
+        x = isXAxis && data.x != null ? data.x : x;
+        y = isYAxis && data.y != null ? data.y : y;
+      } else if (isAutoUpdateEvent && !canTrackCursorOnAutoUpdate) {
+        height = data.axis === "x" ? domRect.height : height;
+        width = data.axis === "y" ? domRect.width : width;
+      }
+      isAutoUpdateEvent = true;
+      return {
+        width,
+        height,
+        x,
+        y,
+        top: y,
+        right: x + width,
+        bottom: y + height,
+        left: x
+      };
+    }
+  };
+}
+function isMouseBasedEvent(event) {
+  return event != null && event.clientX != null;
+}
+function useClientPoint(context, props = {}) {
+  const store = "rootStore" in context ? context.rootStore : context;
+  const open = store.useState("open");
+  const floating = store.useState("floatingElement");
+  const domReference = store.useState("domReferenceElement");
+  const dataRef = store.context.dataRef;
+  const {
+    enabled = true,
+    axis = "both",
+    x = null,
+    y = null
+  } = props;
+  const initialRef = React.useRef(false);
+  const cleanupListenerRef = React.useRef(null);
+  const [pointerType, setPointerType] = React.useState();
+  const [reactive, setReactive] = React.useState([]);
+  const setReference = useStableCallback((newX, newY) => {
+    if (initialRef.current) {
+      return;
+    }
+    if (dataRef.current.openEvent && !isMouseBasedEvent(dataRef.current.openEvent)) {
+      return;
+    }
+    store.set("positionReference", createVirtualElement(domReference, {
+      x: newX,
+      y: newY,
+      axis,
+      dataRef,
+      pointerType
+    }));
+  });
+  const handleReferenceEnterOrMove = useStableCallback((event) => {
+    if (x != null || y != null) {
+      return;
+    }
+    if (!open) {
+      setReference(event.clientX, event.clientY);
+    } else if (!cleanupListenerRef.current) {
+      setReactive([]);
+    }
+  });
+  const openCheck = isMouseLikePointerType(pointerType) ? floating : open;
+  const addListener = React.useCallback(() => {
+    if (!openCheck || !enabled || x != null || y != null) {
+      return void 0;
+    }
+    const win = getWindow(floating);
+    function handleMouseMove(event) {
+      const target = getTarget(event);
+      if (!contains(floating, target)) {
+        setReference(event.clientX, event.clientY);
+      } else {
+        win.removeEventListener("mousemove", handleMouseMove);
+        cleanupListenerRef.current = null;
+      }
+    }
+    if (!dataRef.current.openEvent || isMouseBasedEvent(dataRef.current.openEvent)) {
+      win.addEventListener("mousemove", handleMouseMove);
+      const cleanup = () => {
+        win.removeEventListener("mousemove", handleMouseMove);
+        cleanupListenerRef.current = null;
+      };
+      cleanupListenerRef.current = cleanup;
+      return cleanup;
+    }
+    store.set("positionReference", domReference);
+    return void 0;
+  }, [openCheck, enabled, x, y, floating, dataRef, domReference, store, setReference]);
+  React.useEffect(() => {
+    return addListener();
+  }, [addListener, reactive]);
+  React.useEffect(() => {
+    if (enabled && !floating) {
+      initialRef.current = false;
+    }
+  }, [enabled, floating]);
+  React.useEffect(() => {
+    if (!enabled && open) {
+      initialRef.current = true;
+    }
+  }, [enabled, open]);
+  useIsoLayoutEffect(() => {
+    if (enabled && (x != null || y != null)) {
+      initialRef.current = false;
+      setReference(x, y);
+    }
+  }, [enabled, x, y, setReference]);
+  const reference = React.useMemo(() => {
+    function setPointerTypeRef(event) {
+      setPointerType(event.pointerType);
+    }
+    return {
+      onPointerDown: setPointerTypeRef,
+      onPointerEnter: setPointerTypeRef,
+      onMouseMove: handleReferenceEnterOrMove,
+      onMouseEnter: handleReferenceEnterOrMove
+    };
+  }, [handleReferenceEnterOrMove]);
+  return React.useMemo(() => enabled ? {
+    reference
+  } : {}, [enabled, reference]);
+}
+export {
+  useClientPoint
+};
+//# sourceMappingURL=useClientPoint.js.map