chronos-date 1.0.0

package/dist/types-B2fgrJ86.d.mts

@@ -0,0 +1,2123 @@
+import { A as MILLISECOND_FORMATS, B as ZODIAC_PRESETS, C as DATE_PARTS, D as INTERNALS, E as HOUR_FORMATS, F as TIME_FORMATS, I as TIME_UNIT_VARIANTS, M as MONTHS, N as MONTH_FORMATS, O as LOCALE_CALENDARS, P as SECOND_FORMATS, R as WESTERN_ZODIAC_SIGNS, S as DATE_FORMATS, T as DAY_FORMATS, _ as TIME_ZONE_LABELS, b as BN_MONTH_TABLES, g as TIME_ZONE_IDS, h as TIME_ZONES_NATIVE, j as MINUTE_FORMATS, k as LOCALE_NUMBERING_SYSTEMS, m as TIME_ZONES, u as SEASON_PRESETS, v as BN_DAYS, w as DAYS, x as BN_SEASONS, y as BN_MONTHS, z as YEAR_FORMATS } from "./seasons-CioTH5Dm.mjs";
+
+//#region node_modules/.pnpm/nhb-toolbox@4.30.1/node_modules/nhb-toolbox/dist/dts/utils/types.d.ts
+/**
+ * * Broadens a literal union (typically `string` or `number`) to also accept any other value of the base type, without losing IntelliSense autocomplete for the provided literals.
+ *
+ * *This is especially useful in API design where you want to provide suggestions for common options but still allow flexibility for custom user-defined values.*
+ *
+ * @example
+ * // ✅ String literal usage
+ * type Variant = LooseLiteral<'primary' | 'secondary'>;
+ * const v1: Variant = 'primary';  // suggested
+ * const v2: Variant = 'custom';   // also valid
+ *
+ * // ✅ Number literal usage
+ * type StatusCode = LooseLiteral<200 | 404 | 500>;
+ * const s1: StatusCode = 200;     // suggested
+ * const s2: StatusCode = 999;     // also valid
+ *
+ * // ✅ Mixed literal
+ * type Mixed = LooseLiteral<'one' | 2>;
+ * const m1: Mixed = 'one';        // ✅
+ * const m2: Mixed = 2;            // ✅
+ * const m3: Mixed = 'anything';   // ✅
+ * const m4: Mixed = 123;          // ✅
+ *
+ * @note Technically, this uses intersection with primitive base types (`string & {}` or `number & {}`) to retain IntelliSense while avoiding type narrowing.
+ */
+type LooseLiteral<T extends string | number> = T | (T extends string ? string & {} : number & {});
+/** Internal helper type to build a tuple of length N. */
+type $TupleOf<T, N extends number, R extends unknown[] = []> = R['length'] extends N ? R : $TupleOf<T, N, [...R, T]>;
+/**
+ * * Creates a tuple type of a given length with elements of type T
+ *
+ * 📝 **Notes**:
+ * - This works recursively to build a tuple of exact length N.
+ *
+ * - N must be a literal number, not just number. You can’t pass a general number type because recursion can't compute unbounded lengths
+ * - You can use as const or mapped types when initializing values with this shape
+ *
+ * @example
+ * type FiveStrings = TupleOf<string, 5>; // [string, string, string, string, string]
+ * type EmptyTuple = TupleOf<boolean, 0>; // []
+ */
+type TupleOf<T, N extends number> = $TupleOf<T, N>;
+/** * Build a tuple of given length (helper for type-level arithmetic). */
+type $BuildTuple<L extends number, T extends unknown[] = []> = T['length'] extends L ? T : $BuildTuple<L, [...T, unknown]>;
+/** * Produce a union of numbers `From | From+1 | ... | To`. */
+type $Range<From extends number, To extends number, Arr extends unknown[] = $BuildTuple<From>, Result = never> = Arr['length'] extends To ? Result | To : $Range<From, To, [...Arr, unknown], Result | Arr['length']>;
+/**
+ * * Creates a tuple with length between `Min` and `Max` (inclusive).
+ *
+ * @example
+ * type Ranged = RangeTuple<string, 2, 4>;
+ * // Ranged -> [string, string] | [string, string, string] | [string, string, string, string]
+ */
+type RangeTuple<T, Min extends number, Max extends number> = $Range<Min, Max> extends infer N ? (N extends number ? TupleOf<T, N> : never) : never;
+/**
+ * * Cast one type to another while preserving compatibility.
+ *
+ * @remarks
+ * - Ensures that `A1` extends `A2`. If not, falls back to `A2`.
+ * - Useful for enforcing constraints on generics or parameters.
+ *
+ * @param A1 - Type to check.
+ * @param A2 - Type to cast to.
+ * @returns `A1` if it extends `A2`, otherwise `A2`.
+ *
+ * @example
+ * type T0 = Cast<'42', string>; // '42'
+ * type T1 = Cast<'42', number>; // number
+ * type T2 = Cast<42, number>;   // 42
+ */
+type Cast<A1, A2> = A1 extends A2 ? A1 : A2;
+/**
+ * * Remove the last element of a list (array).
+ *
+ * @remarks Produces a new tuple/list type with the last element removed.
+ *
+ * @example
+ * type T0 = Pop<[1, 2, 3]>;    // [1, 2]
+ * type T1 = Pop<[]>;           // []
+ * type T2 = Pop<['a']>;        // []
+ */
+type Pop<L extends List> = L extends readonly [...infer El, any] | readonly [...infer El, any?] ? El : L;
+type _Split<S extends string, D extends string, T extends string[] = []> = S extends `${infer BS}${D}${infer AS}` ? _Split<AS, D, [...T, BS]> : [...T, S];
+type $Split<S extends string, D extends string = ''> = D extends '' ? Pop<_Split<S, D>> : _Split<S, D>;
+/**
+ * ✂️ Split a string literal by a given delimiter into a list of strings.
+ *
+ * @remarks
+ * Produces a tuple of substrings by splitting `S` at each occurrence of `D`.
+ *
+ * @param S - String literal to split.
+ * @param D - Delimiter to split on (default: empty string, i.e., character split).
+ * @returns A list of string literals.
+ *
+ * @example
+ * type T0 = Split<'a,b,c', ','>; // ['a', 'b', 'c']
+ * type T1 = Split<'hello', ''>;  // ['h', 'e', 'l', 'l', 'o']
+ * type T2 = Split<'foo-bar', '-'>; // ['foo', 'bar']
+ */
+type Split<S extends string, D extends string = ''> = $Split<S, D> extends infer X ? Cast<X, string[]> : never;
+/**
+ * Recursively join the string S for each element in the tuple A.
+ * Returns an empty string for an empty tuple.
+ */
+type $JoinRepeat<S extends string, A extends unknown[]> = A extends [unknown, ...infer Rest] ? `${S}${$JoinRepeat<S, Rest>}` : '';
+/**
+ * * Repeat string `S`, `N` times.
+ *
+ * @example
+ * type L10 = Repeat<'l', 10>; // "llllllllll"
+ *
+ * type AB3 = Repeat<'a' | 'b', 3>; // "aab" | "aaa" | "aba" | "abb" | "bab" | "baa" | "bba" | "bbb"
+ *
+ * @remarks **Limitations:**
+ * - `N` must be a literal number.
+ * - If `S` is a union (e.g. 'a' | 'b'), the resulting union grows exponentially with `N`.
+ */
+type Repeat<S extends string, N extends number> = $JoinRepeat<S, $BuildTuple<N>>;
+//#endregion
+//#region node_modules/.pnpm/nhb-toolbox@4.30.1/node_modules/nhb-toolbox/dist/dts/number/constants.d.ts
+/** List of all supported BCP 47 locales */
+declare const LOCALE_CODES: readonly ["af-ZA", "am-ET", "ar-AE", "ar-BH", "ar-DZ", "ar-EG", "ar-IQ", "ar-JO", "ar-KW", "ar-LB", "ar-LY", "ar-MA", "ar-OM", "ar-QA", "ar-SA", "ar-SD", "ar-SY", "ar-TN", "ar-YE", "az-AZ", "be-BY", "bg-BG", "bn-BD", "bn-IN", "bs-BA", "ca-ES", "cs-CZ", "cy-GB", "da-DK", "de-AT", "de-CH", "de-DE", "el-GR", "en-AU", "en-CA", "en-GB", "en-IE", "en-IN", "en-NZ", "en-PH", "en-SG", "en-US", "en-ZA", "es-AR", "es-BO", "es-CL", "es-CO", "es-CR", "es-DO", "es-EC", "es-ES", "es-GT", "es-HN", "es-MX", "es-NI", "es-PA", "es-PE", "es-PR", "es-PY", "es-SV", "es-US", "es-UY", "es-VE", "et-EE", "eu-ES", "fa-IR", "fi-FI", "fil-PH", "fr-BE", "fr-CA", "fr-CH", "fr-FR", "ga-IE", "gl-ES", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "hy-AM", "id-ID", "is-IS", "it-CH", "it-IT", "ja-JP", "ka-GE", "kk-KZ", "km-KH", "kn-IN", "ko-KR", "ky-KG", "lt-LT", "lv-LV", "mk-MK", "ml-IN", "mn-MN", "mr-IN", "ms-MY", "mt-MT", "nb-NO", "ne-NP", "nl-BE", "nl-NL", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sq-AL", "sr-Latn", "sv-SE", "sw-KE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "uz-UZ", "vi-VN", "zh-CN", "zh-HK", "zh-TW"];
+/** Mapping of CurrencyCodes to `LocaleCodes` */
+declare const CURRENCY_LOCALES: Readonly<{
+  readonly AED: "ar-AE";
+  readonly AFN: "fa-IR";
+  readonly ALL: "sq-AL";
+  readonly AMD: "hy-AM";
+  readonly ANG: "nl-NL";
+  readonly AOA: "pt-AO";
+  readonly ARS: "es-AR";
+  readonly AUD: "en-AU";
+  readonly AWG: "nl-AW";
+  readonly AZN: "az-AZ";
+  readonly BAM: "bs-BA";
+  readonly BBD: "en-BB";
+  readonly BDT: "bn-BD";
+  readonly BGN: "bg-BG";
+  readonly BHD: "ar-BH";
+  readonly BIF: "fr-BI";
+  readonly BMD: "en-BM";
+  readonly BND: "ms-BN";
+  readonly BOB: "es-BO";
+  readonly BRL: "pt-BR";
+  readonly BSD: "en-BS";
+  readonly BTN: "dz-BT";
+  readonly BWP: "en-BW";
+  readonly BYN: "be-BY";
+  readonly BZD: "es-BZ";
+  readonly CAD: "fr-CA";
+  readonly CDF: "fr-CD";
+  readonly CHF: "fr-CH";
+  readonly CLP: "es-CL";
+  readonly CNY: "zh-CN";
+  readonly COP: "es-CO";
+  readonly CRC: "es-CR";
+  readonly CUP: "es-CU";
+  readonly CVE: "pt-CV";
+  readonly CZK: "cs-CZ";
+  readonly DJF: "fr-DJ";
+  readonly DKK: "da-DK";
+  readonly DOP: "es-DO";
+  readonly DZD: "ar-DZ";
+  readonly EGP: "ar-EG";
+  readonly ERN: "ti-ER";
+  readonly ETB: "am-ET";
+  readonly EUR: "de-DE";
+  readonly FJD: "en-FJ";
+  readonly FKP: "en-FK";
+  readonly FOK: "fo-FO";
+  readonly GBP: "en-GB";
+  readonly GEL: "ka-GE";
+  readonly GGP: "en-GG";
+  readonly GHS: "ak-GH";
+  readonly GIP: "en-GI";
+  readonly GMD: "en-GM";
+  readonly GNF: "fr-GN";
+  readonly GTQ: "es-GT";
+  readonly GYD: "en-GY";
+  readonly HKD: "zh-HK";
+  readonly HNL: "es-HN";
+  readonly HRK: "hr-HR";
+  readonly HTG: "ht-HT";
+  readonly HUF: "hu-HU";
+  readonly IDR: "id-ID";
+  readonly ILS: "he-IL";
+  readonly IMP: "en-IM";
+  readonly INR: "hi-IN";
+  readonly IQD: "ar-IQ";
+  readonly IRR: "fa-IR";
+  readonly ISK: "is-IS";
+  readonly JEP: "en-JE";
+  readonly JMD: "en-JM";
+  readonly JOD: "ar-JO";
+  readonly JPY: "ja-JP";
+  readonly KES: "sw-KE";
+  readonly KGS: "ky-KG";
+  readonly KHR: "km-KH";
+  readonly KID: "en-KI";
+  readonly KMF: "fr-KM";
+  readonly KRW: "ko-KR";
+  readonly KWD: "ar-KW";
+  readonly KYD: "en-KY";
+  readonly KZT: "kk-KZ";
+  readonly LAK: "lo-LA";
+  readonly LBP: "ar-LB";
+  readonly LKR: "si-LK";
+  readonly LRD: "en-LR";
+  readonly LSL: "st-LS";
+  readonly LYD: "ar-LY";
+  readonly MAD: "ar-MA";
+  readonly MDL: "ro-RO";
+  readonly MGA: "mg-MG";
+  readonly MKD: "mk-MK";
+  readonly MMK: "my-MM";
+  readonly MNT: "mn-MN";
+  readonly MOP: "pt-MO";
+  readonly MRU: "ar-MA";
+  readonly MUR: "en-MU";
+  readonly MVR: "dv-MV";
+  readonly MWK: "ny-MW";
+  readonly MXN: "es-MX";
+  readonly MYR: "ms-MY";
+  readonly MZN: "pt-MZ";
+  readonly NAD: "en-NA";
+  readonly NGN: "en-NG";
+  readonly NIO: "es-NI";
+  readonly NOK: "no-NO";
+  readonly NPR: "ne-NP";
+  readonly NZD: "en-NZ";
+  readonly OMR: "ar-OM";
+  readonly PAB: "es-PA";
+  readonly PEN: "es-PE";
+  readonly PGK: "en-PG";
+  readonly PHP: "fil-PH";
+  readonly PKR: "ur-PK";
+  readonly PLN: "pl-PL";
+  readonly PYG: "es-PY";
+  readonly QAR: "ar-QA";
+  readonly RON: "ro-RO";
+  readonly RSD: "sr-RS";
+  readonly RUB: "ru-RU";
+  readonly RWF: "rw-RW";
+  readonly SAR: "ar-SA";
+  readonly SBD: "en-SB";
+  readonly SCR: "en-SC";
+  readonly SDG: "ar-SD";
+  readonly SEK: "sv-SE";
+  readonly SGD: "en-SG";
+  readonly SHP: "en-SH";
+  readonly SLE: "en-SL";
+  readonly SOS: "so-SO";
+  readonly SRD: "nl-SR";
+  readonly SSP: "en-SS";
+  readonly STN: "st-ST";
+  readonly SYP: "ar-SY";
+  readonly SZL: "en-SZ";
+  readonly THB: "th-TH";
+  readonly TJS: "tg-TJ";
+  readonly TMT: "tk-TM";
+  readonly TND: "ar-TN";
+  readonly TOP: "to-TO";
+  readonly TRY: "tr-TR";
+  readonly TTD: "en-TT";
+  readonly TVD: "en-TV";
+  readonly TWD: "zh-TW";
+  readonly TZS: "sw-TZ";
+  readonly UAH: "uk-UA";
+  readonly UGX: "sw-UG";
+  readonly USD: "en-US";
+  readonly UYU: "es-UY";
+  readonly UZS: "uz-UZ";
+  readonly VES: "ve-VE";
+  readonly VND: "vi-VN";
+  readonly VUV: "en-VU";
+  readonly WST: "en-WS";
+  readonly YER: "ar-YE";
+  readonly ZAR: "en-ZA";
+  readonly ZMW: "en-ZM";
+  readonly ZWL: "en-ZW";
+}>;
+/** * Bangla digits from `০-৯` mapped against `0-9` */
+declare const BN_DIGITS: Readonly<{
+  readonly '\u09E6': 0;
+  readonly '\u09E7': 1;
+  readonly '\u09E8': 2;
+  readonly '\u09E9': 3;
+  readonly '\u09EA': 4;
+  readonly '\u09EB': 5;
+  readonly '\u09EC': 6;
+  readonly '\u09ED': 7;
+  readonly '\u09EE': 8;
+  readonly '\u09EF': 9;
+}>;
+//#endregion
+//#region node_modules/.pnpm/nhb-toolbox@4.30.1/node_modules/nhb-toolbox/dist/dts/number/types.d.ts
+/** Enumerate & Enumerate Internal: builds a union of all numbers from 0 to N - 1 */
+type $EnumerateInternal<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : $EnumerateInternal<N, [...Acc, Acc['length']]>;
+/**
+ * * Builds a union of numeric literals from `0` to `N - 1`.
+ *
+ * @remarks
+ * - This utility supports ranges up to 998 due to TypeScript recursion limits.
+ *
+ * @example
+ * type U = Enumerate<3>; // 0 | 1 | 2
+ */
+type Enumerate<N extends number> = $EnumerateInternal<N>;
+/** Helper: Add 1 to a number */
+type $AddOne<N extends number, Acc extends unknown[] = []> = Acc['length'] extends N ? [...Acc, unknown]['length'] : $AddOne<N, [...Acc, unknown]>;
+/**
+ *
+ * * Creates a union type of all numeric literals starting from `From` up to `To`.
+ *
+ * @example
+ * type R = NumberRange<2, 5>; // 2 | 3 | 4  5
+ * type N = NumberRange<0, 998>; // 0 | 1 | 2 | ... | 998
+ *
+ * @remarks
+ * - This utility supports ranges up to 998 due to TypeScript recursion limits.
+ * - `From` and `To` both are inclusive, — so `NumberRange<0, 998>` generates `0` to `998`.
+ * - Result is a union type, not a tuple or array.
+ *
+ * @generic From - A number from 0-998, start of the range.
+ * @generic To - A number from 1-998, end of the range.
+ * @returns A union of numeric literal types from `From` to `To - 1`.
+ */
+type NumberRange<From extends number, To extends number> = Exclude<Enumerate<$AddOne<To>>, Enumerate<From>>;
+/** - List of all supported BCP 47 locales */
+type LocaleCode = (typeof CURRENCY_LOCALES)[keyof typeof CURRENCY_LOCALES] | (typeof LOCALE_CODES)[number];
+/** Bangla digits from `০-৯` */
+type BanglaDigit = keyof typeof BN_DIGITS;
+/** Bangla digits from `১-৯` */
+type $BnOnes = Exclude<BanglaDigit, '০'>;
+//#endregion
+//#region node_modules/.pnpm/nhb-toolbox@4.30.1/node_modules/nhb-toolbox/dist/dts/types/index.d.ts
+/** Represents a value that may or may not be present. */
+type Maybe<T> = T | undefined;
+/** Union of `number` and numeric string */
+type Numeric = number | `${number}`;
+/**
+ * * A readonly array of elements of type `T`.
+ *
+ * @remarks
+ * - Shorthand for `ReadonlyArray<T>`. Used to represent immutable lists.
+ *
+ * @example
+ * type Numbers = List<number>;	// readonly number[]
+ * const arr: Numbers = [1, 2, 3];	// ✅ OK
+ * arr.push(4);                   	// ❌ Error (readonly)
+ */
+type List<T = any> = ReadonlyArray<T>;
+//#endregion
+//#region src/types/format-tokens.d.ts
+/** Year in either 4 or 2 digits format */
+type YearToken = (typeof YEAR_FORMATS)[number];
+/** Month in either 1 or 2 digits or 3 letters or full word format */
+type MonthToken = (typeof MONTH_FORMATS)[number];
+/** Day in either 2 letters or full word format */
+type DayToken = (typeof DAY_FORMATS)[number];
+/** Date in either 1 or 2 digits format */
+type DateToken = (typeof DATE_FORMATS)[number];
+/** Second in either 1 or 2 digits format */
+type HourToken = (typeof HOUR_FORMATS)[number];
+/** Second in either 1 or 2 digits format */
+type MinuteToken = (typeof MINUTE_FORMATS)[number];
+/** Second in either 1 or 2 digits format */
+type SecondToken = (typeof SECOND_FORMATS)[number];
+/** Millisecond in either 1 or 2 digits format */
+type MSToken = (typeof MILLISECOND_FORMATS)[number];
+/** Time formats in either capital or lowercase `am/pm` format */
+type TimeToken = (typeof TIME_FORMATS)[number];
+/** Standard date/time format tokens for `Chronos`. */
+type FormatToken = YearToken | MonthToken | DayToken | DateToken | HourToken | MinuteToken | SecondToken | MSToken | TimeToken | 'Z' | 'ZZ';
+/** Standard date formats. */
+type DateFormatToken = `${DateToken} ${Exclude<MonthToken, 'M' | 'MM'>}` | `${Exclude<MonthToken, 'M' | 'MM'>} ${DateToken}` | `${DayToken}, ${DateToken} ${Exclude<MonthToken, 'M' | 'MM'>}` | `${DayToken}, ${Exclude<MonthToken, 'M' | 'MM'>} ${DateToken}` | `${Exclude<MonthToken, 'M' | 'MM'>} ${DateToken}, ${YearToken}` | `${DateToken} ${Exclude<MonthToken, 'M' | 'MM'>}, ${YearToken}` | `${Exclude<MonthToken, 'M' | 'MM'>} ${DateToken} ${YearToken}` | `${DateToken} ${Exclude<MonthToken, 'M' | 'MM'>} ${YearToken}` | `${DayToken}, ${Exclude<MonthToken, 'M' | 'MM'>} ${DateToken}, ${YearToken}` | `${DayToken}, ${DateToken} ${Exclude<MonthToken, 'M' | 'MM'>}, ${YearToken}` | `${DayToken}, ${Exclude<MonthToken, 'M' | 'MM'>} ${DateToken} ${YearToken}` | `${DayToken}, ${DateToken} ${Exclude<MonthToken, 'M' | 'MM'>} ${YearToken}` | `${Exclude<DateToken, 'Do'>}.${Exclude<MonthToken, 'mmm' | 'mmmm'>}.${YearToken}` | `${YearToken}.${Exclude<MonthToken, 'mmm' | 'mmmm'>}.${Exclude<DateToken, 'Do'>}` | `${Exclude<DateToken, 'Do'>}/${Exclude<MonthToken, 'mmm' | 'mmmm'>}/${YearToken}` | `${Exclude<DateToken, 'Do'>}-${Exclude<MonthToken, 'mmm' | 'mmmm'>}-${YearToken}` | `${Exclude<MonthToken, 'mmm' | 'mmmm'>}/${Exclude<DateToken, 'Do'>}/${YearToken}` | `${Exclude<MonthToken, 'mmm' | 'mmmm'>}-${Exclude<DateToken, 'Do'>}-${YearToken}` | `${YearToken}-${Exclude<MonthToken, 'mmm' | 'mmmm'>}-${Exclude<DateToken, 'Do'>}` | `${YearToken}/${Exclude<MonthToken, 'mmm' | 'mmmm'>}/${Exclude<DateToken, 'Do'>}` | `${YearToken}-${Exclude<DateToken, 'Do'>}-${Exclude<MonthToken, 'mmm' | 'mmmm'>}` | `${YearToken}/${Exclude<DateToken, 'Do'>}/${Exclude<MonthToken, 'mmm' | 'mmmm'>}`;
+/** Standard Time Formats */
+type TimeFormatToken = `${Exclude<HourToken, 'h' | 'hh' | 'H'>}:${Exclude<MinuteToken, 'm'>}` | `${Exclude<HourToken, 'H' | 'HH' | 'h'>}:${Exclude<MinuteToken, 'm'>} ${TimeToken}` | `${Exclude<HourToken, 'h' | 'hh' | 'H'>}:${Exclude<MinuteToken, 'm'>}:${Exclude<SecondToken, 's'>}` | `${Exclude<HourToken, 'H' | 'HH' | 'h'>}:${Exclude<MinuteToken, 'm'>}:${Exclude<SecondToken, 's'>} ${TimeToken}` | `${Exclude<HourToken, 'h' | 'hh' | 'H'>}:${Exclude<MinuteToken, 'm'>}:${Exclude<SecondToken, 's'>}:${Exclude<MSToken, 'ms'>}` | `${Exclude<HourToken, 'H' | 'HH' | 'h'>}:${Exclude<MinuteToken, 'm'>}:${Exclude<SecondToken, 's'>}:${Exclude<MSToken, 'ms'>} ${TimeToken}`;
+type DateTimeISO = 'YYYY-MM-DDTHH:mm:ss.mssZZ';
+type TokenConnector = ' ' | ', ' | '; ' | ' - ';
+/** Format tokens for time only string */
+type TimeOnlyFormat = LooseLiteral<TimeFormatToken>;
+/** Pre-defined literal types for formatting date and time. Optionally can pass any string. */
+type StrictFormat = LooseLiteral<DateTimeISO | DateFormatToken | TimeFormatToken | `${DateFormatToken}${TokenConnector}${TimeFormatToken}`>;
+//#endregion
+//#region src/types/bangla-date.d.ts
+type $BnEn = 'bn' | 'en';
+type $BnOnesPadded = `০${$BnOnes}`;
+/** Bangla month from `১-১২` */
+type BanglaMonth = $BnOnes | $BnOnesPadded | '১০' | '১১' | '১২';
+/** Bangla date of month from `১-৩১` */
+type BanglaDate = $BnOnes | $BnOnesPadded | `১${BanglaDigit}` | `২${BanglaDigit}` | '৩০' | '৩১';
+type $BnYearPadded = Repeat<BanglaDigit, 4>;
+type $BnMonthPadded = $BnOnesPadded | '১০' | '১১' | '১২';
+type $BnDatePadded = $BnOnesPadded | `১${BanglaDigit}` | `২${BanglaDigit}` | '৩০' | '৩১';
+/** Bangla year from `০-৯৯৯৯` */
+type BanglaYear = BanglaDigit | `${$BnOnes}${BanglaDigit}` | `${$BnOnes}${BanglaDigit}${BanglaDigit}` | Repeat<BanglaDigit, 4>;
+/** Token for Bangla season format */
+type $SeasonToken = 'S' | 'SS';
+/** Standard format tokens for Bangla date with seasons */
+type DateWithSeasonToken = `${Exclude<MonthToken, 'M' | 'MM'>} ${DateToken}, ${YearToken} ${$SeasonToken}` | `${DateToken} ${Exclude<MonthToken, 'M' | 'MM'>}, ${YearToken} ${$SeasonToken}` | `${Exclude<MonthToken, 'M' | 'MM'>} ${DateToken} ${YearToken} ${$SeasonToken}` | `${DateToken} ${Exclude<MonthToken, 'M' | 'MM'>} ${YearToken} ${$SeasonToken}` | `${DayToken}, ${Exclude<MonthToken, 'M' | 'MM'>} ${DateToken}, ${YearToken}, ${$SeasonToken}` | `${DayToken}, ${DateToken} ${Exclude<MonthToken, 'M' | 'MM'>}, ${YearToken}, ${$SeasonToken}` | `${DayToken}, ${Exclude<MonthToken, 'M' | 'MM'>} ${DateToken} ${YearToken}, ${$SeasonToken}` | `${DayToken}, ${DateToken} ${Exclude<MonthToken, 'M' | 'MM'>} ${YearToken}, ${$SeasonToken}` | `${Exclude<DateToken, 'Do'>}/${Exclude<MonthToken, 'mmm' | 'mmmm'>}/${YearToken} (${$SeasonToken})` | `${Exclude<DateToken, 'Do'>}-${Exclude<MonthToken, 'mmm' | 'mmmm'>}-${YearToken} (${$SeasonToken})` | `${Exclude<MonthToken, 'mmm' | 'mmmm'>}/${Exclude<DateToken, 'Do'>}/${YearToken} (${$SeasonToken})` | `${Exclude<MonthToken, 'mmm' | 'mmmm'>}-${Exclude<DateToken, 'Do'>}-${YearToken} (${$SeasonToken})` | `${YearToken}-${Exclude<MonthToken, 'mmm' | 'mmmm'>}-${Exclude<DateToken, 'Do'>} (${$SeasonToken})` | `${YearToken}/${Exclude<MonthToken, 'mmm' | 'mmmm'>}/${Exclude<DateToken, 'Do'>} (${$SeasonToken})` | `${YearToken}-${Exclude<DateToken, 'Do'>}-${Exclude<MonthToken, 'mmm' | 'mmmm'>} (${$SeasonToken})` | `${YearToken}/${Exclude<DateToken, 'Do'>}/${Exclude<MonthToken, 'mmm' | 'mmmm'>} (${$SeasonToken})`;
+/** Standard format tokens for Bangla date along with any string */
+type BanglaDateFormat = LooseLiteral<DateFormatToken | DateWithSeasonToken>;
+/** Bangla name of the weekday either in Bangla or Latin */
+type BanglaDayName<Locale extends $BnEn = 'bn'> = (typeof BN_DAYS)[number][Locale];
+/** Bangla name of the month either in Bangla or Latin */
+type BanglaMonthName<Locale extends $BnEn = 'bn'> = (typeof BN_MONTHS)[number][Locale];
+/** Bangla name of the season either in Bangla or Latin */
+type BanglaSeasonName<Locale extends $BnEn = 'bn'> = (typeof BN_SEASONS)[number][Locale];
+/** Represents Bangla year either in Bangla digit or Latin from 1-12 */
+type $BanglaYear<Locale extends $BnEn = 'bn'> = Locale extends 'en' ? number : BanglaYear;
+/** Represents Bangla month either in Bangla digit or Latin from 0-9999 */
+type $BanglaMonth<Locale extends $BnEn = 'bn'> = Locale extends 'en' ? NumberRange<1, 12> : BanglaMonth;
+/** Represents Bangla date of the month either in Bangla digit or Latin from 1-31 */
+type $BanglaMonthDate<Locale extends $BnEn = 'bn'> = Locale extends 'en' ? NumberRange<1, 31> : BanglaDate;
+/** Represents a Bangla date object for `Chronos` plugin */
+type BanglaDateObject<Locale extends $BnEn = 'bn'> = {
+  /** Represents Bangla year either in Bangla digit or Latin from 1-12 */year: $BanglaYear<Locale>; /** Represents Bangla month either in Bangla digit or Latin from 1-12 */
+  month: $BanglaMonth<Locale>; /** Represents Bangla date of the month either in Bangla digit or Latin from 1-31 */
+  date: $BanglaMonthDate<Locale>; /** Bangla name of the weekday either in Bangla or Latin */
+  dayName: BanglaDayName<Locale>; /** Bangla name of the month either in Bangla or Latin */
+  monthName: BanglaMonthName<Locale>; /** Bangla name of the season either in Bangla or Latin */
+  seasonName: BanglaSeasonName<Locale>; /** Leap year status of the current year */
+  isLeapYear: boolean;
+};
+/** Variant of Bangla calendar system */
+type BnCalendarVariant = keyof typeof BN_MONTH_TABLES;
+/** Configuration object for Bangla Calendar system */
+interface BnCalendarConfig {
+  /** - Calendar variant to use. Defaults to `'revised-2019'`. */
+  variant?: BnCalendarVariant;
+}
+/** Bangla date options for `Chronos` plugin (`banglaPlugin`) */
+interface BanglaDateOptions<Locale extends $BnEn> extends BnCalendarConfig {
+  /** - Locale to use for output values. Defaults to `'bn'`. */
+  locale?: Locale | $BnEn;
+}
+//#endregion
+//#region src/utils/chronos-fn.d.ts
+/**
+ * * Use `chronos` with all static methods from the `Chronos` class.
+ *
+ * @description
+ * It serves as both a constructor for creating `Chronos` instances and a namespace for accessing all static methods from the `Chronos` class.
+ *
+ * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC and convert it to the **equivalent local time** using the current environment's UTC offset.*
+ *
+ * @example
+ * // Example usage as constructor:
+ * const instance = chronos("2023-12-31");
+ * const instanceWithTime = chronos(2023, 12, 31, 15, 30, 0);
+ *
+ * @example
+ * // Example usage of static methods:
+ * // Both work identically - thanks to automatic Proxy delegation
+ * chronos.parse("2023-12-31", "YYYY-MM-DD");
+ * Chronos.parse("2023-12-31", "YYYY-MM-DD");
+ *
+ * chronos.today();
+ * chronos.isLeapYear(2024);
+ * chronos.min(date1, date2, date3);
+ *
+ * @remarks *No need to call `chronos` for accessing the static methods. Simply call the static methods.*
+ *
+ * **Available Static Methods:**
+ *
+ * ```ts
+ * chronos.now(): number;
+ * chronos.tomorrow(): Chronos;
+ * chronos.yesterday(): Chronos;
+ * chronos.today(options?: FormatOptions): string;
+ * chronos.with(options: ChronosWithOptions): Chronos;
+ * chronos.parse(dateStr: string, format: string): Chronos;
+ * chronos.utc(dateLike: ChronosInput): Chronos;
+ * chronos.min(...dates: ChronosInput[]): Chronos;
+ * chronos.max(...dates: ChronosInput[]): Chronos;
+ * chronos.isLeapYear(date: ChronosInput): boolean;
+ * chronos.isValidDate(value: unknown): boolean;
+ * chronos.isDateString(value: unknown): boolean;
+ * chronos.isValidChronos(value: unknown): boolean;
+ * chronos.isReconstructable(value: unknown): value is ChronosProperties;
+ * chronos.reconstruct(value: ChronosProperties): Chronos;
+ * chronos.formatTimePart(time: string, format?: TimeParts): string;
+ * chronos.getDatesForDay(day: WeekDay, options?: WeekdayOptions): string[];
+ * chronos.use(plugin: ChronosPlugin): void;
+ * chronos.register(plugin: ChronosPlugin): void;
+ * ```
+ */
+declare const chronos: ChronosStatics;
+//#endregion
+//#region src/index.d.ts
+/**
+ * @class Creates a new immutable `Chronos` instance.
+ *      - **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
+ *        and convert it to the **equivalent local time** using the current environment's UTC offset.*
+ *
+ * @param value - A date value (`number`, `string`, `Date`, or `Chronos` object).
+ *
+ * @remarks
+ * - If a string is provided, it should be in a format that can be parsed by the {@link Date} constructor.
+ * - If a number is provided, it should be a timestamp (milliseconds since the Unix epoch).
+ * - If a `Date` or `Chronos` object is provided, it will be handled internally to parse the date value.
+ *
+ * **It also accepts number values as following:**
+ * - **`year, month, date, hours, minutes, seconds, milliseconds`**: Individual components of a date-time to construct a `Chronos` instance.
+ *   - **`year`**: A number representing the year. If the year is between 0 and 99, it will be assumed to be the year 1900 + the provided year.
+ *   - **`month`**: A number between 1 and 12 representing the month (1 for January, 12 for December).
+ *   - **`date`**: A number between 1 and 31 representing the day of the month.
+ *   - **`hours`**: A number between 0 and 23 representing the hour of the day.
+ *   - **`minutes`**: A number between 0 and 59 representing the minutes past the hour.
+ *   - **`seconds`**: A number between 0 and 59 representing the seconds past the minute.
+ *   - **`milliseconds`**: A number between 0 and 999 representing the milliseconds past the second.
+ *
+ * @returns Instance of `Chronos` with all methods and properties.
+ */
+declare class Chronos {
+  #private;
+  /** Use `readonly and/or private` methods outside `Chronos`. Purpose: Plugin creation. */
+  protected static [INTERNALS]: ChronosInternals;
+  /** Origin of the `Chronos` instance (Method that created `new Chronos`), useful for tracking instance. */
+  origin: ChronosMethods | 'root';
+  /**
+   * * `Chronos` date/time as Native JS `Date` object.
+   *
+   * - Also accessible via {@link toDate} instance method.
+   */
+  native: Date;
+  /**
+   * * Current (time zone) UTC offset in `UTC±HH:mm` format.
+   *
+   * - Also accessible via {@link getTimeZoneOffset} instance method without `UTC` prefix (returns in `±HH:mm` format).
+   */
+  utcOffset: UTCOffset;
+  /**
+   * Represents the current timezone name (e.g., `"Bangladesh Standard Time"`), or falls back to the corresponding timezone identifier (e.g., `"Asia/Dhaka"`) if no name can be resolved.
+   *
+   * @remarks
+   * - Invoking the {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/conversion#timezone timeZone} method sets the timezone name that corresponds to the specified UTC offset, or the UTC offset itself if no name exists. For more details on this behavior, see {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/names#gettimezonename getTimeZoneName}.
+   * - To retrieve the local system's native timezone name (or its identifier if the name is unavailable), use the {@link $getNativeTimeZoneName} instance method.
+   */
+  timeZoneName: LooseLiteral<TimeZoneName>;
+  /**
+   * Represents the current timezone context, which can be a single identifier, an array of equivalent identifiers, or a UTC offset.
+   *
+   * - **{@link $TimeZoneIdentifier}** — e.g., `"Asia/Dhaka"`. Returned when the {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/conversion#timezone timeZone} method has not been invoked. It is default behavior.
+   * - **Array of {@link $TimeZoneIdentifier}** — e.g., `[ 'Asia/Calcutta', 'Asia/Colombo' ]`, used when multiple timezones share the same UTC offset such as `"UTC+05:30"`.
+   * - **{@link UTCOffset}** — e.g., `"UTC+06:45"` or `"UTC+02:15"`, returned when no named timezone corresponds to a given offset.
+   *
+   * @remarks
+   * - By default, when {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/conversion#timezone timeZone} is not applied, a single {@link $TimeZoneIdentifier} string is provided.
+   * - When applied, it may instead return a single identifier string, an array of equivalent identifiers or a UTC offset string.
+   * - To retrieve the local system's native timezone identifier, use the {@link $getNativeTimeZoneId} instance method.
+   */
+  timeZoneId: TimeZoneId;
+  /** Tracker to identify the instance created by {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/conversion#timezone timeZone} method */
+  protected $tzTracker?: $TimeZoneIdentifier | TimeZone | UTCOffset;
+  /**
+   * * Creates a new immutable `Chronos` instance from current date & time (UTC).
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  constructor();
+  /**
+   * * Creates a new immutable `Chronos` instance.
+   *
+   * @param value - A date value in `number`, it should be a timestamp (milliseconds since the Unix epoch).
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  constructor(value: number);
+  /**
+   * * Creates a new immutable `Chronos` instance.
+   *
+   * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC and convert it to the **equivalent local time** using the current environment's UTC offset.*
+   *
+   * @param value - A date value in `string`, it should be in a format that can be parsed by the {@link Date} constructor.
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  constructor(value: string);
+  /**
+   * * Creates a new immutable `Chronos` instance.
+   *
+   * @param value - A date value as {@link Date} object.
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  constructor(value: Date);
+  /**
+   * * Creates a new immutable `Chronos` instance.
+   *
+   * @param value - A date value as `Chronos` object.
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  constructor(value: Chronos);
+  /**
+   * * Creates a new immutable `Chronos` instance.
+   *
+   * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC and convert it to the **equivalent local time** using the current environment's UTC offset.*
+   *
+   * @param year The full year designation is required for cross-century date accuracy. If year is between 0 and 99, year is assumed to be 1900 + year.
+   * @param month The month as a `number` between 1 and 12 (January to December).
+   * @param date The date as a `number` between 1 and 31.
+   * @param hours Must be supplied if minutes is supplied. A `number` from 0 to 23 (midnight to 11pm) that specifies the hour.
+   * @param minutes Must be supplied if seconds is supplied. A `number` from 0 to 59 that specifies the minutes.
+   * @param seconds Must be supplied if milliseconds is supplied. A `number` from 0 to 59 that specifies the seconds.
+   * @param ms A `number` from 0 to 999 that specifies the milliseconds.
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  constructor(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number);
+  /**
+   * * Creates a new immutable `Chronos` instance.
+   *
+   * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC and convert it to the **equivalent local time** using the current environment's UTC offset.*
+   *
+   * @param value - A date value (`number`, `string`, `Date`, or `Chronos` object).
+   * - If a `string` is provided, it should be in a format that can be parsed by the `Date` constructor.
+   * - If a `number` is provided, it should be a timestamp (milliseconds since the Unix epoch).
+   * - If a `Date` object is provided, it will be used as is.
+   * - If a `Chronos` object is provided, it will be used directly.
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  constructor(value?: ChronosInput);
+  [Symbol.iterator](): IterableIterator<[string, number]>;
+  [Symbol.toPrimitive](hint: string): string | number;
+  [Symbol.replace](string: string, replacement: string): string;
+  [Symbol.search](string: string): number;
+  [Symbol.split](string: string): string[];
+  [Symbol.match](string: string): RegExpMatchArray | null;
+  get [Symbol.toStringTag](): string;
+  get [Symbol.isConcatSpreadable](): boolean;
+  /**
+   * @instance Retrieves the local system's current time zone name (e.g., `"Bangladesh Standard Time"`), or falls back to its corresponding IANA time zone identifier (e.g., `"Asia/Dhaka"`) if the name cannot be determined.
+   *
+   * @remarks
+   * - This method always reflects the local machine's time zone if `tzId` is parameter is omitted.
+   * - {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/conversion#timezone timeZone}, {@link utc}, or {@link toUTC} methods have no effects on this method.
+   * - To access the time zone name of a modified or converted instance, use the {@link timeZoneName} public property instead.
+   *
+   * @param tzId Optional time zone identifier to get time zone name for that specific identifier if available.
+   *
+   * @returns The resolved time zone name or its IANA identifier as a fallback.
+   */
+  $getNativeTimeZoneName(tzId?: $TimeZoneIdentifier): $NativeTzNameOrId;
+  /**
+   * @instance Retrieves the IANA time zone identifier (e.g., `"Asia/Dhaka"`, `"Africa/Harare"`) for the local system's current time zone.
+   *
+   * @remarks
+   * - This method always returns the identifier of the local machine's time zone.
+   * - {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/conversion#timezone timeZone}, {@link utc}, or {@link toUTC} methods have no effects on this method.
+   * - To obtain the identifier(s) of a modified or converted instance, use the {@link timeZoneId} public property instead.
+   *
+   * @returns The local system's IANA time zone identifier.
+   */
+  $getNativeTimeZoneId(): TimeZoneIdNative;
+  /** Gets the full year of the date. */
+  get year(): number;
+  /** Gets the month (0-11) of the date. */
+  get month(): Enumerate<12>;
+  /** Gets the day of the month (1-31). */
+  get date(): NumberRange<1, 31>;
+  /** Gets the day of the week (0-6, where 0 is Sunday). */
+  get weekDay(): Enumerate<7>;
+  /** Gets the hour (0-23) of the date. */
+  get hour(): Enumerate<24>;
+  /** Gets the minute (0-59) of the date. */
+  get minute(): Enumerate<60>;
+  /** Gets the second (0-59) of the date. */
+  get second(): Enumerate<60>;
+  /** Gets the millisecond (0-999) of the date. */
+  get millisecond(): Milliseconds;
+  /** Gets ISO weekday: 1 = Monday, 7 = Sunday */
+  get isoWeekDay(): NumberRange<1, 7>;
+  /** Gets ISO month (1–12 instead of 0–11) */
+  get isoMonth(): NumberRange<1, 12>;
+  /** Returns the Unix timestamp (seconds since the Unix epoch: January 1, 1970, UTC). */
+  get unix(): number;
+  /** Gets the time value in milliseconds since midnight, January 1, 1970 UTC. */
+  get timestamp(): number;
+  /** * Gets the last date (number) of the current month `(28, 29, 30 or 31)`. */
+  get lastDateOfMonth(): NumberRange<28, 31>;
+  /** @instance Returns a debug-friendly string for `console.log` or `util.inspect`. */
+  inspect(): string;
+  /** @instance Enables `JSON.stringify` to show readable output. Calls {@link toLocalISOString} method. */
+  toJSON(): string;
+  /** @instance Enables arithmetic and comparison operations (e.g., `+new Chronos()`). Calls {@link getTimeStamp} method. */
+  valueOf(): number;
+  /** @instance Clones and returns exactly same `Chronos` instance. */
+  clone(): Chronos;
+  /** @instance Gets the native `Date` instance of the current `Chronos`. */
+  toDate(): Date;
+  /** @instance Returns a string representation of a date. */
+  toString(): string;
+  /** @instance Returns ISO time string in appropriate time zone with offset. */
+  toLocalISOString(): ISOTimeString;
+  /** @instance Returns a date as a string value in ISO format (UTC). */
+  toISOString(): ISODateTimeString;
+  /**
+   * @instance Wrapper over native {@link Date.toLocaleString} with improved type system.
+   * @description Converts a date and time to a string by using the current or specified locale.
+   *
+   * @param locales A locale string, array of locale strings, {@link Intl.Locale} object, or array of {@link Intl.Locale} objects that contain one or more language or locale tags (see: {@link LocalesArguments}). If you include more than one locale string, list them in descending order of priority so that the first entry is the preferred locale. If you omit this parameter, the default locale of the JavaScript runtime is used.
+   * @param options An object that contains one or more properties that specify comparison options (see: {@link DateTimeFormatOptions}).
+   */
+  toLocaleString(locales?: LocalesArguments, options?: DateTimeFormatOptions): string;
+  /** @instance Returns the time value in milliseconds since midnight, January 1, 1970 UTC. */
+  getTimeStamp(): number;
+  /**
+   * @instance Formats the current date into a custom string format (local time by default).
+   *
+   * @param format - The desired format string (Default: `dd, mmm DD, YYYY HH:mm:ss` → e.g., `Sun, Apr 06, 2025 16:11:55`).
+   *
+   * - To output raw text (i.e., not interpreted as a date token), wrap it in square brackets.
+   * - For example, `[Today is] ddd` results in `Today is Sunday`, and `YYYY[ year]` results in `2025 year`.
+   *
+   * - Supported format tokens include: `YYYY`, `YY`, `mmmm`, `mmm`, `MM`, `M`, `DD`, `D`, `dd`, `ddd`, `Do`, `HH`, `H`, `hh`, `h`, `mm`, `m`, `ss`, `s`, `ms`, `mss`, `a`, `A`, `ZZ` and `Z`.
+   * - *Any token not wrapped in brackets will be parsed and replaced with its corresponding date component.*
+   * - Please refer to {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/format#format-tokens format tokens} for details.
+   *
+   * @param useUTC - Optional boolean to format the date using UTC time.
+   * When `true`, it behaves like `formatUTC()` and outputs time based on UTC offset. Defaults to `false`.
+   *
+   * @returns Formatted date string using the specified format.
+   * Uses local time by default unless `useUTC` is set to `true`.
+   */
+  format(format?: string, useUTC?: boolean): string;
+  /**
+   * @instance Formats the date into a predefined strict string format using local time or UTC.
+   *
+   * @remarks Offers `over 21,300` predefined formats with full IntelliSense support.
+   *
+   * @param format - The desired format string. Defaults to `'dd, mmm DD, YYYY HH:mm:ss'`
+   *                 (e.g., `'Sun, Apr 06, 2025 16:11:55'`).
+   *	- Please refer to {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/format#format-tokens format tokens} for details.
+   *
+   * @param useUTC - If `true`, formats the date in UTC (equivalent to `formatUTC()`).
+   *                 Defaults to `false` (local time).
+   * @returns A formatted date string in the specified format.
+   */
+  formatStrict(format?: StrictFormat, useUTC?: boolean): string;
+  /**
+   * @instance Formats the date into a custom string format (UTC time).
+   *
+   * @param format - The desired format (Default format is `dd, mmm DD, YYYY HH:mm:ss:mss` = `Sun, Apr 06, 2025 16:11:55:379`).
+   *
+   * - To output raw text (i.e., not interpreted as a date token), wrap it in square brackets.
+   * - For example, `[Today is] ddd` results in `Today is Sunday`, and `YYYY[ year]` results in `2025 year`.
+   *
+   * - Supported format tokens include: `YYYY`, `YY`, `mmmm`, `mmm`, `MM`, `M`, `DD`, `D`, `dd`, `ddd`, `Do`, `HH`, `H`, `hh`, `h`, `mm`, `m`, `ss`, `s`, `ms`, `mss`, `a`, `A`, `ZZ` and `Z`.
+   * - *Any token not wrapped in brackets will be parsed and replaced with its corresponding date component.*
+   * - Please refer to {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/format#format-tokens format tokens} for details.
+   *
+   * @returns Formatted date string in desired format (UTC time).
+   */
+  formatUTC(format?: string): string;
+  /**
+   * @instance Adds seconds and returns a new immutable instance.
+   * @param seconds - Number of seconds to add.
+   * @returns A new `Chronos` instance with the updated date.
+   */
+  addSeconds(seconds: number): Chronos;
+  /**
+   * @instance Adds minutes and returns a new immutable instance.
+   * @param minutes - Number of minutes to add.
+   * @returns A new `Chronos` instance with the updated date.
+   */
+  addMinutes(minutes: number): Chronos;
+  /**
+   * @instance Adds hours and returns a new immutable instance.
+   * @param hours - Number of hours to add.
+   * @returns A new `Chronos` instance with the updated date.
+   */
+  addHours(hours: number): Chronos;
+  /**
+   * @instance Adds days and returns a new immutable instance.
+   * @param days - Number of days to add.
+   * @returns A new `Chronos` instance with the updated date.
+   */
+  addDays(days: number): Chronos;
+  /**
+   * @instance Adds weeks and returns a new immutable instance.
+   * @param weeks - Number of weeks to add.
+   * @returns A new `Chronos` instance with the updated date.
+   */
+  addWeeks(weeks: number): Chronos;
+  /**
+   * @instance Adds months and returns a new immutable instance.
+   * @param months - Number of months to add.
+   * @returns A new `Chronos` instance with the updated date.
+   */
+  addMonths(months: number): Chronos;
+  /**
+   * @instance Adds years and returns a new immutable instance.
+   * @param years - Number of years to add.
+   * @returns A new `Chronos` instance with the updated date.
+   */
+  addYears(years: number): Chronos;
+  /**
+   * @instance Checks if the current year is a leap year.
+   * - A year is a leap year if it is divisible by 4, but not divisible by 100, unless it is also divisible by 400.
+   * - For example, 2000 and 2400 are leap years, but 1900 and 2100 are not.
+   * @param year - Optional year to check. Default is the year from current `Chronos` instance.
+   * @returns `true` if the year is a leap year, `false` otherwise.
+   */
+  isLeapYear(year?: number): boolean;
+  /** @instance Checks if another date is exactly equal to this one. */
+  isEqual(other: ChronosInput): boolean;
+  /** @instance Checks if another date is exactly equal to or before this one. */
+  isEqualOrBefore(other: ChronosInput): boolean;
+  /** @instance Checks if another date is exactly equal to or after this one. */
+  isEqualOrAfter(other: ChronosInput): boolean;
+  /**
+   * @instance Checks if another date is the same as this one in a specific unit.
+   * @param other The other date to compare.
+   * @param unit The unit to compare.
+   * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
+   */
+  isSame(other: ChronosInput, unit: TimeUnit, weekStartsOn?: Enumerate<7>): boolean;
+  /**
+   * @instance Checks if this date is before another date in a specific unit.
+   * @param other The other date to compare.
+   * @param unit The unit to compare.
+   * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
+   */
+  isBefore(other: ChronosInput, unit: TimeUnit, weekStartsOn?: Enumerate<7>): boolean;
+  /**
+   * @instance Checks if this date is after another date in a specific unit.
+   * @param other The other date to compare.
+   * @param unit The unit to compare.
+   * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
+   */
+  isAfter(other: ChronosInput, unit: TimeUnit, weekStartsOn?: Enumerate<7>): boolean;
+  /**
+   * @instance Checks if this date is the same or before another date in a specific unit.
+   * @param other The other date to compare.
+   * @param unit The unit to compare.
+   * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
+   */
+  isSameOrBefore(other: ChronosInput, unit: TimeUnit, weekStartsOn?: Enumerate<7>): boolean;
+  /**
+   * @instance Checks if this date is the same or after another date in a specific unit.
+   * @param other The other date to compare.
+   * @param unit The unit to compare.
+   * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
+   */
+  isSameOrAfter(other: ChronosInput, unit: TimeUnit, weekStartsOn?: Enumerate<7>): boolean;
+  /**
+   * @instance Checks if the current date is between the given start and end dates.
+   *
+   * @param start - The start of the range.
+   * @param end - The end of the range.
+   * @param inclusive - Specifies whether the comparison is inclusive or exclusive:
+   * - `'[]'`: inclusive of both start and end (≥ start and ≤ end)
+   * - `'[)'`: inclusive of start, exclusive of end (≥ start and < end)
+   * - `'(]'`: exclusive of start, inclusive of end (> start and ≤ end)
+   * - `'()'`: exclusive of both start and end (> start and < end)
+   *
+   * @returns `true` if the current date is within the specified range based on the `inclusive` mode.
+   */
+  isBetween(start: ChronosInput, end: ChronosInput, inclusive?: '[]' | '[)' | '(]' | '()'): boolean;
+  /**
+   * @instance Checks if the date is within daylight saving time (DST).
+   * @returns Whether the date is in DST (`true` or `false`).
+   */
+  isDST(): boolean;
+  /** @instance Checks if current day is the first day of the current month. */
+  isFirstDayOfMonth(): boolean;
+  /** @instance Checks if current day is the last day of the current month. */
+  isLastDayOfMonth(): boolean;
+  /** @instance Returns a new `Chronos` instance set to the first day of the current month. */
+  firstDayOfMonth(): Chronos;
+  /** @instance Returns a new `Chronos` instance set to the last day of the current month. */
+  lastDayOfMonth(): Chronos;
+  /**
+   * @instance Returns a new `Chronos` instance at the start of a given unit.
+   * @param unit The unit to reset (e.g., year, month, day).
+   * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
+   */
+  startOf(unit: TimeUnit, weekStartsOn?: Enumerate<7>): Chronos;
+  /**
+   * @instance Returns a new `Chronos` instance at the end of a given unit.
+   * @param unit The unit to adjust (e.g., year, month, day).
+   * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
+   */
+  endOf(unit: TimeUnit, weekStartsOn?: Enumerate<7>): Chronos;
+  /**
+   * @instance Returns a new `Chronos` instance with the specified unit added.
+   * @param number The number of time unit to add (can be negative).
+   * @param unit The time unit to add.
+   */
+  add(number: number, unit: TimeUnit): Chronos;
+  /**
+   * @instance Returns a new `Chronos` instance with the specified unit subtracted.
+   * @param number The number of time unit to subtract (can be negative).
+   * @param unit The time unit to add.
+   */
+  subtract(number: number, unit: TimeUnit): Chronos;
+  /**
+   * @instance Gets the value of a specific time unit from the date.
+   * @param unit The unit to retrieve. Type of return value is determined by `unit`.
+   */
+  get<Unit extends TimeUnit>(unit: Unit): TimeUnitValue<Unit>;
+  /**
+   * @instance Returns a new `Chronos` instance with the specified unit set to the given value.
+   * @param unit The unit to modify. Type of `value` is determined by `unit`.
+   * @param value The value to set for the unit. Type of `value` is determined by `unit`.
+   */
+  set<Unit extends TimeUnit>(unit: Unit, value: TimeUnitValue<Unit>): Chronos;
+  /**
+   * @instance Returns the difference between current and another date in the given unit.
+   * @param other The other date to compare.
+   * @param unit The unit in which to return the difference.
+   * @returns Difference in number (either `integer` or `float`).
+   */
+  diff(other: ChronosInput, unit: TimeUnit): number;
+  /**
+   * @instance Returns a human-readable relative calendar time like "Today at 3:00 PM"
+   * @param baseDate Optional base date to compare with.
+   */
+  calendar(baseDate?: ChronosInput): string;
+  /** @instance Returns a short human-readable string like "2h ago", "in 5m". From `year` to `second`. */
+  fromNowShort(): string;
+  /**
+   * @instance Sets the date to the Monday of the specified ISO week number within the current year.
+   * This method assumes ISO week logic, where week 1 is the week containing January 4th.
+   *
+   * @param week The ISO week number (1–53) to set the date to.
+   * @returns A new `Chronos` instance set to the start (Monday) of the specified week.
+   */
+  setWeek(week: NumberRange<1, 53>): Chronos;
+  /**
+   * @instance Calculates the ISO 8601 week number of the year.
+   *
+   * @Remarks ISO weeks start on Monday, and the first week of the year is the one containing January 4th.
+   *
+   * @returns Week number (1–53).
+   */
+  getWeek(): NumberRange<1, 53>;
+  /**
+   * @instance Calculates the week number of the year based on custom week start.
+   * @param weekStartsOn Optional: Day the week starts on (0 = Sunday, 1 = Monday). Applicable if week day is required. Default is `0`.
+   * @returns Week number (1-53).
+   */
+  getWeekOfYear(weekStartsOn?: Enumerate<7>): NumberRange<1, 53>;
+  /**
+   * @instance Returns the ISO week-numbering year for the current date.
+   *
+   * The ISO week-numbering year may differ from the calendar year.
+   * For example, January 1st may fall in the last ISO week of the previous year.
+   *
+   * @param weekStartsOn Optional: Defines the start day of the week (0 = Sunday, 1 = Monday).
+   *                     Defaults to `0` (Sunday). Use 1 for strict ISO 8601.
+   * @returns The ISO week-numbering year.
+   */
+  getWeekYear(weekStartsOn?: Enumerate<7>): number;
+  /** @instance Returns day of year (1 - 366) */
+  getDayOfYear(): NumberRange<1, 366>;
+  /** @instance Returns number of days in current month */
+  daysInMonth(): NumberRange<28, 31>;
+  /** @instance Converts to object with all date unit parts */
+  toObject(): ChronosObject;
+  /** @instance Converts to array with all date unit parts */
+  toArray(): TupleOf<number, 12>;
+  /**
+   * @instance Returns the **calendar quarter** (1 to 4) of the current date.
+   *
+   * @remarks
+   * A calendar year is divided into four quarters:
+   *
+   * - `Q1`: January to March
+   * - `Q2`: April to June
+   * - `Q3`: July to September
+   * - `Q4`: October to December
+   *
+   * This method strictly uses the **calendar year**. For fiscal quarters, use {@link toFiscalQuarter} instead.
+   *
+   * @example
+   * new Chronos('2025-02-14').toQuarter(); // 1
+   * new Chronos('2025-08-09').toQuarter(); // 3
+   *
+   * @returns The calendar quarter number (1–4).
+   */
+  toQuarter(): Quarter;
+  /**
+   * @instance Returns the system's current UTC offset formatted as `±HH:mm` (`+06:00` or `-07:00`).
+   *
+   * - *Unlike JavaScript's {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset `Date.prototype.getTimezoneOffset()`}, which returns the offset in minutes **behind** UTC (positive for locations west of UTC and negative for east), this method returns the more intuitive sign format used in timezone representations (e.g., `+06:00` means 6 hours **ahead** of UTC).*
+   *
+   * @returns The (local) system's UTC offset in `±HH:mm` format.
+   */
+  getUTCOffset(): $UTCOffset;
+  /**
+   * @instance Returns the timezone offset of this `Chronos` instance in `±HH:mm` format maintaining current timezone.
+   *
+   * - *Unlike JavaScript's {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset `Date.prototype.getTimezoneOffset()`}, which returns the offset in minutes **behind** UTC (positive for locations west of UTC and negative for east), this method returns the more intuitive sign format used in timezone representations (e.g., `+06:00` means 6 hours **ahead** of UTC).*
+   *
+   * @returns The timezone offset string in `±HH:mm` format maintaining the current timezone regardless of system having different one.
+   */
+  getTimeZoneOffset(): $UTCOffset;
+  /**
+   * @instance Gets the difference in minutes between Universal Coordinated Time (UTC) and the time on the local computer.
+   *
+   * - *Unlike JavaScript's {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset `Date.prototype.getTimezoneOffset()`}, this method returns a positive value if the local time is ahead of UTC, and negative if behind UTC.*
+   *
+   * For example, for `UTC+06:00`, this returns `360`; for `UTC-05:30`, this returns `-330`.
+   *
+   * @returns The system's UTC offset in minutes, matching the sign convention used in `±HH:mm`.
+   */
+  getUTCOffsetMinutes(): number;
+  /**
+   * @instance Returns the current `Chronos` instance's UTC offset in minutes.
+   *
+   * This reflects the parsed or stored offset used internally by `Chronos` and follows the same
+   * sign convention: positive for timezones ahead of UTC, negative for behind.
+   *
+   * @returns The UTC offset in minutes maintaining the current timezone regardless of system having different one.
+   */
+  getTimeZoneOffsetMinutes(): number;
+  /** @instance Returns new `Chronos` instance in UTC time */
+  toUTC(): Chronos;
+  /** @instance Returns new `Chronos` instance in local time */
+  toLocal(): Chronos;
+  /**
+   * @instance Returns the name of the current day or optional day index.
+   * @param index Optional day index (`0–6`, where `0` is `Sunday`) to override current day.
+   * @returns Name of the weekday, e.g., `'Monday'`, `'Tuesday'` etc.
+   */
+  day(index?: Enumerate<7>): WeekDay;
+  /**
+   * @instance Returns the name of the current month or optional month index.
+   * @param index Optional month index (`0–11`, where `0` is `January`) to override current month.
+   * @returns Name of the month, e.g., `'January'`, `'February'` etc.
+   */
+  monthName(index?: Enumerate<12>): MonthName;
+  /**
+   * @static Parses a date string with a given format (limited support only).
+   *
+   * **Supported format tokens**:
+   * - `YYYY`: Full year (e.g., 2023)
+   * - `YY`: Two-digit year (e.g., 23 for 2023, 99 for 1999)
+   * - `MM`: Month (01-12)
+   * - `M`: Month (1-12)
+   * - `DD`: Day of the month (01-31)
+   * - `D`: Day of the month (1-31)
+   * - `HH`: Hour (00-23)
+   * - `H`: Hour (0-23)
+   * - `mm`: Minute (00-59)
+   * - `m`: Minute (0-59)
+   * - `ss`: Second (00-59)
+   * - `s`: Second (0-59)
+   * - `mss`: Millisecond (000-999)
+   * - `ms`: Millisecond (0-999)
+   *
+   * @example
+   * Chronos.parse('23-12-31 15:30:45', 'YY-MM-DD HH:mm:ss');
+   * // returns `Chronos` instance with the parsed date 2023-12-31T15:30:45
+   *
+   * @param dateStr - The date string to be parsed
+   * @param format - The format of the date string. Supported tokens `YYYY`, `YY` `MM`, `M`, `DD`, `D`, `HH`, `H`, `mm`, `m`, `ss`, `s`, `mss`, `ms` are used to specify the structure.
+   * @returns A new `Chronos` instance representing the parsed date.
+   * @throws `Error` If the date string does not match the format.
+   */
+  static parse(dateStr: string, format: string): Chronos;
+  /**
+   * @static Creates a new `Chronos` instance with the provided time component(s).
+   *
+   * @param options - One or more time components to override.
+   * @returns A new `Chronos` instance with the provided time components applied.
+   *
+   * @remarks
+   * - Unspecified components are filled with the current time's (`Chronos`) respective values.
+   * - For option `month`, value should be number from `1` (January) to `12` (December).
+   * - If the `date` component is omitted and the current day is the last day of its month,
+   *   the resulting instance will also use the last day of the target month.
+   *   - _This rule does **not** apply if the `date` component is explicitly provided,
+   *     even if that value exceeds the last day of the target month._
+   *
+   * @example
+   * // Override only the year and month
+   * const c = Chronos.with({ year: 2025, month: 12 });
+   */
+  static with(options: ChronosWithOptions): Chronos;
+  /**
+   * @static Returns the current date and time in a specified format in local time.
+   * * Default format is dd, `mmm DD, YYYY HH:mm:ss` = `Sun, Apr 06, 2025 16:11:55`
+   * @param options - Configure format string and whether to format using utc offset.
+   * @returns Formatted date string in desired format.
+   */
+  static today(options?: FormatOptions): string;
+  /**
+   * @static Returns a new `Chronos` instance representing yesterday's date.
+   *
+   * @returns A `Chronos` instance for the previous calendar day.
+   */
+  static yesterday(): Chronos;
+  /**
+   * @static Returns a new `Chronos` instance representing tomorrow's date.
+   *
+   * @returns A `Chronos` instance for the next calendar day.
+   */
+  static tomorrow(): Chronos;
+  /**
+   * @static Returns the number of milliseconds elapsed since midnight, January 1, 1970 Universal Coordinated Time (UTC).
+   * * It basically calls {@link Date.now()}.
+   * @returns The number of milliseconds elapsed since the Unix epoch.
+   */
+  static now(): number;
+  /**
+   * @static Creates a UTC-based `Chronos` instance.
+   * If no date is provided, it uses the current date and time.
+   *
+   * **This is the base time, meaning conversion in other timezone will consider UTC time as the base time.**
+   *
+   * @param dateLike Optional input date to base the UTC time on.
+   * If omitted, the current system date/time is used.
+   * @returns A new `Chronos` instance representing the UTC equivalent of the input.
+   */
+  static utc(dateLike?: ChronosInput): Chronos;
+  /**
+   * @static Formats a time-only string into a formatted time string.
+   *
+   * @param time - Time string to be formatted. Supported formats include:
+   * - `HH:mm` → e.g., `'14:50'`
+   * - `HH:mm:ss` → e.g., `'14:50:00'`
+   * - `HH:mm:ss.mss` → e.g., `'14:50:00.800'`
+   * - `HH:mm+TimeZoneOffset(HH)` → e.g., `'14:50+06'`
+   * - `HH:mm+TimeZoneOffset(HH:mm)` → e.g., `'14:50+06:00'`
+   * - `HH:mm:ss+TimeZoneOffset(HH)` → e.g., `'14:50:00+06'`
+   * - `HH:mm:ss+TimeZoneOffset(HH:mm)` → e.g., `'14:50:00+05:30'`
+   * - `HH:mm:ss.mss+TimeZoneOffset(HH)` → e.g., `'14:50:00.800+06'`
+   * - `HH:mm:ss.mss+TimeZoneOffset(HH:mm)` → e.g., `'14:50:00.800+06:30'`
+   *
+   * - *Input will default to today's date and assume local timezone if no offset is provided.*
+   *
+   * @param format - Format tokens accepted by {@link formatStrict()} method ({@link TimeOnlyFormat}) for time part only.
+   *                 Default: `hh:mm:ss a` → 02:33:36 pm.
+   * @returns Formatted time string in local (System) time.
+   */
+  static formatTimePart(time: string, format?: TimeOnlyFormat): string;
+  /**
+   * @static Returns ISO date strings for each occurrence of a weekday from today, spanning a relative time range.
+   *
+   * @param day - The weekday to match (e.g., `'Wednesday'`, `'Sunday'`).
+   * @param options - Relative range (e.g., 7 days, 4 weeks) and output format (local with timezone or utc).
+   * @returns Array of ISO date strings in the specified format. Returns empty array if no matches in the time span.
+   *
+   * - Please refer to {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/statics#getdatesforday docs} for details.
+   *
+   * @example
+   * Chronos.getDatesForDay('Wednesday', { span: 7, unit: 'day' });
+   * //=> [ '2025-05-28T21:16:06.198+06:00', '2025-06-04T21:16:06.198+06:00' ]
+   *
+   * @example
+   * Chronos.getDatesForDay('Wednesday', {
+   *   span: 7,
+   *   unit: 'day',
+   *   format: 'utc'
+   * });
+   * //=> [ '2025-05-28T15:17:10.812Z', '2025-06-04T15:17:10.812Z' ]
+   */
+  static getDatesForDay(day: WeekDay, options?: RelativeRangeOptions): string[];
+  /**
+   * @static Returns ISO date strings for each occurrence of a weekday between two fixed dates.
+   *
+   * @param day - The weekday to match (e.g., `'Monday'`, `'Friday'`).
+   * @param options - Date range (from/to, e.g. `'2025-06-30'`, ` new Date()`, `new Chronos()` etc.) and output format (local with timezone or utc).
+   * @returns Array of ISO date strings in the specified format. Returns empty array if no matches in the range.
+   *
+   * - Please refer to {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/statics#getdatesforday docs} for details.
+   *
+   * @remarks
+   * - When using `Chronos` instances for `from` and/or `to`, ensure both are created in the **same time zone** to avoid mismatched boundaries.
+   * - Mixing zones may shift the interpreted start or end by several hours, which can cause the range to include or exclude incorrect weekdays.
+   *
+   * @example
+   * Chronos.getDatesForDay('Monday', {
+   *   from: '2025-05-28',
+   *   to: '2025-06-30',
+   *   format: 'local'
+   * });
+   * //=> [ '2025-01-06T...', '2025-01-13T...', ... ]
+   */
+  static getDatesForDay(day: WeekDay, options?: DateRangeOptions): string[];
+  /**
+   * @static Returns the earliest `Chronos` instance based on the underlying universal {@link timestamp}.
+   *
+   * @remarks
+   * - All inputs are normalized to `Chronos` instances before comparison.
+   * - Comparison is always performed using each instance's **UTC timestamp**, ensuring a consistent and timezone-agnostic result.
+   * - When exactly two values are provided, the first value becomes the initial candidate; if the second value represents an earlier moment in time, it replaces the candidate.
+   * - The returned value is **not** one of the input objects. A new immutable `Chronos` instance is always created. Its internal timezone, offset, name, and tracking information are cloned from the winning input instance.
+   *
+   * @param dates A list of Chronos-compatible inputs (`string`, `number`, `Date` or `Chronos`).
+   * @returns A new `Chronos` instance representing the earliest moment.
+   */
+  static min(...dates: ChronosInput[]): Chronos;
+  /**
+   * @static Returns the latest `Chronos` instance based on the underlying universal {@link timestamp}.
+   *
+   * @remarks
+   * - All inputs are normalized to `Chronos` instances before comparison.
+   * - Comparison is always performed using each instance's **UTC timestamp**, ensuring a consistent and timezone-agnostic result.
+   * - When exactly two values are provided, the first value becomes the initial candidate; if the second value represents a later moment in time, it replaces the candidate.
+   * - The returned value is **not** one of the input objects. A new immutable `Chronos` instance is always created. Its internal timezone, offset, name, and tracking information are cloned from the winning input instance.
+   *
+   * @param dates A list of Chronos-compatible inputs (`string`, `number`, `Date` or `Chronos`).
+   * @returns A new `Chronos` instance representing the latest moment.
+   */
+  static max(...dates: ChronosInput[]): Chronos;
+  /**
+   * @static Checks if the year in the date string or year (from 0 - 9999) is a leap year.
+   * - A year is a leap year if it is divisible by 4, but not divisible by 100, unless it is also divisible by 400.
+   * - For example, 2000 and 2400 are leap years, but 1900 and 2100 are not.
+   *
+   * @description
+   * This method accepts different types of date inputs and extracts the year to check if it's a leap year.
+   * If the provided date is a `number`, it will be treated as a year (must be a valid year from 0 to 9999).
+   * If the year is out of this range (negative or larger than 9999), it will be treated as a Unix timestamp.
+   * If the provided date is a string or a `Date` object, it will be parsed and the year will be extracted.
+   * If a `Chronos` instance is passed, the year will be directly accessed from the instance.
+   *
+   * @param date - A `number` (year or Unix timestamp), `string`, `Date`, or `Chronos` instance representing a date.
+   * @returns `true` if the year is a leap year, `false` otherwise.
+   */
+  static isLeapYear(date: ChronosInput): boolean;
+  /**
+   * @static Checks if the given value is a valid `Date` object.
+   * - A value is considered valid if it is an instance of the built-in `Date` class.
+   * - This does not check whether the date itself is valid (e.g., `new Date('invalid')`).
+   * @param value - The value to test.
+   * @returns `true` if the value is a valid `Date` object, otherwise `false`.
+   */
+  static isValidDate(value: unknown): value is Date;
+  /**
+   * @static Checks if the given value is a valid date string.
+   * - A value is considered a valid date string if it is a string and can be parsed by `Date.parse()`.
+   * - This uses the native JavaScript date parser internally.
+   * @param value - The value to test.
+   * @returns `true` if the value is a valid date string, otherwise `false`.
+   */
+  static isDateString(value: unknown): value is string;
+  /**
+   * @static Checks if the given value is an instance of `Chronos`.
+   * - Useful for verifying `Chronos` objects in type guards or validations.
+   * @param value - The value to test.
+   * @returns `true` if the value is an instance of `Chronos`, otherwise `false`.
+   */
+  static isValidChronos(value: unknown): value is Chronos;
+  /**
+   * @static Checks if the given value has the necessary properties to be reconstructed into a `Chronos` instance.
+   * - Can be used for validating objects that may represent serialized `Chronos` data.
+   * @param value - The value to check.
+   * @returns `true` if the value has the required properties for reconstruction, otherwise `false`.
+   */
+  static isReconstructable(value: unknown): value is ChronosProperties;
+  /**
+   * @static Reconstructs a `Chronos` instance from an object containing the necessary properties.
+   * - The input object must have the properties defined in {@link ChronosProperties} interface.
+   * - If the input is not reconstructable, an error is thrown.
+   *
+   * @param value - An object containing the properties required to reconstruct a `Chronos` instance.
+   * @returns A new `Chronos` instance created from the provided properties.
+   * @throws `TypeError` if the input value does not have the necessary properties for reconstruction.
+   */
+  static reconstruct(value: ChronosProperties): Chronos;
+  /**
+   * @static Injects a plugin into the `Chronos` system.
+   * @param plugin The plugin to inject.
+   *
+   * @remarks
+   * - Using this (`use`) method in `React` projects may trigger *linter error* like `"React Hooks must be called in a React function component or a custom React Hook function."`
+   * 	- To prevent this incorrect *linter error* in `React` projects, prefer using {@link register} method (alias `use` method).
+   *
+   * - **NOTE:** *Once a plugin is injected, all the registered methods for that plugin will be available for the whole project.*
+   * - See {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/plugins#-official-plugins full list of plugins and the methods they register}.
+   */
+  static use(plugin: ChronosPlugin): void;
+  /**
+   * @static Registers a plugin into the `Chronos` system.
+   * @param plugin The plugin to register.
+   *
+   * @remarks
+   * - This is just an alias for {@link use} method.
+   * - Using {@link use} method in `React` projects may trigger *linter error* like `"React Hooks must be called in a React function component or a custom React Hook function."`
+   * 	- To prevent this incorrect *linter error* in `React` projects, prefer using this (`register`) method over {@link use} method.
+   *
+   * - **NOTE:** *Once a plugin is injected, all the registered methods for that plugin will be available for the whole project.*
+   * - See {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/plugins#-official-plugins full list of plugins and the methods they register}.
+   */
+  static register(plugin: ChronosPlugin): void;
+}
+//#endregion
+//#region src/types/chronos-statics.d.ts
+/** All the statics methods in `Chronos` class */
+interface ChronosStatics {
+  /**
+   * * Converts a date into a `Chronos` object and access to all `Chronos` methods and properties.
+   *
+   * @description
+   * This function serves as a wrapper around the `Chronos` class constructor and allows you to create a new `Chronos` instance from various types of date representations.
+   *
+   * Accepts no arguments (defaults to now).
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  (): Chronos;
+  /**
+   * * Converts a date into a `Chronos` object and access to all `Chronos` methods and properties.
+   *
+   * @description
+   * This function serves as a wrapper around the `Chronos` class constructor and allows you to create a new `Chronos` instance from various types of date representations.
+   *
+   * @param value - A date value in `number`, it should be a timestamp (milliseconds since the Unix epoch).
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  (value: number): Chronos;
+  /**
+   * * Converts a date into a `Chronos` object and access to all `Chronos` methods and properties.
+   *
+   * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
+   * and convert it to the **equivalent local time** using the current environment's UTC offset.*
+   *
+   * @description
+   * This function serves as a wrapper around the `Chronos` class constructor and allows you to create a new `Chronos` instance from various types of date representations.
+   *
+   * @param value - A date value in `string`, it should be in a format that can be parsed by the `Date` constructor.
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  (value: string): Chronos;
+  /**
+   * * Converts a date into a `Chronos` object and access to all `Chronos` methods and properties.
+   *
+   * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
+   * and convert it to the **equivalent local time** using the current environment's UTC offset.*
+   *
+   * @description
+   * This function serves as a wrapper around the `Chronos` class constructor and allows you to create a new `Chronos` instance from various types of date representations.
+   *
+   * @param value - A date value as `Date` object, it will be used as is.
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  (value: Date): Chronos;
+  /**
+   * * Converts a date into a `Chronos` object and access to all `Chronos` methods and properties.
+   *
+   * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
+   * and convert it to the **equivalent local time** using the current environment's UTC offset.*
+   *
+   * @description
+   * This function serves as a wrapper around the `Chronos` class constructor and allows you to create a new `Chronos` instance from various types of date representations.
+   *
+   * @param value - A date value as `Chronos` object.
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  (value: Chronos): Chronos;
+  /**
+   * * Converts a date into a `Chronos` object and access to all `Chronos` methods and properties.
+   *
+   * @description
+   * This function serves as a wrapper around the `Chronos` class constructor and allows you to create a new `Chronos` instance from various types of date representations.
+   *
+   * @param year The full year designation is required for cross-century date accuracy. If year is between 0 and 99, year is assumed to be 1900 + year.
+   * @param month The month as a number between 1 and 12 (January to December).
+   * @param date The date as a number between 1 and 31.
+   * @param hours Must be supplied if minutes is supplied. A number from 0 to 23 (midnight to 11pm) that specifies the hour.
+   * @param minutes Must be supplied if seconds is supplied. A number from 0 to 59 that specifies the minutes.
+   * @param seconds Must be supplied if milliseconds is supplied. A number from 0 to 59 that specifies the seconds.
+   * @param ms A number from 0 to 999 that specifies the milliseconds.
+   *
+   * @returns Instance of `Chronos` with all methods and properties.
+   */
+  (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Chronos;
+  /**
+   * @static Injects a plugin into the `Chronos` system.
+   * @param plugin The plugin to inject.
+   *
+   * @remarks
+   * - Using this (`use`) method in `React` projects may trigger *linter error* like `"React Hooks must be called in a React function component or a custom React Hook function."`
+   * 	- To prevent this incorrect *linter error* in `React` projects, prefer using {@link register} method (alias `use` method).
+   *
+   * - **NOTE:** *Once a plugin is injected, all the registered methods for that plugin will be available for the whole project.*
+   * - See {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/plugins#-official-plugins full list of plugins and the methods they register}.
+   */
+  use(plugin: ChronosPlugin): void;
+  /**
+   * @static Registers a plugin into the `Chronos` system.
+   * @param plugin The plugin to register.
+   *
+   * @remarks
+   * - This is just an alias for {@link use} method.
+   * - Using {@link use} method in `React` projects may trigger *linter error* like `"React Hooks must be called in a React function component or a custom React Hook function."`
+   * 	- To prevent this incorrect *linter error* in `React` projects, prefer using this (`register`) method over {@link use} method.
+   *
+   * - **NOTE:** *Once a plugin is injected, all the registered methods for that plugin will be available for the whole project.*
+   * - See {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/plugins#-official-plugins full list of plugins and the methods they register}.
+   */
+  register(plugin: ChronosPlugin): void;
+  /**
+   * * Returns the current date and time in a specified format in local time.
+   * * Default format is dd, `MMM DD, YYYY HH:mm:ss` = `Sun, Apr 06, 2025 16:11:55`
+   * @param options - Configure format string and whether to format using utc offset.
+   * @returns Formatted date string in desired format.
+   */
+  today(options?: FormatOptions): string;
+  /**
+   * * Returns a new `Chronos` instance representing yesterday's date.
+   *
+   * @returns A `Chronos` instance for the next calendar day.
+   */
+  yesterday(): Chronos;
+  /**
+   * * Returns a new `Chronos` instance representing tomorrow's date.
+   *
+   * @returns A `Chronos` instance for the next calendar day.
+   */
+  tomorrow(): Chronos;
+  /**
+   * * Returns the number of milliseconds elapsed since midnight, January 1, 1970 Universal Coordinated Time (UTC).
+   * * It basically calls `Date.now()`.
+   * @returns The number of milliseconds elapsed since the Unix epoch.
+   */
+  now(): number;
+  /**
+   * * Parses a date string with a given format (limited support only).
+   *
+   * * **Supported format tokens**:
+   * - `YYYY`: Full year (e.g., 2023)
+   * - `YY`: Two-digit year (e.g., 23 for 2023, 99 for 1999)
+   * - `MM`: Month (01-12)
+   * - `M`: 1-Digit Month (1-9)
+   * - `DD`: Day of the month (01-31)
+   * - `D`: 1-Digit Day of the month (1-9)
+   * - `HH`: Hour (00-23)
+   * - `H`: 1-Digit Hour (0-9)
+   * - `mm`: Minute (00-59)
+   * - `m`: 1-Digit Minute (0-9)
+   * - `ss`: Second (00-59)
+   * - `s`: 1-Digit Second (0-9)
+   *
+   * @example
+   * Chronos.parse('23-12-31 15:30:45', 'YY-MM-DD HH:mm:ss');
+   * // returns Chronos instance with the parsed date 2023-12-31T15:30:45
+   *
+   * @param dateStr - The date string to be parsed
+   * @param format - The format of the date string. Tokens like `YYYY`, `MM`, `DD`, `HH`, `mm`, `ss` are used to specify the structure.
+   * @returns A new `Chronos` instance representing the parsed date.
+   * @throws `Error` If the date string does not match the format.
+   */
+  parse(dateStr: string, format: string): Chronos;
+  /**
+   * * Creates a new `Chronos` instance with the provided time component(s).
+   *
+   * @param options - One or more time components to override.
+   * @returns A new `Chronos` instance with the provided time components applied.
+   *
+   * @remarks
+   * - Unspecified components are filled with the current time's (`Chronos`) respective values.
+   * - For option `month`, value should be number from `1` (January) to `12` (December).
+   * - If the `date` component is omitted and the current day is the last day of its month,
+   *   the resulting instance will also use the last day of the target month.
+   *   - _This rule does **not** apply if the `date` component is explicitly provided,
+   *     even if that value exceeds the last day of the target month._
+   *
+   * @example
+   * // Override only the year and month
+   * const c = Chronos.with({ year: 2025, month: 12 });
+   */
+  with(options: ChronosWithOptions): Chronos;
+  /**
+   * * Creates a UTC-based Chronos instance.
+   * If no date is provided, it uses the current date and time.
+   *
+   * **This is the base time, meaning conversion in other timezone will consider UTC time as the base time.**
+   *
+   * @param dateLike Optional input date to base the UTC time on.
+   * If omitted, the current system date/time is used.
+   * @returns A new Chronos instance representing the UTC equivalent of the input.
+   */
+  utc(dateLike?: ChronosInput): Chronos;
+  /**
+   * * Formats a time-only string into a formatted time string.
+   *
+   * @param time - Time string to be formatted. Supported formats include:
+   * - `HH:mm` → e.g., `'14:50'`
+   * - `HH:mm:ss` → e.g., `'14:50:00'`
+   * - `HH:mm:ss.SSS` → e.g., `'14:50:00.800'`
+   * - `HH:mm+TimeZoneOffset(HH)` → e.g., `'14:50+06'`
+   * - `HH:mm:ss+TimeZoneOffset(HH)` → e.g., `'14:50:00+06'`
+   * - `HH:mm:ss+TimeZoneOffset(HH:mm)` → e.g., `'14:50:00+05:30'`
+   * - `HH:mm:ss.SSS+TimeZoneOffset(HH)` → e.g., `'14:50:00.800+06'`
+   * - `HH:mm:ss.SSS+TimeZoneOffset(HH:mm)` → e.g., `'14:50:00.800+06:30'`
+   *
+   * * *Input will default to today's date and assume local timezone if no offset is provided.*
+   *
+   * @param format - Format string accepted by `formatStrict()` method (`TimeParts`). Default: `hh:mm:ss a` → 02:33:36 pm.
+   * @returns Formatted time string in local (System) time.
+   */
+  formatTimePart(time: string, format?: TimeFormatToken): string;
+  /**
+   * * Returns ISO date strings for each occurrence of a weekday from today, spanning a relative time range.
+   *
+   * @param day - The weekday to match (e.g., `'Wednesday'`, `'Sunday'`).
+   * @param options - Relative range (e.g., 7 days, 4 weeks) and output format (local with timezone or utc).
+   * @returns Array of ISO date strings in the specified format. Returns empty array if no matches in the time span.
+   *
+   * @example
+   * Chronos.getDatesForDay('Wednesday', { span: 7, unit: 'day' });
+   * //=> [ '2025-05-28T21:16:06.198+06:00', '2025-06-04T21:16:06.198+06:00' ]
+   *
+   * @example
+   * Chronos.getDatesForDay('Wednesday', {
+   *   span: 7,
+   *   unit: 'day',
+   *   format: 'utc'
+   * });
+   * //=> [ '2025-05-28T15:17:10.812Z', '2025-06-04T15:17:10.812Z' ]
+   */
+  getDatesForDay(day: WeekDay, options?: RelativeRangeOptions): string[];
+  /**
+   * * Returns ISO date strings for each occurrence of a weekday between two fixed dates.
+   *
+   * @param day - The weekday to match (e.g., `'Monday'`, `'Friday'`).
+   * @param options - Absolute date range (e.g. `'2025-06-30'`, ` new Date()`, `new Chronos()` etc.) and output format (local with timezone or utc).
+   * @returns Array of ISO date strings in the specified format. Returns empty array if no matches in the range.
+   *
+   * @example
+   * Chronos.getDatesForDay('Monday', {
+   *   from: '2025-05-28',
+   *   to: '2025-06-30',
+   *   format: 'local'
+   * });
+   * //=> [ '2025-01-06T...', '2025-01-13T...', ... ]
+   */
+  getDatesForDay(day: WeekDay, options?: DateRangeOptions): string[];
+  /**
+   * * Returns ISO date strings for each occurrence of a weekday.
+   *
+   * @param day - The weekday to match (e.g., `'Wednesday'`, `'Sunday'`).
+   * @param options - Relative range (e.g., 7 days, 4 weeks) or Absolute date range and output format.
+   * @returns Array of ISO date strings in the specified format.
+   */
+  getDatesForDay(day: WeekDay, options?: WeekdayOptions): string[];
+  /**
+   * * Returns earliest Chronos
+   * @param dates Date inputs.
+   */
+  min(...dates: ChronosInput[]): Chronos;
+  /**
+   * * Returns latest Chronos
+   * @param dates Date inputs.
+   */
+  max(...dates: ChronosInput[]): Chronos;
+  /**
+   * * Checks if the year in the date string or year (from 0 - 9999) is a leap year.
+   * - A year is a leap year if it is divisible by 4, but not divisible by 100, unless it is also divisible by 400.
+   * - For example, 2000 and 2400 are leap years, but 1900 and 2100 are not.
+   *
+   * @description
+   * This method accepts different types of date inputs and extracts the year to check if it's a leap year.
+   * If the provided date is a `number`, it will be treated as a year (must be a valid year from 0 to 9999).
+   * If the year is out of this range (negative or larger than 9999), it will be treated as a Unix timestamp.
+   * If the provided date is a string or a `Date` object, it will be parsed and the year will be extracted.
+   * If a `Chronos` instance is passed, the year will be directly accessed from the instance.
+   *
+   * @param date - A `number` (year or Unix timestamp), `string`, `Date`, or `Chronos` instance representing a date.
+   * @returns `true` if the year is a leap year, `false` otherwise.
+   */
+  isLeapYear(date: ChronosInput): boolean;
+  /**
+   * * Checks if the given value is a valid `Date` object.
+   * - A value is considered valid if it is an instance of the built-in `Date` class.
+   * - This does not check whether the date itself is valid (e.g., `new Date('invalid')`).
+   * @param value - The value to test.
+   * @returns `true` if the value is a valid Date object, otherwise `false`.
+   */
+  isValidDate(value: unknown): value is Date;
+  /**
+   * * Checks if the given value is a valid date string.
+   * - A value is considered a valid date string if it is a string and can be parsed by `Date.parse()`.
+   * - This uses the native JavaScript date parser internally.
+   * @param value - The value to test.
+   * @returns `true` if the value is a valid date string, otherwise `false`.
+   */
+  isDateString(value: unknown): value is string;
+  /**
+   * * Checks if the given value is an instance of `Chronos`.
+   * - Useful for verifying Chronos objects in type guards or validations.
+   * @param value - The value to test.
+   * @returns `true` if the value is an instance of `Chronos`, otherwise `false`.
+   */
+  isValidChronos(value: unknown): value is Chronos;
+  /**
+   * * Checks if the given value has the necessary properties to be reconstructed into a `Chronos` instance.
+   * - Can be used for validating objects that may represent serialized `Chronos` data.
+   * @param value - The value to check.
+   * @returns `true` if the value has the required properties for reconstruction, otherwise `false`.
+   */
+  isReconstructable(value: unknown): value is ChronosProperties;
+  /**
+   * * Reconstructs a `Chronos` instance from an object containing the necessary properties.
+   * - The input object must have the properties defined in {@link ChronosProperties} interface.
+   * - If the input is not reconstructable, an error is thrown.
+   *
+   * @param value - An object containing the properties required to reconstruct a `Chronos` instance.
+   * @returns A new `Chronos` instance created from the provided properties.
+   * @throws `TypeError` if the input value does not have the necessary properties for reconstruction.
+   */
+  reconstruct(value: ChronosProperties): Chronos;
+}
+//#endregion
+//#region src/types/date-time.d.ts
+/** - Represents the full name of a weekday, e.g., 'Monday', 'Tuesday' etc. */
+type WeekDay = (typeof DAYS)[number];
+/** - Represents the full name of a month, e.g., 'January', 'February' etc. */
+type MonthName = (typeof MONTHS)[number];
+/** Mapped type to {@link TIME_UNIT_VARIANTS} */
+type $TimeUnitVarMap = typeof TIME_UNIT_VARIANTS;
+/** Key of {@link TIME_UNIT_VARIANTS} */
+type $TimeUnitKey = keyof typeof TIME_UNIT_VARIANTS;
+/** Variants of different time units in lowercase */
+type $TimeUnitVar<U extends $TimeUnitKey = $TimeUnitKey> = $TimeUnitVarMap[U][number];
+/** Variants of different time units in lowercase, uppercase  and capitalized */
+type $UnitAnyCase = Capitalize<$TimeUnitVar> | Uppercase<$TimeUnitVar> | $TimeUnitVar;
+/** Number (time value) with variants of different time units */
+type TimeWithUnit = `${number}${$UnitAnyCase}` | `${number} ${$UnitAnyCase}`;
+/** - Minute in numeric string from `00` to `23` */
+type ClockHour = `0${Enumerate<10>}` | `${NumberRange<10, 23>}`;
+/** - Minute in numeric string from `00` to `59` */
+type ClockMinute = `0${Enumerate<10>}` | `${NumberRange<10, 59>}`;
+/** - Second in numeric string from `00` to `59` */
+type ClockSecond = `0${Enumerate<10>}` | `${NumberRange<10, 59>}`;
+/** - Time in "HH:MM" format. */
+type ClockTime = `${ClockHour}:${ClockMinute}`;
+/** Normal time in `H:mm` format which does not follow the strict limit up to 23 hours, hour can be any number and minute can be numeric string from `00` to `59` */
+type HourMinutes = `${number}:${ClockMinute}`;
+/** Extends {@link Intl.DateTimeFormatOptions} with improved type system. */
+interface DateTimeFormatOptions extends Intl.DateTimeFormatOptions {
+  /** {@link https://en.wikipedia.org/wiki/List_of_tz_database_time_zones Time zone identifier} to use (excluding `'Factory'`). */
+  timeZone?: $TimeZoneIdentifier;
+  /** Locale calendar system to use. */
+  calendar?: LocaleCalendar;
+  /** Locale numbering system to use. */
+  numberingSystem?: NumberingSystem;
+}
+/** Millisecond from `0-999` */
+type Milliseconds = Enumerate<999> | 999;
+/** Date of the month as `0` padded numeric string e.g. `01`, `18` */
+type DateString = `0${NumberRange<1, 9>}` | `${NumberRange<10, 31>}`;
+/** Month as `0` padded numeric string, e.g. `02`, `01` etc. */
+type MonthString = `0${NumberRange<1, 9>}` | '10' | '11' | '12';
+/** Date and month in `MM-DD` format, e.g. `01-12` means 'January 18' */
+type MonthDateString = Exclude<`${MonthString}-${DateString}`, '02-30' | '02-31' | '04-31' | '06-31' | '09-31' | '11-31'>;
+/** Options for `formatDate` utility */
+interface DateFormatOptions extends FormatOptions {
+  /** - Date to format, must be parsable by {@link Date} constructor. Can be string, number or `Date`. Defaults to current time. */
+  date?: DateArgs;
+  format?: StrictFormat;
+}
+/** Interface representing a date-like object. */
+interface DateLike {
+  toJSON?(): string;
+  toISOString?(): string;
+  toString?(): string;
+  format?(): string;
+  toISO?(): string;
+  toFormat?(format: string): string;
+  plus?(...args: unknown[]): unknown;
+  minus?(...args: unknown[]): unknown;
+  equals?(...args: unknown[]): boolean;
+  getClass?(): unknown;
+  constructor?: {
+    name: string;
+  };
+}
+/** Quarters of the year */
+type Quarter = 1 | 2 | 3 | 4;
+/** Represents key of `ChronosStatics` (each static method and property) */
+type ChronosStaticKey = keyof ChronosStatics;
+/** Key of {@link TIME_ZONE_LABELS} ({@link UTCOffset}) */
+type $TZLabelKey = keyof typeof TIME_ZONE_LABELS;
+/** Abbreviated time zone names (from {@link https://en.wikipedia.org/wiki/List_of_time_zone_abbreviations time zone abbreviations on Wikipedia}). */
+type TimeZone = keyof typeof TIME_ZONES;
+/** Time zone identifier (from {@link https://en.wikipedia.org/wiki/List_of_tz_database_time_zones IANA TZ Database on Wikipedia}) excluding `'Factory'`. */
+type $TimeZoneIdentifier = Exclude<keyof typeof TIME_ZONE_IDS, 'Factory'>;
+/** Time zone identifier (from {@link https://en.wikipedia.org/wiki/List_of_tz_database_time_zones IANA TZ Database on Wikipedia}) excluding `'Factory'` & abbreviations present in {@link TimeZone}. */
+type TimeZoneIdentifier = Exclude<$TimeZoneIdentifier, TimeZone>;
+/** Time zone identifier, array of timezone identifiers or UTC offset. */
+type TimeZoneId = $TimeZoneIdentifier | $TimeZoneIdentifier[] | UTCOffset;
+/** JavaScript native time zone identifier (from {@link Intl.supportedValuesOf} API) */
+type TimeZoneIdNative = keyof typeof TIME_ZONES_NATIVE;
+/** JavaScript native time zone name (from {@link Intl.supportedValuesOf} API) */
+type TimeZoneNameNative = (typeof TIME_ZONES_NATIVE)[TimeZoneIdNative]['tzName'];
+/** Native time zone name or IANA time zone identifier */
+type $NativeTzNameOrId = TimeZoneNameNative | $TimeZoneIdentifier;
+/** Full time zone names from {@link https://en.wikipedia.org/wiki/List_of_time_zone_abbreviations Wikipedia}, {@link https://en.wikipedia.org/wiki/List_of_tz_database_time_zones IANA TZ Database on Wikipedia} and JavaScript native API ({@link Intl.supportedValuesOf}). */
+type TimeZoneName = NonNullable<(typeof TIME_ZONE_LABELS)[$TZLabelKey] | (typeof TIME_ZONES)[TimeZone]['tzName'] | (typeof TIME_ZONE_IDS)[$TimeZoneIdentifier]['tzName'] | TimeZoneNameNative>;
+/** Positive UTC hours */
+type PositiveUTCHour = `+0${Enumerate<10>}` | `+${NumberRange<10, 14>}`;
+/** Negative UTC hours */
+type NegativeUTCHour = `-0${Enumerate<10>}` | `-${NumberRange<10, 14>}`;
+/** UTC Minutes as quarters */
+type UTCMinute = '00' | '15' | '30' | '45';
+/** UTC offset in `±HH:mm` format */
+type $UTCOffset = `${PositiveUTCHour | NegativeUTCHour}:${UTCMinute}`;
+/** UTC offset in `UTC±HH:mm` format */
+type UTCOffset = `UTC${$UTCOffset}`;
+/** GMT offset in `GMT±HH:mm` or simply `GMT` format */
+type $GMTOffset = `GMT${$UTCOffset}` | 'GMT';
+type $ISOTimeString = `${number}-${number}-${number}T${number}:${number}:${number}.${number}`;
+type ISODateTimeString = `${$ISOTimeString}Z`;
+/** ISO timestamp string type in ISO 8601 format */
+type ISOTimeString = `${$ISOTimeString}${'Z' | $UTCOffset}`;
+/** Valid argument type accepted by `Date` constructor */
+type DateArgs = string | number | Date;
+/** Type for ISO date format options */
+type ISODateFormat = 'local' | 'utc';
+/** Options for `getTimestamp` utility */
+interface TimestampOptions {
+  /**
+   * Optional date input (string, number, or `Date` object).
+   * Defaults to {@link Date new Date()}.
+   */
+  value?: DateArgs;
+  /**
+   * Output format for the timestamp.
+   * - `'utc'` (default) → returns ISO string in UTC (`...Z`).
+   * - `'local'` → returns ISO string with current system offset (`...+05:30`).
+   */
+  format?: ISODateFormat;
+}
+/** `Chronos` Date Format options */
+interface FormatOptions {
+  /**
+   * * The desired format (Default format is `'dd, mmm DD, YYYY HH:mm:ss'` = `'Sun, Apr 06, 2025 16:11:55'`).
+   *
+   *   - To output raw text (i.e., not interpreted as a date token), wrap it in square brackets.
+   *   - For example, `[Today is] ddd` results in `Today is Sunday`, and `YYYY[ year]` results in `2025 year`.
+   *
+   *   - Supported format tokens include: `YYYY`, `YY`, `mmmm`, `mmm`, `MM`, `M`, `DD`, `D`, `dd`, `ddd`, `Do`, `HH`, `H`, `hh`, `h`, `mm`, `m`, `ss`, `s`, `ms`, `mss`, `a`, `A`, and `ZZ`.
+   *   - *Any token not wrapped in brackets will be parsed and replaced with its corresponding date component.*
+   *   - Please refer to {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/format#format-tokens format tokens} for details.
+   */
+  format?: string;
+  /** - Whether to use UTC time. Defaults to `false`. */
+  useUTC?: boolean;
+}
+/** - Configuration options for greeting. */
+interface GreetingConfigs {
+  /** Time when the morning period ends (HH:MM format). Defaults to `11:59` */
+  morningEnds?: ClockTime;
+  /** Time when the noon period ends (HH:MM format). Defaults to `12:59` */
+  noonEnds?: ClockTime;
+  /** Time when the afternoon period ends (HH:MM format). Defaults to `17:59` */
+  afternoonEnds?: ClockTime;
+  /** Time when the evening period ends (HH:MM format). Defaults to `23:59` */
+  eveningEnds?: ClockTime;
+  /** Time when the midnight period ends (HH:MM format). Defaults to `02:59` */
+  midnightEnds?: ClockTime;
+  /** Current time in "HH:MM" format for some weird reason. Defaults to current time `new Date()` */
+  currentTime?: ClockTime;
+  /** Optional string to append after each message */
+  appendToMsg?: string;
+  /** Optional string to prepend before each message */
+  prependToMsg?: string;
+  /** Custom greeting message for the morning period. */
+  morningMessage?: string;
+  /** Custom greeting message for the noon period. */
+  noonMessage?: string;
+  /** Custom greeting message for the afternoon period. */
+  afternoonMessage?: string;
+  /** Custom greeting message for the evening period. */
+  eveningMessage?: string;
+  /** Custom greeting message for the midnight period. */
+  midnightMessage?: string;
+  /** Default greeting message if no period matches. */
+  defaultMessage?: string;
+}
+/** Time zone details object */
+type TimeZoneDetails = {
+  /** IANA time zone identifier */tzIdentifier: $TimeZoneIdentifier; /** Long localized form (e.g., `'Pacific Standard Time'`, `'Nordamerikanische Westküsten-Normalzeit'`) */
+  tzNameLong: Maybe<LooseLiteral<TimeZoneName>>; /** Long generic non-location format (e.g.: `'Pacific Time'`, `'Nordamerikanische Westküstenzeit'`) */
+  tzNameLongGeneric: Maybe<LooseLiteral<TimeZoneName>>; /** Long localized GMT format, prefixed with `"GMT"` (e.g., `"GMT-08:00"`) */
+  tzNameLongOffset: Maybe<LooseLiteral<$GMTOffset>>;
+};
+/** Name of time unit from `year` to `millisecond` */
+type TimeUnit = 'year' | 'month' | 'day' | 'week' | 'hour' | 'minute' | 'second' | 'millisecond';
+/** Name of time unit from `year` to `millisecond`, excluding `week` */
+type FromNowUnit = Exclude<TimeUnit, 'week'>;
+/** Conditional value for {@link TimeUnit} */
+type TimeUnitValue<Unit extends TimeUnit> = Unit extends 'month' ? NumberRange<1, 12> : Unit extends 'week' ? NumberRange<1, 53> : Unit extends 'day' ? NumberRange<1, 31> : Unit extends 'hour' ? Enumerate<24> : Unit extends 'minute' | 'second' ? Enumerate<60> : Unit extends 'millisecond' ? Milliseconds : number;
+/** Unit suffix for {@link Date} getter methods (e.g., `'FullYear'` in `'getFullYear'`, `'Month'` in `'getMonth'` etc.). */
+type $DateUnit = 'FullYear' | 'Month' | 'Day' | 'Date' | 'Hours' | 'Minutes' | 'Seconds' | 'Milliseconds';
+/** `BCP47` locale string or {@link Intl.Locale} object that contain one or more language or locale tags */
+type $LocalArguments = LooseLiteral<LocaleCode | Split<LocaleCode, '-'>[0]> | Intl.Locale;
+/** `BCP47` locale string, array of locale strings, {@link Intl.Locale} object, or array of {@link Intl.Locale} objects that contain one or more language or locale tags. */
+type LocalesArguments = $LocalArguments | $LocalArguments[];
+/** Locale calendars supported by {@link Intl} API */
+type LocaleCalendar = (typeof LOCALE_CALENDARS)[number];
+/** Locale numbering systems supported by {@link Intl} API */
+type NumberingSystem = (typeof LOCALE_NUMBERING_SYSTEMS)[number];
+//#endregion
+//#region src/types/chronos-specific.d.ts
+/**
+ * * Options for `Chronos` _static_ method `with()`
+ *
+ * @remarks Should provide at least one property, otherwise use the current date and time.
+ */
+type ChronosWithOptions = Partial<{
+  /** The full year (e.g., 2025). Years 0–99 are interpreted as 1900–1999. */year: number; /** Month number from 1 (January) to 12 (December). */
+  month: NumberRange<1, 12>; /** Day of the month, from 1 to 31. */
+  date: NumberRange<1, 31>; /** Hour of the day, from 0 (midnight) to 23 (11 PM). */
+  hour: Enumerate<24>; /** Minutes of the hour, from 0 to 59. */
+  minute: Enumerate<60>; /** Seconds of the minute, from 0 to 59. */
+  second: Enumerate<60>; /** Milliseconds of the second, from 0 to 999. */
+  millisecond: Milliseconds;
+}>;
+/** Interface for accessing internal private properties in extended `Chronos` class */
+interface ChronosInternals {
+  /**
+   * * Access to `#withOrigin` private method.
+   * * Creates a new `Chronos` instance with `origin` and other properties.
+   *
+   * @param instance The `Chronos` instance to which attach the `origin` and other properties.
+   * @param origin Origin of the instance, the method name from where it was created.
+   * @param offset Optional UTC offset in `UTC±HH:mm` format.
+   * @param tzName Optional time zone name to set.
+   * @param tzId Optional time zone identifier(s) to set.
+   * @param tzTracker Optional tracker to identify the instance created by {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/conversion#timezone timeZone} method.
+   * @returns The `Chronos` instance with the specified origin and other properties.
+   */
+  withOrigin(instance: Chronos, method: PluginMethods, offset?: UTCOffset, tzName?: LooseLiteral<TimeZoneName>, tzId?: TimeZoneId, tzTracker?: $TimeZoneIdentifier | TimeZone | UTCOffset): Chronos;
+  /**
+   * * Access to `#toNewDate` private method
+   * * Creates a new `Date` object from a `Chronos` input
+   * @param instance - `Chronos` instance to operate on
+   * @param value - Input value to convert (optional, uses current date if omitted)
+   * @returns A new JavaScript `Date` object
+   */
+  toNewDate(instance: Chronos, value?: ChronosInput): Date;
+  /**
+   * * Gets the internal `#date`, a readonly private property (core `Date` object)
+   * @param instance - `Chronos` instance to access
+   * @returns The core internal `Date` object
+   */
+  internalDate(instance: Chronos): Date;
+  /**
+   * * Gets current UTC Offset internally stored as `#offset` private property
+   * @param instance - `Chronos` instance to access
+   * @returns The stored formatted UTC offset
+   */
+  offset(instance: Chronos): UTCOffset;
+  /** * Ensures the input is a `Chronos` instance, creating one if necessary. */
+  cast(date: ChronosInput): Chronos;
+}
+/** @internal Helper type to assign instance origin when creating new `Chronos` instance. */
+type WithoutOrigin = Omit<Chronos, '#ORIGIN' | 'origin'>;
+/** Alias for `typeof Chronos` */
+type $Chronos = typeof Chronos;
+/** * Instance methods that return `Chronos` instance */
+type $InstanceMethods = { [Method in keyof WithoutOrigin]: Chronos extends { [Instance in Method]: (...args: any[]) => Chronos } ? Method : never }[keyof WithoutOrigin];
+/** * Static methods that return `Chronos` instance */
+type $StaticMethods = { [Method in keyof $Chronos]: $Chronos extends { [Instance in Method]: (...args: any[]) => Chronos } ? Method : never }[keyof $Chronos];
+/** * Plugin methods that return `Chronos` instance */
+type $PluginMethods = 'round' | `timeZone` | 'nextWorkday' | 'nextWeekend' | 'previousWorkday' | 'previousWeekend';
+/** * Plugin methods that return `Chronos` instance + any custom name */
+type PluginMethods = LooseLiteral<$PluginMethods>;
+/** Both instance and static methods (including built-in plugin methods) in `Chronos` class that return `Chronos` instance. */
+type ChronosMethods = $InstanceMethods | $StaticMethods | $PluginMethods;
+/**
+ * * Accepted Input type for `Chronos`
+ *
+ * **Note**: *If a date is provided **without a time component**, the instance will default to `00:00:00.000` UTC
+ * and convert it to the **equivalent local time** using the current environment's UTC offset.*
+ */
+type ChronosInput = number | string | Date | Chronos;
+/** Properties required to reconstruct a `Chronos` instance. */
+interface ChronosProperties {
+  /** The method or plugin name from which the instance was created. */
+  origin: LooseLiteral<ChronosMethods>;
+  /** The native date value, either as a `Date` object or a date string. */
+  native: Date | string;
+  /** The UTC offset in `UTC±HH:mm` format. */
+  utcOffset: UTCOffset;
+  /** The full time zone name (e.g., `"Pacific Standard Time"`). */
+  timeZoneName: LooseLiteral<TimeZoneName>;
+  /** The time zone identifier(s) associated with the instance (e.g., `"Asia/Dhaka"`). */
+  timeZoneId: TimeZoneId;
+  /** Optional tracker to identify the instance created by `timeZone` method. */
+  $tzTracker?: $TimeZoneIdentifier | TimeZone | UTCOffset;
+}
+/** Iterable `Chronos` object properties */
+interface ChronosObject {
+  /** Full year (e.g., 2025). */
+  year: number;
+  /** Month index starting from 0 (January = 0). */
+  month: Enumerate<12>;
+  /** ISO month number starting from 1 (January = 1). */
+  isoMonth: NumberRange<1, 12>;
+  /** Day of the month (1–31). */
+  date: NumberRange<1, 31>;
+  /** Day of the week index (0–6, Sunday = 0). */
+  weekDay: Enumerate<7>;
+  /** ISO day of the week number (1–7, Monday = 1). */
+  isoWeekDay: NumberRange<1, 7>;
+  /** Hour of the day (0–23). */
+  hour: Enumerate<24>;
+  /** Minute of the hour (0–59). */
+  minute: Enumerate<60>;
+  /** Second of the minute (0–59). */
+  second: Enumerate<60>;
+  /** Milliseconds within the second. */
+  millisecond: Milliseconds;
+  /** Timestamp in milliseconds since the Unix epoch. */
+  timestamp: number;
+  /** Unix timestamp in seconds since the epoch. */
+  unix: number;
+}
+/** Common options for formatting and rounding dates */
+interface $CommonRangeOptions {
+  /** - Output format: return ISO strings in `'local'` or `'utc'` format. Defaults to `'local'`. */
+  format?: ISODateFormat;
+  /** - Whether to round the dates in the range to the start of the day. Default is `false`. */
+  roundDate?: boolean;
+}
+/** - Options to define a **fixed date range** using explicit `from` and `to` dates. */
+interface DateRangeOptions extends $CommonRangeOptions {
+  /** - Start date of the range (inclusive). Defaults to **now** if not provided. */
+  from?: ChronosInput;
+  /** - End date of the range (inclusive). Defaults to **4 weeks from now** if not provided. */
+  to?: ChronosInput;
+}
+/** - Options to define a **relative date range** starting from the current date. */
+interface RelativeRangeOptions extends $CommonRangeOptions {
+  /**
+   * The number of time units to move **forward from `now`**.
+   *
+   * - Determines the size of the range.
+   * - `now` → `start`, and `start + span` → `end`.
+   * - Both `start` and `end` are included in the result.
+   * - Controlled by the {@link unit} option.
+   * - Defaults to `4`.
+   */
+  span?: number;
+  /**
+   * The time unit used to advance the range.
+   *
+   * - Works together with {@link span} to calculate the final date range.
+   * - For example: `span: 2, unit: 'week'` → 2-week range.
+   * - Defaults to `'week'`.
+   */
+  unit?: 'year' | 'month' | 'week' | 'day';
+}
+/** - Unified type that supports either a fixed or relative date range configuration. */
+type WeekdayOptions = RelativeRangeOptions | DateRangeOptions;
+/** Common options to either skip or keep days */
+interface $SkipOrKeepDays {
+  /**
+   * An array of weekdays to exclude from the date range.
+   * - Accepts either weekday names (e.g., `'Saturday'`, `'Sunday'`) or numeric indices (0 for Sunday to 6 for Saturday).
+   * - Ignored if {@link onlyDays} is provided.
+   *
+   * @example
+   * skipDays: ['Saturday', 'Sunday']
+   * skipDays: [0, 6] // Sunday and Saturday
+   */
+  skipDays?: Array<WeekDay> | Array<Enumerate<7>>;
+  /**
+   * An array of weekdays to explicitly include in the date range.
+   * - Accepts either weekday names (e.g., `'Monday'`, `'Wednesday'`) or numeric indices (0 for Sunday to 6 for Saturday).
+   * - When provided, this overrides {@link skipDays} and includes only the specified days.
+   *
+   * @example
+   * onlyDays: ['Monday', 'Wednesday']
+   * onlyDays: [1, 3] // Monday and Wednesday
+   */
+  onlyDays?: Array<WeekDay> | Array<Enumerate<7>>;
+}
+/** - Options to define a **fixed date range** using explicit `from` and `to` dates. */
+interface RangeWithDates extends DateRangeOptions, $SkipOrKeepDays {}
+/** - Options to define a **relative date range** starting from the current date. */
+interface RelativeDateRange extends RelativeRangeOptions, $SkipOrKeepDays {}
+/** - Unified type that supports either a fixed or relative date range configuration. */
+type DatesInRangeOptions = RangeWithDates | RelativeDateRange;
+//#endregion
+//#region src/types/chronos-plugins.d.ts
+/** * A plugin that augments the `Chronos` class with methods or properties. */
+type ChronosPlugin = (Chronos: $Chronos) => void;
+/** ISO date-based range (format: `MM-DD`) e.g. `01-14` for 'January 14' */
+type DateBoundary = {
+  /** Start date in `MM-DD` format, e.g. `01-18` means 'January 18' */startDate: MonthDateString; /** End date in `MM-DD` format, e.g. `03-17` means 'March 17' */
+  endDate: MonthDateString;
+};
+/** Inclusive month index-based range `0-11` (0 = January) */
+type MonthBoundary = {
+  startMonth: Enumerate<12>;
+  endMonth: Enumerate<12>;
+};
+/** Season definition for season configuration */
+interface SeasonDefinition {
+  /** Name of the season */
+  name: string;
+  /** Inclusive date/month boundary of the season */
+  boundary: MonthBoundary | DateBoundary;
+}
+/** Name of a predefined season preset */
+type SeasonPreset = keyof typeof SEASON_PRESETS;
+/** Options for configuring seasons */
+interface SeasonOptions {
+  /** Custom season list to override or define seasons manually */
+  seasons?: SeasonDefinition[];
+  /** Predefined preset to use for season calculation */
+  preset?: SeasonPreset;
+}
+interface $BusinessHourBaseOptions {
+  /** - Optional starting hour of business time (0–23). Defaults to `9` (9 AM). */
+  businessStartHour?: Enumerate<24>;
+  /** - Optional ending hour of business time (0–23). Defaults to `17` (5 PM). */
+  businessEndHour?: Enumerate<24>;
+}
+/** Options for configuring business hour with `weekStartsOn` and `weekendLength` */
+interface BusinessOptionsBasic extends $BusinessHourBaseOptions {
+  /** - Optional day the week starts on (0–6). Default is `0` (Sunday). */
+  weekStartsOn?: Enumerate<7>;
+  /** - Optional weekend length (1-4). Default is `2`.*/
+  weekendLength?: NumberRange<1, 4>;
+}
+/** Options for configuring business hour with `weekendDays` tuple */
+interface BusinessOptionsWeekends extends $BusinessHourBaseOptions {
+  /** - Tuple of indices (0-6) of weekend days. Can pass only 1-4 elements. Default is `undefined`. */
+  weekendDays?: RangeTuple<Enumerate<7>, 1, 4>;
+}
+/** Options for configuring business hour */
+type $BusinessHourOptions = BusinessOptionsBasic | BusinessOptionsWeekends;
+/** Names of standard Zodiac signs */
+type ZodiacSign = (typeof WESTERN_ZODIAC_SIGNS)[number][0];
+/** Presets for Zodiac Sign Configuration */
+type ZodiacPreset = keyof typeof ZODIAC_PRESETS;
+/** Shape of Zodiac signs array */
+type ZodiacArray<Sign extends string = ZodiacSign> = Array<[Sign, [NumberRange<1, 12>, NumberRange<1, 31>]] | Readonly<[Sign, Readonly<[NumberRange<1, 12>, NumberRange<1, 31>]>]>>;
+/** Zodiac metadata options */
+interface ZodiacMetaOptions<Sign extends string = ZodiacSign> {
+  /**
+   * Optional Zodiac preset to use. Default is `western`.
+   * - **Note:** `western` and `tropical`, `vedic` and `sidereal` are same.
+   */
+  preset?: ZodiacPreset;
+  /** Custom Zodiac date ranges, overrides {@link preset presets}. */
+  custom?: ZodiacArray<Sign> | Readonly<ZodiacArray<Sign>>;
+}
+/** Options for configuring Zodiac sign getter */
+interface ZodiacOptions<Sign extends string = ZodiacSign> extends ZodiacMetaOptions<Sign> {
+  /** - Optional birthdate in `MM-DD` format (`1`-based month). */
+  birthDate?: MonthDateString;
+}
+/** Represents resolved metadata for a zodiac sign */
+interface ZodiacMeta<Sign extends string = ZodiacSign> {
+  /**
+   * Index (`0`-based) of the zodiac sign within the resolved and chronologically sorted zodiac list.
+   *
+   * ⚠️ **Notes:**
+   * - The `index` is determined by the Gregorian month–day order of zodiac start dates and may differ between variants (e.g. Western vs Vedic).
+   * - This `index` should not be interpreted as a traditional or mythological zodiac ordering.
+   */
+  index: number;
+  /** The zodiac sign name. */
+  sign: Sign;
+  /** Inclusive start date of the zodiac sign in `MM-DD` format. */
+  start: MonthDateString;
+  /** Inclusive end date of the zodiac sign in `MM-DD` format. */
+  end: MonthDateString;
+}
+/** Definition of day part names. */
+type DayPart = (typeof DATE_PARTS)[number];
+/** Object type for extracting day parts. */
+type DayPartConfig = Partial<Record<DayPart, [ClockHour, ClockHour]>>;
+/** Academic year, e.g. `2024-2025` */
+type AcademicYear = `${number}-${number}`;
+/** Return object type of `duration` method of `Chronos`. */
+interface TimeDuration {
+  /** Total number of years. */
+  years: number;
+  /** Number of months remaining after full years are counted. */
+  months: number;
+  /** Number of days remaining after full months are counted. */
+  days: number;
+  /** Number of hours remaining after full days are counted. */
+  hours: number;
+  /** Number of minutes remaining after full hours are counted. */
+  minutes: number;
+  /** Number of seconds remaining after full minutes are counted. */
+  seconds: number;
+  /** Number of milliseconds remaining after full seconds are counted. */
+  milliseconds: number;
+}
+/** Key of {@link TimeDuration} */
+type DurationKey = keyof TimeDuration;
+/** Options for formatting duration string */
+interface DurationOptions {
+  /** The time to compare with. Defaults to `now`. */
+  toTime?: ChronosInput;
+  /** If true, returns all values as positive numbers. Defaults to `true`. */
+  absolute?: boolean;
+  /** Maximum number of units to display, e.g. 2 → "1 hour, 20 minutes" */
+  maxUnits?: NumberRange<1, 7>;
+  /** Separator between units (default: `", "`) */
+  separator?: string;
+  /** Display mode: `"full"` (default) → "2 hours", `"short"` → "2h" */
+  style?: 'full' | 'short';
+  /** Whether to include zero values (default: `false`) */
+  showZero?: boolean;
+}
+//#endregion
+export { ChronosStaticKey as $, BanglaDateOptions as $t, ChronosObject as A, TimeZoneDetails as At, WithoutOrigin as B, ChronosStatics as Bt, $Chronos as C, Numeric as Cn, NumberingSystem as Ct, ChronosInput as D, RangeTuple as Dn, TimeUnitValue as Dt, $StaticMethods as E, LooseLiteral as En, TimeUnit as Et, PluginMethods as F, TimeZoneNameNative as Ft, $NativeTzNameOrId as G, $BanglaYear as Gt, $GMTOffset as H, chronos as Ht, RangeWithDates as I, TimestampOptions as It, $TimeUnitVar as J, $BnMonthPadded as Jt, $TZLabelKey as K, $BnDatePadded as Kt, RelativeDateRange as L, UTCMinute as Lt, ChronosWithOptions as M, TimeZoneIdNative as Mt, DateRangeOptions as N, TimeZoneIdentifier as Nt, ChronosInternals as O, TimeWithUnit as Ot, DatesInRangeOptions as P, TimeZoneName as Pt, $UnitAnyCase as Q, BanglaDateObject as Qt, RelativeRangeOptions as R, UTCOffset as Rt, ZodiacSign as S, Maybe as Sn, NegativeUTCHour as St, $PluginMethods as T, NumberRange as Tn, Quarter as Tt, $ISOTimeString as U, $BanglaMonth as Ut, $DateUnit as V, Chronos as Vt, $LocalArguments as W, $BanglaMonthDate as Wt, $TimeZoneIdentifier as X, BanglaDate as Xt, $TimeUnitVarMap as Y, $BnYearPadded as Yt, $UTCOffset as Z, BanglaDateFormat as Zt, ZodiacArray as _, StrictFormat as _n, LocalesArguments as _t, BusinessOptionsWeekends as a, BnCalendarConfig as an, DateFormatOptions as at, ZodiacOptions as b, TimeToken as bn, MonthName as bt, DayPart as c, DateFormatToken as cn, DateTimeFormatOptions as ct, DurationOptions as d, FormatToken as dn, GreetingConfigs as dt, BanglaDayName as en, ClockHour as et, MonthBoundary as f, HourToken as fn, HourMinutes as ft, TimeDuration as g, SecondToken as gn, LocaleCalendar as gt, SeasonPreset as h, MonthToken as hn, ISOTimeString as ht, BusinessOptionsBasic as i, BanglaYear as in, DateArgs as it, ChronosProperties as j, TimeZoneId as jt, ChronosMethods as k, TimeZone as kt, DayPartConfig as l, DateToken as ln, FormatOptions as lt, SeasonOptions as m, MinuteToken as mn, ISODateTimeString as mt, $BusinessHourOptions as n, BanglaMonthName as nn, ClockSecond as nt, ChronosPlugin as o, BnCalendarVariant as on, DateLike as ot, SeasonDefinition as p, MSToken as pn, ISODateFormat as pt, $TimeUnitKey as q, $BnEn as qt, AcademicYear as r, BanglaSeasonName as rn, ClockTime as rt, DateBoundary as s, DateWithSeasonToken as sn, DateString as st, $BusinessHourBaseOptions as t, BanglaMonth as tn, ClockMinute as tt, DurationKey as u, DayToken as un, FromNowUnit as ut, ZodiacMeta as v, TimeFormatToken as vn, Milliseconds as vt, $InstanceMethods as w, Enumerate as wn, PositiveUTCHour as wt, ZodiacPreset as x, YearToken as xn, MonthString as xt, ZodiacMetaOptions as y, TimeOnlyFormat as yn, MonthDateString as yt, WeekdayOptions as z, WeekDay as zt };