@oscarpalmer/mora 0.30.0 → 0.32.0

package/dist/mora.full.mjs

@@ -3,7 +3,7 @@ const ACTIVE = {};
 const BATCH = {
 	depth: 0,
 	flushing: false,
-	handlers: /* @__PURE__ */ new Set()
+	handlers: /* @__PURE__ */ new Map()
 };
 const METHODS_AFFECTING_LENGTH = /* @__PURE__ */ new Set([
 	"pop",
@@ -23,14 +23,31 @@ const NAME_ARRAY = "array";
 const NAME_COMPUTED = "computed";
 const NAME_EFFECT = "effect";
 const NAME_MORA = "$mora";
+const NAME_READONLY = "readonly";
 const NAME_SIGNAL = "signal";
 const NAME_STORE = "store";
+const NAME_SUBSCRIPTION = "subscription";
 const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_ARRAY,
 	NAME_COMPUTED,
+	NAME_READONLY,
 	NAME_SIGNAL,
 	NAME_STORE
 ]);
+const SUBSCRIPTION_PROPERTY$1 = {
+	key: NAME_MORA,
+	value: NAME_SUBSCRIPTION
+};
+const SUBSCRIPTION_TYPE_COPY = "copy";
+const SUBSCRIPTION_TYPE_FROZEN = "frozen";
+const SUBSCRIPTION_TYPE_ORIGINAL = "original";
+const SUBSCRIPTION_TYPE_READONLY = "readonly";
+const SUBSCRIPTION_TYPES_COPY = /* @__PURE__ */ new Set([SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_READONLY]);
+const SUBSCRIPTION_TYPES = /* @__PURE__ */ new Set([
+	...SUBSCRIPTION_TYPES_COPY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPE_ORIGINAL
+]);
 //#endregion
 //#region src/effect.ts
 /**
@@ -45,7 +62,7 @@ function effect(callback) {
 }
 function getEffect(callback) {
 	const state = { callback };
-	const instance = Object.freeze({ $mora: NAME_EFFECT });
+	const instance = Object.freeze({ [NAME_MORA]: NAME_EFFECT });
 	runEffect(state);
 	return [instance, state];
 }
@@ -62,6 +79,98 @@ function runEffect(state) {
 	}
 }
 //#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
+/**
+* Is the value a _Key_?
+*
+* @param value Value to check
+* @returns `true` if the value is a _Key_ _(`number` or `string`)_, otherwise `false`
+*/
+function isKey(value) {
+	return typeof value === "number" || typeof value === "string";
+}
+/**
+* Is the value a plain object?
+*
+* @param value Value to check
+* @returns `true` if the value is a plain object, otherwise `false`
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+//#endregion
+//#region src/helpers/value.ts
+function emitValue(state) {
+	for (const computed of state.computeds) computed.dirty = true;
+	for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	for (const type of SUBSCRIPTION_TYPES) {
+		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
+		if (subscriptions != null) for (const [subscription, callback] of subscriptions) BATCH.handlers.set(subscription, {
+			callback,
+			state,
+			frozen: type === SUBSCRIPTION_TYPE_FROZEN,
+			copy: SUBSCRIPTION_TYPES_COPY.has(type)
+		});
+	}
+	if (BATCH.depth === 0) flushHandlers();
+}
+function equalArrays(state, first, second) {
+	let { length } = first;
+	if (length !== second.length) return false;
+	let offset = 0;
+	if (length >= 100) {
+		offset = Math.round(length / 10);
+		offset = offset > 25 ? 25 : offset;
+		for (let index = 0; index < offset; index += 1) if (!state.equal(first[index], second[index])) return false;
+	}
+	length -= offset;
+	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
+	return true;
+}
+function getFrozenValue(value) {
+	let frozen = value;
+	if (Array.isArray(frozen)) frozen = Object.freeze(frozen.slice());
+	else if (isPlainObject(frozen)) frozen = Object.freeze({ ...frozen });
+	return frozen;
+}
+function getSimpleValue(state) {
+	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
+	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
+	return state.value;
+}
+function handleSimpleValue(state, origin, setValue, onAfter) {
+	try {
+		let actual = typeof origin === "function" ? origin() : origin;
+		if (actual instanceof Promise) {
+			state.promise = actual;
+			actual.then((value) => {
+				if (actual === state.promise) {
+					state.promise = void 0;
+					setValue(state, value);
+				}
+			}).catch(() => {
+				if (actual === state.promise) state.promise = void 0;
+			});
+		} else setValue(state, actual);
+	} catch {} finally {
+		onAfter?.();
+	}
+}
+function peekSimpleValue(value, copy) {
+	let peeked = value;
+	if (!copy) return peeked;
+	if (Array.isArray(peeked)) peeked = peeked.slice();
+	else if (isPlainObject(peeked)) peeked = { ...peeked };
+	return peeked;
+}
+function updateSimpleValue(state, callback, setValue) {
+	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+	handleSimpleValue(state, callback(state.value), setValue);
+}
+//#endregion
 //#region src/batch.ts
 function flushHandlers() {
 	if (BATCH.flushing) return;
@@ -72,8 +181,9 @@ function flushHandlers() {
 			const { length } = handlers;
 			BATCH.handlers.clear();
 			for (let index = 0; index < length; index += 1) {
-				const handler = handlers[index];
-				if (typeof handler.destroy === "function") handler.callback(handler.state.value);
+				const [, handler] = handlers[index];
+				const subscription = handler;
+				if (typeof subscription.frozen === "boolean") subscription.callback(subscription.frozen ? getFrozenValue(subscription.state.value) : peekSimpleValue(subscription.state.value, subscription.copy));
 				else runEffect(handler);
 			}
 		}
@@ -99,15 +209,6 @@ function stopBatch() {
 //#endregion
 //#region src/helpers/is.ts
 /**
-* Is the value a reactive array?
-*
-* @param value Value to check
-* @returns True if value is a {@link ReactiveArray}
-*/
-function isArray(value) {
-	return isMora(value, NAME_ARRAY);
-}
-/**
 * Is the value a computed signal?
 *
 * @param value Value to check
@@ -146,6 +247,33 @@ function isReactive(value) {
 function isSignal(value) {
 	return isMora(value, NAME_SIGNAL);
 }
+/**
+* Is the value a reactive array?
+*
+* @param value Value to check
+* @returns True if value is a {@link ReactiveArray}
+*/
+function isReactiveArray(value) {
+	return isMora(value, NAME_ARRAY);
+}
+/**
+* Is the value a reactive store?
+*
+* @param value Value to check
+* @returns True if value is a {@link Store}
+*/
+function isReactiveStore(value) {
+	return isMora(value, NAME_STORE);
+}
+/**
+* Is the value a readonly signal?
+*
+* @param value Value to check
+* @returns True if value is a {@link ReadonlySignal}
+*/
+function isReadonlySignal(value) {
+	return isMora(value, NAME_READONLY);
+}
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/internal/array/callbacks.mjs
 function getArrayCallback(value) {
@@ -153,6 +281,7 @@ function getArrayCallback(value) {
 		case "function": return value;
 		case "number":
 		case "string": return typeof value === "string" && value.includes(".") ? void 0 : (obj) => obj[value];
+		default: return;
 	}
 }
 function getArrayCallbacks(bool, key, value) {
@@ -164,10 +293,18 @@ function getArrayCallbacks(bool, key, value) {
 }
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/internal/array/find.mjs
+function createFindParameters(original) {
+	const { length } = original;
+	return {
+		bool: length === 1 && typeof original[0] === "function" ? original[0] : void 0,
+		key: length === 2 ? original[0] : void 0,
+		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
+	};
+}
 function findValue(type, array, parameters, reversed) {
 	const findIndex = type === FIND_VALUE_INDEX;
 	if (!Array.isArray(array) || array.length === 0) return findIndex ? -1 : void 0;
-	const { bool, key, value } = getFindParameters(parameters);
+	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
 	if (callbacks?.bool == null && callbacks?.keyed == null) {
 		if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
@@ -194,18 +331,22 @@ function findValues(type, array, parameters, mapper) {
 	};
 	if (!Array.isArray(array) || array.length === 0) return result;
 	const { length } = array;
-	const { bool, key, value } = getFindParameters(parameters);
+	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && length >= UNIQUE_THRESHOLD) {
+	if (type === "unique" && callbacks?.keyed == null && length >= FIND_UNIQUE_THRESHOLD) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
-	const mapCallback = getArrayCallback(mapper);
+	const mapCallback = getArrayCallback(mapper?.callback);
+	const mapReverse = mapper?.reverse ?? false;
+	const mapAfter = mapCallback == null ? void 0 : mapReverse ? void 0 : mapCallback;
+	const mapBefore = mapCallback == null ? void 0 : mapReverse ? mapCallback : void 0;
 	if (callbacks?.bool != null || type === "all" && key == null) {
 		const callback = callbacks?.bool ?? ((item) => Object.is(item, value));
 		for (let index = 0; index < length; index += 1) {
 			const item = array[index];
-			if (callback(item, index, array)) result.matched.push(mapCallback?.(item, index, array) ?? item);
+			const transformed = mapBefore?.(item, index, array) ?? item;
+			if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
 			else result.notMatched.push(item);
 		}
 		return result;
@@ -213,71 +354,64 @@ function findValues(type, array, parameters, mapper) {
 	const keys = /* @__PURE__ */ new Set();
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
-		const keyed = callbacks?.keyed?.(item, index, array) ?? item;
+		let keyed;
+		let transformed;
+		if (mapBefore == null) {
+			keyed = callbacks?.keyed?.(item, index, array) ?? item;
+			transformed = item;
+		} else {
+			transformed = mapBefore(item, index, array);
+			keyed = callbacks?.keyed?.(transformed, index, array) ?? transformed;
+		}
 		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
 			keys.add(keyed);
-			result.matched.push(mapCallback?.(item, index, array) ?? item);
+			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
 		} else result.notMatched.push(item);
 	}
 	return result;
 }
-function getFindParameters(original) {
-	const { length } = original;
-	return {
-		bool: length === 1 && typeof original[0] === "function" ? original[0] : void 0,
-		key: length === 2 ? original[0] : void 0,
-		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
-	};
-}
 const FIND_VALUE_INDEX = "index";
 const FIND_VALUE_ITEM = "item";
-const UNIQUE_THRESHOLD = 100;
+const FIND_UNIQUE_THRESHOLD = 100;
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/internal/array/index-of.mjs
 function indexOf(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, false);
 }
-indexOf.last = lastIndexOf;
 function lastIndexOf(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, true);
 }
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
-/**
-* Is the value a _Key_?
-*
-* @param value Value to check
-* @returns `true` if the value is a _Key_ _(`number` or `string`)_, otherwise `false`
-*/
-function isKey(value) {
-	return typeof value === "number" || typeof value === "string";
-}
-/**
-* Is the value a plain object?
-*
-* @param value Value to check
-* @returns `true` if the value is a plain object, otherwise `false`
-*/
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
-}
+indexOf.last = lastIndexOf;
+Object.defineProperty(indexOf, "last", { value: lastIndexOf });
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/array/find.mjs
 function find(array, ...parameters) {
 	return findValue(FIND_VALUE_ITEM, array, parameters, false);
 }
-find.last = findLast;
 function findLast(array, ...parameters) {
 	return findValue(FIND_VALUE_ITEM, array, parameters, true);
 }
+find.last = findLast;
+Object.defineProperty(find, "last", { value: findLast });
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/array/select.mjs
+function reverseSelect(array, ...parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.shift(),
+		reverse: true
+	}).matched;
+}
 function select(array, ...parameters) {
-	return findValues("all", array, parameters, parameters.pop()).matched;
+	return selectValues(array, parameters);
 }
+function selectValues(array, parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.pop(),
+		reverse: false
+	}).matched;
+}
+select.reverse = reverseSelect;
+Object.defineProperty(select, "reverse", { value: reverseSelect });
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/array/filter.mjs
 function exclude(array, ...parameters) {
@@ -287,81 +421,221 @@ function filter(array, ...parameters) {
 	return findValues("all", array, parameters).matched;
 }
 filter.remove = exclude;
+Object.defineProperty(filter, "remove", { value: exclude });
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/function/misc.mjs
-/**
-* A function that does nothing, which can be useful, I guess…
-*/
-function noop$1() {}
-//#endregion
-//#region src/helpers/value.ts
-function emitValue(state) {
-	for (const computed of state.computeds) computed.dirty = true;
-	for (const effect of state.effects) BATCH.handlers.add(effect);
-	for (const [, subscription] of state.subscriptions) BATCH.handlers.add(subscription);
-	if (BATCH.depth === 0) flushHandlers();
+//#region node_modules/@oscarpalmer/atoms/dist/internal/abort.mjs
+function createAborter(value, onAbort) {
+	if (!(value instanceof AbortSignal)) return;
+	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);
+	return {
+		callback: onAbort,
+		signal: value,
+		cancel: () => value.removeEventListener(ABORT_EVENT, onAbort)
+	};
 }
-function equalArrays(state, first, second) {
-	let { length } = first;
-	if (length !== second.length) return false;
-	let offset = 0;
-	if (length >= 100) {
-		offset = Math.round(length / 10);
-		offset = offset > 25 ? 25 : offset;
-		for (let index = 0; index < offset; index += 1) if (!state.equal(first[index], second[index])) return false;
+const ABORT_EVENT = "abort";
+const ABORT_OPTIONS = { once: true };
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/subscription.mjs
+function addSubscription(subscriptions, subscription, state) {
+	const { items, values } = subscriptions;
+	const { key, value } = state.parameters;
+	if (!isKey(key)) {
+		items.any.add(subscription);
+		values.from.any.set(value, subscription);
+		values.to.any.set(subscription, value);
+		return;
 	}
-	length -= offset;
-	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
-	return true;
+	/* istanbul ignore if */
+	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
+ // istanbul ignore next
+	return;
+	let keyedItems = items.keyed.get(key);
+	if (keyedItems == null) {
+		keyedItems = /* @__PURE__ */ new Set();
+		items.keyed.set(key, keyedItems);
+	}
+	keyedItems.add(subscription);
+	let keyedFrom = values.from.keyed.get(key);
+	if (keyedFrom == null) {
+		keyedFrom = /* @__PURE__ */ new Map();
+		values.from.keyed.set(key, keyedFrom);
+	}
+	keyedFrom.set(value, subscription);
+	let keyedTo = values.to.keyed.get(key);
+	if (keyedTo == null) {
+		keyedTo = /* @__PURE__ */ new Map();
+		values.to.keyed.set(key, keyedTo);
+	}
+	keyedTo.set(subscription, value);
 }
-function getSimpleValue(state) {
-	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
-	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
-	return state.value;
+function clearSubscriptions(store) {
+	for (const susbcription of store.values.to.any.keys()) susbcription.unsubscribe();
+	if (store.values.to.keyed != null) for (const values of store.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
 }
-function handleSimpleValue(state, origin, setValue, onAfter) {
-	try {
-		let actual = typeof origin === "function" ? origin() : origin;
-		if (actual instanceof Promise) {
-			state.promise = actual;
-			actual.then((value) => {
-				if (actual === state.promise) {
-					state.promise = void 0;
-					setValue(state, value);
-				}
-			}).catch(() => {
-				if (actual === state.promise) state.promise = void 0;
-			});
-		} else setValue(state, actual);
-	} catch {} finally {
-		onAfter?.();
+function createSubscription(subscriptions, property, params) {
+	const parameters = createSubscriptionParameters(params);
+	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
+	const state = {
+		parameters,
+		active: true
+	};
+	const existing = getExistingSubscription(subscriptions, state);
+	if (existing != null) return [existing, true];
+	if (subscriptions.keys != null && isKey(parameters.key)) {
+		if (subscriptions.keys === false) throw new Error(SUBSCRIPTION_DISALLOWED_KEY);
+		else if (subscriptions.keys !== true && !subscriptions.keys.has(parameters.key)) throw new Error(SUBSCRIPTION_INVALID_KEY);
 	}
+	state.aborter = createAborter(parameters.signal, () => unsubscribe(subscriptions, instance, state));
+	const instance = { unsubscribe: () => unsubscribe(subscriptions, instance, state) };
+	Object.defineProperties(instance, {
+		[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_NAME },
+		[property.key]: { value: property.value },
+		active: {
+			enumerable: true,
+			get: () => (parameters.isActive?.() ?? true) && state.active
+		}
+	});
+	addSubscription(subscriptions, instance, state);
+	return [Object.freeze(instance), false];
 }
-//#endregion
-//#region src/subscription.ts
-function noop() {}
-function subscribe(state, callback) {
-	if (typeof callback !== "function" || state.subscriptions.has(callback)) return noop;
-	state.subscriptions.set(callback, subscription(state, callback));
-	return () => {
-		unsubscribe(state, callback);
+function getExistingSubscription(subscriptions, state) {
+	const { values } = subscriptions;
+	const { parameters } = state;
+	return isKey(parameters.key) ? values.from.keyed?.get(parameters.key)?.get(parameters.value) : values.from.any.get(parameters.value);
+}
+function createSubscriptionParameters(input) {
+	const values = isPlainObject(input) ? input : {};
+	if (values.value == null) throw new Error(SUBSCRIPTION_INVALID_VALUE);
+	return {
+		isActive: typeof values.isActive === "function" ? values.isActive : void 0,
+		key: isKey(values.key) ? values.key : void 0,
+		signal: values.signal instanceof AbortSignal ? values.signal : void 0,
+		value: values.value
 	};
 }
-function subscription(state, callback) {
-	const instance = {
-		callback,
-		state,
-		destroy: () => {
-			instance.callback = noop;
-			instance.state = void 0;
+function createSubscriptionsParameters(input) {
+	const values = isPlainObject(input) ? input : {};
+	let keys;
+	if (values.keys instanceof Set) keys = values.keys;
+	else keys = typeof values.keys === "boolean" ? values.keys : false;
+	return {
+		keys,
+		property: createSubscriptionsProperty(values.property)
+	};
+}
+function createSubscriptionsProperty(input) {
+	const values = isPlainObject(input) ? input : {};
+	return {
+		key: typeof values.key === "string" ? values.key : SUBSCRIPTION_PROPERTY,
+		value: values.value == null ? SUBSCRIPTION_NAME : values.value
+	};
+}
+function createSubscriptionsState(keys) {
+	return {
+		keys,
+		items: {
+			any: /* @__PURE__ */ new Set(),
+			keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
+		},
+		values: {
+			from: {
+				any: /* @__PURE__ */ new Map(),
+				keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
+			},
+			to: {
+				any: /* @__PURE__ */ new Map(),
+				keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
+			}
 		}
 	};
-	callback(state.value);
-	return instance;
 }
-function unsubscribe(state, callback) {
-	state.subscriptions.get(callback)?.destroy();
-	state.subscriptions.delete(callback);
+function removeFromStore(items, values, subscription, value, key) {
+	items.delete(subscription);
+	if (key == null) {
+		values.from.any.delete(value);
+		values.to.any.delete(subscription);
+	} else {
+		values.from.keyed?.get(key)?.delete(value);
+		values.to.keyed?.get(key)?.delete(subscription);
+	}
+}
+function removeSubscription(subscriptionsState, subscription, state) {
+	if (!state.active) return;
+	state.aborter = void 0;
+	state.active = false;
+	state.parameters.isActive = void 0;
+	state.parameters.signal = void 0;
+	const { items, values } = subscriptionsState;
+	const { key, value } = state.parameters;
+	if (!isKey(key)) {
+		removeFromStore(items.any, values, subscription, value);
+		return;
+	}
+	const keyed = items.keyed?.get(key);
+	/* istanbul ignore if */
+	if (items.keyed == null || keyed == null)
+ // istanbul ignore next
+	return;
+	removeFromStore(keyed, values, subscription, value, key);
+	if (keyed.size === 0) items.keyed.delete(key);
+}
+/**
+* Create a subscription store
+*
+* @param parameters Store parameters
+* @returns Subscription store
+*/
+function subscriptions(parameters) {
+	const { keys, property } = createSubscriptionsParameters(parameters);
+	const state = createSubscriptionsState(keys);
+	const instance = {
+		clear: () => clearSubscriptions(state),
+		create: (parameters) => createSubscription(state, property, parameters)
+	};
+	Object.defineProperties(instance, {
+		[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_STORE },
+		items: {
+			enumerable: true,
+			value: state.items
+		},
+		values: {
+			enumerable: true,
+			value: state.values
+		}
+	});
+	return Object.freeze(instance);
+}
+function unsubscribe(subscriptionsState, subscription, state) {
+	state.aborter?.cancel();
+	removeSubscription(subscriptionsState, subscription, state);
+}
+const SUBSCRIPTION_DISALLOWED_KEY = "Disallowed key for subscription";
+const SUBSCRIPTION_INVALID_KEY = "Invalid key for subscription";
+const SUBSCRIPTION_INVALID_VALUE = "A subscription requires a non-null value to identify it";
+const SUBSCRIPTION_NAME = "subscription";
+const SUBSCRIPTION_PROPERTY = "$subscriptions";
+const SUBSCRIPTION_STORE = "subscriptions";
+//#endregion
+//#region src/helpers/subscription.ts
+function subscribeToProxy(isArray, instance, state, mapped, first, second, third) {
+	if (isKey(first)) return getReactiveValueInProxy(instance, mapped, first, isArray).subscribe(second, third);
+	return subscribeToSignal(state, first, second === true);
+}
+function subscribeToReactive(type, state, callback) {
+	state.subscriptions ??= subscriptions({
+		keys: SUBSCRIPTION_TYPES,
+		property: SUBSCRIPTION_PROPERTY$1
+	});
+	const [subscription, existing] = state.subscriptions.create({
+		key: type,
+		value: callback
+	});
+	if (!existing) callback(type === "frozen" ? getFrozenValue(state.value) : peekSimpleValue(state.value, SUBSCRIPTION_TYPES_COPY.has(type)));
+	return subscription;
+}
+function subscribeToSignal(state, callback, copy) {
+	return subscribeToReactive(copy ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL, state, callback);
 }
 //#endregion
 //#region src/value/reactive.ts
@@ -370,7 +644,6 @@ function reactive(value, options) {
 		computeds: /* @__PURE__ */ new Set(),
 		effects: /* @__PURE__ */ new Set(),
 		equal: typeof options === "object" && typeof options?.equal === "function" ? options.equal : Object.is,
-		subscriptions: /* @__PURE__ */ new Map(),
 		value
 	};
 	return [{
@@ -391,21 +664,16 @@ function computed(callback, options) {
 	return getComputed(callback, options)[0];
 }
 function getComputed(callback, options) {
+	if (typeof callback !== "function") throw new TypeError("Computed callback must be a function");
 	const [rx, state] = reactive(void 0, options);
 	let fx;
 	const instance = {
 		...rx,
 		get: () => getValue(state, fx),
-		peek: () => state.value,
-		subscribe: (callback) => subscribe(state, callback),
-		unsubscribe: (callback) => {
-			state.subscriptions.delete(callback);
-		}
+		peek: (copy) => peekSimpleValue(state.value, copy === true),
+		subscribe: (callback, copy) => subscribeToSignal(state, callback, copy === true)
 	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		value: NAME_COMPUTED
-	});
+	Object.defineProperty(instance, NAME_MORA, { value: NAME_COMPUTED });
 	fx = getComputedEffect(state, callback);
 	return [Object.freeze(instance), fx];
 }
@@ -439,37 +707,56 @@ function setAndEmit$1(state, value) {
 	if (state.equal(state.value, value)) return;
 	state.value = value;
 	for (const computed of state.computeds) computed.dirty = true;
-	for (const effect of state.effects) BATCH.handlers.add(effect);
-	for (const [, subscription] of state.subscriptions) subscription.callback(value);
+	for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	for (const type of SUBSCRIPTION_TYPES) {
+		if (type === "frozen") continue;
+		const copy = SUBSCRIPTION_TYPES_COPY.has(type);
+		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
+		if (subscriptions != null) for (const [, callback] of subscriptions) callback(peekSimpleValue(state.value, copy));
+	}
 	flushHandlers();
 }
 //#endregion
 //#region src/helpers/proxy.ts
-function emityProxyValues(state, mapped) {
+function emitProxyValues(state, mapped) {
 	const values = [...mapped.values()];
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) values[index][1].dirty = true;
 	emitValue(state);
 }
 function getReactiveValueInProxy(reactive, mapped, key, isArray) {
-	let item = mapped.get(key);
+	const mapKey = String(key);
+	let item = mapped.get(mapKey);
 	if (item == null) {
 		item = internalComputed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
-		mapped.set(key, item);
+		mapped.set(mapKey, item);
 	}
 	return item[0];
 }
-function setProxyValue(array, state, isObject, isProperty, setObject, setProperty, first, second) {
-	if (array && first === "length") {
+function getValueInProxy(isArray, instance, state, mapped, first) {
+	if (isArray ? typeof first === "number" : isKey(first)) return getReactiveValueInProxy(instance, mapped, first, isArray).get();
+	return getSimpleValue(state);
+}
+function isProxyObject(isArray, value) {
+	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
+}
+function peekValueInProxy(isArray, state, first, second) {
+	let value;
+	if (isArray ? typeof first === "number" : isKey(first)) value = isArray ? state.value.at(first) : state.value[first];
+	else value = state.value;
+	return peekSimpleValue(value, first === true || second === true);
+}
+function setProxyValue(isArray, state, setObject, setProperty, first, second) {
+	if (isArray && first === "length") {
 		state.value.length = second;
 		return;
 	}
-	if (isObject(first)) {
+	if (isProxyObject(isArray, first)) {
 		setObject(state, first);
 		return;
 	}
-	const property = isProperty(first);
-	if (array && property && Number.isNaN(first)) return;
+	const property = isArray ? typeof first === "number" : isKey(first);
+	if (isArray && property && Number.isNaN(first)) return;
 	let actual = property ? second : first;
 	if (typeof actual === "function") try {
 		actual = actual();
@@ -487,7 +774,7 @@ function setProxyValue(array, state, isObject, isProperty, setObject, setPropert
 				setProperty(state, first, value);
 				return;
 			}
-			if (!property && isObject(value) && state.promise === actual) {
+			if (!property && isProxyObject(isArray, value) && state.promise === actual) {
 				state.promise = void 0;
 				setObject(state, value);
 			}
@@ -496,10 +783,9 @@ function setProxyValue(array, state, isObject, isProperty, setObject, setPropert
 			else if (!property && state.promise === actual) state.promise = void 0;
 		});
 	} else if (property) setProperty(state, first, actual);
-	else if (isObject(actual)) setObject(state, actual);
+	else if (isProxyObject(isArray, actual)) setObject(state, actual);
 }
-function setValueInProxy(parameters) {
-	const { isArray, length, property, state, target, value } = parameters;
+function setValueInProxy(isArray, state, target, property, value, length) {
 	if (isArray) {
 		if (!(!Number.isNaN(Number(property)) || property === "length")) return Reflect.set(target, property, value);
 	}
@@ -511,6 +797,39 @@ function setValueInProxy(parameters) {
 	}
 	return true;
 }
+function updateProxyValue(isArray, state, setObject, setProperty, callback) {
+	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+	setProxyValue(isArray, state, setObject, setProperty, callback(state.value));
+}
+//#endregion
+//#region src/value/readonly.ts
+function getReadonlyInstance(state, instances, frozen) {
+	const key = frozen ? "frozen" : "original";
+	instances[key] ??= getReadonlySignal(state, frozen);
+	return instances[key];
+}
+function getReadonlySignal(state, frozen) {
+	const type = frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY;
+	const instance = {
+		get: () => getReadonlyValue(state, false, frozen),
+		peek: (copy) => getReadonlyValue(state, true, frozen, copy),
+		subscribe: (callback) => subscribeToReactive(type, state, callback)
+	};
+	Object.defineProperties(instance, {
+		[NAME_MORA]: { value: NAME_READONLY },
+		frozen: {
+			enumerable: true,
+			value: frozen
+		}
+	});
+	return Object.freeze(instance);
+}
+function getReadonlyValue(state, peek, frozen, copy) {
+	let value;
+	if (peek) value = peekSimpleValue(state.value, copy === true);
+	else value = getSimpleValue(state);
+	return frozen ? getFrozenValue(value) : value;
+}
 //#endregion
 //#region src/value/signal.ts
 function setAndEmit(state, value) {
@@ -521,25 +840,17 @@ function setAndEmit(state, value) {
 }
 function signal(value, options) {
 	const [rx, state] = reactive(void 0, options);
+	const readonlies = {};
 	const instance = {
 		...rx,
+		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, frozen === true),
 		get: () => getSimpleValue(state),
-		peek: () => state.value,
-		set: (value) => {
-			handleSimpleValue(state, value, setAndEmit);
-		},
-		update: (callback) => {
-			handleSimpleValue(state, callback(state.value), setAndEmit);
-		},
-		subscribe: (callback) => subscribe(state, callback),
-		unsubscribe: (callback) => {
-			state.subscriptions.delete(callback);
-		}
+		peek: (copy) => peekSimpleValue(state.value, copy === true),
+		set: (value) => handleSimpleValue(state, value, setAndEmit),
+		subscribe: (callback, copy) => subscribeToSignal(state, callback, copy === true),
+		update: (callback) => updateSimpleValue(state, callback, setAndEmit)
 	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		value: NAME_SIGNAL
-	});
+	Object.defineProperty(instance, NAME_MORA, { value: NAME_SIGNAL });
 	handleSimpleValue(state, value, setAndEmit);
 	return Object.freeze(instance);
 }
@@ -547,25 +858,23 @@ function signal(value, options) {
 //#region src/value/array.ts
 function array(value, options) {
 	const [rx, state] = reactive([], options);
-	const indiced = /* @__PURE__ */ new Map();
+	const isArray = true;
 	const length = signal(0);
+	const mapped = /* @__PURE__ */ new Map();
+	const readonlies = {};
 	state.value = new Proxy([], {
 		get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(property, target, state, length) : Reflect.get(target, property),
-		set: (target, property, value) => setValueInProxy({
-			length,
-			property,
-			state,
-			target,
-			value,
-			isArray: true
-		})
+		set: (target, property, value) => setValueInProxy(isArray, state, target, property, value, length)
 	});
 	function get(value) {
-		return getArrayValue(instance, indiced, state, length, value);
+		return value === "length" ? length.get() : getValueInProxy(isArray, instance, state, mapped, value);
+	}
+	function set(first, second) {
+		setProxyValue(true, state, setArrayValue, setAtIndex, first, second);
 	}
 	const instance = {
 		...rx,
-		length: state.value.length,
+		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, frozen === true),
 		at: (index) => get(index),
 		clear: () => {
 			state.value.length = 0;
@@ -573,63 +882,38 @@ function array(value, options) {
 		filter: (callback) => computed(() => filter(get(), callback)),
 		get: (value) => get(value),
 		map: (callback) => computed(() => get().map(callback)),
-		notify: () => {
-			emityProxyValues(state, indiced);
-		},
-		peek: (value) => peekArrayValue(state, length, value),
+		notify: () => emitProxyValues(state, mapped),
+		peek: (first, second) => peekArrayValue(state, length, first, second),
 		pop: () => state.value.pop(),
 		push: (...items) => state.value.push(...items),
 		select: (filter, map) => computed(() => select(get(), filter, map)),
-		set: (first, second) => {
-			setProxyValue(true, state, isArrayValue, isArrayIndex, setArray, setAtIndex, first, second);
-		},
+		set: (first, second) => set(first, second),
 		shift: () => state.value.shift(),
 		splice: (from, to, ...items) => state.value.splice(from, to ?? state.value.length, ...items),
-		subscribe: (first, second) => {
-			if (typeof first === "number" && typeof second === "function") return getReactiveValueInProxy(instance, indiced, first, true).subscribe(second);
-			return typeof first === "function" ? subscribe(state, first) : noop$1;
-		},
+		subscribe: (first, second, third) => subscribeToProxy(isArray, instance, state, mapped, first, second, third),
 		unshift: (...items) => state.value.unshift(...items),
-		unsubscribe: (first, second) => {
-			if (typeof first === "number" && typeof second === "function") getReactiveValueInProxy(instance, indiced, first, true)?.unsubscribe(second);
-			else if (typeof first === "function") unsubscribe(state, first);
-		},
-		update: (callback) => updateArrayValue(instance, state, callback)
+		update: (callback) => updateProxyValue(true, state, setArrayValue, setAtIndex, callback)
 	};
 	Object.defineProperties(instance, {
-		[NAME_MORA]: {
-			enumerable: false,
-			value: NAME_ARRAY
-		},
+		[NAME_MORA]: { value: NAME_ARRAY },
 		length: {
 			enumerable: true,
 			get: () => length.get(),
 			set: (value) => setArrayLength(state, value)
 		}
 	});
-	instance.set(value);
+	set(value);
 	return Object.freeze(instance);
 }
-function getArrayValue(instance, indiced, state, length, first) {
-	if (typeof first === "number") return getReactiveValueInProxy(instance, indiced, first, true).get();
-	return first === "length" ? length.get() : getSimpleValue(state);
-}
-function isArrayIndex(value) {
-	return typeof value === "number";
+function peekArrayValue(state, length, first, second) {
+	return first === "length" ? length.peek() : peekValueInProxy(true, state, first, second);
 }
-function isArrayValue(value) {
-	return value == null || Array.isArray(value);
-}
-function peekArrayValue(state, length, value) {
-	if (value === "length") return length.peek();
-	return typeof value === "number" ? state.value.at(value) : state.value.slice();
+function setArrayLength(state, value) {
+	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== state.value.length) state.value.length = value;
 }
-function setArray(state, value) {
+function setArrayValue(state, value) {
 	state.value.splice(0, state.value.length, ...value ?? []);
 }
-function setArrayLength(state, value) {
-	if (typeof value === "number" && value >= 0 && value !== state.value.length) state.value.length = value;
-}
 function setAtIndex(state, index, value) {
 	const actual = index < 0 ? state.value.length + index : index;
 	if (actual > -1) state.value[actual] = value;
@@ -647,16 +931,12 @@ function updateArray(type, array, state, length) {
 		return result;
 	};
 }
-function updateArrayValue(instance, state, callback) {
-	const updated = callback(state.value);
-	if (updated == null || Array.isArray(updated)) instance.set(updated);
-}
 //#endregion
 //#region src/value/store.ts
-function isStoreObject(value) {
-	return value == null || isPlainObject(value);
+function setPropertyValue(state, key, value) {
+	state.value[key] = value;
 }
-function setObject(state, value) {
+function setStoreValue(state, value) {
 	startBatch();
 	const actual = value ?? {};
 	const proxy = state.value;
@@ -674,48 +954,25 @@ function setObject(state, value) {
 	}
 	stopBatch();
 }
-function setProperty(state, key, value) {
-	state.value[key] = value;
-}
 function store(value, options) {
 	const [rx, state] = reactive(void 0, options);
+	const isArray = false;
 	const keyed = /* @__PURE__ */ new Map();
-	state.value = new Proxy({}, { set: (target, property, value) => setValueInProxy({
-		target,
-		property,
-		state,
-		value,
-		isArray: false
-	}) });
+	const readonlies = {};
+	state.value = new Proxy({}, { set: (target, property, value) => setValueInProxy(isArray, state, target, property, value) });
 	const instance = {
 		...rx,
-		get: (value) => isKey(value) ? getReactiveValueInProxy(instance, keyed, value, false).get() : getSimpleValue(state),
-		notify() {
-			emityProxyValues(state, keyed);
-		},
-		peek: (value) => isKey(value) ? state.value[value] : { ...state.value },
-		set: (first, second) => {
-			setProxyValue(false, state, isStoreObject, isKey, setObject, setProperty, first, second);
-		},
-		subscribe: (first, second) => {
-			if (isKey(first) && typeof second === "function") return getReactiveValueInProxy(instance, keyed, first, false).subscribe(second);
-			return typeof first === "function" ? subscribe(state, first) : noop;
-		},
-		unsubscribe: (first, second) => {
-			if (isKey(first) && typeof second === "function") getReactiveValueInProxy(instance, keyed, first, false)?.unsubscribe(second);
-			else if (typeof first === "function") unsubscribe(state, first);
-		},
-		update: (callback) => {
-			const updated = callback(state.value);
-			if (updated == null || isPlainObject(updated)) setObject(state, updated);
-		}
+		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, frozen === true),
+		get: (value) => getValueInProxy(isArray, instance, state, keyed, value),
+		notify: () => emitProxyValues(state, keyed),
+		peek: (first, second) => peekValueInProxy(isArray, state, first, second),
+		set: (first, second) => setProxyValue(isArray, state, setStoreValue, setPropertyValue, first, second),
+		subscribe: (first, second, third) => subscribeToProxy(isArray, instance, state, keyed, first, second, third),
+		update: (callback) => updateProxyValue(isArray, state, setStoreValue, setPropertyValue, callback)
 	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		value: NAME_STORE
-	});
+	Object.defineProperty(instance, NAME_MORA, { value: NAME_STORE });
 	instance.set(value);
 	return Object.freeze(instance);
 }
 //#endregion
-export { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };
+export { array, computed, effect, isComputed, isEffect, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal, signal, startBatch, stopBatch, store };