datetick 1.0.0

package/dist/index.umd.js

@@ -0,0 +1,2435 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.datetick = {}));
+})(this, (function (exports) { 'use strict';
+
+    /**
+     * Returns the number of days in a given month (month is 0-based).
+     */
+    const getDaysInMonth = (year, month) => {
+        return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+    };
+    /**
+     * Reads the wall-clock components of an instant as seen in a given timezone.
+     */
+    const partsOf = (date, timezone) => {
+        // Guard invalid dates: `Intl.DateTimeFormat` throws a RangeError on an invalid Date, which would
+        // otherwise make every getter (`year()`, `month()`, …) throw instead of surfacing NaN.
+        if (Number.isNaN(date.getTime())) {
+            return {
+                year: Number.NaN,
+                month: Number.NaN,
+                day: Number.NaN,
+                hour: Number.NaN,
+                minute: Number.NaN,
+                second: Number.NaN,
+                millisecond: Number.NaN,
+                weekday: Number.NaN,
+            };
+        }
+        const dtf = new Intl.DateTimeFormat('en-US', {
+            timeZone: timezone,
+            hourCycle: 'h23',
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+        });
+        const map = {};
+        for (const part of dtf.formatToParts(date)) {
+            if (part.type !== 'literal')
+                map[part.type] = Number(part.value);
+        }
+        // Day-of-week is derived from the zoned Y/M/D treated as a UTC date (a stable, locale-free lookup).
+        const weekday = new Date(Date.UTC(map.year, map.month - 1, map.day)).getUTCDay();
+        return {
+            year: map.year,
+            month: map.month - 1,
+            day: map.day,
+            hour: map.hour,
+            minute: map.minute,
+            second: map.second,
+            millisecond: date.getMilliseconds(),
+            weekday,
+        };
+    };
+    /**
+     * The timezone's offset from UTC (in ms) at a given instant (positive when ahead of UTC).
+     */
+    const offsetMs = (instant, timezone) => {
+        const p = partsOf(instant, timezone);
+        const asUtc = Date.UTC(p.year, p.month, p.day, p.hour, p.minute, p.second, p.millisecond);
+        return asUtc - instant.getTime();
+    };
+    /**
+     * Converts wall-clock components in a timezone back to an absolute instant.
+     * Runs a two-pass correction so it stays correct across DST transitions.
+     */
+    const instantFromParts = (parts, timezone) => {
+        const utcGuess = Date.UTC(parts.year, parts.month, parts.day, parts.hour, parts.minute, parts.second, parts.millisecond);
+        const offset1 = offsetMs(new Date(utcGuess), timezone);
+        let instant = utcGuess - offset1;
+        const offset2 = offsetMs(new Date(instant), timezone);
+        if (offset2 !== offset1)
+            instant = utcGuess - offset2;
+        return new Date(instant);
+    };
+    // Localized month/weekday names are stable per (locale, style); creating a fresh `Intl.DateTimeFormat`
+    // on every call is costly, so resolved names are memoized (e.g. when rendering a calendar grid).
+    const monthNamesCache = new Map();
+    const weekdayNamesCache = new Map();
+    /**
+     * Returns the localized month names for a locale (index 0 = January).
+     */
+    const localeMonthNames = (locale, style) => {
+        const key = `${locale} ${style}`;
+        let names = monthNamesCache.get(key);
+        if (!names) {
+            const fmt = new Intl.DateTimeFormat(locale, { month: style, timeZone: 'UTC' });
+            names = Array.from({ length: 12 }, (_, i) => fmt.format(new Date(Date.UTC(2021, i, 15))));
+            monthNamesCache.set(key, names);
+        }
+        return names;
+    };
+    /**
+     * Returns the localized weekday names for a locale, Sunday-first (index 0 = Sunday).
+     */
+    const localeWeekdayNames = (locale, style) => {
+        const key = `${locale} ${style}`;
+        let names = weekdayNamesCache.get(key);
+        if (!names) {
+            const fmt = new Intl.DateTimeFormat(locale, { weekday: style, timeZone: 'UTC' });
+            // 2020-06-07 is a Sunday, so +i walks Sunday..Saturday.
+            names = Array.from({ length: 7 }, (_, i) => fmt.format(new Date(Date.UTC(2020, 5, 7 + i))));
+            weekdayNamesCache.set(key, names);
+        }
+        return names;
+    };
+    const meridiemCache = new Map();
+    /**
+     * Returns a locale's AM/PM markers (e.g. en -> `{ am: 'AM', pm: 'PM' }`, zh -> morning/afternoon
+     * ideographs), falling back to English when a locale exposes none.
+     */
+    const localeMeridiems = (locale) => {
+        const cached = meridiemCache.get(locale);
+        if (cached)
+            return cached;
+        const dtf = new Intl.DateTimeFormat(locale, { hour: 'numeric', hour12: true, timeZone: 'UTC' });
+        const at = (hour) => dtf.formatToParts(new Date(Date.UTC(2020, 0, 1, hour))).find((p) => p.type === 'dayPeriod')?.value ?? '';
+        const markers = { am: at(6) || 'AM', pm: at(18) || 'PM' };
+        meridiemCache.set(locale, markers);
+        return markers;
+    };
+    /**
+     * Builds a case-insensitive regex alternation matching a locale's AM/PM markers, for use when parsing
+     * the `A`/`a` token (e.g. `PM|pm|AM|am`).
+     */
+    const meridiemRegexGroup = (locale) => {
+        const { am, pm } = localeMeridiems(locale);
+        const variants = (s) => [s.toLocaleUpperCase(locale), s.toLocaleLowerCase(locale)];
+        return Array.from(new Set([...variants(pm), ...variants(am)]))
+            .filter(Boolean)
+            .sort((a, b) => b.length - a.length)
+            .map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+            .join('|');
+    };
+    /**
+     * Returns the English ordinal suffix ('st', 'nd', 'rd', 'th') for a number.
+     */
+    const ordinalSuffix = (n) => {
+        const v = n % 100;
+        if (v >= 11 && v <= 13)
+            return 'th';
+        switch (n % 10) {
+            case 1:
+                return 'st';
+            case 2:
+                return 'nd';
+            case 3:
+                return 'rd';
+            default:
+                return 'th';
+        }
+    };
+    // dayjs-style localized tokens, described as the (date-part, time-part) Intl option pair each one
+    // derives from. Date and time are requested as separate `Intl` calls and joined with a space so that
+    // modern ICU never injects an " at " connector between them.
+    const TIME_LT = { hour: 'numeric', minute: '2-digit' };
+    const TIME_LTS = { hour: 'numeric', minute: '2-digit', second: '2-digit' };
+    const LOCALIZED_PARTS = {
+        LT: { time: TIME_LT },
+        LTS: { time: TIME_LTS },
+        L: { date: { year: 'numeric', month: '2-digit', day: '2-digit' } },
+        l: { date: { year: 'numeric', month: 'numeric', day: 'numeric' } },
+        LL: { date: { year: 'numeric', month: 'long', day: 'numeric' } },
+        ll: { date: { year: 'numeric', month: 'short', day: 'numeric' } },
+        LLL: { date: { year: 'numeric', month: 'long', day: 'numeric' }, time: TIME_LT },
+        lll: { date: { year: 'numeric', month: 'short', day: 'numeric' }, time: TIME_LT },
+        LLLL: { date: { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' }, time: TIME_LT },
+        llll: { date: { weekday: 'short', year: 'numeric', month: 'short', day: 'numeric' }, time: TIME_LT },
+    };
+    // Derived localized patterns are cached per (locale, token): `formatToParts` is comparatively costly.
+    const localizedCache = new Map();
+    // Base token for each field, keyed by the `Intl` option value requested for it. Picks the token whose
+    // width matches the option so a round-trip through `formatPattern`/`parse` stays faithful.
+    const MONTH_TOKENS = { numeric: 'M', '2-digit': 'MM', short: 'MMM', long: 'MMMM' };
+    const WEEKDAY_TOKENS = { narrow: 'dd', short: 'ddd', long: 'dddd' };
+    // Resolves a single `Intl` part into a base token; missing entries are separators/literals.
+    const PART_TOKEN = {
+        year: (o) => (o.year === '2-digit' ? 'YY' : 'YYYY'),
+        month: (o) => MONTH_TOKENS[o.month ?? 'numeric'] ?? 'MMMM',
+        day: (o) => (o.day === '2-digit' ? 'DD' : 'D'),
+        weekday: (o) => WEEKDAY_TOKENS[o.weekday ?? 'long'] ?? 'dddd',
+        hour: (_o, hour12) => (hour12 ? 'h' : 'HH'),
+        minute: () => 'mm',
+        second: () => 'ss',
+        dayPeriod: () => 'A',
+    };
+    /**
+     * Translates one `Intl` skeleton into DateTick base tokens for the given locale, preserving that locale's
+     * field order and separators. Separators come back as `[escaped]` literals (with exotic spaces
+     * normalized), while each field maps to the base token whose width matches the requested option, so
+     * the surrounding `formatPattern`/`parse` still resolves values through the configured timezone.
+     */
+    const tokensFromIntl = (locale, options) => {
+        const dtf = new Intl.DateTimeFormat(locale, { timeZone: 'UTC', ...options });
+        const hour12 = dtf.resolvedOptions().hour12 ?? false;
+        // A reference instant with every field distinct (Thursday, 2 Jan 2020 03:04:05); only part *types*
+        // are read, so the concrete values never leak into the produced pattern.
+        const ref = new Date(Date.UTC(2020, 0, 2, 3, 4, 5));
+        return dtf.formatToParts(ref).map((part) => {
+            const resolve = PART_TOKEN[part.type];
+            // Normalize no-break / narrow-no-break spaces so output stays stable across ICU versions.
+            return resolve ? resolve(options, hour12) : `[${part.value.replace(/[\u00a0\u202f]/g, ' ')}]`;
+        });
+    };
+    /**
+     * Expands a localized token (`L`/`LL`/`LT`/etc.) into locale-aware base tokens.
+     */
+    const localizedTokens = (token, locale) => {
+        const key = `${locale} ${token}`;
+        const cached = localizedCache.get(key);
+        if (cached)
+            return cached;
+        const spec = LOCALIZED_PARTS[token];
+        const tokens = [];
+        if (spec.date)
+            tokens.push(...tokensFromIntl(locale, spec.date));
+        if (spec.date && spec.time)
+            tokens.push('[ ]');
+        if (spec.time)
+            tokens.push(...tokensFromIntl(locale, spec.time));
+        localizedCache.set(key, tokens);
+        return tokens;
+    };
+    // Fallback base-token patterns for localized tokens when no locale is supplied (US-English layout).
+    const LOCALIZED_FALLBACK = {
+        LTS: 'h:mm:ss A',
+        LT: 'h:mm A',
+        LLLL: 'dddd, MMMM D, YYYY h:mm A',
+        LLL: 'MMMM D, YYYY h:mm A',
+        LL: 'MMMM D, YYYY',
+        L: 'MM/DD/YYYY',
+        llll: 'ddd, MMM D, YYYY h:mm A',
+        lll: 'MMM D, YYYY h:mm A',
+        ll: 'MMM D, YYYY',
+        l: 'M/D/YYYY',
+    };
+    // Recognized tokens, ordered by descending length so the matcher is greedy (e.g. `LLLL` before `LL`).
+    const TOKENS = [
+        'YYYY',
+        'MMMM',
+        'dddd',
+        'LLLL',
+        'llll',
+        'MMM',
+        'ddd',
+        'SSS',
+        'LLL',
+        'LTS',
+        'lll',
+        'YY',
+        'MM',
+        'DD',
+        'dd',
+        'HH',
+        'hh',
+        'mm',
+        'ss',
+        'ZZ',
+        'Do',
+        'kk',
+        'ww',
+        'wo',
+        'WW',
+        'Wo',
+        'LL',
+        'LT',
+        'll',
+        'M',
+        'D',
+        'd',
+        'H',
+        'h',
+        'm',
+        's',
+        'A',
+        'a',
+        'Z',
+        'Q',
+        'k',
+        'X',
+        'x',
+        'w',
+        'W',
+        'L',
+        'l',
+    ];
+    // Expands a matched token: localized tokens resolve to locale-aware base tokens (or the US fallback
+    // when no locale is given); everything else passes through unchanged.
+    const expandToken = (token, locale) => {
+        if (!(token in LOCALIZED_FALLBACK))
+            return [token];
+        if (locale)
+            return localizedTokens(token, locale);
+        return splitTokens(LOCALIZED_FALLBACK[token]);
+    };
+    /**
+     * Greedy pattern tokenizer shared by date and duration formatting. Splits a pattern into an ordered
+     * list of recognized tokens (matched longest-first from `tokens`), `[escaped]` literals (brackets
+     * retained), and single passthrough characters. An unclosed `[` is emitted as a literal character.
+     */
+    const tokenize = (pattern, tokens) => {
+        const out = [];
+        let i = 0;
+        while (i < pattern.length) {
+            const end = pattern[i] === '[' ? pattern.indexOf(']', i) : -1;
+            if (end !== -1) {
+                out.push(pattern.slice(i, end + 1));
+                i = end + 1;
+                continue;
+            }
+            const matched = tokens.find((t) => pattern.startsWith(t, i));
+            if (matched) {
+                out.push(matched);
+                i += matched.length;
+            }
+            else {
+                out.push(pattern[i]);
+                i += 1;
+            }
+        }
+        return out;
+    };
+    /**
+     * Splits a token pattern into an ordered list of tokens, literal characters and `[escaped]` literals.
+     * Longer tokens are matched before their prefixes (e.g. `MMMM` before `MM`), and localized tokens
+     * (`L`/`LL`/`LT`/etc.) are expanded in place into their underlying base tokens. When a `locale` is
+     * given, localized tokens follow that locale's field order and separators; otherwise they fall back to
+     * the US-English layout. Literals and non-localized tokens pass through `expandToken` unchanged.
+     */
+    const splitTokens = (pattern, locale) => {
+        return tokenize(pattern, TOKENS).flatMap((segment) => expandToken(segment, locale));
+    };
+
+    /**
+     * Fixed unit ratios in milliseconds (1 month = 30 days, 1 year = 365 days), the same approximation
+     * used by `DateTick.timeAgo`.
+     */
+    const RATIOS = {
+        millisecond: 1,
+        second: 1000,
+        minute: 60_000,
+        hour: 3_600_000,
+        date: 86_400_000,
+        day: 86_400_000,
+        week: 604_800_000,
+        month: 2_592_000_000, // 30 days
+        quarter: 7_776_000_000, // 90 days
+        year: 31_536_000_000, // 365 days
+    };
+    const ratioFor = (unit) => {
+        const ratio = RATIOS[unit];
+        if (ratio == null)
+            throw new Error(`Invalid duration unit: ${unit}`);
+        return ratio;
+    };
+    // Duration format tokens, ordered longest-first so the greedy matcher prefers e.g. `YYYY` over `YY`.
+    const FORMAT_TOKENS = ['YYYY', 'SSS', 'YY', 'MM', 'DD', 'HH', 'mm', 'ss', 'Y', 'M', 'D', 'H', 'm', 's'];
+    // ISO 8601 duration: an optional sign, `P`, the date part (`Y`/`M`/`W`/`D`) and an optional `T` time
+    // part (`H`/`M`/`S`). Each amount may be fractional with `.` or `,`.
+    const ISO_DURATION = /^([+-])?P(?:(\d+(?:[.,]\d+)?)Y)?(?:(\d+(?:[.,]\d+)?)M)?(?:(\d+(?:[.,]\d+)?)W)?(?:(\d+(?:[.,]\d+)?)D)?(?:T(?:(\d+(?:[.,]\d+)?)H)?(?:(\d+(?:[.,]\d+)?)M)?(?:(\d+(?:[.,]\d+)?)S)?)?$/;
+    /**
+     * Parses an ISO 8601 duration string (e.g. 'P1Y2M10DT2H30M') into milliseconds, using the same fixed
+     * unit ratios as the rest of the class (1 month = 30 days, 1 year = 365 days).
+     */
+    const msFromISODuration = (input) => {
+        const m = ISO_DURATION.exec(input.trim());
+        // Reject `P`/`PT` with no components (m[1] is the sign; m[2..8] are the amounts).
+        if (!m || !m.slice(2).some(Boolean))
+            throw new Error(`Invalid ISO 8601 duration: "${input}"`);
+        const num = (value) => (value ? Number.parseFloat(value.replace(',', '.')) : 0);
+        const ms = num(m[2]) * RATIOS.year +
+            num(m[3]) * RATIOS.month +
+            num(m[4]) * RATIOS.week +
+            num(m[5]) * RATIOS.day +
+            num(m[6]) * RATIOS.hour +
+            num(m[7]) * RATIOS.minute +
+            num(m[8]) * RATIOS.second;
+        return m[1] === '-' ? -ms : ms;
+    };
+    /**
+     * An immutable length of time, independent of any particular instant.
+     *
+     * Conversions use fixed ratios (1 month = 30 days, 1 year = 365 days). `humanize()` is locale-aware via `Intl`.
+     *
+     * @class Duration
+     */
+    class Duration {
+        _locale;
+        _ms;
+        /**
+         * Creates a Duration.
+         *
+         * @param {number | string | DurationInput} value - A millisecond amount, an amount paired with `unit`,
+         * an ISO 8601 duration string (e.g. 'P1Y2M10DT2H30M'), or a components object
+         * @param {DateUnit} [unit] - The unit when `value` is a number (defaults to milliseconds)
+         * @param {string} [locale='en'] - The locale used by `humanize()`
+         * @throws {Error} If `value` is a string that is not a valid ISO 8601 duration
+         * @memberof Duration
+         */
+        constructor(value, unit, locale = 'en') {
+            this._locale = locale;
+            if (typeof value === 'string') {
+                this._ms = msFromISODuration(value);
+            }
+            else if (typeof value === 'number') {
+                this._ms = value * (unit ? ratioFor(unit) : 1);
+            }
+            else if (value instanceof Duration) {
+                this._ms = value.valueOf();
+            }
+            else if (value && typeof value === 'object') {
+                this._ms =
+                    (value.years ?? 0) * RATIOS.year +
+                        (value.months ?? 0) * RATIOS.month +
+                        (value.weeks ?? 0) * RATIOS.week +
+                        (value.days ?? 0) * RATIOS.day +
+                        (value.hours ?? 0) * RATIOS.hour +
+                        (value.minutes ?? 0) * RATIOS.minute +
+                        (value.seconds ?? 0) * RATIOS.second +
+                        (value.milliseconds ?? 0);
+            }
+            else {
+                this._ms = 0;
+            }
+        }
+        /**
+         * Checks whether a value is a Duration instance.
+         *
+         * @param {unknown} value - The value to check
+         * @returns {boolean} True if the value is a Duration
+         * @memberof Duration
+         */
+        static isDuration(value) {
+            return value instanceof Duration;
+        }
+        /**
+         * Returns a new Duration with the given amount added
+         *
+         * @param {number} value - The amount to add
+         * @param {DateUnit} [unit='millisecond'] - The unit of the amount
+         * @returns {Duration} The new Duration
+         * @memberof Duration
+         */
+        add(value, unit = 'millisecond') {
+            return new Duration(this._ms + value * ratioFor(unit), undefined, this._locale);
+        }
+        /**
+         * The whole duration expressed in a chosen unit.
+         *
+         * @param {DateUnit} unit - The target unit
+         * @returns {number} The duration in that unit
+         * @memberof Duration
+         */
+        as(unit) {
+            return this._ms / ratioFor(unit);
+        }
+        /**
+         * The whole duration expressed in days (fractional)
+         *
+         * @returns {number} The duration in days
+         * @memberof Duration
+         */
+        asDays() {
+            return this._ms / RATIOS.day;
+        }
+        /**
+         * The whole duration expressed in hours (fractional)
+         *
+         * @returns {number} The duration in hours
+         * @memberof Duration
+         */
+        asHours() {
+            return this._ms / RATIOS.hour;
+        }
+        /**
+         * The whole duration expressed in milliseconds
+         *
+         * @returns {number} The duration in milliseconds
+         * @memberof Duration
+         */
+        asMilliseconds() {
+            return this._ms;
+        }
+        /**
+         * The whole duration expressed in minutes (fractional)
+         *
+         * @returns {number} The duration in minutes
+         * @memberof Duration
+         */
+        asMinutes() {
+            return this._ms / RATIOS.minute;
+        }
+        /**
+         * The whole duration expressed in months (fractional, 1 month = 30 days)
+         *
+         * @returns {number} The duration in months
+         * @memberof Duration
+         */
+        asMonths() {
+            return this._ms / RATIOS.month;
+        }
+        /**
+         * The whole duration expressed in seconds (fractional)
+         *
+         * @returns {number} The duration in seconds
+         * @memberof Duration
+         */
+        asSeconds() {
+            return this._ms / RATIOS.second;
+        }
+        /**
+         * The whole duration expressed in weeks (fractional)
+         *
+         * @returns {number} The duration in weeks
+         * @memberof Duration
+         */
+        asWeeks() {
+            return this._ms / RATIOS.week;
+        }
+        /**
+         * The whole duration expressed in years (fractional, 1 year = 365 days)
+         *
+         * @returns {number} The duration in years
+         * @memberof Duration
+         */
+        asYears() {
+            return this._ms / RATIOS.year;
+        }
+        /**
+         * The days component after extracting whole years and months
+         *
+         * @returns {number} The days component
+         * @memberof Duration
+         */
+        days() {
+            return this.components().days;
+        }
+        /**
+         * Formats the duration with Day.js-style duration tokens.
+         *
+         * Supported tokens: `Y` `YY` `YYYY` `M` `MM` `D` `DD` `H` `HH` `m` `mm` `s` `ss` `SSS`.
+         * Wrap literal text in `[square brackets]`.
+         *
+         * @param {string} [pattern='HH:mm:ss'] - The token pattern
+         * @returns {string} The formatted duration
+         * @memberof Duration
+         */
+        format(pattern = 'HH:mm:ss') {
+            const sign = this._ms < 0 ? '-' : '';
+            const c = this.absComponents();
+            const two = (n) => String(n).padStart(2, '0');
+            const map = {
+                YYYY: String(c.years).padStart(4, '0'),
+                YY: two(c.years % 100),
+                Y: String(c.years),
+                MM: two(c.months),
+                M: String(c.months),
+                DD: two(c.days),
+                D: String(c.days),
+                HH: two(c.hours),
+                H: String(c.hours),
+                mm: two(c.minutes),
+                m: String(c.minutes),
+                ss: two(c.seconds),
+                s: String(c.seconds),
+                SSS: String(c.milliseconds).padStart(3, '0'),
+            };
+            const out = tokenize(pattern, FORMAT_TOKENS)
+                .map((segment) => {
+                if (segment.startsWith('[') && segment.endsWith(']'))
+                    return segment.slice(1, -1);
+                return segment in map ? map[segment] : segment;
+            })
+                .join('');
+            return sign + out;
+        }
+        /**
+         * Returns the duration component for a unit.
+         *
+         * @param {DateUnit} unit - The component unit
+         * @returns {number} The component value
+         * @memberof Duration
+         */
+        get(unit) {
+            const c = this.components();
+            switch (unit) {
+                case 'year':
+                    return c.years;
+                case 'quarter':
+                    return Math.trunc(c.months / 3);
+                case 'month':
+                    return c.months;
+                case 'week':
+                    return Math.trunc(c.days / 7);
+                case 'date':
+                case 'day':
+                    return c.days;
+                case 'hour':
+                    return c.hours;
+                case 'minute':
+                    return c.minutes;
+                case 'second':
+                    return c.seconds;
+                case 'millisecond':
+                    return c.milliseconds;
+                default:
+                    throw new Error(`Invalid duration unit: ${unit}`);
+            }
+        }
+        /**
+         * The hours component
+         *
+         * @returns {number} The hours component
+         * @memberof Duration
+         */
+        hours() {
+            return this.components().hours;
+        }
+        /**
+         * Returns a human-readable, locale-aware string for the duration (e.g. '2 days', 'in 2 days')
+         *
+         * @param {boolean} [withSuffix=false] - Include a relative suffix (past/future) based on the sign
+         * @returns {string} The humanized string
+         * @memberof Duration
+         */
+        humanize(withSuffix = false) {
+            const abs = Math.abs(this._ms);
+            const seconds = abs / 1000;
+            const minutes = seconds / 60;
+            const hours = minutes / 60;
+            const days = hours / 24;
+            let unit;
+            let value;
+            if (seconds < 45) {
+                unit = 'second';
+                value = Math.round(seconds);
+            }
+            else if (minutes < 45) {
+                unit = 'minute';
+                value = Math.round(minutes);
+            }
+            else if (hours < 22) {
+                unit = 'hour';
+                value = Math.round(hours);
+            }
+            else if (days < 26) {
+                unit = 'day';
+                value = Math.round(days);
+            }
+            else if (days / 30 < 11) {
+                unit = 'month';
+                value = Math.round(days / 30);
+            }
+            else {
+                unit = 'year';
+                value = Math.round(days / 365);
+            }
+            if (withSuffix) {
+                const signed = this._ms < 0 ? -value : value;
+                return new Intl.RelativeTimeFormat(this._locale, { numeric: 'auto' }).format(signed, unit);
+            }
+            return new Intl.NumberFormat(this._locale, { style: 'unit', unit, unitDisplay: 'long' }).format(value);
+        }
+        /**
+         * The milliseconds component
+         *
+         * @returns {number} The milliseconds component
+         * @memberof Duration
+         */
+        milliseconds() {
+            return this.components().milliseconds;
+        }
+        /**
+         * The minutes component
+         *
+         * @returns {number} The minutes component
+         * @memberof Duration
+         */
+        minutes() {
+            return this.components().minutes;
+        }
+        /**
+         * The months component after extracting whole years
+         *
+         * @returns {number} The months component
+         * @memberof Duration
+         */
+        months() {
+            return this.components().months;
+        }
+        /**
+         * The seconds component
+         *
+         * @returns {number} The seconds component
+         * @memberof Duration
+         */
+        seconds() {
+            return this.components().seconds;
+        }
+        /**
+         * Returns a new Duration with the given amount subtracted
+         *
+         * @param {number} value - The amount to subtract
+         * @param {DateUnit} [unit='millisecond'] - The unit of the amount
+         * @returns {Duration} The new Duration
+         * @memberof Duration
+         */
+        subtract(value, unit = 'millisecond') {
+            return this.add(-value, unit);
+        }
+        /**
+         * Returns the ISO 8601 duration representation (e.g. 'P1Y2M3DT4H5M6S')
+         *
+         * @returns {string} The ISO 8601 duration string
+         * @memberof Duration
+         */
+        toISOString() {
+            const c = this.components();
+            const sign = this._ms < 0 ? '-' : '';
+            const part = (value, suffix) => (value ? `${Math.abs(value)}${suffix}` : '');
+            const date = `${part(c.years, 'Y')}${part(c.months, 'M')}${part(c.days, 'D')}`;
+            const seconds = Math.abs(c.seconds) + Math.abs(c.milliseconds) / 1000;
+            const time = `${part(c.hours, 'H')}${part(c.minutes, 'M')}${seconds ? `${seconds}S` : ''}`;
+            if (!date && !time)
+                return 'P0D';
+            return `${sign}P${date}${time ? `T${time}` : ''}`;
+        }
+        /**
+         * Serializes the duration as its ISO 8601 string (so `JSON.stringify` works)
+         *
+         * @returns {string} The ISO 8601 duration string
+         * @memberof Duration
+         */
+        toJSON() {
+            return this.toISOString();
+        }
+        /**
+         * The total duration in milliseconds (enables numeric coercion, e.g. `+duration`)
+         *
+         * @returns {number} The duration in milliseconds
+         * @memberof Duration
+         */
+        valueOf() {
+            return this._ms;
+        }
+        /**
+         * The years component
+         *
+         * @returns {number} The years component
+         * @memberof Duration
+         */
+        years() {
+            return this.components().years;
+        }
+        absComponents() {
+            const c = this.components();
+            return {
+                years: Math.abs(c.years),
+                months: Math.abs(c.months),
+                weeks: Math.abs(c.weeks),
+                days: Math.abs(c.days),
+                hours: Math.abs(c.hours),
+                minutes: Math.abs(c.minutes),
+                seconds: Math.abs(c.seconds),
+                milliseconds: Math.abs(c.milliseconds),
+            };
+        }
+        /**
+         * Decomposes the absolute duration into signed calendar components (years → milliseconds).
+         */
+        components() {
+            const sign = this._ms < 0 ? -1 : 1;
+            let rem = Math.abs(this._ms);
+            const years = Math.floor(rem / RATIOS.year);
+            rem -= years * RATIOS.year;
+            const months = Math.floor(rem / RATIOS.month);
+            rem -= months * RATIOS.month;
+            const days = Math.floor(rem / RATIOS.day);
+            rem -= days * RATIOS.day;
+            const hours = Math.floor(rem / RATIOS.hour);
+            rem -= hours * RATIOS.hour;
+            const minutes = Math.floor(rem / RATIOS.minute);
+            rem -= minutes * RATIOS.minute;
+            const seconds = Math.floor(rem / RATIOS.second);
+            rem -= seconds * RATIOS.second;
+            return {
+                years: years * sign,
+                months: months * sign,
+                weeks: 0,
+                days: days * sign,
+                hours: hours * sign,
+                minutes: minutes * sign,
+                seconds: seconds * sign,
+                milliseconds: rem * sign,
+            };
+        }
+    }
+
+    /**
+     * Framework-agnostic, fully timezone-aware date utility class.
+     *
+     * Instances are immutable: every getter/setter-style method returns a brand new
+     * `DateTick` rather than mutating the current one, so it is safe to share instances
+     * across Angular components, React renders, Vue computed properties, or plain scripts.
+     *
+     * Every calendar operation — reading components, setting them, `add`/`subtract`,
+     * `startOf`/`endOf`, week/quarter math and formatting — is resolved through the configured
+     * IANA `timezone`, so a single absolute instant is consistently interpreted in one zone.
+     *
+     * @class DateTick
+     * @author Andreas Nicolaou <anicolaou66@gmail.com>
+     */
+    class DateTick {
+        _date;
+        _locale;
+        _ordinal;
+        _timezone;
+        _weekStartsOn;
+        /**
+         * Creates a new DateTick instance.
+         *
+         * @param {string} [locale='en'] - The BCP 47 locale used for formatting
+         * @param {string} [timezone] - The IANA timezone all calendar operations resolve through (defaults to the runtime's timezone)
+         * @param {DateInput} [date] - The wrapped instant or zoned wall-clock parts (defaults to now). Date instances are cloned defensively.
+         * @param {number} [weekStartsOn=0] - First day of the week (0 = Sunday … 6 = Saturday), used by `week()` and `startOf`/`endOf('week')`
+         * @param {OrdinalFn} [ordinal] - Overrides the English ordinal used by `ordinal()` and the `Do`/`wo`/`Wo` tokens
+         * @memberof DateTick
+         */
+        constructor(locale = 'en', timezone = DateTick.guessTimezone(), date, weekStartsOn = 0, ordinal) {
+            this._locale = locale;
+            this._timezone = timezone;
+            this._weekStartsOn = ((weekStartsOn % 7) + 7) % 7;
+            this._ordinal = ordinal;
+            if (date == null) {
+                this._date = new Date();
+            }
+            else {
+                this._date = DateTick.resolveInput(date, timezone);
+            }
+        }
+        /**
+         * Creates a {@link Duration} representing a length of time.
+         *
+         * @param {number | string | DurationInput} value - A millisecond amount, an amount paired with `unit`,
+         * an ISO 8601 duration string (e.g. 'P1Y2M10DT2H30M'), or a components object
+         * @param {DateUnit} [unit] - The unit when `value` is a number (defaults to milliseconds)
+         * @param {string} [locale='en'] - The locale used by `humanize()`
+         * @returns {Duration} The duration
+         * @example DateTick.duration(2, 'hour').humanize() // '2 hours'
+         * @memberof DateTick
+         */
+        static duration(value, unit, locale = 'en') {
+            return new Duration(value, unit, locale);
+        }
+        /**
+         * Returns the runtime's best-guess IANA timezone.
+         *
+         * @returns {string} The guessed IANA timezone
+         * @memberof DateTick
+         */
+        static guessTimezone() {
+            return Intl.DateTimeFormat().resolvedOptions().timeZone;
+        }
+        /**
+         * Checks whether a value is a DateTick instance.
+         *
+         * @param {unknown} value - The value to check
+         * @returns {boolean} True if the value is a DateTick
+         * @memberof DateTick
+         */
+        static isDateTick(value) {
+            return value instanceof DateTick;
+        }
+        /**
+         * Checks if a date value is valid
+         *
+         * @param {DateInput} date - The date to validate
+         * @returns {boolean} True if valid, false otherwise
+         * @memberof DateTick
+         */
+        static isValid(date) {
+            const d = DateTick.resolveInput(date);
+            return !Number.isNaN(d.getTime());
+        }
+        /**
+         * Returns the maximum (latest) date from a list
+         *
+         * @param {...DateInput[]} dates - Dates to compare
+         * @returns {Date} The latest date
+         * @memberof DateTick
+         */
+        static max(...dates) {
+            const maxTime = Math.max(...dates.map((d) => DateTick.resolveInput(d).getTime()));
+            return new Date(maxTime);
+        }
+        /**
+         * Returns the minimum (earliest) date from a list
+         *
+         * @param {...DateInput[]} dates - Dates to compare
+         * @returns {Date} The earliest date
+         * @memberof DateTick
+         */
+        static min(...dates) {
+            const minTime = Math.min(...dates.map((d) => DateTick.resolveInput(d).getTime()));
+            return new Date(minTime);
+        }
+        /**
+         * Parses a string into a DateTick using an explicit token pattern, interpreting the wall-clock
+         * values in the given timezone. Supported tokens mirror {@link DateTick.formatPattern}; anything
+         * else (and text wrapped in `[square brackets]`) is treated as a literal.
+         *
+         * @param {string} input - The string to parse (e.g. '25/06/2026 22:23')
+         * @param {string} pattern - The token pattern (e.g. 'DD/MM/YYYY HH:mm')
+         * @param {string} [locale='en'] - The BCP 47 locale (also used to resolve month names)
+         * @param {string} [timezone] - The IANA timezone the wall-clock values belong to
+         * @returns {DateTick} The parsed DateTick
+         * @throws {Error} If the input does not match the pattern
+         * @memberof DateTick
+         */
+        static parse(input, pattern, locale = 'en', timezone = DateTick.guessTimezone()) {
+            const acc = { year: 1970, month: 0, day: 1, hour: 0, minute: 0, second: 0, millisecond: 0 };
+            let pm = false;
+            let hasMeridiem = false;
+            let epoch = null;
+            let regex = '^';
+            const handlers = [];
+            const digits = (token, wide, narrow) => (token === wide ? '(\\d{2})' : narrow);
+            const unableToParse = () => new Error(`Unable to parse "${input}" with pattern "${pattern}"`);
+            const assertRange = (value, min, max) => {
+                if (!Number.isInteger(value) || value < min || value > max)
+                    throw unableToParse();
+            };
+            for (const token of splitTokens(pattern, locale)) {
+                switch (token) {
+                    case 'YYYY':
+                        regex += '(\\d{4})';
+                        handlers.push((v) => (acc.year = Number(v)));
+                        break;
+                    case 'YY':
+                        regex += '(\\d{2})';
+                        handlers.push((v) => (acc.year = 2000 + Number(v)));
+                        break;
+                    case 'MMMM':
+                    case 'MMM': {
+                        const names = localeMonthNames(locale, token === 'MMMM' ? 'long' : 'short');
+                        // Match the actual month names (longest-first so a name that prefixes another wins) rather
+                        // than a greedy `.{1,max}` wildcard, which backtracks into adjacent tokens when there is no
+                        // separator between them (e.g. `MMMMDo` parsing `May25th`).
+                        const alternation = [...names]
+                            .sort((a, b) => b.length - a.length)
+                            .map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+                            .join('|');
+                        regex += `(${alternation})`;
+                        handlers.push((v) => {
+                            const normalized = v.toLocaleLowerCase(locale);
+                            const idx = names.findIndex((n) => n.toLocaleLowerCase(locale) === normalized);
+                            if (idx < 0)
+                                throw unableToParse();
+                            acc.month = idx;
+                        });
+                        break;
+                    }
+                    case 'MM':
+                    case 'M':
+                        regex += digits(token, 'MM', '(\\d{1,2})');
+                        handlers.push((v) => {
+                            const month = Number(v);
+                            assertRange(month, 1, 12);
+                            acc.month = month - 1;
+                        });
+                        break;
+                    case 'DD':
+                    case 'D':
+                        regex += digits(token, 'DD', '(\\d{1,2})');
+                        handlers.push((v) => {
+                            const day = Number(v);
+                            assertRange(day, 1, 31);
+                            acc.day = day;
+                        });
+                        break;
+                    case 'HH':
+                    case 'H':
+                        regex += digits(token, 'HH', '(\\d{1,2})');
+                        handlers.push((v) => {
+                            const hour = Number(v);
+                            assertRange(hour, 0, 23);
+                            acc.hour = hour;
+                        });
+                        break;
+                    case 'hh':
+                    case 'h':
+                        regex += digits(token, 'hh', '(\\d{1,2})');
+                        handlers.push((v) => {
+                            const hour = Number(v);
+                            assertRange(hour, 1, 12);
+                            acc.hour = hour;
+                        });
+                        break;
+                    case 'mm':
+                    case 'm':
+                        regex += digits(token, 'mm', '(\\d{1,2})');
+                        handlers.push((v) => {
+                            const minute = Number(v);
+                            assertRange(minute, 0, 59);
+                            acc.minute = minute;
+                        });
+                        break;
+                    case 'ss':
+                    case 's':
+                        regex += digits(token, 'ss', '(\\d{1,2})');
+                        handlers.push((v) => {
+                            const second = Number(v);
+                            assertRange(second, 0, 59);
+                            acc.second = second;
+                        });
+                        break;
+                    case 'SSS':
+                        regex += '(\\d{3})';
+                        handlers.push((v) => (acc.millisecond = Number(v)));
+                        break;
+                    case 'kk':
+                    case 'k':
+                        regex += digits(token, 'kk', '(\\d{1,2})');
+                        handlers.push((v) => {
+                            const hour = Number(v);
+                            assertRange(hour, 1, 24);
+                            acc.hour = hour % 24;
+                        });
+                        break;
+                    case 'Do':
+                        regex += '(\\d{1,2})(?:st|nd|rd|th)';
+                        handlers.push((v) => {
+                            const day = Number(v);
+                            assertRange(day, 1, 31);
+                            acc.day = day;
+                        });
+                        break;
+                    case 'A':
+                    case 'a':
+                        regex += `(${meridiemRegexGroup(locale)})`;
+                        handlers.push((v) => {
+                            hasMeridiem = true;
+                            pm = v.toLocaleLowerCase(locale) === localeMeridiems(locale).pm.toLocaleLowerCase(locale);
+                        });
+                        break;
+                    case 'X':
+                        regex += '(-?\\d{1,16})';
+                        handlers.push((v) => (epoch = Number(v) * 1000));
+                        break;
+                    case 'x':
+                        regex += '(-?\\d{1,16})';
+                        handlers.push((v) => (epoch = Number(v)));
+                        break;
+                    // Derived values that cannot reconstruct an instant on their own: consume but ignore.
+                    case 'Q':
+                    case 'w':
+                    case 'ww':
+                    case 'wo':
+                    case 'W':
+                    case 'WW':
+                    case 'Wo':
+                        regex += '(\\d{1,2})(?:st|nd|rd|th)?';
+                        handlers.push(() => undefined);
+                        break;
+                    default: {
+                        const literal = token.startsWith('[') && token.endsWith(']') ? token.slice(1, -1) : token;
+                        regex += literal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    }
+                }
+            }
+            regex += '$';
+            const match = new RegExp(regex, 'i').exec(input.trim());
+            if (!match)
+                throw unableToParse();
+            handlers.forEach((handler, i) => handler(match[i + 1]));
+            if (epoch !== null)
+                return new DateTick(locale, timezone, new Date(epoch));
+            if (hasMeridiem) {
+                if (pm && acc.hour < 12)
+                    acc.hour += 12;
+                if (!pm && acc.hour === 12)
+                    acc.hour = 0;
+            }
+            if (acc.day > getDaysInMonth(acc.year, acc.month))
+                throw unableToParse();
+            return new DateTick(locale, timezone, instantFromParts(acc, timezone));
+        }
+        static inputParts(input) {
+            if (Array.isArray(input)) {
+                return {
+                    year: input[0],
+                    month: input[1],
+                    day: input[2],
+                    hour: input[3] ?? 0,
+                    minute: input[4] ?? 0,
+                    second: input[5] ?? 0,
+                    millisecond: input[6] ?? 0,
+                };
+            }
+            return {
+                year: input.year,
+                month: input.month,
+                day: input.date,
+                hour: input.hour ?? 0,
+                minute: input.minute ?? 0,
+                second: input.second ?? 0,
+                millisecond: input.millisecond ?? 0,
+            };
+        }
+        static resolveInput(input, timezone = DateTick.guessTimezone()) {
+            if (input instanceof DateTick)
+                return input.toDate();
+            if (input instanceof Date)
+                return new Date(input.getTime());
+            if (typeof input === 'string')
+                return new Date(input);
+            if (typeof input === 'number')
+                return new Date(input);
+            return instantFromParts(DateTick.inputParts(input), timezone);
+        }
+        /**
+         * Adds a specified amount of time to the wrapped date (chainable, immutable).
+         *
+         * Calendar units (`date`/`day`, `week`, `month`, `quarter`, `year`) preserve the wall-clock
+         * time in the configured timezone (so they survive DST). Fixed-duration units
+         * (`millisecond`/`second`/`minute`/`hour`) add absolute time. Month/year additions clamp the day
+         * to the last day of the resulting month instead of overflowing (Jan 31 + 1 month -> Feb 28/29).
+         *
+         * @param {number} amount - The amount to add (negative values subtract)
+         * @param {DateUnit} unit - The unit to add (e.g. 'day', 'month')
+         * @returns {DateTick} A new DateTick with the result
+         * @memberof DateTick
+         */
+        add(amount, unit) {
+            switch (unit) {
+                case 'millisecond':
+                    return this.withDate(new Date(this._date.getTime() + amount));
+                case 'second':
+                    return this.withDate(new Date(this._date.getTime() + amount * 1000));
+                case 'minute':
+                    return this.withDate(new Date(this._date.getTime() + amount * 60_000));
+                case 'hour':
+                    return this.withDate(new Date(this._date.getTime() + amount * 3_600_000));
+                case 'date':
+                case 'day':
+                    return this.rebuild({ day: this.parts().day + amount });
+                case 'week':
+                    return this.rebuild({ day: this.parts().day + amount * 7 });
+                case 'month':
+                    return this.addMonths(amount);
+                case 'quarter':
+                    return this.addMonths(amount * 3);
+                case 'year':
+                    return this.addMonths(amount * 12);
+                default:
+                    return this.clone();
+            }
+        }
+        /**
+         * Formats the date as a calendar-style relative label such as "Today at 7:23 PM".
+         *
+         * @param {DateInput} [reference] - The date to compare against (defaults to now)
+         * @param {CalendarDisplayFormats} [formats] - Token patterns or callbacks for each calendar bucket
+         * @returns {string} The calendar-style label
+         * @memberof DateTick
+         */
+        calendar(reference = new Date(), formats = {}) {
+            const diff = this.diffCalendar(reference, 'day');
+            const key = diff < -6
+                ? 'sameElse'
+                : diff < -1
+                    ? 'lastWeek'
+                    : diff === -1
+                        ? 'lastDay'
+                        : diff === 0
+                            ? 'sameDay'
+                            : diff === 1
+                                ? 'nextDay'
+                                : diff < 7
+                                    ? 'nextWeek'
+                                    : 'sameElse';
+            const defaults = {
+                sameDay: '[Today at] LT',
+                nextDay: '[Tomorrow at] LT',
+                nextWeek: 'dddd [at] LT',
+                lastDay: '[Yesterday at] LT',
+                lastWeek: '[Last] dddd [at] LT',
+                sameElse: 'L',
+            };
+            const format = formats[key] ?? defaults[key];
+            return typeof format === 'function' ? format(this) : this.formatPattern(format);
+        }
+        /**
+         * Returns localized month-grid data for rendering a calendar UI.
+         *
+         * The grid is padded with adjacent-month dates so every week has seven cells,
+         * and the weekday order follows the configured `weekStartsOn`.
+         *
+         * @returns {CalendarMonth} Calendar data for the wrapped date's month
+         * @memberof DateTick
+         */
+        calendarMonth(options = {}) {
+            const selected = options.selected === false
+                ? null
+                : partsOf(options.selected === undefined ? this._date : this.toComparable(options.selected), this._timezone);
+            const firstOfMonth = this.rebuild({ day: 1 }).startOf('day');
+            const first = firstOfMonth.parts();
+            const leadingDays = (first.weekday - this._weekStartsOn + 7) % 7;
+            const daysInMonth = getDaysInMonth(first.year, first.month);
+            const cellCount = Math.ceil((leadingDays + daysInMonth) / 7) * 7;
+            const start = firstOfMonth.subtract(leadingDays, 'day');
+            const today = new DateTick(this._locale, this._timezone, new Date(), this._weekStartsOn).parts();
+            const monthLabel = new Intl.DateTimeFormat(this._locale, {
+                month: 'long',
+                year: 'numeric',
+                timeZone: this._timezone,
+            }).format(firstOfMonth.toDate());
+            const formatDate = (date) => {
+                if (options.dateFormat == null) {
+                    return date.format({ year: 'numeric', month: '2-digit', day: '2-digit' });
+                }
+                if (typeof options.dateFormat === 'function')
+                    return options.dateFormat(date);
+                if (typeof options.dateFormat === 'string')
+                    return date.formatPattern(options.dateFormat);
+                return date.format(options.dateFormat);
+            };
+            const weekdays = Array.from({ length: 7 }, (_, i) => {
+                const day = (this._weekStartsOn + i) % 7;
+                const sample = new Date(Date.UTC(2020, 5, 7 + day));
+                return {
+                    day,
+                    isoDay: day === 0 ? 7 : day,
+                    long: new Intl.DateTimeFormat(this._locale, { weekday: 'long', timeZone: 'UTC' }).format(sample),
+                    short: new Intl.DateTimeFormat(this._locale, { weekday: 'short', timeZone: 'UTC' }).format(sample),
+                    narrow: new Intl.DateTimeFormat(this._locale, { weekday: 'narrow', timeZone: 'UTC' }).format(sample),
+                };
+            });
+            const days = Array.from({ length: cellCount }, (_, i) => {
+                const value = start.add(i, 'day');
+                const p = value.parts();
+                return {
+                    value,
+                    isoDate: value.formatPattern('YYYY-MM-DD'),
+                    formatted: formatDate(value),
+                    year: p.year,
+                    month: p.month,
+                    date: p.day,
+                    day: p.weekday,
+                    isoDay: p.weekday === 0 ? 7 : p.weekday,
+                    isCurrentMonth: p.year === first.year && p.month === first.month,
+                    isToday: p.year === today.year && p.month === today.month && p.day === today.day,
+                    isSelected: Boolean(selected && p.year === selected.year && p.month === selected.month && p.day === selected.day),
+                };
+            });
+            return {
+                year: first.year,
+                month: first.month,
+                label: monthLabel,
+                weekdays,
+                days,
+                weeks: Array.from({ length: days.length / 7 }, (_, i) => days.slice(i * 7, i * 7 + 7)),
+            };
+        }
+        /**
+         * Returns a new DateTick with the exact same instant, locale and timezone
+         *
+         * @returns {DateTick} The cloned instance
+         * @memberof DateTick
+         */
+        clone() {
+            return this.withDate(this._date);
+        }
+        date(value) {
+            if (value == null)
+                return this.parts().day;
+            return this.rebuild({ day: value });
+        }
+        dates(value) {
+            return value == null ? this.date() : this.date(value);
+        }
+        day(value) {
+            const p = this.parts();
+            if (value == null)
+                return p.weekday;
+            return this.rebuild({ day: p.day - p.weekday + value });
+        }
+        dayOfYear(value) {
+            if (value == null) {
+                const p = this.parts();
+                const startOfYear = Date.UTC(p.year, 0, 1);
+                const current = Date.UTC(p.year, p.month, p.day);
+                return Math.round((current - startOfYear) / 86_400_000) + 1;
+            }
+            return this.rebuild({ month: 0, day: value });
+        }
+        days(value) {
+            return value == null ? this.day() : this.day(value);
+        }
+        /**
+         * Gets the number of days in the wrapped date's month (in the configured timezone)
+         *
+         * @returns {number} The number of days in the month
+         * @memberof DateTick
+         */
+        daysInMonth() {
+            const p = this.parts();
+            return getDaysInMonth(p.year, p.month);
+        }
+        /**
+         * Gets the difference between the wrapped date and another date.
+         *
+         * @param {DateInput} date - The date to compare against
+         * @param {DateUnit} [unit='millisecond'] - The unit of measurement
+         * @param {boolean} [precise=false] - When true, returns a floating-point value instead of truncating.
+         * For `month`/`quarter`/`year` the fractional part reflects progress through the current calendar unit.
+         * @returns {number} The difference (positive when the wrapped date is later)
+         * @memberof DateTick
+         */
+        diff(date, unit = 'millisecond', precise = false) {
+            const other = this.toComparable(date);
+            const diffMs = this._date.getTime() - other.getTime();
+            const scale = (ms) => (precise ? ms : Math.trunc(ms));
+            switch (unit) {
+                case 'millisecond':
+                    return diffMs;
+                case 'second':
+                    return scale(diffMs / 1000);
+                case 'minute':
+                    return scale(diffMs / 60_000);
+                case 'hour':
+                    return scale(diffMs / 3_600_000);
+                case 'date':
+                case 'day':
+                    return scale(diffMs / 86_400_000);
+                case 'week':
+                    return scale(diffMs / 604_800_000);
+                case 'month':
+                    return precise ? this.preciseCalendarDiff(other, 1) : this.wholeMonthDiff(other, 1);
+                case 'quarter':
+                    return precise ? this.preciseCalendarDiff(other, 3) : this.wholeMonthDiff(other, 3);
+                case 'year':
+                    return precise ? this.preciseCalendarDiff(other, 12) : this.wholeMonthDiff(other, 12);
+                default:
+                    return diffMs;
+            }
+        }
+        /**
+         * Calendar-boundary difference in the configured timezone.
+         *
+         * Unlike {@link DateTick.diff}, this counts calendar units rather than elapsed duration.
+         * For example, Friday 23:00 to Saturday 01:00 is one calendar day apart even though
+         * only two hours elapsed.
+         *
+         * @param {DateInput} date - The date to compare against
+         * @param {CalendarDiffUnit} [unit='day'] - Calendar unit to compare
+         * @returns {number} The calendar difference, positive when this instance is later
+         * @memberof DateTick
+         */
+        diffCalendar(date, unit = 'day') {
+            const other = this.withDate(this.toComparable(date));
+            switch (unit) {
+                case 'date':
+                case 'day':
+                    return this.calendarDayNumber() - other.calendarDayNumber();
+                case 'week':
+                    return Math.trunc((this.startOf('week').calendarDayNumber() - other.startOf('week').calendarDayNumber()) / 7);
+                case 'month': {
+                    const a = this.parts();
+                    const b = other.parts();
+                    return (a.year - b.year) * 12 + (a.month - b.month);
+                }
+                case 'quarter': {
+                    const a = this.parts();
+                    const b = other.parts();
+                    return (a.year - b.year) * 4 + (Math.floor(a.month / 3) - Math.floor(b.month / 3));
+                }
+                case 'year':
+                    return this.parts().year - other.parts().year;
+                default:
+                    return Number.NaN;
+            }
+        }
+        /**
+         * Returns a new DateTick set to the end of the given unit (one millisecond before the next unit starts)
+         *
+         * @param {DateUnit} unit - The unit to snap to (e.g. 'month', 'day')
+         * @returns {DateTick} A new DateTick at the end of the unit
+         * @memberof DateTick
+         */
+        endOf(unit) {
+            if (unit === 'millisecond')
+                return this.clone();
+            const next = this.startOf(unit).add(1, unit);
+            return this.withDate(new Date(next.valueOf() - 1));
+        }
+        /**
+         * Formats a date using Intl.DateTimeFormat or a preset (in the configured timezone)
+         *
+         * @param {Intl.DateTimeFormatOptions | DateFormatPreset} [format] - Format options or preset
+         * @returns {string} The formatted date string
+         * @memberof DateTick
+         */
+        format(format) {
+            const options = typeof format === 'string' ? this.getPreset(format) : format;
+            return new Intl.DateTimeFormat(this._locale, {
+                timeZone: this._timezone,
+                ...options,
+            }).format(this._date);
+        }
+        /**
+         * Formats the date using a token pattern, resolved in the configured timezone.
+         *
+         * Core tokens: `YYYY` `YY` `MMMM` `MMM` `MM` `M` `DD` `D` `dddd` `ddd` `dd` `d` `HH` `H` `hh` `h`
+         * `mm` `m` `ss` `s` `SSS` `A` `a` `Z` `ZZ`. Advanced: `Do` `Q` `k` `kk` `X` `x` `w` `ww` `wo` `W` `WW` `Wo`.
+         * Localized (resolved to the configured locale's field order and separators): `L` `LL` `LLL` `LLLL`
+         * `l` `ll` `lll` `llll` `LT` `LTS`. Wrap literal text in `[square brackets]`.
+         *
+         * @param {string} pattern - The token pattern (e.g. 'DD/MM/YYYY HH:mm')
+         * @returns {string} The formatted string
+         * @example date.formatPattern('DD/MM/YYYY') // '25/06/2026'
+         * @memberof DateTick
+         */
+        formatPattern(pattern) {
+            const p = this.parts();
+            const two = (n) => String(n).padStart(2, '0');
+            const intl = (opts) => new Intl.DateTimeFormat(this._locale, { timeZone: this._timezone, ...opts }).format(this._date);
+            const hour12 = p.hour % 12 === 0 ? 12 : p.hour % 12;
+            const hour24From1 = p.hour === 0 ? 24 : p.hour;
+            const meridiem = localeMeridiems(this._locale);
+            const dayPeriod = p.hour < 12 ? meridiem.am : meridiem.pm;
+            const map = {
+                YYYY: String(p.year).padStart(4, '0'),
+                YY: two(p.year % 100),
+                MMMM: intl({ month: 'long' }),
+                MMM: intl({ month: 'short' }),
+                MM: two(p.month + 1),
+                M: String(p.month + 1),
+                Do: this.ordinal(),
+                DD: two(p.day),
+                D: String(p.day),
+                dddd: intl({ weekday: 'long' }),
+                ddd: intl({ weekday: 'short' }),
+                dd: intl({ weekday: 'narrow' }),
+                d: String(p.weekday),
+                HH: two(p.hour),
+                H: String(p.hour),
+                hh: two(hour12),
+                h: String(hour12),
+                kk: two(hour24From1),
+                k: String(hour24From1),
+                mm: two(p.minute),
+                m: String(p.minute),
+                SSS: String(p.millisecond).padStart(3, '0'),
+                ss: two(p.second),
+                s: String(p.second),
+                A: dayPeriod,
+                a: dayPeriod.toLocaleLowerCase(this._locale),
+                Q: String(this.quarter()),
+                ww: two(this.week()),
+                w: String(this.week()),
+                wo: this.ordinalFor(this.week()),
+                WW: two(this.isoWeek()),
+                W: String(this.isoWeek()),
+                Wo: this.ordinalFor(this.isoWeek()),
+                X: String(this.unix()),
+                x: String(this.valueOf()),
+                Z: this.offsetString(true),
+                ZZ: this.offsetString(false),
+            };
+            return splitTokens(pattern, this._locale)
+                .map((token) => {
+                if (token.startsWith('[') && token.endsWith(']'))
+                    return token.slice(1, -1);
+                return token in map ? map[token] : token;
+            })
+                .join('');
+        }
+        /**
+         * Formats the date relative to another date, Day.js-style.
+         *
+         * @param {DateInput} date - The date to compare from
+         * @param {boolean} [withoutSuffix=false] - When true, omit "ago" / "in"
+         * @returns {string} The relative-time label
+         * @memberof DateTick
+         */
+        from(date, withoutSuffix = false) {
+            const diff = this._date.getTime() - this.toComparable(date).getTime();
+            const duration = DateTick.duration(diff, 'millisecond', this._locale);
+            return withoutSuffix ? duration.humanize() : duration.humanize(true);
+        }
+        /**
+         * Formats the date relative to now, Day.js-style.
+         *
+         * @param {boolean} [withoutSuffix=false] - When true, omit "ago" / "in"
+         * @returns {string} The relative-time label
+         * @memberof DateTick
+         */
+        fromNow(withoutSuffix = false) {
+            return this.from(new Date(), withoutSuffix);
+        }
+        /**
+         * Gets a specific unit (or derived value) from the wrapped date
+         *
+         * @param {DateGettableUnit} unit - The unit to get (e.g. 'year', 'isoWeek')
+         * @returns {number} The value of the unit
+         * @memberof DateTick
+         */
+        get(unit) {
+            switch (unit) {
+                case 'millisecond':
+                    return this.millisecond();
+                case 'second':
+                    return this.second();
+                case 'minute':
+                    return this.minute();
+                case 'hour':
+                    return this.hour();
+                case 'date':
+                    return this.date();
+                case 'day':
+                    return this.day();
+                case 'week':
+                    return this.week();
+                case 'month':
+                    return this.month();
+                case 'quarter':
+                    return this.quarter();
+                case 'year':
+                    return this.year();
+                case 'dayOfYear':
+                    return this.dayOfYear();
+                case 'isoDay':
+                    return this.isoDay();
+                case 'isoWeek':
+                    return this.isoWeek();
+                case 'isoWeekYear':
+                    return this.isoWeekYear();
+                case 'isoWeeksInYear':
+                    return this.isoWeeksInYear();
+                case 'weekYear':
+                    return this.weekYear();
+                case 'weekday':
+                    return this.weekday();
+                case 'weeksInYear':
+                    return this.weeksInYear();
+                case 'daysInMonth':
+                    return this.daysInMonth();
+                default:
+                    return Number.NaN;
+            }
+        }
+        hour(value) {
+            if (value == null)
+                return this.parts().hour;
+            return this.rebuild({ hour: value });
+        }
+        hours(value) {
+            return value == null ? this.hour() : this.hour(value);
+        }
+        /**
+         * Checks if the wrapped date is strictly after another date
+         *
+         * @param {DateInput} date - The date to compare against
+         * @returns {boolean} True if the wrapped date is later
+         * @memberof DateTick
+         */
+        isAfter(date) {
+            return this._date.getTime() > this.toComparable(date).getTime();
+        }
+        /**
+         * Checks if the wrapped date is strictly before another date
+         *
+         * @param {DateInput} date - The date to compare against
+         * @returns {boolean} True if the wrapped date is earlier
+         * @memberof DateTick
+         */
+        isBefore(date) {
+            return this._date.getTime() < this.toComparable(date).getTime();
+        }
+        /**
+         * Checks if the wrapped date falls between two dates.
+         *
+         * @param {DateInput} start - The lower bound
+         * @param {DateInput} end - The upper bound
+         * @param {boolean | Inclusivity} [inclusivity=false] - `false`/`'()'` excludes both bounds,
+         * `true`/`'[]'` includes both, or use `'(]'`/`'[)'` to control each side independently
+         * @returns {boolean} True if the wrapped date is between start and end
+         * @memberof DateTick
+         */
+        isBetween(start, end, inclusivity = false) {
+            const time = this._date.getTime();
+            const startTime = this.toComparable(start).getTime();
+            const endTime = this.toComparable(end).getTime();
+            const mode = typeof inclusivity === 'boolean' ? (inclusivity ? '[]' : '()') : inclusivity;
+            const afterStart = mode[0] === '[' ? time >= startTime : time > startTime;
+            const beforeEnd = mode[1] === ']' ? time <= endTime : time < endTime;
+            return afterStart && beforeEnd;
+        }
+        /**
+         * Checks if the wrapped date's year is a leap year (in the configured timezone)
+         *
+         * @returns {boolean} True if the year is a leap year
+         * @memberof DateTick
+         */
+        isLeapYear() {
+            const year = this.parts().year;
+            return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+        }
+        /**
+         * Checks if the wrapped date is the same as another date, optionally truncated to a unit
+         *
+         * @param {DateInput} date - The date to compare against
+         * @param {DateUnit} [unit] - When provided, compares after snapping both dates to the start of this unit
+         * @returns {boolean} True if the dates are the same
+         * @memberof DateTick
+         */
+        isSame(date, unit) {
+            const other = this.toComparable(date);
+            if (!unit)
+                return this._date.getTime() === other.getTime();
+            return this.startOf(unit).valueOf() === this.withDate(other).startOf(unit).valueOf();
+        }
+        /**
+         * Checks if the wrapped date is the same as or after another date, optionally truncated to a unit
+         *
+         * @param {DateInput} date - The date to compare against
+         * @param {DateUnit} [unit] - When provided, compares after snapping both dates to the start of this unit
+         * @returns {boolean} True if the wrapped date is the same as or later than the other
+         * @memberof DateTick
+         */
+        isSameOrAfter(date, unit) {
+            return this.isSame(date, unit) || this.isAfter(date);
+        }
+        /**
+         * Checks if the wrapped date is the same as or before another date, optionally truncated to a unit
+         *
+         * @param {DateInput} date - The date to compare against
+         * @param {DateUnit} [unit] - When provided, compares after snapping both dates to the start of this unit
+         * @returns {boolean} True if the wrapped date is the same as or earlier than the other
+         * @memberof DateTick
+         */
+        isSameOrBefore(date, unit) {
+            return this.isSame(date, unit) || this.isBefore(date);
+        }
+        /**
+         * Checks if the wrapped date is today in the configured timezone.
+         *
+         * @returns {boolean} True if the date is today
+         * @memberof DateTick
+         */
+        isToday() {
+            return this.diffCalendar(new Date(), 'day') === 0;
+        }
+        /**
+         * Checks if the wrapped date is tomorrow in the configured timezone.
+         *
+         * @returns {boolean} True if the date is tomorrow
+         * @memberof DateTick
+         */
+        isTomorrow() {
+            return this.diffCalendar(new Date(), 'day') === 1;
+        }
+        /**
+         * Checks whether the wrapped date itself is a valid date
+         *
+         * @returns {boolean} True if valid, false otherwise
+         * @memberof DateTick
+         */
+        isValid() {
+            return DateTick.isValid(this._date);
+        }
+        /**
+         * Checks if the wrapped date is yesterday in the configured timezone.
+         *
+         * @returns {boolean} True if the date is yesterday
+         * @memberof DateTick
+         */
+        isYesterday() {
+            return this.diffCalendar(new Date(), 'day') === -1;
+        }
+        /**
+         * Gets the ISO day of the week (1-7, Monday-Sunday, in the configured timezone)
+         *
+         * @returns {number} The ISO day
+         * @memberof DateTick
+         */
+        isoDay() {
+            const weekday = this.parts().weekday;
+            return weekday === 0 ? 7 : weekday;
+        }
+        /**
+         * Gets the ISO week number (in the configured timezone)
+         *
+         * @returns {number} The ISO week number
+         * @memberof DateTick
+         */
+        isoWeek() {
+            const target = this.isoThursday();
+            const yearStart = new Date(Date.UTC(target.getUTCFullYear(), 0, 1));
+            return Math.ceil(((target.getTime() - yearStart.getTime()) / 86_400_000 + 1) / 7);
+        }
+        /**
+         * Gets the ISO week year (in the configured timezone)
+         *
+         * @returns {number} The ISO week year
+         * @memberof DateTick
+         */
+        isoWeekYear() {
+            return this.weekYear();
+        }
+        /**
+         * Gets the number of ISO weeks in the year (in the configured timezone)
+         *
+         * @returns {number} The number of ISO weeks
+         * @memberof DateTick
+         */
+        isoWeeksInYear() {
+            return this.weeksInYearBy((t) => t.isoWeek());
+        }
+        /**
+         * Returns a new DateTick in the runtime's local timezone, keeping the same instant.
+         *
+         * @returns {DateTick} The local-timezone instance
+         * @memberof DateTick
+         */
+        local() {
+            return this.withTimezone(DateTick.guessTimezone());
+        }
+        /**
+         * Gets the configured locale
+         *
+         * @returns {string} The BCP 47 locale
+         * @memberof DateTick
+         */
+        locale() {
+            return this._locale;
+        }
+        /**
+         * Returns locale metadata (month/weekday names, first day of week, meridiems, ordinal), resolved
+         * through `Intl` — the Day.js `localeData()` equivalent.
+         *
+         * @returns {LocaleData} The locale metadata
+         * @example datetick('2026-06-25', { locale: 'fr' }).localeData().months()[0] // 'janvier'
+         * @memberof DateTick
+         */
+        localeData() {
+            const locale = this._locale;
+            const meridiems = localeMeridiems(locale);
+            return {
+                months: () => localeMonthNames(locale, 'long'),
+                monthsShort: () => localeMonthNames(locale, 'short'),
+                weekdays: () => localeWeekdayNames(locale, 'long'),
+                weekdaysShort: () => localeWeekdayNames(locale, 'short'),
+                weekdaysMin: () => localeWeekdayNames(locale, 'narrow'),
+                firstDayOfWeek: () => this._weekStartsOn,
+                meridiems: () => ({ ...meridiems }),
+                meridiem: (hour, isLowercase = false) => {
+                    const marker = hour < 12 ? meridiems.am : meridiems.pm;
+                    return isLowercase ? marker.toLocaleLowerCase(locale) : marker;
+                },
+                ordinal: (n) => this.ordinalFor(n),
+            };
+        }
+        millisecond(value) {
+            if (value == null)
+                return this.parts().millisecond;
+            return this.rebuild({ millisecond: value });
+        }
+        milliseconds(value) {
+            return value == null ? this.millisecond() : this.millisecond(value);
+        }
+        minute(value) {
+            if (value == null)
+                return this.parts().minute;
+            return this.rebuild({ minute: value });
+        }
+        minutes(value) {
+            return value == null ? this.minute() : this.minute(value);
+        }
+        month(value) {
+            if (value == null)
+                return this.parts().month;
+            return this.rebuild({ month: value });
+        }
+        months(value) {
+            return value == null ? this.month() : this.month(value);
+        }
+        /**
+         * Gets the day of the month with its ordinal suffix (e.g. '1st', '22nd', '31st'). English by default,
+         * or the factory's `ordinal` override when one is configured.
+         *
+         * @returns {string} The ordinal day-of-month
+         * @memberof DateTick
+         */
+        ordinal() {
+            return this.ordinalFor(this.parts().day);
+        }
+        quarter(value) {
+            const month = this.parts().month;
+            if (value == null)
+                return Math.floor(month / 3) + 1;
+            return this.month((month % 3) + 3 * (value - 1));
+        }
+        second(value) {
+            if (value == null)
+                return this.parts().second;
+            return this.rebuild({ second: value });
+        }
+        seconds(value) {
+            return value == null ? this.second() : this.second(value);
+        }
+        /**
+         * Sets a specific unit on the wrapped date
+         *
+         * @param {DateUnit} unit - The unit to set (e.g. 'year', 'month')
+         * @param {number} value - The value to set
+         * @returns {DateTick} A new DateTick with the result
+         * @memberof DateTick
+         */
+        set(unit, value) {
+            switch (unit) {
+                case 'millisecond':
+                    return this.millisecond(value);
+                case 'second':
+                    return this.second(value);
+                case 'minute':
+                    return this.minute(value);
+                case 'hour':
+                    return this.hour(value);
+                case 'date':
+                    return this.date(value);
+                case 'day':
+                    return this.day(value);
+                case 'month':
+                    return this.month(value);
+                case 'quarter':
+                    return this.quarter(value);
+                case 'year':
+                    return this.year(value);
+                default:
+                    throw new Error(`Invalid unit for set(): ${unit}`);
+            }
+        }
+        /**
+         * Returns a new DateTick set to the start of the given unit (in the configured timezone)
+         *
+         * @param {DateUnit} unit - The unit to snap to (e.g. 'month', 'day')
+         * @returns {DateTick} A new DateTick at the start of the unit
+         * @memberof DateTick
+         */
+        startOf(unit) {
+            const p = this.parts();
+            switch (unit) {
+                case 'year':
+                    return this.rebuild({ month: 0, day: 1, hour: 0, minute: 0, second: 0, millisecond: 0 });
+                case 'quarter':
+                    return this.rebuild({
+                        month: Math.floor(p.month / 3) * 3,
+                        day: 1,
+                        hour: 0,
+                        minute: 0,
+                        second: 0,
+                        millisecond: 0,
+                    });
+                case 'month':
+                    return this.rebuild({ day: 1, hour: 0, minute: 0, second: 0, millisecond: 0 });
+                case 'week': {
+                    const offset = (p.weekday - this._weekStartsOn + 7) % 7;
+                    return this.rebuild({ day: p.day - offset, hour: 0, minute: 0, second: 0, millisecond: 0 });
+                }
+                case 'date':
+                case 'day':
+                    return this.rebuild({ hour: 0, minute: 0, second: 0, millisecond: 0 });
+                case 'hour':
+                    return this.rebuild({ minute: 0, second: 0, millisecond: 0 });
+                case 'minute':
+                    return this.rebuild({ second: 0, millisecond: 0 });
+                case 'second':
+                    return this.rebuild({ millisecond: 0 });
+                default:
+                    return this.clone();
+            }
+        }
+        /**
+         * Subtracts a specified amount of time from the wrapped date (chainable, immutable)
+         *
+         * @param {number} amount - The amount to subtract
+         * @param {DateUnit} unit - The unit to subtract (e.g. 'day', 'month')
+         * @returns {DateTick} A new DateTick with the result
+         * @memberof DateTick
+         */
+        subtract(amount, unit) {
+            return this.add(-amount, unit);
+        }
+        /**
+         * Returns a human-readable relative time string (e.g. '3 minutes ago')
+         *
+         * @param {Intl.RelativeTimeFormatOptions} [options] - Intl options
+         * @param {RelativeTimeThresholds} [thresholds] - Override the unit step-up cutoffs
+         * @returns {string} The relative time string
+         * @memberof DateTick
+         */
+        timeAgo(options, thresholds = {}) {
+            const t = {
+                second: thresholds.second ?? 60,
+                minute: thresholds.minute ?? 60,
+                hour: thresholds.hour ?? 24,
+                day: thresholds.day ?? 30,
+                month: thresholds.month ?? 12,
+            };
+            const diff = this._date.getTime() - Date.now();
+            const rtf = new Intl.RelativeTimeFormat(this._locale, { numeric: 'auto', ...options });
+            const seconds = diff / 1000;
+            const minutes = seconds / 60;
+            const hours = minutes / 60;
+            const days = hours / 24;
+            const months = days / 30;
+            const years = days / 365;
+            if (Math.abs(seconds) < t.second)
+                return rtf.format(Math.round(seconds), 'second');
+            if (Math.abs(minutes) < t.minute)
+                return rtf.format(Math.round(minutes), 'minute');
+            if (Math.abs(hours) < t.hour)
+                return rtf.format(Math.round(hours), 'hour');
+            if (Math.abs(days) < t.day)
+                return rtf.format(Math.round(days), 'day');
+            if (Math.abs(months) < t.month)
+                return rtf.format(Math.round(months), 'month');
+            return rtf.format(Math.round(years), 'year');
+        }
+        /**
+         * Returns a dependency-free live relative-time stream.
+         *
+         * Subscribers receive the current `timeAgo()` label immediately, then again whenever it is
+         * expected to change. The refresh rate adapts from every second to every hour as the target
+         * time moves farther away.
+         *
+         * @param {Intl.RelativeTimeFormatOptions} [options] - Intl options
+         * @param {RelativeTimeThresholds} [thresholds] - Override the unit step-up cutoffs
+         * @returns {TimeAgoLive} A live relative-time subscription handle
+         * @memberof DateTick
+         */
+        timeAgoLive(options, thresholds) {
+            return this.liveRelativeTime(() => this.timeAgo(options, thresholds));
+        }
+        /**
+         * Subscribes to live relative-time labels and returns an unsubscribe function.
+         *
+         * @param {TimeAgoListener} listener - Receives each formatted relative-time label
+         * @param {Intl.RelativeTimeFormatOptions} [options] - Intl options
+         * @param {RelativeTimeThresholds} [thresholds] - Override the unit step-up cutoffs
+         * @returns {() => void} Function that stops the live updates
+         * @memberof DateTick
+         */
+        timeAgoSubscribe(listener, options, thresholds) {
+            return this.timeAgoLive(options, thresholds).subscribe(listener);
+        }
+        /**
+         * Gets the configured IANA timezone
+         *
+         * @returns {string} The timezone
+         * @memberof DateTick
+         */
+        timezone() {
+            return this._timezone;
+        }
+        /**
+         * Formats another date relative to this one, Day.js-style.
+         *
+         * @param {DateInput} date - The target date to compare to
+         * @param {boolean} [withoutSuffix=false] - When true, omit "ago" / "in"
+         * @returns {string} The relative-time label
+         * @memberof DateTick
+         */
+        to(date, withoutSuffix = false) {
+            return this.withDate(date).from(this, withoutSuffix);
+        }
+        /**
+         * Converts the wrapped date to an array of zoned calendar parts.
+         *
+         * @returns {DateArray} [year, month, date, hour, minute, second, millisecond]
+         * @memberof DateTick
+         */
+        toArray() {
+            const p = this.parts();
+            return [p.year, p.month, p.day, p.hour, p.minute, p.second, p.millisecond];
+        }
+        /**
+         * Converts the wrapped date to a plain Date object (a fresh clone of the absolute instant)
+         *
+         * @returns {Date} The Date object
+         * @memberof DateTick
+         */
+        toDate() {
+            return new Date(this._date);
+        }
+        /**
+         * Converts the wrapped date to an ISO 8601 string (UTC)
+         *
+         * @returns {string} The ISO 8601 string
+         * @memberof DateTick
+         */
+        toISOString() {
+            return this._date.toISOString();
+        }
+        /**
+         * Enables `JSON.stringify` to serialize a DateTick as an ISO 8601 string
+         *
+         * @returns {string} The ISO 8601 string
+         * @memberof DateTick
+         */
+        toJSON() {
+            return this.toISOString();
+        }
+        /**
+         * Formats now relative to this date, Day.js-style.
+         *
+         * @param {boolean} [withoutSuffix=false] - When true, omit "ago" / "in"
+         * @returns {string} The relative-time label
+         * @memberof DateTick
+         */
+        toNow(withoutSuffix = false) {
+            return this.to(new Date(), withoutSuffix);
+        }
+        /**
+         * Converts the wrapped date to an object of zoned calendar parts.
+         *
+         * @returns {DatePartsObject} Zoned calendar parts
+         * @memberof DateTick
+         */
+        toObject() {
+            const p = this.parts();
+            return {
+                year: p.year,
+                month: p.month,
+                date: p.day,
+                hour: p.hour,
+                minute: p.minute,
+                second: p.second,
+                millisecond: p.millisecond,
+                day: p.weekday,
+            };
+        }
+        /**
+         * Converts the wrapped date to its default string representation
+         *
+         * @returns {string} The string representation
+         * @memberof DateTick
+         */
+        toString() {
+            return this._date.toString();
+        }
+        /**
+         * Gets the Unix timestamp (seconds since epoch)
+         *
+         * @returns {number} The Unix timestamp in seconds
+         * @memberof DateTick
+         */
+        unix() {
+            return Math.floor(this._date.getTime() / 1000);
+        }
+        /**
+         * Returns a new DateTick in UTC, keeping the same instant.
+         *
+         * @returns {DateTick} The UTC instance
+         * @memberof DateTick
+         */
+        utc() {
+            return this.withTimezone('UTC');
+        }
+        /**
+         * Gets the configured timezone's UTC offset for this instant, in minutes.
+         *
+         * @returns {number} Offset minutes, positive east of UTC
+         * @memberof DateTick
+         */
+        utcOffset() {
+            return offsetMs(this._date, this._timezone) / 60_000;
+        }
+        /**
+         * Gets the timestamp in milliseconds since epoch. Enables direct numeric comparisons (e.g. `+datetick`)
+         *
+         * @returns {number} The timestamp in milliseconds
+         * @memberof DateTick
+         */
+        valueOf() {
+            return this._date.getTime();
+        }
+        /**
+         * Gets the week number of the year (in the configured timezone)
+         *
+         * @returns {number} The week number
+         * @memberof DateTick
+         */
+        week() {
+            const p = this.parts();
+            const jan1Weekday = new Date(Date.UTC(p.year, 0, 1)).getUTCDay();
+            const offset = (jan1Weekday - this._weekStartsOn + 7) % 7;
+            return Math.ceil((this.dayOfYear() + offset) / 7);
+        }
+        /**
+         * Gets the configured first day of the week (0 = Sunday … 6 = Saturday)
+         *
+         * @returns {number} The first day of the week
+         * @memberof DateTick
+         */
+        weekStart() {
+            return this._weekStartsOn;
+        }
+        /**
+         * Gets the week year, for ISO week calculations (in the configured timezone)
+         *
+         * @returns {number} The week year
+         * @memberof DateTick
+         */
+        weekYear() {
+            return this.isoThursday().getUTCFullYear();
+        }
+        weekday(value) {
+            const p = this.parts();
+            const relative = (p.weekday - this._weekStartsOn + 7) % 7;
+            if (value == null)
+                return relative;
+            return this.rebuild({ day: p.day - relative + value });
+        }
+        /** Day.js-style plural getter alias of {@link DateTick.week} (weeks have no setter). */
+        weeks() {
+            return this.week();
+        }
+        /**
+         * Gets the number of weeks in the year (in the configured timezone)
+         *
+         * @returns {number} The number of weeks
+         * @memberof DateTick
+         */
+        weeksInYear() {
+            return this.weeksInYearBy((t) => t.week());
+        }
+        /**
+         * Returns a new DateTick instance with the given date, keeping the current locale and timezone
+         *
+         * @param {Date | string} date - The date to wrap
+         * @returns {DateTick} The new DateTick
+         * @memberof DateTick
+         */
+        withDate(date) {
+            return new DateTick(this._locale, this._timezone, date, this._weekStartsOn, this._ordinal);
+        }
+        /**
+         * Returns a new DateTick instance with the given locale, keeping the current instant and timezone
+         *
+         * @param {string} locale - The BCP 47 locale
+         * @returns {DateTick} The new DateTick
+         * @memberof DateTick
+         */
+        withLocale(locale) {
+            return new DateTick(locale, this._timezone, this._date, this._weekStartsOn, this._ordinal);
+        }
+        /**
+         * Returns a new DateTick instance with the given timezone, keeping the same absolute instant
+         * (the wall-clock components will be re-interpreted in the new zone)
+         *
+         * @param {string} timezone - The IANA timezone
+         * @returns {DateTick} The new DateTick
+         * @memberof DateTick
+         */
+        withTimezone(timezone) {
+            return new DateTick(this._locale, timezone, this._date, this._weekStartsOn, this._ordinal);
+        }
+        /**
+         * Returns a new DateTick instance with the given first-day-of-week, keeping everything else
+         *
+         * @param {number} weekStartsOn - First day of the week (0 = Sunday … 6 = Saturday)
+         * @returns {DateTick} The new DateTick
+         * @memberof DateTick
+         */
+        withWeekStart(weekStartsOn) {
+            return new DateTick(this._locale, this._timezone, this._date, weekStartsOn, this._ordinal);
+        }
+        year(value) {
+            if (value == null)
+                return this.parts().year;
+            return this.rebuild({ year: value });
+        }
+        years(value) {
+            return value == null ? this.year() : this.year(value);
+        }
+        /**
+         * Adds calendar months (used for month/quarter/year), clamping the day to the last valid day.
+         */
+        addMonths(months) {
+            const p = this.parts();
+            const totalMonths = p.year * 12 + p.month + months;
+            const targetYear = Math.floor(totalMonths / 12);
+            const targetMonth = ((totalMonths % 12) + 12) % 12;
+            const targetDay = Math.min(p.day, getDaysInMonth(targetYear, targetMonth));
+            return this.rebuild({ year: targetYear, month: targetMonth, day: targetDay });
+        }
+        calendarDayNumber() {
+            const p = this.parts();
+            return Math.floor(Date.UTC(p.year, p.month, p.day) / 86_400_000);
+        }
+        /**
+         * Returns a preset Intl.DateTimeFormatOptions for a given format string.
+         */
+        getPreset(format) {
+            switch (format) {
+                case 'short':
+                    return { dateStyle: 'short', timeStyle: 'short' };
+                case 'medium':
+                    return { dateStyle: 'medium', timeStyle: 'medium' };
+                case 'long':
+                    return { dateStyle: 'long', timeStyle: 'long' };
+                case 'full':
+                    return { dateStyle: 'full', timeStyle: 'full' };
+                case 'dateOnly':
+                    return { year: 'numeric', month: 'long', day: 'numeric' };
+                case 'timeOnly':
+                    return { hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false };
+                case 'weekdayTime':
+                    return { weekday: 'long', hour: 'numeric', minute: 'numeric' };
+                case 'isoStyle12h':
+                    return {
+                        year: 'numeric',
+                        month: '2-digit',
+                        day: '2-digit',
+                        hour: '2-digit',
+                        minute: '2-digit',
+                        second: '2-digit',
+                        hour12: true,
+                    };
+                case 'isoStyle24h':
+                    return {
+                        year: 'numeric',
+                        month: '2-digit',
+                        day: '2-digit',
+                        hour: '2-digit',
+                        minute: '2-digit',
+                        second: '2-digit',
+                        hour12: false,
+                    };
+                default:
+                    return {};
+            }
+        }
+        /**
+         * The Thursday of this instant's ISO week, as a UTC date built from the zoned calendar date so the
+         * math is offset-free. Shared by {@link DateTick.isoWeek} and {@link DateTick.weekYear}.
+         */
+        isoThursday() {
+            const p = this.parts();
+            const target = new Date(Date.UTC(p.year, p.month, p.day));
+            target.setUTCDate(target.getUTCDate() + 4 - (target.getUTCDay() || 7));
+            return target;
+        }
+        /**
+         * Creates an adaptive live relative-time stream.
+         */
+        liveRelativeTime(formatter) {
+            const targetTime = this._date.getTime();
+            const getRefreshInterval = (secondsDiff) => {
+                if (secondsDiff < 60)
+                    return 1000;
+                if (secondsDiff < 3600)
+                    return 30_000;
+                if (secondsDiff < 86400)
+                    return 1_800_000;
+                return 3_600_000;
+            };
+            let timeoutId;
+            const listeners = new Set();
+            const clearTimer = () => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                timeoutId = undefined;
+            };
+            const tick = () => {
+                const value = formatter();
+                listeners.forEach((listener) => listener(value));
+                // A listener may unsubscribe during notification (common when a component unmounts). If that
+                // drained the set, stop here instead of scheduling a timer that would never be cleared.
+                if (listeners.size === 0)
+                    return;
+                const secondsDiff = Math.abs((Date.now() - targetTime) / 1000);
+                timeoutId = setTimeout(tick, getRefreshInterval(secondsDiff));
+            };
+            return {
+                subscribe: (listener) => {
+                    listeners.add(listener);
+                    if (listeners.size === 1) {
+                        tick();
+                    }
+                    else {
+                        listener(formatter());
+                    }
+                    return () => {
+                        listeners.delete(listener);
+                        if (listeners.size === 0)
+                            clearTimer();
+                    };
+                },
+                unsubscribe: () => {
+                    listeners.clear();
+                    clearTimer();
+                },
+            };
+        }
+        /**
+         * Formats the timezone's current offset from UTC as ±HH:mm (with colon) or ±HHmm (without).
+         */
+        offsetString(colon) {
+            const offsetMinutes = offsetMs(this._date, this._timezone) / 60_000;
+            const sign = offsetMinutes >= 0 ? '+' : '-';
+            const abs = Math.abs(offsetMinutes);
+            const hh = String(Math.floor(abs / 60)).padStart(2, '0');
+            const mm = String(Math.round(abs % 60)).padStart(2, '0');
+            return colon ? `${sign}${hh}:${mm}` : `${sign}${hh}${mm}`;
+        }
+        /**
+         * Applies the configured ordinal override, falling back to the English suffix.
+         */
+        ordinalFor(n) {
+            return this._ordinal ? this._ordinal(n) : `${n}${ordinalSuffix(n)}`;
+        }
+        /**
+         * Reads the wrapped instant's wall-clock components in the configured timezone.
+         */
+        parts() {
+            return partsOf(this._date, this._timezone);
+        }
+        /**
+         * Floating-point calendar-unit difference (used by `diff` when `precise` is true).
+         *
+         * Computes the whole-unit count, then interpolates the fractional remainder between the
+         * instant `whole` units away from `other` and the next unit boundary in the direction of `this`.
+         */
+        preciseCalendarDiff(other, unitMonths) {
+            const whole = this.wholeMonthDiff(other, unitMonths);
+            const otherDateTick = this.withDate(other);
+            const anchor = otherDateTick.add(whole * unitMonths, 'month');
+            const step = this._date.getTime() >= anchor.valueOf() ? 1 : -1;
+            const nextAnchor = otherDateTick.add((whole + step) * unitMonths, 'month');
+            const span = nextAnchor.valueOf() - anchor.valueOf();
+            const progress = span === 0 ? 0 : (this._date.getTime() - anchor.valueOf()) / span;
+            return whole + progress * step;
+        }
+        /**
+         * Returns a new DateTick built from the current zoned components with the given overrides applied,
+         * then converted back to an absolute instant in the configured timezone.
+         */
+        rebuild(overrides) {
+            if (!this.isValid())
+                throw new Error(`Invalid date: ${this._date}`);
+            const merged = { ...this.parts(), ...overrides };
+            return this.withDate(instantFromParts(merged, this._timezone));
+        }
+        /**
+         * Normalizes a DateInput (Date, string, or DateTick) to a plain Date
+         */
+        toComparable(value) {
+            return value instanceof DateTick ? value.toDate() : this.validateDate(value);
+        }
+        /**
+         * Validates a date and throws an error if invalid
+         */
+        validateDate(date) {
+            if (!DateTick.isValid(date)) {
+                throw new Error(`Invalid date: ${date}`);
+            }
+            return DateTick.resolveInput(date, this._timezone);
+        }
+        /**
+         * Number of weeks in this instant's year, per the given week-numbering function: Dec 31 usually
+         * carries the highest week number, unless it rolls into week 1 of the next year (then Dec 24 does).
+         * Shared by {@link DateTick.weeksInYear} and {@link DateTick.isoWeeksInYear}.
+         */
+        weeksInYearBy(weekOf) {
+            const week = weekOf(this.rebuild({ month: 11, day: 31 }));
+            return week === 1 ? weekOf(this.rebuild({ month: 11, day: 31 - 7 })) : week;
+        }
+        /**
+         * Whole calendar-month difference (in units of `unitMonths` months), truncated toward zero.
+         */
+        wholeMonthDiff(other, unitMonths) {
+            const a = this.parts();
+            const b = partsOf(other, this._timezone);
+            return Math.trunc(((a.year - b.year) * 12 + (a.month - b.month)) / unitMonths);
+        }
+    }
+
+    const createDateTickFactory = (defaults) => {
+        const factory = (date, options = {}) => {
+            const merged = { ...defaults, ...options };
+            const input = date instanceof DateTick ? date.toDate() : date;
+            return new DateTick(merged.locale ?? 'en', merged.timezone, input, merged.weekStartsOn ?? 0, merged.ordinal);
+        };
+        return Object.assign(factory, {
+            duration: (value, unit, locale = defaults.locale ?? 'en') => DateTick.duration(value, unit, locale),
+            guessTimezone: DateTick.guessTimezone,
+            parse: (input, pattern, locale = defaults.locale ?? 'en', timezone = defaults.timezone ?? DateTick.guessTimezone()) => DateTick.parse(input, pattern, locale, timezone),
+            min: DateTick.min,
+            max: DateTick.max,
+            isValid: DateTick.isValid,
+            isDateTick: DateTick.isDateTick,
+            isDuration: Duration.isDuration,
+            utc: (date, options = {}) => factory(date, { ...options, timezone: 'UTC' }),
+            unix: (seconds, options = {}) => factory(new Date(seconds * 1000), options),
+            withDefaults: (next) => createDateTickFactory({ ...defaults, ...next }),
+        });
+    };
+    /**
+     * The quickest way to create a {@link DateTick}.
+     *
+     * @example
+     * datetick('2026-06-25T19:23Z', { timezone: 'Asia/Tokyo' }).formatPattern('DD/MM/YYYY HH:mm');
+     * datetick.duration(90, 'minute').humanize(); // '2 hours'
+     * datetick.utc('2026-06-25').startOf('week');
+     */
+    // The PURE annotation tells bundlers this call has no observable side effects, so consumers
+    // that only import `DateTick` or `Duration` (not `datetick`/the default export) can tree-shake this away.
+    const datetick = /* @__PURE__ */ createDateTickFactory({});
+
+    exports.DateTick = DateTick;
+    exports.Duration = Duration;
+    exports.datetick = datetick;
+    exports.default = datetick;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));