@oscarpalmer/mora 0.32.0 → 0.33.0

package/dist/mora.full.mjs

@@ -34,6 +34,9 @@ const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_SIGNAL,
 	NAME_STORE
 ]);
+const PROPERTY_LENGTH = "length";
+const SYMBOL_EFFECT = Symbol("effect");
+const SYMBOL_STATE = Symbol("state");
 const SUBSCRIPTION_PROPERTY$1 = {
 	key: NAME_MORA,
 	value: NAME_SUBSCRIPTION
@@ -50,6 +53,11 @@ const SUBSCRIPTION_TYPES = /* @__PURE__ */ new Set([
 ]);
 //#endregion
 //#region src/effect.ts
+function Effect(callback) {
+	this[SYMBOL_STATE] = { callback };
+	runEffect(this[SYMBOL_STATE]);
+}
+Effect.prototype[NAME_MORA] = NAME_EFFECT;
 /**
 * Create an effect
 *
@@ -61,10 +69,8 @@ function effect(callback) {
 	return getEffect(callback)[0];
 }
 function getEffect(callback) {
-	const state = { callback };
-	const instance = Object.freeze({ [NAME_MORA]: NAME_EFFECT });
-	runEffect(state);
-	return [instance, state];
+	const instance = new Effect(callback);
+	return [instance, instance[SYMBOL_STATE]];
 }
 function internalEffect(callback) {
 	return getEffect(callback)[1];
@@ -103,13 +109,15 @@ function isPlainObject(value) {
 }
 //#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);
+function emitValue(instance) {
+	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);
 	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, {
+		if (subscriptions != null && subscriptions.size > 0) for (const [subscription, callback] of subscriptions) BATCH.handlers.set(subscription, {
 			callback,
+			instance,
 			state,
 			frozen: type === SUBSCRIPTION_TYPE_FROZEN,
 			copy: SUBSCRIPTION_TYPES_COPY.has(type)
@@ -118,16 +126,17 @@ function emitValue(state) {
 	if (BATCH.depth === 0) flushHandlers();
 }
 function equalArrays(state, first, second) {
-	let { length } = first;
+	const { length } = first;
 	if (length !== second.length) return false;
+	const eq = state.equal ?? Object.is;
 	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;
+		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;
 	}
-	length -= offset;
-	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
+	const end = length - offset;
+	for (let index = offset; index < end; index += 1) if (!eq(first[index], second[index])) return false;
 	return true;
 }
 function getFrozenValue(value) {
@@ -136,12 +145,22 @@ function getFrozenValue(value) {
 	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 getSignalValue() {
+	if (ACTIVE.computed != null) {
+		this[SYMBOL_STATE].computeds ??= /* @__PURE__ */ new Set();
+		this[SYMBOL_STATE].computeds.add(ACTIVE.computed);
+	}
+	if (ACTIVE.effect != null) {
+		this[SYMBOL_STATE].effects ??= /* @__PURE__ */ new Set();
+		this[SYMBOL_STATE].effects.add(ACTIVE.effect);
+	}
+	return this[SYMBOL_STATE].value;
 }
-function handleSimpleValue(state, origin, setValue, onAfter) {
+function getStringValue(json) {
+	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
+}
+function handleSignalValue(instance, origin, setValue, onAfter) {
+	const state = instance[SYMBOL_STATE];
 	try {
 		let actual = typeof origin === "function" ? origin() : origin;
 		if (actual instanceof Promise) {
@@ -149,26 +168,26 @@ function handleSimpleValue(state, origin, setValue, onAfter) {
 			actual.then((value) => {
 				if (actual === state.promise) {
 					state.promise = void 0;
-					setValue(state, value);
+					setValue(instance, value);
 				}
 			}).catch(() => {
 				if (actual === state.promise) state.promise = void 0;
 			});
-		} else setValue(state, actual);
+		} else setValue(instance, actual);
 	} catch {} finally {
 		onAfter?.();
 	}
 }
-function peekSimpleValue(value, copy) {
-	let peeked = value;
-	if (!copy) return peeked;
+function peekSignalValue(copy) {
+	let peeked = Array.isArray(this) ? this[1] : this[SYMBOL_STATE].value;
+	if (copy !== true) return peeked;
 	if (Array.isArray(peeked)) peeked = peeked.slice();
 	else if (isPlainObject(peeked)) peeked = { ...peeked };
 	return peeked;
 }
-function updateSimpleValue(state, callback, setValue) {
+function updateSignalValue(instance, callback, setValue) {
 	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	handleSimpleValue(state, callback(state.value), setValue);
+	handleSignalValue(instance, callback(instance[SYMBOL_STATE].value), setValue);
 }
 //#endregion
 //#region src/batch.ts
@@ -183,7 +202,7 @@ function flushHandlers() {
 			for (let index = 0; index < length; index += 1) {
 				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));
+				if (typeof subscription.frozen === "boolean") subscription.callback(subscription.frozen ? getFrozenValue(subscription.state.value) : peekSignalValue.call(subscription.instance, subscription.copy));
 				else runEffect(handler);
 			}
 		}
@@ -423,6 +442,14 @@ function filter(array, ...parameters) {
 filter.remove = exclude;
 Object.defineProperty(filter, "remove", { value: exclude });
 //#endregion
+//#region src/helpers/misc.ts
+function getState(value, options) {
+	return {
+		value,
+		equal: typeof options === "object" && typeof options?.equal === "function" ? options.equal : void 0
+	};
+}
+//#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/internal/abort.mjs
 function createAborter(value, onAbort) {
 	if (!(value instanceof AbortSignal)) return;
@@ -618,41 +645,42 @@ 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 subscribeToProxy(first, second, third) {
+	if (isKey(first)) return getReactiveValueInProxy(this, first).subscribe(second, third);
+	return subscribeToSignal.call(this, first, second);
 }
-function subscribeToReactive(type, state, callback) {
-	state.subscriptions ??= subscriptions({
+function subscribeToReactive(type, subscriber) {
+	this[SYMBOL_STATE].subscriptions ??= subscriptions({
 		keys: SUBSCRIPTION_TYPES,
 		property: SUBSCRIPTION_PROPERTY$1
 	});
-	const [subscription, existing] = state.subscriptions.create({
+	const [subscription, existing] = this[SYMBOL_STATE].subscriptions.create({
 		key: type,
-		value: callback
+		value: subscriber
 	});
-	if (!existing) callback(type === "frozen" ? getFrozenValue(state.value) : peekSimpleValue(state.value, SUBSCRIPTION_TYPES_COPY.has(type)));
+	if (!existing) subscriber(type === "frozen" ? getFrozenValue(this[SYMBOL_STATE].value) : peekSignalValue.call(this, SUBSCRIPTION_TYPES_COPY.has(type)), subscription);
 	return subscription;
 }
-function subscribeToSignal(state, callback, copy) {
-	return subscribeToReactive(copy ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL, state, callback);
+function subscribeToReadonly(subscriber) {
+	return subscribeToReactive.call(this, this.frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY, subscriber);
 }
-//#endregion
-//#region src/value/reactive.ts
-function reactive(value, options) {
-	const state = {
-		computeds: /* @__PURE__ */ new Set(),
-		effects: /* @__PURE__ */ new Set(),
-		equal: typeof options === "object" && typeof options?.equal === "function" ? options.equal : Object.is,
-		value
-	};
-	return [{
-		toJSON: () => state.value,
-		toString: () => String(state.value)
-	}, state];
+function subscribeToSignal(subscriber, copy) {
+	return subscribeToReactive.call(this, copy === true ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL, subscriber);
 }
 //#endregion
 //#region src/value/computed.ts
+function Computed(callback, options) {
+	this[SYMBOL_STATE] = getState(void 0, options);
+	this[SYMBOL_EFFECT] = getComputedEffect(this, callback);
+}
+Computed.prototype[NAME_MORA] = NAME_COMPUTED;
+Computed.prototype.get = getComputedValue;
+Computed.prototype.peek = peekSignalValue;
+Computed.prototype.subscribe = subscribeToSignal;
+Computed.prototype.toString = getStringValue;
+Computed.prototype.toJSON = function() {
+	return this[SYMBOL_STATE].value;
+};
 /**
 * Create a computed value
 *
@@ -665,19 +693,10 @@ function computed(callback, options) {
 }
 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: (copy) => peekSimpleValue(state.value, copy === true),
-		subscribe: (callback, copy) => subscribeToSignal(state, callback, copy === true)
-	};
-	Object.defineProperty(instance, NAME_MORA, { value: NAME_COMPUTED });
-	fx = getComputedEffect(state, callback);
-	return [Object.freeze(instance), fx];
+	const instance = new Computed(callback, options);
+	return [instance, instance[SYMBOL_EFFECT]];
 }
-function getComputedEffect(state, callback) {
+function getComputedEffect(instance, callback) {
 	const fx = {
 		dirty: true,
 		instance: void 0
@@ -686,7 +705,7 @@ function getComputedEffect(state, callback) {
 		if (fx.dirty) {
 			const previousComputed = ACTIVE.computed;
 			ACTIVE.computed = fx;
-			handleSimpleValue(state, callback, setAndEmit$1, () => {
+			handleSignalValue(instance, callback, setAndEmit$1, () => {
 				ACTIVE.computed = previousComputed;
 			});
 			fx.dirty = false;
@@ -694,69 +713,116 @@ function getComputedEffect(state, callback) {
 	});
 	return fx;
 }
-function getValue(state, fx) {
-	if (ACTIVE.computed != null && fx !== ACTIVE.computed) state.computeds.add(ACTIVE.computed);
-	if (ACTIVE.effect != null && ACTIVE.effect !== fx.instance) state.effects.add(ACTIVE.effect);
+function getComputedValue() {
+	const fx = this[SYMBOL_EFFECT];
+	const state = this[SYMBOL_STATE];
+	if (ACTIVE.computed != null && fx !== ACTIVE.computed) {
+		state.computeds ??= /* @__PURE__ */ new Set();
+		state.computeds.add(ACTIVE.computed);
+	}
+	if (ACTIVE.effect != null && ACTIVE.effect !== fx.instance) {
+		state.effects ??= /* @__PURE__ */ new Set();
+		state.effects.add(ACTIVE.effect);
+	}
 	if (fx.dirty && BATCH.depth === 0) runEffect(fx.instance);
 	return state.value;
 }
 function internalComputed(callback, options) {
 	return getComputed(callback, options);
 }
-function setAndEmit$1(state, value) {
-	if (state.equal(state.value, value)) return;
+function setAndEmit$1(instance, value) {
+	const state = instance[SYMBOL_STATE];
+	if ((state.equal ?? Object.is)(state.value, value)) return;
 	state.value = value;
-	for (const computed of state.computeds) computed.dirty = true;
-	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) computed.dirty = true;
+	if (state.effects != null && state.effects.size > 0) 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));
+		if (subscriptions != null && subscriptions.size > 0) {
+			const copy = SUBSCRIPTION_TYPES_COPY.has(type);
+			for (const [, callback] of subscriptions) callback(peekSignalValue.call(instance, copy));
+		}
 	}
 	flushHandlers();
 }
 //#endregion
 //#region src/helpers/proxy.ts
-function emitProxyValues(state, mapped) {
-	const values = [...mapped.values()];
+function emitProxyValues() {
+	const state = this[SYMBOL_STATE];
+	state.mapped ??= /* @__PURE__ */ new Map();
+	const values = [...state.mapped.values()];
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) values[index][1].dirty = true;
-	emitValue(state);
+	emitValue(this);
 }
-function getReactiveValueInProxy(reactive, mapped, key, isArray) {
+function getReactiveValueInProxy(instance, key) {
+	const state = instance[SYMBOL_STATE];
+	state.mapped ??= /* @__PURE__ */ new Map();
 	const mapKey = String(key);
-	let item = mapped.get(mapKey);
+	let item = state.mapped.get(mapKey);
 	if (item == null) {
-		item = internalComputed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
-		mapped.set(mapKey, item);
+		item = internalComputed(() => state.isArray ? instance.get().at(key) : instance.get()[key]);
+		state.mapped.set(mapKey, item);
 	}
 	return item[0];
 }
-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 getValueInProxy(first) {
+	if (this[SYMBOL_STATE].isArray ? typeof first === "number" : isKey(first)) return getReactiveValueInProxy(this, first).get();
+	return getSignalValue.call(this);
 }
 function isProxyObject(isArray, value) {
 	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
 }
-function peekValueInProxy(isArray, state, first, second) {
+function peekValueInProxy(first, second) {
+	const state = this[SYMBOL_STATE];
 	let value;
-	if (isArray ? typeof first === "number" : isKey(first)) value = isArray ? state.value.at(first) : state.value[first];
+	if (state.isArray ? typeof first === "number" : isKey(first)) value = state.isArray ? state.value.at(first) : state.value[first];
 	else value = state.value;
-	return peekSimpleValue(value, first === true || second === true);
+	return peekSignalValue.call([this, value], first === true || second === true);
+}
+function setProxyObject(state, value) {
+	if (state.isArray) {
+		state.value.splice(0, state.value.length, ...value ?? []);
+		return;
+	}
+	startBatch();
+	const actual = value ?? {};
+	const proxy = state.value;
+	const proxyKeys = Object.keys(proxy);
+	const actualKeys = Object.keys(actual);
+	let { length } = proxyKeys;
+	for (let index = 0; index < length; index += 1) {
+		const key = proxyKeys[index];
+		proxy[key] = actualKeys.includes(key) ? actual[key] : void 0;
+	}
+	length = actualKeys.length;
+	for (let index = 0; index < length; index += 1) {
+		const key = actualKeys[index];
+		if (!proxyKeys.includes(key)) proxy[key] = actual[key];
+	}
+	stopBatch();
+}
+function setProxyProperty(state, property, value) {
+	if (!state.isArray) {
+		state.value[property] = value;
+		return;
+	}
+	const actual = property < 0 ? state.value.length + property : property;
+	if (actual > -1) state.value[actual] = value;
 }
-function setProxyValue(isArray, state, setObject, setProperty, first, second) {
-	if (isArray && first === "length") {
+function setProxyValue(first, second) {
+	const state = this[SYMBOL_STATE];
+	if (state.isArray && first === "length") {
 		state.value.length = second;
 		return;
 	}
-	if (isProxyObject(isArray, first)) {
-		setObject(state, first);
+	if (isProxyObject(state.isArray, first)) {
+		setProxyObject(state, first);
 		return;
 	}
-	const property = isArray ? typeof first === "number" : isKey(first);
-	if (isArray && property && Number.isNaN(first)) return;
+	const property = state.isArray ? typeof first === "number" : isKey(first);
+	if (state.isArray && property && Number.isNaN(first)) return;
 	let actual = property ? second : first;
 	if (typeof actual === "function") try {
 		actual = actual();
@@ -771,208 +837,213 @@ function setProxyValue(isArray, state, setObject, setProperty, first, second) {
 		actual.then((value) => {
 			if (property && state.promises.get(first) === actual) {
 				state.promises.delete(first);
-				setProperty(state, first, value);
+				setProxyProperty(state, first, value);
 				return;
 			}
-			if (!property && isProxyObject(isArray, value) && state.promise === actual) {
+			if (!property && isProxyObject(state.isArray, value) && state.promise === actual) {
 				state.promise = void 0;
-				setObject(state, value);
+				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;
 		});
-	} else if (property) setProperty(state, first, actual);
-	else if (isProxyObject(isArray, actual)) setObject(state, actual);
+	} else if (property) setProxyProperty(state, first, actual);
+	else if (isProxyObject(state.isArray, actual)) setProxyObject(state, actual);
 }
-function setValueInProxy(isArray, state, target, property, value, length) {
-	if (isArray) {
+function setValueInProxy(instance, target, property, value) {
+	const state = instance[SYMBOL_STATE];
+	if (state.isArray) {
 		if (!(!Number.isNaN(Number(property)) || property === "length")) return Reflect.set(target, property, value);
 	}
 	const previous = Reflect.get(target, property);
-	if (!state.equal(previous, value)) {
+	if (!(state.equal ?? Object.is)(previous, value)) {
 		Reflect.set(target, property, value);
-		emitValue(state);
-		if (isArray) length?.set(target.length);
+		emitValue(instance);
+		if (state.isArray) state.length?.set(target.length);
 	}
 	return true;
 }
-function updateProxyValue(isArray, state, setObject, setProperty, callback) {
+function updateProxyValue(callback) {
 	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
-	setProxyValue(isArray, state, setObject, setProperty, callback(state.value));
+	setProxyValue.call(this, callback(this[SYMBOL_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 Readonly(state, frozen) {
+	this[SYMBOL_STATE] = state;
+	Object.defineProperty(this, SUBSCRIPTION_TYPE_FROZEN, {
+		enumerable: true,
+		value: frozen
+	});
+}
+Readonly.prototype[NAME_MORA] = NAME_READONLY;
+Readonly.prototype.subscribe = subscribeToReadonly;
+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) {
+	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);
+	return this[SYMBOL_STATE].readonlies[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);
+	return new Readonly(state, frozen);
 }
-function getReadonlyValue(state, peek, frozen, copy) {
+function getReadonlyValue(instance, peek, frozen, copy) {
 	let value;
-	if (peek) value = peekSimpleValue(state.value, copy === true);
-	else value = getSimpleValue(state);
+	if (peek) value = peekSignalValue.call(instance, copy === true);
+	else value = getSignalValue.call(instance);
 	return frozen ? getFrozenValue(value) : value;
 }
 //#endregion
 //#region src/value/signal.ts
-function setAndEmit(state, value) {
-	if (!state.equal(state.value, value)) {
+function Signal(value, options) {
+	this[SYMBOL_STATE] = getState(void 0, options);
+	handleSignalValue(this, value, setAndEmit);
+}
+Signal.prototype[NAME_MORA] = NAME_SIGNAL;
+Signal.prototype.asReadonly = getReadonlyInstance;
+Signal.prototype.get = getSignalValue;
+Signal.prototype.peek = peekSignalValue;
+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);
+};
+function setAndEmit(instance, value) {
+	const state = instance[SYMBOL_STATE];
+	if (!(state.equal ?? Object.is)(state.value, value)) {
 		state.value = value;
-		emitValue(state);
+		emitValue(instance);
 	}
 }
 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: (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, { value: NAME_SIGNAL });
-	handleSimpleValue(state, value, setAndEmit);
-	return Object.freeze(instance);
+	return new Signal(value, options);
 }
 //#endregion
 //#region src/value/array.ts
-function array(value, options) {
-	const [rx, state] = reactive([], options);
-	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(isArray, state, target, property, value, length)
-	});
-	function get(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,
-		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, frozen === true),
-		at: (index) => get(index),
-		clear: () => {
-			state.value.length = 0;
-		},
-		filter: (callback) => computed(() => filter(get(), callback)),
-		get: (value) => get(value),
-		map: (callback) => computed(() => get().map(callback)),
-		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) => set(first, second),
-		shift: () => state.value.shift(),
-		splice: (from, to, ...items) => state.value.splice(from, to ?? state.value.length, ...items),
-		subscribe: (first, second, third) => subscribeToProxy(isArray, instance, state, mapped, first, second, third),
-		unshift: (...items) => state.value.unshift(...items),
-		update: (callback) => updateProxyValue(true, state, setArrayValue, setAtIndex, callback)
+function ReactiveArray(value, options) {
+	this[SYMBOL_STATE] = {
+		...getState(void 0, options),
+		isArray: true,
+		length: signal(0)
 	};
-	Object.defineProperties(instance, {
-		[NAME_MORA]: { value: NAME_ARRAY },
-		length: {
-			enumerable: true,
-			get: () => length.get(),
-			set: (value) => setArrayLength(state, value)
-		}
+	this[SYMBOL_STATE].value = new Proxy([], {
+		get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(this, property, target) : Reflect.get(target, property),
+		set: (target, property, value) => setValueInProxy(this, target, property, value)
 	});
-	set(value);
-	return Object.freeze(instance);
+	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;
+ReactiveArray.prototype.at = getArrayValues;
+ReactiveArray.prototype.get = getArrayValues;
+ReactiveArray.prototype.notify = emitProxyValues;
+ReactiveArray.prototype.peek = peekArrayValue;
+ReactiveArray.prototype.set = setProxyValue;
+ReactiveArray.prototype.subscribe = subscribeToProxy;
+ReactiveArray.prototype.toString = getStringValue;
+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 peekArrayValue(state, length, first, second) {
-	return first === "length" ? length.peek() : peekValueInProxy(true, state, first, second);
+function getArrayValues(value) {
+	return value === "length" ? this[SYMBOL_STATE].length.get() : getValueInProxy.call(this, value);
+}
+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 setArrayValue(state, value) {
-	state.value.splice(0, 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;
-}
-function updateArray(type, array, state, length) {
+function updateArray(instance, type, array) {
+	const state = instance[SYMBOL_STATE];
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
 	const previousArray = affectsLength ? [] : array.slice();
 	const previousLength = array.length;
 	return (...args) => {
 		const result = array[type](...args);
 		if (affectsLength ? array.length !== previousLength : !equalArrays(state, previousArray, array)) {
-			emitValue(state);
-			length.set(array.length);
+			emitValue(instance);
+			state.length.set(array.length);
 		}
 		return result;
 	};
 }
 //#endregion
 //#region src/value/store.ts
-function setPropertyValue(state, key, value) {
-	state.value[key] = value;
-}
-function setStoreValue(state, value) {
-	startBatch();
-	const actual = value ?? {};
-	const proxy = state.value;
-	const proxyKeys = Object.keys(proxy);
-	const actualKeys = Object.keys(actual);
-	let { length } = proxyKeys;
-	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
-		proxy[key] = actualKeys.includes(key) ? actual[key] : void 0;
-	}
-	length = actualKeys.length;
-	for (let index = 0; index < length; index += 1) {
-		const key = actualKeys[index];
-		if (!proxyKeys.includes(key)) proxy[key] = actual[key];
-	}
-	stopBatch();
-}
-function store(value, options) {
-	const [rx, state] = reactive(void 0, options);
-	const isArray = false;
-	const keyed = /* @__PURE__ */ new Map();
-	const readonlies = {};
-	state.value = new Proxy({}, { set: (target, property, value) => setValueInProxy(isArray, state, target, property, value) });
-	const instance = {
-		...rx,
-		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)
+function ReactiveStore(value, options) {
+	this[SYMBOL_STATE] = {
+		...getState(void 0, options),
+		isArray: false
 	};
-	Object.defineProperty(instance, NAME_MORA, { value: NAME_STORE });
-	instance.set(value);
-	return Object.freeze(instance);
+	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 = getReadonlyInstance;
+ReactiveStore.prototype.get = getValueInProxy;
+ReactiveStore.prototype.notify = emitProxyValues;
+ReactiveStore.prototype.peek = peekValueInProxy;
+ReactiveStore.prototype.set = setProxyValue;
+ReactiveStore.prototype.subscribe = subscribeToProxy;
+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);
 }
 //#endregion
 export { array, computed, effect, isComputed, isEffect, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal, signal, startBatch, stopBatch, store };