@oscarpalmer/abydon 0.23.0 → 0.24.0

package/dist/abydon.full.mjs

@@ -2,15 +2,16 @@
 const ACTIVE = {};
 const BATCH = {
 	depth: 0,
-	handlers: /* @__PURE__ */ new Set()
+	flushing: false,
+	handlers: /* @__PURE__ */ new Map()
 };
-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,753 +23,1166 @@ 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_SUBSCRIPTION = "subscription";
+const NAME_ALL = /* @__PURE__ */ new Set([
 	NAME_ARRAY,
 	NAME_COMPUTED,
+	NAME_READONLY,
 	NAME_SIGNAL,
 	NAME_STORE
 ]);
+const PROPERTY_LENGTH = "length";
+const SYMBOL_EFFECT = Symbol("effect");
+const SYMBOL_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 node_modules/@oscarpalmer/mora/dist/effect.mjs
-var Effect = class {
-	constructor(callback) {
-		Object.defineProperty(this, NAME_MORA, { value: NAME_EFFECT });
-		this.state = { callback };
-		runEffect(this);
-	}
-};
-function runEffect(effect) {
-	const previousEffect = ACTIVE.effect;
-	ACTIVE.effect = effect;
-	try {
-		effect.state.callback();
-	} finally {
-		ACTIVE.effect = previousEffect;
-	}
+function Effect(callback) {
+	this[SYMBOL_STATE] = { callback };
+	runEffect(this[SYMBOL_STATE]);
 }
+Effect.prototype[NAME_MORA] = NAME_EFFECT;
 /**
 * Create an effect
+*
 * @param callback Callback for handling signal effects
 * @returns Effect
 */
 function effect(callback) {
-	return typeof callback === "function" ? new Effect(callback) : void 0;
+	if (typeof callback !== "function") throw new TypeError("Effect callback must be a function");
+	return getEffect(callback)[0];
+}
+function getEffect(callback) {
+	const instance = new Effect(callback);
+	return [instance, instance[SYMBOL_STATE]];
+}
+function internalEffect(callback) {
+	return getEffect(callback)[1];
+}
+function runEffect(state) {
+	const previousEffect = ACTIVE.effect;
+	ACTIVE.effect = state;
+	try {
+		state.callback();
+	} finally {
+		ACTIVE.effect = previousEffect;
+	}
 }
 //#endregion
-//#region node_modules/@oscarpalmer/mora/dist/helpers/is.mjs
+//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
 /**
-* Is the value a reactive array?
+* Is the value a _Key_?
+*
 * @param value Value to check
-* @returns True if value is a {@link ReactiveArray}
+* @returns `true` if the value is a _Key_ _(`number` or `string`)_, otherwise `false`
 */
-function isArray(value) {
-	return isMora(value, NAME_ARRAY);
+function isKey(value) {
+	return typeof value === "number" || typeof value === "string";
 }
 /**
-* Is the value a computed signal?
+* Is the value not a template strings array?
+*
 * @param value Value to check
-* @returns True if value is a {@link Computed}
+* @returns `true` if the value is not a `TemplateStringsArray`, otherwise `false`
 */
-function isComputed(value) {
-	return isMora(value, NAME_COMPUTED);
+function isNonTemplateStringsArray(value) {
+	return !isTemplateStringsArray(value);
 }
 /**
-* Is the value an effect?
+* Is the value a number?
+*
 * @param value Value to check
-* @returns True if value is an {@link Effect}
+* @returns `true` if the value is a `number`, otherwise `false`
 */
-function isEffect(value) {
-	return isMora(value, NAME_EFFECT);
-}
-function isMora(value, name) {
-	return typeof value === "object" && value != null && "$mora" in value && (typeof name === "string" ? value["$mora"] === name : name.has(value["$mora"]));
+function isNumber(value) {
+	return typeof value === "number" && !Number.isNaN(value);
 }
 /**
-* Is the value reactive?
+* Is the value a plain object?
+*
 * @param value Value to check
-* @returns True if value is a {@link Reactive}
+* @returns `true` if the value is a plain object, otherwise `false`
 */
-function isReactive(value) {
-	return isMora(value, NAME_ALL);
+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;
 }
 /**
-* Is the value a signal?
+* Is the value a template strings array?
+*
 * @param value Value to check
-* @returns True if value is a {@link Signal}
+* @returns `true` if the value is a `TemplateStringsArray`, otherwise `false`
 */
-function isSignal(value) {
-	return isMora(value, NAME_SIGNAL);
+function isTemplateStringsArray(value) {
+	return Array.isArray(value) && Array.isArray(value.raw);
 }
 //#endregion
-//#region node_modules/@oscarpalmer/mora/dist/batch.mjs
-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);
-	}
+//#region node_modules/@oscarpalmer/atoms/dist/internal/string/misc.mjs
+/**
+* Get the string value from any value
+*
+* @param value Original value
+* @returns String representation of the value
+*
+* @example
+* ```typescript
+* getString(null)       // => ''
+* getString('foo')      // => 'foo'
+* getString(123)        // => '123'
+* getString(true)       // => 'true'
+* getString([1, 2, 3])  // => '1,2,3'
+* getString({a: 1})     // => '{"a":1}'
+* getString(() => 123)  // => '123'
+* ```
+*/
+function getString(value) {
+	if (typeof value === "string") return value;
+	if (value == null) return "";
+	if (typeof value === "function") return getString(value());
+	if (typeof value !== "object") return String(value);
+	const asString = String(value.valueOf?.() ?? value);
+	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
 }
 /**
-* Start batching effects
+* Join an array of values into a string _(while ignoring empty values)_
 *
-* _(Use {@link stopBatch} to flush and run batched effects)_
+* _(`null`, `undefined`, and any values that become whitespace-only strings are considered empty)_
+*
+* @param array Array of values
+* @param delimiter Delimiter to use between values
+* @returns Joined string
 */
-function startBatch() {
-	BATCH.depth += 1;
+function join(array, delimiter) {
+	if (!Array.isArray(array)) return "";
+	const { length } = array;
+	if (length === 0) return "";
+	const values = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = getString(array[index]);
+		if (item.length > 0) values.push(item);
+	}
+	return values.join(typeof delimiter === "string" ? delimiter : "");
 }
 /**
-* Stop batching effects and flush _(run)_ them
+* Split a string into words _(and other readable parts)_
+*
+* @param value Original string
+* @returns Array of words found in the string
 */
-function stopBatch() {
-	if (BATCH.depth > 0) BATCH.depth -= 1;
-	flushHandlers();
+function words(value) {
+	return typeof value === "string" ? value.match(STRING_EXPRESSION_WORDS) ?? [] : [];
 }
+const STRING_EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 //#endregion
-//#region node_modules/@oscarpalmer/mora/dist/subscription.mjs
-var Subscription = class {
-	callback;
-	state;
-	constructor(state, callback) {
-		this.state = state;
-		this.callback = callback;
-		callback(state.value);
-	}
-	destroy() {
-		this.callback = noop$1;
-		this.state = void 0;
-	}
-};
-function noop$1() {}
-function subscribe(state, callback) {
-	if (typeof callback !== "function" || state.subscriptions.has(callback)) return noop$1;
-	state.subscriptions.set(callback, new Subscription(state, callback));
-	return () => {
-		unsubscribe(state, callback);
-	};
-}
-function unsubscribe(state, callback) {
-	state.subscriptions.get(callback)?.destroy();
-	state.subscriptions.delete(callback);
+//#region node_modules/@oscarpalmer/atoms/dist/is.mjs
+/**
+* Is the value `undefined`, `null`, or stringified as a whitespace-only string?
+*
+* @param value Value to check
+* @returns `true` if the value is nullable or matches a whitespace-only string, otherwise `false`
+*/
+function isNullableOrWhitespace(value) {
+	return value == null || EXPRESSION_WHITESPACE$1.test(getString(value));
 }
+const EXPRESSION_WHITESPACE$1 = /^\s*$/;
 //#endregion
-//#region node_modules/@oscarpalmer/mora/dist/value/reactive.mjs
-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();
+//#region node_modules/@oscarpalmer/mora/dist/helpers/value.mjs
+function emitValue(instance, notify) {
+	const state = instance[SYMBOL_STATE];
+	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) computed.dirty = true;
+	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	if (notify ?? false) {
+		const mapped = instance[SYMBOL_STATE].mapped;
+		for (const [, item] of mapped) {
+			const fx = item[SYMBOL_EFFECT];
+			BATCH.handlers.set(fx.instance, fx.instance);
+		}
 	}
-	/**
-	* String representation of the value
-	* @return Value as string
-	*/
-	toString() {
-		return String(this.get());
+	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)
+		});
 	}
-	/**
-	* Unsubscribe from changes
-	* @param callback Callback to unsubscribe
-	*/
-	unsubscribe(callback) {
-		unsubscribe(this.state, callback);
+	if (BATCH.depth === 0) flushHandlers();
+}
+function equalArrays(first, second, equal) {
+	const { length } = first;
+	if (length !== second.length) return false;
+	const eq = 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;
 	}
-};
-//#endregion
-//#region node_modules/@oscarpalmer/mora/dist/value/computed.mjs
-var Computed = class extends Reactive {
-	effect = {
-		dirty: true,
-		instance: void 0
-	};
-	constructor(callback, options) {
-		super(NAME_COMPUTED, void 0, options);
-		this.effect.instance = effect(() => {
-			if (this.effect.dirty) {
-				setValue$2(this, this.state, callback);
-				this.effect.dirty = 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 getJsonValue() {
+	return this[SYMBOL_STATE].value;
+}
+function getSignalValue() {
+	const state = this[SYMBOL_STATE];
+	if (ACTIVE.computed != null) {
+		state.computeds ??= /* @__PURE__ */ new Set();
+		state.computeds.add(ACTIVE.computed);
 	}
-	/**
-	* @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;
+	if (ACTIVE.effect != null) {
+		state.effects ??= /* @__PURE__ */ new Set();
+		state.effects.add(ACTIVE.effect);
 	}
-};
-/**
-* 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);
+	return state.value;
 }
-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();
+function getStringValue(json) {
+	return json === true ? JSON.stringify(this[SYMBOL_STATE].value) : String(this[SYMBOL_STATE].value);
 }
-function setValue$2(instance, state, callback) {
-	const previousComputed = ACTIVE.computed;
-	ACTIVE.computed = instance;
+function handleSignal(instance, origin, setValue, onAfter, notify) {
+	const state = instance[SYMBOL_STATE];
 	try {
-		const value = callback();
-		if (value instanceof Promise) {
-			state.promise = value;
-			value.then((resolvedValue) => {
-				if (state.promise === value) {
+		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;
-					setAndEmit$1(state, resolvedValue);
+					setValue(instance, value, notify ?? false);
 				}
 			}).catch(() => {
-				if (state.promise === value) state.promise = void 0;
+				if (actual === state.promise) state.promise = void 0;
 			});
-		} else setAndEmit$1(state, value);
+		} else setValue(instance, actual, notify ?? false);
+	} 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 updateSignal(instance, callback, setValue) {
+	if (typeof callback !== "function") throw new TypeError("Callback must be a function");
+	handleSignal(instance, callback(instance[SYMBOL_STATE].value), setValue);
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/batch.mjs
+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];
+				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);
+			}
+		}
 	} finally {
-		ACTIVE.computed = previousComputed;
+		BATCH.flushing = false;
 	}
 }
+/**
+* Start batching effects
+*
+* _(Use {@link stopBatch} to flush and run batched effects)_
+*/
+function startBatch() {
+	BATCH.depth += 1;
+}
+/**
+* Stop batching effects and flush _(run)_ them
+*/
+function stopBatch() {
+	if (BATCH.depth > 0) BATCH.depth -= 1;
+	flushHandlers();
+}
 //#endregion
-//#region node_modules/@oscarpalmer/mora/node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
+//#region node_modules/@oscarpalmer/mora/dist/helpers/is.mjs
 /**
-* Is the value a key?
+* Is the value a computed signal?
+*
 * @param value Value to check
-* @returns `true` if the value is a `Key` _(`number` or `string`)_, otherwise `false`
+* @returns True if value is a {@link Computed}
 */
-function isKey(value) {
-	return typeof value === "number" || typeof value === "string";
+function isComputed(value) {
+	return isMora(value, NAME_COMPUTED);
 }
 /**
-* Is the value a plain object?
+* Is the value an effect?
+*
 * @param value Value to check
-* @returns `true` if the value is a plain object, otherwise `false`
+* @returns True if value is an {@link Effect}
 */
-function isPlainObject$1(value) {
-	if (value === null || typeof value !== "object") return false;
-	if (Symbol.toStringTag in value || Symbol.iterator in value) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
+function isEffect(value) {
+	return isMora(value, NAME_EFFECT);
+}
+function isMora(value, name) {
+	return typeof value === "object" && value != null && "$mora" in value && (typeof name === "string" ? value["$mora"] === name : name.has(value["$mora"]));
 }
-//#endregion
-//#region node_modules/@oscarpalmer/mora/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
+* Is the value reactive?
+*
+* @param value Value to check
+* @returns True if value is a {@link Reactive}
 */
-function round(value, decimals) {
-	return roundNumber(Math.round, value, decimals);
+function isReactive(value) {
+	return isMora(value, NAME_ALL);
 }
-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;
+/**
+* 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 node_modules/@oscarpalmer/mora/dist/helpers/value.mjs
-function emitValue(state) {
-	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) BATCH.handlers.add(subscription);
-	if (BATCH.depth === 0) flushHandlers();
+/**
+* Is the value a reactive array?
+*
+* @param value Value to check
+* @returns True if value is a {@link ReactiveArray}
+*/
+function isReactiveArray(value) {
+	return isMora(value, NAME_ARRAY);
 }
-function equalArrays(state, first, second) {
-	let { length } = first;
-	if (length !== second.length) return false;
-	let offset = 0;
-	if (length >= 100) {
-		offset = 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;
-	}
-	length -= offset;
-	for (let index = offset; index < length; index += 1) if (!state.equal(first[index], second[index])) return false;
-	return true;
+/**
+* Is the value a reactive store?
+*
+* @param value Value to check
+* @returns True if value is a {@link Store}
+*/
+function isReactiveStore(value) {
+	return isMora(value, NAME_STORE);
 }
-function getValue$1(state) {
-	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
-	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
-	return state.value;
+/**
+* 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);
 }
 //#endregion
-//#region node_modules/@oscarpalmer/mora/dist/value/signal.mjs
-var Signal = class extends Reactive {
-	constructor(value, options) {
-		super(NAME_SIGNAL, value, options);
-	}
-	/**
-	* @inheritdoc
-	*/
-	get() {
-		return getValue$1(this.state);
-	}
-	/**
-	* Set the value
-	* @param value New value
-	*/
-	set(value) {
-		setValue$1(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);
+//#region node_modules/@oscarpalmer/mora/dist/helpers/misc.mjs
+function getState(value, options) {
+	return {
+		value,
+		equal: typeof options === "object" && typeof options?.equal === "function" ? options.equal : void 0
+	};
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/helpers/proxy.mjs
+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(() => state.isArray ? instance.get().at(key) : instance.get()[key]);
+		state.mapped.set(mapKey, item);
 	}
+	return item;
 }
-function setValue$1(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 getValueInProxy(first) {
+	let signal;
+	if (this[SYMBOL_STATE].isArray ? typeof first === "number" : isKey(first)) signal = getReactiveValueInProxy(this, first);
+	return getSignalValue.call(signal ?? this);
 }
-function signal(value, options) {
-	const instance = new Signal(void 0, options);
-	instance.set(value);
-	return instance;
+function isProxyKey(isArray, value) {
+	return isArray ? typeof value === "number" : isKey(value);
 }
-//#endregion
-//#region node_modules/@oscarpalmer/mora/dist/helpers/proxy.mjs
-function emityProxyValues(state, mapped) {
-	const values = [...mapped.values()];
+function isProxyObject(isArray, value) {
+	return value == null || (isArray ? Array.isArray(value) : isPlainObject(value));
+}
+function notifyProxyValue() {
+	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].effect.dirty = true;
-	emitValue(state);
+	for (let index = 0; index < length; index += 1) {
+		values[index][SYMBOL_EFFECT].dirty = true;
+		values[index][SYMBOL_EFFECT].notify = true;
+	}
+	emitValue(this, true);
 }
-function getReactiveValueInProxy(reactive, mapped, key, isArray) {
-	let item = mapped.get(key);
-	if (item == null) {
-		item = computed(() => isArray ? reactive.get().at(key) : reactive.get()[key]);
-		mapped.set(key, item);
+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) {
+		const values = state.value;
+		values.splice(0, values.length, ...value ?? []);
+		return;
 	}
-	return item;
+	startBatch();
+	const current = state.value;
+	const next = value ?? {};
+	const currentKeys = Object.keys(current);
+	const nextKeys = Object.keys(next);
+	let { length } = currentKeys;
+	for (let index = 0; index < length; index += 1) {
+		const key = currentKeys[index];
+		current[key] = nextKeys.includes(key) ? next[key] : void 0;
+	}
+	length = nextKeys.length;
+	for (let index = 0; index < length; index += 1) {
+		const key = nextKeys[index];
+		if (!currentKeys.includes(key)) current[key] = next[key];
+	}
+	stopBatch();
 }
-function setProxyValue(array, state, isObject, isProperty, setObject, setProperty, first, second) {
-	if (array && first === "length") {
+function setProxyProperty(state, property, value) {
+	if (!state.isArray) {
+		state.value[property] = value;
+		return;
+	}
+	const array = state.value;
+	const index = property;
+	const actual = index < 0 ? array.length + index : index;
+	if (actual > -1) array[actual] = value;
+}
+function setProxyValue(first, second) {
+	const state = this[SYMBOL_STATE];
+	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;
-	let actual = property ? second : first;
+	const keyed = isProxyKey(state.isArray, first);
+	if (state.isArray && keyed && Number.isNaN(first)) return;
+	let actual = keyed ? second : first;
 	if (typeof actual === "function") try {
 		actual = actual();
 	} catch {
 		return;
 	}
 	if (actual instanceof Promise) {
-		if (property) {
+		if (keyed) {
 			state.promises ??= /* @__PURE__ */ new Map();
 			state.promises.set(first, actual);
 		} else state.promise = actual;
 		actual.then((value) => {
-			if (property && state.promises.get(first) === actual) {
-				state.promises.delete(first);
-				setProperty(state, first, value);
+			if (keyed && state.promises?.get(first) === actual) {
+				state.promises?.delete(first);
+				setProxyProperty(state, first, value);
 				return;
 			}
-			if (!property && isObject(value) && state.promise === actual) {
+			if (!keyed && 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;
+			if (keyed && state.promises?.get(first) === actual) state.promises?.delete(first);
+			else if (!keyed && state.promise === actual) state.promise = void 0;
 		});
-	} else if (property) setProperty(state, first, actual);
-	else if (isObject(actual)) setObject(state, actual);
+	} else if (keyed) 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 node_modules/@oscarpalmer/mora/dist/value/array.mjs
-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$1(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$1, 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$1;
-	}
-	/**
-	* 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);
+//#region node_modules/@oscarpalmer/atoms/dist/internal/aborter.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)
+	};
+}
+const ABORT_EVENT = "abort";
+const ABORT_OPTIONS = { once: true };
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/subscription.mjs
+const SUBSCRIPTION_NAME = "subscription";
+const SUBSCRIPTION_PROPERTY = "$subscription";
+const SUBSCRIPTION_STORE = "subscriptions";
+function Subscription(state, property, parameters) {
+	this[SUBSCRIPTION_SYMBOL] = state;
+	this[property.key] = property.value;
+	state.aborter = createAborter(parameters.signal, () => this.unsubscribe(subscriptions, this, state));
+	addSubscription(this);
+}
+Subscription.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_NAME;
+Subscription.prototype.unsubscribe = removeSubscription;
+Object.defineProperty(Subscription.prototype, "active", {
+	enumerable: true,
+	get: getSubscriptionActive
+});
+function Subscriptions(parameters) {
+	const { keys, property } = createSubscriptionsParameters(parameters);
+	this[SUBSCRIPTION_SYMBOL] = createSubscriptionsState(property, keys);
+}
+Subscriptions.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_STORE;
+Subscriptions.prototype.clear = clearSubscriptions;
+Subscriptions.prototype.create = createSubscription;
+Object.defineProperties(Subscriptions.prototype, {
+	items: {
+		enumerable: true,
+		get: getSubscriptionsItems
+	},
+	values: {
+		enumerable: true,
+		get: getSubscriptionsValues
+	}
+});
+function addSubscription(instance) {
+	const state = instance[SUBSCRIPTION_SYMBOL];
+	const { key, value } = state.parameters;
+	const { items, values } = state.subscriptions;
+	if (!isKey(key)) {
+		items.any.add(instance);
+		values.from.any.set(value, instance);
+		values.to.any.set(instance, value);
+		return;
 	}
-	/**
-	* 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);
+	/* 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(instance);
+	let keyedFrom = values.from.keyed.get(key);
+	if (keyedFrom == null) {
+		keyedFrom = /* @__PURE__ */ new Map();
+		values.from.keyed.set(key, keyedFrom);
+	}
+	keyedFrom.set(value, instance);
+	let keyedTo = values.to.keyed.get(key);
+	if (keyedTo == null) {
+		keyedTo = /* @__PURE__ */ new Map();
+		values.to.keyed.set(key, keyedTo);
+	}
+	keyedTo.set(instance, value);
+}
+function clearSubscriptions() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	for (const susbcription of state.values.to.any.keys()) susbcription.unsubscribe();
+	if (state.values.to.keyed != null && state.values.to.keyed.size > 0) for (const values of state.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
+}
+function createSubscription(params) {
+	const parameters = createSubscriptionParameters(params);
+	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
+	const subscriptions = this[SUBSCRIPTION_SYMBOL];
+	const state = {
+		parameters,
+		subscriptions,
+		active: true
+	};
+	const existing = getExistingSubscription(subscriptions, state);
+	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);
 	}
-};
-function array(value, options) {
-	const instance = new ReactiveArray([], options);
-	instance.set(value);
-	return instance;
+	return [new Subscription(state, subscriptions.property, parameters), false];
 }
-function isArrayIndex(value) {
-	return typeof value === "number";
+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 isArrayValue(value) {
-	return value == null || Array.isArray(value);
+function getSubscriptionActive() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	return (state.parameters?.isActive?.() ?? true) && state.active;
 }
-function updateArray(type, array, state, length) {
-	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);
+function getSubscriptionsItems() {
+	return this[SUBSCRIPTION_SYMBOL].items;
+}
+function getSubscriptionsValues() {
+	return this[SUBSCRIPTION_SYMBOL].values;
+}
+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 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(property, keys) {
+	return {
+		keys,
+		property,
+		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()
+			}
 		}
-		return result;
 	};
 }
-function setArray$1(state, value) {
-	state.value.splice(0, state.value.length, ...value ?? []);
+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);
+	}
+}
+function removeSubscription() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	if (!state.active) return;
+	state.aborter = void 0;
+	state.active = false;
+	const { items, values } = state.subscriptions;
+	const { key, value } = state.parameters;
+	state.parameters = void 0;
+	state.subscriptions = void 0;
+	if (!isKey(key)) {
+		removeFromStore(items.any, values, this, value);
+		return;
+	}
+	const keyed = items.keyed?.get(key);
+	/* istanbul ignore if */
+	if (items.keyed == null || keyed == null)
+ // istanbul ignore next
+	return;
+	removeFromStore(keyed, values, this, value, key);
+	if (keyed.size === 0) items.keyed.delete(key);
+}
+/**
+* Create a subscription store
+*
+* @param parameters Store parameters
+* @returns Subscription store
+*/
+function subscriptions(parameters) {
+	return new Subscriptions(parameters);
+}
+const SUBSCRIPTION_DISALLOWED_KEY = "Disallowed key for subscription";
+const SUBSCRIPTION_INVALID_KEY = "Invalid key for subscription";
+const SUBSCRIPTION_INVALID_VALUE = "A subscription requires a non-null value to identify it";
+const SUBSCRIPTION_SYMBOL = Symbol(SUBSCRIPTION_PROPERTY);
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/helpers/subscription.mjs
+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 setAtIndex(state, index, value) {
-	const actual = index < 0 ? state.value.length + index : index;
-	if (actual > -1) state.value[actual] = value;
+function subscribeToSignal(subscriber, copy) {
+	return subscribeToReactive.call(this, copy === true ? SUBSCRIPTION_TYPE_COPY : SUBSCRIPTION_TYPE_ORIGINAL, subscriber);
 }
 //#endregion
-//#region node_modules/@oscarpalmer/mora/dist/value/store.mjs
-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);
+//#region node_modules/@oscarpalmer/mora/dist/value/computed.mjs
+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.toJSON = getJsonValue;
+Computed.prototype.toString = getStringValue;
+/**
+* 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);
+}
+function getComputed(callback, options) {
+	if (typeof callback !== "function") throw new TypeError("Computed callback must be a function");
+	return new Computed(callback, options);
+}
+function getComputedEffect(instance, callback) {
+	const fx = {
+		dirty: true,
+		instance: void 0,
+		notify: false
+	};
+	fx.instance = internalEffect(() => {
+		if (fx.dirty) {
+			const previousComputed = ACTIVE.computed;
+			ACTIVE.computed = fx;
+			handleSignal(instance, callback, setAndEmit$1, () => {
+				ACTIVE.computed = previousComputed;
+				fx.notify = false;
+			}, fx.notify);
+			fx.dirty = false;
+		}
+	});
+	return fx;
+}
+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);
 	}
-	get(key) {
-		return isKey(key) ? getReactiveValueInProxy(this, this.#keyed, key, false).get() : getValue$1(this.state);
+	if (ACTIVE.effect != null && ACTIVE.effect !== fx.instance) {
+		state.effects ??= /* @__PURE__ */ new Set();
+		state.effects.add(ACTIVE.effect);
 	}
-	/**
-	* 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);
+	if (fx.dirty && BATCH.depth === 0) runEffect(fx.instance);
+	return state.value;
+}
+function internalComputed(callback, options) {
+	return getComputed(callback, options);
+}
+function setAndEmit$1(instance, value, notify) {
+	const state = instance[SYMBOL_STATE];
+	if (!notify && (state.equal ?? Object.is)(state.value, value)) return;
+	state.value = value;
+	if (state.computeds != null && state.computeds.size > 0) for (const computed of state.computeds) computed.dirty = true;
+	if (state.effects != null && state.effects.size > 0) for (const effect of state.effects) BATCH.handlers.set(effect, effect);
+	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));
+		}
 	}
-	peek(key) {
-		return isKey(key) ? this.state.value[key] : { ...this.state.value };
+	flushHandlers();
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/value/readonly.mjs
+function Readonly(state, frozen) {
+	this[SUBSCRIPTION_TYPE_FROZEN] = frozen;
+	this[SYMBOL_STATE] = state;
+}
+Readonly.prototype[NAME_MORA] = NAME_READONLY;
+Readonly.prototype.get = getReadonlyValue;
+Readonly.prototype.peek = peekReadonlyValue;
+Readonly.prototype.subscribe = subscribeToReadonly;
+Readonly.prototype.toJSON = getJsonValue;
+Readonly.prototype.toString = getStringValue;
+function getReadonlyInstance(state, frozen) {
+	return new Readonly(state, frozen);
+}
+function getReadonlySignal(frozen) {
+	const key = frozen === true ? SUBSCRIPTION_TYPE_FROZEN : SUBSCRIPTION_TYPE_ORIGINAL;
+	this[SYMBOL_STATE].readonlies ??= {};
+	this[SYMBOL_STATE].readonlies[key] ??= getReadonlyInstance(this[SYMBOL_STATE], frozen === true);
+	return this[SYMBOL_STATE].readonlies[key];
+}
+function getReadonlyValue() {
+	return handleReadonlyValue(this, false, this[SUBSCRIPTION_TYPE_FROZEN]);
+}
+function handleReadonlyValue(instance, peek, frozen, copy) {
+	let value;
+	if (peek) value = peekSignalValue.call(instance, copy === true);
+	else value = getSignalValue.call(instance);
+	return frozen ? getFrozenValue(value) : value;
+}
+function peekReadonlyValue(copy) {
+	return handleReadonlyValue(this, true, this[SUBSCRIPTION_TYPE_FROZEN], copy);
+}
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/value/signal.mjs
+function Signal(value, options) {
+	this[SYMBOL_STATE] = getState(void 0, options);
+	handleSignal(this, value, setAndEmit);
+}
+Signal.prototype[NAME_MORA] = NAME_SIGNAL;
+Signal.prototype.asReadonly = getReadonlySignal;
+Signal.prototype.get = getSignalValue;
+Signal.prototype.peek = peekSignalValue;
+Signal.prototype.set = setSignalValue;
+Signal.prototype.subscribe = subscribeToSignal;
+Signal.prototype.toString = getStringValue;
+Signal.prototype.toJSON = getJsonValue;
+Signal.prototype.update = updateSignalValue;
+function setAndEmit(instance, value) {
+	const state = instance[SYMBOL_STATE];
+	if (!(state.equal ?? Object.is)(state.value, value)) {
+		state.value = value;
+		emitValue(instance);
 	}
-	set(first, second) {
-		setProxyValue(false, this.state, isStoreObject, isKey, setObject, setProperty, first, second);
+}
+function setSignalValue(value) {
+	handleSignal(this, value, setAndEmit);
+}
+function signal(value, options) {
+	return new Signal(value, options);
+}
+function updateSignalValue(callback) {
+	updateSignal(this, callback, setAndEmit);
+}
+//#endregion
+//#region 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];
+		default: return;
 	}
-	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$1;
+}
+function getArrayCallbacks(bool, key, value) {
+	if (typeof bool === "function") return { bool };
+	return {
+		keyed: getArrayCallback(key),
+		value: getArrayCallback(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 } = createFindParameters(parameters);
+	const callbacks = getArrayCallbacks(bool, key);
+	if (callbacks?.bool == null && callbacks?.keyed == null) {
+		if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
+		return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
 	}
-	/**
-	* 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$1(updated)) setObject(this.state, updated);
+	if (callbacks.bool != null) {
+		const index = reversed ? array.findLastIndex(callbacks.bool) : array.findIndex(callbacks.bool);
+		return findIndex ? index : array[index];
 	}
-};
-function isStoreObject(value) {
-	return value == null || isPlainObject$1(value);
+	return findValueInArray(array, callbacks.keyed, value, findIndex, reversed);
 }
-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;
+function findValueInArray(array, callback, value, findIndex, reversed) {
+	const { length } = array;
 	for (let index = 0; index < length; index += 1) {
-		const key = proxyKeys[index];
-		proxy[key] = actualKeys.includes(key) ? actual[key] : void 0;
+		const item = reversed ? array.at(-(index + 1)) : array[index];
+		if (Object.is(callback?.(item, index, array), value)) return findIndex ? index : item;
+	}
+	return findIndex ? -1 : void 0;
+}
+function findValues(type, array, parameters, mapper) {
+	const result = {
+		matched: [],
+		notMatched: []
+	};
+	if (!Array.isArray(array) || array.length === 0) return result;
+	const { length } = array;
+	const { bool, key, value } = createFindParameters(parameters);
+	const callbacks = getArrayCallbacks(bool, key);
+	if (type === "unique" && callbacks?.keyed == null && length >= FIND_UNIQUE_THRESHOLD) {
+		result.matched = [...new Set(array)];
+		return result;
+	}
+	const mapCallback = getArrayCallback(mapper?.callback);
+	const mapReverse = mapper?.reverse ?? false;
+	const mapAfter = mapCallback == null ? void 0 : mapReverse ? void 0 : mapCallback;
+	const mapBefore = mapCallback == null ? void 0 : mapReverse ? mapCallback : void 0;
+	if (callbacks?.bool != null || type === "all" && key == null) {
+		const callback = callbacks?.bool ?? ((item) => Object.is(item, value));
+		for (let index = 0; index < length; index += 1) {
+			const item = array[index];
+			const transformed = mapBefore?.(item, index, array) ?? item;
+			if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
+			else result.notMatched.push(item);
+		}
+		return result;
 	}
-	length = actualKeys.length;
+	const keys = /* @__PURE__ */ new Set();
 	for (let index = 0; index < length; index += 1) {
-		const key = actualKeys[index];
-		if (!proxyKeys.includes(key)) proxy[key] = actual[key];
+		const item = array[index];
+		let keyed;
+		let transformed;
+		if (mapBefore == null) {
+			keyed = callbacks?.keyed?.(item, index, array) ?? item;
+			transformed = item;
+		} else {
+			transformed = mapBefore(item, index, array);
+			keyed = callbacks?.keyed?.(transformed, index, array) ?? transformed;
+		}
+		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
+			keys.add(keyed);
+			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
+		} else result.notMatched.push(item);
 	}
-	stopBatch();
+	return result;
 }
-function setProperty(state, key, value) {
-	state.value[key] = value;
+const FIND_VALUE_INDEX = "index";
+const FIND_VALUE_ITEM = "item";
+const FIND_UNIQUE_THRESHOLD = 100;
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/array/index-of.mjs
+function indexOf(array, ...parameters) {
+	return findValue(FIND_VALUE_INDEX, array, parameters, false);
 }
-function store(value, options) {
-	const instance = new Store({}, options);
-	instance.set(value);
-	return instance;
+function lastIndexOf(array, ...parameters) {
+	return findValue(FIND_VALUE_INDEX, array, parameters, true);
 }
+indexOf.last = lastIndexOf;
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/is.mjs
-/**
-* Is the value a number?
-* @param value Value to check
-* @returns `true` if the value is a `number`, otherwise `false`
-*/
-function isNumber(value) {
-	return typeof value === "number" && !Number.isNaN(value);
+//#region node_modules/@oscarpalmer/atoms/dist/array/find.mjs
+function find(array, ...parameters) {
+	return findValue(FIND_VALUE_ITEM, array, parameters, false);
 }
-/**
-* 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;
+function findLast(array, ...parameters) {
+	return findValue(FIND_VALUE_ITEM, array, parameters, true);
 }
+find.last = findLast;
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/string.mjs
-/**
-* Get the string value from any value
-* @param value Original value
-* @returns String representation of the value
-*/
-function getString(value) {
-	if (typeof value === "string") return value;
-	if (value == null) return "";
-	if (typeof value === "function") return getString(value());
-	if (typeof value !== "object") return String(value);
-	const asString = String(value.valueOf?.() ?? value);
-	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
+//#region node_modules/@oscarpalmer/atoms/dist/array/select.mjs
+function reverseSelect(array, ...parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.shift(),
+		reverse: true
+	}).matched;
+}
+function select(array, ...parameters) {
+	return selectValues(array, parameters);
+}
+function selectValues(array, parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.pop(),
+		reverse: false
+	}).matched;
+}
+select.reverse = reverseSelect;
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/array/filter.mjs
+function exclude(array, ...parameters) {
+	return findValues("all", array, parameters).notMatched;
 }
-/**
-* Join an array of values into a string _(while ignoring empty values)_
-*
-* _(`null`, `undefined`, and any values that become whitespace-only strings are considered empty)_
-* @param array Array of values
-* @param delimiter Delimiter to use between values
-* @returns Joined string
-*/
-function join(array, delimiter) {
-	if (!Array.isArray(array)) return "";
-	const { length } = array;
-	if (length === 0) return "";
-	const values = [];
-	for (let index = 0; index < length; index += 1) {
-		const item = getString(array[index]);
-		if (item.trim().length > 0) values.push(item);
-	}
-	return values.join(typeof delimiter === "string" ? delimiter : "");
+function filter(array, ...parameters) {
+	return findValues("all", array, parameters).matched;
 }
-/**
-* Split a string into words _(and other readable parts)_
-* @param value Original string
-* @returns Array of words found in the string
-*/
-function words(value) {
-	return typeof value === "string" ? value.match(EXPRESSION_WORDS) ?? [] : [];
+filter.remove = exclude;
+//#endregion
+//#region node_modules/@oscarpalmer/mora/dist/value/array.mjs
+function ReactiveArray(value, options) {
+	this[SYMBOL_STATE] = {
+		...getState(void 0, options),
+		isArray: true,
+		length: signal(0)
+	};
+	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)
+	});
+	setProxyValue.call(this, value);
+}
+ReactiveArray.prototype[NAME_MORA] = NAME_ARRAY;
+Object.defineProperty(ReactiveArray.prototype, PROPERTY_LENGTH, {
+	enumerable: true,
+	get: getArrayLength,
+	set: setArrayLength
+});
+ReactiveArray.prototype.asReadonly = getReadonlySignal;
+ReactiveArray.prototype.at = getArrayValues;
+ReactiveArray.prototype.clear = clearArrayValues;
+ReactiveArray.prototype.filter = filterArrayValues;
+ReactiveArray.prototype.get = getArrayValues;
+ReactiveArray.prototype.map = mapArrayValues;
+ReactiveArray.prototype.notify = notifyProxyValue;
+ReactiveArray.prototype.peek = peekArrayValue;
+ReactiveArray.prototype.pop = popArrayValue;
+ReactiveArray.prototype.push = pushArrayValues;
+ReactiveArray.prototype.select = selectArrayValues;
+ReactiveArray.prototype.shift = shiftArrayValue;
+ReactiveArray.prototype.set = setProxyValue;
+ReactiveArray.prototype.splice = spliceArrayValues;
+ReactiveArray.prototype.subscribe = subscribeToProxy;
+ReactiveArray.prototype.toString = getStringValue;
+ReactiveArray.prototype.toJSON = getJsonValue;
+ReactiveArray.prototype.unshift = unshiftArrayValues;
+ReactiveArray.prototype.update = updateProxyValue;
+function array(value, options) {
+	return new ReactiveArray(value, options);
+}
+function clearArrayValues() {
+	this[SYMBOL_STATE].value.length = 0;
+}
+function filterArrayValues(callback) {
+	return computed(() => filter(getArrayValues.call(this), callback));
+}
+function getArrayLength() {
+	return this[SYMBOL_STATE].length.get();
+}
+function getArrayValues(value) {
+	return value === "length" ? this[SYMBOL_STATE].length.get() : getValueInProxy.call(this, value);
+}
+function mapArrayValues(callback) {
+	return computed(() => getArrayValues.call(this).map(callback));
+}
+function peekArrayValue(first, second) {
+	return first === "length" ? this[SYMBOL_STATE].length.peek() : peekValueInProxy.call(this, first, second);
+}
+function popArrayValue() {
+	return this[SYMBOL_STATE].value.pop();
+}
+function pushArrayValues(...items) {
+	return this[SYMBOL_STATE].value.push(...items);
+}
+function selectArrayValues(filter, map) {
+	return computed(() => select(getArrayValues.call(this), filter, map));
+}
+function setArrayLength(value) {
+	const values = this[SYMBOL_STATE].value;
+	if (typeof value === "number" && !Number.isNaN(value) && value >= 0 && value !== values.length) values.length = value;
+}
+function shiftArrayValue() {
+	return this[SYMBOL_STATE].value.shift();
+}
+function spliceArrayValues(from, to, ...items) {
+	const values = this[SYMBOL_STATE].value;
+	return values.splice(from, to ?? values.length, ...items);
+}
+function unshiftArrayValues(...items) {
+	return this[SYMBOL_STATE].value.unshift(...items);
+}
+function updateArray(instance, type, array) {
+	const state = instance[SYMBOL_STATE];
+	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(previousArray, array, state.equal)) {
+			emitValue(instance);
+			state.length.set(array.length);
+		}
+		return result;
+	};
 }
-const EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/is.mjs
-/**
-* Is the value `undefined`, `null`, or stringified as a whitespace-only string?
-* @param value Value to check
-* @returns `true` if the value is nullable or matches a whitespace-only string, otherwise `false`
-*/
-function isNullableOrWhitespace(value) {
-	return value == null || EXPRESSION_WHITESPACE$1.test(getString(value));
+//#region node_modules/@oscarpalmer/mora/dist/value/store.mjs
+function ReactiveStore(value, options) {
+	this[SYMBOL_STATE] = {
+		...getState(void 0, options),
+		isArray: false
+	};
+	this[SYMBOL_STATE].value = new Proxy({}, { set: (target, property, value) => setValueInProxy(this, target, property, value) });
+	setProxyValue.call(this, value);
+}
+ReactiveStore.prototype[NAME_MORA] = NAME_STORE;
+ReactiveStore.prototype.asReadonly = getReadonlySignal;
+ReactiveStore.prototype.get = getValueInProxy;
+ReactiveStore.prototype.notify = notifyProxyValue;
+ReactiveStore.prototype.peek = peekValueInProxy;
+ReactiveStore.prototype.set = setProxyValue;
+ReactiveStore.prototype.subscribe = subscribeToProxy;
+ReactiveStore.prototype.toJSON = getJsonValue;
+ReactiveStore.prototype.toString = getStringValue;
+ReactiveStore.prototype.update = updateProxyValue;
+function store(value, options) {
+	return new ReactiveStore(value, options);
 }
-const EXPRESSION_WHITESPACE$1 = /^\s*$/;
 //#endregion
 //#region node_modules/@oscarpalmer/toretto/dist/internal/is.mjs
 /**
 * Is the value an event target?
+*
 * @param value Value to check
 * @returns `true` if it's an event target, otherwise `false`
 */
@@ -776,15 +1190,17 @@ function isEventTarget(value) {
 	return typeof value === "object" && value != null && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function" && typeof value.dispatchEvent === "function";
 }
 /**
-* Is the value an HTML or SVG element?
+* Is the value an _HTML_ or _SVG_ element?
+*
 * @param value Value to check
-* @returns `true` if it's an HTML or SVG element, otherwise `false`
+* @returns `true` if it's an _HTML_ or _SVG_ element, otherwise `false`
 */
 function isHTMLOrSVGElement(value) {
 	return value instanceof HTMLElement || value instanceof SVGElement;
 }
 /**
 * Is the value an input element? _(`<input>`, `<select>`, or `<textarea>`)_
+*
 * @param value Value to check
 * @returns `true` if it's an input element, otherwise `false`
 */
@@ -792,31 +1208,26 @@ function isInputElement(value) {
 	return value instanceof HTMLInputElement || value instanceof HTMLSelectElement || value instanceof HTMLTextAreaElement;
 }
 //#endregion
-//#region node_modules/@oscarpalmer/toretto/dist/is.mjs
-/**
-* Is the value a child node?
-* @param value Value to check
-* @returns `true` if it's a child node, otherwise `false`
-*/
-function isChildNode(value) {
-	return value instanceof Node && CHILD_NODE_TYPES.has(value.nodeType);
+//#region node_modules/@oscarpalmer/atoms/dist/internal/defaults.mjs
+function getNumberOrDefault(value, defaultValue, minimum) {
+	return typeof value === "number" && !Number.isNaN(value) && value >= (minimum ?? 0) ? value : defaultValue;
 }
-const CHILD_NODE_TYPES = new Set([
-	Node.ELEMENT_NODE,
-	Node.TEXT_NODE,
-	Node.PROCESSING_INSTRUCTION_NODE,
-	Node.COMMENT_NODE,
-	Node.DOCUMENT_TYPE_NODE
-]);
 //#endregion
 //#region node_modules/@oscarpalmer/atoms/dist/internal/number.mjs
 /**
 * Clamp a number between a minimum and maximum value
+*
 * @param value Value to clamp
 * @param minimum Minimum value
 * @param maximum Maximum value
 * @param loop If `true`, the value will loop around when smaller than the minimum or larger than the maximum _(defaults to `false`)_
 * @returns Clamped value
+*
+* @example
+* ```typescript
+* clamp(10, 0, 5);       // => 5
+* clamp(10, 0, 5, true); // => 0
+* ```
 */
 function clamp(value, minimum, maximum, loop) {
 	if (![
@@ -828,29 +1239,29 @@ function clamp(value, minimum, maximum, loop) {
 	return value > maximum ? loop === true ? minimum : maximum : value;
 }
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/internal/sized.mjs
+//#region node_modules/@oscarpalmer/atoms/dist/internal/sized/misc.mjs
 function getSizedMaximum(first, second) {
 	let actual;
 	if (typeof first === "number") actual = first;
-	else actual = typeof second === "number" ? second : MAXIMUM_DEFAULT;
-	return clamp(actual, 1, MAXIMUM_ABSOLUTE);
+	else actual = typeof second === "number" ? second : SIZED_MAXIMUM_DEFAULT;
+	return clamp(actual, 1, SIZED_MAXIMUM_ABSOLUTE);
 }
-const MAXIMUM_ABSOLUTE = 16777216;
-const MAXIMUM_DEFAULT = 1048576;
+const SIZED_MAXIMUM_ABSOLUTE = 16777216;
+const SIZED_MAXIMUM_DEFAULT = 1048576;
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/sized/map.mjs
+//#region node_modules/@oscarpalmer/atoms/dist/internal/sized/map.mjs
 /**
-* A Map with a maximum size
+* A _Map_ with a maximum size
 *
-* Behavior is similar to a _LRU_-cache, where the least recently used entries are removed
+* Behavior is similar to a _LRU_ cache, where the least recently used entries are removed
 */
 var SizedMap = class extends Map {
 	/**
-	* The maximum size of the Map
+	* The maximum size of the _Map_
 	*/
 	#maximumSize;
 	/**
-	* Is the Map full?
+	* Is the _Map_ full?
 	*/
 	get full() {
 		return super.size >= this.#maximumSize;
@@ -872,11 +1283,12 @@ var SizedMap = class extends Map {
 	* @inheritdoc
 	*/
 	get(key) {
+		let value;
 		if (super.has(key)) {
-			const value = super.get(key);
+			value = super.get(key);
 			this.#setValue(key, value, true);
-			return value;
 		}
+		return value;
 	}
 	/**
 	* @inheritdoc
@@ -884,124 +1296,104 @@ var SizedMap = class extends Map {
 	set(key, value) {
 		return this.#setValue(key, value, super.has(key));
 	}
-	#setValue(key, value, has) {
-		if (has) super.delete(key);
-		else if (super.size >= this.#maximumSize) super.delete(super.keys().next().value);
-		super.set(key, value);
-		return this;
-	}
-};
-//#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/function/memoize.mjs
-/**
-* A memoized function, caching and retrieving results based on the its parameters _(or a custom cache key)_
-*/
-var Memoized = class {
-	#state;
-	/**
-	* Maximum cache size
-	*/
-	get maximum() {
-		return this.#state.cache?.maximum ?? NaN;
-	}
-	/**
-	* Current cache size
-	*/
-	get size() {
-		return this.#state.cache?.size ?? NaN;
-	}
-	constructor(callback, options) {
-		const cache = new SizedMap(options.cacheSize);
-		const getter = (...parameters) => {
-			const key = options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), SEPARATOR));
-			if (cache.has(key)) return cache.get(key);
-			const value = callback(...parameters);
-			cache.set(key, value);
-			return value;
-		};
-		this.#state = {
-			cache,
-			getter
-		};
-	}
-	/**
-	* Clear the cache
-	*/
-	clear() {
-		this.#state.cache?.clear();
-	}
-	/**
-	* Delete a result from the cache
-	* @param key Key to delete
-	* @returns `true` if the key existed and was removed, otherwise `false`
-	*/
-	delete(key) {
-		return this.#state.cache?.delete(key) ?? false;
-	}
-	/**
-	* Destroy the instance _(clearing its cache and removing its callback)_
-	*/
-	destroy() {
-		this.#state.cache?.clear();
-		this.#state.cache = void 0;
-		this.#state.getter = void 0;
-	}
-	/**
-	* Get a result from the cache
-	* @param key Key to get
-	* @returns Cached result or `undefined` if it does not exist
-	*/
-	get(key) {
-		return this.#state.cache?.get(key);
-	}
-	/**
-	* Does the result exist?
-	* @param key Key to check
-	* @returns `true` if the result exists, otherwise `false`
-	*/
-	has(key) {
-		return this.#state.cache?.has(key) ?? false;
-	}
-	/**
-	* Run the callback with the provided parameters
-	* @param parameters Parameters to pass to the callback
-	* @returns Cached or computed _(then cached)_ result
-	*/
-	run(...parameters) {
-		if (this.#state.cache == null || this.#state.getter == null) throw new Error("The Memoized instance has been destroyed");
-		return this.#state.getter(...parameters);
+	#setValue(key, value, has) {
+		if (has) super.delete(key);
+		else if (super.size >= this.#maximumSize) super.delete(super.keys().next().value);
+		super.set(key, value);
+		return this;
 	}
 };
-function getMemoizationOptions(input) {
+//#endregion
+//#region node_modules/@oscarpalmer/atoms/dist/internal/function/memoize.mjs
+function Memoized(callback, options) {
+	this[MEMOIZED_SYMBOL] = {
+		options,
+		cache: new SizedMap(options.cacheSize),
+		getter: void 0
+	};
+	this[MEMOIZED_SYMBOL].getter = createGetter(this[MEMOIZED_SYMBOL], callback);
+}
+Memoized.prototype.clear = clearMemoized;
+Memoized.prototype.delete = deleteMemoizedValue;
+Memoized.prototype.get = getMemoizedValue;
+Memoized.prototype.has = hasMemoizedValue;
+Memoized.prototype.run = runMemoized;
+Object.defineProperties(Memoized.prototype, {
+	maximum: {
+		enumerable: true,
+		get: getMemoizedMaximum
+	},
+	size: {
+		enumerable: true,
+		get: getMemoizedSize
+	}
+});
+function clearMemoized() {
+	this[MEMOIZED_SYMBOL].cache.clear();
+}
+function deleteMemoizedValue(key) {
+	return this[MEMOIZED_SYMBOL].cache.delete(key);
+}
+function createGetter(state, callback) {
+	return (...parameters) => {
+		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), MEMOIZED_KEY_SEPARATOR));
+		if (state.cache.has(key)) return state.cache.get(key);
+		const value = callback(...parameters);
+		state.cache.set(key, value);
+		return value;
+	};
+}
+function createMemoizationOptions(input) {
 	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
 	return {
 		cacheKey: typeof cacheKey === "function" ? cacheKey : void 0,
-		cacheSize: typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : DEFAULT_CACHE_SIZE
+		cacheSize: getNumberOrDefault(cacheSize, MEMOIZED_CACHE_SIZE_DEFAULT)
 	};
 }
+function getMemoizedMaximum() {
+	return this[MEMOIZED_SYMBOL].cache.maximum;
+}
+function getMemoizedSize() {
+	return this[MEMOIZED_SYMBOL].cache.size;
+}
+function getMemoizedValue(key) {
+	return this[MEMOIZED_SYMBOL].cache.get(key);
+}
+function hasMemoizedValue(key) {
+	return this[MEMOIZED_SYMBOL].cache.has(key);
+}
 /**
 * Memoize a function, caching and retrieving results based on the first parameter
+*
 * @param callback Callback to memoize
 * @param options Memoization options
-* @returns Memoized instance
+* @returns _Memoized_ instance
 */
 function memoize(callback, options) {
-	return new Memoized(callback, getMemoizationOptions(options));
+	if (typeof callback !== "function") throw new TypeError(MEMOIZED_CALLBACK);
+	return new Memoized(callback, createMemoizationOptions(options));
+}
+function runMemoized(...parameters) {
+	return this[MEMOIZED_SYMBOL].getter(...parameters);
 }
-const DEFAULT_CACHE_SIZE = 1024;
-const SEPARATOR = "_";
+const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
+const MEMOIZED_CALLBACK = "Memoized requires a callback function";
+const MEMOIZED_KEY_SEPARATOR = "_";
+const MEMOIZED_SYMBOL = Symbol("memoized");
 //#endregion
-//#region node_modules/@oscarpalmer/atoms/dist/string/case.mjs
+//#region node_modules/@oscarpalmer/atoms/dist/internal/string/case.mjs
 /**
 * Convert a string to camel case _(thisIsCamelCase)_
+*
 * @param value String to convert
 * @returns Camel-cased string
 */
 function camelCase(value) {
-	return toCase(CASE_CAMEL, value, true, false);
+	return toCase(STRING_CASE_CAMEL, value, true, false);
 }
 /**
 * Capitalize the first letter of a string _(and lowercase the rest)_
+*
 * @param value String to capitalize
 * @returns Capitalized string
 */
@@ -1012,11 +1404,12 @@ function capitalize(value) {
 }
 /**
 * Convert a string to kebab case _(this-is-kebab-case)_
+*
 * @param value String to convert
 * @returns Kebab-cased string
 */
 function kebabCase(value) {
-	return toCase(CASE_KEBAB, value, false, false);
+	return toCase(STRING_CASE_KEBAB, value, false, false);
 }
 function toCase(type, value, capitalizeAny, capitalizeFirst) {
 	caseMemoizers[type] ??= memoize(toCaseCallback.bind({
@@ -1034,7 +1427,7 @@ function toCaseCallback(value) {
 	const partsLength = parts.length;
 	const cased = [];
 	for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
-		const items = parts[partIndex].replace(EXPRESSION_ACRONYM, (full, one, two, three) => three === S ? full : `${one}-${two}${three}`).replace(EXPRESSION_CAMEL_CASE, REPLACEMENT_CAMEL_CASE).split("-");
+		const items = parts[partIndex].replace(STRING_EXPRESSION_ACRONYM, (full, one, two, three) => three === STRING_S ? full : `${one}-${two}${three}`).replace(STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE).split("-");
 		const itemsLength = items.length;
 		const partResult = [];
 		let itemCount = 0;
@@ -1049,41 +1442,72 @@ function toCaseCallback(value) {
 	}
 	return join(cased, delimiters[type]);
 }
-const CASE_CAMEL = "camel";
-const CASE_KEBAB = "kebab";
-const CASE_PASCAL = "pascal";
-const CASE_SNAKE = "snake";
-const DELIMTER_EMPTY = "";
-const DELIMITER_HYPHEN = "-";
-const DELIMITER_UNDERSCORE = "_";
-const EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
-const EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
-const REPLACEMENT_CAMEL_CASE = "$1-$2";
-const S = "s";
+const STRING_CASE_CAMEL = "camel";
+const STRING_CASE_KEBAB = "kebab";
+const STRING_CASE_PASCAL = "pascal";
+const STRING_CASE_SNAKE = "snake";
+const STRING_DELIMTER_EMPTY = "";
+const STRING_DELIMITER_HYPHEN = "-";
+const STRING_DELIMITER_UNDERSCORE = "_";
+const STRING_EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
+const STRING_EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
+const STRING_REPLACEMENT_CAMEL_CASE = "$1-$2";
+const STRING_S = "s";
 const caseMemoizers = {};
 const delimiters = {
-	[CASE_CAMEL]: DELIMTER_EMPTY,
-	[CASE_KEBAB]: DELIMITER_HYPHEN,
-	[CASE_PASCAL]: DELIMTER_EMPTY,
-	[CASE_SNAKE]: DELIMITER_UNDERSCORE
+	[STRING_CASE_CAMEL]: STRING_DELIMTER_EMPTY,
+	[STRING_CASE_KEBAB]: STRING_DELIMITER_HYPHEN,
+	[STRING_CASE_PASCAL]: STRING_DELIMTER_EMPTY,
+	[STRING_CASE_SNAKE]: STRING_DELIMITER_UNDERSCORE
 };
 let memoizedCapitalize;
 //#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/internal/property.mjs
+function getPropertyValue(element, name, value) {
+	if (isInputElement(element) && name === "value") return getString(value);
+	return value;
+}
+function updateProperty(element, name, value, dispatch) {
+	let property = name;
+	if (!(property in element)) property = camelCase(name);
+	const next = getPropertyValue(element, name, value);
+	if (!(property in element) || Object.is(element[property], next)) return;
+	element[property] = next;
+	const event = dispatch && elementEvents[element.tagName]?.[property];
+	if (typeof event === "string") element.dispatchEvent(new Event(event, {
+		bubbles: true,
+		cancelable: true
+	}));
+}
+const elementEvents = {
+	DETAILS: { open: "toggle" },
+	INPUT: {
+		checked: "change",
+		value: "input"
+	},
+	SELECT: { value: "change" },
+	TEXTAREA: { value: "input" }
+};
+//#endregion
 //#region node_modules/@oscarpalmer/toretto/dist/internal/element-value.mjs
+function getValueForAttribute(value, json) {
+	if (typeof value === "string") return value;
+	return json ? JSON.stringify(value) : getString(value);
+}
 function ignoreSetAttribute(element, name) {
 	if (element instanceof HTMLTextAreaElement && name === "value") return true;
 	return false;
 }
 function normalizeKey(key, style) {
-	return style && key.startsWith(CSS_VARIABLE_PREFIX) ? key : kebabCase(key);
+	return style && key.startsWith(CSS_VARIABLE_PREFIX$1) ? key : kebabCase(key);
 }
 function setElementValue(element, first, second, third, callback, style) {
-	if (!isHTMLOrSVGElement(element)) return;
+	if (!(element instanceof Element)) return;
 	if (typeof first === "string") setElementValues(element, first, second, third, callback, style);
 	else if (isAttribute(first)) setElementValues(element, first.name, first.value, third, callback, style);
 }
 function setElementValues(element, first, second, third, callback, style) {
-	if (!isHTMLOrSVGElement(element)) return;
+	if (!(element instanceof Element)) return;
 	const dispatch = third !== false;
 	if (typeof first === "string") {
 		callback(element, normalizeKey(first, style), second, dispatch);
@@ -1101,38 +1525,11 @@ function setElementValues(element, first, second, third, callback, style) {
 		if (typeof entry === "object" && typeof entry?.name === "string") callback(element, normalizeKey(entry.name, style), entry.value, dispatch);
 	}
 }
-function updateElementValue(element, key, value, set, remove, isBoolean, json) {
-	if (isBoolean ? value == null : isNullableOrWhitespace(value)) remove.call(element, key);
-	else if (!ignoreSetAttribute(element, key)) set.call(element, key, json ? JSON.stringify(value) : getString(value));
-}
-const CSS_VARIABLE_PREFIX = "--";
-//#endregion
-//#region node_modules/@oscarpalmer/toretto/dist/internal/property.mjs
-function getPropertyValue(element, name, value) {
-	if (isInputElement(element) && name === "value") return getString(value);
-	return value;
-}
-function updateProperty(element, name, value, dispatch) {
-	let property = name;
-	if (!(property in element)) property = camelCase(name);
-	const next = getPropertyValue(element, name, value);
-	if (!(property in element) || Object.is(element[property], next)) return;
-	element[property] = next;
-	const event = dispatch && elementEvents[element.tagName]?.[property];
-	if (typeof event === "string") element.dispatchEvent(new Event(event, {
-		bubbles: true,
-		cancelable: true
-	}));
+function updateElementValue(element, key, value, set, remove, json) {
+	if (value == null) remove.call(element, key);
+	else if (!ignoreSetAttribute(element, key)) set.call(element, key, getValueForAttribute(value, json));
 }
-const elementEvents = {
-	DETAILS: { open: "toggle" },
-	INPUT: {
-		checked: "change",
-		value: "input"
-	},
-	SELECT: { value: "change" },
-	TEXTAREA: { value: "input" }
-};
+const CSS_VARIABLE_PREFIX$1 = "--";
 //#endregion
 //#region node_modules/@oscarpalmer/toretto/dist/internal/attribute.mjs
 function badAttributeHandler(name, value) {
@@ -1184,7 +1581,7 @@ function updateAttribute(element, name, value, dispatch) {
 	const isBoolean = booleanAttributesSet.has(lowerCaseName);
 	const next = isBoolean ? value === true || typeof value === "string" && (value === "" || value.toLowerCase() === lowerCaseName) : value == null ? "" : value;
 	if (isBoolean || dispatchedAttributes.has(name)) updateProperty(element, name, next, dispatch);
-	updateElementValue(element, name, isBoolean ? next ? "" : null : value, element.setAttribute, element.removeAttribute, isBoolean, false);
+	updateElementValue(element, name, isBoolean ? next ? "" : null : value, element.setAttribute, element.removeAttribute, false);
 }
 const EXPRESSION_CLOBBERED_NAME = /^(id|name)$/i;
 const EXPRESSION_DATA_OR_SCRIPT = /^(?:data|\w+script):/i;
@@ -1224,7 +1621,7 @@ const booleanAttributes = Object.freeze([
 	"selected"
 ]);
 const booleanAttributesSet = new Set(booleanAttributes);
-const dispatchedAttributes = new Set([
+const dispatchedAttributes = /* @__PURE__ */ new Set([
 	"checked",
 	"open",
 	"value"
@@ -1238,12 +1635,10 @@ function setAttribute$1(element, first, second, third) {
 }
 //#endregion
 //#region node_modules/@oscarpalmer/toretto/dist/html/sanitize.mjs
-function handleElement(element, depth) {
-	if (depth === 0) {
-		const removable = [...element.querySelectorAll(REMOVE_SELECTOR)];
-		const { length } = removable;
-		for (let index = 0; index < length; index += 1) removable[index].remove();
-	}
+function handleElement(element) {
+	const removable = [...element.querySelectorAll(REMOVE_SELECTOR)];
+	const { length } = removable;
+	for (let index = 0; index < length; index += 1) removable[index].remove();
 	sanitizeAttributes(element, [...element.attributes]);
 }
 /**
@@ -1265,43 +1660,45 @@ function sanitizeAttributes(element, attributes) {
 		else if (_isInvalidBooleanAttribute(name, value, false)) setAttribute$1(element, name, true);
 	}
 }
-function sanitizeNodes(nodes, depth) {
-	const actual = nodes.filter((node) => node instanceof Node);
+function sanitizeNodes(nodes) {
+	const actual = [];
 	let { length } = nodes;
 	for (let index = 0; index < length; index += 1) {
-		const node = actual[index];
+		const node = nodes[index];
 		let remove = isClobbered(node);
 		if (!remove) switch (node.nodeType) {
 			case Node.ELEMENT_NODE:
-				handleElement(node, depth);
+				handleElement(node);
 				break;
 			case Node.COMMENT_NODE:
 				remove = COMMENT_HARMFUL.test(node.data);
 				break;
 			case Node.DOCUMENT_TYPE_NODE:
-			case Node.PROCESSING_INSTRUCTION_NODE:
-				remove = true;
-				break;
+			case Node.PROCESSING_INSTRUCTION_NODE: remove = true;
 		}
 		if (remove) {
 			removeNode(node);
-			actual.splice(index, 1);
-			index -= 1;
-			length -= 1;
 			continue;
 		}
-		if (node.hasChildNodes()) sanitizeNodes([...node.childNodes], depth + 1);
+		if (node.hasChildNodes()) sanitizeNodes(node.childNodes);
+		actual.push(node);
 	}
-	return nodes;
+	return actual;
 }
 const COMMENT_HARMFUL = /<[/\w]/g;
 const REMOVE_SELECTOR = "script, toretto-temporary";
 //#endregion
 //#region node_modules/@oscarpalmer/toretto/dist/html/index.mjs
+/**
+* Clear cache of template elements
+*/
+function clearHtmlTemplates() {
+	templates.clear();
+}
 function createHtml(value) {
 	const parsed = getParser().parseFromString(getHtml(value), PARSE_TYPE_HTML);
 	parsed.body.normalize();
-	sanitizeNodes([parsed.body], 0);
+	sanitizeNodes([parsed.body]);
 	return parsed.body.innerHTML;
 }
 function createTemplate(value, options) {
@@ -1377,28 +1774,23 @@ function hasNodes(value) {
 	if (value instanceof HTMLCollection || value instanceof NodeList) return true;
 	return Array.isArray(value) && value.some((item) => item instanceof Node);
 }
-function html$1(first, ...second) {
+function html(first, ...second) {
 	if (isTagged(first)) {
 		const tagged = getTagged(first, second);
 		return getNodes(tagged.template, getOptions$1(), tagged.nodes);
 	}
 	return getNodes(first, getOptions$1(second[0]));
 }
+function isTagged(value) {
+	return Array.isArray(value) && Array.isArray(value.raw);
+}
 /**
-* Clear cache of template elements
-*/
-html$1.clear = () => {
-	templates.clear();
-};
-/**
-* Remove cached template element for an HTML string or id
-* @param template HTML string or id for a template element
+* Remove cached template element for an _HTML_ string or _ID_
+*
+* @param template _HTML_ string or ID for a template element
 */
-html$1.remove = (template) => {
+function removeHtmlTemplate(template) {
 	templates.delete(template);
-};
-function isTagged(value) {
-	return Array.isArray(value) && Array.isArray(value.raw);
 }
 function replaceComments(origin, replacements) {
 	const nodes = [...origin];
@@ -1422,16 +1814,14 @@ const TEMPLATE_TAG = "template";
 const TEMPORARY_ELEMENT = "<toretto-temporary></toretto-temporary>";
 const templates = new SizedMap(128);
 let parser;
-window.templates = templates;
+html.clear = clearHtmlTemplates;
+html.remove = removeHtmlTemplate;
 //#endregion
 //#region src/constants.ts
 const ARRAY_COMPARISON_ADDED = "added";
 const ARRAY_COMPARISON_DISSIMILAR = "dissimilar";
 const ARRAY_COMPARISON_REMOVED = "removed";
-const CHANGE_INPUTS = new Set(["checkbox", "radio"]);
-const ERROR_FRAGMENT = "Fragment function must return a Fragment instance";
-const ERROR_IDENTIFIER_DUPLICATE = "Duplicate identifier found: '<>'";
-const ERROR_IDENTIFIER_TYPE = "Identifier cannot be null or undefined";
+const CHANGE_INPUTS = /* @__PURE__ */ new Set(["checkbox", "radio"]);
 const EVENT_CHANGE = "change";
 const EVENT_INPUT = "input";
 const EVENT_SUBMIT = "submit";
@@ -1457,8 +1847,16 @@ const EXPRESSION_EVENT_OPTIONS_CAPTURE = /^c(?:apture)$/i;
 const EXPRESSION_EVENT_OPTIONS_ONCE = /^o(?:nce)$/i;
 const EXPRESSION_EVENT_PREFIX = /^@/;
 const EXPRESSION_TEXTAREA_VALUE = /(?:<|&lt;)!--abydon\.(\d+)--(?:>|&gt;)/;
-const NAME_FRAGMENT = "$fragment";
-const NAME_FRAGMENTS = "$fragments";
+const MESSAGE_FRAGMENT_VALUE = "Fragment template must be a string or a template strings array";
+const MESSAGE_FRAGMENTS_FRAGMENT_RESULT = "Fragment function must return a Fragment instance";
+const MESSAGE_FRAGMENTS_FRAGMENT_TYPE = "Fragment handler must be a function";
+const MESSAGE_FRAGMENTS_IDENTIFIER_RESULT_DUPLICATE = "Duplicate identifier found: '<>'";
+const MESSAGE_FRAGMENTS_IDENTIFIER_RESULT_TYPE = "Identifier cannot be null or undefined";
+const MESSAGE_FRAGMENTS_IDENTIFIER_TYPE = "Identifier handler must be a function";
+const MESSAGE_FRAGMENTS_VALUE = "Fragments array must be a reactive array";
+const NAME_FRAGMENT = "fragment";
+const NAME_FRAGMENTS = "fragments";
+const SYMBOL = Symbol("abydon");
 const WHITESPACE = /\s+/g;
 //#endregion
 //#region src/helpers/index.ts
@@ -1471,6 +1869,7 @@ function compareArrays(first, second) {
 }
 /**
 * Is the value a _Fragment_?
+*
 * @param value Value to check
 * @returns `true` if the value is a _Fragment_, otherwise `false`
 */
@@ -1479,6 +1878,7 @@ function isFragment(value) {
 }
 /**
 * Is the value a _Fragments_ instance?
+*
 * @param value Value to check
 * @returns `true` if the value is a _Fragments_ instance, otherwise `false`
 */
@@ -1486,7 +1886,7 @@ function isFragments(value) {
 	return isNamed(value, NAME_FRAGMENTS);
 }
 function isNamed(value, name) {
-	return typeof value === "object" && value != null && name in value && value[name] === true;
+	return typeof value === "object" && value !== null && SYMBOL in value && value[SYMBOL].name === name;
 }
 function setComputedValue(data, callback, after) {
 	const computation = computed(callback);
@@ -1495,25 +1895,50 @@ function setComputedValue(data, callback, after) {
 }
 //#endregion
 //#region src/fragments.ts
-var Fragments = class {
-	#state;
-	constructor(items, identify, fragment) {
-		Object.defineProperty(this, NAME_FRAGMENTS, { value: true });
-		this.#state = {
-			fragment,
-			identify,
-			array: items,
-			instances: {},
-			mapped: array([]),
-			subscriber: void 0
-		};
-		fragmentsStates.set(this, this.#state);
-		initializeFragments(this.#state);
-	}
-};
-function handleFragments(item, remove) {
-	const state = isFragments(item) ? fragmentsStates.get(item) : item;
-	(remove ? removeFragments : initializeFragments)(state);
+function Fragments(items, identify, fragment) {
+	this[SYMBOL] = {
+		fragment,
+		identify,
+		array: items,
+		instances: {},
+		mapped: array([]),
+		name: NAME_FRAGMENTS,
+		subscription: void 0
+	};
+	initializeFragments.call(this);
+}
+Fragments.prototype.remove = removeFragments;
+/**
+* Create a _Fragments_ instance from a reactive array
+*
+* _A Fragments instance can be used to efficiently render a list of items that may change over time, using unique identifiers to track each item, only adding, removing, or updating each related Fragment._
+*
+* @example
+* ```ts
+* const fruits = array(['Apple', 'Banana', 'Cherry']);
+* const items = fragments(
+*   fruits,
+*   fruit => fruit,                           // Identifies a unique item
+*   fruit => html`<p>${fruit}</p>`,           // Creates a Fragment from an item
+* );
+* html`${items}`.appendTo(document.body)      // Renders '<p>Apple</p><p>Banana</p><p>Cherry</p>'
+* fruits.push(['Date', 'Elderberry', 'Fig']); // Appends '<p>Date</p><p>Elderberry</p><p>Fig</p>'
+*                                             // without re-rendering the existing Fragments
+* ```
+*
+* @param array Reactive array
+* @param identify Function to identify item uniquely _(non-nullable)_
+* @param fragment Function to create _Fragment_ from item
+* @returns _Fragments_
+*/
+function fragments(array, identify, fragment) {
+	if (!isReactiveArray(array)) throw new TypeError(MESSAGE_FRAGMENTS_VALUE);
+	if (typeof identify !== "function") throw new TypeError(MESSAGE_FRAGMENTS_IDENTIFIER_TYPE);
+	if (typeof fragment !== "function") throw new TypeError(MESSAGE_FRAGMENTS_FRAGMENT_TYPE);
+	return new Fragments(array, identify, fragment);
+}
+function handleFragments(instance, remove) {
+	(remove ? removeFragments : initializeFragments).call(instance);
 }
 function handleItems(state, items) {
 	const keys = /* @__PURE__ */ new Set();
@@ -1522,13 +1947,13 @@ function handleItems(state, items) {
 	for (let index = 0; index < length; index += 1) {
 		const item = items[index];
 		const identifier = state.identify(item);
-		if (identifier == null) throw new TypeError(ERROR_IDENTIFIER_TYPE);
+		if (identifier == null) throw new TypeError(MESSAGE_FRAGMENTS_IDENTIFIER_RESULT_TYPE);
 		const key = getString(identifier);
-		if (keys.has(key)) throw new Error(ERROR_IDENTIFIER_DUPLICATE.replace("<>", key));
+		if (keys.has(key)) throw new Error(MESSAGE_FRAGMENTS_IDENTIFIER_RESULT_DUPLICATE.replace("<>", key));
 		let instance = state.instances[key];
 		if (instance == null) {
 			instance = state.fragment(item);
-			if (!isFragment(instance)) throw new Error(ERROR_FRAGMENT);
+			if (!isFragment(instance)) throw new Error(MESSAGE_FRAGMENTS_FRAGMENT_RESULT);
 		}
 		instance.configure({ identifier: key });
 		state.instances[key] = instance;
@@ -1538,15 +1963,18 @@ function handleItems(state, items) {
 	state.mapped.set(mapped);
 	updateFragments(state, keys);
 }
-function initializeFragments(state) {
-	state.subscriber ??= state.array.subscribe((items) => {
+function initializeFragments() {
+	const state = this[SYMBOL];
+	state.subscription ??= state.array.subscribe((items) => {
 		handleItems(state, items);
 	});
 }
-function removeFragments(state) {
-	state.subscriber?.();
+function removeFragments() {
+	const state = this[SYMBOL];
+	state.subscription?.unsubscribe();
+	state.mapped.set([]);
 	updateFragments(state);
-	state.subscriber = void 0;
+	state.subscription = void 0;
 }
 function updateFragments(state, active) {
 	const next = {};
@@ -1556,12 +1984,29 @@ function updateFragments(state, active) {
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		if (active?.has(key)) next[key] = previous[key];
-		else previous[key].remove();
+		else if (active == null) previous[key].remove();
 	}
 	state.instances = next;
 	active?.clear();
 }
-const fragmentsStates = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/is.mjs
+/**
+* Is the value a child node?
+*
+* @param value Value to check
+* @returns `true` if it's a child node, otherwise `false`
+*/
+function isChildNode(value) {
+	return value instanceof Node && CHILD_NODE_TYPES.has(value.nodeType);
+}
+const CHILD_NODE_TYPES = /* @__PURE__ */ new Set([
+	Node.ELEMENT_NODE,
+	Node.TEXT_NODE,
+	Node.PROCESSING_INSTRUCTION_NODE,
+	Node.COMMENT_NODE,
+	Node.DOCUMENT_TYPE_NODE
+]);
 //#endregion
 //#region src/helpers/dom.ts
 function createNodes(value) {
@@ -1580,10 +2025,58 @@ function replaceNodes(from, to) {
 	return to;
 }
 //#endregion
+//#region node_modules/@oscarpalmer/toretto/dist/internal/aria.mjs
+/**
+* List of _ARIA_ attributes that can be treated as boolean values
+*/
+const ariaBooleanAttributes = Object.freeze([
+	"aria-atomic",
+	"aria-busy",
+	"aria-checked",
+	"aria-current",
+	"aria-disabled",
+	"aria-expanded",
+	"aria-haspopup",
+	"aria-hidden",
+	"aria-invalid",
+	"aria-modal",
+	"aria-multiline",
+	"aria-multiselectable",
+	"aria-pressed",
+	"aria-readonly",
+	"aria-required",
+	"aria-selected"
+]);
+new Set(ariaBooleanAttributes);
+/**
+* List of _ARIA_ attributes that can be treated as numerical values
+*/
+const ariaNumericalAttributes = Object.freeze([
+	"aria-colcount",
+	"aria-colindex",
+	"aria-colspan",
+	"aria-level",
+	"aria-posinset",
+	"aria-rowcount",
+	"aria-rowindex",
+	"aria-rowspan",
+	"aria-setsize",
+	"aria-valuemax",
+	"aria-valuemin",
+	"aria-valuenow"
+]);
+new Set(ariaNumericalAttributes);
+//#endregion
 //#region node_modules/@oscarpalmer/toretto/dist/internal/get-value.mjs
 function getBoolean(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue ?? false;
 }
+function getStyleValue$1(element, property, computed) {
+	if (property.startsWith(CSS_VARIABLE_PREFIX)) return element.style.getPropertyValue(property);
+	const name = camelCase(property);
+	return computed ? getComputedStyle(element)[name] : element.style[name];
+}
+const CSS_VARIABLE_PREFIX = "--";
 //#endregion
 //#region node_modules/@oscarpalmer/toretto/dist/event/delegation.mjs
 function addDelegatedHandler(doc, type, name, passive) {
@@ -1600,7 +2093,7 @@ function addDelegatedListener(target, type, name, listener, passive) {
 	};
 }
 function delegatedEventHandler(event) {
-	const key = `${EVENT_PREFIX}${event.type}${this ? EVENT_SUFFIX_PASSIVE : EVENT_SUFFIX_ACTIVE}`;
+	const key = `@${event.type}${this ? EVENT_SUFFIX_PASSIVE : EVENT_SUFFIX_ACTIVE}`;
 	const items = event.composedPath();
 	const { length } = items;
 	let cancelled = false;
@@ -1635,7 +2128,7 @@ function delegatedEventHandler(event) {
 	}
 }
 function getDelegatedName(target, type, options) {
-	if (isEventTarget(target) && EVENT_TYPES.has(type) && !options.capture && !options.once && options.signal == null) return `${EVENT_PREFIX}${type}${options.passive ? EVENT_SUFFIX_PASSIVE : EVENT_SUFFIX_ACTIVE}`;
+	if (isEventTarget(target) && EVENT_TYPES.has(type) && !options.capture && !options.once && options.signal == null) return `@${type}${options.passive ? EVENT_SUFFIX_PASSIVE : EVENT_SUFFIX_ACTIVE}`;
 }
 function removeDelegatedListener(target, name, listener) {
 	const handlers = target[name];
@@ -1645,10 +2138,9 @@ function removeDelegatedListener(target, name, listener) {
 	return true;
 }
 const DELEGATED = /* @__PURE__ */ new Set();
-const EVENT_PREFIX = "@";
 const EVENT_SUFFIX_ACTIVE = ":active";
 const EVENT_SUFFIX_PASSIVE = ":passive";
-const EVENT_TYPES = new Set([
+const EVENT_TYPES = /* @__PURE__ */ new Set([
 	"beforeinput",
 	"click",
 	"dblclick",
@@ -1730,27 +2222,89 @@ function mapEvent(element, name, value) {
 }
 //#endregion
 //#region node_modules/@oscarpalmer/toretto/dist/style.mjs
+function StyleToggler(element, styles) {
+	this[STYLE_SYMBOL] = {
+		element,
+		styles,
+		active: false,
+		keys: Object.keys(styles),
+		values: {}
+	};
+}
+StyleToggler.prototype.remove = removeStyleTogglerValues;
+StyleToggler.prototype.set = setStyleTogglerValues;
+/**
+* Get styles from an element
+*
+* @param element Element to get styles from
+* @param names Styles to get
+* @param computed Get computed styles? _(defaults to `false`)_
+* @returns Style values
+*/
+function getStyles(element, first, second) {
+	if (!(element instanceof Element)) return {};
+	if (first == null || typeof first === "boolean") return first === true ? getComputedStyle(element) : element.style;
+	const { length } = first;
+	const styles = {};
+	for (let index = 0; index < length; index += 1) {
+		const name = first[index];
+		if (typeof name === "string") styles[name] = getStyleValue$1(element, name, second === true);
+	}
+	return styles;
+}
+function removeStyleTogglerValues() {
+	toggleStyleValues(this, false);
+}
 /**
 * Set a style on an element
+*
 * @param element Element to set the style on
-* @param property Style name
+* @param name Style name
 * @param value Style value
 */
-function setStyle(element, property, value) {
-	setElementValues(element, property, value, null, updateStyleProperty, true);
+function setStyle(element, name, value) {
+	setElementValues(element, name, value, null, updateStyleProperty, true);
+}
+function setStyleTogglerValues() {
+	toggleStyleValues(this, true);
+}
+/**
+* Set styles on an element
+*
+* @param element Element to set the styles on
+* @param styles Styles to set
+*/
+function setStyles(element, styles) {
+	setElementValues(element, styles, null, null, updateStyleProperty, true);
+}
+function toggleStyleValues(instance, active) {
+	const state = instance[STYLE_SYMBOL];
+	if (state.active === active) return;
+	state.active = active;
+	let next;
+	if (active) {
+		state.values = getStyles(state.element, state.keys);
+		next = state.styles;
+	} else {
+		next = { ...state.values };
+		state.values = {};
+		for (let index = 0; index < state.keys.length; index += 1) state.values[state.keys[index]] = void 0;
+	}
+	setStyles(state.element, next);
 }
 function updateStyleProperty(element, key, value) {
-	updateElementValue(element, key, value, function(property, style) {
-		if (property.startsWith(VARIABLE_PREFIX)) this.style.setProperty(property, getString(style));
-		else this.style[property] = getString(style);
-	}, function(property) {
-		if (property.startsWith(VARIABLE_PREFIX)) this.style.removeProperty(property);
-		else this.style[property] = "";
-		if (this.getAttribute(ATTRIBUTE_STYLE) === "") this.removeAttribute(ATTRIBUTE_STYLE);
-	}, false, false);
-}
-const ATTRIBUTE_STYLE = "style";
-const VARIABLE_PREFIX = "--";
+	updateElementValue(element, key, value, function(name, style) {
+		if (name.startsWith(STYLE_VARIABLE_PREFIX)) this.style.setProperty(name, getString(style));
+		else this.style[name] = getString(style);
+	}, function(name) {
+		if (name.startsWith(STYLE_VARIABLE_PREFIX)) this.style.removeProperty(name);
+		else this.style[name] = "";
+		if (this.getAttribute(STYLE_ATTRIBUTE) === "") this.removeAttribute(STYLE_ATTRIBUTE);
+	}, false);
+}
+const STYLE_ATTRIBUTE = "style";
+const STYLE_SYMBOL = Symbol(STYLE_ATTRIBUTE);
+const STYLE_VARIABLE_PREFIX = "--";
 //#endregion
 //#region src/attribute/value.ts
 function getStyleValue(value, unit, isVariable) {
@@ -1769,9 +2323,7 @@ function setAttribute(data, element, name, value) {
 		case EXPRESSION_ATTRIBUTE_STYLE_PREFIX.test(name):
 			setStyleValues(data, element, name, value);
 			return;
-		default:
-			setValue(data, element, name, value);
-			break;
+		default: setValue(data, element, name, value);
 	}
 }
 function setClassValues(data, element, name, value) {
@@ -1794,7 +2346,7 @@ function setValue(data, element, name, value) {
 	});
 }
 function updateValue(data, value, updater) {
-	if (isReactive(value)) data.mora.subscribers.add(value.subscribe(updater));
+	if (isReactive(value)) data.mora.subscriptions.add(value.subscribe(updater));
 	else updater(value);
 }
 //#endregion
@@ -1819,16 +2371,14 @@ function mapAttributes(data, element, ignoreValue) {
 	for (let index = 0; index < length; index += 1) {
 		const { name, value } = attributes[index];
 		const actualName = name.replace(EXPRESSION_ABYDON_ATTRIBUTE_PREFIX, "");
-		const actualValue = getValue(data, value);
 		if (actualName !== name) element.removeAttribute(name);
-		if (actualName === "value" && ignoreValue) continue;
+		if (isNullableOrWhitespace(value) || actualName === "value" && ignoreValue) continue;
+		const actualValue = getValue(data, value);
 		switch (true) {
 			case EXPRESSION_EVENT_PREFIX.test(actualName):
 				mapEvent(element, actualName, actualValue);
 				break;
-			default:
-				mapAttributeValue(data, element, actualName, actualValue);
-				break;
+			default: mapAttributeValue(data, element, actualName, actualValue);
 		}
 	}
 }
@@ -1849,8 +2399,10 @@ function addToArray(identifiers, items, nodes, added) {
 	const { length } = next;
 	for (let index = 0; index < length; index += 1) {
 		const node = next[index];
-		if (!(added && identifiers.previous.set.has(node.identifier))) if (index === 0 && before) position.before(node.value);
-		else position.after(node.value);
+		if (!(added && identifiers.previous.set.has(node.identifier))) {
+			if (index === 0 && before) position.before(node.value);
+			else position.after(node.value);
+		}
 		position = node.value;
 	}
 }
@@ -1911,7 +2463,7 @@ function removeFragmentsItems(fragments) {
 function setArray(item, comment, value) {
 	if (value.length === 0) return removeArray(item, comment);
 	const { next, previous, template } = getArrayData(item, value);
-	if (template.empty || item.nodes == null || previous.array.some((identifier) => identifier == null)) {
+	if (template.empty || item.nodes == null || item.fragments == null || previous.array.some((identifier) => identifier == null)) {
 		const fragments = (item.fragments ?? []).slice();
 		const result = {
 			fragments: template.empty ? void 0 : template.items,
@@ -1924,7 +2476,7 @@ function setArray(item, comment, value) {
 		next,
 		previous
 	}, {
-		fragments: item.fragments ?? [],
+		fragments: item.fragments,
 		templates: template.items
 	}, item.nodes);
 }
@@ -1934,7 +2486,7 @@ function setNodes(item, comment, next) {
 function setReactiveValue(data, comment, reactive) {
 	let item = data.items.find((item) => item.nodes?.includes(comment));
 	item ??= {};
-	data.mora.subscribers.add(reactive.subscribe((value) => {
+	data.mora.subscriptions.add(reactive.subscribe((value) => {
 		if (Array.isArray(value)) setReactiveValueForArray(item, comment, value);
 		else setReactiveValueForSingle(item, comment, value);
 	}));
@@ -1957,8 +2509,7 @@ function setText(item, comment, value) {
 	item.text ??= new Text();
 	item.text.textContent = valueIsNullable ? "" : getString(value);
 	const result = valueIsNullable ? [comment] : [item.text];
-	replaceNodes(item.nodes ?? [comment], result);
-	return result;
+	return replaceNodes(item.nodes ?? [comment], result);
 }
 //#endregion
 //#region src/node/index.ts
@@ -2002,9 +2553,7 @@ function mapValue(data, comment, value) {
 		case isReactive(value):
 			setReactiveValue(data, comment, value);
 			break;
-		default:
-			replaceComment(data, comment, value);
-			break;
+		default: replaceComment(data, comment, value);
 	}
 }
 function replaceComment(data, comment, value) {
@@ -2022,9 +2571,8 @@ function setComputedNode(data, comment, callback) {
 	});
 }
 function setFragmentsNode(data, comment, fragments) {
-	const state = fragmentsStates.get(fragments);
-	handleFragments(state, false);
-	setReactiveValue(data, comment, state.mapped);
+	handleFragments(fragments, false);
+	setReactiveValue(data, comment, fragments[SYMBOL].mapped);
 }
 //#endregion
 //#region src/parse.ts
@@ -2058,173 +2606,98 @@ function transformExpression(prefix, index) {
 }
 //#endregion
 //#region src/fragment.ts
-var Fragment = class {
-	#data;
-	#configuration = {
+function Fragment(strings, expressions) {
+	this[SYMBOL] = {
+		expressions,
+		strings,
+		cache: true,
 		identifier: void 0,
-		cache: true
+		items: [],
+		mora: {
+			subscriptions: /* @__PURE__ */ new Set(),
+			values: /* @__PURE__ */ new Set()
+		},
+		name: NAME_FRAGMENT,
+		values: []
 	};
-	/**
-	* Is template caching enabled?
-	*/
-	get cache() {
-		return this.#configuration.cache;
-	}
-	/**
-	* Identifier for the _Fragment_
-	*
-	* _An identifier can be used to uniquely identify a Fragment, which helps prevent re-rendering in reactive arrays and Fragments_
-	*/
-	get identifier() {
-		return this.#configuration.identifier;
-	}
-	constructor(strings, expressions) {
-		Object.defineProperty(this, NAME_FRAGMENT, { value: true });
-		this.#data = {
-			expressions,
-			strings,
-			items: [],
-			mora: {
-				subscribers: /* @__PURE__ */ new Set(),
-				values: /* @__PURE__ */ new Set()
-			},
-			values: []
-		};
-	}
-	/**
-	* Insert the _Fragment_ after the given element
-	* @param element Element to insert after
-	*/
-	after(element) {
-		element.after(...this.get());
-	}
-	/**
-	* Append the _Fragment_ to the given element
-	* @param element Element to append to
-	*/
-	appendTo(element) {
-		element.append(...this.get());
-	}
-	/**
-	* Insert the _Fragment_ before the given element
-	* @param element Element to insert before
-	*/
-	before(element) {
-		element.before(...this.get());
-	}
-	/**
-	* Configure the _Fragment_
-	*
-	* _Returns the Fragment instance for chaining_
-	* @param configuration Configuration options
-	* @returns _Fragment_
-	*/
-	configure(configuration) {
-		const actual = isPlainObject(configuration) ? configuration : {};
-		if ("identifier" in actual) this.#configuration.identifier = actual.identifier;
-		if (typeof actual.cache === "boolean") this.#configuration.cache = actual.cache;
-		return this;
-	}
-	/**
-	* Get a list of the _Fragment_'s nodes
-	* @returns List of nodes
-	*/
-	get() {
-		const data = this.#data;
-		if (data.items.length === 0) {
-			const templated = html$1(parse(data), { cache: this.#configuration.cache });
-			data.items.splice(0, data.items.length, ...templated.map((node) => ({ nodes: [node] })));
-			mapNodes(data, data.items.flatMap((item) => item.nodes));
-		}
-		return data.items.flatMap((item) => item.fragments?.flatMap((fragment) => fragment.get()) ?? item.nodes);
-	}
-	/**
-	* Prepend the _Fragment_ to the given element
-	* @param element Element to prepend to
-	*/
-	prependTo(element) {
-		element.prepend(...this.get());
-	}
-	/**
-	* Remove the _Fragment_ _(and all its descendants)_ from the _DOM_
-	*
-	* - _Any events, reactive values, and Fragments will also be cleaned up and removed_
-	* - _After being removed, the Fragment can be re-inserted into the DOM_
-	*/
-	remove() {
-		removeFragment(this.#data);
+}
+Fragment.prototype.after = insertFragmentAfter;
+Fragment.prototype.appendTo = appendFragmentTo;
+Fragment.prototype.before = insertFragmentBefore;
+Fragment.prototype.configure = configureFragment;
+Fragment.prototype.get = getFragmentNodes;
+Fragment.prototype.prependTo = prependFragmentTo;
+Fragment.prototype.remove = removeFragment;
+Object.defineProperties(Fragment.prototype, {
+	cache: {
+		enumerable: true,
+		get: getFragmentCache
+	},
+	identifier: {
+		enumerable: true,
+		get: getFragmentIdentifier
+	}
+});
+function appendFragmentTo(element) {
+	element.append(...this.get());
+}
+function configureFragment(configuration) {
+	const state = this[SYMBOL];
+	const actual = isPlainObject(configuration) ? configuration : {};
+	if ("identifier" in actual) state.identifier = actual.identifier;
+	if (typeof actual.cache === "boolean") state.cache = actual.cache;
+	return this;
+}
+function fragment(template, ...values) {
+	if (typeof template !== "string" && isNonTemplateStringsArray(template)) throw new TypeError(MESSAGE_FRAGMENT_VALUE);
+	return new Fragment(template, values);
+}
+function getFragmentCache() {
+	return this[SYMBOL].cache;
+}
+function getFragmentIdentifier() {
+	return this[SYMBOL].identifier;
+}
+function getFragmentNodes() {
+	const state = this[SYMBOL];
+	if (state.items.length === 0) {
+		const templated = html(parse(state), { cache: state.cache });
+		state.items.splice(0, state.items.length, ...templated.map((node) => ({ nodes: [node] })));
+		mapNodes(state, state.items.flatMap((item) => item.nodes));
 	}
-};
-function removeFragment(data) {
-	removeMora(data);
-	let { length } = data.items;
+	return state.items.flatMap((item) => item.fragments?.flatMap((fragment) => fragment.get()) ?? item.nodes);
+}
+function insertFragmentAfter(element) {
+	element.after(...this.get());
+}
+function insertFragmentBefore(element) {
+	element.before(...this.get());
+}
+function prependFragmentTo(element) {
+	element.prepend(...this.get());
+}
+function removeFragment() {
+	const state = this[SYMBOL];
+	removeMora(state);
+	let { length } = state.items;
 	for (let index = 0; index < length; index += 1) {
-		const { fragments, nodes } = data.items[index];
+		const { fragments, nodes } = state.items[index];
 		const fragmentsLength = fragments?.length ?? 0;
 		for (let fragmentIndex = 0; fragmentIndex < fragmentsLength; fragmentIndex += 1) fragments?.[fragmentIndex]?.remove();
 		removeNodes(nodes);
 	}
-	data.items.length = 0;
-	length = data.values.length;
+	state.items.length = 0;
+	length = state.values.length;
 	for (let index = 0; index < length; index += 1) {
-		const value = data.values[index];
+		const value = state.values[index];
 		if (isFragments(value)) handleFragments(value, true);
 	}
 }
-function removeMora(data) {
-	const unsubscribers = [...data.mora.subscribers];
-	data.mora.subscribers.clear();
-	data.mora.values.clear();
-	for (const unsubscribe of unsubscribers) unsubscribe();
-}
-//#endregion
-//#region src/index.ts
-/**
-* Create a _Fragments_ instance from a reactive array
-* 
-* _A Fragments instance can be used to efficiently render a list of items that may change over time, using unique identifiers to track each item, only adding, removing, or updating each related Fragment._
-*
-* @example
-* ```ts
-* const fruits = array(['Apple', 'Banana', 'Cherry']);
-* const items = fragments(
-*   fruits,
-*   fruit => fruit,                           // Identifies a unique item
-*   fruit => html`<p>${fruit}</p>`,           // Creates a Fragment from an item
-* );
-* html`${items}`.appendTo(document.body)      // Renders '<p>Apple</p><p>Banana</p><p>Cherry</p>'
-* fruits.push(['Date', 'Elderberry', 'Fig']); // Appends '<p>Date</p><p>Elderberry</p><p>Fig</p>'
-*                                             // without re-rendering the existing Fragments
-* ```
-*
-* @param array Reactive array
-* @param identify Function to identify item uniquely _(non-nullable)_
-* @param fragment Function to create _Fragment_ from item
-* @returns _Fragments_
-*/
-function fragments(array, identify, fragment) {
-	if (!isArray(array)) throw new TypeError("Fragments array must be a reactive array");
-	if (typeof identify !== "function") throw new TypeError("Fragments identify must be a function");
-	if (typeof fragment !== "function") throw new TypeError("Fragments fragment must be a function");
-	return new Fragments(array, identify, fragment);
-}
-/**
-* Create a _Fragment_ from a template
-* 
-* _A Fragment can be used to efficiently render a template that may change over time, only updating the necessary parts of the DOM._
-*
-* @example
-* ```ts
-* const name = signal('World');
-* const fragment = html`<p>Hello, ${name}!</p>`;
-* fragment.appendTo(document.body);              // Renders '<p>Hello, World!</p>'
-* name.set('Alice');                             // Replaces 'World' with 'Alice'
-* ```
-*
-* @returns _Fragment_
-*/
-function html(template, ...values) {
-	return new Fragment(template, values);
+function removeMora(state) {
+	const subscriptions = [...state.mora.subscriptions];
+	state.mora.subscriptions.clear();
+	state.mora.values.clear();
+	for (const subscription of subscriptions) subscription.unsubscribe();
 }
 //#endregion
-export { array, computed, effect, fragments, html, isArray, isComputed, isEffect, isFragment, isFragments, isReactive, isSignal, signal, startBatch, stopBatch, store };
+export { array, computed, effect, fragment, fragment as html, fragments, isComputed, isEffect, isFragment, isFragments, isReactive, isReactiveArray, isReactiveStore, isReadonlySignal, isSignal, signal, startBatch, stopBatch, store };