mutts 1.0.2 → 1.0.3

package/dist/eventful.esm.js

@@ -1,4 +1,4 @@
-import { _ as __classPrivateFieldGet } from './chunks/_tslib-CMEnd0VE.esm.js';
+import { _ as __classPrivateFieldGet } from './chunks/_tslib-Mzh1rNsX.esm.js';
 
 var _Eventful_events, _Eventful_hooks;
 /**

package/dist/eventful.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var _tslib = require('./chunks/_tslib-C-cuVLvZ.js');
+var _tslib = require('./chunks/_tslib-BgjropY9.js');
 
 var _Eventful_events, _Eventful_hooks;
 /**

package/dist/index.d.ts

@@ -1,64 +1,19 @@
-export { Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, GenericClassDecorator, LegacyClassDecorator, LegacyPropertyDecorator, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, decorator, legacyDecorator, modernDecorator } from './decorator.js';
-export { ContextManager, Destroyable, DestructionError, allocated, allocatedValues, callOnGC, destructor } from './destroyable.js';
-export { Eventful, EventsBase } from './eventful.js';
-export { Indexable, getAt, setAt } from './indexable.js';
-export { Evolution, Reactive, ReactiveBase, ReactiveError, ScopedCallback, activeEffect, addBatchCleanup, atomic, cleanedBy, computed, effect, getState, immutables, invalidateComputed, isNonReactive, isReactive, profileInfo, reactive, reactiveOptions, trackEffect, unreactive, untracked, unwrap, watch } from './reactive.js';
-export { cache, cached, debounce, deprecated, describe, isCached, throttle } from './std-decorators.js';
+export * from './decorator.js'
+export * from './destroyable.js'
+export * from './eventful.js'
+export * from './indexable.js'
+export * from './iterableWeak.js'
+export * from './mixins.js'
+export * from './reactive.js'
+export * from './std-decorators.js'
+export * from './utils.js'
 
-/**
- * A mixin function that takes a base class and returns a new class with mixed-in functionality
- * @template Mixed - The functionality to be mixed in
- */
-type MixinFunction<Mixed> = <Base>(base: new (...args: any[]) => Base) => new (...args: any[]) => Base & Mixed;
-/**
- * A mixin class that can be used both as a base class and as a mixin function
- * @template Mixed - The functionality to be mixed in
- */
-type MixinClass<Mixed> = new (...args: any[]) => Mixed;
-/**
- * Creates a mixin that can be used both as a class (extends) and as a function (mixin)
- *
- * This function supports:
- * - Using mixins as base classes: `class MyClass extends MyMixin`
- * - Using mixins as functions: `class MyClass extends MyMixin(SomeBase)`
- * - Composing mixins: `const Composed = MixinA(MixinB)`
- * - Type-safe property inference for all patterns
- *
- * @param mixinFunction - The function that creates the mixin
- * @param unwrapFunction - Optional function to unwrap reactive objects for method calls
- * @returns A mixin that can be used both as a class and as a function
- */
-declare function mixin<MixinFn extends (base: any) => new (...args: any[]) => any>(mixinFunction: MixinFn, unwrapFunction?: (obj: any) => any): (new (...args: any[]) => InstanceType<ReturnType<MixinFn>>) & (<Base>(base: abstract new (...args: any[]) => Base) => new (...args: any[]) => InstanceType<ReturnType<MixinFn>> & Base);
-
-type ElementTypes<T extends readonly unknown[]> = {
-    [K in keyof T]: T[K] extends readonly (infer U)[] ? U : T[K];
-};
-/**
- * Combines multiple arrays into an array of tuples, stopping at the shortest array length
- * @param args - Arrays to zip together
- * @returns Array of tuples containing elements from each input array
- */
-declare function zip<T extends (readonly unknown[])[]>(...args: T): ElementTypes<T>[];
-/**
- * Checks if a function is a constructor (class or constructor function)
- * @param fn - The function to check
- * @returns True if the function is a constructor
- */
-declare function isConstructor(fn: Function): boolean;
-/**
- * Renames a function with a new name
- * @param fct - The function to rename
- * @param name - The new name for the function
- * @returns The function with the new name
- */
-declare function renamed<F extends Function>(fct: F, name: string): F;
-declare function ReflectGet(obj: any, prop: any, receiver: any): any;
-declare function ReflectSet(obj: any, prop: any, value: any, receiver: any): any;
-declare function isOwnAccessor(obj: any, prop: any): boolean;
-/**
- * Check if an object is an object (not null, not primitive)
- */
-declare function isObject(obj: any): obj is object;
-
-export { ReflectGet, ReflectSet, isConstructor, isObject, isOwnAccessor, mixin, renamed, zip };
-export type { MixinClass, MixinFunction };
+// Augment Array.isArray to properly handle readonly arrays in type narrowing
+interface ArrayConstructor {
+	/**
+	 * Determines whether an object is an array.
+	 * @param arg Any value to test.
+	 * @returns True if the value is an array (mutable or readonly), false otherwise.
+	 */
+	isArray(arg: any): arg is any[] | readonly any[]
+}

package/dist/index.esm.js

@@ -1,8 +1,8 @@
-export { D as DecoratorError, R as ReflectGet, a as ReflectSet, d as decorator, i as isConstructor, c as isObject, b as isOwnAccessor, l as legacyDecorator, m as modernDecorator, r as renamed, z as zip } from './chunks/decorator-GnHw1Az7.esm.js';
+export { D as DecoratorError, R as ReflectGet, b as ReflectSet, a as arrayEquals, d as decorator, i as isConstructor, c as isOwnAccessor, l as legacyDecorator, m as modernDecorator, r as renamed, z as zip } from './chunks/decorator-DqiszP7i.esm.js';
 export { Destroyable, DestructionError, allocated, allocatedValues, callOnGC, destructor } from './destroyable.esm.js';
 export { Eventful } from './eventful.esm.js';
-export { Indexable, getAt, setAt } from './indexable.esm.js';
-export { R as Reactive, h as ReactiveBase, j as ReactiveError, a as activeEffect, b as addBatchCleanup, c as atomic, l as cleanedBy, n as computed, e as effect, g as getState, i as immutables, q as invalidateComputed, d as isNonReactive, f as isReactive, m as mixin, p as profileInfo, r as reactive, o as reactiveOptions, t as trackEffect, s as unreactive, u as untracked, k as unwrap, w as watch } from './chunks/index-DBScoeCX.esm.js';
+export { ArrayReadForward, Indexable, forwardArray, getAt, setAt } from './indexable.esm.js';
+export { I as IterableWeakMap, a as IterableWeakSet, L as ReactiveBase, U as ReactiveError, R as ReadOnlyError, Q as Register, j as addBatchCleanup, k as atomic, l as biDi, c as buildReactivityGraph, x as cleanedBy, y as cleanup, h as deepWatch, n as defer, z as derived, o as effect, e as enableDevTools, q as getActiveEffect, g as getState, F as immutables, i as isDevtoolsEnabled, G as isNonReactive, K as isReactive, V as isZoneEnabled, C as mapped, E as memoize, m as mixin, O as organize, P as organized, p as profileInfo, J as project, M as reactive, T as reactiveOptions, D as reduced, S as register, r as registerEffectForDebug, H as registerNativeReactivity, d as registerObjectForDebug, u as root, s as setEffectName, f as setObjectName, W as setZoneEnabled, t as touched, b as touched1, v as trackEffect, A as unreactive, w as untracked, N as unwrap, B as watch } from './chunks/index-DzUDtFc7.esm.js';
 export { cache, cached, debounce, deprecated, describe, isCached, throttle } from './std-decorators.esm.js';
-import './chunks/_tslib-CMEnd0VE.esm.js';
+import './chunks/_tslib-Mzh1rNsX.esm.js';
 //# sourceMappingURL=index.esm.js.map

package/dist/index.js

@@ -1,21 +1,21 @@
 'use strict';
 
-var decorator = require('./chunks/decorator-D4DU97Zg.js');
+var decorator = require('./chunks/decorator-DLvrD0UF.js');
 var destroyable = require('./destroyable.js');
 var eventful = require('./eventful.js');
 var indexable = require('./indexable.js');
-var reactive = require('./chunks/index-DOTmXL89.js');
+var reactive = require('./chunks/index-HNVqPzjz.js');
 var stdDecorators = require('./std-decorators.js');
-require('./chunks/_tslib-C-cuVLvZ.js');
+require('./chunks/_tslib-BgjropY9.js');
 
 
 
 exports.DecoratorError = decorator.DecoratorError;
 exports.ReflectGet = decorator.ReflectGet;
 exports.ReflectSet = decorator.ReflectSet;
+exports.arrayEquals = decorator.arrayEquals;
 exports.decorator = decorator.decorator;
 exports.isConstructor = decorator.isConstructor;
-exports.isObject = decorator.isObject;
 exports.isOwnAccessor = decorator.isOwnAccessor;
 exports.legacyDecorator = decorator.legacyDecorator;
 exports.modernDecorator = decorator.modernDecorator;
@@ -28,30 +28,55 @@ exports.allocatedValues = destroyable.allocatedValues;
 exports.callOnGC = destroyable.callOnGC;
 exports.destructor = destroyable.destructor;
 exports.Eventful = eventful.Eventful;
+exports.ArrayReadForward = indexable.ArrayReadForward;
 exports.Indexable = indexable.Indexable;
+exports.forwardArray = indexable.forwardArray;
 exports.getAt = indexable.getAt;
 exports.setAt = indexable.setAt;
-exports.Reactive = reactive.Reactive;
+exports.IterableWeakMap = reactive.IterableWeakMap;
+exports.IterableWeakSet = reactive.IterableWeakSet;
 exports.ReactiveBase = reactive.ReactiveBase;
 exports.ReactiveError = reactive.ReactiveError;
-Object.defineProperty(exports, "activeEffect", {
-	enumerable: true,
-	get: function () { return reactive.activeEffect; }
-});
+exports.ReadOnlyError = reactive.ReadOnlyError;
+exports.Register = reactive.Register;
 exports.addBatchCleanup = reactive.addBatchCleanup;
 exports.atomic = reactive.atomic;
+exports.biDi = reactive.biDi;
+exports.buildReactivityGraph = reactive.buildReactivityGraph;
 exports.cleanedBy = reactive.cleanedBy;
-exports.computed = reactive.computed;
+exports.cleanup = reactive.cleanup;
+exports.deepWatch = reactive.deepWatch;
+exports.defer = reactive.defer;
+exports.derived = reactive.derived;
 exports.effect = reactive.effect;
+exports.enableDevTools = reactive.enableDevTools;
+exports.getActiveEffect = reactive.getActiveEffect;
 exports.getState = reactive.getState;
 exports.immutables = reactive.immutables;
-exports.invalidateComputed = reactive.invalidateComputed;
+exports.isDevtoolsEnabled = reactive.isDevtoolsEnabled;
 exports.isNonReactive = reactive.isNonReactive;
 exports.isReactive = reactive.isReactive;
+exports.isZoneEnabled = reactive.isZoneEnabled;
+exports.mapped = reactive.mapped;
+exports.memoize = reactive.memoize;
 exports.mixin = reactive.mixin;
+exports.organize = reactive.organize;
+exports.organized = reactive.organized;
 exports.profileInfo = reactive.profileInfo;
+exports.project = reactive.project;
 exports.reactive = reactive.reactive;
 exports.reactiveOptions = reactive.options;
+exports.reduced = reactive.reduced;
+exports.register = reactive.register;
+exports.registerEffectForDebug = reactive.registerEffectForDebug;
+exports.registerNativeReactivity = reactive.registerNativeReactivity;
+exports.registerObjectForDebug = reactive.registerObjectForDebug;
+exports.root = reactive.root;
+exports.setEffectName = reactive.setEffectName;
+exports.setObjectName = reactive.setObjectName;
+exports.setZoneEnabled = reactive.setZoneEnabled;
+exports.touched = reactive.touched;
+exports.touched1 = reactive.touched1;
 exports.trackEffect = reactive.trackEffect;
 exports.unreactive = reactive.unreactive;
 exports.untracked = reactive.untracked;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/indexable.d.ts

@@ -53,5 +53,191 @@ declare function Indexable<Items>(): abstract new (...args: any[]) => AbstractGe
 type AtReturnType<T> = T extends {
     [getAt](index: number): infer R;
 } ? R : never;
+/**
+ * Symbol for accessing the forwarded array in ArrayReadForward
+ */
+declare const forwardArray: unique symbol;
+/**
+ * A read-only array forwarder that implements all reading/iterating methods of Array
+ * but does not implement modification methods.
+ *
+ * The constructor takes a callback that returns an array, and all methods forward
+ * their behavior to the result of that callback.
+ */
+declare class ArrayReadForward<T> {
+    protected get [forwardArray](): readonly T[];
+    /**
+     * Get the length of the array
+     */
+    get length(): number;
+    /**
+     * Get an element at a specific index
+     */
+    [index: number]: T | undefined;
+    /**
+     * Iterator protocol support
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Creates a new array with the results of calling a provided function on every element
+     */
+    map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
+    /**
+     * Creates a new array with all elements that pass the test implemented by the provided function
+     */
+    filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[];
+    filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[];
+    /**
+     * Executes a reducer function on each element of the array, resulting in a single output value
+     */
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+    /**
+     * Executes a reducer function on each element of the array (right-to-left), resulting in a single output value
+     */
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
+    /**
+     * Executes a provided function once for each array element
+     */
+    forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
+    /**
+     * Returns the value of the first element in the array that satisfies the provided testing function
+     */
+    find<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S | undefined;
+    find(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T | undefined;
+    /**
+     * Returns the index of the first element in the array that satisfies the provided testing function
+     */
+    findIndex(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): number;
+    /**
+     * Returns the value of the last element in the array that satisfies the provided testing function
+     */
+    findLast<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S | undefined;
+    findLast(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T | undefined;
+    /**
+     * Returns the index of the last element in the array that satisfies the provided testing function
+     */
+    findLastIndex(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): number;
+    /**
+     * Determines whether an array includes a certain value among its entries
+     */
+    includes(searchElement: T, fromIndex?: number): boolean;
+    /**
+     * Returns the first index at which a given element can be found in the array
+     */
+    indexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Returns the last index at which a given element can be found in the array
+     */
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    /**
+     * Returns a shallow copy of a portion of an array into a new array object
+     */
+    slice(start?: number, end?: number): T[];
+    /**
+     * Returns a new array comprised of this array joined with other array(s) and/or value(s)
+     */
+    concat(...items: ConcatArray<T>[]): T[];
+    concat(...items: (T | ConcatArray<T>)[]): T[];
+    /**
+     * Tests whether all elements in the array pass the test implemented by the provided function
+     */
+    every(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
+    /**
+     * Tests whether at least one element in the array passes the test implemented by the provided function
+     */
+    some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
+    /**
+     * Joins all elements of an array into a string
+     */
+    join(separator?: string): string;
+    /**
+     * Returns a new array iterator that contains the keys for each index in the array
+     */
+    keys(): IterableIterator<number>;
+    /**
+     * Returns a new array iterator that contains the values for each index in the array
+     */
+    values(): IterableIterator<T>;
+    /**
+     * Returns a new array iterator that contains the key/value pairs for each index in the array
+     */
+    entries(): IterableIterator<[number, T]>;
+    /**
+     * Returns a string representation of the array
+     */
+    toString(): string;
+    /**
+     * Returns a localized string representing the array
+     */
+    toLocaleString(locales?: string | string[], options?: Intl.NumberFormatOptions | Intl.DateTimeFormatOptions): string;
+    /**
+     * Returns the element at the specified index, or undefined if the index is out of bounds
+     */
+    at(index: number): T | undefined;
+    /**
+     * Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth
+     */
+    flat(depth?: number): T[];
+    /**
+     * Returns a new array formed by applying a given callback function to each element of the array,
+     * and then flattening the result by one level
+     */
+    flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: readonly T[]) => U | ReadonlyArray<U>, thisArg?: This): U[];
+    /**
+     * Returns a new array with elements in reversed order (ES2023)
+     */
+    toReversed(): T[];
+    /**
+     * Returns a new array with elements sorted (ES2023)
+     */
+    toSorted(compareFn?: ((a: T, b: T) => number) | undefined): T[];
+    /**
+     * Returns a new array with some elements removed and/or replaced at a given index (ES2023)
+     */
+    toSpliced(start: number, deleteCount?: number, ...items: T[]): T[];
+    /**
+     * Returns a new array with the element at the given index replaced with the given value (ES2023)
+     */
+    with(index: number, value: T): T[];
+    get [Symbol.unscopables](): {
+        readonly [x: number]: boolean;
+        readonly length?: boolean;
+        toString?: boolean;
+        toLocaleString?: boolean;
+        concat?: boolean;
+        join?: boolean;
+        slice?: boolean;
+        indexOf?: boolean;
+        lastIndexOf?: boolean;
+        every?: boolean;
+        some?: boolean;
+        forEach?: boolean;
+        map?: boolean;
+        filter?: boolean;
+        reduce?: boolean;
+        reduceRight?: boolean;
+        find?: boolean;
+        findIndex?: boolean;
+        entries?: boolean;
+        keys?: boolean;
+        values?: boolean;
+        includes?: boolean;
+        flatMap?: boolean;
+        flat?: boolean;
+        at?: boolean;
+        findLast?: boolean;
+        findLastIndex?: boolean;
+        toReversed?: boolean;
+        toSorted?: boolean;
+        toSpliced?: boolean;
+        with?: boolean;
+        [Symbol.iterator]?: boolean;
+        readonly [Symbol.unscopables]?: boolean;
+    };
+}
 
-export { Indexable, getAt, setAt };
+export { ArrayReadForward, Indexable, forwardArray, getAt, setAt };

package/dist/indexable.esm.js

@@ -68,9 +68,8 @@ function Indexable(base, accessor) {
                 }
                 const numProp = Number(prop);
                 if (!Number.isNaN(numProp)) {
-                    if (!accessor.set) {
+                    if (!accessor.set)
                         throw new Error('Indexable class has read-only numeric index access');
-                    }
                     accessor.set.call(receiver, numProp, value);
                     return true;
                 }
@@ -86,6 +85,201 @@ function Indexable(base, accessor) {
     }));
     return Indexable;
 }
+/**
+ * Symbol for accessing the forwarded array in ArrayReadForward
+ */
+const forwardArray = Symbol('forwardArray');
+/**
+ * A read-only array forwarder that implements all reading/iterating methods of Array
+ * but does not implement modification methods.
+ *
+ * The constructor takes a callback that returns an array, and all methods forward
+ * their behavior to the result of that callback.
+ */
+class ArrayReadForward {
+    get [forwardArray]() {
+        throw new Error('ArrayReadForward is not implemented');
+    }
+    /**
+     * Get the length of the array
+     */
+    get length() {
+        return this[forwardArray].length;
+    }
+    /**
+     * Iterator protocol support
+     */
+    [Symbol.iterator]() {
+        return this[forwardArray][Symbol.iterator]();
+    }
+    // Reading/Iterating methods
+    /**
+     * Creates a new array with the results of calling a provided function on every element
+     */
+    map(callbackfn, thisArg) {
+        return this[forwardArray].map(callbackfn, thisArg);
+    }
+    filter(predicate, thisArg) {
+        return this[forwardArray].filter(predicate, thisArg);
+    }
+    reduce(callbackfn, initialValue) {
+        return initialValue !== undefined
+            ? this[forwardArray].reduce(callbackfn, initialValue)
+            : this[forwardArray].reduce(callbackfn);
+    }
+    reduceRight(callbackfn, initialValue) {
+        return initialValue !== undefined
+            ? this[forwardArray].reduceRight(callbackfn, initialValue)
+            : this[forwardArray].reduceRight(callbackfn);
+    }
+    /**
+     * Executes a provided function once for each array element
+     */
+    forEach(callbackfn, thisArg) {
+        this[forwardArray].forEach(callbackfn, thisArg);
+    }
+    find(predicate, thisArg) {
+        return this[forwardArray].find(predicate, thisArg);
+    }
+    /**
+     * Returns the index of the first element in the array that satisfies the provided testing function
+     */
+    findIndex(predicate, thisArg) {
+        return this[forwardArray].findIndex(predicate, thisArg);
+    }
+    findLast(predicate, thisArg) {
+        return this[forwardArray].findLast(predicate, thisArg);
+    }
+    /**
+     * Returns the index of the last element in the array that satisfies the provided testing function
+     */
+    findLastIndex(predicate, thisArg) {
+        return this[forwardArray].findLastIndex(predicate, thisArg);
+    }
+    /**
+     * Determines whether an array includes a certain value among its entries
+     */
+    includes(searchElement, fromIndex) {
+        return this[forwardArray].includes(searchElement, fromIndex);
+    }
+    /**
+     * Returns the first index at which a given element can be found in the array
+     */
+    indexOf(searchElement, fromIndex) {
+        return this[forwardArray].indexOf(searchElement, fromIndex);
+    }
+    /**
+     * Returns the last index at which a given element can be found in the array
+     */
+    lastIndexOf(searchElement, fromIndex) {
+        return this[forwardArray].lastIndexOf(searchElement, fromIndex);
+    }
+    /**
+     * Returns a shallow copy of a portion of an array into a new array object
+     */
+    slice(start, end) {
+        return this[forwardArray].slice(start, end);
+    }
+    concat(...items) {
+        return this[forwardArray].concat(...items);
+    }
+    /**
+     * Tests whether all elements in the array pass the test implemented by the provided function
+     */
+    every(predicate, thisArg) {
+        return this[forwardArray].every(predicate, thisArg);
+    }
+    /**
+     * Tests whether at least one element in the array passes the test implemented by the provided function
+     */
+    some(predicate, thisArg) {
+        return this[forwardArray].some(predicate, thisArg);
+    }
+    /**
+     * Joins all elements of an array into a string
+     */
+    join(separator) {
+        return this[forwardArray].join(separator);
+    }
+    /**
+     * Returns a new array iterator that contains the keys for each index in the array
+     */
+    keys() {
+        return this[forwardArray].keys();
+    }
+    /**
+     * Returns a new array iterator that contains the values for each index in the array
+     */
+    values() {
+        return this[forwardArray].values();
+    }
+    /**
+     * Returns a new array iterator that contains the key/value pairs for each index in the array
+     */
+    entries() {
+        return this[forwardArray].entries();
+    }
+    /**
+     * Returns a string representation of the array
+     */
+    toString() {
+        return this[forwardArray].toString();
+    }
+    /**
+     * Returns a localized string representing the array
+     */
+    toLocaleString(locales, options) {
+        return this[forwardArray].toLocaleString(locales, options);
+    }
+    /**
+     * Returns the element at the specified index, or undefined if the index is out of bounds
+     */
+    at(index) {
+        return this[forwardArray].at(index);
+    }
+    /**
+     * Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth
+     */
+    flat(depth) {
+        return this[forwardArray].flat(depth);
+    }
+    /**
+     * Returns a new array formed by applying a given callback function to each element of the array,
+     * and then flattening the result by one level
+     */
+    flatMap(callback, thisArg) {
+        return this[forwardArray].flatMap(callback, thisArg);
+    }
+    /**
+     * Returns a new array with elements in reversed order (ES2023)
+     */
+    toReversed() {
+        return this[forwardArray].toReversed?.() ?? [...this[forwardArray]].reverse();
+    }
+    /**
+     * Returns a new array with elements sorted (ES2023)
+     */
+    toSorted(compareFn) {
+        return this[forwardArray].toSorted?.(compareFn) ?? [...this[forwardArray]].sort(compareFn);
+    }
+    /**
+     * Returns a new array with some elements removed and/or replaced at a given index (ES2023)
+     */
+    toSpliced(start, deleteCount, ...items) {
+        if (deleteCount === undefined)
+            return this[forwardArray].toSpliced(start);
+        return this[forwardArray].toSpliced(start, deleteCount, ...items);
+    }
+    /**
+     * Returns a new array with the element at the given index replaced with the given value (ES2023)
+     */
+    with(index, value) {
+        return this[forwardArray].with(index, value);
+    }
+    get [Symbol.unscopables]() {
+        return this[forwardArray][Symbol.unscopables];
+    }
+}
 
-export { Indexable, getAt, setAt };
+export { ArrayReadForward, Indexable, forwardArray, getAt, setAt };
 //# sourceMappingURL=indexable.esm.js.map