@lbd-sh/date-tz 1.0.11 → 1.0.13

package/dist/date-tz.js

@@ -0,0 +1,866 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTz = void 0;
+const timezones_1 = require("./timezones");
+const MS_PER_SECOND = 1000;
+const MS_PER_MINUTE = 60000;
+const MS_PER_HOUR = 3600000;
+const MS_PER_DAY = 86400000;
+const MS_PER_WEEK = MS_PER_DAY * 7;
+const epochYear = 1970;
+const daysPerMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const UNIT_ALIASES = {
+    ms: 'millisecond',
+    millisecond: 'millisecond',
+    milliseconds: 'millisecond',
+    s: 'second',
+    sec: 'second',
+    second: 'second',
+    seconds: 'second',
+    m: 'minute',
+    min: 'minute',
+    minute: 'minute',
+    minutes: 'minute',
+    h: 'hour',
+    hr: 'hour',
+    hour: 'hour',
+    hours: 'hour',
+    d: 'day',
+    day: 'day',
+    days: 'day',
+    w: 'week',
+    wk: 'week',
+    week: 'week',
+    weeks: 'week',
+    M: 'month',
+    mon: 'month',
+    month: 'month',
+    months: 'month',
+    y: 'year',
+    yr: 'year',
+    year: 'year',
+    years: 'year'
+};
+const GRANULARITY_UNITS = ['minute', 'hour', 'day', 'week', 'month', 'year'];
+class DateTz {
+    constructor(value, tz) {
+        if (typeof value === 'object') {
+            this.timestamp = value.timestamp;
+            this.timezone = value.timezone || 'UTC';
+            if (!timezones_1.timezones[this.timezone]) {
+                throw new Error(`Invalid timezone: ${value.timezone}`);
+            }
+        }
+        else {
+            this.timezone = tz || 'UTC';
+            if (!timezones_1.timezones[this.timezone]) {
+                throw new Error(`Invalid timezone: ${tz}`);
+            }
+            this.timestamp = this.stripSMs(value);
+        }
+        this.invalidateOffsetCache();
+    }
+    get timezoneOffset() {
+        return timezones_1.timezones[this.timezone];
+    }
+    compare(other) {
+        if (this.isComparable(other)) {
+            return this.timestamp - other.timestamp;
+        }
+        throw new Error('Cannot compare dates with different timezones');
+    }
+    isComparable(other) {
+        return this.timezone === other.timezone;
+    }
+    toString(pattern, locale) {
+        if (!pattern)
+            pattern = 'YYYY-MM-DD HH:mm:ss';
+        const offsetInfo = this.getOffsetInfo();
+        const offset = offsetInfo.offsetSeconds * 1000;
+        let remainingMs = this.timestamp + offset;
+        let year = epochYear;
+        while (true) {
+            const daysInYear = this.isLeapYear(year) ? 366 : 365;
+            const msInYear = daysInYear * MS_PER_DAY;
+            if (remainingMs >= msInYear) {
+                remainingMs -= msInYear;
+                year++;
+            }
+            else {
+                break;
+            }
+        }
+        let month = 0;
+        while (month < 12) {
+            const daysInMonth = month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month];
+            const msInMonth = daysInMonth * MS_PER_DAY;
+            if (remainingMs >= msInMonth) {
+                remainingMs -= msInMonth;
+                month++;
+            }
+            else {
+                break;
+            }
+        }
+        const day = Math.floor(remainingMs / MS_PER_DAY) + 1;
+        remainingMs %= MS_PER_DAY;
+        const hour = Math.floor(remainingMs / MS_PER_HOUR);
+        remainingMs %= MS_PER_HOUR;
+        const minute = Math.floor(remainingMs / MS_PER_MINUTE);
+        remainingMs %= MS_PER_MINUTE;
+        const second = Math.floor(remainingMs / 1000);
+        const pm = hour >= 12 ? 'PM' : 'AM';
+        const hour12 = hour % 12 || 12;
+        if (!locale)
+            locale = 'en';
+        let monthStr = new Date(year, month, 3).toLocaleString(locale || 'en', { month: 'long' });
+        monthStr = monthStr.charAt(0).toUpperCase() + monthStr.slice(1);
+        const tokens = {
+            YYYY: year,
+            YY: String(year).slice(-2),
+            yyyy: year.toString(),
+            yy: String(year).slice(-2),
+            MM: String(month + 1).padStart(2, '0'),
+            LM: monthStr,
+            DD: String(day).padStart(2, '0'),
+            HH: String(hour).padStart(2, '0'),
+            mm: String(minute).padStart(2, '0'),
+            ss: String(second).padStart(2, '0'),
+            aa: pm.toLowerCase(),
+            AA: pm,
+            hh: hour12.toString().padStart(2, '0'),
+            tz: this.timezone,
+        };
+        return pattern.replace(/YYYY|yyyy|YY|yy|MM|LM|DD|HH|hh|mm|ss|aa|AA|tz/g, (match) => tokens[match]);
+    }
+    add(value, unit) {
+        let remainingMs = this.timestamp;
+        let year = 1970;
+        let days = Math.floor(remainingMs / MS_PER_DAY);
+        remainingMs %= MS_PER_DAY;
+        let hour = Math.floor(remainingMs / MS_PER_HOUR);
+        remainingMs %= MS_PER_HOUR;
+        let minute = Math.floor(remainingMs / MS_PER_MINUTE);
+        let second = Math.floor((remainingMs % MS_PER_MINUTE) / 1000);
+        while (days >= this.daysInYear(year)) {
+            days -= this.daysInYear(year);
+            year++;
+        }
+        let month = 0;
+        while (days >= (month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month])) {
+            days -= month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month];
+            month++;
+        }
+        let day = days + 1;
+        switch (unit) {
+            case 'minute':
+                minute += value;
+                break;
+            case 'hour':
+                hour += value;
+                break;
+            case 'day':
+                day += value;
+                break;
+            case 'month':
+                month += value;
+                break;
+            case 'year':
+                year += value;
+                break;
+            default:
+                throw new Error(`Unsupported unit: ${unit}`);
+        }
+        while (minute >= 60) {
+            minute -= 60;
+            hour++;
+        }
+        while (hour >= 24) {
+            hour -= 24;
+            day++;
+        }
+        while (month >= 12) {
+            month -= 12;
+            year++;
+        }
+        while (day > (month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month])) {
+            day -= month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month];
+            month++;
+            if (month >= 12) {
+                month = 0;
+                year++;
+            }
+        }
+        const newTimestamp = (() => {
+            let totalMs = 0;
+            for (let y = 1970; y < year; y++) {
+                totalMs += this.daysInYear(y) * MS_PER_DAY;
+            }
+            for (let m = 0; m < month; m++) {
+                totalMs += (m === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[m]) * MS_PER_DAY;
+            }
+            totalMs += (day - 1) * MS_PER_DAY;
+            totalMs += hour * MS_PER_HOUR;
+            totalMs += minute * MS_PER_MINUTE;
+            totalMs += second * 1000;
+            return totalMs;
+        })();
+        this.timestamp = newTimestamp;
+        this.invalidateOffsetCache();
+        return this;
+    }
+    subtract(value, unit) {
+        this.shift(unit, -value);
+        return this;
+    }
+    plus(duration = {}) {
+        for (const [rawUnit, rawValue] of Object.entries(duration)) {
+            if (rawValue === undefined || rawValue === 0) {
+                continue;
+            }
+            const normalized = this.normalizeDiffUnit(rawUnit);
+            const value = rawValue;
+            if (normalized === 'millisecond' || normalized === 'second') {
+                throw new Error(`Unsupported duration unit: ${rawUnit}`);
+            }
+            this.shift(normalized, value);
+        }
+        return this;
+    }
+    minus(duration = {}) {
+        const inverted = {};
+        for (const [unit, rawValue] of Object.entries(duration)) {
+            if (rawValue === undefined || rawValue === 0) {
+                continue;
+            }
+            inverted[unit] = -rawValue;
+        }
+        return this.plus(inverted);
+    }
+    diff(other, unit = 'millisecond', asFloat = false) {
+        const normalized = this.normalizeDiffUnit(unit);
+        const comparable = this.ensureComparable(other);
+        const delta = this.timestamp - comparable.timestamp;
+        switch (normalized) {
+            case 'millisecond':
+                return this.roundDiff(delta, asFloat);
+            case 'second':
+                return this.roundDiff(delta / MS_PER_SECOND, asFloat);
+            case 'minute':
+                return this.roundDiff(delta / MS_PER_MINUTE, asFloat);
+            case 'hour':
+                return this.roundDiff(delta / MS_PER_HOUR, asFloat);
+            case 'day':
+                return this.roundDiff(delta / MS_PER_DAY, asFloat);
+            case 'week':
+                return this.roundDiff(delta / MS_PER_WEEK, asFloat);
+            case 'month': {
+                const months = this.diffInMonths(comparable, true);
+                return this.roundDiff(months, asFloat);
+            }
+            case 'year': {
+                const years = this.diffInMonths(comparable, true) / 12;
+                return this.roundDiff(years, asFloat);
+            }
+            default:
+                return this.roundDiff(delta, asFloat);
+        }
+    }
+    startOf(unit) {
+        const granularity = this.normalizeGranularity(unit);
+        switch (granularity) {
+            case 'minute':
+                this.setLocalComponents({ second: 0 });
+                break;
+            case 'hour':
+                this.setLocalComponents({ minute: 0, second: 0 });
+                break;
+            case 'day':
+                this.setLocalComponents({ hour: 0, minute: 0, second: 0 });
+                break;
+            case 'week': {
+                this.startOf('day');
+                const dayOfWeek = this.dayOfWeek;
+                if (dayOfWeek !== 0) {
+                    this.shift('day', -dayOfWeek);
+                    this.startOf('day');
+                }
+                break;
+            }
+            case 'month':
+                this.setLocalComponents({ day: 1, hour: 0, minute: 0, second: 0 });
+                break;
+            case 'year':
+                this.setLocalComponents({ month: 0, day: 1, hour: 0, minute: 0, second: 0 });
+                break;
+        }
+        return this;
+    }
+    endOf(unit) {
+        const granularity = this.normalizeGranularity(unit);
+        switch (granularity) {
+            case 'minute':
+                return this;
+            case 'hour':
+                this.startOf('hour');
+                this.shift('hour', 1);
+                this.shift('minute', -1);
+                break;
+            case 'day':
+                this.startOf('day');
+                this.shift('day', 1);
+                this.shift('minute', -1);
+                break;
+            case 'week':
+                this.startOf('week');
+                this.shift('week', 1);
+                this.shift('minute', -1);
+                break;
+            case 'month':
+                this.startOf('month');
+                this.shift('month', 1);
+                this.shift('minute', -1);
+                break;
+            case 'year':
+                this.startOf('year');
+                this.shift('year', 1);
+                this.shift('minute', -1);
+                break;
+        }
+        return this;
+    }
+    clone() {
+        return new DateTz(this);
+    }
+    toJSDate() {
+        return new Date(this.timestamp);
+    }
+    toISOString() {
+        return this.toJSDate().toISOString();
+    }
+    toISO() {
+        return this.toISOString();
+    }
+    toUnix() {
+        return Math.floor(this.timestamp / 1000);
+    }
+    valueOf() {
+        return this.timestamp;
+    }
+    isBefore(other, unit = 'millisecond') {
+        return this.compareWithUnit(other, unit) < 0;
+    }
+    isAfter(other, unit = 'millisecond') {
+        return this.compareWithUnit(other, unit) > 0;
+    }
+    isSame(other, unit = 'millisecond') {
+        return this.compareWithUnit(other, unit) === 0;
+    }
+    isSameOrBefore(other, unit = 'millisecond') {
+        return this.compareWithUnit(other, unit) <= 0;
+    }
+    isSameOrAfter(other, unit = 'millisecond') {
+        return this.compareWithUnit(other, unit) >= 0;
+    }
+    isBetween(start, end, unit = 'millisecond', inclusivity = '()') {
+        if (inclusivity.length !== 2 || !['(', '['].includes(inclusivity[0]) || ![')', ']'].includes(inclusivity[1])) {
+            throw new Error(`Invalid inclusivity token: ${inclusivity}`);
+        }
+        const normalized = this.normalizeDiffUnit(unit);
+        const rangeStart = this.ensureComparable(start);
+        const rangeEnd = this.ensureComparable(end);
+        if (rangeStart.timestamp > rangeEnd.timestamp) {
+            throw new Error('Start date must be before end date');
+        }
+        const [lower, upper] = inclusivity.split('');
+        const lowerCmp = this.compareWithUnitDate(rangeStart, normalized);
+        const upperCmp = this.compareWithUnitDate(rangeEnd, normalized);
+        const lowerPass = lower === '(' ? lowerCmp > 0 : lowerCmp >= 0;
+        const upperPass = upper === ')' ? upperCmp < 0 : upperCmp <= 0;
+        return lowerPass && upperPass;
+    }
+    _year(considerDst = false) {
+        const offset = this.getOffsetSeconds(considerDst) * 1000;
+        let remainingMs = this.timestamp + offset;
+        let year = 1970;
+        let days = Math.floor(remainingMs / MS_PER_DAY);
+        while (days >= this.daysInYear(year)) {
+            days -= this.daysInYear(year);
+            year++;
+        }
+        return year;
+    }
+    _month(considerDst = false) {
+        const offset = this.getOffsetSeconds(considerDst) * 1000;
+        let remainingMs = this.timestamp + offset;
+        let year = 1970;
+        let days = Math.floor(remainingMs / MS_PER_DAY);
+        while (days >= this.daysInYear(year)) {
+            days -= this.daysInYear(year);
+            year++;
+        }
+        let month = 0;
+        while (days >= (month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month])) {
+            days -= month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month];
+            month++;
+        }
+        return month;
+    }
+    _day(considerDst = false) {
+        const offset = this.getOffsetSeconds(considerDst) * 1000;
+        let remainingMs = this.timestamp + offset;
+        let year = 1970;
+        let days = Math.floor(remainingMs / MS_PER_DAY);
+        while (days >= this.daysInYear(year)) {
+            days -= this.daysInYear(year);
+            year++;
+        }
+        let month = 0;
+        while (days >= (month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month])) {
+            days -= month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month];
+            month++;
+        }
+        return days + 1;
+    }
+    _hour(considerDst = false) {
+        const offset = this.getOffsetSeconds(considerDst) * 1000;
+        let remainingMs = this.timestamp + offset;
+        remainingMs %= MS_PER_DAY;
+        let hour = Math.floor(remainingMs / MS_PER_HOUR);
+        return hour;
+    }
+    _minute(considerDst = false) {
+        const offset = this.getOffsetSeconds(considerDst) * 1000;
+        let remainingMs = this.timestamp + offset;
+        remainingMs %= MS_PER_HOUR;
+        let minute = Math.floor(remainingMs / MS_PER_MINUTE);
+        return minute;
+    }
+    _dayOfWeek(considerDst = false) {
+        const offset = this.getOffsetSeconds(considerDst) * 1000;
+        let remainingMs = this.timestamp + offset;
+        const date = new Date(remainingMs);
+        return date.getDay();
+    }
+    convertToTimezone(tz) {
+        if (!timezones_1.timezones[tz]) {
+            throw new Error(`Invalid timezone: ${tz}`);
+        }
+        this.timezone = tz;
+        this.invalidateOffsetCache();
+        return this;
+    }
+    cloneToTimezone(tz) {
+        if (!timezones_1.timezones[tz]) {
+            throw new Error(`Invalid timezone: ${tz}`);
+        }
+        const clone = new DateTz(this);
+        clone.timezone = tz;
+        clone.invalidateOffsetCache();
+        return clone;
+    }
+    stripSMs(timestamp) {
+        const days = Math.floor(timestamp / MS_PER_DAY);
+        const remainingAfterDays = timestamp % MS_PER_DAY;
+        const hours = Math.floor(remainingAfterDays / MS_PER_HOUR);
+        const remainingAfterHours = remainingAfterDays % MS_PER_HOUR;
+        const minutes = Math.floor(remainingAfterHours / MS_PER_MINUTE);
+        return days * MS_PER_DAY + hours * MS_PER_HOUR + minutes * MS_PER_MINUTE;
+    }
+    invalidateOffsetCache() {
+        this.offsetCache = undefined;
+    }
+    getOffsetSeconds(considerDst) {
+        const tzInfo = timezones_1.timezones[this.timezone];
+        if (!tzInfo) {
+            throw new Error(`Invalid timezone: ${this.timezone}`);
+        }
+        if (!considerDst) {
+            return tzInfo.sdt;
+        }
+        return this.getOffsetInfo().offsetSeconds;
+    }
+    getOffsetInfo() {
+        if (this.offsetCache && this.offsetCache.timestamp === this.timestamp) {
+            return this.offsetCache.info;
+        }
+        const info = this.computeOffsetInfo();
+        this.offsetCache = { timestamp: this.timestamp, info };
+        return info;
+    }
+    computeOffsetInfo() {
+        const tzInfo = timezones_1.timezones[this.timezone];
+        if (!tzInfo) {
+            throw new Error(`Invalid timezone: ${this.timezone}`);
+        }
+        if (tzInfo.dst === tzInfo.sdt) {
+            return { offsetSeconds: tzInfo.sdt, isDst: false };
+        }
+        const actual = this.getIntlOffsetSeconds(this.timestamp);
+        if (actual !== null) {
+            if (actual !== tzInfo.sdt && actual !== tzInfo.dst) {
+                return { offsetSeconds: actual, isDst: actual > tzInfo.sdt };
+            }
+            return { offsetSeconds: actual, isDst: actual === tzInfo.dst };
+        }
+        return { offsetSeconds: tzInfo.sdt, isDst: false };
+    }
+    getIntlOffsetSeconds(timestamp) {
+        try {
+            const formatter = new Intl.DateTimeFormat('en-US', {
+                timeZone: this.timezone,
+                hour12: false,
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit'
+            });
+            const parts = formatter.formatToParts(new Date(timestamp));
+            const lookup = (type) => {
+                const part = parts.find(p => p.type === type);
+                if (!part) {
+                    throw new Error(`Missing part ${type}`);
+                }
+                return Number(part.value);
+            };
+            const adjusted = Date.UTC(lookup('year'), lookup('month') - 1, lookup('day'), lookup('hour'), lookup('minute'), lookup('second'));
+            return Math.round((adjusted - timestamp) / 1000);
+        }
+        catch {
+            return null;
+        }
+    }
+    getLocalParts(considerDst = true) {
+        return {
+            year: this._year(considerDst),
+            month: this._month(considerDst),
+            day: this._day(considerDst),
+            hour: this._hour(considerDst),
+            minute: this._minute(considerDst),
+            second: 0
+        };
+    }
+    setLocalComponents(update) {
+        const current = this.getLocalParts(true);
+        const next = {
+            ...current,
+            ...update
+        };
+        const pattern = 'YYYY-MM-DD HH:mm:ss';
+        const dateString = [
+            String(next.year).padStart(4, '0'),
+            String(next.month + 1).padStart(2, '0'),
+            String(next.day).padStart(2, '0')
+        ].join('-') + ' ' + [
+            String(next.hour).padStart(2, '0'),
+            String(next.minute).padStart(2, '0'),
+            String(next.second).padStart(2, '0')
+        ].join(':');
+        const parsed = DateTz.parse(dateString, pattern, this.timezone);
+        this.timestamp = parsed.timestamp;
+        this.invalidateOffsetCache();
+    }
+    toDateInstance(other) {
+        if (other instanceof DateTz) {
+            return other;
+        }
+        const tz = other.timezone ?? this.timezone;
+        return new DateTz(other.timestamp, tz);
+    }
+    ensureComparable(other) {
+        const instance = this.toDateInstance(other);
+        if (!this.isComparable(instance)) {
+            throw new Error('Cannot compare dates with different timezones');
+        }
+        return instance;
+    }
+    normalizeDiffUnit(unit) {
+        if (!unit) {
+            return 'millisecond';
+        }
+        const normalized = UNIT_ALIASES[unit.toLowerCase()];
+        if (!normalized) {
+            throw new Error(`Unsupported unit: ${unit}`);
+        }
+        return normalized;
+    }
+    normalizeGranularity(unit) {
+        const normalized = this.normalizeDiffUnit(unit);
+        if (normalized === 'millisecond' || normalized === 'second') {
+            throw new Error(`Unsupported granularity: ${unit}`);
+        }
+        return normalized;
+    }
+    diffInMonths(other, asFloat) {
+        const earlier = this.timestamp < other.timestamp ? new DateTz(this) : new DateTz(other);
+        const later = this.timestamp < other.timestamp ? new DateTz(other) : new DateTz(this);
+        let anchor = new DateTz(earlier);
+        let months = 0;
+        let next = new DateTz(anchor).add(1, 'month');
+        while (next.timestamp <= later.timestamp) {
+            anchor = next;
+            months++;
+            next = new DateTz(anchor).add(1, 'month');
+        }
+        if (!asFloat) {
+            return this.timestamp < other.timestamp ? -months : months;
+        }
+        const spanStart = anchor.timestamp;
+        const spanEnd = next.timestamp;
+        const span = spanEnd - spanStart;
+        const remainder = later.timestamp - spanStart;
+        const fractional = span !== 0 ? remainder / span : 0;
+        const value = months + fractional;
+        return this.timestamp < other.timestamp ? -value : value;
+    }
+    roundDiff(value, asFloat) {
+        if (asFloat) {
+            return value;
+        }
+        return value < 0 ? Math.ceil(value) : Math.floor(value);
+    }
+    compareWithUnitDate(other, unit) {
+        const normalized = this.normalizeDiffUnit(unit);
+        if (normalized === 'millisecond' || normalized === 'second') {
+            return this.timestamp - other.timestamp;
+        }
+        const granularity = normalized;
+        const left = this.clone().startOf(granularity);
+        const right = other.clone().startOf(granularity);
+        return left.timestamp - right.timestamp;
+    }
+    compareWithUnit(other, unit) {
+        const instance = this.ensureComparable(other);
+        return this.compareWithUnitDate(instance, unit);
+    }
+    shift(unit, value) {
+        if (value === 0) {
+            return this;
+        }
+        switch (unit) {
+            case 'minute':
+                this.timestamp += value * MS_PER_MINUTE;
+                break;
+            case 'hour':
+                this.timestamp += value * MS_PER_HOUR;
+                break;
+            case 'day':
+                this.timestamp += value * MS_PER_DAY;
+                break;
+            case 'week':
+                this.timestamp += value * MS_PER_WEEK;
+                break;
+            case 'month':
+                this.shiftCalendar('month', value);
+                return this;
+            case 'year':
+                this.shiftCalendar('year', value);
+                return this;
+            default:
+                throw new Error(`Unsupported unit: ${unit}`);
+        }
+        this.invalidateOffsetCache();
+        return this;
+    }
+    shiftCalendar(unit, value) {
+        if (value === 0) {
+            return;
+        }
+        const current = this.getLocalParts(true);
+        let year = current.year;
+        let month = current.month;
+        let day = current.day;
+        if (unit === 'year') {
+            year += value;
+        }
+        else {
+            let totalMonths = year * 12 + month + value;
+            year = Math.floor(totalMonths / 12);
+            month = totalMonths % 12;
+            if (month < 0) {
+                month += 12;
+                year -= 1;
+            }
+        }
+        const maxDay = month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month];
+        if (day > maxDay) {
+            day = maxDay;
+        }
+        this.setLocalComponents({ year, month, day });
+    }
+    set(value, unit) {
+        let remainingMs = this.timestamp;
+        let year = 1970;
+        let days = Math.floor(remainingMs / MS_PER_DAY);
+        remainingMs %= MS_PER_DAY;
+        let hour = Math.floor(remainingMs / MS_PER_HOUR);
+        remainingMs %= MS_PER_HOUR;
+        let minute = Math.floor(remainingMs / MS_PER_MINUTE);
+        let second = Math.floor((remainingMs % MS_PER_MINUTE) / 1000);
+        while (days >= this.daysInYear(year)) {
+            days -= this.daysInYear(year);
+            year++;
+        }
+        let month = 0;
+        while (days >= (month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month])) {
+            days -= month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month];
+            month++;
+        }
+        let day = days + 1;
+        switch (unit) {
+            case 'year':
+                year = value;
+                break;
+            case 'month':
+                month = value - 1;
+                break;
+            case 'day':
+                day = value;
+                break;
+            case 'hour':
+                hour = value;
+                break;
+            case 'minute':
+                minute = value;
+                break;
+            default:
+                throw new Error(`Unsupported unit: ${unit}`);
+        }
+        while (month >= 12) {
+            month -= 12;
+            year++;
+        }
+        while (day > (month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month])) {
+            day -= month === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[month];
+            month++;
+            if (month >= 12) {
+                month = 0;
+                year++;
+            }
+        }
+        const newTimestamp = (() => {
+            let totalMs = 0;
+            for (let y = 1970; y < year; y++) {
+                totalMs += this.daysInYear(y) * MS_PER_DAY;
+            }
+            for (let m = 0; m < month; m++) {
+                totalMs += (m === 1 && this.isLeapYear(year) ? 29 : daysPerMonth[m]) * MS_PER_DAY;
+            }
+            totalMs += (day - 1) * MS_PER_DAY;
+            totalMs += hour * MS_PER_HOUR;
+            totalMs += minute * MS_PER_MINUTE;
+            totalMs += second * 1000;
+            return totalMs;
+        })();
+        this.timestamp = newTimestamp;
+        this.invalidateOffsetCache();
+        return this;
+    }
+    isLeapYear(year) {
+        return (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
+    }
+    daysInYear(year) {
+        return this.isLeapYear(year) ? 366 : 365;
+    }
+    static parse(dateString, pattern, tz) {
+        if (!pattern)
+            pattern = DateTz.defaultFormat;
+        if (!tz)
+            tz = 'UTC';
+        if (!timezones_1.timezones[tz]) {
+            throw new Error(`Invalid timezone: ${tz}`);
+        }
+        if (pattern.includes('hh') && (!pattern.includes('aa') || !pattern.includes('AA'))) {
+            throw new Error('AM/PM marker (aa or AA) is required when using 12-hour format (hh)');
+        }
+        const regex = /YYYY|yyyy|MM|DD|HH|hh|mm|ss|aa|AA/g;
+        const dateComponents = {
+            YYYY: 1970,
+            yyyy: 1970,
+            MM: 0,
+            DD: 0,
+            HH: 0,
+            hh: 0,
+            aa: 'am',
+            AA: "AM",
+            mm: 0,
+            ss: 0,
+        };
+        let match;
+        let index = 0;
+        while ((match = regex.exec(pattern)) !== null) {
+            const token = match[0];
+            const value = parseInt(dateString.substring(match.index, match.index + token.length), 10);
+            dateComponents[token] = value;
+            index += token.length + 1;
+        }
+        const year = dateComponents.YYYY || dateComponents.yyyy;
+        const month = dateComponents.MM - 1;
+        const day = dateComponents.DD;
+        let hour = 0;
+        const ampm = (dateComponents.a || dateComponents.A);
+        if (ampm) {
+            hour = ampm.toUpperCase() === 'AM' ? dateComponents.hh : dateComponents.hh + 12;
+        }
+        else {
+            hour = dateComponents.HH;
+        }
+        const minute = dateComponents.mm;
+        const second = dateComponents.ss;
+        const daysInYear = (year) => (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0) ? 366 : 365;
+        const daysInMonth = (year, month) => month === 1 && daysInYear(year) === 366 ? 29 : daysPerMonth[month];
+        let timestamp = 0;
+        for (let y = 1970; y < year; y++) {
+            timestamp += daysInYear(y) * MS_PER_DAY;
+        }
+        for (let m = 0; m < month; m++) {
+            timestamp += daysInMonth(year, m) * MS_PER_DAY;
+        }
+        timestamp += (day - 1) * MS_PER_DAY;
+        timestamp += hour * MS_PER_HOUR;
+        timestamp += minute * MS_PER_MINUTE;
+        timestamp += second * 1000;
+        const offset = (timezones_1.timezones[tz].sdt) * 1000;
+        let remainingMs = timestamp - offset;
+        const date = new DateTz(remainingMs, tz);
+        date.timestamp -= date.isDst ? (timezones_1.timezones[tz].dst - timezones_1.timezones[tz].sdt) * 1000 : 0;
+        date.invalidateOffsetCache();
+        return date;
+    }
+    static now(tz) {
+        if (!tz)
+            tz = 'UTC';
+        const timezone = timezones_1.timezones[tz];
+        if (!timezone) {
+            throw new Error(`Invalid timezone: ${tz}`);
+        }
+        const date = new DateTz(Date.now(), tz);
+        return date;
+    }
+    get isDst() {
+        return this.getOffsetInfo().isDst;
+    }
+    get year() {
+        return this._year(true);
+    }
+    get month() {
+        return this._month(true);
+    }
+    get day() {
+        return this._day(true);
+    }
+    get hour() {
+        return this._hour(true);
+    }
+    get minute() {
+        return this._minute(true);
+    }
+    get dayOfWeek() {
+        return this._dayOfWeek(true);
+    }
+}
+exports.DateTz = DateTz;
+DateTz.defaultFormat = 'YYYY-MM-DD HH:mm:ss';
+//# sourceMappingURL=date-tz.js.map