@aussieljk/forkbook 0.0.0-stage → 0.0.1-2

package/dist/manager/_manager-chunks/globals-runtime-BmphMP6z.js

@@ -0,0 +1,1190 @@
+import { a as __toESM, n as __esmMin } from "./globals-runtime-BdGkqNEt.js";
+import { c as require_shim, s as require_with_selector } from "./globals-runtime-eLPTIfX-.js";
+import { j as require_react } from "./globals-runtime-ZHrQFa3-.js";
+import { L as getInstance, R as init_fastHooks, X as addEventListener, at as NOOP, it as EMPTY_ARRAY, ot as init_empty, rt as ownerDocument, z as register } from "./globals-runtime-C02fvgcd.js";
+import { L as isOverflowElement, M as init_floating_ui_utils_dom, N as isElement, R as isShadowRoot, j as getWindow } from "./globals-runtime-BIKBO23x.js";
+//#region ../../node_modules/@base-ui/utils/safeReact.mjs
+var import_react$10, SafeReact;
+function init_safeReact() {
+	return (init_safeReact = __esmMin((() => {
+		import_react$10 = /* @__PURE__ */ __toESM(require_react(), 1);
+		SafeReact = { ...import_react$10 };
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useRefWithInit.mjs
+/**
+* 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 = import_react$9.useRef(UNINITIALIZED);
+	if (ref.current === UNINITIALIZED) ref.current = init(initArg);
+	return ref;
+}
+var import_react$9, UNINITIALIZED;
+function init_useRefWithInit() {
+	return (init_useRefWithInit = __esmMin((() => {
+		import_react$9 = /* @__PURE__ */ __toESM(require_react(), 1);
+		UNINITIALIZED = {};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useStableCallback.mjs
+/**
+* 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() {}
+var useInsertionEffect, useSafeInsertionEffect;
+function init_useStableCallback() {
+	return (init_useStableCallback = __esmMin((() => {
+		init_safeReact();
+		init_useRefWithInit();
+		useInsertionEffect = SafeReact.useInsertionEffect;
+		useSafeInsertionEffect = useInsertionEffect && useInsertionEffect !== SafeReact.useLayoutEffect ? useInsertionEffect : (fn) => fn();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useOnMount.mjs
+/**
+* A React.useEffect equivalent that runs once, when the component is mounted.
+*/
+function useOnMount(fn) {
+	import_react$8.useEffect(fn, EMPTY_ARRAY);
+}
+var import_react$8;
+function init_useOnMount() {
+	return (init_useOnMount = __esmMin((() => {
+		import_react$8 = /* @__PURE__ */ __toESM(require_react(), 1);
+		init_empty();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useTimeout.mjs
+/**
+* A `setTimeout` with automatic cleanup and guard.
+*/
+function useTimeout() {
+	const timeout = useRefWithInit(Timeout.create).current;
+	useOnMount(timeout.disposeEffect);
+	return timeout;
+}
+var EMPTY$1, Timeout;
+function init_useTimeout() {
+	return (init_useTimeout = __esmMin((() => {
+		init_useRefWithInit();
+		init_useOnMount();
+		EMPTY$1 = 0;
+		Timeout = class Timeout {
+			static create() {
+				return new Timeout();
+			}
+			currentId = EMPTY$1;
+			/**
+			* Executes `fn` after `delay`, clearing any previously scheduled call.
+			*/
+			start(delay, fn) {
+				this.clear();
+				this.currentId = setTimeout(() => {
+					this.currentId = EMPTY$1;
+					fn();
+				}, delay);
+			}
+			isStarted() {
+				return this.currentId !== EMPTY$1;
+			}
+			clear = () => {
+				if (this.currentId !== EMPTY$1) {
+					clearTimeout(this.currentId);
+					this.currentId = EMPTY$1;
+				}
+			};
+			disposeEffect = () => {
+				return this.clear;
+			};
+		};
+	})))();
+}
+//#endregion
+//#region ../../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;
+					}
+				}
+			};
+		}
+	};
+}
+function init_useMergedRefs() {
+	return (init_useMergedRefs = __esmMin((() => {
+		init_useRefWithInit();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/reactVersion.mjs
+function isReactVersionAtLeast(reactVersionToCheck) {
+	return majorVersion >= reactVersionToCheck;
+}
+var majorVersion;
+function init_reactVersion() {
+	return (init_reactVersion = __esmMin((() => {
+		require_react();
+		majorVersion = parseInt("18.3.1", 10);
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useForcedRerendering.mjs
+/**
+* Returns a function that forces a rerender.
+*/
+function useForcedRerendering() {
+	const [, setState] = import_react$6.useState({});
+	return import_react$6.useCallback(() => {
+		setState({});
+	}, []);
+}
+var import_react$6;
+function init_useForcedRerendering() {
+	return (init_useForcedRerendering = __esmMin((() => {
+		import_react$6 = /* @__PURE__ */ __toESM(require_react(), 1);
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useId.mjs
+function useGlobalId(idOverride, prefix = "mui") {
+	const defaultId = import_react$5.useRef(void 0);
+	const forceRerender = useForcedRerendering();
+	const id = idOverride ?? defaultId.current;
+	import_react$5.useEffect(() => {
+		if (defaultId.current == null) {
+			globalId += 1;
+			defaultId.current = `${prefix}-${globalId}`;
+			if (idOverride == null) forceRerender();
+		}
+	}, [
+		idOverride,
+		prefix,
+		forceRerender
+	]);
+	return id;
+}
+/**
+*
+* @example <div id={useId()} />
+* @param {string | undefined} idOverride overrides the generated id when provided
+* @param {string | undefined} prefix prefixes the generated id when provided
+* @returns {string | undefined}
+*/
+function useId(idOverride, prefix) {
+	if (maybeReactUseId !== void 0) {
+		const reactId = maybeReactUseId();
+		return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);
+	}
+	return useGlobalId(idOverride, prefix);
+}
+var import_react$5, globalId, maybeReactUseId;
+function init_useId() {
+	return (init_useId = __esmMin((() => {
+		import_react$5 = /* @__PURE__ */ __toESM(require_react(), 1);
+		init_safeReact();
+		init_useForcedRerendering();
+		globalId = 0;
+		maybeReactUseId = SafeReact.useId;
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/platform/shared.mjs
+/**
+* Reads `navigator.userAgent` / `navigator.platform` (legacy but universally
+* supported) into a normalized shape. In development, prefers the modern
+* `navigator.userAgentData` API on Chromium to avoid DevTools warnings about
+* the deprecated reads; that branch is dead-code-eliminated in production
+* builds to keep the bundle small.
+*
+* Returns empty/zero values when `navigator` is undefined (SSR), so every
+* derived flag safely evaluates to `false`.
+*/
+function readRawData() {
+	if (typeof navigator === "undefined") return {
+		userAgent: "",
+		platform: "",
+		maxTouchPoints: 0
+	};
+	return {
+		userAgent: navigator.userAgent,
+		platform: navigator.platform ?? "",
+		maxTouchPoints: navigator.maxTouchPoints ?? 0
+	};
+}
+var userAgent, platform, maxTouchPoints, lowerUserAgent, lowerPlatform;
+function init_shared() {
+	return (init_shared = __esmMin((() => {
+		({userAgent, platform, maxTouchPoints} = readRawData());
+		lowerUserAgent = userAgent.toLowerCase();
+		lowerPlatform = platform.toLowerCase();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/platform/os.mjs
+var ios, ANDROID_STRING, android, mac, apple;
+function init_os() {
+	return (init_os = __esmMin((() => {
+		init_shared();
+		ios = /^i(os$|p)/.test(lowerPlatform) || lowerPlatform === "macintel" && maxTouchPoints > 1;
+		ANDROID_STRING = "android";
+		android = lowerPlatform === ANDROID_STRING || lowerUserAgent.includes(ANDROID_STRING);
+		mac = !ios && lowerPlatform.startsWith("mac");
+		lowerPlatform.startsWith("win");
+		!android && /^(linux|chrome os)/.test(lowerPlatform);
+		apple = mac || ios;
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/platform/engine.mjs
+var webkit;
+function init_engine() {
+	return (init_engine = __esmMin((() => {
+		init_shared();
+		webkit = typeof CSS !== "undefined" && !!CSS.supports?.("-webkit-backdrop-filter:none");
+		!webkit && lowerUserAgent.includes("firefox");
+		!webkit && lowerUserAgent.includes("chrom");
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/platform/screen-reader.mjs
+var voiceOver;
+function init_screen_reader() {
+	return (init_screen_reader = __esmMin((() => {
+		init_os();
+		voiceOver = apple;
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/platform/env.mjs
+var jsdom;
+function init_env() {
+	return (init_env = __esmMin((() => {
+		init_shared();
+		jsdom = /jsdom|happydom/.test(lowerUserAgent);
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/shadowDom.mjs
+function activeElement(doc) {
+	let element = doc.activeElement;
+	while (element?.shadowRoot?.activeElement != null) element = element.shadowRoot.activeElement;
+	return element;
+}
+function contains(parent, child) {
+	if (!parent || !child) return false;
+	const rootNode = child.getRootNode?.();
+	if (parent.contains(child)) return true;
+	if (rootNode && isShadowRoot(rootNode)) {
+		let next = child;
+		while (next) {
+			if (parent === next) return true;
+			next = next.parentNode || next.host;
+		}
+	}
+	return false;
+}
+/**
+* Finds the closest matching element in the composed tree, crossing slots and shadow roots.
+* `:scope` is not supported.
+*/
+function closest(node, selector) {
+	let current = node;
+	while (current) {
+		if (isElement(current) && current.matches(selector)) return current;
+		current = current.assignedSlot ?? current.parentNode ?? (isShadowRoot(current) ? current.host : null);
+	}
+	return null;
+}
+function getTarget(event) {
+	if ("composedPath" in event) return event.composedPath()[0] ?? event.target;
+	return event.target;
+}
+function init_shadowDom() {
+	return (init_shadowDom = __esmMin((() => {
+		init_floating_ui_utils_dom();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useIsoLayoutEffect.mjs
+var import_react$4, noop, useIsoLayoutEffect;
+function init_useIsoLayoutEffect() {
+	return (init_useIsoLayoutEffect = __esmMin((() => {
+		import_react$4 = /* @__PURE__ */ __toESM(require_react(), 1);
+		noop = () => {};
+		useIsoLayoutEffect = typeof document !== "undefined" ? import_react$4.useLayoutEffect : noop;
+	})))();
+}
+//#endregion
+//#region ../../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;
+}
+function init_useValueAsRef() {
+	return (init_useValueAsRef = __esmMin((() => {
+		init_useIsoLayoutEffect();
+		init_useRefWithInit();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useAnimationFrame.mjs
+/**
+* A `requestAnimationFrame` with automatic cleanup and guard.
+*/
+function useAnimationFrame() {
+	const timeout = useRefWithInit(AnimationFrame.create).current;
+	useOnMount(timeout.disposeEffect);
+	return timeout;
+}
+var EMPTY, Scheduler, scheduler, AnimationFrame;
+function init_useAnimationFrame() {
+	return (init_useAnimationFrame = __esmMin((() => {
+		init_useRefWithInit();
+		init_useOnMount();
+		EMPTY = null;
+		globalThis.requestAnimationFrame;
+		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;
+				if (!this.isScheduled || false) {
+					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;
+			}
+		};
+		scheduler = new Scheduler();
+		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;
+			};
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/visuallyHidden.mjs
+var visuallyHiddenBase, visuallyHidden;
+function init_visuallyHidden() {
+	return (init_visuallyHidden = __esmMin((() => {
+		visuallyHiddenBase = {
+			clipPath: "inset(50%)",
+			overflow: "hidden",
+			whiteSpace: "nowrap",
+			border: 0,
+			padding: 0,
+			width: 1,
+			height: 1,
+			margin: -1
+		};
+		visuallyHidden = {
+			...visuallyHiddenBase,
+			position: "fixed",
+			margin: 0,
+			top: 0,
+			left: 0
+		};
+		({ ...visuallyHiddenBase });
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/store/useStore.mjs
+function useStore(store, selector, a1, a2, a3) {
+	return useStoreImplementation(store, selector, a1, a2, a3);
+}
+function useStoreR19(store, selector, a1, a2, a3) {
+	const getSelection = import_react$3.useCallback(() => selector(store.getSnapshot(), a1, a2, a3), [
+		store,
+		selector,
+		a1,
+		a2,
+		a3
+	]);
+	return (0, import_shim.useSyncExternalStore)(store.subscribe, getSelection, getSelection);
+}
+function useStoreFast(store, selector, a1, a2, a3) {
+	const instance = getInstance();
+	if (!instance) return useStoreR19(store, selector, a1, a2, a3);
+	const index = instance.syncIndex;
+	instance.syncIndex += 1;
+	let hook;
+	if (!instance.didInitialize) {
+		hook = {
+			store,
+			selector,
+			a1,
+			a2,
+			a3,
+			value: selector(store.getSnapshot(), a1, a2, a3)
+		};
+		instance.syncHooks.push(hook);
+	} else {
+		hook = instance.syncHooks[index];
+		if (hook.store !== store || hook.selector !== selector || !Object.is(hook.a1, a1) || !Object.is(hook.a2, a2) || !Object.is(hook.a3, a3)) {
+			if (hook.store !== store) instance.didChangeStore = true;
+			hook.store = store;
+			hook.selector = selector;
+			hook.a1 = a1;
+			hook.a2 = a2;
+			hook.a3 = a3;
+			hook.value = selector(store.getSnapshot(), a1, a2, a3);
+		}
+	}
+	return hook.value;
+}
+function useStoreLegacy(store, selector, a1, a2, a3) {
+	return (0, import_with_selector.useSyncExternalStoreWithSelector)(store.subscribe, store.getSnapshot, store.getSnapshot, (state) => selector(state, a1, a2, a3));
+}
+var import_react$3, import_shim, import_with_selector, useStoreImplementation;
+function init_useStore() {
+	return (init_useStore = __esmMin((() => {
+		import_react$3 = /* @__PURE__ */ __toESM(require_react(), 1);
+		import_shim = require_shim();
+		import_with_selector = require_with_selector();
+		init_reactVersion();
+		init_fastHooks();
+		useStoreImplementation = isReactVersionAtLeast(19) ? useStoreFast : useStoreLegacy;
+		register({
+			before(instance) {
+				instance.syncIndex = 0;
+				if (!instance.didInitialize) {
+					instance.syncTick = 1;
+					instance.syncHooks = [];
+					instance.didChangeStore = true;
+					instance.getSnapshot = () => {
+						let didChange = false;
+						for (let i = 0; i < instance.syncHooks.length; i += 1) {
+							const hook = instance.syncHooks[i];
+							const value = hook.selector(hook.store.state, hook.a1, hook.a2, hook.a3);
+							if (!Object.is(hook.value, value)) {
+								didChange = true;
+								hook.value = value;
+							}
+						}
+						if (didChange) instance.syncTick += 1;
+						return instance.syncTick;
+					};
+				}
+			},
+			after(instance) {
+				if (instance.syncHooks.length > 0) {
+					if (instance.didChangeStore) {
+						instance.didChangeStore = false;
+						instance.subscribe = (onStoreChange) => {
+							const stores = /* @__PURE__ */ new Set();
+							for (const hook of instance.syncHooks) stores.add(hook.store);
+							const unsubscribes = [];
+							for (const store of stores) unsubscribes.push(store.subscribe(onStoreChange));
+							return () => {
+								for (const unsubscribe of unsubscribes) unsubscribe();
+							};
+						};
+					}
+					(0, import_shim.useSyncExternalStore)(instance.subscribe, instance.getSnapshot, instance.getSnapshot);
+				}
+			}
+		});
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/store/Store.mjs
+var Store;
+function init_Store() {
+	return (init_Store = __esmMin((() => {
+		init_useStore();
+		Store = class {
+			/**
+			* Creates a store with the given initial state, constructing the class it is called on.
+			* Calling it on a generic base class (e.g. `ReactStore.create(...)`) constructs that
+			* class but degrades the inferred instance type to `Store`; use `new` there instead.
+			*/
+			static create(state) {
+				return new this(state);
+			}
+			/**
+			* The current state of the store.
+			* This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.
+			* To subscribe to state changes, use the {@link useState} method. The value returned by {@link useState} is updated after the component renders (similarly to React's useState).
+			* The values can be used directly (to avoid subscribing to the store) in effects or event handlers.
+			*
+			* Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.
+			*/
+			constructor(state) {
+				this.state = state;
+				this.listeners = /* @__PURE__ */ new Set();
+				this.updateTick = 0;
+			}
+			/**
+			* Registers a listener that will be called whenever the store's state changes.
+			*
+			* @param fn The listener function to be called on state changes.
+			* @returns A function to unsubscribe the listener.
+			*/
+			subscribe = (fn) => {
+				this.listeners.add(fn);
+				return () => {
+					this.listeners.delete(fn);
+				};
+			};
+			/**
+			* Returns the current state of the store.
+			*/
+			getSnapshot = () => {
+				return this.state;
+			};
+			/**
+			* Updates the entire store's state and notifies all registered listeners.
+			*
+			* @param newState The new state to set for the store.
+			*/
+			setState(newState) {
+				if (this.state === newState) return;
+				this.state = newState;
+				this.updateTick += 1;
+				const currentTick = this.updateTick;
+				for (const listener of this.listeners) {
+					if (currentTick !== this.updateTick) return;
+					listener(newState);
+				}
+			}
+			/**
+			* Merges the provided changes into the current state and notifies listeners if there are changes.
+			* Each value must match its state key. Pass an exact known subset rather than a broad
+			* `Partial<State>`, which may contain `undefined` for required state fields.
+			*
+			* @param changes An object containing the changes to apply to the current state.
+			*/
+			update(changes) {
+				for (const key in changes) if (!Object.is(this.state[key], changes[key])) {
+					this.setState({
+						...this.state,
+						...changes
+					});
+					return;
+				}
+			}
+			/**
+			* Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
+			*
+			* @param key The key in the store's state to update.
+			* @param value The new value to set for the specified key.
+			*/
+			set(key, value) {
+				if (!Object.is(this.state[key], value)) this.setState({
+					...this.state,
+					[key]: value
+				});
+			}
+			/**
+			* Gives the state a new reference and updates all registered listeners.
+			*/
+			notifyAll() {
+				const newState = { ...this.state };
+				this.setState(newState);
+			}
+			use(selector, a1, a2, a3) {
+				return useStore(this, selector, a1, a2, a3);
+			}
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/store/ReactStore.mjs
+var import_react$2, ReactStore;
+function init_ReactStore() {
+	return (init_ReactStore = __esmMin((() => {
+		import_react$2 = /* @__PURE__ */ __toESM(require_react(), 1);
+		init_Store();
+		init_useStore();
+		init_useStableCallback();
+		init_useIsoLayoutEffect();
+		init_empty();
+		ReactStore = class extends Store {
+			/**
+			* Creates a new ReactStore instance.
+			*
+			* @param state Initial state of the store.
+			* @param context Non-reactive context values.
+			* @param selectors Optional selectors for use with `useState`.
+			*/
+			constructor(state, context = {}, selectors) {
+				super(state);
+				this.context = context;
+				this.selectors = selectors;
+			}
+			/**
+			* Non-reactive values such as refs, callbacks, etc.
+			*/
+			/**
+			* Synchronizes a single external value into the store.
+			*
+			* Note that the while the value in `state` is updated immediately, the value returned
+			* by `useState` is updated before the next render (similarly to React's `useState`).
+			*/
+			useSyncedValue(key, value) {
+				import_react$2.useDebugValue(key);
+				const store = this;
+				useIsoLayoutEffect(() => {
+					if (store.state[key] !== value) store.set(key, value);
+				}, [
+					store,
+					key,
+					value
+				]);
+			}
+			/**
+			* Synchronizes a single external value into the store and
+			* cleans it up (sets to `undefined`) on unmount.
+			*
+			* Note that the while the value in `state` is updated immediately, the value returned
+			* by `useState` is updated before the next render (similarly to React's `useState`).
+			*/
+			useSyncedValueWithCleanup(key, value) {
+				const store = this;
+				useIsoLayoutEffect(() => {
+					if (store.state[key] !== value) store.set(key, value);
+					return () => {
+						store.set(key, void 0);
+					};
+				}, [
+					store,
+					key,
+					value
+				]);
+			}
+			/**
+			* Synchronizes multiple external values into the store.
+			* Each value must match its state key. Pass an exact known subset rather than a broad
+			* `Partial<State>`, which may contain `undefined` for required state fields.
+			*
+			* Note that the while the values in `state` are updated immediately, the values returned
+			* by `useState` are updated before the next render (similarly to React's `useState`).
+			*
+			* @param statePart An exact subset of state fields to synchronize. Unknown keys are not accepted.
+			*/
+			useSyncedValues(statePart) {
+				const store = this;
+				const dependencies = Object.values(statePart);
+				useIsoLayoutEffect(() => {
+					store.update(statePart);
+				}, [store, ...dependencies]);
+			}
+			/**
+			* Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`
+			* is non-undefined, the store's state at `key` is updated to match `controlled`.
+			*/
+			useControlledProp(key, controlled) {
+				import_react$2.useDebugValue(key);
+				const store = this;
+				const isControlled = controlled !== void 0;
+				useIsoLayoutEffect(() => {
+					if (isControlled && !Object.is(store.state[key], controlled)) store.setState({
+						...store.state,
+						[key]: controlled
+					});
+				}, [
+					store,
+					key,
+					controlled,
+					isControlled
+				]);
+			}
+			/** Gets the current value from the store using a selector with the provided key.
+			*
+			* @param key Key of the selector to use.
+			*/
+			select(key, a1, a2, a3) {
+				const selector = this.selectors[key];
+				return selector(this.state, a1, a2, a3);
+			}
+			/**
+			* Returns a value from the store's state using a selector function.
+			* Used to subscribe to specific parts of the state.
+			* This methods causes a rerender whenever the selected state changes.
+			*
+			* @param key Key of the selector to use.
+			*/
+			useState(key, a1, a2, a3) {
+				import_react$2.useDebugValue(key);
+				return useStore(this, this.selectors[key], a1, a2, a3);
+			}
+			/**
+			* Wraps a function with `useStableCallback` to ensure it has a stable reference
+			* and assigns it to the context.
+			*
+			* @param key Key of the event callback. Must be a function in the context.
+			* @param fn Function to assign.
+			*/
+			useContextCallback(key, fn) {
+				import_react$2.useDebugValue(key);
+				const stableFunction = useStableCallback(fn ?? NOOP);
+				this.context[key] = stableFunction;
+			}
+			/**
+			* Returns a stable setter function for a specific key in the store's state.
+			* It's commonly used to pass as a ref callback to React elements.
+			*
+			* @param key Key of the state to set.
+			*/
+			useStateSetter(key) {
+				const ref = import_react$2.useRef(void 0);
+				if (ref.current === void 0) ref.current = (value) => {
+					this.set(key, value);
+				};
+				return ref.current;
+			}
+			/**
+			* Observes changes derived from the store's selectors and calls the listener when the selected value changes.
+			*
+			* @param key Key of the selector to observe.
+			* @param listener Listener function called when the selector result changes.
+			*/
+			observe(selector, listener) {
+				let selectFn;
+				if (typeof selector === "function") selectFn = selector;
+				else selectFn = this.selectors[selector];
+				let prevValue = selectFn(this.state);
+				listener(prevValue, prevValue, this);
+				return this.subscribe((nextState) => {
+					const nextValue = selectFn(nextState);
+					if (!Object.is(prevValue, nextValue)) {
+						const oldValue = prevValue;
+						prevValue = nextValue;
+						listener(nextValue, oldValue, this);
+					}
+				});
+			}
+		};
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useScrollLock.mjs
+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();
+	};
+}
+/**
+* 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]);
+}
+var originalHtmlStyles, originalBodyStyles, originalHtmlScrollBehavior, ScrollLocker, SCROLL_LOCKER;
+function init_useScrollLock() {
+	return (init_useScrollLock = __esmMin((() => {
+		init_floating_ui_utils_dom();
+		init_engine(), init_os();
+		init_useIsoLayoutEffect();
+		init_useTimeout();
+		init_useAnimationFrame();
+		originalHtmlStyles = {};
+		originalBodyStyles = {};
+		originalHtmlScrollBehavior = "";
+		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);
+			}
+		};
+		SCROLL_LOCKER = new ScrollLocker();
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useEnhancedClickHandler.mjs
+/**
+* Provides a cross-browser way to determine the type of the pointer used to click.
+* Safari and Firefox do not provide the PointerEvent to the click handler (they use MouseEvent) yet.
+* Additionally, this implementation detects if the click was triggered by the keyboard.
+*
+* @param handler The function to be called when the button is clicked. The first parameter is the original event and the second parameter is the pointer type.
+*/
+function useEnhancedClickHandler(handler) {
+	const lastClickInteractionTypeRef = import_react$1.useRef("");
+	const handlePointerDown = import_react$1.useCallback((event) => {
+		if (event.defaultPrevented) return;
+		lastClickInteractionTypeRef.current = event.pointerType;
+		handler(event, event.pointerType);
+	}, [handler]);
+	return {
+		onClick: import_react$1.useCallback((event) => {
+			if (event.detail === 0) {
+				handler(event, "keyboard");
+				return;
+			}
+			if ("pointerType" in event) handler(event, event.pointerType);
+			else handler(event, lastClickInteractionTypeRef.current);
+			lastClickInteractionTypeRef.current = "";
+		}, [handler]),
+		onPointerDown: handlePointerDown
+	};
+}
+var import_react$1;
+function init_useEnhancedClickHandler() {
+	return (init_useEnhancedClickHandler = __esmMin((() => {
+		import_react$1 = /* @__PURE__ */ __toESM(require_react(), 1);
+	})))();
+}
+//#endregion
+//#region ../../node_modules/@base-ui/utils/useControlled.mjs
+function useControlled({ controlled, default: defaultProp, name, state = "value" }) {
+	const { current: isControlled } = import_react.useRef(controlled !== void 0);
+	const [valueState, setValue] = import_react.useState(() => defaultProp);
+	return [isControlled && controlled !== void 0 ? controlled : valueState, import_react.useCallback((newValue) => {
+		if (!isControlled) setValue(newValue);
+	}, [])];
+}
+var import_react;
+function init_useControlled() {
+	return (init_useControlled = __esmMin((() => {
+		import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+	})))();
+}
+//#endregion
+export { init_os as A, useMergedRefs as B, init_env as C, init_engine as D, voiceOver as E, init_useForcedRerendering as F, init_useOnMount as G, Timeout as H, useForcedRerendering as I, useStableCallback as J, useOnMount as K, init_reactVersion as L, mac as M, init_useId as N, webkit as O, useId as P, isReactVersionAtLeast as R, init_shadowDom as S, init_screen_reader as T, init_useTimeout as U, useMergedRefsN as V, useTimeout as W, useRefWithInit as X, init_useRefWithInit as Y, useIsoLayoutEffect as _, init_useScrollLock as a, contains as b, init_ReactStore as c, AnimationFrame as d, init_useAnimationFrame as f, init_useIsoLayoutEffect as g, useValueAsRef as h, useEnhancedClickHandler as i, ios as j, android as k, init_visuallyHidden as l, init_useValueAsRef as m, useControlled as n, useScrollLock as o, useAnimationFrame as p, init_useStableCallback as q, init_useEnhancedClickHandler as r, ReactStore as s, init_useControlled as t, visuallyHidden as u, activeElement as v, jsdom as w, getTarget as x, closest as y, init_useMergedRefs as z };