//#region node_modules/.pnpm/nanostores@1.0.1/node_modules/nanostores/clean-stores/index.js
let clean = Symbol("clean");

//#endregion
//#region node_modules/.pnpm/nanostores@1.0.1/node_modules/nanostores/atom/index.js
var listenerQueue = [];
var lqIndex = 0;
var QUEUE_ITEMS_PER_LISTENER = 4;
let epoch = 0;
let atom = (initialValue) => {
	let listeners = [];
	let $atom = {
		get() {
			if (!$atom.lc) $atom.listen(() => {})();
			return $atom.value;
		},
		lc: 0,
		listen(listener) {
			$atom.lc = listeners.push(listener);
			return () => {
				for (let i = lqIndex + QUEUE_ITEMS_PER_LISTENER; i < listenerQueue.length;) if (listenerQueue[i] === listener) listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
				else i += QUEUE_ITEMS_PER_LISTENER;
				let index = listeners.indexOf(listener);
				if (~index) {
					listeners.splice(index, 1);
					if (!--$atom.lc) $atom.off();
				}
			};
		},
		notify(oldValue, changedKey) {
			epoch++;
			let runListenerQueue = !listenerQueue.length;
			for (let listener of listeners) listenerQueue.push(listener, $atom.value, oldValue, changedKey);
			if (runListenerQueue) {
				for (lqIndex = 0; lqIndex < listenerQueue.length; lqIndex += QUEUE_ITEMS_PER_LISTENER) listenerQueue[lqIndex](listenerQueue[lqIndex + 1], listenerQueue[lqIndex + 2], listenerQueue[lqIndex + 3]);
				listenerQueue.length = 0;
			}
		},
		off() {},
		set(newValue) {
			let oldValue = $atom.value;
			if (oldValue !== newValue) {
				$atom.value = newValue;
				$atom.notify(oldValue);
			}
		},
		subscribe(listener) {
			let unbind = $atom.listen(listener);
			listener($atom.value);
			return unbind;
		},
		value: initialValue
	};
	$atom[clean] = () => {
		listeners = [];
		$atom.lc = 0;
		$atom.off();
	};
	return $atom;
};

//#endregion
//#region node_modules/.pnpm/nanostores@1.0.1/node_modules/nanostores/lifecycle/index.js
var MOUNT = 5;
var UNMOUNT = 6;
var REVERT_MUTATION = 10;
let on = (object, listener, eventKey, mutateStore) => {
	object.events = object.events || {};
	if (!object.events[eventKey + REVERT_MUTATION]) object.events[eventKey + REVERT_MUTATION] = mutateStore((eventProps) => {
		object.events[eventKey].reduceRight((event, l) => (l(event), event), {
			shared: {},
			...eventProps
		});
	});
	object.events[eventKey] = object.events[eventKey] || [];
	object.events[eventKey].push(listener);
	return () => {
		let currentListeners = object.events[eventKey];
		let index = currentListeners.indexOf(listener);
		currentListeners.splice(index, 1);
		if (!currentListeners.length) {
			delete object.events[eventKey];
			object.events[eventKey + REVERT_MUTATION]();
			delete object.events[eventKey + REVERT_MUTATION];
		}
	};
};
let STORE_UNMOUNT_DELAY = 1e3;
let onMount = ($store, initialize) => {
	let listener = (payload) => {
		let destroy = initialize(payload);
		if (destroy) $store.events[UNMOUNT].push(destroy);
	};
	return on($store, listener, MOUNT, (runListeners) => {
		let originListen = $store.listen;
		$store.listen = (...args) => {
			if (!$store.lc && !$store.active) {
				$store.active = true;
				runListeners();
			}
			return originListen(...args);
		};
		let originOff = $store.off;
		$store.events[UNMOUNT] = [];
		$store.off = () => {
			originOff();
			setTimeout(() => {
				if ($store.active && !$store.lc) {
					$store.active = false;
					for (let destroy of $store.events[UNMOUNT]) destroy();
					$store.events[UNMOUNT] = [];
				}
			}, STORE_UNMOUNT_DELAY);
		};
		{
			let originClean = $store[clean];
			$store[clean] = () => {
				for (let destroy of $store.events[UNMOUNT]) destroy();
				$store.events[UNMOUNT] = [];
				$store.active = false;
				originClean();
			};
		}
		return () => {
			$store.listen = originListen;
			$store.off = originOff;
		};
	});
};

//#endregion
//#region node_modules/.pnpm/nanostores@1.0.1/node_modules/nanostores/map/index.js
let map = (initial = {}) => {
	let $map = atom(initial);
	$map.setKey = function(key, value) {
		let oldMap = $map.value;
		if (typeof value === "undefined" && key in $map.value) {
			$map.value = { ...$map.value };
			delete $map.value[key];
			$map.notify(oldMap, key);
		} else if ($map.value[key] !== value) {
			$map.value = {
				...$map.value,
				[key]: value
			};
			$map.notify(oldMap, key);
		}
	};
	return $map;
};

//#endregion
//#region node_modules/.pnpm/@nanostores+persistent@1.1.0_nanostores@1.0.1/node_modules/@nanostores/persistent/index.js
var identity = (a) => a;
var storageEngine = {};
var eventsEngine = {
	addEventListener() {},
	removeEventListener() {}
};
function testSupport() {
	try {
		return typeof localStorage !== "undefined";
	} catch {
		return false;
	}
}
if (testSupport()) storageEngine = localStorage;
let windowPersistentEvents = {
	addEventListener(key, listener, restore) {
		window.addEventListener("storage", listener);
		window.addEventListener("pageshow", restore);
	},
	removeEventListener(key, listener, restore) {
		window.removeEventListener("storage", listener);
		window.removeEventListener("pageshow", restore);
	}
};
if (typeof window !== "undefined") eventsEngine = windowPersistentEvents;
function setPersistentEngine(storage, events) {
	storageEngine = storage;
	eventsEngine = events;
}
function persistentAtom(name, initial = void 0, opts = {}) {
	let encode = opts.encode || identity;
	let decode = opts.decode || identity;
	let store = atom(initial);
	let set = store.set;
	store.set = (newValue) => {
		let converted = encode(newValue);
		if (typeof converted === "undefined") delete storageEngine[name];
		else storageEngine[name] = converted;
		set(newValue);
	};
	function listener(e) {
		if (e.key === name) if (e.newValue === null) set(initial);
		else set(decode(e.newValue));
		else if (!storageEngine[name]) set(initial);
	}
	function restore() {
		store.set(storageEngine[name] ? decode(storageEngine[name]) : initial);
	}
	onMount(store, () => {
		restore();
		if (opts.listen !== false) {
			eventsEngine.addEventListener(name, listener, restore);
			return () => {
				eventsEngine.removeEventListener(name, listener, restore);
			};
		}
	});
	return store;
}
function persistentMap(prefix, initial = {}, opts = {}) {
	let encode = opts.encode || identity;
	let decode = opts.decode || identity;
	let store = map();
	let setKey = store.setKey;
	let storeKey = (key, newValue) => {
		if (typeof newValue === "undefined") {
			if (opts.listen !== false && eventsEngine.perKey) eventsEngine.removeEventListener(prefix + key, listener, restore);
			delete storageEngine[prefix + key];
		} else {
			if (opts.listen !== false && eventsEngine.perKey && !(key in store.value)) eventsEngine.addEventListener(prefix + key, listener, restore);
			storageEngine[prefix + key] = encode(newValue);
		}
	};
	store.setKey = (key, newValue) => {
		storeKey(key, newValue);
		setKey(key, newValue);
	};
	let set = store.set;
	store.set = function(newObject) {
		for (let key in newObject) storeKey(key, newObject[key]);
		for (let key in store.value) if (!(key in newObject)) storeKey(key, void 0);
		set(newObject);
	};
	function listener(e) {
		if (!e.key) set({});
		else if (e.key.startsWith(prefix)) if (e.newValue === null) setKey(e.key.slice(prefix.length), void 0);
		else setKey(e.key.slice(prefix.length), decode(e.newValue));
	}
	function restore() {
		let data = { ...initial };
		for (let key in storageEngine) if (key.startsWith(prefix)) data[key.slice(prefix.length)] = decode(storageEngine[key]);
		for (let key in data) store.setKey(key, data[key]);
	}
	onMount(store, () => {
		restore();
		if (opts.listen !== false) {
			eventsEngine.addEventListener(prefix, listener, restore);
			return () => {
				eventsEngine.removeEventListener(prefix, listener, restore);
				for (let key in store.value) eventsEngine.removeEventListener(prefix + key, listener, restore);
			};
		}
	});
	return store;
}
var testStorage = {};
var testListeners = [];
function useTestStorageEngine() {
	setPersistentEngine(testStorage, {
		addEventListener(key, cb) {
			testListeners.push(cb);
		},
		removeEventListener(key, cb) {
			testListeners = testListeners.filter((i) => i !== cb);
		}
	});
}
function setTestStorageKey(key, newValue) {
	if (typeof newValue === "undefined") delete testStorage[key];
	else testStorage[key] = newValue;
	let event = {
		key,
		newValue
	};
	for (let listener of testListeners) listener(event);
}
function getTestStorage() {
	return testStorage;
}
function cleanTestStorage() {
	for (let i in testStorage) setTestStorageKey(i, void 0);
}

//#endregion
export { cleanTestStorage, getTestStorage, persistentAtom, persistentMap, setPersistentEngine, setTestStorageKey, useTestStorageEngine, windowPersistentEvents };
//# sourceMappingURL=@nanostores_persistent.js.map