datetick 1.0.0

package/dist/index.js

@@ -0,0 +1,2422 @@
+/**
+ * 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({});
+
+export { DateTick, Duration, datetick, datetick as default };