@oscarpalmer/mora 0.23.0 → 0.25.0

package/dist/mora.full.js

@@ -3,604 +3,507 @@ const ARRAY_THRESHOLD = 100;
 const ARRAY_OFFSET = 25;
 const ARRAY_PEEK = 10;
 const BATCH = {
-    depth: 0,
-    handlers: new Set(),
+	depth: 0,
+	handlers: /* @__PURE__ */ new Set()
 };
 const METHODS_AFFECTING_LENGTH = new Set([
-    'pop',
-    'push',
-    'shift',
-    'unshift',
+	"pop",
+	"push",
+	"shift",
+	"unshift"
 ]);
 const METHODS_UPDATE = new Set([
-    ...METHODS_AFFECTING_LENGTH,
-    'copyWithin',
-    'fill',
-    'reverse',
-    'sort',
-    'splice',
+	...METHODS_AFFECTING_LENGTH,
+	"copyWithin",
+	"fill",
+	"reverse",
+	"sort",
+	"splice"
 ]);
-const NAME_ARRAY = 'array';
-const NAME_COMPUTED = 'computed';
-const NAME_EFFECT = 'effect';
-const NAME_SIGNAL = 'signal';
-const NAME_STORE = 'store';
-const NAMES = new Set([
-    NAME_ARRAY,
-    NAME_COMPUTED,
-    NAME_SIGNAL,
-    NAME_STORE,
+const NAME_ARRAY = "array";
+const NAME_COMPUTED = "computed";
+const NAME_EFFECT = "effect";
+const NAME_MORA = "$mora";
+const NAME_SIGNAL = "signal";
+const NAME_STORE = "store";
+const NAME_ALL = new Set([
+	NAME_ARRAY,
+	NAME_COMPUTED,
+	NAME_SIGNAL,
+	NAME_STORE
 ]);
+const PROPERTY_LENGTH = "length";
 
-class Effect {
-    constructor(callback) {
-        Object.defineProperty(this, '$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;
-    }
+var Effect = class {
+	constructor(callback) {
+		Object.defineProperty(this, NAME_MORA, { value: NAME_EFFECT });
+		this.state = { callback };
+		runEffect(this);
+	}
+};
+function runEffect(effect$1) {
+	const previousEffect = ACTIVE.effect;
+	ACTIVE.effect = effect$1;
+	try {
+		effect$1.state.callback();
+	} finally {
+		ACTIVE.effect = previousEffect;
+	}
 }
 /**
- * Create an effect
- * @param callback Callback for handling signal effects
- * @returns Effect
- */
+* Create an effect
+* @param callback Callback for handling signal effects
+* @returns Effect
+*/
 function effect(callback) {
-    return typeof callback === 'function'
-        ? new Effect(callback)
-        : undefined;
+	return typeof callback === "function" ? new Effect(callback) : void 0;
 }
 
 /**
- * Is the value a reactive array?
- * @param value Value to check
- * @returns True if value is a {@link ReactiveArray}
- */
+* Is the value a reactive array?
+* @param value Value to check
+* @returns True if value is a {@link ReactiveArray}
+*/
 function isArray(value) {
-    return isMora(value, NAME_ARRAY);
+	return isMora(value, NAME_ARRAY);
 }
 /**
- * Is the value a computed signal?
- * @param value Value to check
- * @returns True if value is a {@link Computed}
- */
+* Is the value a computed signal?
+* @param value Value to check
+* @returns True if value is a {@link Computed}
+*/
 function isComputed(value) {
-    return isMora(value, NAME_COMPUTED);
+	return isMora(value, NAME_COMPUTED);
 }
 /**
- * Is the value an effect?
- * @param value Value to check
- * @returns True if value is an {@link Effect}
- */
+* Is the value an effect?
+* @param value Value to check
+* @returns True if value is an {@link Effect}
+*/
 function isEffect(value) {
-    return isMora(value, NAME_EFFECT);
+	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)));
+	return typeof value === "object" && value != null && NAME_MORA in value && (typeof name === "string" ? value[NAME_MORA] === name : name.has(value[NAME_MORA]));
 }
 /**
- * Is the value reactive?
- * @param value Value to check
- * @returns True if value is a {@link Reactive}
- */
+* Is the value reactive?
+* @param value Value to check
+* @returns True if value is a {@link Reactive}
+*/
 function isReactive(value) {
-    return isMora(value, NAMES);
+	return isMora(value, NAME_ALL);
 }
 /**
- * Is the value a signal?
- * @param value Value to check
- * @returns True if value is a {@link Signal}
- */
+* 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);
+	return isMora(value, NAME_SIGNAL);
 }
 
 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);
-            }
-        }
-    }
+	while (BATCH.depth === 0 && BATCH.handlers.size > 0) {
+		const handlers = [...BATCH.handlers];
+		BATCH.handlers.clear();
+		for (const handler of handlers) if (isEffect(handler)) runEffect(handler);
+		else handler.callback(handler.state.value);
+	}
 }
 /**
- * Start batching effects
- *
- * _(Use {@link stopBatch} to flush and run batched effects)_
- */
+* Start batching effects
+*
+* _(Use {@link stopBatch} to flush and run batched effects)_
+*/
 function startBatch() {
-    BATCH.depth += 1;
+	BATCH.depth += 1;
 }
 /**
- * Stop batching effects and flush _(run)_ them
- */
+* Stop batching effects and flush _(run)_ them
+*/
 function stopBatch() {
-    if (BATCH.depth > 0) {
-        BATCH.depth -= 1;
-    }
-    flushHandlers();
+	if (BATCH.depth > 0) BATCH.depth -= 1;
+	flushHandlers();
 }
 
-class Subscription {
-    callback;
-    state;
-    constructor(state, callback) {
-        this.state = state;
-        this.callback = callback;
-        callback(state.value);
-    }
-    destroy() {
-        this.callback = noop;
-        this.state = undefined;
-    }
-}
-function noop() { }
+var Subscription = class {
+	callback;
+	state;
+	constructor(state, callback) {
+		this.state = state;
+		this.callback = callback;
+		callback(state.value);
+	}
+	destroy() {
+		this.callback = noop;
+		this.state = void 0;
+	}
+};
+function noop() {}
 function subscribe(state, callback) {
-    if (typeof callback !== 'function' || state.subscriptions.has(callback)) {
-        return noop;
-    }
-    state.subscriptions.set(callback, new Subscription(state, callback));
-    return () => {
-        unsubscribe(state, callback);
-    };
+	if (typeof callback !== "function" || state.subscriptions.has(callback)) return noop;
+	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);
+	state.subscriptions.get(callback)?.destroy();
+	state.subscriptions.delete(callback);
 }
 
-class Reactive {
-    state = {
-        computeds: new Set(),
-        effects: new Set(),
-        equal: Object.is,
-        subscriptions: new Map(),
-        value: undefined,
-    };
-    constructor(name, value, options) {
-        this.state.value = value;
-        if (typeof options === 'object' && typeof options.equal === 'function') {
-            this.state.equal = options.equal;
-        }
-        Object.defineProperty(this, '$mora', {
-            value: name,
-        });
-    }
-    /**
-     * Get the value _(without reactivity)_
-     * @return Current value
-     */
-    peek() {
-        return this.state.value;
-    }
-    /**
-     * Subscribe to changes
-     * @param callback Callback for changes
-     * @return Unsubscribe callback
-     */
-    subscribe(callback) {
-        return subscribe(this.state, callback);
-    }
-    /**
-     * JSON representation of the value
-     * @return JSON value
-     */
-    toJSON() {
-        return this.get();
-    }
-    /**
-     * String representation of the value
-     * @return Value as string
-     */
-    toString() {
-        return String(this.get());
-    }
-    /**
-     * Unsubscribe from changes
-     * @param callback Callback to unsubscribe
-     */
-    unsubscribe(callback) {
-        unsubscribe(this.state, callback);
-    }
-}
+var Reactive = class {
+	state = {
+		computeds: /* @__PURE__ */ new Set(),
+		effects: /* @__PURE__ */ new Set(),
+		equal: Object.is,
+		subscriptions: /* @__PURE__ */ new Map(),
+		value: void 0
+	};
+	constructor(name, value, options) {
+		this.state.value = value;
+		if (typeof options === "object" && typeof options.equal === "function") this.state.equal = options.equal;
+		Object.defineProperty(this, NAME_MORA, { value: name });
+	}
+	/**
+	* Get the value _(without reactivity)_
+	* @return Current value
+	*/
+	peek() {
+		return this.state.value;
+	}
+	/**
+	* Subscribe to changes
+	* @param callback Callback for changes
+	* @return Unsubscribe callback
+	*/
+	subscribe(callback) {
+		return subscribe(this.state, callback);
+	}
+	/**
+	* JSON representation of the value
+	* @return JSON value
+	*/
+	toJSON() {
+		return this.get();
+	}
+	/**
+	* String representation of the value
+	* @return Value as string
+	*/
+	toString() {
+		return String(this.get());
+	}
+	/**
+	* Unsubscribe from changes
+	* @param callback Callback to unsubscribe
+	*/
+	unsubscribe(callback) {
+		unsubscribe(this.state, callback);
+	}
+};
 
-class Computed extends Reactive {
-    effect = {
-        dirty: true,
-        instance: undefined,
-    };
-    constructor(callback, options) {
-        super(NAME_COMPUTED, undefined, options);
-        this.effect.instance = effect(() => {
-            if (!this.effect.dirty) {
-                return;
-            }
-            const previousComputed = ACTIVE.computed;
-            ACTIVE.computed = this;
-            const value = callback();
-            ACTIVE.computed = previousComputed;
-            if (!this.state.equal(this.state.value, value)) {
-                this.state.value = value;
-                for (const computed of this.state.computeds) {
-                    computed.effect.dirty = true;
-                }
-                for (const effect of this.state.effects) {
-                    BATCH.handlers.add(effect);
-                }
-                for (const [, subscription] of this.state.subscriptions) {
-                    subscription.callback(value);
-                }
-            }
-            this.effect.dirty = false;
-        });
-    }
-    /**
-     * @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;
-    }
-}
+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) return;
+			const previousComputed = ACTIVE.computed;
+			ACTIVE.computed = this;
+			const value = callback();
+			ACTIVE.computed = previousComputed;
+			if (!this.state.equal(this.state.value, value)) {
+				this.state.value = value;
+				for (const computed$1 of this.state.computeds) computed$1.effect.dirty = true;
+				for (const effect$1 of this.state.effects) BATCH.handlers.add(effect$1);
+				for (const [, subscription] of this.state.subscriptions) subscription.callback(value);
+			}
+			this.effect.dirty = false;
+		});
+	}
+	/**
+	* @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;
+	}
+};
 /**
- * Create a computed value
- */
+* 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 new Computed(callback, options);
 }
 
 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();
-    }
+	for (const computed$1 of state.computeds) computed$1.effect.dirty = true;
+	for (const effect$1 of state.effects) BATCH.handlers.add(effect$1);
+	for (const [, subscription] of state.subscriptions) BATCH.handlers.add(subscription);
+	if (BATCH.depth === 0) flushHandlers();
 }
 function equalArrays(state, first, second) {
-    let { length } = first;
-    if (length !== second.length) {
-        return false;
-    }
-    let offset = 0;
-    if (length >= ARRAY_THRESHOLD) {
-        offset = Math.round(length / ARRAY_PEEK);
-        offset = offset > ARRAY_OFFSET ? ARRAY_OFFSET : 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;
+	let { length } = first;
+	if (length !== second.length) return false;
+	let offset = 0;
+	if (length >= ARRAY_THRESHOLD) {
+		offset = Math.round(length / ARRAY_PEEK);
+		offset = offset > ARRAY_OFFSET ? ARRAY_OFFSET : 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;
 }
 function getValue(state) {
-    if (ACTIVE.computed != null) {
-        state.computeds.add(ACTIVE.computed);
-    }
-    if (ACTIVE.effect != null) {
-        state.effects.add(ACTIVE.effect);
-    }
-    return state.value;
+	if (ACTIVE.computed != null) state.computeds.add(ACTIVE.computed);
+	if (ACTIVE.effect != null) state.effects.add(ACTIVE.effect);
+	return state.value;
 }
 
-function getReactiveValueInProxy(reactive, mapped, key, isArray) {
-    let item = mapped.get(key);
-    if (item == null) {
-        item = computed(() => {
-            const value = reactive.get();
-            return isArray
-                ? value.at(key)
-                : value[key];
-        });
-        mapped.set(key, item);
-    }
-    return item;
+function emityProxyValues(state, mapped) {
+	const values = [...mapped.values()];
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) values[index].effect.dirty = true;
+	emitValue(state);
+}
+function getReactiveValueInProxy(reactive, mapped, key, isArray$1) {
+	let item = mapped.get(key);
+	if (item == null) {
+		item = computed(() => isArray$1 ? reactive.get().at(key) : reactive.get()[key]);
+		mapped.set(key, item);
+	}
+	return item;
 }
 function setProxyValue(proxy, value) {
-    startBatch();
-    const proxyKeys = Object.keys(proxy);
-    const valueKeys = Object.keys(value);
-    let { length } = proxyKeys;
-    for (let index = 0; index < length; index += 1) {
-        const key = proxyKeys[index];
-        proxy[key] = valueKeys.includes(key)
-            ? value[key]
-            : undefined;
-    }
-    length = valueKeys.length;
-    for (let index = 0; index < length; index += 1) {
-        const key = valueKeys[index];
-        if (!proxyKeys.includes(key)) {
-            const keyedValue = value[key];
-            proxy[key] = keyedValue;
-        }
-    }
-    stopBatch();
+	startBatch();
+	const proxyKeys = Object.keys(proxy);
+	const valueKeys = Object.keys(value);
+	let { length } = proxyKeys;
+	for (let index = 0; index < length; index += 1) {
+		const key = proxyKeys[index];
+		proxy[key] = valueKeys.includes(key) ? value[key] : void 0;
+	}
+	length = valueKeys.length;
+	for (let index = 0; index < length; index += 1) {
+		const key = valueKeys[index];
+		if (!proxyKeys.includes(key)) proxy[key] = value[key];
+	}
+	stopBatch();
 }
 function setValueInProxy(parameters) {
-    const { isArray, length, property, state, target, value } = parameters;
-    if (isArray) {
-        const isIndex = !Number.isNaN(Number(property));
-        const isLength = property === 'length';
-        if (!(isIndex || isLength)) {
-            return Reflect.set(target, property, value);
-        }
-    }
-    const previous = Reflect.get(target, property);
-    if (!state.equal(previous, value)) {
-        Reflect.set(target, property, value);
-        emitValue(state);
-        if (isArray) {
-            length?.set(target.length);
-        }
-    }
-    return true;
+	const { isArray: isArray$1, length, property, state, target, value } = parameters;
+	if (isArray$1) {
+		if (!(!Number.isNaN(Number(property)) || property === PROPERTY_LENGTH)) return Reflect.set(target, property, value);
+	}
+	const previous = Reflect.get(target, property);
+	if (!state.equal(previous, value)) {
+		Reflect.set(target, property, value);
+		emitValue(state);
+		if (isArray$1) length?.set(target.length);
+	}
+	return true;
 }
 
-class Signal extends Reactive {
-    constructor(value, options) {
-        super(NAME_SIGNAL, value, options);
-    }
-    /**
-     * @inheritdoc
-     */
-    get() {
-        return getValue(this.state);
-    }
-    /**
-     * Set the value
-     * @param value New value
-     */
-    set(value) {
-        if (!this.state.equal(this.state.value, value)) {
-            this.state.value = value;
-            emitValue(this.state);
-        }
-    }
-    /**
-     * Update the value _(based on the current value)_
-     * @param callback Callback to update the value
-     */
-    update(callback) {
-        this.set(callback(this.state.value));
-    }
-}
+var Signal = class extends Reactive {
+	constructor(value, options) {
+		super(NAME_SIGNAL, value, options);
+	}
+	/**
+	* @inheritdoc
+	*/
+	get() {
+		return getValue(this.state);
+	}
+	/**
+	* Set the value
+	* @param value New value
+	*/
+	set(value) {
+		if (!this.state.equal(this.state.value, value)) {
+			this.state.value = value;
+			emitValue(this.state);
+		}
+	}
+	/**
+	* Update the value _(based on the current value)_
+	* @param callback Callback to update the value
+	*/
+	update(callback) {
+		this.set(callback(this.state.value));
+	}
+};
 /**
- * Create a reactive value
- * @param value Initial value
- * @param options Optional reactivity options
- * @returns Reactive value
- */
+* Create a reactive value
+* @param value Initial value
+* @param options Reactivity options
+* @returns Reactive value
+*/
 function signal(value, options) {
-    return new Signal(value, options);
+	return new Signal(value, options);
 }
 
-class ReactiveArray extends Reactive {
-    #indiced = 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();
-        }
-        if (first === 'length') {
-            return this.length;
-        }
-        return getValue(this.state);
-    }
-    /**
-     * Create a computed, mapped array
-     * @param callback Callback to transform each item
-     * @return Computed array of mapped items
-     */
-    map(callback) {
-        return computed(() => this.get().map(callback));
-    }
-    /**
-     * Notify dependents of changes
-     *
-     * _This bypasses equality checks and will immediately notify dependents.
-     * Use this only if you're modifying nested data that would be ignored by equality checks._
-     */
-    notify() {
-        emitValue(this.state);
-    }
-    peek(value) {
-        if (value === 'length') {
-            return this.#size.peek();
-        }
-        if (typeof value === 'number') {
-            return this.state.value.at(value);
-        }
-        return [...this.state.value];
-    }
-    /**
-     * 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) {
-        if (first == null || Array.isArray(first)) {
-            this.state.value.splice(0, this.state.value.length, ...(first ?? []));
-        }
-        else if (first === 'length') {
-            this.length = second;
-        }
-        else if (typeof first === 'number' && !Number.isNaN(first)) {
-            setAtIndex(this.state.value, first, second);
-        }
-    }
-    /**
-     * Remove and return the first item of the array
-     * @returns Removed item, or `undefined` if the array is empty
-     */
-    shift() {
-        return this.state.value.shift();
-    }
-    /**
-     * Remove and return items from the array _(and optionally add new items)_
-     * @param from Index to start removing items from
-     * @param to Index to stop removing items at _(defaults to the end of the array)_
-     * @param items Optional items to add
-     * @returns Removed items
-     */
-    splice(from, to, ...items) {
-        return this.state.value.splice(from, to ?? this.state.value.length, ...items);
-    }
-    subscribe(first, second) {
-        if (typeof first === 'number' && typeof second === 'function') {
-            return getReactiveValueInProxy(this, this.#indiced, first, true).subscribe(second);
-        }
-        return typeof first === 'function' ? subscribe(this.state, first) : noop;
-    }
-    /**
-     * Add items to the beginning of the array
-     * @param items Items to add
-     * @returns New array length
-     */
-    unshift(...items) {
-        return this.state.value.unshift(...items);
-    }
-    /**
-     * Update the value _(based on the current value)_
-     * @param callback Callback to update the value
-     */
-    update(callback) {
-        const updated = callback(this.state.value);
-        if (updated == null || Array.isArray(updated)) {
-            this.set(updated);
-        }
-    }
-}
+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$1) => setValueInProxy({
+				property,
+				target,
+				value: value$1,
+				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 === PROPERTY_LENGTH ? this.length : getValue(this.state);
+	}
+	/**
+	* Create a computed, mapped array
+	* @param callback Callback to transform each item
+	* @return Computed array of mapped items
+	*/
+	map(callback) {
+		return computed(() => this.get().map(callback));
+	}
+	/**
+	* Notify dependents of changes
+	*
+	* _This bypasses equality checks and will immediately notify dependents.
+	* Use this only if you're modifying nested data that would be ignored by equality checks._
+	*/
+	notify() {
+		emityProxyValues(this.state, this.#indiced);
+	}
+	peek(value) {
+		if (value === "length") return this.#size.peek();
+		return typeof value === "number" ? this.state.value.at(value) : [...this.state.value];
+	}
+	/**
+	* 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) {
+		if (first == null || Array.isArray(first)) this.state.value.splice(0, this.state.value.length, ...first ?? []);
+		else if (first === "length") this.length = second;
+		else if (typeof first === "number" && !Number.isNaN(first)) setAtIndex(this.state.value, first, second);
+	}
+	/**
+	* Remove and return the first item of the array
+	* @returns Removed item, or `undefined` if the array is empty
+	*/
+	shift() {
+		return this.state.value.shift();
+	}
+	/**
+	* Remove and return items from the array _(and optionally add new items)_
+	* @param from Index to start removing items from
+	* @param to Index to stop removing items at _(defaults to the end of the array)_
+	* @param items Optional items to add
+	* @returns Removed items
+	*/
+	splice(from, to, ...items) {
+		return this.state.value.splice(from, to ?? this.state.value.length, ...items);
+	}
+	subscribe(first, second) {
+		if (typeof first === "number" && typeof second === "function") return getReactiveValueInProxy(this, this.#indiced, first, true).subscribe(second);
+		return typeof first === "function" ? subscribe(this.state, first) : noop;
+	}
+	/**
+	* Add items to the beginning of the array
+	* @param items Items to add
+	* @returns New array length
+	*/
+	unshift(...items) {
+		return this.state.value.unshift(...items);
+	}
+	/**
+	* Update the value _(based on the current value)_
+	* @param callback Callback to update the value
+	*/
+	update(callback) {
+		const updated = callback(this.state.value);
+		if (updated == null || Array.isArray(updated)) this.set(updated);
+	}
+};
 /**
- * Create a reactive array
- * @param value Initial array of items
- * @param options Optional reactivity options
- * @returns Reactive array
- */
+* Create a reactive array
+* @param value Initial array of items
+* @param options Reactivity options
+* @returns Reactive array
+*/
 function array(value, options) {
-    return new ReactiveArray(Array.isArray(value) ? value : [], options);
-}
-function updateArray(type, array, state, length) {
-    const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
-    const previousArray = affectsLength ? [] : [...array];
-    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);
-        }
-        return result;
-    };
-}
-function setAtIndex(array, index, value) {
-    const actual = index < 0 ? array.length + index : index;
-    if (actual > -1) {
-        array[actual] = value;
-    }
+	return new ReactiveArray(Array.isArray(value) ? value : [], options);
+}
+function updateArray(type, array$1, state, length) {
+	const affectsLength = METHODS_AFFECTING_LENGTH.has(type);
+	const previousArray = affectsLength ? [] : [...array$1];
+	const previousLength = array$1.length;
+	return (...args) => {
+		const result = array$1[type](...args);
+		if (affectsLength ? array$1.length !== previousLength : !equalArrays(state, previousArray, array$1)) {
+			emitValue(state);
+			length.set(array$1.length);
+		}
+		return result;
+	};
+}
+function setAtIndex(array$1, index, value) {
+	const actual = index < 0 ? array$1.length + index : index;
+	if (actual > -1) array$1[actual] = value;
 }
 
 function isKey(value) {
@@ -612,61 +515,71 @@ function isPlainObject(value) {
 	const prototype = Object.getPrototypeOf(value);
 	return prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null;
 }
+var TYPED_ARRAYS = new Set([
+	Int8Array,
+	Uint8Array,
+	Uint8ClampedArray,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array,
+	BigInt64Array,
+	BigUint64Array
+]);
 
-class Store extends Reactive {
-    #keyed = new Map();
-    constructor(value, options) {
-        super(NAME_STORE, new Proxy(value, {
-            set: (target, property, value) => setValueInProxy({
-                target,
-                property,
-                value,
-                isArray: false,
-                state: this.state,
-            }),
-        }), options);
-    }
-    get(key) {
-        return isKey(key)
-            ? getReactiveValueInProxy(this, this.#keyed, key, false).get()
-            : getValue(this.state);
-    }
-    peek(key) {
-        return isKey(key) ? this.state.value[key] : { ...this.state.value };
-    }
-    set(first, second) {
-        if (isKey(first)) {
-            this.state.value[first] = second;
-        }
-        else if (first == null || isPlainObject(first)) {
-            setProxyValue(this.state.value, first ?? {});
-        }
-    }
-    subscribe(first, second) {
-        if (isKey(first) && typeof second === 'function') {
-            return getReactiveValueInProxy(this, this.#keyed, first, false).subscribe(second);
-        }
-        return typeof first === 'function' ? subscribe(this.state, first) : noop;
-    }
-    /**
-     * Update the value _(based on the current value)_
-     * @param callback Callback to update the value
-     */
-    update(callback) {
-        const updated = callback({ ...this.state.value });
-        if (updated == null || isPlainObject(updated)) {
-            setProxyValue(this.state.value, updated ?? {});
-        }
-    }
-}
+var Store = class extends Reactive {
+	#keyed = /* @__PURE__ */ new Map();
+	constructor(value, options) {
+		super(NAME_STORE, new Proxy(value, { set: (target, property, value$1) => setValueInProxy({
+			target,
+			property,
+			value: value$1,
+			isArray: false,
+			state: this.state
+		}) }), options);
+	}
+	get(key) {
+		return isKey(key) ? getReactiveValueInProxy(this, this.#keyed, key, false).get() : getValue(this.state);
+	}
+	/**
+	* Notify dependents of changes
+	*
+	* _This bypasses equality checks and will immediately notify dependents.
+	* Use this only if you're modifying nested data that would be ignored by equality checks._
+	*/
+	notify() {
+		emityProxyValues(this.state, this.#keyed);
+	}
+	peek(key) {
+		return isKey(key) ? this.state.value[key] : { ...this.state.value };
+	}
+	set(first, second) {
+		if (isKey(first)) this.state.value[first] = second;
+		else if (first == null || isPlainObject(first)) setProxyValue(this.state.value, first ?? {});
+	}
+	subscribe(first, second) {
+		if (isKey(first) && typeof second === "function") return getReactiveValueInProxy(this, this.#keyed, first, false).subscribe(second);
+		return typeof first === "function" ? subscribe(this.state, first) : noop;
+	}
+	/**
+	* Update the value _(based on the current value)_
+	* @param callback Callback to update the value
+	*/
+	update(callback) {
+		const updated = callback({ ...this.state.value });
+		if (updated == null || isPlainObject(updated)) setProxyValue(this.state.value, updated ?? {});
+	}
+};
 /**
- * Create a reactive store
- * @param value Initial object value
- * @param options Optional reactivity options
- * @returns Reactive store
- */
+* Create a reactive store
+* @param value Initial object value
+* @param options Reactivity options
+* @returns Reactive store
+*/
 function store(value, options) {
-    return new Store((isPlainObject(value) ? value : {}), options);
+	return new Store(isPlainObject(value) ? value : {}, options);
 }
 
-export { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };
+export { array, computed, effect, isArray, isComputed, isEffect, isReactive, isSignal, signal, startBatch, stopBatch, store };