@oscarpalmer/mora 0.29.0 → 0.31.0

package/dist/mora.full.mjs

@@ -2,15 +2,16 @@
 const ACTIVE = {};
 const BATCH = {
 	depth: 0,
+	flushing: false,
 	handlers: /* @__PURE__ */ new Set()
 };
-const METHODS_AFFECTING_LENGTH = new Set([
+const METHODS_AFFECTING_LENGTH = /* @__PURE__ */ new Set([
 	"pop",
 	"push",
 	"shift",
 	"unshift"
 ]);
-const METHODS_UPDATE = new Set([
+const METHODS_UPDATE = /* @__PURE__ */ new Set([
 	...METHODS_AFFECTING_LENGTH,
 	"copyWithin",
 	"fill",
@@ -22,52 +23,86 @@ const NAME_ARRAY = "array";
 const NAME_COMPUTED = "computed";
 const NAME_EFFECT = "effect";
 const NAME_MORA = "$mora";
+const NAME_READONLY = "readonly";
 const NAME_SIGNAL = "signal";
 const NAME_STORE = "store";
-const NAME_ALL = new Set([
+const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_ARRAY,
 	NAME_COMPUTED,
+	NAME_READONLY,
 	NAME_SIGNAL,
 	NAME_STORE
 ]);
 //#endregion
 //#region src/effect.ts
-var Effect = class {
-	constructor(callback) {
-		Object.defineProperty(this, NAME_MORA, { value: NAME_EFFECT });
-		this.state = { callback };
-		runEffect(this);
-	}
-};
-function runEffect(effect) {
+/**
+* Create an effect
+*
+* @param callback Callback for handling signal effects
+* @returns Effect
+*/
+function effect(callback) {
+	if (typeof callback !== "function") throw new TypeError("Effect callback must be a function");
+	return getEffect(callback)[0];
+}
+function getEffect(callback) {
+	const state = { callback };
+	const instance = Object.freeze({ $mora: NAME_EFFECT });
+	runEffect(state);
+	return [instance, state];
+}
+function internalEffect(callback) {
+	return getEffect(callback)[1];
+}
+function runEffect(state) {
 	const previousEffect = ACTIVE.effect;
-	ACTIVE.effect = effect;
+	ACTIVE.effect = state;
 	try {
-		effect.state.callback();
+		state.callback();
 	} finally {
 		ACTIVE.effect = previousEffect;
 	}
 }
+//#endregion
+//#region src/batch.ts
+function flushHandlers() {
+	if (BATCH.flushing) return;
+	BATCH.flushing = true;
+	try {
+		while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
+			const handlers = [...BATCH.handlers];
+			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);
+				else runEffect(handler);
+			}
+		}
+	} finally {
+		BATCH.flushing = false;
+	}
+}
 /**
-* Create an effect
-* @param callback Callback for handling signal effects
-* @returns Effect
+* Start batching effects
+*
+* _(Use {@link stopBatch} to flush and run batched effects)_
 */
-function effect(callback) {
-	return typeof callback === "function" ? new Effect(callback) : void 0;
+function startBatch() {
+	BATCH.depth += 1;
 }
-//#endregion
-//#region src/helpers/is.ts
 /**
-* Is the value a reactive array?
-* @param value Value to check
-* @returns True if value is a {@link ReactiveArray}
+* Stop batching effects and flush _(run)_ them
 */
-function isArray(value) {
-	return isMora(value, NAME_ARRAY);
+function stopBatch() {
+	if (BATCH.depth > 0) BATCH.depth -= 1;
+	flushHandlers();
 }
+//#endregion
+//#region src/helpers/is.ts
 /**
 * Is the value a computed signal?
+*
 * @param value Value to check
 * @returns True if value is a {@link Computed}
 */
@@ -76,6 +111,7 @@ function isComputed(value) {
 }
 /**
 * Is the value an effect?
+*
 * @param value Value to check
 * @returns True if value is an {@link Effect}
 */
@@ -87,6 +123,7 @@ function isMora(value, name) {
 }
 /**
 * Is the value reactive?
+*
 * @param value Value to check
 * @returns True if value is a {@link Reactive}
 */
@@ -95,196 +132,143 @@ function isReactive(value) {
 }
 /**
 * Is the value a signal?
+*
 * @param value Value to check
 * @returns True if value is a {@link Signal}
 */
 function isSignal(value) {
 	return isMora(value, NAME_SIGNAL);
 }
-//#endregion
-//#region src/batch.ts
-function flushHandlers() {
-	while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
-		const handlers = [...BATCH.handlers];
-		BATCH.handlers.clear();
-		for (const handler of handlers) if (isEffect(handler)) runEffect(handler);
-		else handler.callback(handler.state.value);
-	}
-}
 /**
-* Start batching effects
+* Is the value a reactive array?
 *
-* _(Use {@link stopBatch} to flush and run batched effects)_
+* @param value Value to check
+* @returns True if value is a {@link ReactiveArray}
 */
-function startBatch() {
-	BATCH.depth += 1;
+function isReactiveArray(value) {
+	return isMora(value, NAME_ARRAY);
 }
 /**
-* Stop batching effects and flush _(run)_ them
+* Is the value a reactive store?
+*
+* @param value Value to check
+* @returns True if value is a {@link Store}
 */
-function stopBatch() {
-	if (BATCH.depth > 0) BATCH.depth -= 1;
-	flushHandlers();
+function isReactiveStore(value) {
+	return isMora(value, NAME_STORE);
+}
+function isReadonlySignal(value) {
+	return isMora(value, NAME_READONLY);
 }
 //#endregion
-//#region src/subscription.ts
-var Subscription = class {
-	callback;
-	state;
-	constructor(state, callback) {
-		this.state = state;
-		this.callback = callback;
-		callback(state.value);
-	}
-	destroy() {
-		this.callback = noop;
-		this.state = void 0;
-	}
-};
-function noop() {}
-function subscribe(state, callback) {
-	if (typeof callback !== "function" || state.subscriptions.has(callback)) return noop;
-	state.subscriptions.set(callback, new Subscription(state, callback));
-	return () => {
-		unsubscribe(state, callback);
+//#region node_modules/@oscarpalmer/atoms/dist/internal/array/callbacks.mjs
+function getArrayCallback(value) {
+	switch (typeof value) {
+		case "function": return value;
+		case "number":
+		case "string": return typeof value === "string" && value.includes(".") ? void 0 : (obj) => obj[value];
+	}
+}
+function getArrayCallbacks(bool, key, value) {
+	if (typeof bool === "function") return { bool };
+	return {
+		keyed: getArrayCallback(key),
+		value: getArrayCallback(value)
 	};
 }
-function unsubscribe(state, callback) {
-	state.subscriptions.get(callback)?.destroy();
-	state.subscriptions.delete(callback);
-}
 //#endregion
-//#region src/value/reactive.ts
-var Reactive = class {
-	/**
-	* Internal state of the reactive value
-	*
-	* @internal
-	*/
-	state = {
-		computeds: /* @__PURE__ */ new Set(),
-		effects: /* @__PURE__ */ new Set(),
-		equal: Object.is,
-		subscriptions: /* @__PURE__ */ new Map(),
-		value: void 0
-	};
-	constructor(name, value, options) {
-		this.state.value = value;
-		if (typeof options === "object" && typeof options.equal === "function") this.state.equal = options.equal;
-		Object.defineProperty(this, NAME_MORA, { value: name });
-	}
-	/**
-	* Get the value _(without reactivity)_
-	* @return Current value
-	*/
-	peek() {
-		return this.state.value;
-	}
-	/**
-	* Subscribe to changes
-	* @param callback Callback for changes
-	* @return Unsubscribe callback
-	*/
-	subscribe(callback) {
-		return subscribe(this.state, callback);
-	}
-	/**
-	* JSON representation of the value
-	* @return JSON value
-	*/
-	toJSON() {
-		return this.get();
-	}
-	/**
-	* String representation of the value
-	* @return Value as string
-	*/
-	toString() {
-		return String(this.get());
-	}
-	/**
-	* Unsubscribe from changes
-	* @param callback Callback to unsubscribe
-	*/
-	unsubscribe(callback) {
-		unsubscribe(this.state, callback);
+//#region node_modules/@oscarpalmer/atoms/dist/internal/array/find.mjs
+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 callbacks = getArrayCallbacks(bool, key);
+	if (callbacks?.bool == null && callbacks?.keyed == null) {
+		if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
+		return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
+	}
+	if (callbacks.bool != null) {
+		const index = reversed ? array.findLastIndex(callbacks.bool) : array.findIndex(callbacks.bool);
+		return findIndex ? index : array[index];
+	}
+	return findValueInArray(array, callbacks.keyed, value, findIndex, reversed);
+}
+function findValueInArray(array, callback, value, findIndex, reversed) {
+	const { length } = array;
+	for (let index = 0; index < length; index += 1) {
+		const item = reversed ? array.at(-(index + 1)) : array[index];
+		if (Object.is(callback?.(item, index, array), value)) return findIndex ? index : item;
 	}
-};
-//#endregion
-//#region src/value/computed.ts
-var Computed = class extends Reactive {
-	effect = {
-		dirty: true,
-		instance: void 0
+	return findIndex ? -1 : void 0;
+}
+function findValues(type, array, parameters, mapper) {
+	const result = {
+		matched: [],
+		notMatched: []
 	};
-	constructor(callback, options) {
-		super(NAME_COMPUTED, void 0, options);
-		this.effect.instance = effect(() => {
-			if (this.effect.dirty) {
-				setValue$1(this, this.state, callback);
-				this.effect.dirty = false;
-			}
-		});
+	if (!Array.isArray(array) || array.length === 0) return result;
+	const { length } = array;
+	const { bool, key, value } = getFindParameters(parameters);
+	const callbacks = getArrayCallbacks(bool, key);
+	if (type === "unique" && callbacks?.keyed == null && length >= UNIQUE_THRESHOLD) {
+		result.matched = [...new Set(array)];
+		return result;
 	}
-	/**
-	* @inheritdoc
-	*/
-	get() {
-		if (ACTIVE.computed != null && this !== ACTIVE.computed) this.state.computeds.add(ACTIVE.computed);
-		if (ACTIVE.effect != null && ACTIVE.effect !== this.effect.instance) this.state.effects.add(ACTIVE.effect);
-		if (this.effect.dirty && BATCH.depth === 0) runEffect(this.effect.instance);
-		return this.state.value;
+	const mapCallback = getArrayCallback(mapper);
+	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);
+			else result.notMatched.push(item);
+		}
+		return result;
 	}
-};
-/**
-* Create a computed value
-* @param callback Callback to compute the value
-* @param options Reactivity options
-* @returns Computed value
-*/
-function computed(callback, options) {
-	return new Computed(callback, options);
+	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;
+		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
+			keys.add(keyed);
+			result.matched.push(mapCallback?.(item, index, array) ?? item);
+		} 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]
+	};
 }
-function setAndEmit$1(state, value) {
-	if (state.equal(state.value, value)) return;
-	state.value = value;
-	for (const computed of state.computeds) computed.effect.dirty = true;
-	for (const effect of state.effects) BATCH.handlers.add(effect);
-	for (const [, subscription] of state.subscriptions) subscription.callback(value);
-	flushHandlers();
+const FIND_VALUE_INDEX = "index";
+const FIND_VALUE_ITEM = "item";
+const UNIQUE_THRESHOLD = 100;
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/array/index-of.mjs
+function indexOf(array, ...parameters) {
+	return findValue(FIND_VALUE_INDEX, array, parameters, false);
 }
-function setValue$1(instance, state, callback) {
-	const previousComputed = ACTIVE.computed;
-	ACTIVE.computed = instance;
-	try {
-		const value = callback();
-		if (value instanceof Promise) {
-			state.promise = value;
-			value.then((resolvedValue) => {
-				if (state.promise === value) {
-					state.promise = void 0;
-					setAndEmit$1(state, resolvedValue);
-				}
-			}).catch(() => {
-				if (state.promise === value) state.promise = void 0;
-			});
-		} else setAndEmit$1(state, value);
-	} finally {
-		ACTIVE.computed = previousComputed;
-	}
+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?
+* Is the value a _Key_?
+*
 * @param value Value to check
-* @returns `true` if the value is a `Key` _(`number` or `string`)_, otherwise `false`
+* @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`
 */
@@ -295,26 +279,38 @@ function isPlainObject(value) {
 	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
 }
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/math.mjs
-/**
-* Round a number
-* @param value Number to round
-* @param decimals Number of decimal places to round to _(defaults to `0`)_
-* @returns Rounded number, or `NaN` if the value if unable to be rounded
-*/
-function round(value, decimals) {
-	return roundNumber(Math.round, value, decimals);
+//#region node_modules/@oscarpalmer/atoms/dist/array/find.mjs
+function find(array, ...parameters) {
+	return findValue(FIND_VALUE_ITEM, array, parameters, false);
 }
-function roundNumber(callback, value, decimals) {
-	if (typeof value !== "number") return NaN;
-	if (typeof decimals !== "number" || decimals < 1) return callback(value);
-	const mod = 10 ** decimals;
-	return callback((value + Number.EPSILON) * mod) / mod;
+find.last = findLast;
+function findLast(array, ...parameters) {
+	return findValue(FIND_VALUE_ITEM, array, parameters, true);
+}
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/array/select.mjs
+function select(array, ...parameters) {
+	return findValues("all", array, parameters, parameters.pop()).matched;
 }
 //#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/array/filter.mjs
+function exclude(array, ...parameters) {
+	return findValues("all", array, parameters).notMatched;
+}
+function filter(array, ...parameters) {
+	return findValues("all", array, parameters).matched;
+}
+filter.remove = exclude;
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/function/misc.mjs
+/**
+* A function that does nothing, which can be useful, I guess…
+*/
+function noop$1() {}
+//#endregion
 //#region src/helpers/value.ts
 function emitValue(state) {
-	for (const computed of state.computeds) computed.effect.dirty = true;
+	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();
@@ -324,7 +320,7 @@ function equalArrays(state, first, second) {
 	if (length !== second.length) return false;
 	let offset = 0;
 	if (length >= 100) {
-		offset = round(length / 10);
+		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;
 	}
@@ -332,26 +328,150 @@ function equalArrays(state, first, second) {
 	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
 	return true;
 }
-function getValue(state) {
+function getSimpleValue(state) {
 	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
 	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
 	return state.value;
 }
+function handleSimpleValue(state, origin, setValue, onAfter) {
+	try {
+		let actual = typeof origin === "function" ? origin() : origin;
+		if (actual instanceof Promise) {
+			state.promise = actual;
+			actual.then((value) => {
+				if (actual === state.promise) {
+					state.promise = void 0;
+					setValue(state, value);
+				}
+			}).catch(() => {
+				if (actual === state.promise) state.promise = void 0;
+			});
+		} else setValue(state, actual);
+	} catch {} finally {
+		onAfter?.();
+	}
+}
+//#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 subscription(state, callback) {
+	const instance = {
+		callback,
+		state,
+		destroy: () => {
+			instance.callback = noop;
+			instance.state = void 0;
+		}
+	};
+	callback(state.value);
+	return instance;
+}
+function unsubscribe(state, callback) {
+	state.subscriptions.get(callback)?.destroy();
+	state.subscriptions.delete(callback);
+}
+//#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
+	};
+	return [{
+		toJSON: () => state.value,
+		toString: () => String(state.value)
+	}, state];
+}
+//#endregion
+//#region src/value/computed.ts
+/**
+* Create a computed value
+*
+* @param callback Callback to compute the value
+* @param options Reactivity options
+* @returns Computed value
+*/
+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];
+}
+function getComputedEffect(state, callback) {
+	const fx = {
+		dirty: true,
+		instance: void 0
+	};
+	fx.instance = internalEffect(() => {
+		if (fx.dirty) {
+			const previousComputed = ACTIVE.computed;
+			ACTIVE.computed = fx;
+			handleSimpleValue(state, callback, setAndEmit$1, () => {
+				ACTIVE.computed = previousComputed;
+			});
+			fx.dirty = false;
+		}
+	});
+	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);
+	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;
+	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);
+	flushHandlers();
+}
 //#endregion
 //#region src/helpers/proxy.ts
 function emityProxyValues(state, mapped) {
 	const values = [...mapped.values()];
 	const { length } = values;
-	for (let index = 0; index < length; index += 1) values[index].effect.dirty = true;
+	for (let index = 0; index < length; index += 1) values[index][1].dirty = true;
 	emitValue(state);
 }
 function getReactiveValueInProxy(reactive, mapped, key, isArray) {
 	let item = mapped.get(key);
 	if (item == null) {
-		item = computed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
+		item = internalComputed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
 		mapped.set(key, item);
 	}
-	return item;
+	return item[0];
 }
 function setProxyValue(array, state, isObject, isProperty, setObject, setProperty, first, second) {
 	if (array && first === "length") {
@@ -406,190 +526,153 @@ function setValueInProxy(parameters) {
 	return true;
 }
 //#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
+		}
+	});
+	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);
+}
+//#endregion
 //#region src/value/signal.ts
-var Signal = class extends Reactive {
-	constructor(value, options) {
-		super(NAME_SIGNAL, value, options);
-	}
-	/**
-	* @inheritdoc
-	*/
-	get() {
-		return getValue(this.state);
-	}
-	/**
-	* Set the value
-	* @param value New value
-	*/
-	set(value) {
-		setValue(this.state, value);
-	}
-	/**
-	* Update the value _(based on the current value)_
-	* @param callback Callback to update the value
-	*/
-	update(callback) {
-		this.set(callback(this.state.value));
-	}
-};
 function setAndEmit(state, value) {
 	if (!state.equal(state.value, value)) {
 		state.value = value;
 		emitValue(state);
 	}
 }
-function setValue(state, value) {
-	try {
-		let actual = value;
-		if (typeof value === "function") actual = value();
-		if (actual instanceof Promise) {
-			state.promise = actual;
-			actual.then((value) => {
-				if (actual === state.promise) {
-					state.promise = void 0;
-					setAndEmit(state, value);
-				}
-			}).catch(() => {
-				if (actual === state.promise) state.promise = void 0;
-			});
-		} else setAndEmit(state, actual);
-	} catch {}
-}
 function signal(value, options) {
-	const instance = new Signal(void 0, options);
-	instance.set(value);
-	return instance;
+	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);
 }
 //#endregion
 //#region src/value/array.ts
-var ReactiveArray = class extends Reactive {
-	#indiced = /* @__PURE__ */ new Map();
-	#size = signal(0);
-	/**
-	* The length of the array
-	*/
-	get length() {
-		return this.#size.get();
-	}
-	/**
-	* Set the length of the array
-	*/
-	set length(value) {
-		if (typeof value === "number" && value >= 0 && value !== this.state.value.length) this.get().length = value;
-	}
-	constructor(value, options) {
-		super(NAME_ARRAY, new Proxy(value, {
-			get: (target, property) => METHODS_UPDATE.has(property) ? updateArray(property, target, this.state, this.#size) : Reflect.get(target, property),
-			set: (target, property, value) => setValueInProxy({
-				property,
-				target,
-				value,
-				isArray: true,
-				state: this.state,
-				length: this.#size
-			})
-		}), options);
-		this.#size.set(value.length);
-	}
-	/**
-	* Clear the array
-	*/
-	clear() {
-		this.length = 0;
-	}
-	/**
-	* Create a computed, filtered array
-	* @param callback Callback to evaluate each item
-	* @return Computed array of filtered items
-	*/
-	filter(callback) {
-		return computed(() => this.get().filter(callback));
-	}
-	get(first) {
-		if (typeof first === "number") return getReactiveValueInProxy(this, this.#indiced, first, true).get();
-		return first === "length" ? this.length : getValue(this.state);
-	}
-	/**
-	* Create a computed, mapped array
-	* @param callback Callback to transform each item
-	* @return Computed array of mapped items
-	*/
-	map(callback) {
-		return computed(() => this.get().map(callback));
-	}
-	/**
-	* Notify dependents of changes
-	*
-	* _This bypasses equality checks and will immediately notify dependents.
-	* Use this only if you're modifying nested data that would be ignored by equality checks._
-	*/
-	notify() {
-		emityProxyValues(this.state, this.#indiced);
-	}
-	peek(value) {
-		if (value === "length") return this.#size.peek();
-		return typeof value === "number" ? this.state.value.at(value) : this.state.value.slice();
-	}
-	/**
-	* Remove and return the last item of the array
-	* @returns Removed item, or `undefined` if the array is empty
-	*/
-	pop() {
-		return this.state.value.pop();
-	}
-	/**
-	* Add items to the end of the array
-	* @param items Items to add
-	* @returns New array length
-	*/
-	push(...items) {
-		return this.state.value.push(...items);
-	}
-	set(first, second) {
-		setProxyValue(true, this.state, isArrayValue, isArrayIndex, setArray, setAtIndex, first, second);
-	}
-	/**
-	* Remove and return the first item of the array
-	* @returns Removed item, or `undefined` if the array is empty
-	*/
-	shift() {
-		return this.state.value.shift();
-	}
-	/**
-	* Remove and return items from the array _(and optionally add new items)_
-	* @param from Index to start removing items from
-	* @param to Index to stop removing items at _(defaults to the end of the array)_
-	* @param items Optional items to add
-	* @returns Removed items
-	*/
-	splice(from, to, ...items) {
-		return this.state.value.splice(from, to ?? this.state.value.length, ...items);
-	}
-	subscribe(first, second) {
-		if (typeof first === "number" && typeof second === "function") return getReactiveValueInProxy(this, this.#indiced, first, true).subscribe(second);
-		return typeof first === "function" ? subscribe(this.state, first) : noop;
-	}
-	/**
-	* Add items to the beginning of the array
-	* @param items Items to add
-	* @returns New array length
-	*/
-	unshift(...items) {
-		return this.state.value.unshift(...items);
-	}
-	/**
-	* Update the value _(based on the current value)_
-	* @param callback Callback to update the value
-	*/
-	update(callback) {
-		const updated = callback(this.state.value);
-		if (updated == null || Array.isArray(updated)) this.set(updated);
-	}
-};
 function array(value, options) {
-	const instance = new ReactiveArray([], options);
-	instance.set(value);
-	return instance;
+	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)
+	};
+	Object.defineProperties(instance, {
+		[NAME_MORA]: {
+			enumerable: false,
+			value: NAME_ARRAY
+		},
+		length: {
+			enumerable: true,
+			get: () => length.get(),
+			set: (value) => setArrayLength(state, 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";
@@ -597,6 +680,26 @@ function isArrayIndex(value) {
 function isArrayValue(value) {
 	return value == null || Array.isArray(value);
 }
+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 setArray(state, value) {
+	state.value.splice(0, state.value.length, ...value ?? []);
+}
+function setArrayLength(state, value) {
+	if (typeof value === "number" && value >= 0 && value !== state.value.length) state.value.length = value;
+}
+function setAtIndex(state, index, value) {
+	const actual = index < 0 ? state.value.length + index : index;
+	if (actual > -1) state.value[actual] = value;
+}
 function updateArray(type, array, state, length) {
 	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
 	const previousArray = affectsLength ? [] : array.slice();
@@ -610,57 +713,12 @@ function updateArray(type, array, state, length) {
 		return result;
 	};
 }
-function setArray(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 updateArrayValue(instance, state, callback) {
+	const updated = callback(state.value);
+	if (updated == null || Array.isArray(updated)) instance.set(updated);
 }
 //#endregion
 //#region src/value/store.ts
-var Store = class extends Reactive {
-	#keyed = /* @__PURE__ */ new Map();
-	constructor(value, options) {
-		super(NAME_STORE, new Proxy(value, { set: (target, property, value) => setValueInProxy({
-			target,
-			property,
-			value,
-			isArray: false,
-			state: this.state
-		}) }), options);
-	}
-	get(key) {
-		return isKey(key) ? getReactiveValueInProxy(this, this.#keyed, key, false).get() : getValue(this.state);
-	}
-	/**
-	* Notify dependents of changes
-	*
-	* _This bypasses equality checks and will immediately notify dependents.
-	* Use this only if you're modifying nested data that would be ignored by equality checks._
-	*/
-	notify() {
-		emityProxyValues(this.state, this.#keyed);
-	}
-	peek(key) {
-		return isKey(key) ? this.state.value[key] : { ...this.state.value };
-	}
-	set(first, second) {
-		setProxyValue(false, this.state, isStoreObject, isKey, setObject, setProperty, first, second);
-	}
-	subscribe(first, second) {
-		if (isKey(first) && typeof second === "function") return getReactiveValueInProxy(this, this.#keyed, first, false).subscribe(second);
-		return typeof first === "function" ? subscribe(this.state, first) : noop;
-	}
-	/**
-	* Update the value _(based on the current value)_
-	* @param callback Callback to update the value
-	*/
-	update(callback) {
-		const updated = callback(this.state.value);
-		if (updated == null || isPlainObject(updated)) setObject(this.state, updated);
-	}
-};
 function isStoreObject(value) {
 	return value == null || isPlainObject(value);
 }
@@ -682,13 +740,63 @@ function setObject(state, value) {
 	}
 	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 instance = new Store({}, 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,
+		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 instance;
+	return Object.freeze(instance);
 }
 //#endregion
-export { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };
+export { array, computed, effect, isComputed, isEffect, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal, signal, startBatch, stopBatch, store };