@preply/ds-web-lib 11.0.0 → 11.1.0

package/dist/store-sN_eYeZT.js

@@ -0,0 +1,1064 @@
+"use client";
+"use strict";
+import { t as __commonJSMin } from "./chunk-BVTlhY3a.js";
+import { n as require_builtin_esm_external_require_react } from "./jsx-runtime-i4KUlhDu.js";
+import { d as NOOP } from "./useRenderElement-ZBds6eRN.js";
+import { S as useEventCallback, x as useIsoLayoutEffect } from "./floating-ui.utils.dom-CoeTbDZx.js";
+import { F as useOpenChangeComplete, _ as useClick, a as useInteractions, c as useDismiss, i as useRole, mt as _defineProperty, n as useScrollLock, nt as getTarget, pt as useTransitionStatus, s as useFloatingRootContext, t as useOpenInteractionType } from "./useOpenInteractionType-D8vA_ZKI.js";
+import * as React$1 from "react";
+//#region ../../node_modules/@base-ui-components/react/esm/dialog/root/useDialogRoot.js
+function useDialogRoot(params) {
+	const { store, parentContext } = params;
+	const open = store.useState("open");
+	const dismissible = store.useState("dismissible");
+	const modal = store.useState("modal");
+	const triggerElement = store.useState("triggerElement");
+	const popupElement = store.useState("popupElement");
+	const { mounted, setMounted, transitionStatus } = useTransitionStatus(open);
+	const { openMethod, triggerProps, reset: resetOpenInteractionType } = useOpenInteractionType(open);
+	const handleUnmount = useEventCallback(() => {
+		var _store$context$openCh, _store$context;
+		setMounted(false);
+		(_store$context$openCh = (_store$context = store.context).openChangeComplete) === null || _store$context$openCh === void 0 || _store$context$openCh.call(_store$context, false);
+		resetOpenInteractionType();
+	});
+	useOpenChangeComplete({
+		enabled: !params.actionsRef,
+		open,
+		ref: store.context.popupRef,
+		onComplete() {
+			if (!open) handleUnmount();
+		}
+	});
+	React$1.useImperativeHandle(params.actionsRef, () => ({ unmount: handleUnmount }), [handleUnmount]);
+	const context = useFloatingRootContext({
+		elements: {
+			reference: triggerElement,
+			floating: popupElement
+		},
+		open,
+		onOpenChange: store.setOpen,
+		noEmit: true
+	});
+	const [ownNestedOpenDialogs, setOwnNestedOpenDialogs] = React$1.useState(0);
+	const isTopmost = ownNestedOpenDialogs === 0;
+	const role = useRole(context);
+	const click = useClick(context);
+	const dismiss = useDismiss(context, {
+		outsidePressEvent() {
+			if (store.context.internalBackdropRef.current || store.context.backdropRef.current) return "intentional";
+			return {
+				mouse: modal === "trap-focus" ? "sloppy" : "intentional",
+				touch: "sloppy"
+			};
+		},
+		outsidePress(event) {
+			if (event.button !== 0) return false;
+			const target = getTarget(event);
+			if (isTopmost && dismissible) {
+				const eventTarget = target;
+				if (modal) return store.context.internalBackdropRef.current || store.context.backdropRef.current ? store.context.internalBackdropRef.current === eventTarget || store.context.backdropRef.current === eventTarget : true;
+				return true;
+			}
+			return false;
+		},
+		escapeKey: isTopmost
+	});
+	useScrollLock({
+		enabled: open && modal === true,
+		mounted,
+		open,
+		referenceElement: popupElement
+	});
+	const { getReferenceProps, getFloatingProps } = useInteractions([
+		role,
+		click,
+		dismiss
+	]);
+	store.useContextCallback("nestedDialogOpen", (ownChildrenCount) => {
+		setOwnNestedOpenDialogs(ownChildrenCount + 1);
+	});
+	store.useContextCallback("nestedDialogClose", () => {
+		setOwnNestedOpenDialogs(0);
+	});
+	React$1.useEffect(() => {
+		if ((parentContext === null || parentContext === void 0 ? void 0 : parentContext.nestedDialogOpen) && open) parentContext.nestedDialogOpen(ownNestedOpenDialogs);
+		if ((parentContext === null || parentContext === void 0 ? void 0 : parentContext.nestedDialogClose) && !open) parentContext.nestedDialogClose();
+		return () => {
+			if ((parentContext === null || parentContext === void 0 ? void 0 : parentContext.nestedDialogClose) && open) parentContext.nestedDialogClose();
+		};
+	}, [
+		open,
+		parentContext,
+		ownNestedOpenDialogs
+	]);
+	const dialogTriggerProps = React$1.useMemo(() => getReferenceProps(triggerProps), [getReferenceProps, triggerProps]);
+	store.useSyncedValues({
+		openMethod,
+		mounted,
+		transitionStatus,
+		triggerProps: dialogTriggerProps,
+		popupProps: getFloatingProps(),
+		floatingRootContext: context,
+		nestedOpenDialogCount: ownNestedOpenDialogs
+	});
+}
+//#endregion
+//#region ../../node_modules/reselect/dist/reselect.mjs
+var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {
+	if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {
+		let isInputSameAsOutput = false;
+		try {
+			const emptyObject = {};
+			if (resultFunc(emptyObject) === emptyObject) isInputSameAsOutput = true;
+		} catch {}
+		if (isInputSameAsOutput) {
+			let stack = void 0;
+			try {
+				throw new Error();
+			} catch (e) {
+				({stack} = e);
+			}
+			console.warn("The result function returned its own inputs without modification. e.g\n`createSelector([state => state.todos], todos => todos)`\nThis could lead to inefficient memoization and unnecessary re-renders.\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.", { stack });
+		}
+	}
+};
+var runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {
+	const { memoize, memoizeOptions } = options;
+	const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;
+	const createAnEmptyObject = memoize(() => ({}), ...memoizeOptions);
+	if (!(createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy))) {
+		let stack = void 0;
+		try {
+			throw new Error();
+		} catch (e) {
+			({stack} = e);
+		}
+		console.warn("An input selector returned a different result when passed same arguments.\nThis means your output selector will likely run more frequently than intended.\nAvoid returning a new reference inside your input selector, e.g.\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`", {
+			arguments: inputSelectorArgs,
+			firstInputs: inputSelectorResults,
+			secondInputs: inputSelectorResultsCopy,
+			stack
+		});
+	}
+};
+var globalDevModeChecks = {
+	inputStabilityCheck: "once",
+	identityFunctionCheck: "once"
+};
+var NOT_FOUND = /* @__PURE__ */ Symbol("NOT_FOUND");
+function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
+	if (typeof func !== "function") throw new TypeError(errorMessage);
+}
+function assertIsObject(object, errorMessage = `expected an object, instead received ${typeof object}`) {
+	if (typeof object !== "object") throw new TypeError(errorMessage);
+}
+function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
+	if (!array.every((item) => typeof item === "function")) {
+		const itemTypes = array.map((item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item).join(", ");
+		throw new TypeError(`${errorMessage}[${itemTypes}]`);
+	}
+}
+var ensureIsArray = (item) => {
+	return Array.isArray(item) ? item : [item];
+};
+function getDependencies(createSelectorArgs) {
+	const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
+	assertIsArrayOfFunctions(dependencies, `createSelector expects all input-selectors to be functions, but received the following types: `);
+	return dependencies;
+}
+function collectInputSelectorResults(dependencies, inputSelectorArgs) {
+	const inputSelectorResults = [];
+	const { length } = dependencies;
+	for (let i = 0; i < length; i++) inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
+	return inputSelectorResults;
+}
+var getDevModeChecksExecutionInfo = (firstRun, devModeChecks) => {
+	const { identityFunctionCheck, inputStabilityCheck } = {
+		...globalDevModeChecks,
+		...devModeChecks
+	};
+	return {
+		identityFunctionCheck: {
+			shouldRun: identityFunctionCheck === "always" || identityFunctionCheck === "once" && firstRun,
+			run: runIdentityFunctionCheck
+		},
+		inputStabilityCheck: {
+			shouldRun: inputStabilityCheck === "always" || inputStabilityCheck === "once" && firstRun,
+			run: runInputStabilityCheck
+		}
+	};
+};
+function createSingletonCache(equals) {
+	let entry;
+	return {
+		get(key) {
+			if (entry && equals(entry.key, key)) return entry.value;
+			return NOT_FOUND;
+		},
+		put(key, value) {
+			entry = {
+				key,
+				value
+			};
+		},
+		getEntries() {
+			return entry ? [entry] : [];
+		},
+		clear() {
+			entry = void 0;
+		}
+	};
+}
+function createLruCache(maxSize, equals) {
+	let entries = [];
+	function get(key) {
+		const cacheIndex = entries.findIndex((entry) => equals(key, entry.key));
+		if (cacheIndex > -1) {
+			const entry = entries[cacheIndex];
+			if (cacheIndex > 0) {
+				entries.splice(cacheIndex, 1);
+				entries.unshift(entry);
+			}
+			return entry.value;
+		}
+		return NOT_FOUND;
+	}
+	function put(key, value) {
+		if (get(key) === NOT_FOUND) {
+			entries.unshift({
+				key,
+				value
+			});
+			if (entries.length > maxSize) entries.pop();
+		}
+	}
+	function getEntries() {
+		return entries;
+	}
+	function clear() {
+		entries = [];
+	}
+	return {
+		get,
+		put,
+		getEntries,
+		clear
+	};
+}
+var referenceEqualityCheck = (a, b) => a === b;
+function createCacheKeyComparator(equalityCheck) {
+	return function areArgumentsShallowlyEqual(prev, next) {
+		if (prev === null || next === null || prev.length !== next.length) return false;
+		const { length } = prev;
+		for (let i = 0; i < length; i++) if (!equalityCheck(prev[i], next[i])) return false;
+		return true;
+	};
+}
+function lruMemoize(func, equalityCheckOrOptions) {
+	const { equalityCheck = referenceEqualityCheck, maxSize = 1, resultEqualityCheck } = typeof equalityCheckOrOptions === "object" ? equalityCheckOrOptions : { equalityCheck: equalityCheckOrOptions };
+	const comparator = createCacheKeyComparator(equalityCheck);
+	let resultsCount = 0;
+	const cache = maxSize <= 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator);
+	function memoized() {
+		let value = cache.get(arguments);
+		if (value === NOT_FOUND) {
+			value = func.apply(null, arguments);
+			resultsCount++;
+			if (resultEqualityCheck) {
+				const matchingEntry = cache.getEntries().find((entry) => resultEqualityCheck(entry.value, value));
+				if (matchingEntry) {
+					value = matchingEntry.value;
+					resultsCount !== 0 && resultsCount--;
+				}
+			}
+			cache.put(arguments, value);
+		}
+		return value;
+	}
+	memoized.clearCache = () => {
+		cache.clear();
+		memoized.resetResultsCount();
+	};
+	memoized.resultsCount = () => resultsCount;
+	memoized.resetResultsCount = () => {
+		resultsCount = 0;
+	};
+	return memoized;
+}
+var StrongRef = class {
+	constructor(value) {
+		this.value = value;
+	}
+	deref() {
+		return this.value;
+	}
+};
+var Ref = typeof WeakRef !== "undefined" ? WeakRef : StrongRef;
+var UNTERMINATED = 0;
+var TERMINATED = 1;
+function createCacheNode() {
+	return {
+		s: UNTERMINATED,
+		v: void 0,
+		o: null,
+		p: null
+	};
+}
+function weakMapMemoize(func, options = {}) {
+	let fnNode = createCacheNode();
+	const { resultEqualityCheck } = options;
+	let lastResult;
+	let resultsCount = 0;
+	function memoized() {
+		let cacheNode = fnNode;
+		const { length } = arguments;
+		for (let i = 0, l = length; i < l; i++) {
+			const arg = arguments[i];
+			if (typeof arg === "function" || typeof arg === "object" && arg !== null) {
+				let objectCache = cacheNode.o;
+				if (objectCache === null) cacheNode.o = objectCache = /* @__PURE__ */ new WeakMap();
+				const objectNode = objectCache.get(arg);
+				if (objectNode === void 0) {
+					cacheNode = createCacheNode();
+					objectCache.set(arg, cacheNode);
+				} else cacheNode = objectNode;
+			} else {
+				let primitiveCache = cacheNode.p;
+				if (primitiveCache === null) cacheNode.p = primitiveCache = /* @__PURE__ */ new Map();
+				const primitiveNode = primitiveCache.get(arg);
+				if (primitiveNode === void 0) {
+					cacheNode = createCacheNode();
+					primitiveCache.set(arg, cacheNode);
+				} else cacheNode = primitiveNode;
+			}
+		}
+		const terminatedNode = cacheNode;
+		let result;
+		if (cacheNode.s === TERMINATED) result = cacheNode.v;
+		else {
+			result = func.apply(null, arguments);
+			resultsCount++;
+			if (resultEqualityCheck) {
+				var _lastResult$deref, _lastResult$deref2;
+				const lastResultValue = (_lastResult$deref = lastResult === null || lastResult === void 0 || (_lastResult$deref2 = lastResult.deref) === null || _lastResult$deref2 === void 0 ? void 0 : _lastResult$deref2.call(lastResult)) !== null && _lastResult$deref !== void 0 ? _lastResult$deref : lastResult;
+				if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
+					result = lastResultValue;
+					resultsCount !== 0 && resultsCount--;
+				}
+				lastResult = typeof result === "object" && result !== null || typeof result === "function" ? new Ref(result) : result;
+			}
+		}
+		terminatedNode.s = TERMINATED;
+		terminatedNode.v = result;
+		return result;
+	}
+	memoized.clearCache = () => {
+		fnNode = createCacheNode();
+		memoized.resetResultsCount();
+	};
+	memoized.resultsCount = () => resultsCount;
+	memoized.resetResultsCount = () => {
+		resultsCount = 0;
+	};
+	return memoized;
+}
+function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
+	const createSelectorCreatorOptions = typeof memoizeOrOptions === "function" ? {
+		memoize: memoizeOrOptions,
+		memoizeOptions: memoizeOptionsFromArgs
+	} : memoizeOrOptions;
+	const createSelector2 = (...createSelectorArgs) => {
+		let recomputations = 0;
+		let dependencyRecomputations = 0;
+		let lastResult;
+		let directlyPassedOptions = {};
+		let resultFunc = createSelectorArgs.pop();
+		if (typeof resultFunc === "object") {
+			directlyPassedOptions = resultFunc;
+			resultFunc = createSelectorArgs.pop();
+		}
+		assertIsFunction(resultFunc, `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]`);
+		const { memoize, memoizeOptions = [], argsMemoize = weakMapMemoize, argsMemoizeOptions = [], devModeChecks = {} } = {
+			...createSelectorCreatorOptions,
+			...directlyPassedOptions
+		};
+		const finalMemoizeOptions = ensureIsArray(memoizeOptions);
+		const finalArgsMemoizeOptions = ensureIsArray(argsMemoizeOptions);
+		const dependencies = getDependencies(createSelectorArgs);
+		const memoizedResultFunc = memoize(function recomputationWrapper() {
+			recomputations++;
+			return resultFunc.apply(null, arguments);
+		}, ...finalMemoizeOptions);
+		let firstRun = true;
+		const selector = argsMemoize(function dependenciesChecker() {
+			dependencyRecomputations++;
+			const inputSelectorResults = collectInputSelectorResults(dependencies, arguments);
+			lastResult = memoizedResultFunc.apply(null, inputSelectorResults);
+			if (process.env.NODE_ENV !== "production") {
+				const { identityFunctionCheck, inputStabilityCheck } = getDevModeChecksExecutionInfo(firstRun, devModeChecks);
+				if (identityFunctionCheck.shouldRun) identityFunctionCheck.run(resultFunc, inputSelectorResults, lastResult);
+				if (inputStabilityCheck.shouldRun) {
+					const inputSelectorResultsCopy = collectInputSelectorResults(dependencies, arguments);
+					inputStabilityCheck.run({
+						inputSelectorResults,
+						inputSelectorResultsCopy
+					}, {
+						memoize,
+						memoizeOptions: finalMemoizeOptions
+					}, arguments);
+				}
+				if (firstRun) firstRun = false;
+			}
+			return lastResult;
+		}, ...finalArgsMemoizeOptions);
+		return Object.assign(selector, {
+			resultFunc,
+			memoizedResultFunc,
+			dependencies,
+			dependencyRecomputations: () => dependencyRecomputations,
+			resetDependencyRecomputations: () => {
+				dependencyRecomputations = 0;
+			},
+			lastResult: () => lastResult,
+			recomputations: () => recomputations,
+			resetRecomputations: () => {
+				recomputations = 0;
+			},
+			memoize,
+			argsMemoize
+		});
+	};
+	Object.assign(createSelector2, { withTypes: () => createSelector2 });
+	return createSelector2;
+}
+var createSelector$1 = /* @__PURE__ */ createSelectorCreator(weakMapMemoize);
+var createStructuredSelector = Object.assign((inputSelectorsObject, selectorCreator = createSelector$1) => {
+	assertIsObject(inputSelectorsObject, `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof inputSelectorsObject}`);
+	const inputSelectorKeys = Object.keys(inputSelectorsObject);
+	return selectorCreator(inputSelectorKeys.map((key) => inputSelectorsObject[key]), (...inputSelectorResults) => {
+		return inputSelectorResults.reduce((composition, value, index) => {
+			composition[inputSelectorKeys[index]] = value;
+			return composition;
+		}, {});
+	});
+}, { withTypes: () => createStructuredSelector });
+createSelectorCreator({
+	memoize: lruMemoize,
+	memoizeOptions: {
+		maxSize: 1,
+		equalityCheck: Object.is
+	}
+});
+/**
+* Creates a selector function that can be used to derive values from the store's state.
+* The selector can take up to three additional arguments that can be used in the selector logic.
+* This function accepts up to six functions and combines them into a single selector function.
+* The last parameter is the combiner function that combines the results of the previous selectors.
+*
+* @example
+* const selector = createSelector(
+*  (state) => state.disabled
+* );
+*
+* @example
+* const selector = createSelector(
+*   (state) => state.disabled,
+*   (state) => state.open,
+*   (disabled, open) => ({ disabled, open })
+* );
+*
+*/
+var createSelector = (a, b, c, d, e, f, ...other) => {
+	if (other.length > 0) throw new Error("Unsupported number of selectors");
+	let selector;
+	if (a && b && c && d && e && f) selector = (state, a1, a2, a3) => {
+		return f(a(state, a1, a2, a3), b(state, a1, a2, a3), c(state, a1, a2, a3), d(state, a1, a2, a3), e(state, a1, a2, a3), a1, a2, a3);
+	};
+	else if (a && b && c && d && e) selector = (state, a1, a2, a3) => {
+		return e(a(state, a1, a2, a3), b(state, a1, a2, a3), c(state, a1, a2, a3), d(state, a1, a2, a3), a1, a2, a3);
+	};
+	else if (a && b && c && d) selector = (state, a1, a2, a3) => {
+		return d(a(state, a1, a2, a3), b(state, a1, a2, a3), c(state, a1, a2, a3), a1, a2, a3);
+	};
+	else if (a && b && c) selector = (state, a1, a2, a3) => {
+		return c(a(state, a1, a2, a3), b(state, a1, a2, a3), a1, a2, a3);
+	};
+	else if (a && b) selector = (state, a1, a2, a3) => {
+		return b(a(state, a1, a2, a3), a1, a2, a3);
+	};
+	else if (a) selector = a;
+	else throw new Error("Missing arguments");
+	return selector;
+};
+//#endregion
+//#region ../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js
+var require_use_sync_external_store_shim_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* @license React
+	* use-sync-external-store-shim.production.js
+	*
+	* Copyright (c) Meta Platforms, Inc. and affiliates.
+	*
+	* This source code is licensed under the MIT license found in the
+	* LICENSE file in the root directory of this source tree.
+	*/
+	var React = require_builtin_esm_external_require_react();
+	function is(x, y) {
+		return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+	}
+	var objectIs = "function" === typeof Object.is ? Object.is : is, useState = React.useState, useEffect = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue;
+	function useSyncExternalStore$2(subscribe, getSnapshot) {
+		var value = getSnapshot(), _useState = useState({ inst: {
+			value,
+			getSnapshot
+		} }), inst = _useState[0].inst, forceUpdate = _useState[1];
+		useLayoutEffect(function() {
+			inst.value = value;
+			inst.getSnapshot = getSnapshot;
+			checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+		}, [
+			subscribe,
+			value,
+			getSnapshot
+		]);
+		useEffect(function() {
+			checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+			return subscribe(function() {
+				checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+			});
+		}, [subscribe]);
+		useDebugValue(value);
+		return value;
+	}
+	function checkIfSnapshotChanged(inst) {
+		var latestGetSnapshot = inst.getSnapshot;
+		inst = inst.value;
+		try {
+			var nextValue = latestGetSnapshot();
+			return !objectIs(inst, nextValue);
+		} catch (error) {
+			return !0;
+		}
+	}
+	function useSyncExternalStore$1(subscribe, getSnapshot) {
+		return getSnapshot();
+	}
+	var shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+	exports.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
+}));
+//#endregion
+//#region ../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
+var require_use_sync_external_store_shim_development = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* @license React
+	* use-sync-external-store-shim.development.js
+	*
+	* Copyright (c) Meta Platforms, Inc. and affiliates.
+	*
+	* This source code is licensed under the MIT license found in the
+	* LICENSE file in the root directory of this source tree.
+	*/
+	"production" !== process.env.NODE_ENV && (function() {
+		function is(x, y) {
+			return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+		}
+		function useSyncExternalStore$2(subscribe, getSnapshot) {
+			didWarnOld18Alpha || void 0 === React.startTransition || (didWarnOld18Alpha = !0, console.error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."));
+			var value = getSnapshot();
+			if (!didWarnUncachedGetSnapshot) {
+				var cachedValue = getSnapshot();
+				objectIs(value, cachedValue) || (console.error("The result of getSnapshot should be cached to avoid an infinite loop"), didWarnUncachedGetSnapshot = !0);
+			}
+			cachedValue = useState({ inst: {
+				value,
+				getSnapshot
+			} });
+			var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
+			useLayoutEffect(function() {
+				inst.value = value;
+				inst.getSnapshot = getSnapshot;
+				checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+			}, [
+				subscribe,
+				value,
+				getSnapshot
+			]);
+			useEffect(function() {
+				checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+				return subscribe(function() {
+					checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+				});
+			}, [subscribe]);
+			useDebugValue(value);
+			return value;
+		}
+		function checkIfSnapshotChanged(inst) {
+			var latestGetSnapshot = inst.getSnapshot;
+			inst = inst.value;
+			try {
+				var nextValue = latestGetSnapshot();
+				return !objectIs(inst, nextValue);
+			} catch (error) {
+				return !0;
+			}
+		}
+		function useSyncExternalStore$1(subscribe, getSnapshot) {
+			return getSnapshot();
+		}
+		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+		var React = require_builtin_esm_external_require_react(), objectIs = "function" === typeof Object.is ? Object.is : is, useState = React.useState, useEffect = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue, didWarnOld18Alpha = !1, didWarnUncachedGetSnapshot = !1, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+		exports.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
+		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+	})();
+}));
+//#endregion
+//#region ../../node_modules/use-sync-external-store/shim/index.js
+var require_shim = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (process.env.NODE_ENV === "production") module.exports = require_use_sync_external_store_shim_production();
+	else module.exports = require_use_sync_external_store_shim_development();
+}));
+//#endregion
+//#region ../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.js
+var require_with_selector_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* @license React
+	* use-sync-external-store-shim/with-selector.production.js
+	*
+	* Copyright (c) Meta Platforms, Inc. and affiliates.
+	*
+	* This source code is licensed under the MIT license found in the
+	* LICENSE file in the root directory of this source tree.
+	*/
+	var React = require_builtin_esm_external_require_react(), shim = require_shim();
+	function is(x, y) {
+		return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+	}
+	var objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim.useSyncExternalStore, useRef = React.useRef, useEffect = React.useEffect, useMemo = React.useMemo, useDebugValue = React.useDebugValue;
+	exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+		var instRef = useRef(null);
+		if (null === instRef.current) {
+			var inst = {
+				hasValue: !1,
+				value: null
+			};
+			instRef.current = inst;
+		} else inst = instRef.current;
+		instRef = useMemo(function() {
+			function memoizedSelector(nextSnapshot) {
+				if (!hasMemo) {
+					hasMemo = !0;
+					memoizedSnapshot = nextSnapshot;
+					nextSnapshot = selector(nextSnapshot);
+					if (void 0 !== isEqual && inst.hasValue) {
+						var currentSelection = inst.value;
+						if (isEqual(currentSelection, nextSnapshot)) return memoizedSelection = currentSelection;
+					}
+					return memoizedSelection = nextSnapshot;
+				}
+				currentSelection = memoizedSelection;
+				if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+				var nextSelection = selector(nextSnapshot);
+				if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) return memoizedSnapshot = nextSnapshot, currentSelection;
+				memoizedSnapshot = nextSnapshot;
+				return memoizedSelection = nextSelection;
+			}
+			var hasMemo = !1, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+			return [function() {
+				return memoizedSelector(getSnapshot());
+			}, null === maybeGetServerSnapshot ? void 0 : function() {
+				return memoizedSelector(maybeGetServerSnapshot());
+			}];
+		}, [
+			getSnapshot,
+			getServerSnapshot,
+			selector,
+			isEqual
+		]);
+		var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+		useEffect(function() {
+			inst.hasValue = !0;
+			inst.value = value;
+		}, [value]);
+		useDebugValue(value);
+		return value;
+	};
+}));
+//#endregion
+//#region ../../node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js
+var require_with_selector_development = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* @license React
+	* use-sync-external-store-shim/with-selector.development.js
+	*
+	* Copyright (c) Meta Platforms, Inc. and affiliates.
+	*
+	* This source code is licensed under the MIT license found in the
+	* LICENSE file in the root directory of this source tree.
+	*/
+	"production" !== process.env.NODE_ENV && (function() {
+		function is(x, y) {
+			return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+		}
+		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+		var React = require_builtin_esm_external_require_react(), shim = require_shim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim.useSyncExternalStore, useRef = React.useRef, useEffect = React.useEffect, useMemo = React.useMemo, useDebugValue = React.useDebugValue;
+		exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+			var instRef = useRef(null);
+			if (null === instRef.current) {
+				var inst = {
+					hasValue: !1,
+					value: null
+				};
+				instRef.current = inst;
+			} else inst = instRef.current;
+			instRef = useMemo(function() {
+				function memoizedSelector(nextSnapshot) {
+					if (!hasMemo) {
+						hasMemo = !0;
+						memoizedSnapshot = nextSnapshot;
+						nextSnapshot = selector(nextSnapshot);
+						if (void 0 !== isEqual && inst.hasValue) {
+							var currentSelection = inst.value;
+							if (isEqual(currentSelection, nextSnapshot)) return memoizedSelection = currentSelection;
+						}
+						return memoizedSelection = nextSnapshot;
+					}
+					currentSelection = memoizedSelection;
+					if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+					var nextSelection = selector(nextSnapshot);
+					if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) return memoizedSnapshot = nextSnapshot, currentSelection;
+					memoizedSnapshot = nextSnapshot;
+					return memoizedSelection = nextSelection;
+				}
+				var hasMemo = !1, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+				return [function() {
+					return memoizedSelector(getSnapshot());
+				}, null === maybeGetServerSnapshot ? void 0 : function() {
+					return memoizedSelector(maybeGetServerSnapshot());
+				}];
+			}, [
+				getSnapshot,
+				getServerSnapshot,
+				selector,
+				isEqual
+			]);
+			var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+			useEffect(function() {
+				inst.hasValue = !0;
+				inst.value = value;
+			}, [value]);
+			useDebugValue(value);
+			return value;
+		};
+		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+	})();
+}));
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/store/useStore.js
+var import_with_selector = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (process.env.NODE_ENV === "production") module.exports = require_with_selector_production();
+	else module.exports = require_with_selector_development();
+})))();
+/**
+* Returns a value from the store. The value is derived from the store's state using the provided selector function.
+* Updates to the store's other properties will not cause re-renders.
+*
+* @param store The Store instance to read from.
+* @param selector A function that selects a value from the store's state.
+* @param a1 Optional first argument for the selector function.
+* @param a2 Optional second argument for the selector function.
+* @param a3 Optional third argument for the selector function.
+*/
+function useStore(store, selector, a1, a2, a3) {
+	const selectorWithArgs = (state) => selector(state, a1, a2, a3);
+	return (0, import_with_selector.useSyncExternalStoreWithSelector)(store.subscribe, store.getSnapshot, store.getSnapshot, selectorWithArgs);
+}
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/store/Store.js
+/**
+* A data store implementation that allows subscribing to state changes and updating the state.
+* It uses an observer pattern to notify subscribers when the state changes.
+*/
+var Store = class {
+	/**
+	* The current state of the store.
+	* This property is updated immediately when the state changes as a result of calling {@link update}, {@link apply}, 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) {
+		_defineProperty(
+			this,
+			/**
+			* 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);
+				};
+			}
+		);
+		_defineProperty(
+			this,
+			/**
+			* Returns the current state of the store.
+			*/
+			"getSnapshot",
+			() => {
+				return this.state;
+			}
+		);
+		this.state = state;
+		this.listeners = /* @__PURE__ */ new Set();
+	}
+	/**
+	* Updates the entire store's state and notifies all registered listeners.
+	*
+	* @param newState The new state to set for the store.
+	*/
+	update(newState) {
+		if (this.state !== newState) {
+			this.state = newState;
+			this.listeners.forEach((l) => l(newState));
+		}
+	}
+	/**
+	* Merges the provided changes into the current state and notifies listeners if there are changes.
+	*
+	* @param changes An object containing the changes to apply to the current state.
+	*/
+	apply(changes) {
+		for (const key in changes) if (!Object.is(this.state[key], changes[key])) {
+			this.update({
+				...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.update({
+			...this.state,
+			[key]: value
+		});
+	}
+};
+//#endregion
+//#region ../../node_modules/@base-ui-components/utils/esm/store/ReactStore.js
+/**
+* A Store that supports controlled state keys.
+*
+* - Keys registered through {@link useControlledProp} become controlled when a non-undefined
+*   value is provided. Controlled keys mirror the incoming value and ignore local writes
+*   (via {@link set}, {@link apply}, or {@link update}).
+* - When a key is uncontrolled, an optional default value is written once on first render.
+* - Use {@link useSyncedValue} and {@link useSyncedValues} to synchronize external values/props into the
+*   store during a layout phase using {@link useIsoLayoutEffect}.
+*/
+var ReactStore = class extends Store {
+	constructor(state, context = {}, selectors) {
+		super(state);
+		_defineProperty(
+			this,
+			/**
+			* Non-reactive values such as refs, callbacks, etc.
+			* Unlike `state`, this property can be accessed directly.
+			*/
+			/**
+			* Keeps track of which properties are controlled.
+			*/
+			"controlledValues",
+			/* @__PURE__ */ new Map()
+		);
+		this.context = context;
+		this.selectors = selectors;
+	}
+	/**
+	* Synchronizes a single external value into the store during layout phase.
+	*/
+	useSyncedValue(key, value) {
+		useIsoLayoutEffect(() => {
+			if (this.state[key] !== value) this.set(key, value);
+		}, [key, value]);
+	}
+	/**
+	* Synchronizes a single external value into the store during layout phase and
+	* cleans it up (sets to `undefined`) on unmount.
+	*/
+	useSyncedValueWithCleanup(key, value) {
+		useIsoLayoutEffect(() => {
+			if (this.state[key] !== value) this.set(key, value);
+			return () => {
+				this.set(key, void 0);
+			};
+		}, [key, value]);
+	}
+	/**
+	* Synchronizes multiple external values into the store during layout phase.
+	*/
+	useSyncedValues(props) {
+		useIsoLayoutEffect(() => {
+			this.apply(props);
+		}, [props]);
+	}
+	/**
+	* Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key.
+	* - If `controlled` is non-undefined, the key is marked as controlled and the store's
+	*   state at `key` is updated to match `controlled`. Local writes to that key are ignored.
+	* - If `controlled` is undefined, the key is marked as uncontrolled. The store's state
+	*   is initialized to `defaultValue` on first render and can be updated with local writes.
+	*/
+	useControlledProp(key, controlled, defaultValue) {
+		const isControlled = controlled !== void 0;
+		if (process.env.NODE_ENV !== "production") {
+			const previouslyControlled = this.controlledValues.get(key);
+			if (previouslyControlled !== void 0 && previouslyControlled !== isControlled) console.error(`A component is changing the ${isControlled ? "" : "un"}controlled state of ${key.toString()} to be ${isControlled ? "un" : ""}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);
+		}
+		if (!this.controlledValues.has(key)) {
+			this.controlledValues.set(key, isControlled);
+			if (!isControlled && !Object.is(this.state[key], defaultValue)) super.update({
+				...this.state,
+				[key]: defaultValue
+			});
+		}
+		useIsoLayoutEffect(() => {
+			if (isControlled && !Object.is(this.state[key], controlled)) super.update({
+				...this.state,
+				[key]: controlled
+			});
+		}, [
+			key,
+			controlled,
+			defaultValue,
+			isControlled
+		]);
+	}
+	/**
+	* Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
+	* If the key is controlled (registered via {@link useControlledProp} with a non-undefined value),
+	* the update is ignored and no listeners are notified.
+	*
+	* @param key The state key to update.
+	* @param value The new value to set for the specified key.
+	*/
+	set(key, value) {
+		if (this.controlledValues.get(key) === true) return;
+		super.set(key, value);
+	}
+	/**
+	* Merges the provided changes into the current state and notifies listeners if there are changes.
+	* Controlled keys are filtered out and not updated.
+	*
+	* @param values An object containing the changes to apply to the current state.
+	*/
+	apply(values) {
+		const newValues = { ...values };
+		for (const key in newValues) if (this.controlledValues.get(key) === true) delete newValues[key];
+		super.apply(newValues);
+	}
+	/**
+	* Updates the entire store's state and notifies all registered listeners.
+	* Controlled keys are left unchanged; only uncontrolled keys from `newState` are applied.
+	*
+	* @param newState The new state to set for the store.
+	*/
+	update(newState) {
+		const newValues = { ...newState };
+		for (const key in newValues) if (this.controlledValues.get(key) === true) delete newValues[key];
+		super.update({
+			...this.state,
+			...newValues
+		});
+	}
+	/**
+	* 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) {
+		if (!this.selectors) throw new Error("Base UI: selectors are required to call useState.");
+		return useStore(this, this.selectors[key]);
+	}
+	/**
+	* Wraps a function with `useEventCallback` 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) {
+		const stableFunction = useEventCallback(fn !== null && fn !== void 0 ? 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.
+	*/
+	getElementSetter(key) {
+		return React$1.useCallback((element) => {
+			this.set(key, element);
+		}, [key]);
+	}
+};
+//#endregion
+//#region ../../node_modules/@base-ui-components/react/esm/dialog/store.js
+var selectors = {
+	open: createSelector((state) => state.open),
+	modal: createSelector((state) => state.modal),
+	nested: createSelector((state) => state.nested),
+	nestedOpenDialogCount: createSelector((state) => state.nestedOpenDialogCount),
+	dismissible: createSelector((state) => state.dismissible),
+	openMethod: createSelector((state) => state.openMethod),
+	descriptionElementId: createSelector((state) => state.descriptionElementId),
+	titleElementId: createSelector((state) => state.titleElementId),
+	mounted: createSelector((state) => state.mounted),
+	transitionStatus: createSelector((state) => state.transitionStatus),
+	triggerProps: createSelector((state) => state.triggerProps),
+	popupProps: createSelector((state) => state.popupProps),
+	floatingRootContext: createSelector((state) => state.floatingRootContext),
+	popupElement: createSelector((state) => state.popupElement),
+	triggerElement: createSelector((state) => state.triggerElement)
+};
+var DialogStore = class DialogStore extends ReactStore {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "setOpen", (nextOpen, eventDetails) => {
+			var _this$context$openCha, _this$context, _this$state$floatingR;
+			(_this$context$openCha = (_this$context = this.context).openChange) === null || _this$context$openCha === void 0 || _this$context$openCha.call(_this$context, nextOpen, eventDetails);
+			if (eventDetails.isCanceled) return;
+			const details = {
+				open: nextOpen,
+				nativeEvent: eventDetails.event,
+				reason: eventDetails.reason,
+				nested: this.state.nested
+			};
+			(_this$state$floatingR = this.state.floatingRootContext.events) === null || _this$state$floatingR === void 0 || _this$state$floatingR.emit("openchange", details);
+			this.set("open", nextOpen);
+		});
+	}
+	static create(initialState) {
+		return new DialogStore(initialState, {
+			popupRef: /* @__PURE__ */ React$1.createRef(),
+			backdropRef: /* @__PURE__ */ React$1.createRef(),
+			internalBackdropRef: /* @__PURE__ */ React$1.createRef()
+		}, selectors);
+	}
+};
+//#endregion
+export { useDialogRoot as n, DialogStore as t };