@oscarpalmer/mora 0.31.0 → 0.33.0

package/dist/mora.full.mjs

@@ -3,7 +3,7 @@ const ACTIVE = {};
 const BATCH = {
 	depth: 0,
 	flushing: false,
-	handlers: /* @__PURE__ */ new Set()
+	handlers: /* @__PURE__ */ new Map()
 };
 const METHODS_AFFECTING_LENGTH = /* @__PURE__ */ new Set([
 	"pop",
@@ -26,6 +26,7 @@ const NAME_MORA = "$mora";
 const NAME_READONLY = "readonly";
 const NAME_SIGNAL = "signal";
 const NAME_STORE = "store";
+const NAME_SUBSCRIPTION = "subscription";
 const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_ARRAY,
 	NAME_COMPUTED,
@@ -33,8 +34,30 @@ 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
+};
+const SUBSCRIPTION_TYPE_COPY = "copy";
+const SUBSCRIPTION_TYPE_FROZEN = "frozen";
+const SUBSCRIPTION_TYPE_ORIGINAL = "original";
+const SUBSCRIPTION_TYPE_READONLY = "readonly";
+const SUBSCRIPTION_TYPES_COPY = /* @__PURE__ */ new Set([SUBSCRIPTION_TYPE_COPY, SUBSCRIPTION_TYPE_READONLY]);
+const SUBSCRIPTION_TYPES = /* @__PURE__ */ new Set([
+	...SUBSCRIPTION_TYPES_COPY,
+	SUBSCRIPTION_TYPE_FROZEN,
+	SUBSCRIPTION_TYPE_ORIGINAL
+]);
 //#endregion
 //#region src/effect.ts
+function Effect(callback) {
+	this[SYMBOL_STATE] = { callback };
+	runEffect(this[SYMBOL_STATE]);
+}
+Effect.prototype[NAME_MORA] = NAME_EFFECT;
 /**
 * Create an effect
 *
@@ -46,10 +69,8 @@ function effect(callback) {
 	return getEffect(callback)[0];
 }
 function getEffect(callback) {
-	const state = { callback };
-	const instance = Object.freeze({ $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];
@@ -64,6 +85,111 @@ function runEffect(state) {
 	}
 }
 //#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
+/**
+* Is the value a _Key_?
+*
+* @param value Value to check
+* @returns `true` if the value is a _Key_ _(`number` or `string`)_, otherwise `false`
+*/
+function isKey(value) {
+	return typeof value === "number" || typeof value === "string";
+}
+/**
+* Is the value a plain object?
+*
+* @param value Value to check
+* @returns `true` if the value is a plain object, otherwise `false`
+*/
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+}
+//#endregion
+//#region src/helpers/value.ts
+function emitValue(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 && 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)
+		});
+	}
+	if (BATCH.depth === 0) flushHandlers();
+}
+function equalArrays(state, first, second) {
+	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 (!(eq(first[index], second[index]) && eq(first[length - index - 1], second[length - index - 1]))) 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) {
+	let frozen = value;
+	if (Array.isArray(frozen)) frozen = Object.freeze(frozen.slice());
+	else if (isPlainObject(frozen)) frozen = Object.freeze({ ...frozen });
+	return frozen;
+}
+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 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) {
+			state.promise = actual;
+			actual.then((value) => {
+				if (actual === state.promise) {
+					state.promise = void 0;
+					setValue(instance, value);
+				}
+			}).catch(() => {
+				if (actual === state.promise) state.promise = void 0;
+			});
+		} else setValue(instance, actual);
+	} catch {} finally {
+		onAfter?.();
+	}
+}
+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 updateSignalValue(instance, callback, setValue) {
+	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+	handleSignalValue(instance, callback(instance[SYMBOL_STATE].value), setValue);
+}
+//#endregion
 //#region src/batch.ts
 function flushHandlers() {
 	if (BATCH.flushing) return;
@@ -74,8 +200,9 @@ function flushHandlers() {
 			const { length } = handlers;
 			BATCH.handlers.clear();
 			for (let index = 0; index < length; index += 1) {
-				const handler = handlers[index];
-				if (typeof handler.destroy === "function") handler.callback(handler.state.value);
+				const [, handler] = handlers[index];
+				const subscription = handler;
+				if (typeof subscription.frozen === "boolean") subscription.callback(subscription.frozen ? getFrozenValue(subscription.state.value) : peekSignalValue.call(subscription.instance, subscription.copy));
 				else runEffect(handler);
 			}
 		}
@@ -157,6 +284,12 @@ function isReactiveArray(value) {
 function isReactiveStore(value) {
 	return isMora(value, NAME_STORE);
 }
+/**
+* Is the value a readonly signal?
+*
+* @param value Value to check
+* @returns True if value is a {@link ReadonlySignal}
+*/
 function isReadonlySignal(value) {
 	return isMora(value, NAME_READONLY);
 }
@@ -167,6 +300,7 @@ function getArrayCallback(value) {
 		case "function": return value;
 		case "number":
 		case "string": return typeof value === "string" && value.includes(".") ? void 0 : (obj) => obj[value];
+		default: return;
 	}
 }
 function getArrayCallbacks(bool, key, value) {
@@ -178,10 +312,18 @@ function getArrayCallbacks(bool, key, value) {
 }
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/internal/array/find.mjs
+function createFindParameters(original) {
+	const { length } = original;
+	return {
+		bool: length === 1 && typeof original[0] === "function" ? original[0] : void 0,
+		key: length === 2 ? original[0] : void 0,
+		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
+	};
+}
 function findValue(type, array, parameters, reversed) {
 	const findIndex = type === FIND_VALUE_INDEX;
 	if (!Array.isArray(array) || array.length === 0) return findIndex ? -1 : void 0;
-	const { bool, key, value } = getFindParameters(parameters);
+	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
 	if (callbacks?.bool == null && callbacks?.keyed == null) {
 		if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
@@ -208,18 +350,22 @@ function findValues(type, array, parameters, mapper) {
 	};
 	if (!Array.isArray(array) || array.length === 0) return result;
 	const { length } = array;
-	const { bool, key, value } = getFindParameters(parameters);
+	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && length >= UNIQUE_THRESHOLD) {
+	if (type === "unique" && callbacks?.keyed == null && length >= FIND_UNIQUE_THRESHOLD) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
-	const mapCallback = getArrayCallback(mapper);
+	const mapCallback = getArrayCallback(mapper?.callback);
+	const mapReverse = mapper?.reverse ?? false;
+	const mapAfter = mapCallback == null ? void 0 : mapReverse ? void 0 : mapCallback;
+	const mapBefore = mapCallback == null ? void 0 : mapReverse ? mapCallback : void 0;
 	if (callbacks?.bool != null || type === "all" && key == null) {
 		const callback = callbacks?.bool ?? ((item) => Object.is(item, value));
 		for (let index = 0; index < length; index += 1) {
 			const item = array[index];
-			if (callback(item, index, array)) result.matched.push(mapCallback?.(item, index, array) ?? item);
+			const transformed = mapBefore?.(item, index, array) ?? item;
+			if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
 			else result.notMatched.push(item);
 		}
 		return result;
@@ -227,71 +373,64 @@ function findValues(type, array, parameters, mapper) {
 	const keys = /* @__PURE__ */ new Set();
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
-		const keyed = callbacks?.keyed?.(item, index, array) ?? item;
+		let keyed;
+		let transformed;
+		if (mapBefore == null) {
+			keyed = callbacks?.keyed?.(item, index, array) ?? item;
+			transformed = item;
+		} else {
+			transformed = mapBefore(item, index, array);
+			keyed = callbacks?.keyed?.(transformed, index, array) ?? transformed;
+		}
 		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
 			keys.add(keyed);
-			result.matched.push(mapCallback?.(item, index, array) ?? item);
+			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
 		} else result.notMatched.push(item);
 	}
 	return result;
 }
-function getFindParameters(original) {
-	const { length } = original;
-	return {
-		bool: length === 1 && typeof original[0] === "function" ? original[0] : void 0,
-		key: length === 2 ? original[0] : void 0,
-		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
-	};
-}
 const FIND_VALUE_INDEX = "index";
 const FIND_VALUE_ITEM = "item";
-const UNIQUE_THRESHOLD = 100;
+const FIND_UNIQUE_THRESHOLD = 100;
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/internal/array/index-of.mjs
 function indexOf(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, false);
 }
-indexOf.last = lastIndexOf;
 function lastIndexOf(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, true);
 }
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
-/**
-* Is the value a _Key_?
-*
-* @param value Value to check
-* @returns `true` if the value is a _Key_ _(`number` or `string`)_, otherwise `false`
-*/
-function isKey(value) {
-	return typeof value === "number" || typeof value === "string";
-}
-/**
-* Is the value a plain object?
-*
-* @param value Value to check
-* @returns `true` if the value is a plain object, otherwise `false`
-*/
-function isPlainObject(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
-}
+indexOf.last = lastIndexOf;
+Object.defineProperty(indexOf, "last", { value: lastIndexOf });
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/array/find.mjs
 function find(array, ...parameters) {
 	return findValue(FIND_VALUE_ITEM, array, parameters, false);
 }
-find.last = findLast;
 function findLast(array, ...parameters) {
 	return findValue(FIND_VALUE_ITEM, array, parameters, true);
 }
+find.last = findLast;
+Object.defineProperty(find, "last", { value: findLast });
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/array/select.mjs
+function reverseSelect(array, ...parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.shift(),
+		reverse: true
+	}).matched;
+}
 function select(array, ...parameters) {
-	return findValues("all", array, parameters, parameters.pop()).matched;
+	return selectValues(array, parameters);
+}
+function selectValues(array, parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.pop(),
+		reverse: false
+	}).matched;
 }
+select.reverse = reverseSelect;
+Object.defineProperty(select, "reverse", { value: reverseSelect });
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/array/filter.mjs
 function exclude(array, ...parameters) {
@@ -301,99 +440,247 @@ function filter(array, ...parameters) {
 	return findValues("all", array, parameters).matched;
 }
 filter.remove = exclude;
+Object.defineProperty(filter, "remove", { value: exclude });
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/function/misc.mjs
-/**
-* A function that does nothing, which can be useful, I guess…
-*/
-function noop$1() {}
+//#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 src/helpers/value.ts
-function emitValue(state) {
-	for (const computed of state.computeds) computed.dirty = true;
-	for (const effect of state.effects) BATCH.handlers.add(effect);
-	for (const [, subscription] of state.subscriptions) BATCH.handlers.add(subscription);
-	if (BATCH.depth === 0) flushHandlers();
+//#region node_modules/@oscarpalmer/atoms/dist/internal/abort.mjs
+function createAborter(value, onAbort) {
+	if (!(value instanceof AbortSignal)) return;
+	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);
+	return {
+		callback: onAbort,
+		signal: value,
+		cancel: () => value.removeEventListener(ABORT_EVENT, onAbort)
+	};
 }
-function equalArrays(state, first, second) {
-	let { length } = first;
-	if (length !== second.length) return false;
-	let offset = 0;
-	if (length >= 100) {
-		offset = Math.round(length / 10);
-		offset = offset > 25 ? 25 : offset;
-		for (let index = 0; index < offset; index += 1) if (!state.equal(first[index], second[index])) return false;
+const ABORT_EVENT = "abort";
+const ABORT_OPTIONS = { once: true };
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/subscription.mjs
+function addSubscription(subscriptions, subscription, state) {
+	const { items, values } = subscriptions;
+	const { key, value } = state.parameters;
+	if (!isKey(key)) {
+		items.any.add(subscription);
+		values.from.any.set(value, subscription);
+		values.to.any.set(subscription, value);
+		return;
 	}
-	length -= offset;
-	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
-	return true;
+	/* istanbul ignore if */
+	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
+ // istanbul ignore next
+	return;
+	let keyedItems = items.keyed.get(key);
+	if (keyedItems == null) {
+		keyedItems = /* @__PURE__ */ new Set();
+		items.keyed.set(key, keyedItems);
+	}
+	keyedItems.add(subscription);
+	let keyedFrom = values.from.keyed.get(key);
+	if (keyedFrom == null) {
+		keyedFrom = /* @__PURE__ */ new Map();
+		values.from.keyed.set(key, keyedFrom);
+	}
+	keyedFrom.set(value, subscription);
+	let keyedTo = values.to.keyed.get(key);
+	if (keyedTo == null) {
+		keyedTo = /* @__PURE__ */ new Map();
+		values.to.keyed.set(key, keyedTo);
+	}
+	keyedTo.set(subscription, value);
 }
-function getSimpleValue(state) {
-	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
-	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
-	return state.value;
+function clearSubscriptions(store) {
+	for (const susbcription of store.values.to.any.keys()) susbcription.unsubscribe();
+	if (store.values.to.keyed != null) for (const values of store.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
 }
-function handleSimpleValue(state, origin, setValue, onAfter) {
-	try {
-		let actual = typeof origin === "function" ? origin() : origin;
-		if (actual instanceof Promise) {
-			state.promise = actual;
-			actual.then((value) => {
-				if (actual === state.promise) {
-					state.promise = void 0;
-					setValue(state, value);
-				}
-			}).catch(() => {
-				if (actual === state.promise) state.promise = void 0;
-			});
-		} else setValue(state, actual);
-	} catch {} finally {
-		onAfter?.();
+function createSubscription(subscriptions, property, params) {
+	const parameters = createSubscriptionParameters(params);
+	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
+	const state = {
+		parameters,
+		active: true
+	};
+	const existing = getExistingSubscription(subscriptions, state);
+	if (existing != null) return [existing, true];
+	if (subscriptions.keys != null && isKey(parameters.key)) {
+		if (subscriptions.keys === false) throw new Error(SUBSCRIPTION_DISALLOWED_KEY);
+		else if (subscriptions.keys !== true && !subscriptions.keys.has(parameters.key)) throw new Error(SUBSCRIPTION_INVALID_KEY);
 	}
+	state.aborter = createAborter(parameters.signal, () => unsubscribe(subscriptions, instance, state));
+	const instance = { unsubscribe: () => unsubscribe(subscriptions, instance, state) };
+	Object.defineProperties(instance, {
+		[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_NAME },
+		[property.key]: { value: property.value },
+		active: {
+			enumerable: true,
+			get: () => (parameters.isActive?.() ?? true) && state.active
+		}
+	});
+	addSubscription(subscriptions, instance, state);
+	return [Object.freeze(instance), false];
 }
-//#endregion
-//#region src/subscription.ts
-function noop() {}
-function subscribe(state, callback) {
-	if (typeof callback !== "function" || state.subscriptions.has(callback)) return noop;
-	state.subscriptions.set(callback, subscription(state, callback));
-	return () => {
-		unsubscribe(state, callback);
+function getExistingSubscription(subscriptions, state) {
+	const { values } = subscriptions;
+	const { parameters } = state;
+	return isKey(parameters.key) ? values.from.keyed?.get(parameters.key)?.get(parameters.value) : values.from.any.get(parameters.value);
+}
+function createSubscriptionParameters(input) {
+	const values = isPlainObject(input) ? input : {};
+	if (values.value == null) throw new Error(SUBSCRIPTION_INVALID_VALUE);
+	return {
+		isActive: typeof values.isActive === "function" ? values.isActive : void 0,
+		key: isKey(values.key) ? values.key : void 0,
+		signal: values.signal instanceof AbortSignal ? values.signal : void 0,
+		value: values.value
 	};
 }
-function subscription(state, callback) {
-	const instance = {
-		callback,
-		state,
-		destroy: () => {
-			instance.callback = noop;
-			instance.state = void 0;
+function createSubscriptionsParameters(input) {
+	const values = isPlainObject(input) ? input : {};
+	let keys;
+	if (values.keys instanceof Set) keys = values.keys;
+	else keys = typeof values.keys === "boolean" ? values.keys : false;
+	return {
+		keys,
+		property: createSubscriptionsProperty(values.property)
+	};
+}
+function createSubscriptionsProperty(input) {
+	const values = isPlainObject(input) ? input : {};
+	return {
+		key: typeof values.key === "string" ? values.key : SUBSCRIPTION_PROPERTY,
+		value: values.value == null ? SUBSCRIPTION_NAME : values.value
+	};
+}
+function createSubscriptionsState(keys) {
+	return {
+		keys,
+		items: {
+			any: /* @__PURE__ */ new Set(),
+			keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
+		},
+		values: {
+			from: {
+				any: /* @__PURE__ */ new Map(),
+				keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
+			},
+			to: {
+				any: /* @__PURE__ */ new Map(),
+				keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
+			}
 		}
 	};
-	callback(state.value);
-	return instance;
 }
-function unsubscribe(state, callback) {
-	state.subscriptions.get(callback)?.destroy();
-	state.subscriptions.delete(callback);
+function removeFromStore(items, values, subscription, value, key) {
+	items.delete(subscription);
+	if (key == null) {
+		values.from.any.delete(value);
+		values.to.any.delete(subscription);
+	} else {
+		values.from.keyed?.get(key)?.delete(value);
+		values.to.keyed?.get(key)?.delete(subscription);
+	}
 }
-//#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,
-		subscriptions: /* @__PURE__ */ new Map(),
-		value
+function removeSubscription(subscriptionsState, subscription, state) {
+	if (!state.active) return;
+	state.aborter = void 0;
+	state.active = false;
+	state.parameters.isActive = void 0;
+	state.parameters.signal = void 0;
+	const { items, values } = subscriptionsState;
+	const { key, value } = state.parameters;
+	if (!isKey(key)) {
+		removeFromStore(items.any, values, subscription, value);
+		return;
+	}
+	const keyed = items.keyed?.get(key);
+	/* istanbul ignore if */
+	if (items.keyed == null || keyed == null)
+ // istanbul ignore next
+	return;
+	removeFromStore(keyed, values, subscription, value, key);
+	if (keyed.size === 0) items.keyed.delete(key);
+}
+/**
+* Create a subscription store
+*
+* @param parameters Store parameters
+* @returns Subscription store
+*/
+function subscriptions(parameters) {
+	const { keys, property } = createSubscriptionsParameters(parameters);
+	const state = createSubscriptionsState(keys);
+	const instance = {
+		clear: () => clearSubscriptions(state),
+		create: (parameters) => createSubscription(state, property, parameters)
 	};
-	return [{
-		toJSON: () => state.value,
-		toString: () => String(state.value)
-	}, state];
+	Object.defineProperties(instance, {
+		[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_STORE },
+		items: {
+			enumerable: true,
+			value: state.items
+		},
+		values: {
+			enumerable: true,
+			value: state.values
+		}
+	});
+	return Object.freeze(instance);
+}
+function unsubscribe(subscriptionsState, subscription, state) {
+	state.aborter?.cancel();
+	removeSubscription(subscriptionsState, subscription, state);
+}
+const SUBSCRIPTION_DISALLOWED_KEY = "Disallowed key for subscription";
+const SUBSCRIPTION_INVALID_KEY = "Invalid key for subscription";
+const SUBSCRIPTION_INVALID_VALUE = "A subscription requires a non-null value to identify it";
+const SUBSCRIPTION_NAME = "subscription";
+const SUBSCRIPTION_PROPERTY = "$subscriptions";
+const SUBSCRIPTION_STORE = "subscriptions";
+//#endregion
+//#region src/helpers/subscription.ts
+function subscribeToProxy(first, second, third) {
+	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({
+		keys: SUBSCRIPTION_TYPES,
+		property: SUBSCRIPTION_PROPERTY$1
+	});
+	const [subscription, existing] = this[SYMBOL_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);
+	return subscription;
+}
+function subscribeToReadonly(subscriber) {
+	return subscribeToReactive.call(this, this.frozen ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_READONLY, subscriber);
+}
+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
 *
@@ -405,25 +692,11 @@ function computed(callback, options) {
 	return getComputed(callback, options)[0];
 }
 function getComputed(callback, options) {
-	const [rx, state] = reactive(void 0, options);
-	let fx;
-	const instance = {
-		...rx,
-		get: () => getValue(state, fx),
-		peek: () => state.value,
-		subscribe: (callback) => subscribe(state, callback),
-		unsubscribe: (callback) => {
-			state.subscriptions.delete(callback);
-		}
-	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		value: NAME_COMPUTED
-	});
-	fx = getComputedEffect(state, callback);
-	return [Object.freeze(instance), fx];
+	if (typeof callback !== "function") throw new TypeError("Computed callback must be a function");
+	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
@@ -432,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;
@@ -440,50 +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.add(effect);
-	for (const [, subscription] of state.subscriptions) subscription.callback(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);
+	for (const type of SUBSCRIPTION_TYPES) {
+		if (type === "frozen") continue;
+		const subscriptions = state.subscriptions?.values.to.keyed?.get(type);
+		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 emityProxyValues(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) {
-	let item = mapped.get(key);
+function getReactiveValueInProxy(instance, key) {
+	const state = instance[SYMBOL_STATE];
+	state.mapped ??= /* @__PURE__ */ new Map();
+	const mapKey = String(key);
+	let item = state.mapped.get(mapKey);
 	if (item == null) {
-		item = internalComputed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
-		mapped.set(key, item);
+		item = internalComputed(() => state.isArray ? instance.get().at(key) : instance.get()[key]);
+		state.mapped.set(mapKey, item);
 	}
 	return item[0];
 }
-function setProxyValue(array, state, isObject, isProperty, setObject, setProperty, first, second) {
-	if (array && first === "length") {
+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(first, second) {
+	const state = this[SYMBOL_STATE];
+	let value;
+	if (state.isArray ? typeof first === "number" : isKey(first)) value = state.isArray ? state.value.at(first) : state.value[first];
+	else value = state.value;
+	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(first, second) {
+	const state = this[SYMBOL_STATE];
+	if (state.isArray && first === "length") {
 		state.value.length = second;
 		return;
 	}
-	if (isObject(first)) {
-		setObject(state, first);
+	if (isProxyObject(state.isArray, first)) {
+		setProxyObject(state, first);
 		return;
 	}
-	const property = isProperty(first);
-	if (array && 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();
@@ -498,305 +837,213 @@ function setProxyValue(array, state, isObject, isProperty, setObject, setPropert
 		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 && isObject(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 (isObject(actual)) setObject(state, actual);
+	} else if (property) setProxyProperty(state, first, actual);
+	else if (isProxyObject(state.isArray, actual)) setProxyObject(state, actual);
 }
-function setValueInProxy(parameters) {
-	const { isArray, length, property, state, target, value } = parameters;
-	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(callback) {
+	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+	setProxyValue.call(this, callback(this[SYMBOL_STATE].value));
+}
 //#endregion
 //#region src/value/readonly.ts
-function getReadonlyInstance(state, instances, handlers, frozen) {
-	const key = frozen ? "frozen" : "original";
-	instances[key] ??= getReadonlySignal(state, handlers, frozen);
-	return instances[key];
-}
-function getReadonlySignal(state, handlers, frozen) {
-	const instance = {
-		...handlers,
-		get: () => getReadonlyValue(state, false, frozen),
-		peek: () => getReadonlyValue(state, true, frozen)
-	};
-	Object.defineProperties(instance, {
-		[NAME_MORA]: {
-			enumerable: false,
-			value: NAME_READONLY
-		},
-		frozen: {
-			enumerable: true,
-			value: frozen
-		}
+function Readonly(state, frozen) {
+	this[SYMBOL_STATE] = state;
+	Object.defineProperty(this, SUBSCRIPTION_TYPE_FROZEN, {
+		enumerable: true,
+		value: frozen
 	});
-	return Object.freeze(instance);
 }
-function getReadonlyValue(state, peek, frozen) {
-	let value = peek ? state.value : getSimpleValue(state);
-	if (!frozen) return value;
-	if (Array.isArray(state.value)) value = [...state.value];
-	else if (isPlainObject(state.value)) value = { ...state.value };
-	else value = state.value;
-	return Object.freeze(value);
+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) {
+	return new Readonly(state, frozen);
+}
+function getReadonlyValue(instance, peek, frozen, copy) {
+	let value;
+	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 handlers = {
-		...rx,
-		subscribe: (callback) => subscribe(state, callback),
-		unsubscribe: (callback) => {
-			state.subscriptions.delete(callback);
-		}
-	};
-	const instance = {
-		...handlers,
-		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, handlers, frozen === true),
-		get: () => getSimpleValue(state),
-		peek: () => state.value,
-		set: (value) => {
-			handleSimpleValue(state, value, setAndEmit);
-		},
-		update: (callback) => {
-			handleSimpleValue(state, callback(state.value), setAndEmit);
-		}
-	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		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 indiced = /* @__PURE__ */ new Map();
-	const length = signal(0);
-	const readonlies = {};
-	let instance = {};
-	state.value = new Proxy([], {
-		get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(property, target, state, length) : Reflect.get(target, property),
-		set: (target, property, value) => setValueInProxy({
-			length,
-			property,
-			state,
-			target,
-			value,
-			isArray: true
-		})
-	});
-	function get(value) {
-		return getArrayValue(instance, indiced, state, length, value);
-	}
-	function set(first, second) {
-		setProxyValue(true, state, isArrayValue, isArrayIndex, setArray, setAtIndex, first, second);
-	}
-	const handlers = {
-		...rx,
-		get: (value) => get(value),
-		peek: (first, second) => peekArrayValue(state, length, first, second),
-		subscribe: (first, second) => {
-			if (typeof first === "number" && typeof second === "function") return getReactiveValueInProxy(instance, indiced, first, true).subscribe(second);
-			return typeof first === "function" ? subscribe(state, first) : noop$1;
-		},
-		unsubscribe: (first, second) => {
-			if (typeof first === "number" && typeof second === "function") getReactiveValueInProxy(instance, indiced, first, true)?.unsubscribe(second);
-			else if (typeof first === "function") unsubscribe(state, first);
-		}
-	};
-	instance = {
-		...handlers,
-		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, handlers, frozen === true),
-		at: (index) => get(index),
-		clear: () => {
-			state.value.length = 0;
-		},
-		filter: (callback) => computed(() => filter(get(), callback)),
-		map: (callback) => computed(() => get().map(callback)),
-		notify: () => {
-			emityProxyValues(state, indiced);
-		},
-		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),
-		unshift: (...items) => state.value.unshift(...items),
-		update: (callback) => updateArrayValue(instance, state, callback)
+function ReactiveArray(value, options) {
+	this[SYMBOL_STATE] = {
+		...getState(void 0, options),
+		isArray: true,
+		length: signal(0)
 	};
-	Object.defineProperties(instance, {
-		[NAME_MORA]: {
-			enumerable: false,
-			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);
-}
-function getArrayValue(instance, indiced, state, length, first) {
-	if (typeof first === "number") return getReactiveValueInProxy(instance, indiced, first, true).get();
-	return first === "length" ? length.get() : getSimpleValue(state);
-}
-function isArrayIndex(value) {
-	return typeof value === "number";
-}
-function isArrayValue(value) {
-	return value == null || Array.isArray(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;
+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) {
-	if (first === "length") return length.peek();
-	let value;
-	if (typeof first === "number") value = state.value.at(first);
-	else value = state.value;
-	if (!(first === true || second === true)) return value;
-	if (Array.isArray(value)) return value.slice();
-	if (isPlainObject(value)) return { ...value };
-	return value;
+function getArrayValues(value) {
+	return value === "length" ? this[SYMBOL_STATE].length.get() : getValueInProxy.call(this, value);
 }
-function setArray(state, value) {
-	state.value.splice(0, state.value.length, ...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" && value >= 0 && value !== state.value.length) state.value.length = value;
-}
-function setAtIndex(state, index, value) {
-	const actual = index < 0 ? state.value.length + index : index;
-	if (actual > -1) state.value[actual] = value;
+	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== state.value.length) state.value.length = 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;
 	};
 }
-function updateArrayValue(instance, state, callback) {
-	const updated = callback(state.value);
-	if (updated == null || Array.isArray(updated)) instance.set(updated);
-}
 //#endregion
 //#region src/value/store.ts
-function isStoreObject(value) {
-	return value == null || isPlainObject(value);
-}
-function setObject(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 peekStoreValue(state, first, second) {
-	let value;
-	if (isKey(first)) value = state.value[first];
-	else value = state.value;
-	if (!(first === true || second === true)) return value;
-	if (Array.isArray(value)) return value.slice();
-	if (isPlainObject(value)) return { ...value };
-	return value;
-}
-function setProperty(state, key, value) {
-	state.value[key] = value;
-}
-function store(value, options) {
-	const [rx, state] = reactive(void 0, options);
-	const keyed = /* @__PURE__ */ new Map();
-	const readonlies = {};
-	let instance = {};
-	state.value = new Proxy({}, { set: (target, property, value) => setValueInProxy({
-		target,
-		property,
-		state,
-		value,
+function ReactiveStore(value, options) {
+	this[SYMBOL_STATE] = {
+		...getState(void 0, options),
 		isArray: false
-	}) });
-	const handlers = {
-		...rx,
-		get: (value) => isKey(value) ? getReactiveValueInProxy(instance, keyed, value, false).get() : getSimpleValue(state),
-		peek: (first, second) => peekStoreValue(state, first, second),
-		subscribe: (first, second) => {
-			if (isKey(first) && typeof second === "function") return getReactiveValueInProxy(instance, keyed, first, false).subscribe(second);
-			return typeof first === "function" ? subscribe(state, first) : noop;
-		},
-		unsubscribe: (first, second) => {
-			if (isKey(first) && typeof second === "function") getReactiveValueInProxy(instance, keyed, first, false)?.unsubscribe(second);
-			else if (typeof first === "function") unsubscribe(state, first);
-		}
-	};
-	instance = {
-		...handlers,
-		asReadonly: (frozen) => getReadonlyInstance(state, readonlies, handlers, frozen === true),
-		notify() {
-			emityProxyValues(state, keyed);
-		},
-		set: (first, second) => {
-			setProxyValue(false, state, isStoreObject, isKey, setObject, setProperty, first, second);
-		},
-		update: (callback) => {
-			const updated = callback(state.value);
-			if (updated == null || isPlainObject(updated)) setObject(state, updated);
-		}
 	};
-	Object.defineProperty(instance, NAME_MORA, {
-		enumerable: false,
-		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 };