mutts 1.0.5 → 1.0.7

package/dist/eventful.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"eventful.js","sources":["../src/eventful.ts"],"sourcesContent":["/**\n * Base type for event maps - all event handlers must be functions\n */\nexport type EventsBase = Record<string, (...args: any[]) => void>\n/**\n * A type-safe event system that provides a clean API for event handling\n * @template Events - The event map defining event names and their handler signatures\n */\nexport class Eventful<Events extends EventsBase> {\n\treadonly #events = new Map<keyof Events, ((...args: any[]) => void)[]>()\n\treadonly #hooks = [] as ((...args: any[]) => void)[]\n\n\tpublic hook(\n\t\tcb: <EventType extends keyof Events>(\n\t\t\tevent: EventType,\n\t\t\t...args: Parameters<Events[EventType]>\n\t\t) => void\n\t): () => void {\n\t\tif (!this.#hooks.includes(cb)) this.#hooks.push(cb)\n\t\treturn () => {\n\t\t\tthis.#hooks.splice(this.#hooks.indexOf(cb), 1)\n\t\t}\n\t}\n\n\tpublic on(events: Partial<Events>): void\n\tpublic on<EventType extends keyof Events>(event: EventType, cb: Events[EventType]): () => void\n\tpublic on<EventType extends keyof Events>(\n\t\teventOrEvents: EventType | Partial<Events>,\n\t\tcb?: Events[EventType]\n\t): () => void {\n\t\tif (typeof eventOrEvents === 'object') {\n\t\t\tfor (const e of Object.keys(eventOrEvents) as (keyof Events)[]) {\n\t\t\t\tthis.on(e, eventOrEvents[e]!)\n\t\t\t}\n\t\t} else if (cb !== undefined) {\n\t\t\tlet callbacks = this.#events.get(eventOrEvents)\n\t\t\tif (!callbacks) {\n\t\t\t\tcallbacks = []\n\t\t\t\tthis.#events.set(eventOrEvents, callbacks)\n\t\t\t}\n\t\t\tcallbacks.push(cb)\n\t\t}\n\t\t// @ts-expect-error Generic case leads to generic case\n\t\treturn () => this.off(eventOrEvents, cb)\n\t}\n\tpublic off(events: Partial<Events>): void\n\tpublic off<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]): void\n\tpublic off<EventType extends keyof Events>(\n\t\teventOrEvents: EventType | Partial<Events>,\n\t\tcb?: Events[EventType]\n\t): void {\n\t\tif (typeof eventOrEvents === 'object') {\n\t\t\tfor (const e of Object.keys(eventOrEvents) as (keyof Events)[]) {\n\t\t\t\tthis.off(e, eventOrEvents[e])\n\t\t\t}\n\t\t} else if (cb !== null && cb !== undefined) {\n\t\t\tconst callbacks = this.#events.get(eventOrEvents)\n\t\t\tif (callbacks) {\n\t\t\t\tthis.#events.set(\n\t\t\t\t\teventOrEvents,\n\t\t\t\t\tcallbacks.filter((c) => c !== cb)\n\t\t\t\t)\n\t\t\t}\n\t\t} else {\n\t\t\t// Remove all listeners for this event\n\t\t\tthis.#events.delete(eventOrEvents)\n\t\t}\n\t}\n\tpublic emit<EventType extends keyof Events>(\n\t\tevent: EventType,\n\t\t...args: Parameters<Events[EventType]>\n\t) {\n\t\tconst callbacks = this.#events.get(event)\n\t\tif (callbacks) for (const cb of callbacks) cb.apply(this, args)\n\t\tfor (const cb of this.#hooks) cb.call(this, event, ...args)\n\t}\n}\n"],"names":["__classPrivateFieldGet"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,19 +0,0 @@
-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'
-
-// 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 +0,0 @@
-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 { ArrayReadForward, Indexable, forwardArray, getAt, setAt } from './indexable.esm.js';
-export { I as IterableWeakMap, a as IterableWeakSet, O as ReactiveBase, X as ReactiveError, R as ReadOnlyError, U as Register, j as addBatchCleanup, k as atomic, l as batch, n as biDi, c as buildReactivityGraph, z as cleanedBy, A as cleanup, h as deepWatch, o as defer, B as derived, q as effect, e as enableDevTools, u as getActivationLog, v as getActiveEffect, L as getActiveProjection, g as getState, H as immutables, i as isDevtoolsEnabled, J as isNonReactive, N as isReactive, Y as isZoneEnabled, E as mapped, G as memoize, m as mixin, S as organize, T as organized, p as profileInfo, M as project, P as reactive, W as reactiveOptions, F as reduced, V as register, r as registerEffectForDebug, K as registerNativeReactivity, d as registerObjectForDebug, w as root, s as setEffectName, f as setObjectName, Z as setZoneEnabled, t as touched, b as touched1, x as trackEffect, C as unreactive, y as untracked, Q as unwrap, D as watch } from './chunks/index-qiWwozOc.esm.js';
-export { cache, cached, debounce, deprecated, describe, isCached, throttle } from './std-decorators.esm.js';
-import './chunks/_tslib-Mzh1rNsX.esm.js';
-//# sourceMappingURL=index.esm.js.map

package/dist/index.esm.js.map

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

package/dist/index.js

@@ -1,95 +0,0 @@
-'use strict';
-
-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-Cvxdw6Ax.js');
-var stdDecorators = require('./std-decorators.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.isOwnAccessor = decorator.isOwnAccessor;
-exports.legacyDecorator = decorator.legacyDecorator;
-exports.modernDecorator = decorator.modernDecorator;
-exports.renamed = decorator.renamed;
-exports.zip = decorator.zip;
-exports.Destroyable = destroyable.Destroyable;
-exports.DestructionError = destroyable.DestructionError;
-exports.allocated = destroyable.allocated;
-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.IterableWeakMap = reactive.IterableWeakMap;
-exports.IterableWeakSet = reactive.IterableWeakSet;
-exports.ReactiveBase = reactive.ReactiveBase;
-exports.ReactiveError = reactive.ReactiveError;
-exports.ReadOnlyError = reactive.ReadOnlyError;
-exports.Register = reactive.Register;
-exports.addBatchCleanup = reactive.addBatchCleanup;
-exports.atomic = reactive.atomic;
-exports.batch = reactive.batch;
-exports.biDi = reactive.biDi;
-exports.buildReactivityGraph = reactive.buildReactivityGraph;
-exports.cleanedBy = reactive.cleanedBy;
-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.getActivationLog = reactive.getActivationLog;
-exports.getActiveEffect = reactive.getActiveEffect;
-exports.getActiveProjection = reactive.getActiveProjection;
-exports.getState = reactive.getState;
-exports.immutables = reactive.immutables;
-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;
-exports.unwrap = reactive.unwrap;
-exports.watch = reactive.watch;
-exports.cache = stdDecorators.cache;
-exports.cached = stdDecorators.cached;
-exports.debounce = stdDecorators.debounce;
-exports.deprecated = stdDecorators.deprecated;
-exports.describe = stdDecorators.describe;
-exports.isCached = stdDecorators.isCached;
-exports.throttle = stdDecorators.throttle;
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/indexable.d.ts

@@ -1,243 +0,0 @@
-/**
- * Symbol for defining custom getter logic for numeric index access
- */
-declare const getAt: unique symbol;
-/**
- * Symbol for defining custom setter logic for numeric index access
- */
-declare const setAt: unique symbol;
-interface IndexingAt<Items = any> {
-    [getAt](index: number): Items;
-}
-interface Accessor<T, Items> {
-    get(this: T, index: number): Items;
-    set?(this: T, index: number, value: Items): void;
-    getLength?(this: T): number;
-    setLength?(this: T, value: number): void;
-}
-declare abstract class AbstractGetAt<Items = any> {
-    abstract [getAt](index: number): Items;
-}
-/**
- * Creates an indexable class with a base class and accessor object
- * @param base - The base class to extend
- * @param accessor - Object containing get/set methods for numeric index access
- * @returns A class that supports numeric index access
- */
-declare function Indexable<Items, Base extends abstract new (...args: any[]) => any>(base: Base, accessor: Accessor<InstanceType<Base>, Items>): new (...args: ConstructorParameters<Base>) => InstanceType<Base> & {
-    [x: number]: Items;
-};
-/**
- * Creates an indexable class with only an accessor object (no base class)
- * @param accessor - Object containing get/set methods for numeric index access
- * @returns A class that supports numeric index access
- */
-declare function Indexable<Items>(accessor: Accessor<any, Items>): new () => {
-    [x: number]: Items;
-};
-/**
- * Creates an indexable class with a base class that has [getAt] method
- * @param base - The base class that implements [getAt] method
- * @returns A class that supports numeric index access using the base class's [getAt] method
- */
-declare function Indexable<Base extends new (...args: any[]) => IndexingAt>(base: Base): new (...args: ConstructorParameters<Base>) => InstanceType<Base> & {
-    [x: number]: AtReturnType<InstanceType<Base>>;
-};
-/**
- * Creates an abstract indexable base class
- * @returns An abstract class that supports numeric index access
- */
-declare function Indexable<Items>(): abstract new (...args: any[]) => AbstractGetAt & {
-    [x: number]: Items;
-};
-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 { ArrayReadForward, Indexable, forwardArray, getAt, setAt };

package/dist/indexable.esm.js

@@ -1,285 +0,0 @@
-/**
- * Symbol for defining custom getter logic for numeric index access
- */
-const getAt = Symbol('getAt');
-/**
- * Symbol for defining custom setter logic for numeric index access
- */
-const setAt = Symbol('setAt');
-function Indexable(base, accessor) {
-    if (base && typeof base !== 'function') {
-        accessor = base;
-        base = undefined;
-    }
-    if (!base) {
-        //@ts-expect-error
-        base = class {
-        };
-    }
-    if (!accessor) {
-        accessor = {
-            get(index) {
-                if (typeof this[getAt] !== 'function') {
-                    throw new Error('Indexable class must have an [getAt] method');
-                }
-                return this[getAt](index);
-            },
-            set(index, value) {
-                if (typeof this[setAt] !== 'function') {
-                    throw new Error('Indexable class has read-only numeric index access');
-                }
-                this[setAt](index, value);
-            },
-        };
-    }
-    class Indexable extends base {
-    }
-    Object.setPrototypeOf(Indexable.prototype, new Proxy(base.prototype, {
-        //@ts-expect-error
-        [Symbol.toStringTag]: 'MutTs Indexable',
-        get(target, prop, receiver) {
-            if (prop in target) {
-                const getter = Object.getOwnPropertyDescriptor(target, prop)?.get;
-                return getter ? getter.call(receiver) : target[prop];
-            }
-            if (typeof prop === 'string') {
-                if (prop === 'length' && accessor.getLength)
-                    return accessor.getLength.call(receiver);
-                const numProp = Number(prop);
-                if (!Number.isNaN(numProp)) {
-                    return accessor.get.call(receiver, numProp);
-                }
-            }
-            return undefined;
-        },
-        set(target, prop, value, receiver) {
-            if (prop in target) {
-                const setter = Object.getOwnPropertyDescriptor(target, prop)?.set;
-                if (setter)
-                    setter.call(receiver, value);
-                else
-                    target[prop] = value;
-                return true;
-            }
-            if (typeof prop === 'string') {
-                if (prop === 'length' && accessor.setLength) {
-                    accessor.setLength.call(receiver, value);
-                    return true;
-                }
-                const numProp = Number(prop);
-                if (!Number.isNaN(numProp)) {
-                    if (!accessor.set)
-                        throw new Error('Indexable class has read-only numeric index access');
-                    accessor.set.call(receiver, numProp, value);
-                    return true;
-                }
-            }
-            Object.defineProperty(receiver, prop, {
-                value,
-                writable: true,
-                enumerable: true,
-                configurable: true,
-            });
-            return true;
-        },
-    }));
-    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 { ArrayReadForward, Indexable, forwardArray, getAt, setAt };
-//# sourceMappingURL=indexable.esm.js.map