data-structure-typed 2.1.0 → 2.1.1

package/dist/cjs/utils/utils.js

@@ -1,354 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTrampolineThunk = exports.makeTrampolineThunk = exports.roundFixed = exports.calcMinUnitsRequired = exports.isWeakKey = exports.throwRangeError = exports.rangeCheck = exports.getMSB = exports.arrayRemove = exports.uuidV4 = void 0;
-exports.isComparable = isComparable;
-exports.trampoline = trampoline;
-exports.makeTrampoline = makeTrampoline;
-exports.asyncTrampoline = asyncTrampoline;
-exports.makeAsyncTrampoline = makeAsyncTrampoline;
-/**
- * The function generates a random UUID (Universally Unique Identifier) in TypeScript.
- * @returns A randomly generated UUID (Universally Unique Identifier) in the format
- * 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' where each 'x' is replaced with a random hexadecimal
- * character.
- */
-const uuidV4 = function () {
-    return 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'.replace(/[x]/g, function (c) {
-        const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-};
-exports.uuidV4 = uuidV4;
-/**
- * The `arrayRemove` function removes elements from an array based on a specified predicate function
- * and returns the removed elements.
- * @param {T[]} array - An array of elements that you want to filter based on the provided predicate
- * function.
- * @param predicate - The `predicate` parameter is a function that takes three arguments:
- * @returns The `arrayRemove` function returns an array containing the elements that satisfy the given
- * `predicate` function.
- */
-const arrayRemove = function (array, predicate) {
-    let i = -1, len = array ? array.length : 0;
-    const result = [];
-    while (++i < len) {
-        const value = array[i];
-        if (predicate(value, i, array)) {
-            result.push(value);
-            Array.prototype.splice.call(array, i--, 1);
-            len--;
-        }
-    }
-    return result;
-};
-exports.arrayRemove = arrayRemove;
-/**
- * The function `getMSB` returns the most significant bit of a given number.
- * @param {number} value - The `value` parameter is a number for which we want to find the position of
- * the Most Significant Bit (MSB). The function `getMSB` takes this number as input and calculates the
- * position of the MSB in its binary representation.
- * @returns The function `getMSB` returns the most significant bit (MSB) of the input `value`. If the
- * input value is less than or equal to 0, it returns 0. Otherwise, it calculates the position of the
- * MSB using the `Math.clz32` function and bitwise left shifts 1 to that position.
- */
-const getMSB = (value) => {
-    if (value <= 0) {
-        return 0;
-    }
-    return 1 << (31 - Math.clz32(value));
-};
-exports.getMSB = getMSB;
-/**
- * The `rangeCheck` function in TypeScript is used to validate if an index is within a specified range
- * and throws a `RangeError` with a custom message if it is out of bounds.
- * @param {number} index - The `index` parameter represents the value that you want to check if it
- * falls within a specified range.
- * @param {number} min - The `min` parameter represents the minimum value that the `index` should be
- * compared against in the `rangeCheck` function.
- * @param {number} max - The `max` parameter in the `rangeCheck` function represents the maximum value
- * that the `index` parameter is allowed to have. If the `index` is greater than this `max` value, a
- * `RangeError` will be thrown.
- * @param [message=Index out of bounds.] - The `message` parameter is a string that represents the
- * error message to be thrown if the index is out of bounds. By default, if no message is provided when
- * calling the `rangeCheck` function, the message "Index out of bounds." will be used.
- */
-const rangeCheck = (index, min, max, message = 'Index out of bounds.') => {
-    if (index < min || index > max)
-        throw new RangeError(message);
-};
-exports.rangeCheck = rangeCheck;
-/**
- * The function `throwRangeError` throws a RangeError with a custom message if called.
- * @param [message=The value is off-limits.] - The `message` parameter is a string that represents the
- * error message to be displayed when a `RangeError` is thrown. If no message is provided, the default
- * message is 'The value is off-limits.'.
- */
-const throwRangeError = (message = 'The value is off-limits.') => {
-    throw new RangeError(message);
-};
-exports.throwRangeError = throwRangeError;
-/**
- * The function `isWeakKey` checks if the input is an object or a function in TypeScript.
- * @param {unknown} input - The `input` parameter in the `isWeakKey` function is of type `unknown`,
- * which means it can be any type. The function checks if the `input` is an object (excluding `null`)
- * or a function, and returns a boolean indicating whether the `input` is a weak
- * @returns The function `isWeakKey` returns a boolean value indicating whether the input is an object
- * or a function.
- */
-const isWeakKey = (input) => {
-    const inputType = typeof input;
-    return (inputType === 'object' && input !== null) || inputType === 'function';
-};
-exports.isWeakKey = isWeakKey;
-/**
- * The function `calcMinUnitsRequired` calculates the minimum number of units required to accommodate a
- * given total quantity based on a specified unit size.
- * @param {number} totalQuantity - The `totalQuantity` parameter represents the total quantity of items
- * that need to be processed or handled.
- * @param {number} unitSize - The `unitSize` parameter represents the size of each unit or package. It
- * is used in the `calcMinUnitsRequired` function to calculate the minimum number of units required to
- * accommodate a total quantity of items.
- */
-const calcMinUnitsRequired = (totalQuantity, unitSize) => Math.floor((totalQuantity + unitSize - 1) / unitSize);
-exports.calcMinUnitsRequired = calcMinUnitsRequired;
-/**
- * The `roundFixed` function in TypeScript rounds a number to a specified number of decimal places.
- * @param {number} num - The `num` parameter is a number that you want to round to a certain number of
- * decimal places.
- * @param {number} [digit=10] - The `digit` parameter in the `roundFixed` function specifies the number
- * of decimal places to round the number to. By default, it is set to 10 if not provided explicitly.
- * @returns The function `roundFixed` returns a number that is rounded to the specified number of
- * decimal places (default is 10 decimal places).
- */
-const roundFixed = (num, digit = 10) => {
-    const multiplier = Math.pow(10, digit);
-    return Math.round(num * multiplier) / multiplier;
-};
-exports.roundFixed = roundFixed;
-/**
- * The function `isPrimitiveComparable` checks if a value is a primitive type that can be compared.
- * @param {unknown} value - The `value` parameter in the `isPrimitiveComparable` function is of type
- * `unknown`, which means it can be any type. The function checks if the `value` is a primitive type
- * that can be compared, such as number, bigint, string, or boolean.
- * @returns The function `isPrimitiveComparable` returns a boolean value indicating whether the input
- * `value` is a primitive value that can be compared using standard comparison operators (<, >, <=,
- * >=).
- */
-function isPrimitiveComparable(value) {
-    const valueType = typeof value;
-    if (valueType === 'number')
-        return true;
-    // if (valueType === 'number') return !Number.isNaN(value);
-    return valueType === 'bigint' || valueType === 'string' || valueType === 'boolean';
-}
-/**
- * The function `tryObjectToPrimitive` attempts to convert an object to a comparable primitive value by
- * first checking the `valueOf` method and then the `toString` method.
- * @param {object} obj - The `obj` parameter in the `tryObjectToPrimitive` function is an object that
- * you want to convert to a primitive value. The function attempts to convert the object to a primitive
- * value by first checking if the object has a `valueOf` method. If the `valueOf` method exists, it
- * @returns The function `tryObjectToPrimitive` returns a value of type `ComparablePrimitive` if a
- * primitive comparable value is found within the object, or a string value if the object has a custom
- * `toString` method that does not return `'[object Object]'`. If neither condition is met, the
- * function returns `null`.
- */
-function tryObjectToPrimitive(obj) {
-    if (typeof obj.valueOf === 'function') {
-        const valueOfResult = obj.valueOf();
-        if (valueOfResult !== obj) {
-            if (isPrimitiveComparable(valueOfResult))
-                return valueOfResult;
-            if (typeof valueOfResult === 'object' && valueOfResult !== null)
-                return tryObjectToPrimitive(valueOfResult);
-        }
-    }
-    if (typeof obj.toString === 'function') {
-        const stringResult = obj.toString();
-        if (stringResult !== '[object Object]')
-            return stringResult;
-    }
-    return null;
-}
-/**
- * The function `isComparable` in TypeScript checks if a value is comparable, handling primitive values
- * and objects with optional force comparison.
- * @param {unknown} value - The `value` parameter in the `isComparable` function represents the value
- * that you want to check if it is comparable. It can be of any type (`unknown`), and the function will
- * determine if it is comparable based on certain conditions.
- * @param [isForceObjectComparable=false] - The `isForceObjectComparable` parameter in the
- * `isComparable` function is a boolean flag that determines whether to treat non-primitive values as
- * comparable objects. When set to `true`, it forces the function to consider non-primitive values as
- * comparable objects, regardless of their type.
- * @returns The function `isComparable` returns a boolean value indicating whether the `value` is
- * considered comparable or not.
- */
-function isComparable(value, isForceObjectComparable = false) {
-    if (value === null || value === undefined)
-        return false;
-    if (isPrimitiveComparable(value))
-        return true;
-    if (typeof value !== 'object')
-        return false;
-    if (value instanceof Date)
-        return true;
-    // if (value instanceof Date) return !Number.isNaN(value.getTime());
-    if (isForceObjectComparable)
-        return true;
-    const comparableValue = tryObjectToPrimitive(value);
-    if (comparableValue === null || comparableValue === undefined)
-        return false;
-    return isPrimitiveComparable(comparableValue);
-}
-/**
- * Creates a trampoline thunk object.
- *
- * A "thunk" is a deferred computation — instead of performing a recursive call immediately,
- * it wraps the next step of the computation in a function. This allows recursive processes
- * to be executed iteratively, preventing stack overflows.
- *
- * @template T - The type of the final computation result.
- * @param computation - A function that, when executed, returns the next trampoline step.
- * @returns A TrampolineThunk object containing the deferred computation.
- */
-const makeTrampolineThunk = (computation) => ({
-    isThunk: true, // Marker indicating this is a thunk
-    fn: computation // The deferred computation function
-});
-exports.makeTrampolineThunk = makeTrampolineThunk;
-/**
- * Type guard to check whether a given value is a TrampolineThunk.
- *
- * This function is used to distinguish between a final computation result (value)
- * and a deferred computation (thunk).
- *
- * @template T - The type of the value being checked.
- * @param value - The value to test.
- * @returns True if the value is a valid TrampolineThunk, false otherwise.
- */
-const isTrampolineThunk = (value) => typeof value === 'object' && // Must be an object
-    value !== null && // Must not be null
-    'isThunk' in value && // Must have the 'isThunk' property
-    value.isThunk; // The flag must be true
-exports.isTrampolineThunk = isTrampolineThunk;
-/**
- * Executes a trampoline computation until a final (non-thunk) result is obtained.
- *
- * The trampoline function repeatedly invokes the deferred computations (thunks)
- * in an iterative loop. This avoids deep recursive calls and prevents stack overflow,
- * which is particularly useful for implementing recursion in a stack-safe manner.
- *
- * @template T - The type of the final result.
- * @param initial - The initial Trampoline value or thunk to start execution from.
- * @returns The final result of the computation (a non-thunk value).
- */
-function trampoline(initial) {
-    let current = initial; // Start with the initial trampoline value
-    while ((0, exports.isTrampolineThunk)(current)) {
-        // Keep unwrapping while we have thunks
-        current = current.fn(); // Execute the deferred function to get the next step
-    }
-    return current; // Once no thunks remain, return the final result
-}
-/**
- * Wraps a recursive function inside a trampoline executor.
- *
- * This function transforms a potentially recursive function (that returns a Trampoline<Result>)
- * into a *stack-safe* function that executes iteratively using the `trampoline` runner.
- *
- * In other words, it allows you to write functions that look recursive,
- * but actually run in constant stack space.
- *
- * @template Args - The tuple type representing the argument list of the original function.
- * @template Result - The final return type after all trampoline steps are resolved.
- *
- * @param fn - A function that performs a single step of computation
- *             and returns a Trampoline (either a final value or a deferred thunk).
- *
- * @returns A new function with the same arguments, but which automatically
- *          runs the trampoline process and returns the *final result* instead
- *          of a Trampoline.
- *
- * @example
- * // Example: Computing factorial in a stack-safe way
- * const factorial = makeTrampoline(function fact(n: number, acc: number = 1): Trampoline<number> {
- *   return n === 0
- *     ? acc
- *     : makeTrampolineThunk(() => fact(n - 1, acc * n));
- * });
- *
- * console.log(factorial(100000)); // Works without stack overflow
- */
-function makeTrampoline(fn // A function that returns a trampoline step
-) {
-    // Return a wrapped function that automatically runs the trampoline execution loop
-    return (...args) => trampoline(fn(...args));
-}
-/**
- * Executes an asynchronous trampoline computation until a final (non-thunk) result is obtained.
- *
- * This function repeatedly invokes asynchronous deferred computations (thunks)
- * in an iterative loop. Each thunk may return either a Trampoline<T> or a Promise<Trampoline<T>>.
- *
- * It ensures that asynchronous recursive functions can run without growing the call stack,
- * making it suitable for stack-safe async recursion.
- *
- * @template T - The type of the final result.
- * @param initial - The initial Trampoline or Promise of Trampoline to start execution from.
- * @returns A Promise that resolves to the final result (a non-thunk value).
- */
-function asyncTrampoline(initial) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let current = yield initial; // Wait for the initial step to resolve if it's a Promise
-        // Keep executing thunks until we reach a non-thunk (final) value
-        while ((0, exports.isTrampolineThunk)(current)) {
-            current = yield current.fn(); // Execute the thunk function (may be async)
-        }
-        // Once the final value is reached, return it
-        return current;
-    });
-}
-/**
- * Wraps an asynchronous recursive function inside an async trampoline executor.
- *
- * This helper transforms a recursive async function that returns a Trampoline<Result>
- * (or Promise<Trampoline<Result>>) into a *stack-safe* async function that executes
- * iteratively via the `asyncTrampoline` runner.
- *
- * @template Args - The tuple type representing the argument list of the original function.
- * @template Result - The final return type after all async trampoline steps are resolved.
- *
- * @param fn - An async or sync function that performs a single step of computation
- *             and returns a Trampoline (either a final value or a deferred thunk).
- *
- * @returns An async function with the same arguments, but which automatically
- *          runs the trampoline process and resolves to the *final result*.
- *
- * @example
- * // Example: Async factorial using trampoline
- * const asyncFactorial = makeAsyncTrampoline(async function fact(
- *   n: number,
- *   acc: number = 1
- * ): Promise<Trampoline<number>> {
- *   return n === 0
- *     ? acc
- *     : makeTrampolineThunk(() => fact(n - 1, acc * n));
- * });
- *
- * asyncFactorial(100000).then(console.log); // Works without stack overflow
- */
-function makeAsyncTrampoline(fn) {
-    // Return a wrapped async function that runs through the async trampoline loop
-    return (...args) => __awaiter(this, void 0, void 0, function* () {
-        return asyncTrampoline(fn(...args));
-    });
-}
-//# sourceMappingURL=utils.js.map

package/dist/cjs/utils/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/utils/utils.ts"],"names":[],"mappings":"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"}

package/dist/esm/common/index.d.ts

@@ -1,12 +0,0 @@
-export declare enum DFSOperation {
-    VISIT = 0,
-    PROCESS = 1
-}
-export declare class Range<K> {
-    low: K;
-    high: K;
-    includeLow: boolean;
-    includeHigh: boolean;
-    constructor(low: K, high: K, includeLow?: boolean, includeHigh?: boolean);
-    isInRange(key: K, comparator: (a: K, b: K) => number): boolean;
-}

package/dist/esm/common/index.js

@@ -1,29 +0,0 @@
-import { isComparable } from '../utils';
-export var DFSOperation;
-(function (DFSOperation) {
-    DFSOperation[DFSOperation["VISIT"] = 0] = "VISIT";
-    DFSOperation[DFSOperation["PROCESS"] = 1] = "PROCESS";
-})(DFSOperation || (DFSOperation = {}));
-export class Range {
-    low;
-    high;
-    includeLow;
-    includeHigh;
-    constructor(low, high, includeLow = true, includeHigh = true) {
-        this.low = low;
-        this.high = high;
-        this.includeLow = includeLow;
-        this.includeHigh = includeHigh;
-        if (!(isComparable(low) && isComparable(high)))
-            throw new RangeError('low or high is not comparable');
-        if (low > high)
-            throw new RangeError('low must be less than or equal to high');
-    }
-    // Determine whether a key is within the range
-    isInRange(key, comparator) {
-        const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
-        const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
-        return lowCheck && highCheck;
-    }
-}
-//# sourceMappingURL=index.js.map

package/dist/esm/common/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/common/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC,MAAM,CAAN,IAAY,YAGX;AAHD,WAAY,YAAY;IACtB,iDAAS,CAAA;IACT,qDAAW,CAAA;AACb,CAAC,EAHW,YAAY,KAAZ,YAAY,QAGvB;AAED,MAAM,OAAO,KAAK;IAEP;IACA;IACA;IACA;IAJT,YACS,GAAM,EACN,IAAO,EACP,aAAsB,IAAI,EAC1B,cAAuB,IAAI;QAH3B,QAAG,GAAH,GAAG,CAAG;QACN,SAAI,GAAJ,IAAI,CAAG;QACP,eAAU,GAAV,UAAU,CAAgB;QAC1B,gBAAW,GAAX,WAAW,CAAgB;QAElC,IAAI,CAAC,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;YAAE,MAAM,IAAI,UAAU,CAAC,+BAA+B,CAAC,CAAC;QACtG,IAAI,GAAG,GAAG,IAAI;YAAE,MAAM,IAAI,UAAU,CAAC,wCAAwC,CAAC,CAAC;IACjF,CAAC;IAED,8CAA8C;IAC9C,SAAS,CAAC,GAAM,EAAE,UAAkC;QAClD,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAClG,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtG,OAAO,QAAQ,IAAI,SAAS,CAAC;IAC/B,CAAC;CACF"}

package/dist/esm/data-structures/base/index.d.ts

@@ -1,2 +0,0 @@
-export * from './iterable-entry-base';
-export * from './iterable-element-base';

package/dist/esm/data-structures/base/index.js

@@ -1,3 +0,0 @@
-export * from './iterable-entry-base';
-export * from './iterable-element-base';
-//# sourceMappingURL=index.js.map

package/dist/esm/data-structures/base/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/data-structures/base/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC"}

package/dist/esm/data-structures/base/iterable-element-base.d.ts

@@ -1,219 +0,0 @@
-import type { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';
-/**
- * Base class that makes a data structure iterable and provides common
- * element-wise utilities (e.g., map/filter/reduce/find).
- *
- * @template E The public element type yielded by the structure.
- * @template R The underlying "raw" element type used internally or by converters.
- *
- * @remarks
- * This class implements the JavaScript iteration protocol (via `Symbol.iterator`)
- * and offers array-like helpers with predictable time/space complexity.
- */
-export declare abstract class IterableElementBase<E, R> implements Iterable<E> {
-    /**
-     * Create a new iterable base.
-     *
-     * @param options Optional behavior overrides. When provided, a `toElementFn`
-     * is used to convert a raw element (`R`) into a public element (`E`).
-     *
-     * @remarks
-     * Time O(1), Space O(1).
-     */
-    protected constructor(options?: IterableElementBaseOptions<E, R>);
-    /**
-     * The converter used to transform a raw element (`R`) into a public element (`E`).
-     *
-     * @remarks
-     * Time O(1), Space O(1).
-     */
-    protected _toElementFn?: (rawElement: R) => E;
-    /**
-     * Exposes the current `toElementFn`, if configured.
-     *
-     * @returns The converter function or `undefined` when not set.
-     * @remarks
-     * Time O(1), Space O(1).
-     */
-    get toElementFn(): ((rawElement: R) => E) | undefined;
-    /**
-     * Returns an iterator over the structure's elements.
-     *
-     * @param args Optional iterator arguments forwarded to the internal iterator.
-     * @returns An `IterableIterator<E>` that yields the elements in traversal order.
-     *
-     * @remarks
-     * Producing the iterator is O(1); consuming the entire iterator is Time O(n) with O(1) extra space.
-     */
-    [Symbol.iterator](...args: unknown[]): IterableIterator<E>;
-    /**
-     * Returns an iterator over the values (alias of the default iterator).
-     *
-     * @returns An `IterableIterator<E>` over all elements.
-     * @remarks
-     * Creating the iterator is O(1); full iteration is Time O(n), Space O(1).
-     */
-    values(): IterableIterator<E>;
-    /**
-     * Tests whether all elements satisfy the predicate.
-     *
-     * @template TReturn
-     * @param predicate Function invoked for each element with signature `(value, index, self)`.
-     * @param thisArg Optional `this` binding for the predicate.
-     * @returns `true` if every element passes; otherwise `false`.
-     *
-     * @remarks
-     * Time O(n) in the worst case; may exit early when the first failure is found. Space O(1).
-     */
-    every(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): boolean;
-    /**
-     * Tests whether at least one element satisfies the predicate.
-     *
-     * @param predicate Function invoked for each element with signature `(value, index, self)`.
-     * @param thisArg Optional `this` binding for the predicate.
-     * @returns `true` if any element passes; otherwise `false`.
-     *
-     * @remarks
-     * Time O(n) in the worst case; may exit early on first success. Space O(1).
-     */
-    some(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): boolean;
-    /**
-     * Invokes a callback for each element in iteration order.
-     *
-     * @param callbackfn Function invoked per element with signature `(value, index, self)`.
-     * @param thisArg Optional `this` binding for the callback.
-     * @returns `void`.
-     *
-     * @remarks
-     * Time O(n), Space O(1).
-     */
-    forEach(callbackfn: ElementCallback<E, R, void>, thisArg?: unknown): void;
-    /**
-     * Finds the first element that satisfies the predicate and returns it.
-     *
-     * @overload
-     * Finds the first element of type `S` (a subtype of `E`) that satisfies the predicate and returns it.
-     * @template S
-     * @param predicate Type-guard predicate: `(value, index, self) => value is S`.
-     * @param thisArg Optional `this` binding for the predicate.
-     * @returns The matched element typed as `S`, or `undefined` if not found.
-     *
-     * @overload
-     * @param predicate Boolean predicate: `(value, index, self) => boolean`.
-     * @param thisArg Optional `this` binding for the predicate.
-     * @returns The first matching element as `E`, or `undefined` if not found.
-     *
-     * @remarks
-     * Time O(n) in the worst case; may exit early on the first match. Space O(1).
-     */
-    find<S extends E>(predicate: ElementCallback<E, R, S>, thisArg?: unknown): S | undefined;
-    find(predicate: ElementCallback<E, R, unknown>, thisArg?: unknown): E | undefined;
-    /**
-     * Checks whether a strictly-equal element exists in the structure.
-     *
-     * @param element The element to test with `===` equality.
-     * @returns `true` if an equal element is found; otherwise `false`.
-     *
-     * @remarks
-     * Time O(n) in the worst case. Space O(1).
-     */
-    has(element: E): boolean;
-    reduce(callbackfn: ReduceElementCallback<E, R>): E;
-    reduce(callbackfn: ReduceElementCallback<E, R>, initialValue: E): E;
-    reduce<U>(callbackfn: ReduceElementCallback<E, R, U>, initialValue: U): U;
-    /**
-     * Materializes the elements into a new array.
-     *
-     * @returns A shallow array copy of the iteration order.
-     * @remarks
-     * Time O(n), Space O(n).
-     */
-    toArray(): E[];
-    /**
-     * Returns a representation of the structure suitable for quick visualization.
-     * Defaults to an array of elements; subclasses may override to provide richer visuals.
-     *
-     * @returns A visual representation (array by default).
-     * @remarks
-     * Time O(n), Space O(n).
-     */
-    toVisual(): E[];
-    /**
-     * Prints `toVisual()` to the console. Intended for quick debugging.
-     *
-     * @returns `void`.
-     * @remarks
-     * Time O(n) due to materialization, Space O(n) for the intermediate representation.
-     */
-    print(): void;
-    /**
-     * Indicates whether the structure currently contains no elements.
-     *
-     * @returns `true` if empty; otherwise `false`.
-     * @remarks
-     * Expected Time O(1), Space O(1) for most implementations.
-     */
-    abstract isEmpty(): boolean;
-    /**
-     * Removes all elements from the structure.
-     *
-     * @returns `void`.
-     * @remarks
-     * Expected Time O(1) or O(n) depending on the implementation; Space O(1).
-     */
-    abstract clear(): void;
-    /**
-     * Creates a structural copy with the same element values and configuration.
-     *
-     * @returns A clone of the current instance (same concrete type).
-     * @remarks
-     * Expected Time O(n) to copy elements; Space O(n).
-     */
-    abstract clone(): this;
-    /**
-     * Maps each element to a new element and returns a new iterable structure.
-     *
-     * @template EM The mapped element type.
-     * @template RM The mapped raw element type used internally by the target structure.
-     * @param callback Function with signature `(value, index, self) => mapped`.
-     * @param options Optional options for the returned structure, including its `toElementFn`.
-     * @param thisArg Optional `this` binding for the callback.
-     * @returns A new `IterableElementBase<EM, RM>` containing mapped elements.
-     *
-     * @remarks
-     * Time O(n), Space O(n).
-     */
-    abstract map<EM, RM>(callback: ElementCallback<E, R, EM>, options?: IterableElementBaseOptions<EM, RM>, thisArg?: unknown): IterableElementBase<EM, RM>;
-    /**
-     * Maps each element to the same element type and returns the same concrete structure type.
-     *
-     * @param callback Function with signature `(value, index, self) => mappedValue`.
-     * @param thisArg Optional `this` binding for the callback.
-     * @returns A new instance of the same concrete type with mapped elements.
-     *
-     * @remarks
-     * Time O(n), Space O(n).
-     */
-    abstract mapSame(callback: ElementCallback<E, R, E>, thisArg?: unknown): this;
-    /**
-     * Filters elements using the provided predicate and returns the same concrete structure type.
-     *
-     * @param predicate Function with signature `(value, index, self) => boolean`.
-     * @param thisArg Optional `this` binding for the predicate.
-     * @returns A new instance of the same concrete type containing only elements that pass the predicate.
-     *
-     * @remarks
-     * Time O(n), Space O(k) where `k` is the number of kept elements.
-     */
-    abstract filter(predicate: ElementCallback<E, R, boolean>, thisArg?: unknown): this;
-    /**
-     * Internal iterator factory used by the default iterator.
-     *
-     * @param args Optional iterator arguments.
-     * @returns An iterator over elements.
-     *
-     * @remarks
-     * Implementations should yield in O(1) per element with O(1) extra space when possible.
-     */
-    protected abstract _getIterator(...args: unknown[]): IterableIterator<E>;
-}