@oscarpalmer/mora 0.33.0 → 0.35.0

package/dist/mora.full.mjs

@@ -125,10 +125,10 @@ function emitValue(instance) {
 	}
 	if (BATCH.depth === 0) flushHandlers();
 }
-function equalArrays(state, first, second) {
+function equalArrays(first, second, equal) {
 	const { length } = first;
 	if (length !== second.length) return false;
-	const eq = state.equal ?? Object.is;
+	const eq = equal ?? Object.is;
 	let offset = 0;
 	if (length >= 100) {
 		offset = Math.round(length / 10);
@@ -145,21 +145,25 @@ function getFrozenValue(value) {
 	else if (isPlainObject(frozen)) frozen = Object.freeze({ ...frozen });
 	return frozen;
 }
+function getJsonValue() {
+	return this[SYMBOL_STATE].value;
+}
 function getSignalValue() {
+	const state = this[SYMBOL_STATE];
 	if (ACTIVE.computed != null) {
-		this[SYMBOL_STATE].computeds ??= /* @__PURE__ */ new Set();
-		this[SYMBOL_STATE].computeds.add(ACTIVE.computed);
+		state.computeds ??= /* @__PURE__ */ new Set();
+		state.computeds.add(ACTIVE.computed);
 	}
 	if (ACTIVE.effect != null) {
-		this[SYMBOL_STATE].effects ??= /* @__PURE__ */ new Set();
-		this[SYMBOL_STATE].effects.add(ACTIVE.effect);
+		state.effects ??= /* @__PURE__ */ new Set();
+		state.effects.add(ACTIVE.effect);
 	}
-	return this[SYMBOL_STATE].value;
+	return state.value;
 }
 function getStringValue(json) {
 	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
 }
-function handleSignalValue(instance, origin, setValue, onAfter) {
+function handleSignal(instance, origin, setValue, onAfter) {
 	const state = instance[SYMBOL_STATE];
 	try {
 		let actual = typeof origin === "function" ? origin() : origin;
@@ -185,9 +189,9 @@ function peekSignalValue(copy) {
 	else if (isPlainObject(peeked)) peeked = { ...peeked };
 	return peeked;
 }
-function updateSignalValue(instance, callback, setValue) {
+function updateSignal(instance, callback, setValue) {
 	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	handleSignalValue(instance, callback(instance[SYMBOL_STATE].value), setValue);
+	handleSignal(instance, callback(instance[SYMBOL_STATE].value), setValue);
 }
 //#endregion
 //#region src/batch.ts
@@ -464,13 +468,54 @@ 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 SUBSCRIPTION_NAME = "subscription";
+const SUBSCRIPTION_PROPERTY = "$subscription";
+const SUBSCRIPTION_STORE = "subscriptions";
+function Subscription(state, property, parameters) {
+	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: state });
+	state.aborter = createAborter(parameters.signal, () => this.unsubscribe(subscriptions, this, state));
+	Object.defineProperties(this, {
+		[property.key]: { value: property.value },
+		active: {
+			enumerable: true,
+			get: () => (state.parameters?.isActive?.() ?? true) && state.active
+		}
+	});
+	addSubscription(this);
+}
+Object.defineProperties(Subscription.prototype, {
+	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_NAME },
+	unsubscribe: { value: removeSubscription }
+});
+function Subscriptions(parameters) {
+	const { keys, property } = createSubscriptionsParameters(parameters);
+	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: createSubscriptionsState(property, keys) });
+}
+Object.defineProperties(Subscriptions.prototype, {
+	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_STORE },
+	clear: { value: clearSubscriptions },
+	create: { value: createSubscription },
+	items: {
+		enumerable: true,
+		get() {
+			return this[SUBSCRIPTION_SYMBOL].items;
+		}
+	},
+	values: {
+		enumerable: true,
+		get() {
+			return this[SUBSCRIPTION_SYMBOL].values;
+		}
+	}
+});
+function addSubscription(instance) {
+	const state = instance[SUBSCRIPTION_SYMBOL];
 	const { key, value } = state.parameters;
+	const { items, values } = state.subscriptions;
 	if (!isKey(key)) {
-		items.any.add(subscription);
-		values.from.any.set(value, subscription);
-		values.to.any.set(subscription, value);
+		items.any.add(instance);
+		values.from.any.set(value, instance);
+		values.to.any.set(instance, value);
 		return;
 	}
 	/* istanbul ignore if */
@@ -482,29 +527,32 @@ function addSubscription(subscriptions, subscription, state) {
 		keyedItems = /* @__PURE__ */ new Set();
 		items.keyed.set(key, keyedItems);
 	}
-	keyedItems.add(subscription);
+	keyedItems.add(instance);
 	let keyedFrom = values.from.keyed.get(key);
 	if (keyedFrom == null) {
 		keyedFrom = /* @__PURE__ */ new Map();
 		values.from.keyed.set(key, keyedFrom);
 	}
-	keyedFrom.set(value, subscription);
+	keyedFrom.set(value, instance);
 	let keyedTo = values.to.keyed.get(key);
 	if (keyedTo == null) {
 		keyedTo = /* @__PURE__ */ new Map();
 		values.to.keyed.set(key, keyedTo);
 	}
-	keyedTo.set(subscription, value);
+	keyedTo.set(instance, 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 clearSubscriptions() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	for (const susbcription of state.values.to.any.keys()) susbcription.unsubscribe();
+	if (state.values.to.keyed != null && state.values.to.keyed.size > 0) for (const values of state.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
 }
-function createSubscription(subscriptions, property, params) {
+function createSubscription(params) {
 	const parameters = createSubscriptionParameters(params);
 	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
+	const subscriptions = this[SUBSCRIPTION_SYMBOL];
 	const state = {
 		parameters,
+		subscriptions,
 		active: true
 	};
 	const existing = getExistingSubscription(subscriptions, state);
@@ -513,18 +561,7 @@ function createSubscription(subscriptions, property, params) {
 		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];
+	return [new Subscription(state, subscriptions.property, parameters), false];
 }
 function getExistingSubscription(subscriptions, state) {
 	const { values } = subscriptions;
@@ -558,9 +595,10 @@ function createSubscriptionsProperty(input) {
 		value: values.value == null ? SUBSCRIPTION_NAME : values.value
 	};
 }
-function createSubscriptionsState(keys) {
+function createSubscriptionsState(property, keys) {
 	return {
 		keys,
+		property,
 		items: {
 			any: /* @__PURE__ */ new Set(),
 			keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
@@ -587,16 +625,17 @@ function removeFromStore(items, values, subscription, value, key) {
 		values.to.keyed?.get(key)?.delete(subscription);
 	}
 }
-function removeSubscription(subscriptionsState, subscription, state) {
+function removeSubscription() {
+	const state = this[SUBSCRIPTION_SYMBOL];
 	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 { items, values } = state.subscriptions;
 	const { key, value } = state.parameters;
+	state.parameters = void 0;
+	state.subscriptions = void 0;
 	if (!isKey(key)) {
-		removeFromStore(items.any, values, subscription, value);
+		removeFromStore(items.any, values, this, value);
 		return;
 	}
 	const keyed = items.keyed?.get(key);
@@ -604,7 +643,7 @@ function removeSubscription(subscriptionsState, subscription, state) {
 	if (items.keyed == null || keyed == null)
  // istanbul ignore next
 	return;
-	removeFromStore(keyed, values, subscription, value, key);
+	removeFromStore(keyed, values, this, value, key);
 	if (keyed.size === 0) items.keyed.delete(key);
 }
 /**
@@ -614,35 +653,12 @@ function removeSubscription(subscriptionsState, subscription, state) {
 * @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);
+	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_NAME = "subscription";
-const SUBSCRIPTION_PROPERTY = "$subscriptions";
-const SUBSCRIPTION_STORE = "subscriptions";
+const SUBSCRIPTION_SYMBOL = Symbol(SUBSCRIPTION_PROPERTY);
 //#endregion
 //#region src/helpers/subscription.ts
 function subscribeToProxy(first, second, third) {
@@ -677,10 +693,8 @@ Computed.prototype[NAME_MORA] = NAME_COMPUTED;
 Computed.prototype.get = getComputedValue;
 Computed.prototype.peek = peekSignalValue;
 Computed.prototype.subscribe = subscribeToSignal;
+Computed.prototype.toJSON = getJsonValue;
 Computed.prototype.toString = getStringValue;
-Computed.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
 /**
 * Create a computed value
 *
@@ -705,7 +719,7 @@ function getComputedEffect(instance, callback) {
 		if (fx.dirty) {
 			const previousComputed = ACTIVE.computed;
 			ACTIVE.computed = fx;
-			handleSignalValue(instance, callback, setAndEmit$1, () => {
+			handleSignal(instance, callback, setAndEmit$1, () => {
 				ACTIVE.computed = previousComputed;
 			});
 			fx.dirty = false;
@@ -768,8 +782,12 @@ function getReactiveValueInProxy(instance, key) {
 	return item[0];
 }
 function getValueInProxy(first) {
-	if (this[SYMBOL_STATE].isArray ? typeof first === "number" : isKey(first)) return getReactiveValueInProxy(this, first).get();
-	return getSignalValue.call(this);
+	let signal;
+	if (this[SYMBOL_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);
 }
 function isProxyObject(isArray, value) {
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
@@ -783,23 +801,24 @@ function peekValueInProxy(first, second) {
 }
 function setProxyObject(state, value) {
 	if (state.isArray) {
-		state.value.splice(0, state.value.length, ...value ?? []);
+		const values = state.value;
+		values.splice(0, values.length, ...value ?? []);
 		return;
 	}
 	startBatch();
-	const actual = value ?? {};
-	const proxy = state.value;
-	const proxyKeys = Object.keys(proxy);
-	const actualKeys = Object.keys(actual);
-	let { length } = proxyKeys;
+	const current = state.value;
+	const next = value ?? {};
+	const currentKeys = Object.keys(current);
+	const nextKeys = Object.keys(next);
+	let { length } = currentKeys;
 	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
-		proxy[key] = actualKeys.includes(key) ? actual[key] : void 0;
+		const key = currentKeys[index];
+		current[key] = nextKeys.includes(key) ? next[key] : void 0;
 	}
-	length = actualKeys.length;
+	length = nextKeys.length;
 	for (let index = 0; index < length; index += 1) {
-		const key = actualKeys[index];
-		if (!proxyKeys.includes(key)) proxy[key] = actual[key];
+		const key = nextKeys[index];
+		if (!currentKeys.includes(key)) current[key] = next[key];
 	}
 	stopBatch();
 }
@@ -808,8 +827,10 @@ function setProxyProperty(state, property, value) {
 		state.value[property] = value;
 		return;
 	}
-	const actual = property < 0 ? state.value.length + property : property;
-	if (actual > -1) state.value[actual] = value;
+	const array = state.value;
+	const index = property;
+	const actual = index < 0 ? array.length + index : index;
+	if (actual > -1) array[actual] = value;
 }
 function setProxyValue(first, second) {
 	const state = this[SYMBOL_STATE];
@@ -821,34 +842,34 @@ function setProxyValue(first, second) {
 		setProxyObject(state, first);
 		return;
 	}
-	const property = state.isArray ? typeof first === "number" : isKey(first);
-	if (state.isArray && property && Number.isNaN(first)) return;
-	let actual = property ? second : first;
+	const keyed = isProxyKey(state.isArray, first);
+	if (state.isArray && keyed && Number.isNaN(first)) return;
+	let actual = keyed ? second : first;
 	if (typeof actual === "function") try {
 		actual = actual();
 	} catch {
 		return;
 	}
 	if (actual instanceof Promise) {
-		if (property) {
+		if (keyed) {
 			state.promises ??= /* @__PURE__ */ new Map();
 			state.promises.set(first, actual);
 		} else state.promise = actual;
 		actual.then((value) => {
-			if (property && state.promises.get(first) === actual) {
-				state.promises.delete(first);
+			if (keyed && state.promises?.get(first) === actual) {
+				state.promises?.delete(first);
 				setProxyProperty(state, first, value);
 				return;
 			}
-			if (!property && isProxyObject(state.isArray, value) && state.promise === actual) {
+			if (!keyed && isProxyObject(state.isArray, value) && state.promise === actual) {
 				state.promise = void 0;
 				setProxyObject(state, value);
 			}
 		}).catch(() => {
-			if (property && state.promises.get(first) === actual) state.promises.delete(first);
-			else if (!property && state.promise === actual) state.promise = void 0;
+			if (keyed && state.promises?.get(first) === actual) state.promises?.delete(first);
+			else if (!keyed && state.promise === actual) state.promise = void 0;
 		});
-	} else if (property) setProxyProperty(state, first, actual);
+	} else if (keyed) setProxyProperty(state, first, actual);
 	else if (isProxyObject(state.isArray, actual)) setProxyObject(state, actual);
 }
 function setValueInProxy(instance, target, property, value) {
@@ -871,60 +892,51 @@ function updateProxyValue(callback) {
 //#endregion
 //#region src/value/readonly.ts
 function Readonly(state, frozen) {
+	this[SUBSCRIPTION_TYPE_FROZEN] = frozen;
 	this[SYMBOL_STATE] = state;
-	Object.defineProperty(this, SUBSCRIPTION_TYPE_FROZEN, {
-		enumerable: true,
-		value: frozen
-	});
 }
 Readonly.prototype[NAME_MORA] = NAME_READONLY;
+Readonly.prototype.get = getReadonlyValue;
+Readonly.prototype.peek = peekReadonlyValue;
 Readonly.prototype.subscribe = subscribeToReadonly;
+Readonly.prototype.toJSON = getJsonValue;
 Readonly.prototype.toString = getStringValue;
-Readonly.prototype.get = function() {
-	return getReadonlyValue(this, false, this[SUBSCRIPTION_TYPE_FROZEN]);
-};
-Readonly.prototype.peek = function(copy) {
-	return getReadonlyValue(this, true, this[SUBSCRIPTION_TYPE_FROZEN], copy);
-};
-Readonly.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
-function getReadonlyInstance(frozen) {
+function getReadonlyInstance(state, frozen) {
+	return new Readonly(state, frozen);
+}
+function getReadonlySignal(frozen) {
 	const key = frozen === true ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_ORIGINAL;
 	this[SYMBOL_STATE].readonlies ??= {};
-	this[SYMBOL_STATE].readonlies[key] ??= getReadonlySignal(this[SYMBOL_STATE], frozen === true);
+	this[SYMBOL_STATE].readonlies[key] ??= getReadonlyInstance(this[SYMBOL_STATE], frozen === true);
 	return this[SYMBOL_STATE].readonlies[key];
 }
-function getReadonlySignal(state, frozen) {
-	return new Readonly(state, frozen);
+function getReadonlyValue() {
+	return handleReadonlyValue(this, false, this[SUBSCRIPTION_TYPE_FROZEN]);
 }
-function getReadonlyValue(instance, peek, frozen, copy) {
+function handleReadonlyValue(instance, peek, frozen, copy) {
 	let value;
 	if (peek) value = peekSignalValue.call(instance, copy === true);
 	else value = getSignalValue.call(instance);
 	return frozen ? getFrozenValue(value) : value;
 }
+function peekReadonlyValue(copy) {
+	return handleReadonlyValue(this, true, this[SUBSCRIPTION_TYPE_FROZEN], copy);
+}
 //#endregion
 //#region src/value/signal.ts
 function Signal(value, options) {
 	this[SYMBOL_STATE] = getState(void 0, options);
-	handleSignalValue(this, value, setAndEmit);
+	handleSignal(this, value, setAndEmit);
 }
 Signal.prototype[NAME_MORA] = NAME_SIGNAL;
-Signal.prototype.asReadonly = getReadonlyInstance;
+Signal.prototype.asReadonly = getReadonlySignal;
 Signal.prototype.get = getSignalValue;
 Signal.prototype.peek = peekSignalValue;
+Signal.prototype.set = setSignalValue;
 Signal.prototype.subscribe = subscribeToSignal;
 Signal.prototype.toString = getStringValue;
-Signal.prototype.set = function(value) {
-	return handleSignalValue(this, value, setAndEmit);
-};
-Signal.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
-Signal.prototype.update = function(callback) {
-	return updateSignalValue(this, callback, setAndEmit);
-};
+Signal.prototype.toJSON = getJsonValue;
+Signal.prototype.update = updateSignalValue;
 function setAndEmit(instance, value) {
 	const state = instance[SYMBOL_STATE];
 	if (!(state.equal ?? Object.is)(state.value, value)) {
@@ -932,9 +944,15 @@ function setAndEmit(instance, value) {
 		emitValue(instance);
 	}
 }
+function setSignalValue(value) {
+	handleSignal(this, value, setAndEmit);
+}
 function signal(value, options) {
 	return new Signal(value, options);
 }
+function updateSignalValue(callback) {
+	updateSignal(this, callback, setAndEmit);
+}
 //#endregion
 //#region src/value/array.ts
 function ReactiveArray(value, options) {
@@ -947,64 +965,76 @@ function ReactiveArray(value, options) {
 		get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(this, property, target) : Reflect.get(target, property),
 		set: (target, property, value) => setValueInProxy(this, target, property, value)
 	});
-	Object.defineProperty(this, PROPERTY_LENGTH, {
-		enumerable: true,
-		get: () => this[SYMBOL_STATE].length.get(),
-		set: (value) => setArrayLength(this[SYMBOL_STATE], value)
-	});
 	setProxyValue.call(this, value);
 }
 ReactiveArray.prototype[NAME_MORA] = NAME_ARRAY;
-ReactiveArray.prototype.asReadonly = getReadonlyInstance;
+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.filter = filterArrayValues;
 ReactiveArray.prototype.get = getArrayValues;
+ReactiveArray.prototype.map = mapArrayValues;
 ReactiveArray.prototype.notify = emitProxyValues;
 ReactiveArray.prototype.peek = peekArrayValue;
+ReactiveArray.prototype.pop = popArrayValue;
+ReactiveArray.prototype.push = pushArrayValues;
+ReactiveArray.prototype.select = selectArrayValues;
+ReactiveArray.prototype.shift = shiftArrayValue;
 ReactiveArray.prototype.set = setProxyValue;
+ReactiveArray.prototype.splice = spliceArrayValues;
 ReactiveArray.prototype.subscribe = subscribeToProxy;
 ReactiveArray.prototype.toString = getStringValue;
+ReactiveArray.prototype.toJSON = getJsonValue;
+ReactiveArray.prototype.unshift = unshiftArrayValues;
 ReactiveArray.prototype.update = updateProxyValue;
-ReactiveArray.prototype.clear = function() {
-	this[SYMBOL_STATE].value.length = 0;
-};
-ReactiveArray.prototype.filter = function(callback) {
-	return computed(() => filter(getArrayValues.call(this), callback));
-};
-ReactiveArray.prototype.map = function(callback) {
-	return computed(() => getArrayValues.call(this).map(callback));
-};
-ReactiveArray.prototype.pop = function() {
-	return this[SYMBOL_STATE].value.pop();
-};
-ReactiveArray.prototype.push = function(...items) {
-	return this[SYMBOL_STATE].value.push(...items);
-};
-ReactiveArray.prototype.select = function(filter, map) {
-	return computed(() => select(getArrayValues.call(this), filter, map));
-};
-ReactiveArray.prototype.shift = function() {
-	return this[SYMBOL_STATE].value.shift();
-};
-ReactiveArray.prototype.splice = function(from, to, ...items) {
-	return this[SYMBOL_STATE].value.splice(from, to ?? this[SYMBOL_STATE].value.length, ...items);
-};
-ReactiveArray.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
-ReactiveArray.prototype.unshift = function(...items) {
-	return this[SYMBOL_STATE].value.unshift(...items);
-};
 function array(value, options) {
 	return new ReactiveArray(value, options);
 }
+function clearArrayValues() {
+	this[SYMBOL_STATE].value.length = 0;
+}
+function filterArrayValues(callback) {
+	return computed(() => filter(getArrayValues.call(this), callback));
+}
+function getArrayLength() {
+	return this[SYMBOL_STATE].length.get();
+}
 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));
+}
 function peekArrayValue(first, second) {
 	return first === "length" ? this[SYMBOL_STATE].length.peek() : peekValueInProxy.call(this, first, second);
 }
-function setArrayLength(state, value) {
-	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== state.value.length) state.value.length = value;
+function popArrayValue() {
+	return this[SYMBOL_STATE].value.pop();
+}
+function pushArrayValues(...items) {
+	return this[SYMBOL_STATE].value.push(...items);
+}
+function selectArrayValues(filter, map) {
+	return computed(() => select(getArrayValues.call(this), filter, map));
+}
+function setArrayLength(value) {
+	const values = this[SYMBOL_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();
+}
+function spliceArrayValues(from, to, ...items) {
+	const values = this[SYMBOL_STATE].value;
+	return values.splice(from, to ?? values.length, ...items);
+}
+function unshiftArrayValues(...items) {
+	return this[SYMBOL_STATE].value.unshift(...items);
 }
 function updateArray(instance, type, array) {
 	const state = instance[SYMBOL_STATE];
@@ -1013,7 +1043,7 @@ function updateArray(instance, type, array) {
 	const previousLength = array.length;
 	return (...args) => {
 		const result = array[type](...args);
-		if (affectsLength ? array.length !== previousLength : !equalArrays(state, previousArray, array)) {
+		if (affectsLength ? array.length !== previousLength : !equalArrays(previousArray, array, state.equal)) {
 			emitValue(instance);
 			state.length.set(array.length);
 		}
@@ -1031,17 +1061,15 @@ function ReactiveStore(value, options) {
 	setProxyValue.call(this, value);
 }
 ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
-ReactiveStore.prototype.asReadonly = getReadonlyInstance;
+ReactiveStore.prototype.asReadonly = getReadonlySignal;
 ReactiveStore.prototype.get = getValueInProxy;
 ReactiveStore.prototype.notify = emitProxyValues;
 ReactiveStore.prototype.peek = peekValueInProxy;
 ReactiveStore.prototype.set = setProxyValue;
 ReactiveStore.prototype.subscribe = subscribeToProxy;
+ReactiveStore.prototype.toJSON = getJsonValue;
 ReactiveStore.prototype.toString = getStringValue;
 ReactiveStore.prototype.update = updateProxyValue;
-ReactiveStore.prototype.toJSON = function() {
-	return this[SYMBOL_STATE].value;
-};
 function store(value, options) {
 	return new ReactiveStore(value, options);
 }