@zelgadis87/utils-core 5.2.12 → 5.3.0

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;
-}

package/dist/time/TimeDuration.d.ts

@@ -1,71 +0,0 @@
-import { ICancelable, ICancelablePromise } from "../async/Deferred.js";
-import { TComparisonResult } from "../sorting/_index.js";
-import { TIntervalHandle, TTimeoutHandle } from "../utils/_index.js";
-import TimeBase, { type TTimeInUnits } from "./TimeBase";
-import TimeInstant from "./TimeInstant";
-import { TimeUnit } from "./TimeUnit";
-export declare class TimeDuration extends TimeBase<TimeDuration> {
-    protected constructor(value: number, unit: TimeUnit);
-    protected create(value: number, unit: TimeUnit): TimeDuration;
-    addDuration(duration: TimeDuration): TimeDuration;
-    removeDuration(duration: TimeDuration): TimeDuration;
-    removeUnits(n: number, unit: TimeUnit): TimeDuration;
-    multiplyBy(times: number): TimeDuration;
-    divideBy(times: number): TimeDuration;
-    /**
-        * Returns the current duration in a human readable format, prioritizing the most significant unit of time and excluding the rest.
-        * @todo[2023-06] Should allow more customization options
-        * @todo[2023-06] By default should show the secondary unit only when actually needed (eg, 1h 20m & 3h, instead of 1h 20m & 3h 28m)
-        * @todo[2023-06] Should not allow negative durations, as this is a duration and not an instant.
-        * @returns the duration, with only the most significant units displayed as a human readable string, eg: 1d 20h, 10m 30s.
-    */
-    get formatted(): string;
-    interval(cb: () => unknown): TIntervalHandle;
-    timeout(cb: () => unknown): TTimeoutHandle;
-    cancelablePromise(): ICancelablePromise<void>;
-    promise(): Promise<void>;
-    delay(cb: () => unknown): void;
-    cancelableDelay(cb: () => unknown): ICancelable;
-    debounce<T>(fn: (t: T) => void): (t: T) => void;
-    toDigitalClock(): string;
-    get asSeconds(): string;
-    fromNow(): TimeInstant;
-    differenceFrom(other: TimeDuration): TimeDuration;
-    isGreaterThan(other: TimeDuration): boolean;
-    isLessThan(other: TimeDuration): boolean;
-    compareTo(other: TimeDuration): TComparisonResult;
-    atLeast(other: TimeDuration): TimeDuration;
-    atMost(other: TimeDuration): TimeDuration;
-    isEmpty(): boolean;
-    isNotEmpty(): boolean;
-    toUnits(): TTimeInUnits;
-    /**
-        * This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
-        */
-    protected get _duration(): string;
-    toString(): string;
-    static parseHumanTime(humanTime: string): TimeDuration;
-    static compare(a: TimeDuration, b: TimeDuration): TComparisonResult;
-    static ms: (value: number) => TimeDuration;
-    static seconds: (value: number) => TimeDuration;
-    static minutes: (value: number) => TimeDuration;
-    static hours: (value: number) => TimeDuration;
-    static days: (value: number) => TimeDuration;
-    static shamefulUnref: (ms: TAllowedTimeDuration) => number;
-    static shamefulRef: (ms: TAllowedTimeDuration) => TimeDuration;
-    static unref: (ms: TValidTimeDuration) => TPredefinedTimeDuration;
-    static ref: (ms: TValidTimeDuration) => TimeDuration;
-    static fromMs(ms: number): TimeDuration;
-    static distanceFromNow(instant: TimeInstant): TimeDuration;
-    static distance(instant1: TimeInstant, instant2: TimeInstant): TimeDuration;
-    static greatest(duration1: TimeDuration, duration2: TimeDuration): TimeDuration;
-    static lowest(duration1: TimeDuration, duration2: TimeDuration): TimeDuration;
-    static ZERO: TimeDuration;
-    static fromJSON(ms: number): TimeDuration;
-    static fromUnits(parameters: Partial<TTimeInUnits>): TimeDuration;
-}
-export type TPredefinedTimeDuration = 0 | 50 | 100 | 150 | 200 | 250 | 300 | 500 | 1000 | 1500 | 2000 | 2500 | 5000;
-export type TValidTimeDuration = TimeDuration | TPredefinedTimeDuration;
-type TAllowedTimeDuration = TValidTimeDuration | number;
-export declare function isAllowedTimeDuration(t: unknown): t is TAllowedTimeDuration;
-export default TimeDuration;

package/dist/time/TimeFrequency.d.ts

@@ -1,10 +0,0 @@
-import { TPositiveNumber } from "../utils/_index";
-import TimeDuration from "./TimeDuration";
-export default class TimeFrequency {
-    readonly times: TPositiveNumber;
-    readonly period: TimeDuration;
-    constructor(times: TPositiveNumber, period: TimeDuration);
-    get frequency(): TimeDuration;
-    static onceEvery(period: TimeDuration): TimeFrequency;
-    static twiceEvery(period: TimeDuration): TimeFrequency;
-}

package/dist/time/TimeInstant.d.ts

@@ -1,174 +0,0 @@
-import { ICancelable, ICancelablePromise } from "../async/Deferred.js";
-import { TComparisonResult } from "../sorting/_index.js";
-import TimeBase from "./TimeBase";
-import TimeDuration from "./TimeDuration";
-import { TTimeInstantBuilder, TTimeInstantCreationParameters, type TTimeInstantParameters } from "./TimeInstantBuilder.js";
-import { TimeUnit } from "./TimeUnit";
-import { TIso8601DateUtcString, TWeekNumber } from "./types";
-export declare class TimeInstant extends TimeBase<TimeInstant> {
-    protected constructor(number: number, unit: TimeUnit);
-    protected create(value: number, unit: TimeUnit): TimeInstant;
-    addDuration(duration: TimeDuration): TimeInstant;
-    removeDuration(duration: TimeDuration): TimeInstant;
-    distanceFrom(instant: TimeInstant): TimeDuration;
-    distanceFromNow(): TimeDuration;
-    distanceFromUnixTimestamp(timestamp: number): TimeDuration;
-    timeLeftFrom(instant: TimeInstant): TimeDuration;
-    timeLeftFromNow(): TimeDuration;
-    distanceFromStartOfDay(): TimeDuration;
-    atStartOfDay(): TimeInstant;
-    distanceFromEndOfDay(): TimeDuration;
-    atEndOfDay(): TimeInstant;
-    promise(): Promise<void>;
-    cancelablePromise(): ICancelablePromise<void>;
-    delay(cb: () => unknown): void;
-    cancelableDelay(cb: () => unknown): ICancelable;
-    ensureInTheFuture(): void;
-    ensureInThePast(): void;
-    isToday(): boolean;
-    /**
-     * Formats this instant using the given pattern. The pattern can contain the following tokens:
-     *
-     * Note: Implementation inspired by the small-date library (https://github.com/robinweser/small-date).
-     *
-     * | Token | Description                     | Example                       |
-     * |:------|:--------------------------------|:------------------------------|
-     * | D     | Weekday, 1 letter               | W                             |
-     * | DD    | Weekday, 3 letters              | Wed                           |
-     * | DDD   | Weekday, long                   | Wednesday                     |
-     * | d     | Day of the month, no padding    | 3                             |
-     * | dd    | Day of the month, padded to 2   | 03                            |
-     * | M     | Month, numeric                  | 3                             |
-     * | MM    | Month, 2 digits                 | 03                            |
-     * | MMM   | Month, 3 letters                | Mar                           |
-     * | MMMM  | Month, long                     | March                         |
-     * | y     | Year, numeric                   | 2021                          |
-     * | yy    | Year, 2 digits                  | 21                            |
-     * | yyyy  | Year, numeric                   | 2021                          |
-     * | h     | Hours, no padding               | 6                             |
-     * | hh    | Hours, padded to 2              | 06                            |
-     * | H     | Hours in 24-format, no padding  | 18                            |
-     * | HH    | Hours in 24-format, padded to 2 | 18                            |
-     * | m     | Minutes, no padding             | 7                             |
-     * | m     | Minutes, padded to 2            | 07                            |
-     * | s     | Seconds, no padding             | 8                             |
-     * | ss    | Seconds, padded to 2            | 08                            |
-     * | S     | Milliseconds, no padding        | 9                             |
-     * | SS    | Milliseconds, padded to 2       | 09                            |
-     * | SSS   | Milliseconds, padded to 3       | 009                           |
-     * | G     | Era, narrow                     | A                             |
-     * | GG    | Era, short                      | AD                            |
-     * | GGG   | Era, long                       | Anno Domino                   |
-     * | Z     | Time zone, short                | GMT+1                         |
-     * | ZZ    | Time short, long	C              | entral European Standard Time |
-     * | P     | Period of the day, narrow       | in the morning                |
-     * | PP    | Period of the day, short        | in the morning                |
-     * | PPP   | Period of the day, long         | in the morning                |
-     * | a     | Meridiem                        | pm                            |
-     * @param pattern The pattern to use. Refer to the token table above for details.
-     * @param config An optional locale and timeZone definition to use during the format.
-     * @returns a string, formatted using the given pattern, at the given timeZone with the given locale.
-     */
-    format(pattern: string, config?: {
-        locale?: string;
-        timeZone?: string;
-    }): string;
-    /**
-     * Parses a date string using the given pattern and creates a TimeInstant.
-     * This method is the inverse of format() - parsing a formatted string should recreate the original instant.
-     *
-     * For partial patterns (e.g., time-only or date-only), the missing components are taken from the base instant.
-     * For example, parsing "14:30" with base set to yesterday at midnight will result in yesterday at 14:30.
-     *
-     * Note: Currently performs basic validation (e.g., month 1-12, day 1-31) but does not validate
-     * calendar-specific constraints (e.g., February 30th, April 31st). Invalid dates may be
-     * normalized by the underlying Date constructor.
-     *
-     * @param dateString The date string to parse
-     * @param pattern The pattern used to parse the string (same tokens as format())
-     * @param base The base TimeInstant to use for partial patterns (defaults to now)
-     * @param config An optional locale and timeZone definition to use during parsing
-     * @returns A TimeInstant parsed from the string
-     * @throws Error if the string doesn't match the pattern or contains invalid basic values
-     * @todo Add calendar-aware validation to reject dates like February 30th, April 31st
-     */
-    static fromString(dateString: string, pattern: string, base?: TimeInstant, config?: {
-        locale?: string;
-        timeZone?: string;
-    }): TimeInstant;
-    static parse(dateString: string, pattern: string, config?: {
-        locale?: string;
-        timeZone?: string;
-    }): Partial<TTimeInstantParameters>;
-    /**
- * @returns this instant, in ISO 8601 format (eg, 2024-11-01T15:49:22.024Z). The format is meant to always be realiable.
- */
-    asIso8601(): TIso8601DateUtcString;
-    /**
-     * @returns this instant, in a human readable format, containing both the date and the time. The format COULD change in the future, do NOT use this method for consistent outputs.
-     */
-    asHumanTimestamp(): string;
-    toUnixTimestamp(): number;
-    toDate(): Date;
-    toParameters(): TTimeInstantParameters;
-    /**
-     * @returns true if the instant is in the past, false otherwise
-     */
-    isInThePast(): boolean;
-    /**
-     * @returns true if the instant is in the future, false otherwise
-     */
-    isInTheFuture(): boolean;
-    isAfter(other: TimeInstant): boolean;
-    isBefore(other: TimeInstant): boolean;
-    compareTo(other: TimeInstant): TComparisonResult;
-    atTime(parameters: Partial<TTimeInstantCreationParameters & {
-        year: never;
-        month: never;
-        date: never;
-    }>): TimeInstant;
-    atDate(parameters: Partial<TTimeInstantCreationParameters & {
-        hours: never;
-        minutes: never;
-        seconds: never;
-        milliseconds: never;
-    }>): TimeInstant;
-    at(parameters: Partial<TTimeInstantCreationParameters>): TimeInstant;
-    isBetween(start: TimeInstant, end: TimeInstant): boolean;
-    static fromDate(date: Date): TimeInstant;
-    static fromUnixTimestamp(unixTimestamp: number): TimeInstant;
-    static fromUnixSeconds(unixSeconds: number): TimeInstant;
-    static fromParameters(parameters: Partial<TTimeInstantCreationParameters>, referenceDate?: Date | TimeInstant): TimeInstant;
-    static highest(instant1: TimeInstant, instant2: TimeInstant): TimeInstant;
-    static lowest(instant1: TimeInstant, instant2: TimeInstant): TimeInstant;
-    static builder(): TTimeInstantBuilder;
-    static fromIso8601(str: string): TimeInstant;
-    /**
-     * @deprecated [2025.10.19]: Use fromIso8601 instead.
-     */
-    static tryFromIso8601: typeof TimeInstant.fromIso8601;
-    static now(): TimeInstant;
-    static compare(a: TimeInstant, b: TimeInstant): TComparisonResult;
-    roundedToStartOf(unit: TimeUnit): TimeInstant;
-    roundedToEndOf(unit: TimeUnit): TimeInstant;
-    roundedToNext(unit: TimeUnit, factor?: number): TimeInstant;
-    roundedToPrevious(unit: TimeUnit, factor?: number): TimeInstant;
-    roundedTo(unit: TimeUnit, factor?: number): TimeInstant;
-    /**
-     * Returns the week number represented by this instant, according to the ISO 8601 standard.
-     * Please note that the instant and the week number could be of two different years, eg the friday 1st january is actually part of week 52 of the previous year.
-     */
-    get weekNumber(): {
-        weekNumber: TWeekNumber;
-        year: number;
-    };
-    /**
-     * This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
-     */
-    protected get _time(): string;
-    toString(): string;
-    static ZERO: TimeInstant;
-    static fromJSON(ms: number): TimeInstant;
-}
-export declare function isTimeInstant(x: unknown): x is TimeInstant;
-export default TimeInstant;

package/dist/time/TimeInstantBuilder.d.ts

@@ -1,72 +0,0 @@
-import { TimeInstant } from "./TimeInstant.js";
-import { TDayOfMonth, THourOfDay, TMillisecondOfSecond, TMinuteOfHour, TMonth, TSecondOfMinute, TUpToTwoDigits, type TMonthName, type TYear } from "./types.js";
-type TRelativeSignum = '+' | '-';
-type TRelativeNumber = `${TRelativeSignum}${TUpToTwoDigits}`;
-export type TTimeInstantParameters = {
-    year: TYear;
-    month: TMonth;
-    date: TDayOfMonth;
-    hours: THourOfDay;
-    minutes: TMinuteOfHour;
-    seconds: TSecondOfMinute;
-    milliseconds: TMillisecondOfSecond;
-};
-export type TTimeInstantCreationParameters = {
-    year: TTimeInstantParameters["year"] | {
-        absolute: TTimeInstantParameters["year"];
-    } | TRelativeNumber | {
-        relative: number;
-        relativeTo: 'now' | TimeInstant;
-    } | 'next' | 'last' | 'current' | undefined;
-    month: TTimeInstantParameters["month"] | {
-        absolute: TTimeInstantParameters["month"];
-    } | TMonthName | TRelativeNumber | {
-        relative: number;
-        relativeTo: 'now' | TimeInstant;
-    } | 'next' | 'last' | 'current' | undefined;
-    date: TTimeInstantParameters["date"] | {
-        absolute: TTimeInstantParameters["date"];
-    } | TRelativeNumber | {
-        relative: number;
-        relativeTo: 'now' | TimeInstant;
-    } | 'next' | 'last' | 'current' | undefined;
-    hours: TTimeInstantParameters["hours"] | {
-        absolute: TTimeInstantParameters["hours"];
-    } | TRelativeNumber | {
-        relative: number;
-        relativeTo: 'now' | TimeInstant;
-    } | 'next' | 'last' | 'current' | undefined;
-    minutes: TTimeInstantParameters["minutes"] | {
-        absolute: TTimeInstantParameters["minutes"];
-    } | TRelativeNumber | {
-        relative: number;
-        relativeTo: 'now' | TimeInstant;
-    } | 'next' | 'last' | 'current' | undefined;
-    seconds: TTimeInstantParameters["seconds"] | {
-        absolute: TTimeInstantParameters["seconds"];
-    } | TRelativeNumber | {
-        relative: number;
-        relativeTo: 'now' | TimeInstant;
-    } | 'next' | 'last' | 'current' | undefined;
-    milliseconds: TTimeInstantParameters["milliseconds"] | {
-        absolute: TTimeInstantParameters["milliseconds"];
-    } | TRelativeNumber | {
-        relative: number;
-        relativeTo: 'now' | TimeInstant;
-    } | 'next' | 'last' | 'current' | undefined;
-};
-export declare function createTimeInstantFromParameters(aParameters: Partial<TTimeInstantCreationParameters>, aReferenceDate?: TimeInstant | Date): TimeInstant;
-export declare function timeInstantBuilder(): {
-    year: (x: TTimeInstantCreationParameters["year"]) => /*elided*/ any;
-    month: (x: TTimeInstantCreationParameters["month"]) => /*elided*/ any;
-    date: (x: TTimeInstantCreationParameters["date"]) => /*elided*/ any;
-    hours: (x: TTimeInstantCreationParameters["hours"]) => /*elided*/ any;
-    minutes: (x: TTimeInstantCreationParameters["minutes"]) => /*elided*/ any;
-    seconds: (x: TTimeInstantCreationParameters["seconds"]) => /*elided*/ any;
-    milliseconds: (x: TTimeInstantCreationParameters["milliseconds"]) => /*elided*/ any;
-    values: (x: Partial<TTimeInstantCreationParameters>) => /*elided*/ any;
-    relativeTo: (x: TimeInstant | Date) => /*elided*/ any;
-    build: () => TimeInstant;
-};
-export type TTimeInstantBuilder = ReturnType<typeof timeInstantBuilder>;
-export {};

package/dist/time/TimeRange.d.ts

@@ -1,11 +0,0 @@
-import { TimeDuration } from "./_index.js";
-import TimeInstant from "./TimeInstant.js";
-export declare class TimeRange {
-    readonly start: TimeInstant;
-    readonly duration: TimeDuration;
-    readonly end: TimeInstant;
-    protected constructor(start: TimeInstant, duration: TimeDuration);
-    static fromInstants(a: TimeInstant, b: TimeInstant): TimeRange;
-    static fromInstantWithDuration(a: TimeInstant, d: TimeDuration): TimeRange;
-    static fromNowWithDuration(d: TimeDuration): TimeRange;
-}