@oscarpalmer/mora 0.37.0 → 0.39.0

package/dist/mora.full.mjs

@@ -1,10 +1,18 @@
-//#region src/constants.ts
+// src/constants.ts
 const ACTIVE = {};
 const BATCH = {
 	depth: 0,
 	flushing: false,
 	handlers: /* @__PURE__ */ new Map()
 };
+const MESSAGE_COMPUTED_CALLBACK = "Computed callback must be a function";
+const MESSAGE_DEACTIVATED_ARRAY_FILTER = "Cannot filter an inactive reactive array";
+const MESSAGE_DEACTIVATED_ARRAY_MAP = "Cannot map an inactive reactive array";
+const MESSAGE_DEACTIVATED_ARRAY_SELECT = "Cannot select from an inactive reactive array";
+const MESSAGE_DEACTIVATED_READONLY = "Cannot create readonly variant of inactive signal";
+const MESSAGE_DEACTIVATED_SUBSCRIPTION = "Cannot subscribe to inactive signal";
+const MESSAGE_EFFECT_CALLBACK = "Effect callback must be a function";
+const MESSAGE_UPDATE_CALLBACK = "Update callback must be a function";
 const METHODS_AFFECTING_LENGTH = /* @__PURE__ */ new Set([
 	"pop",
 	"push",
@@ -22,7 +30,6 @@ const METHODS_UPDATE = /* @__PURE__ */ new Set([
 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";
@@ -30,15 +37,15 @@ const NAME_SUBSCRIPTION = "subscription";
 const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_ARRAY,
 	NAME_COMPUTED,
-	NAME_READONLY,
 	NAME_SIGNAL,
 	NAME_STORE
 ]);
 const PROPERTY_LENGTH = "length";
 const SYMBOL_EFFECT = Symbol("effect");
+const SYMBOL_READONLY = Symbol("readonly");
 const SYMBOL_STATE = Symbol("state");
 const SUBSCRIPTION_PROPERTY$1 = {
-	key: NAME_MORA,
+	key: "$mora",
 	value: NAME_SUBSCRIPTION
 };
 const SUBSCRIPTION_TYPE_COPY = "copy";
@@ -51,13 +58,70 @@ const SUBSCRIPTION_TYPES = /* @__PURE__ */ new Set([
 	SUBSCRIPTION_TYPE_FROZEN,
 	SUBSCRIPTION_TYPE_ORIGINAL
 ]);
-//#endregion
-//#region src/effect.ts
+// 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 not a number?
+*
+* @param value Value to check
+* @returns `true` if the value is not a `number`, otherwise `false`
+*/
+function isNonNumber(value) {
+	return !isNumber(value);
+}
+/**
+* Is the value a number?
+*
+* @param value Value to check
+* @returns `true` if the value is a `number`, otherwise `false`
+*/
+function isNumber(value) {
+	return typeof value === "number" && !Number.isNaN(value);
+}
+/**
+* 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;
+}
+// node_modules/@oscarpalmer/atoms/dist/internal/function/misc.mjs
+/**
+* A function that does nothing, which can be useful, I guess…
+*/
+function noop() {}
+// src/effect.ts
 function Effect(callback) {
-	this[SYMBOL_STATE] = { callback };
+	this[SYMBOL_STATE] = {
+		callback,
+		active: true,
+		name: NAME_EFFECT
+	};
 	runEffect(this[SYMBOL_STATE]);
 }
-Effect.prototype[NAME_MORA] = NAME_EFFECT;
+Effect.prototype.stop = stopEffect;
+Object.defineProperties(Effect.prototype, { active: {
+	enumerable: true,
+	get: getActive
+} });
+function deactivateEffect(state) {
+	state.active = false;
+	state.callback = noop;
+	BATCH.handlers.delete(state);
+}
 /**
 * Create an effect
 *
@@ -65,9 +129,12 @@ Effect.prototype[NAME_MORA] = NAME_EFFECT;
 * @returns Effect
 */
 function effect(callback) {
-	if (typeof callback !== "function") throw new TypeError("Effect callback must be a function");
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_EFFECT_CALLBACK);
 	return getEffect(callback)[0];
 }
+function getActive() {
+	return this[SYMBOL_STATE].active;
+}
 function getEffect(callback) {
 	const instance = new Effect(callback);
 	return [instance, instance[SYMBOL_STATE]];
@@ -84,40 +151,145 @@ function runEffect(state) {
 		ACTIVE.effect = previousEffect;
 	}
 }
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
+function stopEffect() {
+	const state = this[SYMBOL_STATE];
+	if (state.active) deactivateEffect(state);
+}
+// node_modules/@oscarpalmer/atoms/dist/internal/string/misc.mjs
 /**
-* Is the value a _Key_?
+* Get the string value from any value
 *
-* @param value Value to check
-* @returns `true` if the value is a _Key_ _(`number` or `string`)_, otherwise `false`
+* @param value Original value
+* @returns String representation of the value
+*
+* @example
+* ```typescript
+* getString(null)       // => ''
+* getString('foo')      // => 'foo'
+* getString(123)        // => '123'
+* getString(true)       // => 'true'
+* getString([1, 2, 3])  // => '1,2,3'
+* getString({a: 1})     // => '{"a":1}'
+* getString(() => 123)  // => '123'
+* ```
 */
-function isKey(value) {
-	return typeof value === "number" || typeof value === "string";
-}
+function getString(value) {
+	if (typeof value === "string") return value;
+	if (value == null) return "";
+	if (typeof value === "function") return getString(value());
+	if (typeof value !== "object") return String(value);
+	const asString = String(value.valueOf?.() ?? value);
+	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
+}
+// node_modules/@oscarpalmer/atoms/dist/models/misc.model.mjs
+const EXPRESSION_NUMBER_BINARY = /^0b[01]+$/i;
+const EXPRESSION_NUMBER_OCTAL = /^0o[0-7]+$/i;
+const EXPRESSION_NUMBER_ZEROISH = /^\s*0+\s*$/;
+// node_modules/@oscarpalmer/atoms/dist/internal/math/misc.mjs
 /**
-* Is the value a plain object?
+* Round a number
 *
-* @param value Value to check
-* @returns `true` if the value is a plain object, otherwise `false`
+* @param value Number to round
+* @param decimals Number of decimal places to round to _(defaults to `0`)_
+* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*
+* @example
+* ```typescript
+* round(10.567, 2); // => 10.57
+* round(10.567);    // => 11
+* round('abc');       // => Number.NaN
+* ```
 */
-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;
+function round(value, decimals) {
+	return roundNumber(Math.round, value, decimals);
+}
+function roundNumber(callback, value, decimals) {
+	if (typeof value !== "number") return NaN;
+	if (typeof decimals !== "number" || decimals < 1) return callback(value);
+	const mod = 10 ** decimals;
+	return callback((value + Number.EPSILON) * mod) / mod;
+}
+// node_modules/@oscarpalmer/atoms/dist/internal/math/aggregate.mjs
+function aggregate(type, array, key, first) {
+	const length = Array.isArray(array) ? array.length : 0;
+	const aggregation = {
+		array: false,
+		count: 0,
+		first: first === true,
+		value: NaN
+	};
+	if (length === 0) return aggregation;
+	const aggregator = aggregators[type];
+	const callback = getAggregateCallback(key);
+	aggregation.array = callback != null && (type === "max" || type === "min");
+	let notNumber = true;
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const value = callback == null ? item : callback(item, index, array);
+		if (isNonNumber(value)) continue;
+		aggregation.value = aggregator(aggregation, value, notNumber, item);
+		aggregation.count += 1;
+		notNumber = false;
+	}
+	return aggregation;
+}
+function calculateSum(aggregation, value, notNumber) {
+	return notNumber ? value : aggregation.value + value;
+}
+function getAbsoluteValue(condition, aggregation, value, notNumber, item) {
+	if (notNumber || condition(aggregation, value)) {
+		if (aggregation.array) {
+			aggregation.items ??= {};
+			aggregation.items[value] ??= [];
+			aggregation.items[value].push(item);
+		}
+		return value;
+	}
+	return aggregation.value;
+}
+function getAggregateCallback(key) {
+	if (key == null) return;
+	return typeof key === "function" ? key : (item) => item[key];
 }
-//#endregion
-//#region src/helpers/value.ts
+function getAggregated(type, array, key, first) {
+	const aggregation = aggregate(type, array, key, first);
+	if (aggregation.count === 0) {
+		if (aggregation.array) return aggregation.first ? void 0 : [];
+		return NaN;
+	}
+	if (aggregation.array) {
+		const array = aggregation.items[aggregation.value];
+		return aggregation.first ? array[0] : array;
+	}
+	return aggregation.value;
+}
+function isMaxValue(aggregation, value) {
+	return aggregation.array ? value >= aggregation.value : value > aggregation.value;
+}
+function isMinValue(aggregation, value) {
+	return aggregation.array ? value <= aggregation.value : value < aggregation.value;
+}
+function min(array, key, first) {
+	return getAggregated("min", array, key, first);
+}
+const aggregators = {
+	average: calculateSum,
+	max: getAbsoluteValue.bind(void 0, isMaxValue),
+	min: getAbsoluteValue.bind(void 0, isMinValue),
+	sum: calculateSum
+};
+// src/helpers/value.ts
 function emitValue(instance, notify) {
 	const state = instance[SYMBOL_STATE];
-	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) computed.dirty = true;
-	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) if (computed.instance.active) computed.dirty = true;
+	else state.computeds.delete(computed);
+	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) if (effect.active) BATCH.handlers.set(effect, effect);
+	else state.effects.delete(effect);
 	if (notify ?? false) {
 		const mapped = instance[SYMBOL_STATE].mapped;
 		for (const [, item] of mapped) {
-			const fx = item[SYMBOL_EFFECT];
-			BATCH.handlers.set(fx.instance, fx.instance);
+			const { instance } = item[SYMBOL_EFFECT];
+			BATCH.handlers.set(instance, instance);
 		}
 	}
 	for (const type of SUBSCRIPTION_TYPES) {
@@ -138,8 +310,8 @@ function equalArrays(first, second, equal) {
 	const eq = equal ?? Object.is;
 	let offset = 0;
 	if (length >= 100) {
-		offset = Math.round(length / 10);
-		offset = offset > 25 ? 25 : offset;
+		offset = round(length / 10);
+		offset = min([offset, 25]);
 		for (let index = 0; index < offset; index += 1) if (!(eq(first[index], second[index]) && eq(first[length - index - 1], second[length - index - 1]))) return false;
 	}
 	const end = length - offset;
@@ -153,10 +325,12 @@ function getFrozenValue(value) {
 	return frozen;
 }
 function getJsonValue() {
+	if (SYMBOL_READONLY in this && !this[SYMBOL_READONLY].active) return this[SYMBOL_READONLY].value;
 	return this[SYMBOL_STATE].value;
 }
 function getSignalValue() {
 	const state = this[SYMBOL_STATE];
+	if (!state.active) return state.value;
 	if (ACTIVE.computed != null) {
 		state.computeds ??= /* @__PURE__ */ new Set();
 		state.computeds.add(ACTIVE.computed);
@@ -168,10 +342,13 @@ function getSignalValue() {
 	return state.value;
 }
 function getStringValue(json) {
-	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
+	let { value } = this[SYMBOL_STATE];
+	if (SYMBOL_READONLY in this && !this[SYMBOL_READONLY].active) value = this[SYMBOL_READONLY].value;
+	return json === true ? JSON.stringify(value) : String(value);
 }
 function handleSignal(instance, origin, setValue, onAfter, notify) {
 	const state = instance[SYMBOL_STATE];
+	if (!state.active) return;
 	try {
 		let actual = typeof origin === "function" ? origin() : origin;
 		if (actual instanceof Promise) {
@@ -197,11 +374,10 @@ function peekSignalValue(copy) {
 	return peeked;
 }
 function updateSignal(instance, callback, setValue) {
-	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	handleSignal(instance, callback(instance[SYMBOL_STATE].value), setValue);
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_UPDATE_CALLBACK);
+	if (instance[SYMBOL_STATE].active) handleSignal(instance, callback(instance[SYMBOL_STATE].value), setValue);
 }
-//#endregion
-//#region src/batch.ts
+// src/batch.ts
 function flushHandlers() {
 	if (BATCH.flushing) return;
 	BATCH.flushing = true;
@@ -211,7 +387,8 @@ function flushHandlers() {
 			const { length } = handlers;
 			BATCH.handlers.clear();
 			for (let index = 0; index < length; index += 1) {
-				const [, handler] = handlers[index];
+				const [owner, handler] = handlers[index];
+				if (!owner.active) continue;
 				const subscription = handler;
 				if (typeof subscription.frozen === "boolean") subscription.callback(subscription.frozen ? getFrozenValue(subscription.state.value) : peekSignalValue.call(subscription.instance, subscription.copy));
 				else runEffect(handler);
@@ -236,8 +413,7 @@ function stopBatch() {
 	if (BATCH.depth > 0) BATCH.depth -= 1;
 	flushHandlers();
 }
-//#endregion
-//#region src/helpers/is.ts
+// src/helpers/is.ts
 /**
 * Is the value a computed signal?
 *
@@ -256,8 +432,12 @@ function isComputed(value) {
 function isEffect(value) {
 	return isMora(value, NAME_EFFECT);
 }
-function isMora(value, name) {
-	return typeof value === "object" && value != null && "$mora" in value && (typeof name === "string" ? value["$mora"] === name : name.has(value["$mora"]));
+function isMora(input, value) {
+	if (typeof input !== "object" || input === null) return false;
+	if (value === "readonly") return SYMBOL_READONLY in input;
+	if (!(SYMBOL_STATE in input)) return false;
+	const state = input[SYMBOL_STATE];
+	return typeof value === "string" ? state.name === value : value.has(state.name);
 }
 /**
 * Is the value reactive?
@@ -304,13 +484,12 @@ function isReactiveStore(value) {
 function isReadonlySignal(value) {
 	return isMora(value, NAME_READONLY);
 }
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/array/callbacks.mjs
+// node_modules/@oscarpalmer/atoms/dist/internal/array/callbacks.mjs
 function getArrayCallback(value) {
 	switch (typeof value) {
 		case "function": return value;
 		case "number":
-		case "string": return typeof value === "string" && value.includes(".") ? void 0 : (obj) => obj[value];
+		case "string": return (obj) => obj?.[value];
 		default: return;
 	}
 }
@@ -321,8 +500,16 @@ function getArrayCallbacks(bool, key, value) {
 		value: getArrayCallback(value)
 	};
 }
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/array/find.mjs
+// node_modules/@oscarpalmer/atoms/dist/internal/array/find.mjs
+function addResult(result, mapped, flat) {
+	if (!flat) {
+		result.matched.push(mapped);
+		return;
+	}
+	const array = Array.isArray(mapped) ? mapped : [mapped];
+	const { length } = array;
+	for (let index = 0; index < length; index += 1) result.matched.push(array[index]);
+}
 function createFindParameters(original) {
 	const { length } = original;
 	return {
@@ -331,116 +518,84 @@ function createFindParameters(original) {
 		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 } = createFindParameters(parameters);
-	const callbacks = getArrayCallbacks(bool, key);
-	if (callbacks?.bool == null && callbacks?.keyed == null) {
-		if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
-		return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
-	}
-	if (callbacks.bool != null) {
-		const index = reversed ? array.findLastIndex(callbacks.bool) : array.findIndex(callbacks.bool);
-		return findIndex ? index : array[index];
+function findComplexValues(parameters) {
+	const { array, arrayLength, callback, limit, result, type, value } = parameters;
+	const keys = /* @__PURE__ */ new Set();
+	for (let arrayIndex = 0; arrayIndex < arrayLength; arrayIndex += 1) {
+		const arrayItem = array[arrayIndex];
+		const keyed = callback == null ? arrayItem : callback(arrayItem, arrayIndex, array);
+		const mapped = arrayItem;
+		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
+			keys.add(keyed);
+			result.matched.push(mapped);
+			if (result.matched.length >= limit) return result;
+		} else result.notMatched.push(arrayItem);
 	}
-	return findValueInArray(array, callbacks.keyed, value, findIndex, reversed);
+	return result;
 }
-function findValueInArray(array, callback, value, findIndex, reversed) {
-	const { length } = array;
-	for (let index = 0; index < length; index += 1) {
-		const item = reversed ? array.at(-(index + 1)) : array[index];
-		if (Object.is(callback?.(item, index, array), value)) return findIndex ? index : item;
+function findSimpleValues(parameters) {
+	const { array, arrayLength, callback, flat, limit, map, result, value } = parameters;
+	const { after, before } = map ?? {};
+	const handler = callback ?? ((item) => Object.is(item, value));
+	for (let arrayIndex = 0; arrayIndex < arrayLength; arrayIndex += 1) {
+		const arrayItem = array[arrayIndex];
+		let mapped = before == null ? arrayItem : before(arrayItem, arrayIndex, array);
+		if (!flat || after != null) {
+			if (handler(mapped, arrayIndex, array)) {
+				mapped = after == null ? mapped : after(arrayItem, arrayIndex, array);
+				addResult(result, mapped, flat);
+				if (result.matched.length >= limit) return result;
+			} else result.notMatched.push(arrayItem);
+			continue;
+		}
+		const flatItems = Array.isArray(mapped) ? mapped : [mapped];
+		const flatLength = flatItems.length;
+		for (let flatIndex = 0; flatIndex < flatLength; flatIndex += 1) {
+			const flatItem = flatItems[flatIndex];
+			if (handler(flatItem, arrayIndex, array)) result.matched.push(flatItem);
+			else result.notMatched.push(flatItem);
+		}
 	}
-	return findIndex ? -1 : void 0;
+	return result;
 }
-function findValues(type, array, parameters, mapper) {
+function findValues(type, array, parameters, options) {
 	const result = {
 		matched: [],
 		notMatched: []
 	};
-	if (!Array.isArray(array) || array.length === 0) return result;
-	const { length } = array;
+	if (!Array.isArray(array)) return result;
+	const arrayLength = array.length;
+	if (arrayLength === 0) return result;
 	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && length >= FIND_UNIQUE_THRESHOLD) {
+	if (type === "unique" && callbacks?.keyed == null && arrayLength >= 100) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
-	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];
-			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;
-	}
-	const keys = /* @__PURE__ */ new Set();
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		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(mapAfter?.(item, index, array) ?? transformed);
-		} else result.notMatched.push(item);
-	}
-	return result;
+	const limit = options?.limit ?? Number.POSITIVE_INFINITY;
+	const flat = options?.map?.flat ?? false;
+	const mapCallback = getArrayCallback(options?.map?.callback);
+	const mapReverse = options?.map?.reverse ?? false;
+	let map;
+	if (mapCallback != null) map = {
+		before: mapReverse ? mapCallback : void 0,
+		after: mapReverse ? void 0 : mapCallback
+	};
+	const simple = callbacks?.bool != null || type === "all" && key == null;
+	const findParameters = {
+		array,
+		arrayLength,
+		flat,
+		limit,
+		map,
+		result,
+		type,
+		value,
+		callback: simple ? callbacks?.bool : callbacks?.keyed
+	};
+	return simple ? findSimpleValues(findParameters) : findComplexValues(findParameters);
 }
-const FIND_VALUE_INDEX = "index";
-const FIND_VALUE_ITEM = "item";
-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);
-}
-function lastIndexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters, true);
-}
-indexOf.last = lastIndexOf;
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/array/find.mjs
-function find(array, ...parameters) {
-	return findValue(FIND_VALUE_ITEM, array, parameters, false);
-}
-function findLast(array, ...parameters) {
-	return findValue(FIND_VALUE_ITEM, array, parameters, true);
-}
-find.last = 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 selectValues(array, parameters);
-}
-function selectValues(array, parameters) {
-	return findValues("all", array, parameters, {
-		callback: parameters.pop(),
-		reverse: false
-	}).matched;
-}
-select.reverse = reverseSelect;
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/array/filter.mjs
+// node_modules/@oscarpalmer/atoms/dist/array/filter.mjs
 function exclude(array, ...parameters) {
 	return findValues("all", array, parameters).notMatched;
 }
@@ -448,32 +603,152 @@ function filter(array, ...parameters) {
 	return findValues("all", array, parameters).matched;
 }
 filter.remove = exclude;
-//#endregion
-//#region src/helpers/misc.ts
-function getState(value, options) {
+// node_modules/@oscarpalmer/atoms/dist/array/select.mjs
+function filterAndFlatMap(array, filter, mapper) {
+	return selectValues(array, filter, mapper, true, false);
+}
+function filterAndMap(array, filter, mapper) {
+	return selectValues(array, filter, mapper, false, false);
+}
+function flatMapAndFilter(array, mapper, filter) {
+	return selectValues(array, filter, mapper, true, true);
+}
+function mapAndFilter(array, mapper, filter) {
+	return selectValues(array, filter, mapper, false, true);
+}
+function selectValues(array, filter, mapper, flat, reverse) {
+	return findValues("all", array, [filter], { map: {
+		flat,
+		reverse,
+		callback: mapper
+	} }).matched;
+}
+filterAndMap.flat = filterAndFlatMap;
+filterAndMap.reverse = mapAndFilter;
+mapAndFilter.flat = flatMapAndFilter;
+// src/helpers/misc.ts
+function deactivateComputed() {
+	if (!this[SYMBOL_STATE].active) return;
+	deactivateEffect(this[SYMBOL_EFFECT].instance);
+	deactivateReactive.call(this);
+}
+function deactivateProxy() {
+	const state = this[SYMBOL_STATE];
+	if (!state.active) return;
+	if (state.derived != null) {
+		for (const computed of state.derived) computed.deactivate();
+		state.derived.clear();
+		state.derived = void 0;
+	}
+	if (state.mapped != null) {
+		for (const [, computed] of state.mapped) computed.deactivate();
+		state.mapped.clear();
+		state.mapped = void 0;
+	}
+	deactivateReactive.call(this);
+}
+function deactivateReactive() {
+	const state = this[SYMBOL_STATE];
+	if (!state.active) return;
+	state.active = false;
+	state.computeds?.clear();
+	state.effects?.clear();
+	state.promises?.clear();
+	state.readonlies?.frozen?.deactivate();
+	state.readonlies?.original?.deactivate();
+	state.subscriptions?.clear();
+	state.equal = noop;
+	state.promise = void 0;
+	state.computeds = void 0;
+	state.effects = void 0;
+	state.promises = void 0;
+	state.readonlies = void 0;
+	state.subscriptions = void 0;
+}
+function deactivateReadonly() {
+	const readonly = this[SYMBOL_READONLY];
+	const signal = this[SYMBOL_STATE];
+	if (!readonly.active) return;
+	signal.readonlies[readonly.name] = void 0;
+	if (readonly.subscriptions != null) {
+		for (const subscription of readonly.subscriptions) subscription.unsubscribe();
+		readonly.subscriptions.clear();
+		readonly.subscriptions = void 0;
+	}
+	readonly.active = false;
+	readonly.value = peekSignalValue.call(this, true);
+}
+function getReactiveActive() {
+	return this[SYMBOL_STATE].active;
+}
+function getReadonlyActive() {
+	return this[SYMBOL_READONLY].active;
+}
+function getState(name, value, options) {
 	return {
+		name,
 		value,
+		active: true,
 		equal: typeof options === "object" && typeof options?.equal === "function" ? options.equal : void 0
 	};
 }
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/aborter.mjs
+// node_modules/@oscarpalmer/atoms/dist/internal/number.mjs
+/**
+* Get the number value from an unknown value
+*
+* _(Based on Lodash)_
+*
+* @param value Original value
+* @returns Original value as a number, or `Number.NaN` if the value is unable to be parsed
+*
+* @example
+* ```typescript
+* getNumber(null)       // => Number.NaN
+* getNumber('foo')      // => Number.NaN
+* getNumber('123')        // => 123
+* getNumber(true)       // => 1
+* getNumber([1, 2, 3])  // => Number.NaN
+* getNumber({a: 1})     // => Number.NaN
+* getNumber(() => 123)  // => 123
+* ```
+*/
+function getNumber(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "bigint" || typeof value === "boolean") return Number(value);
+	if (value == null || typeof value === "symbol") return NaN;
+	if (typeof value === "function") return getNumber(value());
+	let parsed = value.valueOf();
+	if (typeof parsed === "object") parsed = parsed.toString();
+	if (typeof parsed !== "string") return getNumber(parsed);
+	const trimmed = parsed.trim();
+	if (trimmed.length === 0) return NaN;
+	if (EXPRESSION_NUMBER_ZEROISH.test(parsed)) return 0;
+	const isBinary = EXPRESSION_NUMBER_BINARY.test(trimmed);
+	if (isBinary || EXPRESSION_NUMBER_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : 8);
+	return Number(trimmed);
+}
+// node_modules/@oscarpalmer/atoms/dist/models/subscription.model.mjs
+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 = "$subscription";
+const SUBSCRIPTION_STORE = "subscriptions";
+const SUBSCRIPTION_SYMBOL = Symbol(SUBSCRIPTION_PROPERTY);
+// node_modules/@oscarpalmer/atoms/dist/models/aborter.model.mjs
+const ABORTER_EVENT = "abort";
+const ABORTER_OPTIONS = { once: true };
+// node_modules/@oscarpalmer/atoms/dist/internal/aborter.mjs
 function createAborter(value, onAbort) {
 	if (!(value instanceof AbortSignal)) return;
-	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);
+	value.addEventListener(ABORTER_EVENT, onAbort, ABORTER_OPTIONS);
 	return {
 		callback: onAbort,
 		signal: value,
-		cancel: () => value.removeEventListener(ABORT_EVENT, onAbort)
+		cancel: () => value.removeEventListener(ABORTER_EVENT, onAbort)
 	};
 }
-const ABORT_EVENT = "abort";
-const ABORT_OPTIONS = { once: true };
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/subscription.mjs
-const SUBSCRIPTION_NAME = "subscription";
-const SUBSCRIPTION_PROPERTY = "$subscription";
-const SUBSCRIPTION_STORE = "subscriptions";
+// node_modules/@oscarpalmer/atoms/dist/internal/subscription.mjs
 function Subscription(state, property, parameters) {
 	this[SUBSCRIPTION_SYMBOL] = state;
 	this[property.key] = property.value;
@@ -514,9 +789,7 @@ function addSubscription(instance) {
 		return;
 	}
 	/* istanbul ignore if */
-	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
- // istanbul ignore next
-	return;
+	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null) return;
 	let keyedItems = items.keyed.get(key);
 	if (keyedItems == null) {
 		keyedItems = /* @__PURE__ */ new Set();
@@ -597,7 +870,7 @@ 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
+		value: values.value ?? "subscription"
 	};
 }
 function createSubscriptionsState(property, keys) {
@@ -645,9 +918,7 @@ function removeSubscription() {
 	}
 	const keyed = items.keyed?.get(key);
 	/* istanbul ignore if */
-	if (items.keyed == null || keyed == null)
- // istanbul ignore next
-	return;
+	if (items.keyed == null || keyed == null) return;
 	removeFromStore(keyed, values, this, value, key);
 	if (keyed.size === 0) items.keyed.delete(key);
 }
@@ -660,46 +931,53 @@ function removeSubscription() {
 function subscriptions(parameters) {
 	return new Subscriptions(parameters);
 }
-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_SYMBOL = Symbol(SUBSCRIPTION_PROPERTY);
-//#endregion
-//#region src/helpers/subscription.ts
+// src/helpers/subscription.ts
 function subscribeToProxy(first, second, third) {
+	if (!this[SYMBOL_STATE].active) throw new Error(MESSAGE_DEACTIVATED_SUBSCRIPTION);
 	if (isKey(first)) return getReactiveValueInProxy(this, first).subscribe(second, third);
 	return subscribeToSignal.call(this, first, second);
 }
 function subscribeToReactive(type, subscriber) {
-	this[SYMBOL_STATE].subscriptions ??= subscriptions({
+	const state = this[SYMBOL_STATE];
+	if (!state.active) throw new Error(MESSAGE_DEACTIVATED_SUBSCRIPTION);
+	state.subscriptions ??= subscriptions({
 		keys: SUBSCRIPTION_TYPES,
 		property: SUBSCRIPTION_PROPERTY$1
 	});
-	const [subscription, existing] = this[SYMBOL_STATE].subscriptions.create({
+	const [subscription, existing] = state.subscriptions.create({
 		key: type,
 		value: subscriber
 	});
-	if (!existing) subscriber(type === "frozen" ? getFrozenValue(this[SYMBOL_STATE].value) : peekSignalValue.call(this, SUBSCRIPTION_TYPES_COPY.has(type)), subscription);
+	if (!existing) subscriber(type === "frozen" ? getFrozenValue(state.value) : peekSignalValue.call(this, SUBSCRIPTION_TYPES_COPY.has(type)), subscription);
 	return subscription;
 }
 function subscribeToReadonly(subscriber) {
-	return subscribeToReactive.call(this, this.frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY, subscriber);
+	const state = this[SYMBOL_READONLY];
+	if (!state.active) throw new Error(MESSAGE_DEACTIVATED_SUBSCRIPTION);
+	const subscription = subscribeToReactive.call(this, this.frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY, subscriber);
+	state.subscriptions ??= /* @__PURE__ */ new Set();
+	for (const existing of state.subscriptions) if (!existing.active) state.subscriptions.delete(existing);
+	state.subscriptions.add(subscription);
+	return subscription;
 }
 function subscribeToSignal(subscriber, copy) {
 	return subscribeToReactive.call(this, copy === true ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL, subscriber);
 }
-//#endregion
-//#region src/value/computed.ts
+// src/value/computed.ts
 function Computed(callback, options) {
-	this[SYMBOL_STATE] = getState(void 0, options);
+	this[SYMBOL_STATE] = getState(NAME_COMPUTED, void 0, options);
 	this[SYMBOL_EFFECT] = getComputedEffect(this, callback);
 }
-Computed.prototype[NAME_MORA] = NAME_COMPUTED;
+Computed.prototype.deactivate = deactivateComputed;
 Computed.prototype.get = getComputedValue;
 Computed.prototype.peek = peekSignalValue;
 Computed.prototype.subscribe = subscribeToSignal;
 Computed.prototype.toJSON = getJsonValue;
 Computed.prototype.toString = getStringValue;
+Object.defineProperties(Computed.prototype, { active: {
+	enumerable: true,
+	get: getReactiveActive
+} });
 /**
 * Create a computed value
 *
@@ -711,7 +989,7 @@ function computed(callback, options) {
 	return getComputed(callback, options);
 }
 function getComputed(callback, options) {
-	if (typeof callback !== "function") throw new TypeError("Computed callback must be a function");
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_COMPUTED_CALLBACK);
 	return new Computed(callback, options);
 }
 function getComputedEffect(instance, callback) {
@@ -734,8 +1012,9 @@ function getComputedEffect(instance, callback) {
 	return fx;
 }
 function getComputedValue() {
-	const fx = this[SYMBOL_EFFECT];
 	const state = this[SYMBOL_STATE];
+	if (!state.active) return state.value;
+	const fx = this[SYMBOL_EFFECT];
 	if (ACTIVE.computed != null && fx !== ACTIVE.computed) {
 		state.computeds ??= /* @__PURE__ */ new Set();
 		state.computeds.add(ACTIVE.computed);
@@ -752,10 +1031,12 @@ function internalComputed(callback, options) {
 }
 function setAndEmit$1(instance, value, notify) {
 	const state = instance[SYMBOL_STATE];
-	if (!notify && (state.equal ?? Object.is)(state.value, value)) return;
+	if (!state.active || !notify && (state.equal ?? Object.is)(state.value, value)) return;
 	state.value = value;
-	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) computed.dirty = true;
-	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) if (computed.instance.active) computed.dirty = true;
+	else state.computeds.delete(computed);
+	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) if (effect.active) BATCH.handlers.set(effect, effect);
+	else state.effects.delete(effect);
 	for (const type of SUBSCRIPTION_TYPES) {
 		if (type === "frozen") continue;
 		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
@@ -766,12 +1047,11 @@ function setAndEmit$1(instance, value, notify) {
 	}
 	flushHandlers();
 }
-//#endregion
-//#region src/helpers/proxy.ts
+// src/helpers/proxy.ts
 function getReactiveValueInProxy(instance, key) {
 	const state = instance[SYMBOL_STATE];
 	state.mapped ??= /* @__PURE__ */ new Map();
-	const mapKey = String(key);
+	const mapKey = getString(key);
 	let item = state.mapped.get(mapKey);
 	if (item == null) {
 		item = internalComputed(() => state.isArray ? instance.get().at(key) : instance.get()[key]);
@@ -780,18 +1060,21 @@ function getReactiveValueInProxy(instance, key) {
 	return item;
 }
 function getValueInProxy(first) {
+	const state = this[SYMBOL_STATE];
+	if (!state.active) return peekValueInProxy.call(this, first);
 	let signal;
-	if (this[SYMBOL_STATE].isArray ? typeof first === "number" : isKey(first)) signal = getReactiveValueInProxy(this, first);
+	if (state.isArray ? typeof first === "number" : isKey(first)) signal = getReactiveValueInProxy(this, first);
 	return getSignalValue.call(signal ?? this);
 }
 function isProxyKey(isArray, value) {
-	return isArray ? typeof value === "number" : isKey(value);
+	return isArray && typeof value === "number" || isKey(value);
 }
 function isProxyObject(isArray, value) {
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
 }
 function notifyProxyValue() {
 	const state = this[SYMBOL_STATE];
+	if (!state.active) return;
 	state.mapped ??= /* @__PURE__ */ new Map();
 	const values = [...state.mapped.values()];
 	const { length } = values;
@@ -843,6 +1126,7 @@ function setProxyProperty(state, property, value) {
 }
 function setProxyValue(first, second) {
 	const state = this[SYMBOL_STATE];
+	if (!state.active) return;
 	if (state.isArray && first === "length") {
 		state.value.length = second;
 		return;
@@ -883,8 +1167,9 @@ function setProxyValue(first, second) {
 }
 function setValueInProxy(instance, target, property, value) {
 	const state = instance[SYMBOL_STATE];
+	if (!state.active) return true;
 	if (state.isArray) {
-		if (!(!Number.isNaN(Number(property)) || property === "length")) return Reflect.set(target, property, value);
+		if (!(!Number.isNaN(getNumber(property)) || property === "length")) return Reflect.set(target, property, value);
 	}
 	const previous = Reflect.get(target, property);
 	if (!(state.equal ?? Object.is)(previous, value)) {
@@ -894,51 +1179,67 @@ function setValueInProxy(instance, target, property, value) {
 	}
 	return true;
 }
+function updateProxyDerivations(instance, value) {
+	const state = instance[SYMBOL_STATE];
+	if (state.derived == null) {
+		state.derived = /* @__PURE__ */ new Set([value]);
+		return value;
+	}
+	for (const computed of state.derived) if (!computed.active) state.derived.delete(computed);
+	state.derived.add(value);
+	return value;
+}
 function updateProxyValue(callback) {
-	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_UPDATE_CALLBACK);
+	if (this[SYMBOL_STATE].active) setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
 }
-//#endregion
-//#region src/value/readonly.ts
+// src/value/readonly.ts
 function Readonly(state, frozen) {
-	this[SUBSCRIPTION_TYPE_FROZEN] = frozen;
 	this[SYMBOL_STATE] = state;
+	this[SYMBOL_READONLY] = {
+		active: true,
+		name: frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_ORIGINAL
+	};
+	Object.defineProperty(this, SUBSCRIPTION_TYPE_FROZEN, { value: frozen });
 }
-Readonly.prototype[NAME_MORA] = NAME_READONLY;
+Readonly.prototype.deactivate = deactivateReadonly;
 Readonly.prototype.get = getReadonlyValue;
 Readonly.prototype.peek = peekReadonlyValue;
 Readonly.prototype.subscribe = subscribeToReadonly;
 Readonly.prototype.toJSON = getJsonValue;
 Readonly.prototype.toString = getStringValue;
-function getReadonlyInstance(state, frozen) {
-	return new Readonly(state, frozen);
-}
+Object.defineProperties(Readonly.prototype, { active: {
+	enumerable: true,
+	get: getReadonlyActive
+} });
 function getReadonlySignal(frozen) {
+	const state = this[SYMBOL_STATE];
+	if (!state.active) throw new Error(MESSAGE_DEACTIVATED_READONLY);
 	const key = frozen === true ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_ORIGINAL;
-	this[SYMBOL_STATE].readonlies ??= {};
-	this[SYMBOL_STATE].readonlies[key] ??= getReadonlyInstance(this[SYMBOL_STATE], frozen === true);
-	return this[SYMBOL_STATE].readonlies[key];
+	state.readonlies ??= {};
+	state.readonlies[key] ??= new Readonly(state, frozen === true);
+	return state.readonlies[key];
 }
 function getReadonlyValue() {
-	return handleReadonlyValue(this, false, this[SUBSCRIPTION_TYPE_FROZEN]);
+	return handleReadonlyValue(this, false, this.frozen);
 }
 function handleReadonlyValue(instance, peek, frozen, copy) {
+	const state = instance[SYMBOL_READONLY];
 	let value;
-	if (peek) value = peekSignalValue.call(instance, copy === true);
-	else value = getSignalValue.call(instance);
+	if (peek) value = peekSignalValue.call(state.active ? instance : [instance, state.value], copy === true);
+	else value = state.active ? getSignalValue.call(instance) : state.value;
 	return frozen ? getFrozenValue(value) : value;
 }
 function peekReadonlyValue(copy) {
-	return handleReadonlyValue(this, true, this[SUBSCRIPTION_TYPE_FROZEN], copy);
+	return handleReadonlyValue(this, true, this.frozen, copy);
 }
-//#endregion
-//#region src/value/signal.ts
+// src/value/signal.ts
 function Signal(value, options) {
-	this[SYMBOL_STATE] = getState(void 0, options);
+	this[SYMBOL_STATE] = getState(NAME_SIGNAL, void 0, options);
 	handleSignal(this, value, setAndEmit);
 }
-Signal.prototype[NAME_MORA] = NAME_SIGNAL;
 Signal.prototype.asReadonly = getReadonlySignal;
+Signal.prototype.deactivate = deactivateReactive;
 Signal.prototype.get = getSignalValue;
 Signal.prototype.peek = peekSignalValue;
 Signal.prototype.set = setSignalValue;
@@ -946,6 +1247,10 @@ Signal.prototype.subscribe = subscribeToSignal;
 Signal.prototype.toString = getStringValue;
 Signal.prototype.toJSON = getJsonValue;
 Signal.prototype.update = updateSignalValue;
+Object.defineProperties(Signal.prototype, { active: {
+	enumerable: true,
+	get: getReactiveActive
+} });
 function setAndEmit(instance, value) {
 	const state = instance[SYMBOL_STATE];
 	if (!(state.equal ?? Object.is)(state.value, value)) {
@@ -962,11 +1267,10 @@ function signal(value, options) {
 function updateSignalValue(callback) {
 	updateSignal(this, callback, setAndEmit);
 }
-//#endregion
-//#region src/value/array.ts
+// src/value/array.ts
 function ReactiveArray(value, options) {
 	this[SYMBOL_STATE] = {
-		...getState(void 0, options),
+		...getState(NAME_ARRAY, void 0, options),
 		isArray: true,
 		length: signal(0)
 	};
@@ -976,15 +1280,10 @@ function ReactiveArray(value, options) {
 	});
 	setProxyValue.call(this, value);
 }
-ReactiveArray.prototype[NAME_MORA] = NAME_ARRAY;
-Object.defineProperty(ReactiveArray.prototype, PROPERTY_LENGTH, {
-	enumerable: true,
-	get: getArrayLength,
-	set: setArrayLength
-});
 ReactiveArray.prototype.asReadonly = getReadonlySignal;
 ReactiveArray.prototype.at = getArrayValues;
 ReactiveArray.prototype.clear = clearArrayValues;
+ReactiveArray.prototype.deactivate = deactivateArray;
 ReactiveArray.prototype.filter = filterArrayValues;
 ReactiveArray.prototype.get = getArrayValues;
 ReactiveArray.prototype.map = mapArrayValues;
@@ -1001,14 +1300,33 @@ ReactiveArray.prototype.toString = getStringValue;
 ReactiveArray.prototype.toJSON = getJsonValue;
 ReactiveArray.prototype.unshift = unshiftArrayValues;
 ReactiveArray.prototype.update = updateProxyValue;
+Object.defineProperties(ReactiveArray.prototype, {
+	[PROPERTY_LENGTH]: {
+		enumerable: true,
+		get: getArrayLength,
+		set: setArrayLength
+	},
+	active: {
+		enumerable: true,
+		get: getReactiveActive
+	}
+});
 function array(value, options) {
 	return new ReactiveArray(value, options);
 }
 function clearArrayValues() {
-	this[SYMBOL_STATE].value.length = 0;
+	const state = this[SYMBOL_STATE];
+	if (state.active) state.value.length = 0;
+}
+function deactivateArray() {
+	const state = this[SYMBOL_STATE];
+	if (!state.active) return;
+	state.length?.deactivate?.();
+	deactivateProxy.call(this);
 }
 function filterArrayValues(callback) {
-	return computed(() => filter(getArrayValues.call(this), callback));
+	if (!this[SYMBOL_STATE].active) throw new Error(MESSAGE_DEACTIVATED_ARRAY_FILTER);
+	return updateProxyDerivations(this, computed(() => filter(getArrayValues.call(this), callback)));
 }
 function getArrayLength() {
 	return this[SYMBOL_STATE].length.get();
@@ -1017,36 +1335,47 @@ function getArrayValues(value) {
 	return value === "length" ? this[SYMBOL_STATE].length.get() : getValueInProxy.call(this, value);
 }
 function mapArrayValues(callback) {
-	return computed(() => getArrayValues.call(this).map(callback));
+	if (!this[SYMBOL_STATE].active) throw new Error(MESSAGE_DEACTIVATED_ARRAY_MAP);
+	return updateProxyDerivations(this, computed(() => getArrayValues.call(this).map((item, index, array) => callback(item, index, array))));
 }
 function peekArrayValue(first, second) {
 	return first === "length" ? this[SYMBOL_STATE].length.peek() : peekValueInProxy.call(this, first, second);
 }
 function popArrayValue() {
-	return this[SYMBOL_STATE].value.pop();
+	const state = this[SYMBOL_STATE];
+	return state.active ? state.value.pop() : void 0;
 }
 function pushArrayValues(...items) {
-	return this[SYMBOL_STATE].value.push(...items);
+	const state = this[SYMBOL_STATE];
+	return state.active ? state.value.push(...items) : state.value.length;
 }
 function selectArrayValues(filter, map) {
-	return computed(() => select(getArrayValues.call(this), filter, map));
+	if (!this[SYMBOL_STATE].active) throw new Error(MESSAGE_DEACTIVATED_ARRAY_SELECT);
+	return updateProxyDerivations(this, computed(() => filterAndMap(getArrayValues.call(this), filter, map)));
 }
 function setArrayLength(value) {
-	const values = this[SYMBOL_STATE].value;
+	const state = this[SYMBOL_STATE];
+	if (!state.active) return;
+	const values = state.value;
 	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== values.length) values.length = value;
 }
 function shiftArrayValue() {
-	return this[SYMBOL_STATE].value.shift();
+	const state = this[SYMBOL_STATE];
+	return state.active ? state.value.shift() : void 0;
 }
 function spliceArrayValues(from, to, ...items) {
-	const values = this[SYMBOL_STATE].value;
+	const state = this[SYMBOL_STATE];
+	if (!state.active) return [];
+	const values = state.value;
 	return values.splice(from, to ?? values.length, ...items);
 }
 function unshiftArrayValues(...items) {
-	return this[SYMBOL_STATE].value.unshift(...items);
+	const state = this[SYMBOL_STATE];
+	return state.active ? state.value.unshift(...items) : state.value.length;
 }
 function updateArray(instance, type, array) {
 	const state = instance[SYMBOL_STATE];
+	if (!state.active) return () => void 0;
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
 	const previousArray = affectsLength ? [] : array.slice();
 	const previousLength = array.length;
@@ -1059,18 +1388,17 @@ function updateArray(instance, type, array) {
 		return result;
 	};
 }
-//#endregion
-//#region src/value/store.ts
+// src/value/store.ts
 function ReactiveStore(value, options) {
 	this[SYMBOL_STATE] = {
-		...getState(void 0, options),
+		...getState(NAME_STORE, void 0, options),
 		isArray: false
 	};
 	this[SYMBOL_STATE].value = new Proxy({}, { set: (target, property, value) => setValueInProxy(this, target, property, value) });
 	setProxyValue.call(this, value);
 }
-ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
 ReactiveStore.prototype.asReadonly = getReadonlySignal;
+ReactiveStore.prototype.deactivate = deactivateProxy;
 ReactiveStore.prototype.get = getValueInProxy;
 ReactiveStore.prototype.notify = notifyProxyValue;
 ReactiveStore.prototype.peek = peekValueInProxy;
@@ -1079,8 +1407,11 @@ ReactiveStore.prototype.subscribe = subscribeToProxy;
 ReactiveStore.prototype.toJSON = getJsonValue;
 ReactiveStore.prototype.toString = getStringValue;
 ReactiveStore.prototype.update = updateProxyValue;
+Object.defineProperties(ReactiveStore.prototype, { active: {
+	enumerable: true,
+	get: getReactiveActive
+} });
 function store(value, options) {
 	return new ReactiveStore(value, options);
 }
-//#endregion
 export { array, computed, effect, isComputed, isEffect, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal, signal, startBatch, stopBatch, store };