@ariakit/react-core 0.0.1 → 0.1.0

package/cjs/__chunks/44UMDBZE.cjs

@@ -0,0 +1,354 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _UYIFJ7U3cjs = require('./UYIFJ7U3.cjs');
+
+
+
+
+var _5QY4WCTRcjs = require('./5QY4WCTR.cjs');
+
+// src/focusable/focusable.ts
+var _react = require('react');
+var _dom = require('@ariakit/core/utils/dom');
+
+
+
+
+
+
+var _events = require('@ariakit/core/utils/events');
+
+
+
+
+var _focus = require('@ariakit/core/utils/focus');
+var _platform = require('@ariakit/core/utils/platform');
+var isSafariBrowser = _platform.isSafari.call(void 0, );
+var alwaysFocusVisibleInputTypes = [
+  "text",
+  "search",
+  "url",
+  "tel",
+  "email",
+  "password",
+  "number",
+  "date",
+  "month",
+  "week",
+  "time",
+  "datetime",
+  "datetime-local"
+];
+function isAlwaysFocusVisible(element) {
+  const { tagName, readOnly, type } = element;
+  if (tagName === "TEXTAREA" && !readOnly)
+    return true;
+  if (tagName === "SELECT" && !readOnly)
+    return true;
+  if (tagName === "INPUT" && !readOnly) {
+    return alwaysFocusVisibleInputTypes.includes(type);
+  }
+  if (element.isContentEditable)
+    return true;
+  return false;
+}
+function isAlwaysFocusVisibleDelayed(element) {
+  const role = element.getAttribute("role");
+  if (role !== "combobox")
+    return false;
+  return !!element.dataset.name;
+}
+function getLabels(element) {
+  if ("labels" in element) {
+    return element.labels;
+  }
+  return null;
+}
+function isNativeCheckboxOrRadio(element) {
+  const tagName = element.tagName.toLowerCase();
+  if (tagName === "input" && element.type) {
+    return element.type === "radio" || element.type === "checkbox";
+  }
+  return false;
+}
+function isNativeTabbable(tagName) {
+  if (!tagName)
+    return true;
+  return tagName === "button" || tagName === "input" || tagName === "select" || tagName === "textarea" || tagName === "a";
+}
+function supportsDisabledAttribute(tagName) {
+  if (!tagName)
+    return true;
+  return tagName === "button" || tagName === "input" || tagName === "select" || tagName === "textarea";
+}
+function getTabIndex(focusable, trulyDisabled, nativeTabbable, supportsDisabled, tabIndexProp) {
+  if (!focusable) {
+    return tabIndexProp;
+  }
+  if (trulyDisabled) {
+    if (nativeTabbable && !supportsDisabled) {
+      return -1;
+    }
+    return;
+  }
+  if (nativeTabbable) {
+    return tabIndexProp;
+  }
+  return tabIndexProp || 0;
+}
+function useDisableEvent(onEvent, disabled) {
+  return _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+    _optionalChain([onEvent, 'optionalCall', _ => _(event)]);
+    if (event.defaultPrevented)
+      return;
+    if (disabled) {
+      event.stopPropagation();
+      event.preventDefault();
+    }
+  });
+}
+var isKeyboardModality = true;
+function onGlobalMouseDown(event) {
+  const target = event.target;
+  if (target && "hasAttribute" in target) {
+    if (!target.hasAttribute("data-focus-visible")) {
+      isKeyboardModality = false;
+    }
+  }
+}
+function onGlobalKeyDown(event) {
+  if (event.metaKey)
+    return;
+  if (event.ctrlKey)
+    return;
+  isKeyboardModality = true;
+}
+var useFocusable = _UYIFJ7U3cjs.createHook.call(void 0, 
+  ({
+    focusable = true,
+    accessibleWhenDisabled,
+    autoFocus,
+    onFocusVisible,
+    ...props
+  }) => {
+    const ref = _react.useRef.call(void 0, null);
+    _react.useEffect.call(void 0, () => {
+      if (!focusable)
+        return;
+      _events.addGlobalEventListener.call(void 0, "mousedown", onGlobalMouseDown, true);
+      _events.addGlobalEventListener.call(void 0, "keydown", onGlobalKeyDown, true);
+    }, [focusable]);
+    if (isSafariBrowser) {
+      _react.useEffect.call(void 0, () => {
+        if (!focusable)
+          return;
+        const element = ref.current;
+        if (!element)
+          return;
+        if (!isNativeCheckboxOrRadio(element))
+          return;
+        const labels = getLabels(element);
+        if (!labels)
+          return;
+        const onMouseUp = () => queueMicrotask(() => element.focus());
+        labels.forEach((label) => label.addEventListener("mouseup", onMouseUp));
+        return () => {
+          labels.forEach(
+            (label) => label.removeEventListener("mouseup", onMouseUp)
+          );
+        };
+      }, [focusable]);
+    }
+    const disabled = focusable && props.disabled;
+    const trulyDisabled = !!disabled && !accessibleWhenDisabled;
+    const [focusVisible, setFocusVisible] = _react.useState.call(void 0, false);
+    _react.useEffect.call(void 0, () => {
+      if (!focusable)
+        return;
+      if (trulyDisabled && focusVisible) {
+        setFocusVisible(false);
+      }
+    }, [focusable, trulyDisabled, focusVisible]);
+    _react.useEffect.call(void 0, () => {
+      if (!focusable)
+        return;
+      if (!focusVisible)
+        return;
+      const element = ref.current;
+      if (!element)
+        return;
+      if (typeof IntersectionObserver === "undefined")
+        return;
+      const observer = new IntersectionObserver(() => {
+        if (!_focus.isFocusable.call(void 0, element)) {
+          setFocusVisible(false);
+        }
+      });
+      observer.observe(element);
+      return () => observer.disconnect();
+    }, [focusable, focusVisible]);
+    const onKeyPressCapture = useDisableEvent(
+      props.onKeyPressCapture,
+      disabled
+    );
+    const onMouseDownCapture = useDisableEvent(
+      props.onMouseDownCapture,
+      disabled
+    );
+    const onClickCapture = useDisableEvent(props.onClickCapture, disabled);
+    const onMouseDownProp = props.onMouseDown;
+    const onMouseDown = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+      _optionalChain([onMouseDownProp, 'optionalCall', _2 => _2(event)]);
+      if (event.defaultPrevented)
+        return;
+      if (!focusable)
+        return;
+      const element = event.currentTarget;
+      if (!isSafariBrowser)
+        return;
+      if (_events.isPortalEvent.call(void 0, event))
+        return;
+      if (!_dom.isButton.call(void 0, element) && !isNativeCheckboxOrRadio(element))
+        return;
+      let receivedFocus = false;
+      const onFocus = () => {
+        receivedFocus = true;
+      };
+      const options = { capture: true, once: true };
+      document.body.addEventListener("focusin", onFocus, options);
+      _events.queueBeforeEvent.call(void 0, element, "mouseup", () => {
+        element.removeEventListener("focusin", onFocus, true);
+        if (receivedFocus)
+          return;
+        _focus.focusIfNeeded.call(void 0, element);
+      });
+    });
+    const handleFocusVisible = (event, currentTarget) => {
+      if (currentTarget) {
+        event.currentTarget = currentTarget;
+      }
+      _optionalChain([onFocusVisible, 'optionalCall', _3 => _3(event)]);
+      if (event.defaultPrevented)
+        return;
+      if (!focusable)
+        return;
+      const element = event.currentTarget;
+      if (!element)
+        return;
+      if (!_focus.hasFocus.call(void 0, element))
+        return;
+      setFocusVisible(true);
+    };
+    const onKeyDownCaptureProp = props.onKeyDownCapture;
+    const onKeyDownCapture = _5QY4WCTRcjs.useEvent.call(void 0, 
+      (event) => {
+        _optionalChain([onKeyDownCaptureProp, 'optionalCall', _4 => _4(event)]);
+        if (event.defaultPrevented)
+          return;
+        if (!focusable)
+          return;
+        if (focusVisible)
+          return;
+        if (event.metaKey)
+          return;
+        if (event.altKey)
+          return;
+        if (event.ctrlKey)
+          return;
+        if (!_events.isSelfTarget.call(void 0, event))
+          return;
+        const element = event.currentTarget;
+        queueMicrotask(() => handleFocusVisible(event, element));
+      }
+    );
+    const onFocusCaptureProp = props.onFocusCapture;
+    const onFocusCapture = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+      _optionalChain([onFocusCaptureProp, 'optionalCall', _5 => _5(event)]);
+      if (event.defaultPrevented)
+        return;
+      if (!focusable)
+        return;
+      if (!_events.isSelfTarget.call(void 0, event)) {
+        setFocusVisible(false);
+        return;
+      }
+      const element = event.currentTarget;
+      const applyFocusVisible = () => handleFocusVisible(event, element);
+      if (isKeyboardModality || isAlwaysFocusVisible(event.target)) {
+        queueMicrotask(applyFocusVisible);
+      } else if (isAlwaysFocusVisibleDelayed(event.target)) {
+        _events.queueBeforeEvent.call(void 0, event.target, "focusout", applyFocusVisible);
+      } else {
+        setFocusVisible(false);
+      }
+    });
+    const onBlurProp = props.onBlur;
+    const onBlur = _5QY4WCTRcjs.useEvent.call(void 0, (event) => {
+      _optionalChain([onBlurProp, 'optionalCall', _6 => _6(event)]);
+      if (!focusable)
+        return;
+      if (_events.isFocusEventOutside.call(void 0, event)) {
+        setFocusVisible(false);
+      }
+    });
+    const autoFocusRef = _5QY4WCTRcjs.useEvent.call(void 0, (element) => {
+      if (!focusable)
+        return;
+      if (!autoFocus)
+        return;
+      if (!element)
+        return;
+      queueMicrotask(() => {
+        if (_focus.hasFocus.call(void 0, element))
+          return;
+        if (!_focus.isFocusable.call(void 0, element))
+          return;
+        element.focus();
+      });
+    });
+    const tagName = _5QY4WCTRcjs.useTagName.call(void 0, ref, props.as);
+    const nativeTabbable = focusable && isNativeTabbable(tagName);
+    const supportsDisabled = focusable && supportsDisabledAttribute(tagName);
+    const style = trulyDisabled ? { pointerEvents: "none", ...props.style } : props.style;
+    props = {
+      "data-focus-visible": focusable && focusVisible ? "" : void 0,
+      "data-autofocus": autoFocus ? true : void 0,
+      "aria-disabled": disabled ? true : void 0,
+      ...props,
+      ref: _5QY4WCTRcjs.useForkRef.call(void 0, ref, autoFocusRef, props.ref),
+      style,
+      tabIndex: getTabIndex(
+        focusable,
+        trulyDisabled,
+        nativeTabbable,
+        supportsDisabled,
+        props.tabIndex
+      ),
+      disabled: supportsDisabled && trulyDisabled ? true : void 0,
+      // TODO: Test Focusable contentEditable.
+      contentEditable: disabled ? void 0 : props.contentEditable,
+      onKeyPressCapture,
+      onClickCapture,
+      onMouseDownCapture,
+      onMouseDown,
+      onKeyDownCapture,
+      onFocusCapture,
+      onBlur
+    };
+    return props;
+  }
+);
+var Focusable = _UYIFJ7U3cjs.createComponent.call(void 0, (props) => {
+  props = useFocusable(props);
+  return _UYIFJ7U3cjs.createElement.call(void 0, "div", props);
+});
+if (process.env.NODE_ENV !== "production") {
+  Focusable.displayName = "Focusable";
+}
+
+
+
+
+exports.useFocusable = useFocusable; exports.Focusable = Focusable;

package/cjs/__chunks/4K6QJIPX.cjs

@@ -0,0 +1,6 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/popover/popover-arrow-path.ts
+var POPOVER_ARROW_PATH = "M23,27.8c1.1,1.2,3.4,2.2,5,2.2h2H0h2c1.7,0,3.9-1,5-2.2l6.6-7.2c0.7-0.8,2-0.8,2.7,0L23,27.8L23,27.8z";
+
+
+
+exports.POPOVER_ARROW_PATH = POPOVER_ARROW_PATH;

package/cjs/__chunks/56QOFCPO.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/toolbar/toolbar-context.ts
+var _react = require('react');
+var ToolbarContext = _react.createContext.call(void 0, 
+  void 0
+);
+
+
+
+exports.ToolbarContext = ToolbarContext;

package/cjs/__chunks/5EIZ4QQ7.cjs

@@ -0,0 +1,29 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/dialog/utils/prepend-hidden-dismiss.ts
+var _dom = require('@ariakit/core/utils/dom');
+function prependHiddenDismiss(container, onClick) {
+  const document = _dom.getDocument.call(void 0, container);
+  const button = document.createElement("button");
+  button.type = "button";
+  button.tabIndex = -1;
+  button.textContent = "Dismiss popup";
+  button.style.border = "0px";
+  button.style.clip = "rect(0 0 0 0)";
+  button.style.height = "1px";
+  button.style.margin = "-1px";
+  button.style.overflow = "hidden";
+  button.style.padding = "0px";
+  button.style.position = "absolute";
+  button.style.whiteSpace = "nowrap";
+  button.style.width = "1px";
+  button.addEventListener("click", onClick);
+  container.prepend(button);
+  const removeHiddenDismiss = () => {
+    button.removeEventListener("click", onClick);
+    button.remove();
+  };
+  return removeHiddenDismiss;
+}
+
+
+
+exports.prependHiddenDismiss = prependHiddenDismiss;

package/cjs/__chunks/5LMWS5O4.cjs

@@ -0,0 +1,27 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+
+var _F6IOE5QTcjs = require('./F6IOE5QT.cjs');
+
+// src/collection/collection-store.ts
+var _collectionstore = require('@ariakit/core/collection/collection-store'); var Core = _interopRequireWildcard(_collectionstore);
+function useCollectionStoreOptions(_props) {
+  return {};
+}
+function useCollectionStoreProps(store, props) {
+  _F6IOE5QTcjs.useStoreProps.call(void 0, store, props, "items", "setItems");
+  return store;
+}
+function useCollectionStore(props = {}) {
+  const options = useCollectionStoreOptions(props);
+  const store = _F6IOE5QTcjs.useStore.call(void 0, 
+    () => Core.createCollectionStore({ ...props, ...options })
+  );
+  return useCollectionStoreProps(store, props);
+}
+
+
+
+
+
+exports.useCollectionStoreOptions = useCollectionStoreOptions; exports.useCollectionStoreProps = useCollectionStoreProps; exports.useCollectionStore = useCollectionStore;

package/cjs/__chunks/5QY4WCTR.cjs

@@ -0,0 +1,259 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _2X5K3J7Ycjs = require('./2X5K3J7Y.cjs');
+
+// src/utils/hooks.ts
+
+
+
+
+
+
+
+
+var _react = require('react'); var React = _interopRequireWildcard(_react);
+
+var _dom = require('@ariakit/core/utils/dom');
+var _events = require('@ariakit/core/utils/events');
+var _misc = require('@ariakit/core/utils/misc');
+var _React = { ...React };
+var useReactId = _React.useId;
+var useReactDeferredValue = _React.useDeferredValue;
+var useReactInsertionEffect = _React.useInsertionEffect;
+var useSafeLayoutEffect = _dom.canUseDOM ? _react.useLayoutEffect : _react.useEffect;
+function useInitialValue(value) {
+  const [initialValue] = _react.useState.call(void 0, value);
+  return initialValue;
+}
+function useLazyValue(init) {
+  const ref = _react.useRef.call(void 0, );
+  if (ref.current === void 0) {
+    ref.current = init();
+  }
+  return ref.current;
+}
+function useLiveRef(value) {
+  const ref = _react.useRef.call(void 0, value);
+  useSafeLayoutEffect(() => {
+    ref.current = value;
+  });
+  return ref;
+}
+function usePreviousValue(value) {
+  const [previousValue, setPreviousValue] = _react.useState.call(void 0, value);
+  if (value !== previousValue) {
+    setPreviousValue(value);
+  }
+  return previousValue;
+}
+function useEvent(callback) {
+  const ref = _react.useRef.call(void 0, () => {
+    throw new Error("Cannot call an event handler while rendering.");
+  });
+  if (useReactInsertionEffect) {
+    useReactInsertionEffect(() => {
+      ref.current = callback;
+    });
+  } else {
+    ref.current = callback;
+  }
+  return _react.useCallback.call(void 0, (...args) => _optionalChain([ref, 'access', _ => _.current, 'optionalCall', _2 => _2(...args)]), []);
+}
+function useForkRef(...refs) {
+  return _react.useMemo.call(void 0, () => {
+    if (!refs.some(Boolean))
+      return;
+    return (value) => {
+      refs.forEach((ref) => {
+        _2X5K3J7Ycjs.setRef.call(void 0, ref, value);
+      });
+    };
+  }, refs);
+}
+function useRefId(ref, deps) {
+  const [id, setId] = _react.useState.call(void 0, void 0);
+  useSafeLayoutEffect(() => {
+    setId(_optionalChain([ref, 'optionalAccess', _3 => _3.current, 'optionalAccess', _4 => _4.id]));
+  }, deps);
+  return id;
+}
+function useId(defaultId) {
+  if (useReactId) {
+    const reactId = useReactId();
+    if (defaultId)
+      return defaultId;
+    return reactId;
+  }
+  const [id, setId] = _react.useState.call(void 0, defaultId);
+  useSafeLayoutEffect(() => {
+    if (defaultId || id)
+      return;
+    const random = Math.random().toString(36).substr(2, 6);
+    setId(`id-${random}`);
+  }, [defaultId, id]);
+  return defaultId || id;
+}
+function useDeferredValue(value) {
+  if (useReactDeferredValue) {
+    return useReactDeferredValue(value);
+  }
+  const [deferredValue, setDeferredValue] = _react.useState.call(void 0, value);
+  _react.useEffect.call(void 0, () => {
+    const raf = requestAnimationFrame(() => setDeferredValue(value));
+    return () => cancelAnimationFrame(raf);
+  }, [value]);
+  return deferredValue;
+}
+function useTagName(refOrElement, type) {
+  const stringOrUndefined = (type2) => {
+    if (typeof type2 !== "string")
+      return;
+    return type2;
+  };
+  const [tagName, setTagName] = _react.useState.call(void 0, () => stringOrUndefined(type));
+  useSafeLayoutEffect(() => {
+    const element = refOrElement && "current" in refOrElement ? refOrElement.current : refOrElement;
+    setTagName(_optionalChain([element, 'optionalAccess', _5 => _5.tagName, 'access', _6 => _6.toLowerCase, 'call', _7 => _7()]) || stringOrUndefined(type));
+  }, [refOrElement, type]);
+  return tagName;
+}
+function useUpdateEffect(effect, deps) {
+  const mounted = _react.useRef.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    if (mounted.current) {
+      return effect();
+    }
+    mounted.current = true;
+  }, deps);
+  _react.useEffect.call(void 0, 
+    () => () => {
+      mounted.current = false;
+    },
+    []
+  );
+}
+function useUpdateLayoutEffect(effect, deps) {
+  const mounted = _react.useRef.call(void 0, false);
+  useSafeLayoutEffect(() => {
+    if (mounted.current) {
+      return effect();
+    }
+    mounted.current = true;
+  }, deps);
+  useSafeLayoutEffect(
+    () => () => {
+      mounted.current = false;
+    },
+    []
+  );
+}
+function useControlledState(defaultState, state, setState) {
+  const [localState, setLocalState] = _react.useState.call(void 0, defaultState);
+  const nextState = state !== void 0 ? state : localState;
+  const stateRef = useLiveRef(state);
+  const setStateRef = useLiveRef(setState);
+  const nextStateRef = useLiveRef(nextState);
+  const setNextState = _react.useCallback.call(void 0, (prevValue) => {
+    const setStateProp = setStateRef.current;
+    if (setStateProp) {
+      if (isSetNextState(setStateProp)) {
+        setStateProp(prevValue);
+      } else {
+        const nextValue = _misc.applyState.call(void 0, prevValue, nextStateRef.current);
+        nextStateRef.current = nextValue;
+        setStateProp(nextValue);
+      }
+    }
+    if (stateRef.current === void 0) {
+      setLocalState(prevValue);
+    }
+  }, []);
+  defineSetNextState(setNextState);
+  return [nextState, setNextState];
+}
+var SET_NEXT_STATE = Symbol("setNextState");
+function isSetNextState(arg) {
+  return arg[SET_NEXT_STATE] === true;
+}
+function defineSetNextState(arg) {
+  if (!isSetNextState(arg)) {
+    Object.defineProperty(arg, SET_NEXT_STATE, { value: true });
+  }
+}
+function useForceUpdate() {
+  return _react.useReducer.call(void 0, () => [], []);
+}
+function useBooleanEvent(booleanOrCallback) {
+  return useEvent(
+    typeof booleanOrCallback === "function" ? booleanOrCallback : () => booleanOrCallback
+  );
+}
+function useWrapElement(props, callback, deps = []) {
+  const wrapElement = _react.useCallback.call(void 0, 
+    (element) => {
+      if (props.wrapElement) {
+        element = props.wrapElement(element);
+      }
+      return callback(element);
+    },
+    [...deps, props.wrapElement]
+  );
+  return { ...props, wrapElement };
+}
+function usePortalRef(portalProp = false, portalRefProp) {
+  const [portalNode, setPortalNode] = _react.useState.call(void 0, null);
+  const portalRef = useForkRef(setPortalNode, portalRefProp);
+  const domReady = !portalProp || portalNode;
+  return { portalRef, portalNode, domReady };
+}
+function useIsMouseMoving() {
+  _react.useEffect.call(void 0, () => {
+    _events.addGlobalEventListener.call(void 0, "mousemove", setMouseMoving, true);
+    _events.addGlobalEventListener.call(void 0, "mousedown", resetMouseMoving, true);
+    _events.addGlobalEventListener.call(void 0, "mouseup", resetMouseMoving, true);
+    _events.addGlobalEventListener.call(void 0, "keydown", resetMouseMoving, true);
+    _events.addGlobalEventListener.call(void 0, "scroll", resetMouseMoving, true);
+  }, []);
+  const isMouseMoving = useEvent(() => mouseMoving);
+  return isMouseMoving;
+}
+var mouseMoving = false;
+var previousScreenX = 0;
+var previousScreenY = 0;
+function hasMouseMovement(event) {
+  const movementX = event.movementX || event.screenX - previousScreenX;
+  const movementY = event.movementY || event.screenY - previousScreenY;
+  previousScreenX = event.screenX;
+  previousScreenY = event.screenY;
+  return movementX || movementY || process.env.NODE_ENV === "test";
+}
+function setMouseMoving(event) {
+  if (!hasMouseMovement(event))
+    return;
+  mouseMoving = true;
+}
+function resetMouseMoving() {
+  mouseMoving = false;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.useSafeLayoutEffect = useSafeLayoutEffect; exports.useInitialValue = useInitialValue; exports.useLazyValue = useLazyValue; exports.useLiveRef = useLiveRef; exports.usePreviousValue = usePreviousValue; exports.useEvent = useEvent; exports.useForkRef = useForkRef; exports.useRefId = useRefId; exports.useId = useId; exports.useDeferredValue = useDeferredValue; exports.useTagName = useTagName; exports.useUpdateEffect = useUpdateEffect; exports.useUpdateLayoutEffect = useUpdateLayoutEffect; exports.useControlledState = useControlledState; exports.useForceUpdate = useForceUpdate; exports.useBooleanEvent = useBooleanEvent; exports.useWrapElement = useWrapElement; exports.usePortalRef = usePortalRef; exports.useIsMouseMoving = useIsMouseMoving;