@monimesl/dot-renderer-react 0.1.0-alpha.8 → 0.1.0-alpha.9

package/dist/vendor/@base-ui/utils/useAnimationFrame.js

@@ -0,0 +1,87 @@
+"use client";
+import { useRefWithInit } from "./useRefWithInit.js";
+import { useOnMount } from "./useOnMount.js";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useAnimationFrame.mjs
+/** Unlike `setTimeout`, rAF doesn't guarantee a positive integer return value, so we can't have
+* a monomorphic `uint` type with `0` meaning empty.
+* See warning note at:
+* https://developer.mozilla.org/en-US/docs/Web/API/Window/requestAnimationFrame#return_value */
+const EMPTY = null;
+let LAST_RAF = globalThis.requestAnimationFrame;
+var Scheduler = class {
+	callbacks = [];
+	callbacksCount = 0;
+	nextId = 1;
+	startId = 1;
+	isScheduled = false;
+	tick = (timestamp) => {
+		this.isScheduled = false;
+		const currentCallbacks = this.callbacks;
+		const currentCallbacksCount = this.callbacksCount;
+		this.callbacks = [];
+		this.callbacksCount = 0;
+		this.startId = this.nextId;
+		if (currentCallbacksCount > 0) for (let i = 0; i < currentCallbacks.length; i += 1) currentCallbacks[i]?.(timestamp);
+	};
+	request(fn) {
+		const id = this.nextId;
+		this.nextId += 1;
+		this.callbacks.push(fn);
+		this.callbacksCount += 1;
+		const didRAFChange = process.env.NODE_ENV !== "production" && LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, true);
+		if (!this.isScheduled || didRAFChange) {
+			requestAnimationFrame(this.tick);
+			this.isScheduled = true;
+		}
+		return id;
+	}
+	cancel(id) {
+		const index = id - this.startId;
+		if (index < 0 || index >= this.callbacks.length) return;
+		if (this.callbacks[index] === null) return;
+		this.callbacks[index] = null;
+		this.callbacksCount -= 1;
+	}
+};
+let scheduler = new Scheduler();
+var AnimationFrame = class AnimationFrame {
+	static create() {
+		return new AnimationFrame();
+	}
+	static request(fn) {
+		return scheduler.request(fn);
+	}
+	static cancel(id) {
+		return scheduler.cancel(id);
+	}
+	currentId = EMPTY;
+	/**
+	* Executes `fn` after `delay`, clearing any previously scheduled call.
+	*/
+	request(fn) {
+		this.cancel();
+		this.currentId = scheduler.request(() => {
+			this.currentId = EMPTY;
+			fn();
+		});
+	}
+	cancel = () => {
+		if (this.currentId !== EMPTY) {
+			scheduler.cancel(this.currentId);
+			this.currentId = EMPTY;
+		}
+	};
+	disposeEffect = () => {
+		return this.cancel;
+	};
+};
+/**
+* A `requestAnimationFrame` with automatic cleanup and guard.
+*/
+function useAnimationFrame() {
+	const timeout = useRefWithInit(AnimationFrame.create).current;
+	useOnMount(timeout.disposeEffect);
+	return timeout;
+}
+//#endregion
+export { AnimationFrame, useAnimationFrame };

package/dist/vendor/@base-ui/utils/useControlled.js

@@ -0,0 +1,52 @@
+"use client";
+import { error } from "./error.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useControlled.mjs
+function useControlled({ controlled, default: defaultProp, name, state = "value" }) {
+	const { current: isControlled } = React.useRef(controlled !== void 0);
+	const [valueState, setValue] = React.useState(defaultProp);
+	const value = isControlled && controlled !== void 0 ? controlled : valueState;
+	if (process.env.NODE_ENV !== "production") {
+		React.useEffect(() => {
+			if (isControlled !== (controlled !== void 0)) error([
+				`A component is changing the ${isControlled ? "" : "un"}controlled ${state} state of ${name} to be ${isControlled ? "un" : ""}controlled.`,
+				"Elements should not switch from uncontrolled to controlled (or vice versa).",
+				`Decide between using a controlled or uncontrolled ${name} element for the lifetime of the component.`,
+				"The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.",
+				"More info: https://fb.me/react-controlled-components"
+			].join("\n"));
+		}, [
+			state,
+			name,
+			controlled
+		]);
+		const { current: defaultValue } = React.useRef(defaultProp);
+		React.useEffect(() => {
+			if (!isControlled && serializeToDevModeString(defaultValue) !== serializeToDevModeString(defaultProp)) error([`A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`].join("\n"));
+		}, [defaultProp]);
+	}
+	return [value, React.useCallback((newValue) => {
+		if (!isControlled) setValue(newValue);
+	}, [])];
+}
+function serializeToDevModeString(input) {
+	let nextId = 0;
+	const seen = /* @__PURE__ */ new WeakMap();
+	try {
+		return JSON.stringify(input, function replacer(key, value) {
+			if (key === "_owner" && this != null && typeof this === "object" && "$$typeof" in this) return;
+			if (typeof value === "bigint") return `__bigint__:${value}`;
+			if (value !== null && typeof value === "object") {
+				const id = seen.get(value);
+				if (id !== void 0) return `__object__:${id}`;
+				seen.set(value, nextId);
+				nextId += 1;
+			}
+			return value;
+		}) ?? `__top__:${typeof input}`;
+	} catch {
+		return "__unserializable__";
+	}
+}
+//#endregion
+export { useControlled };

package/dist/vendor/@base-ui/utils/useId.js

@@ -0,0 +1,32 @@
+"use client";
+import { SafeReact } from "./safeReact.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useId.mjs
+let globalId = 0;
+function useGlobalId(idOverride, prefix = "mui") {
+	const [defaultId, setDefaultId] = React.useState(idOverride);
+	const id = idOverride || defaultId;
+	React.useEffect(() => {
+		if (defaultId == null) {
+			globalId += 1;
+			setDefaultId(`${prefix}-${globalId}`);
+		}
+	}, [defaultId, prefix]);
+	return id;
+}
+const maybeReactUseId = SafeReact.useId;
+/**
+*
+* @example <div id={useId()} />
+* @param idOverride
+* @returns {string}
+*/
+function useId$1(idOverride, prefix) {
+	if (maybeReactUseId !== void 0) {
+		const reactId = maybeReactUseId();
+		return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);
+	}
+	return useGlobalId(idOverride, prefix);
+}
+//#endregion
+export { useId$1 as useId };

package/dist/vendor/@base-ui/utils/useIsoLayoutEffect.js

@@ -0,0 +1,7 @@
+"use client";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useIsoLayoutEffect.mjs
+const noop = () => {};
+const useIsoLayoutEffect = typeof document !== "undefined" ? React.useLayoutEffect : noop;
+//#endregion
+export { useIsoLayoutEffect };

package/dist/vendor/@base-ui/utils/useMergedRefs.js

@@ -0,0 +1,87 @@
+import { useRefWithInit } from "./useRefWithInit.js";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useMergedRefs.mjs
+/**
+* Merges refs into a single memoized callback ref or `null`.
+* This makes sure multiple refs are updated together and have the same value.
+*
+* This function accepts up to four refs. If you need to merge more, or have an unspecified number of refs to merge,
+* use `useMergedRefsN` instead.
+*/
+function useMergedRefs(a, b, c, d) {
+	const forkRef = useRefWithInit(createForkRef).current;
+	if (didChange(forkRef, a, b, c, d)) update(forkRef, [
+		a,
+		b,
+		c,
+		d
+	]);
+	return forkRef.callback;
+}
+/**
+* Merges an array of refs into a single memoized callback ref or `null`.
+*
+* If you need to merge a fixed number (up to four) of refs, use `useMergedRefs` instead for better performance.
+*/
+function useMergedRefsN(refs) {
+	const forkRef = useRefWithInit(createForkRef).current;
+	if (didChangeN(forkRef, refs)) update(forkRef, refs);
+	return forkRef.callback;
+}
+function createForkRef() {
+	return {
+		callback: null,
+		cleanup: null,
+		refs: []
+	};
+}
+function didChange(forkRef, a, b, c, d) {
+	return forkRef.refs[0] !== a || forkRef.refs[1] !== b || forkRef.refs[2] !== c || forkRef.refs[3] !== d;
+}
+function didChangeN(forkRef, newRefs) {
+	return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index) => ref !== newRefs[index]);
+}
+function update(forkRef, refs) {
+	forkRef.refs = refs;
+	if (refs.every((ref) => ref == null)) {
+		forkRef.callback = null;
+		return;
+	}
+	forkRef.callback = (instance) => {
+		if (forkRef.cleanup) {
+			forkRef.cleanup();
+			forkRef.cleanup = null;
+		}
+		if (instance != null) {
+			const cleanupCallbacks = Array(refs.length).fill(null);
+			for (let i = 0; i < refs.length; i += 1) {
+				const ref = refs[i];
+				if (ref == null) continue;
+				switch (typeof ref) {
+					case "function": {
+						const refCleanup = ref(instance);
+						if (typeof refCleanup === "function") cleanupCallbacks[i] = refCleanup;
+						break;
+					}
+					case "object": ref.current = instance;
+				}
+			}
+			forkRef.cleanup = () => {
+				for (let i = 0; i < refs.length; i += 1) {
+					const ref = refs[i];
+					if (ref == null) continue;
+					switch (typeof ref) {
+						case "function": {
+							const cleanupCallback = cleanupCallbacks[i];
+							if (typeof cleanupCallback === "function") cleanupCallback();
+							else ref(null);
+							break;
+						}
+						case "object": ref.current = null;
+					}
+				}
+			};
+		}
+	};
+}
+//#endregion
+export { useMergedRefs, useMergedRefsN };

package/dist/vendor/@base-ui/utils/useOnMount.js

@@ -0,0 +1,12 @@
+"use client";
+import { EMPTY_ARRAY } from "./empty.js";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useOnMount.mjs
+/**
+* A React.useEffect equivalent that runs once, when the component is mounted.
+*/
+function useOnMount(fn) {
+	React.useEffect(fn, EMPTY_ARRAY);
+}
+//#endregion
+export { useOnMount };

package/dist/vendor/@base-ui/utils/useRefWithInit.js

@@ -0,0 +1,18 @@
+"use client";
+import * as React from "react";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useRefWithInit.mjs
+const UNINITIALIZED = {};
+/**
+* A React.useRef() that is initialized with a function. Note that it accepts an optional
+* initialization argument, so the initialization function doesn't need to be an inline closure.
+*
+* @usage
+*   const ref = useRefWithInit(sortColumns, columns)
+*/
+function useRefWithInit(init, initArg) {
+	const ref = React.useRef(UNINITIALIZED);
+	if (ref.current === UNINITIALIZED) ref.current = init(initArg);
+	return ref;
+}
+//#endregion
+export { useRefWithInit };

package/dist/vendor/@base-ui/utils/useScrollLock.js

@@ -0,0 +1,206 @@
+"use client";
+import { getWindow, isOverflowElement } from "../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useIsoLayoutEffect } from "./useIsoLayoutEffect.js";
+import { ownerDocument } from "./owner.js";
+import { Timeout } from "./useTimeout.js";
+import { ios } from "./platform/os.js";
+import { webkit } from "./platform/engine.js";
+import { addEventListener } from "./addEventListener.js";
+import { AnimationFrame } from "./useAnimationFrame.js";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useScrollLock.mjs
+let originalHtmlStyles = {};
+let originalBodyStyles = {};
+let originalHtmlScrollBehavior = "";
+function getViewportScroller(html, body) {
+	return isOverflowElement(html) ? html : body;
+}
+function isPageScrollLocked(win, html, body) {
+	return /hidden|clip/.test(win.getComputedStyle(getViewportScroller(html, body)).overflowY);
+}
+function hasInsetScrollbars(referenceElement) {
+	if (typeof document === "undefined") return false;
+	const doc = ownerDocument(referenceElement);
+	return getWindow(doc).innerWidth - doc.documentElement.clientWidth > 0;
+}
+function supportsStableScrollbarGutter(referenceElement) {
+	if (!(typeof CSS !== "undefined" && CSS.supports && CSS.supports("scrollbar-gutter", "stable")) || typeof document === "undefined") return false;
+	const doc = ownerDocument(referenceElement);
+	const html = doc.documentElement;
+	const body = doc.body;
+	const scrollContainer = getViewportScroller(html, body);
+	const originalScrollContainerOverflowY = scrollContainer.style.overflowY;
+	const originalHtmlStyleGutter = html.style.scrollbarGutter;
+	html.style.scrollbarGutter = "stable";
+	scrollContainer.style.overflowY = "scroll";
+	const before = scrollContainer.offsetWidth;
+	scrollContainer.style.overflowY = "hidden";
+	const after = scrollContainer.offsetWidth;
+	scrollContainer.style.overflowY = originalScrollContainerOverflowY;
+	html.style.scrollbarGutter = originalHtmlStyleGutter;
+	return before === after;
+}
+function preventScrollOverlayScrollbars(referenceElement) {
+	const doc = ownerDocument(referenceElement);
+	const html = doc.documentElement;
+	const body = doc.body;
+	const elementToLock = getViewportScroller(html, body);
+	const originalElementToLockStyles = {
+		overflowY: elementToLock.style.overflowY,
+		overflowX: elementToLock.style.overflowX
+	};
+	Object.assign(elementToLock.style, {
+		overflowY: "hidden",
+		overflowX: "hidden"
+	});
+	return () => {
+		Object.assign(elementToLock.style, originalElementToLockStyles);
+	};
+}
+function preventScrollInsetScrollbars(referenceElement) {
+	const doc = ownerDocument(referenceElement);
+	const html = doc.documentElement;
+	const body = doc.body;
+	const win = getWindow(html);
+	let scrollTop = 0;
+	let scrollLeft = 0;
+	let updateGutterOnly = false;
+	const resizeFrame = AnimationFrame.create();
+	if (webkit && (win.visualViewport?.scale ?? 1) !== 1) return () => {};
+	function lockScroll() {
+		const htmlStyles = win.getComputedStyle(html);
+		const bodyStyles = win.getComputedStyle(body);
+		const scrollbarGutterValue = (htmlStyles.scrollbarGutter || "").includes("both-edges") ? "stable both-edges" : "stable";
+		scrollTop = html.scrollTop;
+		scrollLeft = html.scrollLeft;
+		originalHtmlStyles = {
+			scrollbarGutter: html.style.scrollbarGutter,
+			overflowY: html.style.overflowY,
+			overflowX: html.style.overflowX
+		};
+		originalHtmlScrollBehavior = html.style.scrollBehavior;
+		originalBodyStyles = {
+			position: body.style.position,
+			height: body.style.height,
+			width: body.style.width,
+			boxSizing: body.style.boxSizing,
+			overflowY: body.style.overflowY,
+			overflowX: body.style.overflowX,
+			scrollBehavior: body.style.scrollBehavior
+		};
+		const isScrollableY = html.scrollHeight > html.clientHeight;
+		const isScrollableX = html.scrollWidth > html.clientWidth;
+		const hasConstantOverflowY = htmlStyles.overflowY === "scroll" || bodyStyles.overflowY === "scroll";
+		const hasConstantOverflowX = htmlStyles.overflowX === "scroll" || bodyStyles.overflowX === "scroll";
+		const scrollbarWidth = Math.max(0, win.innerWidth - body.clientWidth);
+		const scrollbarHeight = Math.max(0, win.innerHeight - body.clientHeight);
+		const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
+		const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
+		const elementToLock = getViewportScroller(html, body);
+		updateGutterOnly = supportsStableScrollbarGutter(referenceElement);
+		if (updateGutterOnly) {
+			html.style.scrollbarGutter = scrollbarGutterValue;
+			elementToLock.style.overflowY = "hidden";
+			elementToLock.style.overflowX = "hidden";
+			return;
+		}
+		Object.assign(html.style, {
+			scrollbarGutter: scrollbarGutterValue,
+			overflowY: "hidden",
+			overflowX: "hidden"
+		});
+		if (isScrollableY || hasConstantOverflowY) html.style.overflowY = "scroll";
+		if (isScrollableX || hasConstantOverflowX) html.style.overflowX = "scroll";
+		Object.assign(body.style, {
+			position: "relative",
+			height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : "100dvh",
+			width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : "100vw",
+			boxSizing: "border-box",
+			overflowY: "hidden",
+			overflowX: "hidden",
+			scrollBehavior: "unset"
+		});
+		body.scrollTop = scrollTop;
+		body.scrollLeft = scrollLeft;
+		html.setAttribute("data-base-ui-scroll-locked", "");
+		html.style.scrollBehavior = "unset";
+	}
+	function cleanup() {
+		Object.assign(html.style, originalHtmlStyles);
+		Object.assign(body.style, originalBodyStyles);
+		if (!updateGutterOnly) {
+			html.scrollTop = scrollTop;
+			html.scrollLeft = scrollLeft;
+			html.removeAttribute("data-base-ui-scroll-locked");
+			html.style.scrollBehavior = originalHtmlScrollBehavior;
+		}
+	}
+	function handleResize() {
+		cleanup();
+		resizeFrame.request(lockScroll);
+	}
+	lockScroll();
+	const unsubscribeResize = addEventListener(win, "resize", handleResize);
+	return () => {
+		resizeFrame.cancel();
+		cleanup();
+		if (typeof win.removeEventListener === "function") unsubscribeResize();
+	};
+}
+var ScrollLocker = class {
+	lockCount = 0;
+	restore = null;
+	timeoutLock = Timeout.create();
+	timeoutUnlock = Timeout.create();
+	acquire(referenceElement) {
+		this.lockCount += 1;
+		if (this.lockCount === 1 && this.restore === null) this.timeoutLock.start(0, () => this.lock(referenceElement));
+		return this.release;
+	}
+	release = () => {
+		this.lockCount -= 1;
+		if (this.lockCount === 0 && this.restore) this.timeoutUnlock.start(0, this.unlock);
+	};
+	unlock = () => {
+		if (this.lockCount === 0 && this.restore) {
+			this.restore?.();
+			this.restore = null;
+		}
+	};
+	lock(referenceElement) {
+		if (this.lockCount === 0 || this.restore !== null) return;
+		const doc = ownerDocument(referenceElement);
+		const html = doc.documentElement;
+		const body = doc.body;
+		const win = getWindow(html);
+		if (isPageScrollLocked(win, html, body)) {
+			const observer = new win.MutationObserver(() => {
+				if (isPageScrollLocked(win, html, body)) return;
+				observer.disconnect();
+				this.restore = null;
+				this.lock(referenceElement);
+			});
+			const options = { attributes: true };
+			observer.observe(html, options);
+			observer.observe(body, options);
+			this.restore = () => observer.disconnect();
+			return;
+		}
+		const hasOverlayScrollbars = ios || !hasInsetScrollbars(referenceElement);
+		this.restore = hasOverlayScrollbars ? preventScrollOverlayScrollbars(referenceElement) : preventScrollInsetScrollbars(referenceElement);
+	}
+};
+const SCROLL_LOCKER = new ScrollLocker();
+/**
+* Locks the scroll of the document when enabled.
+*
+* @param enabled - Whether to enable the scroll lock.
+* @param referenceElement - Element to use as a reference for lock calculations.
+*/
+function useScrollLock(enabled = true, referenceElement = null) {
+	useIsoLayoutEffect(() => {
+		if (!enabled) return;
+		return SCROLL_LOCKER.acquire(referenceElement);
+	}, [enabled, referenceElement]);
+}
+//#endregion
+export { useScrollLock };

package/dist/vendor/@base-ui/utils/useStableCallback.js

@@ -0,0 +1,38 @@
+"use client";
+import { useRefWithInit } from "./useRefWithInit.js";
+import { SafeReact } from "./safeReact.js";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useStableCallback.mjs
+const useInsertionEffect = SafeReact.useInsertionEffect;
+const useSafeInsertionEffect = useInsertionEffect && useInsertionEffect !== SafeReact.useLayoutEffect ? useInsertionEffect : (fn) => fn();
+/**
+* Stabilizes the function passed so it's always the same between renders.
+*
+* The function becomes non-reactive to any values it captures.
+* It can safely be passed as a dependency of `React.useMemo` and `React.useEffect` without re-triggering them if its captured values change.
+*
+* The function must only be called inside effects and event handlers, never during render (which throws an error).
+*
+* This hook is a more permissive version of React 19.2's `React.useEffectEvent` in that it can be passed through contexts and called in event handler props, not just effects.
+*/
+function useStableCallback(callback) {
+	const stable = useRefWithInit(createStableCallback).current;
+	stable.next = callback;
+	useSafeInsertionEffect(stable.effect);
+	return stable.trampoline;
+}
+function createStableCallback() {
+	const stable = {
+		next: void 0,
+		callback: assertNotCalled,
+		trampoline: (...args) => stable.callback?.(...args),
+		effect: () => {
+			stable.callback = stable.next;
+		}
+	};
+	return stable;
+}
+function assertNotCalled() {
+	if (process.env.NODE_ENV !== "production") throw new Error("Base UI: Cannot call an event handler while rendering.");
+}
+//#endregion
+export { useStableCallback };

package/dist/vendor/@base-ui/utils/useTimeout.js

@@ -0,0 +1,43 @@
+"use client";
+import { useRefWithInit } from "./useRefWithInit.js";
+import { useOnMount } from "./useOnMount.js";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useTimeout.mjs
+const EMPTY = 0;
+var Timeout = class Timeout {
+	static create() {
+		return new Timeout();
+	}
+	currentId = EMPTY;
+	/**
+	* Executes `fn` after `delay`, clearing any previously scheduled call.
+	*/
+	start(delay, fn) {
+		this.clear();
+		this.currentId = setTimeout(() => {
+			this.currentId = EMPTY;
+			fn();
+		}, delay);
+	}
+	isStarted() {
+		return this.currentId !== EMPTY;
+	}
+	clear = () => {
+		if (this.currentId !== EMPTY) {
+			clearTimeout(this.currentId);
+			this.currentId = EMPTY;
+		}
+	};
+	disposeEffect = () => {
+		return this.clear;
+	};
+};
+/**
+* A `setTimeout` with automatic cleanup and guard.
+*/
+function useTimeout() {
+	const timeout = useRefWithInit(Timeout.create).current;
+	useOnMount(timeout.disposeEffect);
+	return timeout;
+}
+//#endregion
+export { Timeout, useTimeout };

package/dist/vendor/@base-ui/utils/useValueAsRef.js

@@ -0,0 +1,27 @@
+"use client";
+import { useRefWithInit } from "./useRefWithInit.js";
+import { useIsoLayoutEffect } from "./useIsoLayoutEffect.js";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/useValueAsRef.mjs
+/**
+* Untracks the provided value by turning it into a ref to remove its reactivity.
+*
+* Used to access the passed value inside `React.useEffect` without causing the effect to re-run when the value changes.
+*/
+function useValueAsRef(value) {
+	const latest = useRefWithInit(createLatestRef, value).current;
+	latest.next = value;
+	useIsoLayoutEffect(latest.effect);
+	return latest;
+}
+function createLatestRef(value) {
+	const latest = {
+		current: value,
+		next: value,
+		effect: () => {
+			latest.current = latest.next;
+		}
+	};
+	return latest;
+}
+//#endregion
+export { useValueAsRef };

package/dist/vendor/@base-ui/utils/visuallyHidden.js

@@ -0,0 +1,23 @@
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/visuallyHidden.mjs
+const visuallyHiddenBase = {
+	clipPath: "inset(50%)",
+	overflow: "hidden",
+	whiteSpace: "nowrap",
+	border: 0,
+	padding: 0,
+	width: 1,
+	height: 1,
+	margin: -1
+};
+const visuallyHidden = {
+	...visuallyHiddenBase,
+	position: "fixed",
+	top: 0,
+	left: 0
+};
+const visuallyHiddenInput = {
+	...visuallyHiddenBase,
+	position: "absolute"
+};
+//#endregion
+export { visuallyHidden, visuallyHiddenInput };

package/dist/vendor/@base-ui/utils/warn.js

@@ -0,0 +1,5 @@
+import { createLogOnce } from "./createLogOnce.js";
+//#region ../../../node_modules/.pnpm/@base-ui+utils@0.4.0_@types+react@19.3.0_react-dom@19.3.0_react@19.3.0__react@19.3.0/node_modules/@base-ui/utils/warn.mjs
+const warn = createLogOnce("warn", "Base UI");
+//#endregion
+export { warn };