chronos-date 1.0.2 → 1.1.1

package/dist/index.mjs

@@ -1 +1,1474 @@
-import{c as e,o as t,s as n,u as r}from"./basic-e46DaNAi.mjs";import{i,r as a}from"./primitives-Cxss_JVF.mjs";import{t as o}from"./non-primitives-B2EE6D6s.mjs";import{isLeapYear as s}from"./guards.mjs";import{c,n as l,p as u,r as d,u as f}from"./helpers-N1X_Rj_V.mjs";import{l as p,r as m}from"./utilities-DV_ohS37.mjs";const h=(e,t,n,r,i,o,s)=>a(e)&&a(t)?new v(e,t,n??1,r??0,i??0,o??0,s??0):new v(e);function g(e){return e in v&&e!==`prototype`&&e!==`name`&&e!==`length`&&o(v[e])}const _=new Proxy(h,{get(e,t,n){return t in e?Reflect.get(e,t,n):g(t)?v[t]:Reflect.get(e,t,n)},has(e,t){return t in e||g(t)}});var v=class o{#e;#t;#n;static#r=new Set;static[n]={internalDate(e){return e.#e},offset(e){return e.#t},withOrigin(e,t,n,r,i,a){return e.#o(t,n,r,i,a)},toNewDate(e,t){return e.#a(t)},cast(e){return o.#u(e)}};origin;native;utcOffset;timeZoneName;timeZoneId;$tzTracker;constructor(e,t,n,r,i,o,s){a(e)&&a(t)?(this.#e=new Date(e,t-1,n??1,r??0,i??0,o??0,s??0),this.native=this.#e):(this.#e=this.#a(e),this.native=this.#e),this.#n=`root`,this.origin=this.#n,this.#t=`UTC${this.getUTCOffset()}`,this.utcOffset=this.#t,this.timeZoneName=this.$getNativeTimeZoneName(),this.timeZoneId=this.$getNativeTimeZoneId()}*[Symbol.iterator](){yield[`year`,this.year],yield[`month`,this.month],yield[`isoMonth`,this.isoMonth],yield[`date`,this.date],yield[`weekDay`,this.weekDay],yield[`isoWeekDay`,this.isoWeekDay],yield[`hour`,this.hour],yield[`minute`,this.minute],yield[`second`,this.second],yield[`millisecond`,this.millisecond],yield[`timestamp`,this.getTimeStamp()],yield[`unix`,this.unix]}[Symbol.toPrimitive](e){return e===`number`?this.getTimeStamp():this.toLocalISOString()}[Symbol.replace](e,t){return e.replace(this.#l(),t)}[Symbol.search](e){return e.indexOf(this.#l())}[Symbol.split](e){return e.split(this.#l())}[Symbol.match](e){let[t,n]=this.toLocalISOString().split(`.`)[0].split(`T`),r=t.replace(/-/g,`[-/]?`),i=n?.replace(/:/g,`[:.]?`),a=n?`${r}(?:[T ]?${i})?`:r;return e.match(new RegExp(a))}get[Symbol.toStringTag](){return this.toLocalISOString()}get[Symbol.isConcatSpreadable](){return!0}$getNativeTimeZoneName(e){let t=e||p();return u(t,`long`,this.#e)??t}$getNativeTimeZoneId(){return p()}get#i(){return this.#e.getTime()}#a(e){let t=e instanceof o?e.toDate():l(e);if(isNaN(t.getTime()))throw Error(`Provided date is invalid!`);return t}#o(e,t,n,r,i){let a=new o(this.#e);return a.#n=e,a.origin=e,t&&(a.#t=t,a.utcOffset=t),n&&(a.timeZoneName=n),r&&(a.timeZoneId=r),i&&(a.$tzTracker=i),a.native=a.toDate(),a}#s(e,t){return e.#o(t,this.#t,this.timeZoneName,this.timeZoneId,this.$tzTracker)}#c(e,t=!1){let n=this.#e,r=this.toDate(),i=e=>t?r[`getUTC${e}`]():n[`get${e}`]();return d(e,i(`FullYear`),i(`Month`),i(`Day`),i(`Date`),i(`Hours`),i(`Minutes`),i(`Seconds`),i(`Milliseconds`),t?`Z`:this.getTimeZoneOffset())}#l(e=!0){let t=/\.\d+(Z|[+-]\d{2}:\d{2})?$/;return e?this.toLocalISOString().replace(t,``):this.toISOString().replace(t,``)}get year(){return this.#e.getFullYear()}get month(){return this.#e.getMonth()}get date(){return this.#e.getDate()}get weekDay(){return this.#e.getDay()}get hour(){return this.#e.getHours()}get minute(){return this.#e.getMinutes()}get second(){return this.#e.getSeconds()}get millisecond(){return this.#e.getMilliseconds()}get isoWeekDay(){let e=this.weekDay;return e===0?7:e}get isoMonth(){return this.month+1}get unix(){return Math.floor(this.getTimeStamp()/1e3)}get timestamp(){return this.getTimeStamp()}get lastDateOfMonth(){return this.daysInMonth()}inspect(){return`[Chronos ${this.toLocalISOString()}]`}toJSON(){return this.toLocalISOString()}valueOf(){return this.getTimeStamp()}clone(){return new o(this.#e).#o(this.#n,this.#t,this.timeZoneName,this.timeZoneId,this.$tzTracker)}toDate(){let e=(m(this.#t)-this.getUTCOffsetMinutes())*6e4;return new Date(this.#i-e)}toString(){return this.#c(`dd mmm DD YYYY HH:mm:ss `).concat(this.#t.replace(`UTC`,`GMT`).replace(`:`,``)).concat(` (${this.timeZoneName})`)}toLocalISOString(){return this.#c(`YYYY-MM-DDTHH:mm:ss.mssZZ`)}toISOString(){return this.toDate().toISOString()}toLocaleString(e,t){return this.#e.toLocaleString(e,t)}getTimeStamp(){return this.toDate().getTime()}format(e,t=!1){return this.#c(e||`dd, mmm DD, YYYY HH:mm:ss`,t)}formatStrict(e,t=!1){return this.#c(e||`dd, mmm DD, YYYY HH:mm:ss`,t)}formatUTC(e=`dd, mmm DD, YYYY HH:mm:ss:mss`){return this.#c(e,!0)}addSeconds(e){return this.#s(this.add(e,`second`),`addSeconds`)}addMinutes(e){return this.#s(this.add(e,`minute`),`addMinutes`)}addHours(e){return this.#s(this.add(e,`hour`),`addHours`)}addDays(e){return this.#s(this.add(e,`day`),`addDays`)}addWeeks(e){return this.#s(this.add(e,`week`),`addWeeks`)}addMonths(e){return this.#s(this.add(e,`month`),`addMonths`)}addYears(e){return this.#s(this.add(e,`year`),`addYears`)}isLeapYear(e){return s(e??this.year)}isEqual(e){return this.#i===o.#u(e).#i}isEqualOrBefore(e){return this.#i<=o.#u(e).#i}isEqualOrAfter(e){return this.#i>=o.#u(e).#i}isSame(e,t,n=0){return this.startOf(t,n).#i===o.#u(e).startOf(t,n).#i}isBefore(e,t,n=0){return this.startOf(t,n).#i<o.#u(e).startOf(t,n).#i}isAfter(e,t,n=0){return this.startOf(t,n).#i>o.#u(e).startOf(t,n).#i}isSameOrBefore(e,t,n=0){return this.isSame(e,t,n)||this.isBefore(e,t,n)}isSameOrAfter(e,t,n=0){return this.isSame(e,t,n)||this.isAfter(e,t,n)}isBetween(e,t,n=`()`){let r=o.#u(e).getTimeStamp(),i=o.#u(t).getTimeStamp(),a=this.getTimeStamp();switch(n){case`[]`:return a>=r&&a<=i;case`[)`:return a>=r&&a<i;case`(]`:return a>r&&a<=i;case`()`:return a>r&&a<i;default:return!1}}isDST(){let e=this.year,t=new Date(e,0,1).getTimezoneOffset(),n=new Date(e,6,1).getTimezoneOffset();return this.#e.getTimezoneOffset()<Math.max(t,n)}isFirstDayOfMonth(){return this.isSame(this.firstDayOfMonth(),`day`)}isLastDayOfMonth(){return this.isSame(this.lastDayOfMonth(),`day`)}firstDayOfMonth(){let e=new Date(this.year,this.month,1);return this.#s(new o(e),`firstDayOfMonth`)}lastDayOfMonth(){let e=new Date(this.year,this.month+1,0);return this.#s(new o(e),`lastDayOfMonth`)}startOf(e,t=0){let n=new Date(this.#e);switch(e){case`year`:n.setMonth(0,1),n.setHours(0,0,0,0);break;case`month`:n.setDate(1),n.setHours(0,0,0,0);break;case`week`:{let e=(n.getDay()-t+7)%7;n.setDate(n.getDate()-e),n.setHours(0,0,0,0);break}case`day`:n.setHours(0,0,0,0);break;case`hour`:n.setMinutes(0,0,0);break;case`minute`:n.setSeconds(0,0);break;case`second`:n.setMilliseconds(0);break;case`millisecond`:break}return this.#s(new o(n),`startOf`)}endOf(e,t=0){let n=this.startOf(e,t).add(1,e).add(-1,`millisecond`);return this.#s(n,`endOf`)}add(e,t){let n=new Date(this.#e);switch(t){case`millisecond`:n.setMilliseconds(n.getMilliseconds()+e);break;case`second`:n.setSeconds(n.getSeconds()+e);break;case`minute`:n.setMinutes(n.getMinutes()+e);break;case`hour`:n.setHours(n.getHours()+e);break;case`day`:n.setDate(n.getDate()+e);break;case`week`:n.setDate(n.getDate()+e*7);break;case`month`:n.setMonth(n.getMonth()+e);break;case`year`:n.setFullYear(n.getFullYear()+e);break}return this.#s(new o(n),`add`)}subtract(e,t){return this.#s(this.add(-e,t),`subtract`)}get(e){switch(e){case`year`:return this.year;case`month`:return this.isoMonth;case`day`:return this.date;case`week`:return this.getWeek();case`hour`:return this.hour;case`minute`:return this.minute;case`second`:return this.second;case`millisecond`:return this.millisecond}}set(e,t){let n=new Date(this.#e);switch(e){case`year`:n.setFullYear(t);break;case`month`:n.setMonth(t-1);break;case`day`:n.setDate(t);break;case`week`:return this.setWeek(t);case`hour`:n.setHours(t);break;case`minute`:n.setMinutes(t);break;case`second`:n.setSeconds(t);break;case`millisecond`:n.setMilliseconds(t);break}return this.#s(new o(n),`set`)}diff(e,t){let n=o.#u(e),r=this.#i-n.#i;switch(t){case`millisecond`:return r;case`second`:return r/1e3;case`minute`:return r/6e4;case`hour`:return r/36e5;case`day`:return r/864e5;case`week`:return r/6048e5;case`month`:{let e=this.year-n.year,t=this.month-n.month;return e*12+t+(this.date-n.date)/this.daysInMonth()}case`year`:return this.diff(n,`month`)/12}}calendar(e){let t=e?o.#u(e):new o,n=this.startOf(`day`),r=t.startOf(`day`),i=n.diff(r,`day`),a=this.toDate().toLocaleString(`en`,{hour:`numeric`,minute:`2-digit`});return i===0?`Today at ${a}`:i===1?`Tomorrow at ${a}`:i===-1?`Yesterday at ${a}`:this.toDate().toLocaleString(`en`,{month:`long`,day:`2-digit`,year:`numeric`,weekday:`long`,hour:`numeric`,minute:`2-digit`})}fromNowShort(){let e=new o,t=this.diff(e,`second`),n=Math.abs(t),r=t>=0?`in `:``,i=t<0?` ago`:``;return n<60?`${r}${Math.floor(n)}s${i}`:n<3600?`${r}${Math.floor(n/60)}m${i}`:n<86400?`${r}${Math.floor(n/3600)}h${i}`:n<2592e3?`${r}${Math.floor(n/86400)}d${i}`:n<31536e3?`${r}${Math.floor(n/2592e3)}mo${i}`:`${r}${Math.floor(n/31536e3)}y${i}`}setWeek(e){let t=new Date(this.#e),n=t.getFullYear(),r=new Date(n,0,4),i=r.getDay()||7,a=new Date(r);return a.setDate(r.getDate()-(i-1)),a.setDate(a.getDate()+(e-1)*7),t.setFullYear(a.getFullYear()),t.setMonth(a.getMonth()),t.setDate(a.getDate()),this.#s(new o(t),`setWeek`)}getWeek(){let e=this.startOf(`week`,1).add(3,`day`),t=new o(e.year,1,4).startOf(`week`,1).add(3,`day`);return e.diff(t,`week`)+1}getWeekOfYear(e=0){let t=this.startOf(`year`).startOf(`week`,e);return this.startOf(`week`,e).diff(t,`week`)+1}getWeekYear(e=0){return this.startOf(`week`,e).add(3,`day`).year}getDayOfYear(){return this.startOf(`day`).diff(this.startOf(`year`),`day`)+1}daysInMonth(){return new Date(this.year,this.month+1,0).getDate()}toObject(){return Object.fromEntries([...this])}toArray(){return Object.values(this.toObject())}toQuarter(){let e=this.#e.getMonth();return Math.floor(e/3)+1}getUTCOffset(){let e=-this.#e.getTimezoneOffset(),t=e>=0?`+`:`-`,n=e=>String(Math.floor(Math.abs(e))).padStart(2,`0`);return`${t}${n(e/60)}:${n(e%60)}`}getTimeZoneOffset(){return this.#t.replace(`UTC`,``)}getUTCOffsetMinutes(){return-this.#e.getTimezoneOffset()}getTimeZoneOffsetMinutes(){return m(this.#t)}toUTC(){let e=this.getTimeZoneOffsetMinutes();return new o(new Date(this.#i-e*60*1e3)).#o(`toUTC`,`UTC+00:00`,`Greenwich Mean Time`,`UTC`)}toLocal(){let e=this.getTimeZoneOffsetMinutes()-this.getUTCOffsetMinutes();return new o(new Date(this.#i-e*60*1e3)).#o(`toLocal`)}day(e){return t[e??this.weekDay]}monthName(t){return e[t??this.month]}static parse(e,t){let n={YYYY:`(?<YYYY>\\d{4})`,YY:`(?<YY>\\d{2})`,MM:`(?<MM>\\d{2})`,M:`(?<M>\\d{1,2})`,DD:`(?<DD>\\d{2})`,D:`(?<D>\\d{1,2})`,HH:`(?<HH>\\d{2})`,H:`(?<H>\\d{1,2})`,mm:`(?<mm>\\d{2})`,m:`(?<m>\\d{1,2})`,ss:`(?<ss>\\d{2})`,s:`(?<s>\\d{1,2})`,mss:`(?<mss>\\d{3})`,ms:`(?<ms>\\d{1,3})`},r={YYYY:`year`,YY:`year`,MM:`month`,M:`month`,DD:`date`,D:`date`,HH:`hour`,H:`hour`,mm:`minute`,m:`minute`,ss:`second`,s:`second`,mss:`millisecond`,ms:`millisecond`},i=new RegExp(Object.keys(n).sort((e,t)=>t.length-e.length).join(`|`),`g`),a=t?.trim()?.replace(i,e=>n[e]??e)?.replace(/\s+/g,`\\s*`),s=RegExp(`^${a}\\s*$`).exec(e.trim());if(!s?.groups)throw Error(`Invalid date format!`);let c={};for(let[e,t]of Object.entries(s.groups)){let n=r[e];if(n){let r=Number(t);e===`YY`&&(r+=r<100?2e3:0),c[n]=r}}return new o(c?.year??1970,c?.month??1,c?.date??1,c?.hour??0,c?.minute??0,c?.second??0,c?.millisecond??0).#o(`parse`)}static with(e){let t=new o,{year:n,month:r,date:i,hour:a,minute:s,second:c,millisecond:l}=e??{},u=()=>t.startOf(`month`).set(`year`,n??t.year).set(`month`,r??t.isoMonth).lastDateOfMonth;return new o(n??t.year,r??t.isoMonth,i||(t.isLastDayOfMonth()&&t.date>=u()?u():t.date),a??t.hour,s??t.minute,c??t.second,l??t.millisecond).#o(`with`)}static today(e){let{format:t=`dd, mmm DD, YYYY HH:mm:ss`,useUTC:n=!1}=e||{};return new o().#c(t,n)}static yesterday(){let e=new Date;return new o(e.setDate(e.getDate()-1)).#o(`yesterday`)}static tomorrow(){let e=new Date;return new o(e.setDate(e.getDate()+1)).#o(`tomorrow`)}static now(){return Date.now()}static utc(e){let t=new o(e),n=t.getTimeZoneOffsetMinutes();return new o(new Date(t.#i-n*60*1e3)).#o(`utc`,`UTC+00:00`,`Greenwich Mean Time`,`UTC`)}static formatTimePart(e,t){return new o(`${new o().#c(`YYYY-MM-DD`)}T${f(e)}`).#c(t||`hh:mm:ss a`)}static getDatesForDay(e,n){let i=new o,a=i.addWeeks(4),{format:s=`local`,roundDate:c=!1}=n??{};if(n){if(`from`in n||`to`in n)n?.from&&(i=o.#u(n?.from)),n?.to&&(a=o.#u(n?.to));else if(`span`in n||`unit`in n){let{span:e=4,unit:t=`week`}=n??{};a=i.add(e,t)}}c&&(i=i.startOf(`day`),a=a.startOf(`day`));let l=[],u=(i.isBefore(a,`day`)?1:-1)*r,d=Math.abs(a.diff(i,`day`)),f=i.#i,p=0;for(;new Date(f+p*u).getDay()!==t.indexOf(e);)p++;for(let e=p;e<=d;e+=7){let t=new o(f+e*u).#o(`clone`,i.#t,i.timeZoneName,i.timeZoneId,i.$tzTracker);l.push(s===`local`?t.toLocalISOString():t.toISOString())}return l}static min(...e){let t=o.#u(e[0]);for(let n of e){let e=o.#u(n);e.getTimeStamp()<t.getTimeStamp()&&(t=e)}return t.#s(t,t.#n===`root`?`min`:t.#n)}static max(...e){let t=o.#u(e[0]);for(let n of e){let e=o.#u(n);e.getTimeStamp()>t.getTimeStamp()&&(t=e)}return t.#s(t,t.#n===`root`?`max`:t.#n)}static isLeapYear(e){let t;return t=a(e)?e>0&&e<=9999?e:new Date(e).getFullYear():o.#u(e).year,s(t)}static isValidDate(e){return e instanceof Date}static isDateString(e){return i(e)&&!isNaN(Date.parse(e))}static isValidChronos(e){return e instanceof o}static isReconstructable(e){return c(e)}static reconstruct(e){if(!c(e))throw TypeError(`Invalid input for reconstruction!`);let{native:t,origin:n,utcOffset:r,timeZoneName:i,timeZoneId:a,$tzTracker:s}=e,l=m(r),u=new o(t),d=u.getTimeZoneOffsetMinutes()-l;return(u.utcOffset===r?u:u.add(-d,`minute`)).#o(n,r,i,a,s)}static use(e){o.#r.has(e)||(o.#r.add(e),e(o))}static register(e){o.use(e)}static#u(e){return e instanceof o?e:new o(e)}};export{v as Chronos,n as INTERNALS,_ as chronos};
+/**
+ * Copyright 2026 - present Nazmul Hassan
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { c as MONTHS, o as DAYS, s as INTERNALS, u as MS_PER_DAY } from "./basic-DqKyujoj.mjs";
+import { r as isNumber } from "./primitives-dXzXlzJw.mjs";
+import { t as isFunction } from "./non-primitives-DBtomDty.mjs";
+import { isDateString, isLeapYear } from "./guards.mjs";
+import { c as _hasChronosProperties, n as _dateArgsToDate, p as _resolveNativeTzName, r as _formatDate, u as _normalizeOffset } from "./helpers-DEf4sevD.mjs";
+import { l as getNativeTimeZoneId, r as extractMinutesFromUTC } from "./utilities-BGX8dviZ.mjs";
+
+//#region src/utils/chronos-fn.ts
+/**
+* * 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.
+* The following types of input are supported:
+*
+* - **`string`**: A string representing a date, which can be parsed by the JavaScript `Date` constructor.
+*   Example: `"2023-12-31"`.
+* - **`number`**: A timestamp representing the number of milliseconds since the Unix epoch.
+*   Example: `1672531199000`.
+* - **`Date`**: A JavaScript `Date` object.
+* - **`Chronos`**: A `Chronos` instance created by the same constructor.
+* - **`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). It is adjusted internally to a 0-based index (0 for January, 11 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.
+*
+* This function also allows you to access static methods from the `Chronos` class, as it copies all static methods from `Chronos` to the `chronos` function itself.
+* Therefore, static methods can be called either through the `Chronos` class directly or through the `chronos` function.
+*
+* @example
+* const chronosInstanceFn = chronos("2023-12-31");
+* const chronosInstanceClass = new Chronos("2023-12-31");
+* const sameInstanceFn = chronos.parse("2023-12-31", "YYYY-MM-DD");
+* const sameInstanceClass = Chronos.parse("2023-12-31", "YYYY-MM-DD");
+*
+* @param valueOrYear The value in number, string, Date or Chronos format or the full year designation is required for cross-century date accuracy. If year is between 0 and 99 is used, then 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 new `Chronos` instance representing the provided date with all `Chronos` methods and properties.
+*
+* @remarks
+* - Static methods can be accessed from both the `Chronos` class and the `chronos` function.
+* - Static methods from the `Chronos` class are copied over to the `chronos` wrapper function, so you can call them like:
+* ```ts
+* chronos.parse("2023-12-31", "YYYY-MM-DD");
+* // Or
+* Chronos.parse("2023-12-31", "YYYY-MM-DD");
+* ```
+*/
+const $chronos = (valueOrYear, month, date, hours, minutes, seconds, ms) => {
+	if (isNumber(valueOrYear) && isNumber(month)) return new Chronos(valueOrYear, month, date ?? 1, hours ?? 0, minutes ?? 0, seconds ?? 0, ms ?? 0);
+	else return new Chronos(valueOrYear);
+};
+/**
+* @internal Type guard to check if a property is a static method of the `Chronos` class.
+*
+* @param prop - The property name to check.
+* @returns `true` if the property is a static method of `Chronos`, `false` otherwise.
+*/
+function _isChronosStaticKey(prop) {
+	return prop in Chronos && prop !== "prototype" && prop !== "name" && prop !== "length" && isFunction(Chronos[prop]);
+}
+/**
+* * 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;
+* ```
+*/
+const chronos = new Proxy($chronos, {
+	get(target, prop, receiver) {
+		if (prop in target) return Reflect.get(target, prop, receiver);
+		if (_isChronosStaticKey(prop)) return Chronos[prop];
+		return Reflect.get(target, prop, receiver);
+	},
+	has(target, prop) {
+		return prop in target || _isChronosStaticKey(prop);
+	}
+});
+
+//#endregion
+//#region src/index.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.
+*/
+var Chronos = class Chronos {
+	#date;
+	#offset;
+	#ORIGIN;
+	static #plugins = /* @__PURE__ */ new Set();
+	/** Use `readonly and/or private` methods outside `Chronos`. Purpose: Plugin creation. */
+	static [INTERNALS] = {
+		internalDate(instance) {
+			return instance.#date;
+		},
+		offset(instance) {
+			return instance.#offset;
+		},
+		withOrigin(instance, method, offset, tzName, tzId, tzTracker) {
+			return instance.#withOrigin(method, offset, tzName, tzId, tzTracker);
+		},
+		toNewDate(instance, value) {
+			return instance.#toNewDate(value);
+		},
+		cast(date) {
+			return Chronos.#cast(date);
+		}
+	};
+	/** Origin of the `Chronos` instance (Method that created `new Chronos`), useful for tracking instance. */
+	origin;
+	/**
+	* * `Chronos` date/time as Native JS `Date` object.
+	*
+	* - Also accessible via {@link toDate} instance method.
+	*/
+	native;
+	/**
+	* * 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;
+	/**
+	* 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;
+	/**
+	* 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;
+	/** Tracker to identify the instance created by {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/conversion#timezone timeZone} method */
+	$tzTracker;
+	/**
+	* * 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 valueOrYear The value in `number`, `string`, `Date` or `Chronos` format or 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 (1: January to 12: 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(valueOrYear, month, date, hours, minutes, seconds, ms) {
+		if (isNumber(valueOrYear) && isNumber(month)) {
+			this.#date = new Date(valueOrYear, month - 1, date ?? 1, hours ?? 0, minutes ?? 0, seconds ?? 0, ms ?? 0);
+			this.native = this.#date;
+		} else {
+			this.#date = this.#toNewDate(valueOrYear);
+			this.native = this.#date;
+		}
+		this.#ORIGIN = "root";
+		this.origin = this.#ORIGIN;
+		this.#offset = `UTC${this.getUTCOffset()}`;
+		this.utcOffset = this.#offset;
+		this.timeZoneName = this.$getNativeTimeZoneName();
+		this.timeZoneId = this.$getNativeTimeZoneId();
+	}
+	*[Symbol.iterator]() {
+		yield ["year", this.year];
+		yield ["month", this.month];
+		yield ["isoMonth", this.isoMonth];
+		yield ["date", this.date];
+		yield ["weekDay", this.weekDay];
+		yield ["isoWeekDay", this.isoWeekDay];
+		yield ["hour", this.hour];
+		yield ["minute", this.minute];
+		yield ["second", this.second];
+		yield ["millisecond", this.millisecond];
+		yield ["timestamp", this.getTimeStamp()];
+		yield ["unix", this.unix];
+	}
+	[Symbol.toPrimitive](hint) {
+		if (hint === "number") return this.getTimeStamp();
+		return this.toLocalISOString();
+	}
+	[Symbol.replace](string, replacement) {
+		return string.replace(this.#removeUTCFromISO(), replacement);
+	}
+	[Symbol.search](string) {
+		return string.indexOf(this.#removeUTCFromISO());
+	}
+	[Symbol.split](string) {
+		return string.split(this.#removeUTCFromISO());
+	}
+	[Symbol.match](string) {
+		const [datePart, timePart] = this.toLocalISOString().split(".")[0].split("T");
+		const fuzzyDate = datePart.replace(/-/g, "[-/]?");
+		const fuzzyTime = timePart?.replace(/:/g, "[:.]?");
+		const pattern = timePart ? `${fuzzyDate}(?:[T ]?${fuzzyTime})?` : fuzzyDate;
+		return string.match(new RegExp(pattern));
+	}
+	get [Symbol.toStringTag]() {
+		return this.toLocalISOString();
+	}
+	get [Symbol.isConcatSpreadable]() {
+		return true;
+	}
+	/**
+	* @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) {
+		const $tzId = tzId || getNativeTimeZoneId();
+		return _resolveNativeTzName($tzId, "long", this.#date) ?? $tzId;
+	}
+	/**
+	* @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() {
+		return getNativeTimeZoneId();
+	}
+	/** Get timestamp (milliseconds since midnight, January 1, 1970 UTC) of the current instance, not the true `Date`. */
+	get #timestamp() {
+		return this.#date.getTime();
+	}
+	/**
+	* @private Method to create native `Date` instance from date-like data types.
+	* @param value The value to convert into `Date`.
+	* @returns Instance of native `Date` object.
+	*/
+	#toNewDate(value) {
+		const date = value instanceof Chronos ? value.toDate() : _dateArgsToDate(value);
+		if (isNaN(date.getTime())) throw new Error("Provided date is invalid!");
+		return date;
+	}
+	/**
+	* @private Method to tag origin and other properties to the `Chronos` instance.
+	*
+	* @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(origin, offset, tzName, tzId, tzTracker) {
+		const instance = new Chronos(this.#date);
+		instance.#ORIGIN = origin;
+		instance.origin = origin;
+		if (offset) {
+			instance.#offset = offset;
+			instance.utcOffset = offset;
+		}
+		if (tzName) instance.timeZoneName = tzName;
+		if (tzId) instance.timeZoneId = tzId;
+		if (tzTracker) instance.$tzTracker = tzTracker;
+		instance.native = instance.toDate();
+		return instance;
+	}
+	/**
+	* @private Method to pass all the current states to the provided `Chronos` instance.
+	* @param instance States to pass to the `Chronos` instance.
+	* @param origin Origin of the instates (which method created the instance).
+	* @returns The provided instance with all the current states.
+	*/
+	#cloneStates(instance, origin) {
+		return instance.#withOrigin(origin, this.#offset, this.timeZoneName, this.timeZoneId, this.$tzTracker);
+	}
+	/**
+	* @private Formats the current `Chronos` date using the specified template.
+	*
+	* @param format - The desired date format.
+	* @param useUTC - Whether to use UTC or local time.
+	* @returns Formatted date string.
+	*/
+	#format(format, useUTC = false) {
+		const $date = this.#date;
+		const $utcDate = this.toDate();
+		/** Get unit value for {@link $date} or {@link $utcDate} for specific unit */
+		const _getUnitValue = (suffix) => {
+			return useUTC ? $utcDate[`getUTC${suffix}`]() : $date[`get${suffix}`]();
+		};
+		return _formatDate(format, _getUnitValue("FullYear"), _getUnitValue("Month"), _getUnitValue("Day"), _getUnitValue("Date"), _getUnitValue("Hours"), _getUnitValue("Minutes"), _getUnitValue("Seconds"), _getUnitValue("Milliseconds"), useUTC ? "Z" : this.getTimeZoneOffset());
+	}
+	/**
+	* @private Returns ISO string for the current date with removed timezone/utc part.
+	* @param local Whether to use {@link toLocalISOString()} method or not. Defaults to `true`.
+	* @returns Modified ISO string for the current date with removed timezone/utc part.
+	*/
+	#removeUTCFromISO(local = true) {
+		const search = /\.\d+(Z|[+-]\d{2}:\d{2})?$/;
+		return local ? this.toLocalISOString().replace(search, "") : this.toISOString().replace(search, "");
+	}
+	/** Gets the full year of the date. */
+	get year() {
+		return this.#date.getFullYear();
+	}
+	/** Gets the month (0-11) of the date. */
+	get month() {
+		return this.#date.getMonth();
+	}
+	/** Gets the day of the month (1-31). */
+	get date() {
+		return this.#date.getDate();
+	}
+	/** Gets the day of the week (0-6, where 0 is Sunday). */
+	get weekDay() {
+		return this.#date.getDay();
+	}
+	/** Gets the hour (0-23) of the date. */
+	get hour() {
+		return this.#date.getHours();
+	}
+	/** Gets the minute (0-59) of the date. */
+	get minute() {
+		return this.#date.getMinutes();
+	}
+	/** Gets the second (0-59) of the date. */
+	get second() {
+		return this.#date.getSeconds();
+	}
+	/** Gets the millisecond (0-999) of the date. */
+	get millisecond() {
+		return this.#date.getMilliseconds();
+	}
+	/** Gets ISO weekday: 1 = Monday, 7 = Sunday */
+	get isoWeekDay() {
+		const day = this.weekDay;
+		return day === 0 ? 7 : day;
+	}
+	/** Gets ISO month (1–12 instead of 0–11) */
+	get isoMonth() {
+		return this.month + 1;
+	}
+	/** Returns the Unix timestamp (seconds since the Unix epoch: January 1, 1970, UTC). */
+	get unix() {
+		return Math.floor(this.getTimeStamp() / 1e3);
+	}
+	/** Gets the time value in milliseconds since midnight, January 1, 1970 UTC. */
+	get timestamp() {
+		return this.getTimeStamp();
+	}
+	/** * Gets the last date (number) of the current month `(28, 29, 30 or 31)`. */
+	get lastDateOfMonth() {
+		return this.daysInMonth();
+	}
+	/** @instance Returns a debug-friendly string for `console.log` or `util.inspect`. */
+	inspect() {
+		return `[Chronos ${this.toLocalISOString()}]`;
+	}
+	/** @instance Enables `JSON.stringify` to show readable output. Calls {@link toLocalISOString} method. */
+	toJSON() {
+		return this.toLocalISOString();
+	}
+	/** @instance Enables arithmetic and comparison operations (e.g., `+new Chronos()`). Calls {@link getTimeStamp} method. */
+	valueOf() {
+		return this.getTimeStamp();
+	}
+	/** @instance Clones and returns exactly same `Chronos` instance. */
+	clone() {
+		return new Chronos(this.#date).#withOrigin(this.#ORIGIN, this.#offset, this.timeZoneName, this.timeZoneId, this.$tzTracker);
+	}
+	/** @instance Gets the native `Date` instance of the current `Chronos`. */
+	toDate() {
+		const adjustmentMs = (extractMinutesFromUTC(this.#offset) - this.getUTCOffsetMinutes()) * 6e4;
+		return new Date(this.#timestamp - adjustmentMs);
+	}
+	/** @instance Returns a string representation of a date. */
+	toString() {
+		return this.#format("dd mmm DD YYYY HH:mm:ss ").concat(this.#offset.replace("UTC", "GMT").replace(":", "")).concat(` (${this.timeZoneName})`);
+	}
+	/** @instance Returns ISO time string in appropriate time zone with offset. */
+	toLocalISOString() {
+		return this.#format("YYYY-MM-DDTHH:mm:ss.mssZZ");
+	}
+	/** @instance Returns a date as a string value in ISO format (UTC). */
+	toISOString() {
+		return this.toDate().toISOString();
+	}
+	/**
+	* @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, options) {
+		return this.#date.toLocaleString(locales, options);
+	}
+	/** @instance Returns the time value in milliseconds since midnight, January 1, 1970 UTC. */
+	getTimeStamp() {
+		return this.toDate().getTime();
+	}
+	/**
+	* @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, useUTC = false) {
+		return this.#format(format || "dd, mmm DD, YYYY HH:mm:ss", useUTC);
+	}
+	/**
+	* @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, useUTC = false) {
+		return this.#format(format || "dd, mmm DD, YYYY HH:mm:ss", useUTC);
+	}
+	/**
+	* @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 = "dd, mmm DD, YYYY HH:mm:ss:mss") {
+		return this.#format(format, true);
+	}
+	/**
+	* @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) {
+		return this.#cloneStates(this.add(seconds, "second"), "addSeconds");
+	}
+	/**
+	* @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) {
+		return this.#cloneStates(this.add(minutes, "minute"), "addMinutes");
+	}
+	/**
+	* @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) {
+		return this.#cloneStates(this.add(hours, "hour"), "addHours");
+	}
+	/**
+	* @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) {
+		return this.#cloneStates(this.add(days, "day"), "addDays");
+	}
+	/**
+	* @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) {
+		return this.#cloneStates(this.add(weeks, "week"), "addWeeks");
+	}
+	/**
+	* @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) {
+		return this.#cloneStates(this.add(months, "month"), "addMonths");
+	}
+	/**
+	* @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) {
+		return this.#cloneStates(this.add(years, "year"), "addYears");
+	}
+	/**
+	* @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) {
+		return isLeapYear(year ?? this.year);
+	}
+	/** @instance Checks if another date is exactly equal to this one. */
+	isEqual(other) {
+		return this.#timestamp === Chronos.#cast(other).#timestamp;
+	}
+	/** @instance Checks if another date is exactly equal to or before this one. */
+	isEqualOrBefore(other) {
+		return this.#timestamp <= Chronos.#cast(other).#timestamp;
+	}
+	/** @instance Checks if another date is exactly equal to or after this one. */
+	isEqualOrAfter(other) {
+		return this.#timestamp >= Chronos.#cast(other).#timestamp;
+	}
+	/**
+	* @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, unit, weekStartsOn = 0) {
+		return this.startOf(unit, weekStartsOn).#timestamp === Chronos.#cast(other).startOf(unit, weekStartsOn).#timestamp;
+	}
+	/**
+	* @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, unit, weekStartsOn = 0) {
+		return this.startOf(unit, weekStartsOn).#timestamp < Chronos.#cast(other).startOf(unit, weekStartsOn).#timestamp;
+	}
+	/**
+	* @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, unit, weekStartsOn = 0) {
+		return this.startOf(unit, weekStartsOn).#timestamp > Chronos.#cast(other).startOf(unit, weekStartsOn).#timestamp;
+	}
+	/**
+	* @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, unit, weekStartsOn = 0) {
+		return this.isSame(other, unit, weekStartsOn) || this.isBefore(other, unit, weekStartsOn);
+	}
+	/**
+	* @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, unit, weekStartsOn = 0) {
+		return this.isSame(other, unit, weekStartsOn) || this.isAfter(other, unit, weekStartsOn);
+	}
+	/**
+	* @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, end, inclusive = "()") {
+		const s = Chronos.#cast(start).getTimeStamp();
+		const e = Chronos.#cast(end).getTimeStamp();
+		const t = this.getTimeStamp();
+		switch (inclusive) {
+			case "[]": return t >= s && t <= e;
+			case "[)": return t >= s && t < e;
+			case "(]": return t > s && t <= e;
+			case "()": return t > s && t < e;
+			default: return false;
+		}
+	}
+	/**
+	* @instance Checks if the date is within daylight saving time (DST).
+	* @returns Whether the date is in DST (`true` or `false`).
+	*/
+	isDST() {
+		const year = this.year;
+		const jan = new Date(year, 0, 1).getTimezoneOffset();
+		const jul = new Date(year, 6, 1).getTimezoneOffset();
+		return this.#date.getTimezoneOffset() < Math.max(jan, jul);
+	}
+	/** @instance Checks if current day is the first day of the current month. */
+	isFirstDayOfMonth() {
+		return this.isSame(this.firstDayOfMonth(), "day");
+	}
+	/** @instance Checks if current day is the last day of the current month. */
+	isLastDayOfMonth() {
+		return this.isSame(this.lastDayOfMonth(), "day");
+	}
+	/** @instance Returns a new `Chronos` instance set to the first day of the current month. */
+	firstDayOfMonth() {
+		const firstDate = new Date(this.year, this.month, 1);
+		return this.#cloneStates(new Chronos(firstDate), "firstDayOfMonth");
+	}
+	/** @instance Returns a new `Chronos` instance set to the last day of the current month. */
+	lastDayOfMonth() {
+		const lastDate = new Date(this.year, this.month + 1, 0);
+		return this.#cloneStates(new Chronos(lastDate), "lastDayOfMonth");
+	}
+	/**
+	* @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, weekStartsOn = 0) {
+		const d = new Date(this.#date);
+		switch (unit) {
+			case "year":
+				d.setMonth(0, 1);
+				d.setHours(0, 0, 0, 0);
+				break;
+			case "month":
+				d.setDate(1);
+				d.setHours(0, 0, 0, 0);
+				break;
+			case "week": {
+				const diff = (d.getDay() - weekStartsOn + 7) % 7;
+				d.setDate(d.getDate() - diff);
+				d.setHours(0, 0, 0, 0);
+				break;
+			}
+			case "day":
+				d.setHours(0, 0, 0, 0);
+				break;
+			case "hour":
+				d.setMinutes(0, 0, 0);
+				break;
+			case "minute":
+				d.setSeconds(0, 0);
+				break;
+			case "second":
+				d.setMilliseconds(0);
+				break;
+			case "millisecond": break;
+		}
+		return this.#cloneStates(new Chronos(d), "startOf");
+	}
+	/**
+	* @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, weekStartsOn = 0) {
+		const instance = this.startOf(unit, weekStartsOn).add(1, unit).add(-1, "millisecond");
+		return this.#cloneStates(instance, "endOf");
+	}
+	/**
+	* @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, unit) {
+		const d = new Date(this.#date);
+		switch (unit) {
+			case "millisecond":
+				d.setMilliseconds(d.getMilliseconds() + number);
+				break;
+			case "second":
+				d.setSeconds(d.getSeconds() + number);
+				break;
+			case "minute":
+				d.setMinutes(d.getMinutes() + number);
+				break;
+			case "hour":
+				d.setHours(d.getHours() + number);
+				break;
+			case "day":
+				d.setDate(d.getDate() + number);
+				break;
+			case "week":
+				d.setDate(d.getDate() + number * 7);
+				break;
+			case "month":
+				d.setMonth(d.getMonth() + number);
+				break;
+			case "year":
+				d.setFullYear(d.getFullYear() + number);
+				break;
+		}
+		return this.#cloneStates(new Chronos(d), "add");
+	}
+	/**
+	* @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, unit) {
+		return this.#cloneStates(this.add(-number, unit), "subtract");
+	}
+	/**
+	* @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) {
+		switch (unit) {
+			case "year": return this.year;
+			case "month": return this.isoMonth;
+			case "day": return this.date;
+			case "week": return this.getWeek();
+			case "hour": return this.hour;
+			case "minute": return this.minute;
+			case "second": return this.second;
+			case "millisecond": return this.millisecond;
+		}
+	}
+	/**
+	* @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, value) {
+		const d = new Date(this.#date);
+		switch (unit) {
+			case "year":
+				d.setFullYear(value);
+				break;
+			case "month":
+				d.setMonth(value - 1);
+				break;
+			case "day":
+				d.setDate(value);
+				break;
+			case "week": return this.setWeek(value);
+			case "hour":
+				d.setHours(value);
+				break;
+			case "minute":
+				d.setMinutes(value);
+				break;
+			case "second":
+				d.setSeconds(value);
+				break;
+			case "millisecond":
+				d.setMilliseconds(value);
+				break;
+		}
+		return this.#cloneStates(new Chronos(d), "set");
+	}
+	/**
+	* @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, unit) {
+		const time = Chronos.#cast(other);
+		const msDiff = this.#timestamp - time.#timestamp;
+		switch (unit) {
+			case "millisecond": return msDiff;
+			case "second": return msDiff / 1e3;
+			case "minute": return msDiff / 6e4;
+			case "hour": return msDiff / 36e5;
+			case "day": return msDiff / 864e5;
+			case "week": return msDiff / 6048e5;
+			case "month": {
+				const yearDiff = this.year - time.year;
+				const monthDiff = this.month - time.month;
+				return yearDiff * 12 + monthDiff + (this.date - time.date) / this.daysInMonth();
+			}
+			case "year": return this.diff(time, "month") / 12;
+		}
+	}
+	/**
+	* @instance Returns a human-readable relative calendar time like "Today at 3:00 PM"
+	* @param baseDate Optional base date to compare with.
+	*/
+	calendar(baseDate) {
+		const base = baseDate ? Chronos.#cast(baseDate) : new Chronos();
+		const input = this.startOf("day");
+		const comparison = base.startOf("day");
+		const diff = input.diff(comparison, "day");
+		const timeStr = this.toDate().toLocaleString("en", {
+			hour: "numeric",
+			minute: "2-digit"
+		});
+		if (diff === 0) return `Today at ${timeStr}`;
+		if (diff === 1) return `Tomorrow at ${timeStr}`;
+		if (diff === -1) return `Yesterday at ${timeStr}`;
+		return this.toDate().toLocaleString("en", {
+			month: "long",
+			day: "2-digit",
+			year: "numeric",
+			weekday: "long",
+			hour: "numeric",
+			minute: "2-digit"
+		});
+	}
+	/** @instance Returns a short human-readable string like "2h ago", "in 5m". From `year` to `second`. */
+	fromNowShort() {
+		const now = new Chronos();
+		const diffInSeconds = this.diff(now, "second");
+		const abs = Math.abs(diffInSeconds);
+		const prefix = diffInSeconds >= 0 ? "in " : "";
+		const suffix = diffInSeconds < 0 ? " ago" : "";
+		if (abs < 60) return `${prefix}${Math.floor(abs)}s${suffix}`;
+		else if (abs < 3600) return `${prefix}${Math.floor(abs / 60)}m${suffix}`;
+		else if (abs < 86400) return `${prefix}${Math.floor(abs / 3600)}h${suffix}`;
+		else if (abs < 2592e3) return `${prefix}${Math.floor(abs / 86400)}d${suffix}`;
+		else if (abs < 31536e3) return `${prefix}${Math.floor(abs / 2592e3)}mo${suffix}`;
+		else return `${prefix}${Math.floor(abs / 31536e3)}y${suffix}`;
+	}
+	/**
+	* @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) {
+		const d = new Date(this.#date);
+		const year = d.getFullYear();
+		const jan4 = new Date(year, 0, 4);
+		const dayOfWeek = jan4.getDay() || 7;
+		const weekStart = new Date(jan4);
+		weekStart.setDate(jan4.getDate() - (dayOfWeek - 1));
+		weekStart.setDate(weekStart.getDate() + (week - 1) * 7);
+		d.setFullYear(weekStart.getFullYear());
+		d.setMonth(weekStart.getMonth());
+		d.setDate(weekStart.getDate());
+		return this.#cloneStates(new Chronos(d), "setWeek");
+	}
+	/**
+	* @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() {
+		const target = this.startOf("week", 1).add(3, "day");
+		const firstThursday = new Chronos(target.year, 1, 4).startOf("week", 1).add(3, "day");
+		return target.diff(firstThursday, "week") + 1;
+	}
+	/**
+	* @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 = 0) {
+		const startOfFirstWeek = this.startOf("year").startOf("week", weekStartsOn);
+		return this.startOf("week", weekStartsOn).diff(startOfFirstWeek, "week") + 1;
+	}
+	/**
+	* @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 = 0) {
+		return this.startOf("week", weekStartsOn).add(3, "day").year;
+	}
+	/** @instance Returns day of year (1 - 366) */
+	getDayOfYear() {
+		return this.startOf("day").diff(this.startOf("year"), "day") + 1;
+	}
+	/** @instance Returns number of days in current month */
+	daysInMonth() {
+		return new Date(this.year, this.month + 1, 0).getDate();
+	}
+	/** @instance Converts to object with all date unit parts */
+	toObject() {
+		return Object.fromEntries([...this]);
+	}
+	/** @instance Converts to array with all date unit parts */
+	toArray() {
+		return Object.values(this.toObject());
+	}
+	/**
+	* @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() {
+		const month = this.#date.getMonth();
+		return Math.floor(month / 3) + 1;
+	}
+	/**
+	* @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() {
+		const offset = -this.#date.getTimezoneOffset();
+		const sign = offset >= 0 ? "+" : "-";
+		const pad = (n) => String(Math.floor(Math.abs(n))).padStart(2, "0");
+		return `${sign}${pad(offset / 60)}:${pad(offset % 60)}`;
+	}
+	/**
+	* @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() {
+		return this.#offset.replace("UTC", "");
+	}
+	/**
+	* @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() {
+		return -this.#date.getTimezoneOffset();
+	}
+	/**
+	* @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() {
+		return extractMinutesFromUTC(this.#offset);
+	}
+	/** @instance Returns new `Chronos` instance in UTC time */
+	toUTC() {
+		const offset = this.getTimeZoneOffsetMinutes();
+		return new Chronos(/* @__PURE__ */ new Date(this.#timestamp - offset * 60 * 1e3)).#withOrigin("toUTC", "UTC+00:00", "Greenwich Mean Time", "UTC");
+	}
+	/** @instance Returns new `Chronos` instance in local time */
+	toLocal() {
+		const offset = this.getTimeZoneOffsetMinutes() - this.getUTCOffsetMinutes();
+		return new Chronos(/* @__PURE__ */ new Date(this.#timestamp - offset * 60 * 1e3)).#withOrigin("toLocal");
+	}
+	/**
+	* @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) {
+		return DAYS[index ?? this.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) {
+		return MONTHS[index ?? this.month];
+	}
+	/**
+	* @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, format) {
+		const tokenPatterns = {
+			YYYY: "(?<YYYY>\\d{4})",
+			YY: "(?<YY>\\d{2})",
+			MM: "(?<MM>\\d{2})",
+			M: "(?<M>\\d{1,2})",
+			DD: "(?<DD>\\d{2})",
+			D: "(?<D>\\d{1,2})",
+			HH: "(?<HH>\\d{2})",
+			H: "(?<H>\\d{1,2})",
+			mm: "(?<mm>\\d{2})",
+			m: "(?<m>\\d{1,2})",
+			ss: "(?<ss>\\d{2})",
+			s: "(?<s>\\d{1,2})",
+			mss: "(?<mss>\\d{3})",
+			ms: "(?<ms>\\d{1,3})"
+		};
+		const tokenToComponent = {
+			YYYY: "year",
+			YY: "year",
+			MM: "month",
+			M: "month",
+			DD: "date",
+			D: "date",
+			HH: "hour",
+			H: "hour",
+			mm: "minute",
+			m: "minute",
+			ss: "second",
+			s: "second",
+			mss: "millisecond",
+			ms: "millisecond"
+		};
+		const tokenRegExp = new RegExp(Object.keys(tokenPatterns).sort((a, b) => b.length - a.length).join("|"), "g");
+		const regexStr = format?.trim()?.replace(tokenRegExp, (token) => tokenPatterns[token] ?? token)?.replace(/\s+/g, "\\s*");
+		const match = new RegExp(`^${regexStr}\\s*$`).exec(dateStr.trim());
+		if (!match?.groups) throw new Error("Invalid date format!");
+		const parts = {};
+		for (const [token, value] of Object.entries(match.groups)) {
+			const key = tokenToComponent[token];
+			if (key) {
+				let num = Number(value);
+				if (token === "YY") num += num < 100 ? 2e3 : 0;
+				parts[key] = num;
+			}
+		}
+		return new Chronos(parts?.year ?? 1970, parts?.month ?? 1, parts?.date ?? 1, parts?.hour ?? 0, parts?.minute ?? 0, parts?.second ?? 0, parts?.millisecond ?? 0).#withOrigin("parse");
+	}
+	/**
+	* @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) {
+		const now = new Chronos();
+		const { year, month, date, hour, minute, second, millisecond } = options ?? {};
+		const nextLDoM = () => {
+			return now.startOf("month").set("year", year ?? now.year).set("month", month ?? now.isoMonth).lastDateOfMonth;
+		};
+		return new Chronos(year ?? now.year, month ?? now.isoMonth, date ? date : now.isLastDayOfMonth() && now.date >= nextLDoM() ? nextLDoM() : now.date, hour ?? now.hour, minute ?? now.minute, second ?? now.second, millisecond ?? now.millisecond).#withOrigin("with");
+	}
+	/**
+	* @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) {
+		const { format = "dd, mmm DD, YYYY HH:mm:ss", useUTC = false } = options || {};
+		return new Chronos().#format(format, useUTC);
+	}
+	/**
+	* @static Returns a new `Chronos` instance representing yesterday's date.
+	*
+	* @returns A `Chronos` instance for the previous calendar day.
+	*/
+	static yesterday() {
+		const today = /* @__PURE__ */ new Date();
+		return new Chronos(today.setDate(today.getDate() - 1)).#withOrigin("yesterday");
+	}
+	/**
+	* @static Returns a new `Chronos` instance representing tomorrow's date.
+	*
+	* @returns A `Chronos` instance for the next calendar day.
+	*/
+	static tomorrow() {
+		const today = /* @__PURE__ */ new Date();
+		return new Chronos(today.setDate(today.getDate() + 1)).#withOrigin("tomorrow");
+	}
+	/**
+	* @static Returns the number of milliseconds elapsed since midnight, January 1, 1970 Universal Coordinated Time (UTC).
+	* @returns The number of milliseconds elapsed since the Unix epoch.
+	* @remarks It internally uses {@link Date.now()}.
+	*/
+	static now() {
+		return Date.now();
+	}
+	/**
+	* @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) {
+		const chronos = new Chronos(dateLike);
+		const offset = chronos.getTimeZoneOffsetMinutes();
+		return new Chronos(/* @__PURE__ */ new Date(chronos.#timestamp - offset * 60 * 1e3)).#withOrigin("utc", "UTC+00:00", "Greenwich Mean Time", "UTC");
+	}
+	/**
+	* @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, format) {
+		return new Chronos(`${new Chronos().#format("YYYY-MM-DD")}T${_normalizeOffset(time)}`).#format(format || "hh:mm:ss a");
+	}
+	/**
+	* @static 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 date range (from/to) and output format.
+	* @returns Array of ISO date strings in the specified format.
+	*
+	* - Please refer to {@link https://toolbox.nazmul-nhb.dev/docs/classes/Chronos/statics#getdatesforday docs} for details.
+	*/
+	static getDatesForDay(day, options) {
+		let startDate = new Chronos(), endDate = startDate.addWeeks(4);
+		const { format = "local", roundDate = false } = options ?? {};
+		if (options) {
+			if ("from" in options || "to" in options) {
+				if (options?.from) startDate = Chronos.#cast(options?.from);
+				if (options?.to) endDate = Chronos.#cast(options?.to);
+			} else if ("span" in options || "unit" in options) {
+				const { span = 4, unit = "week" } = options ?? {};
+				endDate = startDate.add(span, unit);
+			}
+		}
+		if (roundDate) {
+			startDate = startDate.startOf("day");
+			endDate = endDate.startOf("day");
+		}
+		const result = [];
+		const step = (startDate.isBefore(endDate, "day") ? 1 : -1) * MS_PER_DAY;
+		const totalDays = Math.abs(endDate.diff(startDate, "day"));
+		const currentTime = startDate.#timestamp;
+		let firstOffset = 0;
+		while (new Date(currentTime + firstOffset * step).getDay() !== DAYS.indexOf(day)) firstOffset++;
+		for (let i = firstOffset; i <= totalDays; i += 7) {
+			const chr = new Chronos(currentTime + i * step).#withOrigin("clone", startDate.#offset, startDate.timeZoneName, startDate.timeZoneId, startDate.$tzTracker);
+			result.push(format === "local" ? chr.toLocalISOString() : chr.toISOString());
+		}
+		return result;
+	}
+	/**
+	* @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) {
+		let winner = Chronos.#cast(dates[0]);
+		for (const d of dates) {
+			const c = Chronos.#cast(d);
+			if (c.getTimeStamp() < winner.getTimeStamp()) winner = c;
+		}
+		return winner.#cloneStates(winner, winner.#ORIGIN !== "root" ? winner.#ORIGIN : "min");
+	}
+	/**
+	* @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) {
+		let winner = Chronos.#cast(dates[0]);
+		for (const d of dates) {
+			const c = Chronos.#cast(d);
+			if (c.getTimeStamp() > winner.getTimeStamp()) winner = c;
+		}
+		return winner.#cloneStates(winner, winner.#ORIGIN !== "root" ? winner.#ORIGIN : "max");
+	}
+	/**
+	* @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.
+	*
+	* @remarks
+	* - 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) {
+		let year;
+		if (isNumber(date)) if (date > 0 && date <= 9999) year = date;
+		else year = new Date(date).getFullYear();
+		else year = Chronos.#cast(date).year;
+		return isLeapYear(year);
+	}
+	/**
+	* @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) {
+		return value instanceof 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) {
+		return isDateString(value);
+	}
+	/**
+	* @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) {
+		return value instanceof 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) {
+		return _hasChronosProperties(value);
+	}
+	/**
+	* @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) {
+		if (!_hasChronosProperties(value)) throw new TypeError("Invalid input for reconstruction!");
+		const { native, origin, utcOffset, timeZoneName, timeZoneId, $tzTracker } = value;
+		const offsetMins = extractMinutesFromUTC(utcOffset);
+		const chr = new Chronos(native);
+		const diffMins = chr.getTimeZoneOffsetMinutes() - offsetMins;
+		return (chr.utcOffset === utcOffset ? chr : chr.add(-diffMins, "minute")).#withOrigin(origin, utcOffset, timeZoneName, timeZoneId, $tzTracker);
+	}
+	/**
+	* @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) {
+		if (!Chronos.#plugins.has(plugin)) {
+			Chronos.#plugins.add(plugin);
+			plugin(Chronos);
+		}
+	}
+	/**
+	* @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) {
+		Chronos.use(plugin);
+	}
+	/** @static Ensures the input is a `Chronos` instance, creating one if necessary. */
+	static #cast(date) {
+		return date instanceof Chronos ? date : new Chronos(date);
+	}
+};
+
+//#endregion
+export { Chronos, INTERNALS, chronos };