import * as React from "react"; /** * One callback ref that keeps an incoming ref and a local ref on the same node. * * A React 19 callback ref may return a cleanup function; when the incoming ref * does, React runs that cleanup instead of calling the callback again with * `null`, so the local ref must be cleared inside the cleanup too. */export const composedRefCallback =  <T>(outer: React.Ref<T> | undefined, local: React.RefObject<T | null>): React.RefCallback<T> =>  (node) => {    local.current = node;    if (typeof outer === "function") {      const cleanup = outer(node);      if (typeof cleanup === "function") {        return () => {          local.current = null;          cleanup();        };      }      return undefined;    }    if (outer) outer.current = node;    return undefined;  }; /** `composedRefCallback`, kept stable across renders for stable inputs so the *  incoming ref is not detached and reattached on every render. */export const useComposedRef = <T>(  outer: React.Ref<T> | undefined,  local: React.RefObject<T | null>,): React.RefCallback<T> => React.useMemo(() => composedRefCallback(outer, local), [outer, local]);