@zelgadis87/utils-core 5.2.12 → 5.3.1

package/src/utils/arrays/indexBy.ts

@@ -1,40 +1,40 @@
 
-import { TFunction, TKeysOfType } from "../_index";
+import { TFunction, TKeysOfType, identity } from "../_index";
 
-export function indexByString<V, K extends TKeysOfType<V, string>>( arr: V[], field: K ): Record<V[K] & string, V> {
-	return indexByStringWith( arr, t => t[ field ] as string );
+export function indexByString<V, K extends TKeysOfType<V, string>, R = V>( arr: V[], field: K, valueMapper: TFunction<V, R> = v => v as unknown as R ): Record<V[K] & string, R> {
+	return indexByStringWith( arr, t => t[ field ] as string, valueMapper );
 }
 
-export function indexByNumber<V, K extends TKeysOfType<V, number>>( arr: V[], field: K ): Record<V[K] & number, V> {
-	return indexByNumberWith( arr, t => t[ field ] as number );
+export function indexByNumber<V, K extends TKeysOfType<V, number>, R = V>( arr: V[], field: K, valueMapper: TFunction<V, R> = v => v as unknown as R ): Record<V[K] & number, R> {
+	return indexByNumberWith( arr, t => t[ field ] as number, valueMapper );
 }
 
-export function indexBySymbol<V, K extends TKeysOfType<V, symbol>>( arr: V[], field: K ): Record<V[K] & symbol, V> {
-	return indexBySymbolWith( arr, t => t[ field ] as symbol );
+export function indexBySymbol<V, K extends TKeysOfType<V, symbol>, R = V>( arr: V[], field: K, valueMapper: TFunction<V, R> = v => v as unknown as R ): Record<V[K] & symbol, R> {
+	return indexBySymbolWith( arr, t => t[ field ] as symbol, valueMapper );
 }
 
-export function indexByStringWith<V>( arr: V[], getter: TFunction<V, string> ): Record<string, V> {
-	return doIndexByWith<string, V>( arr, getter );
+export function indexByStringWith<V, R = V>( arr: V[], keyGetter: TFunction<V, string>, valueMapper: TFunction<V, R> = v => v as unknown as R ): Record<string, R> {
+	return doIndexByWith<string, V, R>( arr, keyGetter, valueMapper );
 }
 
-export function indexByNumberWith<V>( arr: V[], getter: TFunction<V, number> ): Record<number, V> {
-	return doIndexByWith<number, V>( arr, getter );
+export function indexByNumberWith<V, R = V>( arr: V[], keyGetter: TFunction<V, number>, valueMapper: TFunction<V, R> = v => v as unknown as R ): Record<number, R> {
+	return doIndexByWith<number, V, R>( arr, keyGetter, valueMapper );
 }
 
-export function indexBySymbolWith<V>( arr: V[], getter: TFunction<V, symbol> ): Record<symbol, V> {
-	return doIndexByWith<symbol, V>( arr, getter );
+export function indexBySymbolWith<V, R = V>( arr: V[], keyGetter: TFunction<V, symbol>, valueMapper: TFunction<V, R> = v => v as unknown as R ): Record<symbol, R> {
+	return doIndexByWith<symbol, V, R>( arr, keyGetter, valueMapper );
 }
 
-function doIndexByWith<K extends string | number | symbol, V>( arr: V[], getter: TFunction<V, K> ): Record<K, V> {
+function doIndexByWith<K extends string | number | symbol, V, R = V>( arr: V[], keyGetter: TFunction<V, K>, valueMapper: TFunction<V, R> = v => v as unknown as R ): Record<K, R> {
 	return arr.reduce( ( dict, cur ) => {
-		const key = getter( cur );
+		const key = keyGetter( cur );
 		if ( key !== null && key !== undefined ) {
 			if ( dict[ key ] ) {
 				throw new Error( `Multiple values indexed by same key "${ String( key ) }".` );
 			}
-			dict[ key ] = cur;
+			dict[ key ] = valueMapper( cur );
 		}
 		return dict;
-	}, {} as Record<K, V> );
+	}, {} as Record<K, R> );
 }
 

package/src/utils/arrays.ts

@@ -96,9 +96,11 @@ export function sortedArray<T>( arr: TReadableArray<T>, sortFn?: TComparisonFunc
 /**
  * Custom implementation of includes which allows checking for arbitrary items inside the array.
  */
-export function includes<T>( arr: TReadableArray<T>, item: unknown, fromIndex?: number ) {
+export function arrayIncludes<T>( arr: TReadableArray<T>, item: unknown, fromIndex?: number ) {
 	return arr.includes( item as any, fromIndex );
 }
+/** @deprecated[2025.11.08]: Use {@link arrayIncludes} instead. */
+export const includes= arrayIncludes;
 
 export function mapTruthys<T, R>( arr: Array<T>, mapper: ( value: T, index: number, array: T[] ) => R | undefined ): Array<R> {
 	return arr.map( mapper ).filter( value => value !== undefined ) as Array<R>;

package/dist/Logger.d.ts

@@ -1,22 +0,0 @@
-declare const LEVELS: readonly ["trace", "log", "debug", "info", "warn", "error"];
-type TLogLevel = keyof Console & typeof LEVELS[number];
-export type TLoggerOpts = {
-    console: Console;
-    enabled: boolean;
-    minLevel: Uppercase<TLogLevel>;
-};
-export declare class Logger {
-    readonly name: string;
-    private enabled;
-    private console;
-    private minLevel;
-    constructor(name: string, args?: Partial<TLoggerOpts>);
-    get trace(): (...args: any[]) => void;
-    get log(): (...args: any[]) => void;
-    get debug(): (...args: any[]) => void;
-    get info(): (...args: any[]) => void;
-    get warn(): (...args: any[]) => void;
-    get error(): (...args: any[]) => void;
-    private logWrap;
-}
-export default Logger;

package/dist/Optional.d.ts

@@ -1,108 +0,0 @@
-import { TConsumer, TFunction, TPredicate, TProducer, TVoidFunction } from "./utils/functions.js";
-export declare class Optional<T> implements TOptional<T> {
-    private _present;
-    private _value;
-    private constructor();
-    getRawValue(): T | undefined;
-    get(): T;
-    getOrElseThrow(errorProducer: TProducer<Error>): T;
-    set(t: T): void;
-    protected setNullable(t: T | null | undefined): void | this;
-    clear(): void;
-    isEmpty(): this is TEmptyOptional<T>;
-    isPresent(): this is TPresentOptional<T>;
-    ifEmpty(callback: TVoidFunction): void;
-    ifPresent(callback: TConsumer<T>): void;
-    ifPresentThenClear(callback: TConsumer<T>): void;
-    apply(callbackIfPresent: TConsumer<T>, callbackIfEmpty: TVoidFunction): any;
-    orElseReturn(newValue: T): T;
-    orElse: (newValue: T) => T;
-    orElseProduce(newValueProducer: TProducer<T>): T;
-    orElseGet: (newValueProducer: TProducer<T>) => T;
-    orElseReturnAndApply(newValue: T): T;
-    orElseProduceAndApply(newValueProducer: TProducer<T>): T;
-    orElseReturnNullableAndApply(newValue: T | null | undefined): TOptional<T>;
-    orElseProduceNullableAndApply(newValueProducer: TProducer<T | null | undefined>): TOptional<T>;
-    orElseReturnNullable(newValue: T | null | undefined): any;
-    orElseNullable: (newValue: T | null | undefined) => any;
-    orElseProduceNullable(newValueProducer: TProducer<T | null | undefined>): any;
-    orElseGetNullable: (newValueProducer: TProducer<T | null | undefined>) => any;
-    orElseThrow(errorProducer: TProducer<Error>): TPresentOptional<T>;
-    throwIfPresent(errorProducer: TFunction<T, Error>): any;
-    mapTo<R>(mapper: TFunction<T, R | null | undefined>): any;
-    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): any;
-    filter(predicate: TPredicate<T>): this | TEmptyOptional<T>;
-    static empty<T>(): TEmptyOptional<T>;
-    static of<T>(t: T): TPresentOptional<T>;
-    static ofNullable<T>(t: T | null | undefined): TOptional<T>;
-}
-export default Optional;
-export type TOptional<T> = {
-    /**
-     * @returns the currently stored value, if any; throws {@link ErrorGetEmptyOptional} otherwise;
-     */
-    get(): T;
-    /**
-     * @returns the currently stored value, if any; returns undefined otherwise;
-     */
-    getRawValue(): T | undefined;
-    /**
-     * @returns the currently stored value, if any; throws the error generated by errorProducer otherwise;
-     */
-    getOrElseThrow: (errorProducer: TProducer<Error>) => T;
-    /**
-     * Places a new value inside this optional. Throws {@link ErrorSetEmptyOptional} if t is null or undefined.
-     */
-    set(t: T): void;
-    /**
-     * Clears the current value from this optional, if any.
-     */
-    clear(): void;
-    isEmpty(): boolean;
-    isPresent(): boolean;
-    ifEmpty(callback: TVoidFunction): void;
-    ifPresent(callback: TConsumer<T>): void;
-    apply<RP = void, RE = void>(callbackIfPresent: TFunction<T, RP>, callbackIfEmpty: TProducer<RE>): RP | RE;
-    throwIfPresent: (errorGenerator: TFunction<T, Error>) => TEmptyOptional<T>;
-    /** @deprecated[2025.07.25]: Replace with {@link orElseReturn} (drop-in replacement) */
-    orElse: (newValue: T) => T;
-    /** @deprecated[2025.07.25]: Replace with {@link orElseProduce} (drop-in replacement) */
-    orElseGet: (newValueProducer: TProducer<T>) => T;
-    /** @deprecated[2025.07.25]: Replace with {@link orElseReturnNullabe} (drop-in replacement) */
-    orElseNullable: (newValue: T | null | undefined) => TOptional<T>;
-    /** @deprecated[2025.07.25]: Replace with {@link orElseProduceNullable} (drop-in replacement) */
-    orElseGetNullable: (newValueProducer: TProducer<T | null | undefined>) => TOptional<T>;
-    orElseReturn: (newValue: T) => T;
-    orElseProduce: (newValueProducer: TProducer<T>) => T;
-    orElseReturnNullable: (newValue: T | null | undefined) => TOptional<T>;
-    orElseProduceNullable: (newValueProducer: TProducer<T | null | undefined>) => TOptional<T>;
-    orElseReturnAndApply: (newValue: T) => T;
-    orElseProduceAndApply: (newValueProducer: TProducer<T>) => T;
-    orElseReturnNullableAndApply: (newValue: T | null | undefined) => TOptional<T>;
-    orElseProduceNullableAndApply: (newValueProducer: TProducer<T | null | undefined>) => TOptional<T>;
-    orElseThrow: (errorProducer: TProducer<Error>) => TPresentOptional<T>;
-    mapTo<R>(mapper: TFunction<T, R>): TOptional<R>;
-    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): TOptional<R>;
-    filter(predicate: TPredicate<T>): TOptional<T>;
-};
-export type TEmptyOptional<T> = TOptional<T> & {
-    get(): never;
-    isEmpty(): true;
-    isPresent(): false;
-    apply<RP = void, RE = void>(callbackIfPresent: TFunction<T, RP>, callbackIfEmpty: TProducer<RE>): RE;
-};
-export type TPresentOptional<T> = TOptional<T> & {
-    get(): T;
-    isEmpty(): false;
-    isPresent(): true;
-    apply<RP = void, RE = void>(callbackIfPresent: TFunction<T, RP>, callbackIfEmpty: TProducer<RE>): RP;
-};
-export declare class ErrorGetEmptyOptional extends Error {
-    constructor();
-}
-export declare class ErrorSetEmptyOptional extends Error {
-    constructor();
-}
-export declare class ErrorCannotInstantiatePresentOptionalWithEmptyValue extends Error {
-    constructor();
-}

package/dist/async/CancelableDeferred.d.ts

@@ -1,17 +0,0 @@
-import Deferred from "./Deferred.js";
-interface ICancelablePromise<T> extends Promise<T> {
-    cancel(): void;
-}
-/** @deprecated use Deferred instead. */
-export default class CancelableDeferred<T = void> extends Deferred<T> implements ICancelablePromise<T> {
-    private _canceled;
-    get canceled(): boolean;
-    constructor();
-    cancel(): void;
-    protected createInternals(): {
-        promise: Promise<T>;
-        resolve: (value: T) => void;
-        reject: (reason: Error) => void;
-    };
-}
-export {};

package/dist/async/Deferred.d.ts

@@ -1,32 +0,0 @@
-export interface ICancelable {
-    cancel(): void;
-}
-export interface ICancelablePromise<T> extends Promise<T>, ICancelable {
-}
-export declare class DeferredCanceledError extends Error {
-    constructor();
-}
-export declare class Deferred<T = void> implements ICancelablePromise<T> {
-    private _pending;
-    private readonly _internals;
-    get pending(): boolean;
-    constructor();
-    resolve(val: T): void;
-    reject(reason: Error): void;
-    cancel(): void;
-    resolveIfPending(val: T): void;
-    rejectIfPending(reason: Error): void;
-    cancelIfPending(): void;
-    then<R = T, S = T>(onFulfilled: ((value: T) => R | PromiseLike<R>) | null | undefined, onRejected?: ((reason: Error) => S | PromiseLike<S>) | null | undefined): Promise<R | S>;
-    catch<R = T>(onRejected: ((reason: Error) => R | PromiseLike<R>) | null | undefined): Promise<T | R>;
-    finally(onfinally: (() => void) | null | undefined): Promise<T>;
-    asPromise(): Promise<T>;
-    asCancelablePromise(): ICancelablePromise<T>;
-    protected createInternals(): {
-        promise: Promise<T>;
-        resolve: (value: T) => void;
-        reject: (reason: Error) => void;
-    };
-    get [Symbol.toStringTag](): string;
-}
-export default Deferred;

package/dist/async/RateThrottler.d.ts

@@ -1,13 +0,0 @@
-import { TFunction, TPromisable } from "..";
-import TimeFrequency from "../time/TimeFrequency";
-type TPromiseFactory<T, R> = TFunction<T, Promise<R>>;
-export declare class RateThrottler {
-    private readonly _frequency;
-    private readonly _availableSlots;
-    private readonly _waitingRequests;
-    constructor(_frequency: TimeFrequency);
-    get cooldown(): import("..").TimeDuration;
-    execute<T>(fn: TPromiseFactory<void, T>): Promise<T>;
-}
-export default RateThrottler;
-export declare function throttle<TParams extends unknown[], R>(fn: (...params: TParams) => TPromisable<R>, frequence: TimeFrequency): (...params: TParams) => Promise<R>;

package/dist/async/Semaphore.d.ts

@@ -1,17 +0,0 @@
-import { TAsyncProducer, TProducer, TimeDuration } from "..";
-export declare class Semaphore {
-    private _availableSlots;
-    private readonly _queuedRequests;
-    private _inProgress;
-    /** Creates a new Semaphore with a single slot. */
-    constructor();
-    /** Creates a new Semaphore with the specified amounts of slots. */
-    constructor(availableSlots: number);
-    private _awaitSlot;
-    private _releaseSlot;
-    execute<T>(fn: TAsyncProducer<T> | TProducer<T>, cooldown?: TimeDuration): Promise<T>;
-    get availableSlots(): number;
-    get queueSize(): number;
-    get inProgressSize(): number;
-}
-export default Semaphore;

package/dist/async/_index.d.ts

@@ -1,3 +0,0 @@
-export * from './Deferred.ts';
-export * from './RateThrottler.ts';
-export * from './Semaphore.ts';

package/dist/index.d.ts

@@ -1,8 +0,0 @@
-export * from './async/_index.js';
-export * from './lazy/_index.js';
-export * from './Logger.js';
-export * from './Optional.js';
-export * from './sorting/_index.js';
-export * from './time/_index.js';
-export * from './upgrade/_index.js';
-export * from './utils/_index.js';

package/dist/lazy/Lazy.d.ts

@@ -1,22 +0,0 @@
-/**
- * Class that stores a value that is computationally/memory intensive to initialize.
- * The initialization of the value is done once and only if required (lazy initialization).
- * @author gtomberli
- */
-export declare class Lazy<T> {
-    private _value;
-    private _initialized;
-    private _generator;
-    private constructor();
-    get value(): T | undefined;
-    getOrCreate(): T;
-    getOrThrow(errorMessage?: "Value not initialized"): T;
-    or(t: T): T;
-    isPresent(): boolean;
-    isEmpty(): boolean;
-    ifPresent(fn: (t: T) => void): void;
-    ifEmpty(fn: () => void): void;
-    apply(fnPresent: (t: T) => void, fnEmpty: () => void): void;
-    static of<T>(generator: () => T): Lazy<T>;
-}
-export default Lazy;

package/dist/lazy/LazyAsync.d.ts

@@ -1,24 +0,0 @@
-export declare class LazyAsync<T> {
-    private _promise;
-    private _pending;
-    private _resolvedValue;
-    private _error;
-    private _generator;
-    private constructor();
-    getOrCreate(): Promise<T>;
-    isPresent(): boolean;
-    isEmpty(): boolean;
-    isPending(): boolean;
-    isReady(): boolean;
-    isResolved(): boolean;
-    isError(): boolean;
-    ifPresent(fn: (t: Promise<T>) => void): void;
-    ifEmpty(fn: () => void): void;
-    ifPending(fn: (t: Promise<T>) => void): void;
-    ifReady(fn: (t: Promise<T>) => void): void;
-    ifResolved(fn: (t: T) => void): void;
-    ifError(fn: (err: Error) => void): void;
-    getOrThrow(errorMessage?: "Value not initialized"): Promise<T> | never;
-    static of<T>(generator: () => Promise<T>): LazyAsync<T>;
-}
-export default LazyAsync;

package/dist/lazy/LazyDictionary.d.ts

@@ -1,9 +0,0 @@
-import type { TFunction } from "../utils/_index.ts";
-export declare class LazyDictionary<K extends string | number | symbol, T> {
-    private readonly _generator;
-    private readonly _dictionary;
-    private constructor();
-    static of<K extends string | number | symbol, T>(generator: TFunction<K, T>): LazyDictionary<K, T>;
-    getOrCreate(key: K): T;
-    getOrThrow(key: K, errorMessage?: "Value not initialized"): T;
-}

package/dist/lazy/_index.d.ts

@@ -1,3 +0,0 @@
-export * from './Lazy.js';
-export * from './LazyAsync.js';
-export * from './LazyDictionary.js';

package/dist/sorting/ComparisonChain.d.ts

@@ -1,57 +0,0 @@
-import { TFunction, TKeysOfType, TReadableArray } from "../utils/_index.js";
-import { TComparisonDirection, TComparisonFunction, TComparisonResult } from "./types.js";
-type TCompareValueOptions = {
-    nullsFirst: boolean;
-    direction: TComparisonDirection;
-};
-type TLooseCompareValueOptions = Partial<TCompareValueOptions> | TComparisonDirection;
-declare function compareStrings(options?: TLooseCompareValueOptions & {
-    ignoreCase?: boolean;
-}): TComparisonFunction<string>;
-declare function compareBooleans(options: Partial<TCompareValueOptions> & {
-    truesFirst: boolean;
-}): TComparisonFunction<boolean>;
-/**
- * Creates a ComparisonChain V1.
- * Usage: ComparisonChain.createWith<number>( c => c.compareUsingNumbers() ).sort( [ 100, 1, 10, 5 ] );
- * @deprecated[2023-10-22]: Use createSorterFor instead.
- **/
-export declare class ComparisonChain<T> {
-    private readonly _fns;
-    private readonly _reversed;
-    private constructor();
-    compare: (a: T, b: T) => TComparisonResult;
-    sort: <A extends TReadableArray<T>>(arr: A) => A extends Array<T> ? Array<T> : ReadonlyArray<T>;
-    then(getFn: (compare: TChain<T>) => TComparisonFunction<T>): ComparisonChain<T>;
-    thenBy(cmp: ComparisonChain<T> | TComparisonFunction<T>): ComparisonChain<T>;
-    thenChain<R>(transform: TFunction<T, R>, getFn: (compare: TChain<R>) => TComparisonFunction<R>): ComparisonChain<T>;
-    thenChainBy<R>(transform: TFunction<T, R>, cmp: ComparisonChain<R> | TComparisonFunction<R>): ComparisonChain<T>;
-    reversed(): ComparisonChain<T>;
-    private doCompare;
-    static create<T>(): {
-        using: (getFn: (chainable: TChain<T>) => TComparisonFunction<T>) => ComparisonChain<T>;
-        usingTransformation: <R>(transform: TFunction<T, R>, getFn: (chainable: TChain<R>) => TComparisonFunction<R>) => ComparisonChain<T>;
-    };
-    static createWith<T>(getFn: (chainable: TChain<T>) => TComparisonFunction<T>): ComparisonChain<T>;
-    static createWithTransformation<T, R>(transform: TFunction<T, R>, getFn: (chainable: TChain<R>) => TComparisonFunction<R>): ComparisonChain<T>;
-}
-export default ComparisonChain;
-declare function createCompare<T>(): {
-    compareUsingGetter: {
-        (getter: TFunction<T, string>, options?: TLooseCompareValueOptions): TComparisonFunction<T>;
-        (getter: TFunction<T, number>, options?: TLooseCompareValueOptions): TComparisonFunction<T>;
-        (getter: TFunction<T, Date>, options?: TLooseCompareValueOptions): TComparisonFunction<T>;
-    };
-    compareUsingField: (field: keyof T & TKeysOfType<T, string | number | Date>, options?: TLooseCompareValueOptions) => TComparisonFunction<T>;
-    compareUsingStrings: typeof compareStrings;
-    compareUsingStringsIgnoringCase: (options?: TLooseCompareValueOptions) => TComparisonFunction<string>;
-    compareUsingBooleans: typeof compareBooleans;
-    compareUsingNumbers: (options?: TLooseCompareValueOptions) => TComparisonFunction<number>;
-    compareUsingDates: (options?: TLooseCompareValueOptions) => TComparisonFunction<Date>;
-    compareUsingFunction: (fn: TComparisonFunction<T>) => TComparisonFunction<T>;
-    placeFirst: (arr: Array<T>) => TComparisonFunction<T>;
-    placeFirstInOrder: (arr: Array<T>) => TComparisonFunction<T>;
-    placeLast: (arr: Array<T>) => TComparisonFunction<T>;
-    placeLastInOrder: (arr: Array<T>) => TComparisonFunction<T>;
-};
-type TChain<T> = ReturnType<typeof createCompare<T>>;

package/dist/sorting/Sorter.d.ts

@@ -1,121 +0,0 @@
-import type TimeDuration from "../time/TimeDuration.js";
-import type TimeInstant from "../time/TimeInstant.js";
-import { TConditionalParameterOptions, TFunction, TKeysOfType, TPositiveNumber, TReadableArray } from "../utils/_index.js";
-import { TComparisonFunction } from "./types.js";
-type TComparable<T> = {
-    compare: TComparisonFunction<T>;
-};
-export type TSorter<T> = {
-    get then(): TSorterStep<T, TSorter<T>>;
-    reversed: () => TSorter<T>;
-    compare: TComparisonFunction<T>;
-    sort: (arr: TReadableArray<T>) => Array<T>;
-    top: (arr: TReadableArray<T>, n: TPositiveNumber) => Array<T>;
-    bottom: (arr: TReadableArray<T>, n: TPositiveNumber) => Array<T>;
-    first: (arr: TReadableArray<T>) => T | null;
-    last: (arr: TReadableArray<T>) => T | null;
-};
-type TSorterStepForRecords<T, Ret> = {
-    usingStrings: (field: TKeysOfType<T, string>) => TSorterStepUsing<string, Ret>;
-    usingNumbers: (field: TKeysOfType<T, number>) => TSorterStepUsing<number, Ret>;
-    usingBooleans: (field: TKeysOfType<T, boolean>) => TSorterStepUsing<boolean, Ret>;
-    usingDates: (field: TKeysOfType<T, Date>) => TSorterStepUsing<Date, Ret>;
-    usingTimeInstant: (field: TKeysOfType<T, TimeInstant>) => TSorterStepUsing<TimeInstant, Ret>;
-    usingTimeDuration: (field: TKeysOfType<T, TimeDuration>) => TSorterStepUsing<TimeDuration, Ret>;
-};
-type TSorterStepForNumbers<_T, Ret> = {
-    inAscendingOrder(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    inDescendingOrder(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-};
-type TSorterStepForStrings<_T, Ret> = {
-    /** @deprecated: Use inLexographicalOrder instead */ inLexographicalOrder(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    /** @deprecated: Use inLexographicalOrderIgnoringCase instead */ inLexographicalOrderIgnoringCase(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    /** @deprecated: Use inReverseLexographicalOrder instead */ inReverseLexographicalOrder(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    /** @deprecated: Use inReverseLexographicalOrderIgnoringCase instead */ inReverseLexographicalOrderIgnoringCase(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    inLexicographicalOrder(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    inLexicographicalOrderIgnoringCase(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    inReverseLexicographicalOrder(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    inReverseLexicographicalOrderIgnoringCase(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-};
-type TSorterStepForBooleans<_T, Ret> = {
-    truesFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    falsesFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-};
-type TSorterStepForDates<_T, Ret> = {
-    oldestDateFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    newestDateFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-};
-type TSorterStepForTimeInstant<_T, Ret> = {
-    oldestFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    newestFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-};
-type TSorterStepForTimeDuration<_T, Ret> = {
-    longestFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-    shortestFirst(opts?: {
-        nullsFirst?: boolean;
-    }): Ret;
-};
-type TSorterStepForChainables<T, Ret> = {
-    chain: (chain: TComparable<T>) => Ret;
-    chainFunction: (fn: TComparisonFunction<T>) => Ret;
-};
-type TSorterStepForUsing<T, Ret> = {
-    using: <X>(transform: TFunction<T, X>) => TSorterStepUsing<X, Ret>;
-};
-type TSorterStepForPrioritizable<T extends string | number, Ret> = {
-    prioritizing(arr: T[], options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
-    deprioritizing(arr: Array<T>, options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
-    prioritizingWithEqualWeight(arr: T[], options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
-    deprioritizingWithEqualWeight(arr: Array<T>, options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions>): Ret;
-};
-type TSorterStepUsing<T, Ret> = {} & (T extends Record<string | number | symbol, unknown> ? TSorterStepForRecords<T, Ret> : {}) & (T extends number ? TSorterStepForNumbers<T, Ret> : {}) & (T extends string ? TSorterStepForStrings<T, Ret> : {}) & (T extends boolean ? TSorterStepForBooleans<T, Ret> : {}) & (T extends Date ? TSorterStepForDates<T, Ret> : {}) & (T extends TimeInstant ? TSorterStepForTimeInstant<T, Ret> : {}) & (T extends TimeDuration ? TSorterStepForTimeDuration<T, Ret> : {}) & (T extends string ? TSorterStepForPrioritizable<string, Ret> : {}) & (T extends number ? TSorterStepForPrioritizable<number, Ret> : {});
-type TSorterStep<T, Ret> = TSorterStepUsing<T, Ret> & TSorterStepForChainables<T, Ret> & TSorterStepForUsing<T, Ret>;
-type TSorterStarter<T> = TSorterStepUsing<T, TSorter<T>> & TSorterStepForUsing<T, TSorter<T>> & {
-    usingFunction: (fn: TComparisonFunction<T>) => TSorter<T>;
-};
-export type TSorterBuilder<T> = (builder: TSorterStarter<T>) => TSorter<T>;
-type TPrioritizeOptions = {};
-declare const defaultPrioritizeOptions: {};
-export declare const Sorter: {
-    createFor: <T>(_template?: T) => TSorterStarter<T>;
-    sort: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T[];
-    top: <T>(arr: TReadableArray<T>, n: TPositiveNumber, builder: TSorterBuilder<T>) => T[];
-    bottom: <T>(arr: TReadableArray<T>, n: TPositiveNumber, builder: TSorterBuilder<T>) => T[];
-    first: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T | null;
-    last: <T>(arr: TReadableArray<T>, builder: TSorterBuilder<T>) => T | null;
-};
-export default Sorter;

package/dist/sorting/_index.d.ts

@@ -1,2 +0,0 @@
-export * from './Sorter.js';
-export * from './types.js';

package/dist/sorting/types.d.ts

@@ -1,5 +0,0 @@
-import { TBiFunction } from "../utils/functions.js";
-export type TComparisonResult = -1 | 0 | 1;
-export type TStrictComparisonResult = -1 | 1;
-export type TComparisonFunction<T> = TBiFunction<T, T, TComparisonResult>;
-export type TComparisonDirection = 'ASC' | 'DESC';

package/dist/time/RandomTimeDuration.d.ts

@@ -1,9 +0,0 @@
-import TimeDuration from "./TimeDuration.js";
-export default class RandomTimeDuration {
-    private constructor();
-    static ms: (a: number, b: number) => TimeDuration;
-    static seconds: (a: number, b: number) => TimeDuration;
-    static minutes: (a: number, b: number) => TimeDuration;
-    static hours: (a: number, b: number) => TimeDuration;
-    static days: (a: number, b: number) => TimeDuration;
-}

package/dist/time/TimeBase.d.ts

@@ -1,49 +0,0 @@
-import { TimeUnit } from "./TimeUnit";
-export type TTimeInUnits = {
-    milliseconds: number;
-    seconds: number;
-    minutes: number;
-    hours: number;
-    days: number;
-};
-export default abstract class TimeBase<T> {
-    private readonly _ms;
-    protected constructor(value: number, unit: TimeUnit);
-    protected abstract create(value: number, unit: TimeUnit): T;
-    /**
-     * Total number of milliseconds, rounded down.
-     */
-    get ms(): number;
-    /**
-     * Total number of seconds, rounded down.
-     */
-    get seconds(): number;
-    /**
-     * Total number of minutes, rounded down.
-     */
-    get minutes(): number;
-    /**
-     * Total number of hours, rounded down.
-     */
-    get hours(): number;
-    /**
-     * Total number of days, rounded down.
-     */
-    get days(): number;
-    addMs(milliseconds: number): T;
-    addSeconds(seconds: number): T;
-    addMinutes(minutes: number): T;
-    addHours(hours: number): T;
-    addDays(days: number): T;
-    removeDays(days: number): T;
-    addUnits(n: number, unit: TimeUnit): T;
-    removeMs(milliseconds: number): T;
-    removeSeconds(seconds: number): T;
-    removeMinutes(minutes: number): T;
-    removeHours(hours: number): T;
-    removeUnits(n: number, unit: TimeUnit): T;
-    getUnit(unit: TimeUnit): number;
-    protected toUnits(): TTimeInUnits;
-    protected static unitsToMs(units: Partial<TTimeInUnits>): number;
-    toJSON(): number;
-}