yummies 7.11.0 → 7.12.0

package/react.cjs

@@ -1,219 +1,677 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const react = require("react");
-const attachRefs = (value, ...refs) => refs.forEach((ref) => {
-  if (typeof ref === "function") {
-    ref(value);
-  } else if (ref && typeof ref !== "string") {
-    ref.current = value;
-  }
+require("./chunk-CVq3Gv4J.cjs");
+let react = require("react");
+//#region src/react/attach-refs.ts
+/**
+* Assigns the same value to multiple React refs, including callback refs.
+*
+* @template T Referenced value type.
+* @param value Value that should be written into every provided ref.
+* @param refs Target refs to update.
+*
+* @example
+* ```ts
+* attachRefs(node, localRef, forwardedRef);
+* ```
+*
+* @example
+* ```ts
+* attachRefs(null, inputRef, (value) => console.log(value));
+* ```
+*/
+var attachRefs = (value, ...refs) => refs.forEach((ref) => {
+	if (typeof ref === "function") ref(value);
+	else if (ref && typeof ref !== "string") ref.current = value;
 });
-const useConstant = (defineValue) => {
-  const ref = react.useRef();
-  if (!ref.current) {
-    ref.current = { value: defineValue() };
-  }
-  return ref.current.value;
-};
-const useAbortController = () => {
-  const controller = useConstant(() => new AbortController());
-  react.useEffect(() => {
-    return () => {
-      controller.abort();
-    };
-  }, []);
-  return controller;
-};
-const useAbortSignal = () => {
-  return useAbortController().signal;
-};
-const useSyncRef = (value) => {
-  const ref = react.useRef(value);
-  ref.current = value;
-  return ref;
-};
-const useEventListener = ({
-  event,
-  handler,
-  options,
-  deps = [],
-  debounce,
-  node = document
-}) => {
-  const handlerRef = useSyncRef(handler);
-  react.useEffect(() => {
-    let timerId;
-    const handleEvent = (e) => {
-      if (debounce == null) {
-        handlerRef.current(e);
-      } else {
-        clearTimeout(timerId);
-        timerId = setTimeout(() => {
-          handlerRef.current(e);
-          timerId = void 0;
-        }, debounce);
-      }
-    };
-    node.addEventListener(event, handleEvent, options);
-    return () => {
-      node.removeEventListener(event, handleEvent, options);
-      clearTimeout(timerId);
-    };
-  }, deps);
-};
-const useClickOutside = ({
-  contentRef,
-  onClick,
-  options
-}) => {
-  useEventListener({
-    event: "mousedown",
-    handler: (event) => {
-      if (contentRef.current && !contentRef.current.contains(event.target)) {
-        onClick();
-      }
-    },
-    options
-  });
-};
-const useDefineRef = (defineFn) => {
-  const ref = react.useRef(void 0);
-  if (!ref.current) {
-    ref.current = defineFn();
-  }
-  return ref;
-};
-const useElementRef = (selector) => {
-  const ref = react.useRef();
-  react.useLayoutEffect(() => {
-    ref.current = selector();
-  }, []);
-  return ref;
-};
-const useEvent = (handler) => {
-  const handlerRef = react.useRef(handler);
-  react.useLayoutEffect(() => {
-    handlerRef.current = handler;
-  });
-  return react.useCallback((...args) => {
-    const fn = handlerRef.current;
-    return fn(...args);
-  }, []);
-};
-const useFlag = (defaultValue = false) => {
-  const [enabled, setEnabled] = react.useState(defaultValue);
-  const toggle = react.useCallback(() => setEnabled((value) => !value), []);
-  const enable = react.useCallback(() => setEnabled(true), []);
-  const disable = react.useCallback(() => setEnabled(false), []);
-  const flagObjRef = react.useRef({
-    enabled,
-    toggle,
-    enable,
-    disable
-  });
-  flagObjRef.current.enabled = enabled;
-  return flagObjRef.current;
-};
-const useForceUpdate = () => {
-  const [, setState] = react.useState(null);
-  return react.useCallback(() => {
-    setState({});
-  }, []);
-};
-const useInitialHeight = () => {
-  const ref = react.useRef(null);
-  const [initialHeight, setInitialHeight] = react.useState(
-    void 0
-  );
-  react.useEffect(() => {
-    if (ref.current && !initialHeight) {
-      setInitialHeight(ref.current.offsetHeight);
-    }
-  }, [initialHeight]);
-  return { ref, initialHeight };
-};
-const createUseInstanceHook = (extension) => (factory, config) => {
-  const abortSignal = useAbortSignal();
-  const instance = useConstant(
-    () => factory({
-      ...extension,
-      abortSignal,
-      payload: config?.payload
-    })
-  );
-  react.useLayoutEffect(() => {
-    config?.onUpdate?.(config.payload);
-  }, [config?.payload]);
-  return instance;
-};
-const useInstance = createUseInstanceHook();
-const useIntersectionObserver = (callback, options) => {
-  const [intersectionObserver] = react.useState(
-    () => new IntersectionObserver(callback, options)
-  );
-  react.useEffect(() => {
-    return () => {
-      intersectionObserver.disconnect();
-    };
-  }, []);
-  return intersectionObserver;
-};
-const useLastDefinedValue = (value) => {
-  const ref = react.useRef(value);
-  if (value != null) {
-    ref.current = value;
-  }
-  return ref.current;
-};
-const useLastValueRef = (value) => {
-  const ref = react.useRef(value);
-  if (value != null) {
-    ref.current = value;
-  }
-  return ref;
-};
-const useLifeCycle = (fn) => {
-  const fnRef = useSyncRef(fn);
-  react.useEffect(() => {
-    const fnOperation = fnRef.current();
-    fnOperation.mount?.();
-    return fnOperation.unmount?.();
-  }, []);
-};
-const useResizeObserver = (callback) => {
-  const resizeObserverRef = useDefineRef(() => new ResizeObserver(callback));
-  react.useLayoutEffect(() => {
-    return () => {
-      resizeObserverRef.current.disconnect();
-    };
-  }, []);
-  return resizeObserverRef;
-};
-const useToggle = (initialState) => {
-  const [toggled, setToggled] = react.useState(!!initialState);
-  const toggle = react.useCallback(() => setToggled((toggled2) => !toggled2), []);
-  return [toggled, toggle, setToggled];
-};
-const useValue = (defaults) => {
-  const [value, setValue] = react.useState(defaults);
-  return {
-    value,
-    set: setValue
-  };
-};
-const useVisibilityState = () => {
-  const [state, setState] = react.useState();
-  react.useEffect(() => {
-    const handleVisibilityChange = () => {
-      setState(document.visibilityState);
-    };
-    document.addEventListener("visibilitychange", handleVisibilityChange);
-    return () => {
-      document.removeEventListener("visibilitychange", handleVisibilityChange);
-    };
-  }, []);
-  return state;
+//#endregion
+//#region src/react/hooks/use-constant.ts
+/**
+* React hook for creating a value exactly once.
+*
+* Unlike `useMemo`, this guarantees that the initializer is executed only once
+* for the component lifetime.
+*
+* @template T Value type.
+* @param defineValue Function that lazily creates the value.
+* @returns Stable value created on the first render.
+*
+* @example
+* ```ts
+* const id = useConstant(() => crypto.randomUUID());
+* ```
+*
+* @example
+* ```ts
+* const formatter = useConstant(() => new Intl.NumberFormat('en-US'));
+* ```
+*/
+var useConstant = (defineValue) => {
+	const ref = (0, react.useRef)();
+	if (!ref.current) ref.current = { value: defineValue() };
+	return ref.current.value;
 };
+//#endregion
+//#region src/react/hooks/use-abort-controller.ts
+/**
+* Creates a single `AbortController` instance for the component lifetime.
+*
+* The controller is aborted automatically during unmount.
+*
+* @returns Stable abort controller instance.
+*
+* @example
+* ```ts
+* const controller = useAbortController();
+* fetch('/api', { signal: controller.signal });
+* ```
+*
+* @example
+* ```ts
+* const controller = useAbortController();
+* controller.abort();
+* ```
+*/
+var useAbortController = () => {
+	const controller = useConstant(() => new AbortController());
+	(0, react.useEffect)(() => {
+		return () => {
+			controller.abort();
+		};
+	}, []);
+	return controller;
+};
+//#endregion
+//#region src/react/hooks/use-abort-signal.ts
+/**
+* Returns an `AbortSignal` tied to the component lifecycle.
+*
+* The signal is aborted automatically on unmount.
+*
+* @returns Lifecycle-bound abort signal.
+*
+* @example
+* ```ts
+* const signal = useAbortSignal();
+* fetch('/api/users', { signal });
+* ```
+*
+* @example
+* ```ts
+* const signal = useAbortSignal();
+* someAsyncTask({ signal });
+* ```
+*/
+var useAbortSignal = () => {
+	return useAbortController().signal;
+};
+//#endregion
+//#region src/react/hooks/use-sync-ref.ts
+/**
+* Returns a ref whose `current` value is synchronized with the latest input
+* on every render.
+*
+* @template T Value type.
+* @param value Current value to expose through the ref.
+* @returns Ref containing the latest value.
+*
+* @example
+* ```ts
+* const latestHandler = useSyncRef(onSubmit);
+* latestHandler.current();
+* ```
+*
+* @example
+* ```ts
+* const latestValue = useSyncRef(props.value);
+* latestValue.current;
+* ```
+*/
+var useSyncRef = (value) => {
+	const ref = (0, react.useRef)(value);
+	ref.current = value;
+	return ref;
+};
+//#endregion
+//#region src/react/hooks/use-event-listener.ts
+/**
+* Subscribes to a DOM event and keeps the latest handler without resubscribing
+* on every render.
+*
+* Supports optional debounce and custom effect dependencies.
+*
+* @template EventName DOM event name from `HTMLElementEventMap`.
+* @param config Event subscription configuration.
+*
+* @example
+* ```ts
+* useEventListener({
+*   event: 'click',
+*   handler: () => console.log('clicked'),
+* });
+* ```
+*
+* @example
+* ```ts
+* useEventListener({
+*   event: 'scroll',
+*   node: window,
+*   debounce: 100,
+*   handler: () => console.log('scroll'),
+* });
+* ```
+*/
+var useEventListener = ({ event, handler, options, deps = [], debounce, node = document }) => {
+	const handlerRef = useSyncRef(handler);
+	(0, react.useEffect)(() => {
+		let timerId;
+		const handleEvent = (e) => {
+			if (debounce == null) handlerRef.current(e);
+			else {
+				clearTimeout(timerId);
+				timerId = setTimeout(() => {
+					handlerRef.current(e);
+					timerId = void 0;
+				}, debounce);
+			}
+		};
+		node.addEventListener(event, handleEvent, options);
+		return () => {
+			node.removeEventListener(event, handleEvent, options);
+			clearTimeout(timerId);
+		};
+	}, deps);
+};
+//#endregion
+//#region src/react/hooks/use-click-outside.ts
+/**
+* Calls a handler when a pointer interaction happens outside the referenced element.
+*
+* @param input Target element ref, callback and event listener options.
+*
+* @example
+* ```ts
+* useClickOutside({
+*   contentRef: modalRef,
+*   onClick: () => closeModal(),
+* });
+* ```
+*
+* @example
+* ```ts
+* useClickOutside({
+*   contentRef: dropdownRef,
+*   onClick: hideDropdown,
+*   options: { capture: true },
+* });
+* ```
+*/
+var useClickOutside = ({ contentRef, onClick, options }) => {
+	useEventListener({
+		event: "mousedown",
+		handler: (event) => {
+			if (contentRef.current && !contentRef.current.contains(event.target)) onClick();
+		},
+		options
+	});
+};
+//#endregion
+//#region src/react/hooks/use-define-ref.ts
+/**
+* Creates a mutable ref whose value is initialized exactly once.
+*
+* @template T Ref value type.
+* @param defineFn Function that lazily creates the initial ref value.
+* @returns Mutable ref with a stable initialized value.
+*
+* @example
+* ```ts
+* const cacheRef = useDefineRef(() => new Map());
+* ```
+*
+* @example
+* ```ts
+* const observerRef = useDefineRef(() => new ResizeObserver(() => {}));
+* ```
+*/
+var useDefineRef = (defineFn) => {
+	const ref = (0, react.useRef)(void 0);
+	if (!ref.current) ref.current = defineFn();
+	return ref;
+};
+//#endregion
+//#region src/react/hooks/use-element-ref.ts
+/**
+* Resolves an element once after mount and stores it in a ref.
+*
+* @template T Element type.
+* @param selector Function returning the target element.
+* @returns Ref containing the selected element.
+*
+* @example
+* ```ts
+* const buttonRef = useElementRef(() => document.getElementById('save') as HTMLButtonElement);
+* ```
+*
+* @example
+* ```ts
+* const modalRef = useElementRef(() => document.querySelector('.modal') as HTMLDivElement);
+* ```
+*/
+var useElementRef = (selector) => {
+	const ref = (0, react.useRef)();
+	(0, react.useLayoutEffect)(() => {
+		ref.current = selector();
+	}, []);
+	return ref;
+};
+//#endregion
+//#region src/react/hooks/use-event.ts
+/**
+* Creates an event callback with a stable function identity and up-to-date logic.
+*
+* Borrowed from the `useEvent` RFC idea by React contributors.
+*
+* @template H Handler function type.
+* @param handler Latest callback implementation.
+* @returns Stable callback that always delegates to the latest handler.
+*
+* @example
+* ```ts
+* const onClick = useEvent(() => {
+*   console.log('clicked');
+* });
+* ```
+*
+* @example
+* ```ts
+* const onSubmit = useEvent((value: string) => save(value));
+* ```
+*/
+var useEvent = (handler) => {
+	const handlerRef = (0, react.useRef)(handler);
+	(0, react.useLayoutEffect)(() => {
+		handlerRef.current = handler;
+	});
+	return (0, react.useCallback)((...args) => {
+		const fn = handlerRef.current;
+		return fn(...args);
+	}, []);
+};
+//#endregion
+//#region src/react/hooks/use-flag.ts
+/**
+* Manages a reusable boolean flag object with stable helper methods.
+*
+* @param defaultValue Initial enabled state.
+* @returns Stable object exposing current state and mutators.
+*
+* @example
+* ```ts
+* const modal = useFlag();
+* modal.enable();
+* ```
+*
+* @example
+* ```ts
+* const loading = useFlag(true);
+* loading.disable();
+* ```
+*/
+var useFlag = (defaultValue = false) => {
+	const [enabled, setEnabled] = (0, react.useState)(defaultValue);
+	const flagObjRef = (0, react.useRef)({
+		enabled,
+		toggle: (0, react.useCallback)(() => setEnabled((value) => !value), []),
+		enable: (0, react.useCallback)(() => setEnabled(true), []),
+		disable: (0, react.useCallback)(() => setEnabled(false), [])
+	});
+	flagObjRef.current.enabled = enabled;
+	return flagObjRef.current;
+};
+//#endregion
+//#region src/react/hooks/use-force-update.ts
+/**
+* Forces a component re-render by updating an internal dummy state.
+*
+* @returns Stable callback that triggers a re-render.
+*
+* @example
+* ```ts
+* const forceUpdate = useForceUpdate();
+* forceUpdate();
+* ```
+*
+* @example
+* ```ts
+* const rerender = useForceUpdate();
+* setTimeout(rerender, 1000);
+* ```
+*/
+var useForceUpdate = () => {
+	const [, setState] = (0, react.useState)(null);
+	return (0, react.useCallback)(() => {
+		setState({});
+	}, []);
+};
+//#endregion
+//#region src/react/hooks/use-initial-height.ts
+/**
+* Captures an element's height the first time its ref becomes available.
+*
+* @template T Element type attached to the returned ref.
+* @returns Ref and the initial measured height.
+*
+* @example
+* ```ts
+* const { ref, initialHeight } = useInitialHeight<HTMLDivElement>();
+* ```
+*
+* @example
+* ```ts
+* const state = useInitialHeight<HTMLTextAreaElement>();
+* state.initialHeight;
+* ```
+*/
+var useInitialHeight = () => {
+	const ref = (0, react.useRef)(null);
+	const [initialHeight, setInitialHeight] = (0, react.useState)(void 0);
+	(0, react.useEffect)(() => {
+		if (ref.current && !initialHeight) setInitialHeight(ref.current.offsetHeight);
+	}, [initialHeight]);
+	return {
+		ref,
+		initialHeight
+	};
+};
+//#endregion
+//#region src/react/hooks/use-instance.ts
+/**
+* Builds a custom hook that creates an instance once and wires lifecycle helpers
+* such as an `AbortSignal` and optional extension data into the factory.
+*
+* @template TExtension Extra configuration injected into every factory call.
+* @param extension Optional static extension object merged into the factory config.
+* @returns Hook factory that creates stable instances from a supplied factory.
+*
+* @example
+* ```ts
+* const useStoreInstance = createUseInstanceHook({ api });
+* ```
+*
+* @example
+* ```ts
+* const useService = createUseInstanceHook({ logger });
+* const service = useService(({ logger, payload }) => new Service(logger, payload));
+* ```
+*/
+var createUseInstanceHook = (extension) => (factory, config) => {
+	const abortSignal = useAbortSignal();
+	const instance = useConstant(() => factory({
+		...extension,
+		abortSignal,
+		payload: config?.payload
+	}));
+	(0, react.useLayoutEffect)(() => {
+		config?.onUpdate?.(config.payload);
+	}, [config?.payload]);
+	return instance;
+};
+/**
+* The `useInstance` hook is used to create and manage an instance of an object
+* that requires access to the root store and an abort signal.
+*
+* You can create YOUR OWN CUSTOM `useInstance` hook using `createUseInstanceHook` if you need
+* to provide some specific data
+*
+* @param factory - A factory function that takes a configuration and returns an instance.
+* @param config - An optional configuration containing additional input parameters and an update function.
+* @returns An instance created by the factory function.
+*
+* @example
+* ```ts
+* const service = useInstance(({ abortSignal }) => new UsersService({ abortSignal }));
+* ```
+*
+* @example
+* ```ts
+* const store = useInstance(
+*   ({ payload }) => new UserStore(payload),
+*   { payload: userId, onUpdate: (nextId) => console.log(nextId) },
+* );
+* ```
+*/
+var useInstance = createUseInstanceHook();
+//#endregion
+//#region src/react/hooks/use-intersection-observer.ts
+/**
+* Creates a single `IntersectionObserver` instance and disposes it on unmount.
+*
+* @param callback Observer callback invoked for intersection changes.
+* @param options Optional observer configuration.
+* @returns Stable `IntersectionObserver` instance.
+*
+* @example
+* ```ts
+* const observer = useIntersectionObserver((entries) => {
+*   console.log(entries[0]?.isIntersecting);
+* });
+* ```
+*
+* @example
+* ```ts
+* const observer = useIntersectionObserver(handleIntersect, { threshold: 0.5 });
+* observer.observe(element);
+* ```
+*/
+var useIntersectionObserver = (callback, options) => {
+	const [intersectionObserver] = (0, react.useState)(() => new IntersectionObserver(callback, options));
+	(0, react.useEffect)(() => {
+		return () => {
+			intersectionObserver.disconnect();
+		};
+	}, []);
+	return intersectionObserver;
+};
+//#endregion
+//#region src/react/hooks/use-last-defined-value.ts
+/**
+* Remembers and returns the last non-nullish value passed to the hook.
+*
+* @template T Value type.
+* @param value Current value that may be `null` or `undefined`.
+* @returns Current value when defined, otherwise the previous defined value.
+*
+* @example
+* ```ts
+* const title = useLastDefinedValue(props.title);
+* ```
+*
+* @example
+* ```ts
+* const user = useLastDefinedValue<User | null>(selectedUser);
+* ```
+*/
+var useLastDefinedValue = (value) => {
+	const ref = (0, react.useRef)(value);
+	if (value != null) ref.current = value;
+	return ref.current;
+};
+//#endregion
+//#region src/react/hooks/use-last-value-ref.ts
+/**
+* Returns a ref that always points to the last non-nullish value.
+*
+* @template T Value type.
+* @param value Current value that may temporarily become `null` or `undefined`.
+* @returns Ref containing the last defined value.
+*
+* @example
+* ```ts
+* const latestUserRef = useLastValueRef(user);
+* latestUserRef.current;
+* ```
+*
+* @example
+* ```ts
+* const latestNodeRef = useLastValueRef<HTMLDivElement | null>(node);
+* ```
+*/
+var useLastValueRef = (value) => {
+	const ref = (0, react.useRef)(value);
+	if (value != null) ref.current = value;
+	return ref;
+};
+//#endregion
+//#region src/react/hooks/use-life-cycle.ts
+/**
+* Runs mount and unmount callbacks returned by a factory function.
+*
+* The latest factory is stored in a ref, while the effect itself is only
+* subscribed once.
+*
+* @param fn Factory returning optional `mount` and `unmount` handlers.
+*
+* @example
+* ```ts
+* useLifeCycle(() => ({
+*   mount: () => console.log('mounted'),
+*   unmount: () => console.log('unmounted'),
+* }));
+* ```
+*
+* @example
+* ```ts
+* useLifeCycle(() => ({
+*   mount: subscribe,
+*   unmount: unsubscribe,
+* }));
+* ```
+*/
+var useLifeCycle = (fn) => {
+	const fnRef = useSyncRef(fn);
+	(0, react.useEffect)(() => {
+		const fnOperation = fnRef.current();
+		fnOperation.mount?.();
+		return fnOperation.unmount?.();
+	}, []);
+};
+//#endregion
+//#region src/react/hooks/use-resize-observer.ts
+/**
+* Creates a stable `ResizeObserver` instance and disconnects it on unmount.
+*
+* @param callback Resize observer callback.
+* @returns Ref containing the observer instance.
+*
+* @example
+* ```ts
+* const observerRef = useResizeObserver((entries) => {
+*   console.log(entries[0]?.contentRect.width);
+* });
+* ```
+*
+* @example
+* ```ts
+* const resizeObserver = useResizeObserver(handleResize);
+* resizeObserver.current.observe(element);
+* ```
+*/
+var useResizeObserver = (callback) => {
+	const resizeObserverRef = useDefineRef(() => new ResizeObserver(callback));
+	(0, react.useLayoutEffect)(() => {
+		return () => {
+			resizeObserverRef.current.disconnect();
+		};
+	}, []);
+	return resizeObserverRef;
+};
+//#endregion
+//#region src/react/hooks/use-toggle.ts
+/**
+* Manages a boolean state and returns helpers to toggle or set it directly.
+*
+* @param initialState Initial boolean value.
+* @returns Tuple with current state, toggle callback and raw setter.
+*
+* @example
+* ```ts
+* const [open, toggleOpen] = useToggle();
+* toggleOpen();
+* ```
+*
+* @example
+* ```ts
+* const [enabled, , setEnabled] = useToggle(true);
+* setEnabled(false);
+* ```
+*/
+var useToggle = (initialState) => {
+	const [toggled, setToggled] = (0, react.useState)(!!initialState);
+	return [
+		toggled,
+		(0, react.useCallback)(() => setToggled((toggled) => !toggled), []),
+		setToggled
+	];
+};
+//#endregion
+//#region src/react/hooks/use-value.ts
+/**
+* Wraps `useState` and returns the state value as an object with a `set` method.
+*
+* @template T State value type.
+* @param defaults Initial state value or lazy initializer.
+* @returns Object containing the current value and setter.
+*
+* @example
+* ```ts
+* const counter = useValue(0);
+* counter.set(1);
+* ```
+*
+* @example
+* ```ts
+* const user = useValue(() => ({ name: 'Ann' }));
+* user.value.name;
+* ```
+*/
+var useValue = (defaults) => {
+	const [value, setValue] = (0, react.useState)(defaults);
+	return {
+		value,
+		set: setValue
+	};
+};
+//#endregion
+//#region src/react/hooks/use-visibility-state.ts
+/**
+* Tracks `document.visibilityState` and updates when the page visibility changes.
+*
+* @returns Current document visibility state.
+*
+* @example
+* ```ts
+* const visibility = useVisibilityState();
+* ```
+*
+* @example
+* ```ts
+* const isHidden = useVisibilityState() === 'hidden';
+* ```
+*/
+var useVisibilityState = () => {
+	const [state, setState] = (0, react.useState)();
+	(0, react.useEffect)(() => {
+		const handleVisibilityChange = () => {
+			setState(document.visibilityState);
+		};
+		document.addEventListener("visibilitychange", handleVisibilityChange);
+		return () => {
+			document.removeEventListener("visibilitychange", handleVisibilityChange);
+		};
+	}, []);
+	return state;
+};
+//#endregion
 exports.attachRefs = attachRefs;
 exports.createUseInstanceHook = createUseInstanceHook;
 exports.useAbortController = useAbortController;
@@ -237,4 +695,5 @@ exports.useSyncRef = useSyncRef;
 exports.useToggle = useToggle;
 exports.useValue = useValue;
 exports.useVisibilityState = useVisibilityState;
-//# sourceMappingURL=react.cjs.map
+
+//# sourceMappingURL=react.cjs.map