import { r as requireReact } from "./index-DQGM2Mpm.js";
import { X as requireShim } from "./index-Bs--Ol2m.js";

var withSelector = { exports: {} };

var withSelector_production = {};

/**
 * @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 hasRequiredWithSelector_production;

function requireWithSelector_production() {
	if (hasRequiredWithSelector_production) return withSelector_production;
	hasRequiredWithSelector_production = 1;
	var React = requireReact(),
		shim = requireShim();
	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;
	withSelector_production.useSyncExternalStoreWithSelector = function (subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
		var instRef = useRef(null);
		if (null === instRef.current) {
			var inst = { hasValue: false, value: null };
			instRef.current = inst;
		} else inst = instRef.current;
		instRef = useMemo(
			function () {
				function memoizedSelector(nextSnapshot) {
					if (!hasMemo) {
						hasMemo = true;
						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 = false,
					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 = true;
				inst.value = value;
			},
			[value],
		);
		useDebugValue(value);
		return value;
	};
	return withSelector_production;
}

var hasRequiredWithSelector;

function requireWithSelector() {
	if (hasRequiredWithSelector) return withSelector.exports;
	hasRequiredWithSelector = 1;
	{
		withSelector.exports = requireWithSelector_production();
	}
	return withSelector.exports;
}

var withSelectorExports = requireWithSelector();

export { withSelectorExports as w };