chronos-ts 2.0.3 → 2.0.4

package/dist/index.d.mts

@@ -630,6 +630,13 @@ declare class Chronos implements ChronosLike {
      * ```
      */
     add(amount: number | Duration, unit?: AnyTimeUnit): Chronos;
+    /**
+     * Add an amount of a single unit while respecting the instance timezone.
+     * Calendar units (day/week/month/quarter/year/…) preserve the wall-clock time
+     * in the zone (DST-safe); absolute units (hour/minute/second/millisecond) add a
+     * fixed offset to the instant. Day clamping mirrors the local-time path.
+     */
+    private addInZone;
     /**
      * Subtract time from the date
      */
@@ -656,6 +663,14 @@ declare class Chronos implements ChronosLike {
      * ```
      */
     endOf(unit: AnyTimeUnit): Chronos;
+    /**
+     * Compute the start/end boundary of a unit in the instance timezone.
+     * The plain `startOf`/`endOf` helpers operate on local wall-clock fields of the
+     * underlying Date, which is wrong when an explicit timezone is attached. Here we
+     * read the wall-clock components in the target zone, snap them to the boundary,
+     * and rebuild the instant (dateFromComponents handles DST).
+     */
+    private boundaryInZone;
     addMilliseconds(amount: number): Chronos;
     addSeconds(amount: number): Chronos;
     addMinutes(amount: number): Chronos;
@@ -1216,7 +1231,6 @@ declare class ChronosPeriod implements Iterable<Chronos> {
     private _recurrences;
     private _options;
     private _filters;
-    private _current;
     private _locale;
     /**
      * Create a new ChronosPeriod
@@ -1484,6 +1498,12 @@ declare class ChronosPeriod implements Iterable<Chronos> {
      * Reduce dates to a single value
      */
     reduce<T>(callback: (acc: T, date: Chronos, index: number) => T, initial: T): T;
+    /**
+     * Resolve the effective end of the period.
+     * Returns null for a truly unbounded period (no end and no recurrence limit),
+     * which avoids calling last() — that would iterate until the safety limit and throw.
+     */
+    private _resolvedEnd;
     /**
      * Check if two periods overlap
      */

package/dist/index.d.ts

@@ -630,6 +630,13 @@ declare class Chronos implements ChronosLike {
      * ```
      */
     add(amount: number | Duration, unit?: AnyTimeUnit): Chronos;
+    /**
+     * Add an amount of a single unit while respecting the instance timezone.
+     * Calendar units (day/week/month/quarter/year/…) preserve the wall-clock time
+     * in the zone (DST-safe); absolute units (hour/minute/second/millisecond) add a
+     * fixed offset to the instant. Day clamping mirrors the local-time path.
+     */
+    private addInZone;
     /**
      * Subtract time from the date
      */
@@ -656,6 +663,14 @@ declare class Chronos implements ChronosLike {
      * ```
      */
     endOf(unit: AnyTimeUnit): Chronos;
+    /**
+     * Compute the start/end boundary of a unit in the instance timezone.
+     * The plain `startOf`/`endOf` helpers operate on local wall-clock fields of the
+     * underlying Date, which is wrong when an explicit timezone is attached. Here we
+     * read the wall-clock components in the target zone, snap them to the boundary,
+     * and rebuild the instant (dateFromComponents handles DST).
+     */
+    private boundaryInZone;
     addMilliseconds(amount: number): Chronos;
     addSeconds(amount: number): Chronos;
     addMinutes(amount: number): Chronos;
@@ -1216,7 +1231,6 @@ declare class ChronosPeriod implements Iterable<Chronos> {
     private _recurrences;
     private _options;
     private _filters;
-    private _current;
     private _locale;
     /**
      * Create a new ChronosPeriod
@@ -1484,6 +1498,12 @@ declare class ChronosPeriod implements Iterable<Chronos> {
      * Reduce dates to a single value
      */
     reduce<T>(callback: (acc: T, date: Chronos, index: number) => T, initial: T): T;
+    /**
+     * Resolve the effective end of the period.
+     * Returns null for a truly unbounded period (no end and no recurrence limit),
+     * which avoids calling last() — that would iterate until the safety limit and throw.
+     */
+    private _resolvedEnd;
     /**
      * Check if two periods overlap
      */

package/dist/index.js

@@ -2017,18 +2017,14 @@ var Chronos = class _Chronos {
     if (isValidDate(isoDate)) {
       return isoDate;
     }
-    const formats = [
-      /^(\d{4})-(\d{2})-(\d{2})$/,
-      /^(\d{2})\/(\d{2})\/(\d{4})$/,
-      /^(\d{4})\/(\d{2})\/(\d{2})$/
-    ];
-    for (const format of formats) {
-      const match = input.match(format);
-      if (match) {
-        const parsed = new Date(input);
-        if (isValidDate(parsed)) {
-          return parsed;
-        }
+    const dmy = input.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
+    if (dmy) {
+      const day = parseInt(dmy[1], 10);
+      const month = parseInt(dmy[2], 10);
+      const year = parseInt(dmy[3], 10);
+      const parsed = new Date(year, month - 1, day);
+      if (isValidDate(parsed) && parsed.getMonth() === month - 1) {
+        return parsed;
       }
     }
     throw new Error(`Unable to parse date: ${input}`);
@@ -2332,18 +2328,40 @@ var Chronos = class _Chronos {
   }
   /** Get the quarter (1-4) */
   get quarter() {
+    if (this._timezone) {
+      const month = new ChronosTimezone(this._timezone).getComponents(
+        this._date
+      ).month;
+      return Math.floor((month - 1) / 3) + 1;
+    }
     return getQuarter(this._date);
   }
   /** Get the day of year (1-366) */
   get dayOfYear() {
+    if (this._timezone) {
+      const c = new ChronosTimezone(this._timezone).getComponents(this._date);
+      let days = c.day;
+      for (let m = 1; m < c.month; m++) {
+        days += getDaysInMonth(c.year, m - 1);
+      }
+      return days;
+    }
     return getDayOfYear(this._date);
   }
   /** Get the ISO week number (1-53) */
   get week() {
+    if (this._timezone) {
+      const c = new ChronosTimezone(this._timezone).getComponents(this._date);
+      return getISOWeek(new Date(c.year, c.month - 1, c.day));
+    }
     return getISOWeek(this._date);
   }
   /** Get the ISO week year */
   get weekYear() {
+    if (this._timezone) {
+      const c = new ChronosTimezone(this._timezone).getComponents(this._date);
+      return getISOWeekYear(new Date(c.year, c.month - 1, c.day));
+    }
     return getISOWeekYear(this._date);
   }
   /** Get the number of days in the current month */
@@ -2364,6 +2382,9 @@ var Chronos = class _Chronos {
   }
   /** Get the timezone offset in minutes */
   get offset() {
+    if (this._timezone) {
+      return -new ChronosTimezone(this._timezone).getOffsetMinutes(this._date);
+    }
     return this._date.getTimezoneOffset();
   }
   /** Get the timezone offset as string (+05:30) */
@@ -2475,9 +2496,82 @@ var Chronos = class _Chronos {
       throw new Error("Unit is required when amount is a number");
     }
     const normalizedUnit = normalizeUnit(unit);
+    if (this._timezone) {
+      return this.addInZone(amount, normalizedUnit);
+    }
     const newDate = addUnits(this._date, amount, normalizedUnit);
     return new _Chronos(newDate, this._timezone);
   }
+  /**
+   * Add an amount of a single unit while respecting the instance timezone.
+   * Calendar units (day/week/month/quarter/year/…) preserve the wall-clock time
+   * in the zone (DST-safe); absolute units (hour/minute/second/millisecond) add a
+   * fixed offset to the instant. Day clamping mirrors the local-time path.
+   */
+  addInZone(amount, unit) {
+    const absoluteMs = {
+      millisecond: 1,
+      second: MILLISECONDS_PER_SECOND,
+      minute: MILLISECONDS_PER_MINUTE,
+      hour: MILLISECONDS_PER_HOUR
+    };
+    const perUnit = absoluteMs[unit];
+    if (perUnit !== void 0) {
+      const newDate = new Date(this._date.getTime() + amount * perUnit);
+      return new _Chronos(newDate, this._timezone);
+    }
+    const tz = new ChronosTimezone(this._timezone);
+    const c = tz.getComponents(this._date);
+    let year = c.year;
+    let month = c.month;
+    let day = c.day;
+    const calendarUnit = unit === "month" || unit === "quarter" || unit === "year" || unit === "decade" || unit === "century" || unit === "millennium";
+    switch (unit) {
+      case "day":
+        day += amount;
+        break;
+      case "week":
+        day += amount * 7;
+        break;
+      case "month":
+        month += amount;
+        break;
+      case "quarter":
+        month += amount * 3;
+        break;
+      case "year":
+        year += amount;
+        break;
+      case "decade":
+        year += amount * 10;
+        break;
+      case "century":
+        year += amount * 100;
+        break;
+      case "millennium":
+        year += amount * 1e3;
+        break;
+    }
+    year += Math.floor((month - 1) / 12);
+    month = ((month - 1) % 12 + 12) % 12 + 1;
+    if (calendarUnit) {
+      const maxDay = getDaysInMonth(year, month - 1);
+      if (day > maxDay) day = maxDay;
+    }
+    const date = _Chronos.dateFromComponents(
+      {
+        year,
+        month,
+        day,
+        hour: c.hour,
+        minute: c.minute,
+        second: c.second,
+        millisecond: this._date.getMilliseconds()
+      },
+      this._timezone
+    );
+    return new _Chronos(date, this._timezone);
+  }
   /**
    * Subtract time from the date
    */
@@ -2505,6 +2599,9 @@ var Chronos = class _Chronos {
    */
   startOf(unit) {
     const normalizedUnit = normalizeUnit(unit);
+    if (this._timezone) {
+      return this.boundaryInZone(normalizedUnit, false);
+    }
     const newDate = startOf(this._date, normalizedUnit);
     return new _Chronos(newDate, this._timezone);
   }
@@ -2520,9 +2617,96 @@ var Chronos = class _Chronos {
    */
   endOf(unit) {
     const normalizedUnit = normalizeUnit(unit);
+    if (this._timezone) {
+      return this.boundaryInZone(normalizedUnit, true);
+    }
     const newDate = endOf(this._date, normalizedUnit);
     return new _Chronos(newDate, this._timezone);
   }
+  /**
+   * Compute the start/end boundary of a unit in the instance timezone.
+   * The plain `startOf`/`endOf` helpers operate on local wall-clock fields of the
+   * underlying Date, which is wrong when an explicit timezone is attached. Here we
+   * read the wall-clock components in the target zone, snap them to the boundary,
+   * and rebuild the instant (dateFromComponents handles DST).
+   */
+  boundaryInZone(unit, end) {
+    if (unit === "millisecond") {
+      return this.clone();
+    }
+    const tz = new ChronosTimezone(this._timezone);
+    const c = tz.getComponents(this._date);
+    const comp = {
+      year: c.year,
+      month: c.month,
+      day: c.day,
+      hour: c.hour,
+      minute: c.minute,
+      second: c.second,
+      millisecond: this._date.getMilliseconds()
+    };
+    const resetTime = () => {
+      comp.hour = end ? 23 : 0;
+      comp.minute = end ? 59 : 0;
+      comp.second = end ? 59 : 0;
+      comp.millisecond = end ? 999 : 0;
+    };
+    switch (unit) {
+      case "second":
+        comp.millisecond = end ? 999 : 0;
+        break;
+      case "minute":
+        comp.second = end ? 59 : 0;
+        comp.millisecond = end ? 999 : 0;
+        break;
+      case "hour":
+        comp.minute = end ? 59 : 0;
+        comp.second = end ? 59 : 0;
+        comp.millisecond = end ? 999 : 0;
+        break;
+      case "day":
+        resetTime();
+        break;
+      case "week":
+        resetTime();
+        comp.day = c.day + (end ? 6 - c.dayOfWeek : -c.dayOfWeek);
+        break;
+      case "month":
+        resetTime();
+        comp.day = end ? getDaysInMonth(c.year, c.month - 1) : 1;
+        break;
+      case "quarter": {
+        resetTime();
+        const qStartMonth = Math.floor((c.month - 1) / 3) * 3 + 1;
+        if (end) {
+          comp.month = qStartMonth + 2;
+          comp.day = getDaysInMonth(c.year, comp.month - 1);
+        } else {
+          comp.month = qStartMonth;
+          comp.day = 1;
+        }
+        break;
+      }
+      case "year":
+        resetTime();
+        comp.month = end ? 12 : 1;
+        comp.day = end ? 31 : 1;
+        break;
+      case "decade":
+      case "century":
+      case "millennium": {
+        resetTime();
+        comp.month = end ? 12 : 1;
+        comp.day = end ? 31 : 1;
+        const span = unit === "decade" ? 10 : unit === "century" ? 100 : 1e3;
+        const base = Math.floor(c.year / span) * span;
+        comp.year = end ? base + span - 1 : base;
+        break;
+      }
+    }
+    const date = _Chronos.dateFromComponents(comp, this._timezone);
+    return new _Chronos(date, this._timezone);
+  }
   // ============================================================================
   // Convenience Add/Subtract Methods
   // ============================================================================
@@ -2717,6 +2901,12 @@ var Chronos = class _Chronos {
           return diffMs / MILLISECONDS_PER_DAY;
         case "week":
           return diffMs / (MILLISECONDS_PER_DAY * 7);
+        case "month":
+          return diffMs / MILLISECONDS_PER_MONTH;
+        case "quarter":
+          return diffMs / (MILLISECONDS_PER_MONTH * 3);
+        case "year":
+          return diffMs / MILLISECONDS_PER_YEAR;
       }
     }
     return diffInUnits(this._date, otherDate._date, normalizedUnit);
@@ -2774,12 +2964,12 @@ var Chronos = class _Chronos {
    * Get relative time from another date
    */
   from(other, options = {}) {
-    var _a, _b;
+    var _a, _b, _c;
     const otherDate = _Chronos.parse(other);
     const diffMs = this._date.getTime() - otherDate._date.getTime();
     const absDiff = Math.abs(diffMs);
     const isFuture = diffMs > 0;
-    const { short: _short = false, absolute = false } = options;
+    const { short = false, absolute = false } = options;
     const relative = this._locale.relativeTime;
     let value;
     let unit;
@@ -2805,10 +2995,26 @@ var Chronos = class _Chronos {
       value = Math.round(absDiff / (MILLISECONDS_PER_DAY * 365));
       unit = value === 1 ? "y" : "yy";
     }
-    const relativeStr = (_b = (_a = relative[unit]) == null ? void 0 : _a.replace(
+    const shortUnits = {
+      s: "s",
+      ss: "s",
+      m: "m",
+      mm: "m",
+      h: "h",
+      hh: "h",
+      d: "d",
+      dd: "d",
+      w: "w",
+      ww: "w",
+      M: "mo",
+      MM: "mo",
+      y: "y",
+      yy: "y"
+    };
+    const relativeStr = short ? `${value}${(_a = shortUnits[unit]) != null ? _a : unit}` : (_c = (_b = relative[unit]) == null ? void 0 : _b.replace(
       "%d",
       String(value)
-    )) != null ? _b : `${value} ${unit}`;
+    )) != null ? _c : `${value} ${unit}`;
     if (absolute) {
       return relativeStr;
     }
@@ -2887,7 +3093,7 @@ var Chronos = class _Chronos {
       Z: () => this.offsetString,
       ZZ: () => this.offsetString.replace(":", ""),
       Q: () => String(this.quarter),
-      Do: () => ordinalSuffix(this.date),
+      Do: () => this._locale.ordinal(this.date),
       W: () => String(this.week),
       WW: () => padStart(this.week, 2),
       X: () => String(this.unix),
@@ -3161,15 +3367,16 @@ var ChronosInterval = class _ChronosInterval {
   // Constructor
   // ============================================================================
   constructor(duration = {}, inverted = false) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     this._years = (_a = duration.years) != null ? _a : 0;
     this._months = (_b = duration.months) != null ? _b : 0;
     this._weeks = (_c = duration.weeks) != null ? _c : 0;
     this._days = (_d = duration.days) != null ? _d : 0;
     this._hours = (_e = duration.hours) != null ? _e : 0;
     this._minutes = (_f = duration.minutes) != null ? _f : 0;
-    this._seconds = Math.floor((_g = duration.seconds) != null ? _g : 0);
-    this._milliseconds = (_i = duration.milliseconds) != null ? _i : ((_h = duration.seconds) != null ? _h : 0) % 1 * 1e3;
+    const totalSeconds = (_g = duration.seconds) != null ? _g : 0;
+    this._seconds = Math.trunc(totalSeconds);
+    this._milliseconds = (_h = duration.milliseconds) != null ? _h : Math.round((totalSeconds - this._seconds) * 1e3);
     this._locale = getLocale("en");
     this._inverted = inverted;
   }
@@ -3858,7 +4065,6 @@ var ChronosPeriod = class _ChronosPeriod {
       immutable: (_c = options.immutable) != null ? _c : true
     };
     this._filters = [];
-    this._current = 0;
     this._locale = getLocale("en");
   }
   // ============================================================================
@@ -4468,13 +4674,24 @@ var ChronosPeriod = class _ChronosPeriod {
   // ============================================================================
   // Range Operations
   // ============================================================================
+  /**
+   * Resolve the effective end of the period.
+   * Returns null for a truly unbounded period (no end and no recurrence limit),
+   * which avoids calling last() — that would iterate until the safety limit and throw.
+   */
+  _resolvedEnd() {
+    var _a;
+    if (this.isUnbounded) {
+      return null;
+    }
+    return (_a = this._end) != null ? _a : this.last();
+  }
   /**
    * Check if two periods overlap
    */
   overlaps(other) {
-    var _a, _b;
-    const thisEnd = (_a = this._end) != null ? _a : this.last();
-    const otherEnd = (_b = other._end) != null ? _b : other.last();
+    const thisEnd = this._resolvedEnd();
+    const otherEnd = other._resolvedEnd();
     if (!thisEnd || !otherEnd) {
       return true;
     }
@@ -4484,13 +4701,12 @@ var ChronosPeriod = class _ChronosPeriod {
    * Get the intersection of two periods
    */
   intersect(other) {
-    var _a, _b;
     if (!this.overlaps(other)) {
       return null;
     }
     const start = this._start.isAfter(other._start) ? this._start : other._start;
-    const thisEnd = (_a = this._end) != null ? _a : this.last();
-    const otherEnd = (_b = other._end) != null ? _b : other.last();
+    const thisEnd = this._resolvedEnd();
+    const otherEnd = other._resolvedEnd();
     if (!thisEnd || !otherEnd) {
       return new _ChronosPeriod(start, void 0, this._interval);
     }
@@ -4501,13 +4717,12 @@ var ChronosPeriod = class _ChronosPeriod {
    * Get the union of two periods
    */
   union(other) {
-    var _a, _b;
     if (!this.overlaps(other) && !this._adjacentTo(other)) {
       return null;
     }
     const start = this._start.isBefore(other._start) ? this._start : other._start;
-    const thisEnd = (_a = this._end) != null ? _a : this.last();
-    const otherEnd = (_b = other._end) != null ? _b : other.last();
+    const thisEnd = this._resolvedEnd();
+    const otherEnd = other._resolvedEnd();
     if (!thisEnd || !otherEnd) {
       return new _ChronosPeriod(start, void 0, this._interval);
     }
@@ -4519,13 +4734,12 @@ var ChronosPeriod = class _ChronosPeriod {
    * Returns the parts of this period that don't overlap with the other period
    */
   diff(other) {
-    var _a, _b;
     if (!this.overlaps(other)) {
       return [this.clone()];
     }
     const results = [];
-    const thisEnd = (_a = this._end) != null ? _a : this.last();
-    const otherEnd = (_b = other._end) != null ? _b : other.last();
+    const thisEnd = this._resolvedEnd();
+    const otherEnd = other._resolvedEnd();
     if (this._start.isBefore(other._start)) {
       results.push(
         new _ChronosPeriod(this._start, other._start, this._interval)
@@ -4540,9 +4754,8 @@ var ChronosPeriod = class _ChronosPeriod {
    * Check if this period is adjacent to another
    */
   _adjacentTo(other) {
-    var _a, _b;
-    const thisEnd = (_a = this._end) != null ? _a : this.last();
-    const otherEnd = (_b = other._end) != null ? _b : other.last();
+    const thisEnd = this._resolvedEnd();
+    const otherEnd = other._resolvedEnd();
     if (!thisEnd || !otherEnd) {
       return false;
     }
@@ -4634,11 +4847,13 @@ var ChronosPeriod = class _ChronosPeriod {
     }
     const chunks = [];
     let current = this._start.clone();
+    const subStep = splitInterval.total("days") >= 1 ? { days: 1 } : { milliseconds: 1 };
     while (current.isSameOrBefore(this._end)) {
-      const chunkEnd = current.add(splitInterval.toDuration()).subtract({ days: 1 });
+      const nextStart = current.add(splitInterval.toDuration());
+      const chunkEnd = nextStart.subtract(subStep);
       const end = chunkEnd.isAfter(this._end) ? this._end : chunkEnd;
       chunks.push(new _ChronosPeriod(current, end, this._interval));
-      current = current.add(splitInterval.toDuration());
+      current = nextStart;
     }
     return chunks;
   }

package/dist/index.mjs

@@ -2013,18 +2013,14 @@ var Chronos = class _Chronos {
     if (isValidDate(isoDate)) {
       return isoDate;
     }
-    const formats = [
-      /^(\d{4})-(\d{2})-(\d{2})$/,
-      /^(\d{2})\/(\d{2})\/(\d{4})$/,
-      /^(\d{4})\/(\d{2})\/(\d{2})$/
-    ];
-    for (const format of formats) {
-      const match = input.match(format);
-      if (match) {
-        const parsed = new Date(input);
-        if (isValidDate(parsed)) {
-          return parsed;
-        }
+    const dmy = input.match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
+    if (dmy) {
+      const day = parseInt(dmy[1], 10);
+      const month = parseInt(dmy[2], 10);
+      const year = parseInt(dmy[3], 10);
+      const parsed = new Date(year, month - 1, day);
+      if (isValidDate(parsed) && parsed.getMonth() === month - 1) {
+        return parsed;
       }
     }
     throw new Error(`Unable to parse date: ${input}`);
@@ -2328,18 +2324,40 @@ var Chronos = class _Chronos {
   }
   /** Get the quarter (1-4) */
   get quarter() {
+    if (this._timezone) {
+      const month = new ChronosTimezone(this._timezone).getComponents(
+        this._date
+      ).month;
+      return Math.floor((month - 1) / 3) + 1;
+    }
     return getQuarter(this._date);
   }
   /** Get the day of year (1-366) */
   get dayOfYear() {
+    if (this._timezone) {
+      const c = new ChronosTimezone(this._timezone).getComponents(this._date);
+      let days = c.day;
+      for (let m = 1; m < c.month; m++) {
+        days += getDaysInMonth(c.year, m - 1);
+      }
+      return days;
+    }
     return getDayOfYear(this._date);
   }
   /** Get the ISO week number (1-53) */
   get week() {
+    if (this._timezone) {
+      const c = new ChronosTimezone(this._timezone).getComponents(this._date);
+      return getISOWeek(new Date(c.year, c.month - 1, c.day));
+    }
     return getISOWeek(this._date);
   }
   /** Get the ISO week year */
   get weekYear() {
+    if (this._timezone) {
+      const c = new ChronosTimezone(this._timezone).getComponents(this._date);
+      return getISOWeekYear(new Date(c.year, c.month - 1, c.day));
+    }
     return getISOWeekYear(this._date);
   }
   /** Get the number of days in the current month */
@@ -2360,6 +2378,9 @@ var Chronos = class _Chronos {
   }
   /** Get the timezone offset in minutes */
   get offset() {
+    if (this._timezone) {
+      return -new ChronosTimezone(this._timezone).getOffsetMinutes(this._date);
+    }
     return this._date.getTimezoneOffset();
   }
   /** Get the timezone offset as string (+05:30) */
@@ -2471,9 +2492,82 @@ var Chronos = class _Chronos {
       throw new Error("Unit is required when amount is a number");
     }
     const normalizedUnit = normalizeUnit(unit);
+    if (this._timezone) {
+      return this.addInZone(amount, normalizedUnit);
+    }
     const newDate = addUnits(this._date, amount, normalizedUnit);
     return new _Chronos(newDate, this._timezone);
   }
+  /**
+   * Add an amount of a single unit while respecting the instance timezone.
+   * Calendar units (day/week/month/quarter/year/…) preserve the wall-clock time
+   * in the zone (DST-safe); absolute units (hour/minute/second/millisecond) add a
+   * fixed offset to the instant. Day clamping mirrors the local-time path.
+   */
+  addInZone(amount, unit) {
+    const absoluteMs = {
+      millisecond: 1,
+      second: MILLISECONDS_PER_SECOND,
+      minute: MILLISECONDS_PER_MINUTE,
+      hour: MILLISECONDS_PER_HOUR
+    };
+    const perUnit = absoluteMs[unit];
+    if (perUnit !== void 0) {
+      const newDate = new Date(this._date.getTime() + amount * perUnit);
+      return new _Chronos(newDate, this._timezone);
+    }
+    const tz = new ChronosTimezone(this._timezone);
+    const c = tz.getComponents(this._date);
+    let year = c.year;
+    let month = c.month;
+    let day = c.day;
+    const calendarUnit = unit === "month" || unit === "quarter" || unit === "year" || unit === "decade" || unit === "century" || unit === "millennium";
+    switch (unit) {
+      case "day":
+        day += amount;
+        break;
+      case "week":
+        day += amount * 7;
+        break;
+      case "month":
+        month += amount;
+        break;
+      case "quarter":
+        month += amount * 3;
+        break;
+      case "year":
+        year += amount;
+        break;
+      case "decade":
+        year += amount * 10;
+        break;
+      case "century":
+        year += amount * 100;
+        break;
+      case "millennium":
+        year += amount * 1e3;
+        break;
+    }
+    year += Math.floor((month - 1) / 12);
+    month = ((month - 1) % 12 + 12) % 12 + 1;
+    if (calendarUnit) {
+      const maxDay = getDaysInMonth(year, month - 1);
+      if (day > maxDay) day = maxDay;
+    }
+    const date = _Chronos.dateFromComponents(
+      {
+        year,
+        month,
+        day,
+        hour: c.hour,
+        minute: c.minute,
+        second: c.second,
+        millisecond: this._date.getMilliseconds()
+      },
+      this._timezone
+    );
+    return new _Chronos(date, this._timezone);
+  }
   /**
    * Subtract time from the date
    */
@@ -2501,6 +2595,9 @@ var Chronos = class _Chronos {
    */
   startOf(unit) {
     const normalizedUnit = normalizeUnit(unit);
+    if (this._timezone) {
+      return this.boundaryInZone(normalizedUnit, false);
+    }
     const newDate = startOf(this._date, normalizedUnit);
     return new _Chronos(newDate, this._timezone);
   }
@@ -2516,9 +2613,96 @@ var Chronos = class _Chronos {
    */
   endOf(unit) {
     const normalizedUnit = normalizeUnit(unit);
+    if (this._timezone) {
+      return this.boundaryInZone(normalizedUnit, true);
+    }
     const newDate = endOf(this._date, normalizedUnit);
     return new _Chronos(newDate, this._timezone);
   }
+  /**
+   * Compute the start/end boundary of a unit in the instance timezone.
+   * The plain `startOf`/`endOf` helpers operate on local wall-clock fields of the
+   * underlying Date, which is wrong when an explicit timezone is attached. Here we
+   * read the wall-clock components in the target zone, snap them to the boundary,
+   * and rebuild the instant (dateFromComponents handles DST).
+   */
+  boundaryInZone(unit, end) {
+    if (unit === "millisecond") {
+      return this.clone();
+    }
+    const tz = new ChronosTimezone(this._timezone);
+    const c = tz.getComponents(this._date);
+    const comp = {
+      year: c.year,
+      month: c.month,
+      day: c.day,
+      hour: c.hour,
+      minute: c.minute,
+      second: c.second,
+      millisecond: this._date.getMilliseconds()
+    };
+    const resetTime = () => {
+      comp.hour = end ? 23 : 0;
+      comp.minute = end ? 59 : 0;
+      comp.second = end ? 59 : 0;
+      comp.millisecond = end ? 999 : 0;
+    };
+    switch (unit) {
+      case "second":
+        comp.millisecond = end ? 999 : 0;
+        break;
+      case "minute":
+        comp.second = end ? 59 : 0;
+        comp.millisecond = end ? 999 : 0;
+        break;
+      case "hour":
+        comp.minute = end ? 59 : 0;
+        comp.second = end ? 59 : 0;
+        comp.millisecond = end ? 999 : 0;
+        break;
+      case "day":
+        resetTime();
+        break;
+      case "week":
+        resetTime();
+        comp.day = c.day + (end ? 6 - c.dayOfWeek : -c.dayOfWeek);
+        break;
+      case "month":
+        resetTime();
+        comp.day = end ? getDaysInMonth(c.year, c.month - 1) : 1;
+        break;
+      case "quarter": {
+        resetTime();
+        const qStartMonth = Math.floor((c.month - 1) / 3) * 3 + 1;
+        if (end) {
+          comp.month = qStartMonth + 2;
+          comp.day = getDaysInMonth(c.year, comp.month - 1);
+        } else {
+          comp.month = qStartMonth;
+          comp.day = 1;
+        }
+        break;
+      }
+      case "year":
+        resetTime();
+        comp.month = end ? 12 : 1;
+        comp.day = end ? 31 : 1;
+        break;
+      case "decade":
+      case "century":
+      case "millennium": {
+        resetTime();
+        comp.month = end ? 12 : 1;
+        comp.day = end ? 31 : 1;
+        const span = unit === "decade" ? 10 : unit === "century" ? 100 : 1e3;
+        const base = Math.floor(c.year / span) * span;
+        comp.year = end ? base + span - 1 : base;
+        break;
+      }
+    }
+    const date = _Chronos.dateFromComponents(comp, this._timezone);
+    return new _Chronos(date, this._timezone);
+  }
   // ============================================================================
   // Convenience Add/Subtract Methods
   // ============================================================================
@@ -2713,6 +2897,12 @@ var Chronos = class _Chronos {
           return diffMs / MILLISECONDS_PER_DAY;
         case "week":
           return diffMs / (MILLISECONDS_PER_DAY * 7);
+        case "month":
+          return diffMs / MILLISECONDS_PER_MONTH;
+        case "quarter":
+          return diffMs / (MILLISECONDS_PER_MONTH * 3);
+        case "year":
+          return diffMs / MILLISECONDS_PER_YEAR;
       }
     }
     return diffInUnits(this._date, otherDate._date, normalizedUnit);
@@ -2770,12 +2960,12 @@ var Chronos = class _Chronos {
    * Get relative time from another date
    */
   from(other, options = {}) {
-    var _a, _b;
+    var _a, _b, _c;
     const otherDate = _Chronos.parse(other);
     const diffMs = this._date.getTime() - otherDate._date.getTime();
     const absDiff = Math.abs(diffMs);
     const isFuture = diffMs > 0;
-    const { short: _short = false, absolute = false } = options;
+    const { short = false, absolute = false } = options;
     const relative = this._locale.relativeTime;
     let value;
     let unit;
@@ -2801,10 +2991,26 @@ var Chronos = class _Chronos {
       value = Math.round(absDiff / (MILLISECONDS_PER_DAY * 365));
       unit = value === 1 ? "y" : "yy";
     }
-    const relativeStr = (_b = (_a = relative[unit]) == null ? void 0 : _a.replace(
+    const shortUnits = {
+      s: "s",
+      ss: "s",
+      m: "m",
+      mm: "m",
+      h: "h",
+      hh: "h",
+      d: "d",
+      dd: "d",
+      w: "w",
+      ww: "w",
+      M: "mo",
+      MM: "mo",
+      y: "y",
+      yy: "y"
+    };
+    const relativeStr = short ? `${value}${(_a = shortUnits[unit]) != null ? _a : unit}` : (_c = (_b = relative[unit]) == null ? void 0 : _b.replace(
       "%d",
       String(value)
-    )) != null ? _b : `${value} ${unit}`;
+    )) != null ? _c : `${value} ${unit}`;
     if (absolute) {
       return relativeStr;
     }
@@ -2883,7 +3089,7 @@ var Chronos = class _Chronos {
       Z: () => this.offsetString,
       ZZ: () => this.offsetString.replace(":", ""),
       Q: () => String(this.quarter),
-      Do: () => ordinalSuffix(this.date),
+      Do: () => this._locale.ordinal(this.date),
       W: () => String(this.week),
       WW: () => padStart(this.week, 2),
       X: () => String(this.unix),
@@ -3157,15 +3363,16 @@ var ChronosInterval = class _ChronosInterval {
   // Constructor
   // ============================================================================
   constructor(duration = {}, inverted = false) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     this._years = (_a = duration.years) != null ? _a : 0;
     this._months = (_b = duration.months) != null ? _b : 0;
     this._weeks = (_c = duration.weeks) != null ? _c : 0;
     this._days = (_d = duration.days) != null ? _d : 0;
     this._hours = (_e = duration.hours) != null ? _e : 0;
     this._minutes = (_f = duration.minutes) != null ? _f : 0;
-    this._seconds = Math.floor((_g = duration.seconds) != null ? _g : 0);
-    this._milliseconds = (_i = duration.milliseconds) != null ? _i : ((_h = duration.seconds) != null ? _h : 0) % 1 * 1e3;
+    const totalSeconds = (_g = duration.seconds) != null ? _g : 0;
+    this._seconds = Math.trunc(totalSeconds);
+    this._milliseconds = (_h = duration.milliseconds) != null ? _h : Math.round((totalSeconds - this._seconds) * 1e3);
     this._locale = getLocale("en");
     this._inverted = inverted;
   }
@@ -3854,7 +4061,6 @@ var ChronosPeriod = class _ChronosPeriod {
       immutable: (_c = options.immutable) != null ? _c : true
     };
     this._filters = [];
-    this._current = 0;
     this._locale = getLocale("en");
   }
   // ============================================================================
@@ -4464,13 +4670,24 @@ var ChronosPeriod = class _ChronosPeriod {
   // ============================================================================
   // Range Operations
   // ============================================================================
+  /**
+   * Resolve the effective end of the period.
+   * Returns null for a truly unbounded period (no end and no recurrence limit),
+   * which avoids calling last() — that would iterate until the safety limit and throw.
+   */
+  _resolvedEnd() {
+    var _a;
+    if (this.isUnbounded) {
+      return null;
+    }
+    return (_a = this._end) != null ? _a : this.last();
+  }
   /**
    * Check if two periods overlap
    */
   overlaps(other) {
-    var _a, _b;
-    const thisEnd = (_a = this._end) != null ? _a : this.last();
-    const otherEnd = (_b = other._end) != null ? _b : other.last();
+    const thisEnd = this._resolvedEnd();
+    const otherEnd = other._resolvedEnd();
     if (!thisEnd || !otherEnd) {
       return true;
     }
@@ -4480,13 +4697,12 @@ var ChronosPeriod = class _ChronosPeriod {
    * Get the intersection of two periods
    */
   intersect(other) {
-    var _a, _b;
     if (!this.overlaps(other)) {
       return null;
     }
     const start = this._start.isAfter(other._start) ? this._start : other._start;
-    const thisEnd = (_a = this._end) != null ? _a : this.last();
-    const otherEnd = (_b = other._end) != null ? _b : other.last();
+    const thisEnd = this._resolvedEnd();
+    const otherEnd = other._resolvedEnd();
     if (!thisEnd || !otherEnd) {
       return new _ChronosPeriod(start, void 0, this._interval);
     }
@@ -4497,13 +4713,12 @@ var ChronosPeriod = class _ChronosPeriod {
    * Get the union of two periods
    */
   union(other) {
-    var _a, _b;
     if (!this.overlaps(other) && !this._adjacentTo(other)) {
       return null;
     }
     const start = this._start.isBefore(other._start) ? this._start : other._start;
-    const thisEnd = (_a = this._end) != null ? _a : this.last();
-    const otherEnd = (_b = other._end) != null ? _b : other.last();
+    const thisEnd = this._resolvedEnd();
+    const otherEnd = other._resolvedEnd();
     if (!thisEnd || !otherEnd) {
       return new _ChronosPeriod(start, void 0, this._interval);
     }
@@ -4515,13 +4730,12 @@ var ChronosPeriod = class _ChronosPeriod {
    * Returns the parts of this period that don't overlap with the other period
    */
   diff(other) {
-    var _a, _b;
     if (!this.overlaps(other)) {
       return [this.clone()];
     }
     const results = [];
-    const thisEnd = (_a = this._end) != null ? _a : this.last();
-    const otherEnd = (_b = other._end) != null ? _b : other.last();
+    const thisEnd = this._resolvedEnd();
+    const otherEnd = other._resolvedEnd();
     if (this._start.isBefore(other._start)) {
       results.push(
         new _ChronosPeriod(this._start, other._start, this._interval)
@@ -4536,9 +4750,8 @@ var ChronosPeriod = class _ChronosPeriod {
    * Check if this period is adjacent to another
    */
   _adjacentTo(other) {
-    var _a, _b;
-    const thisEnd = (_a = this._end) != null ? _a : this.last();
-    const otherEnd = (_b = other._end) != null ? _b : other.last();
+    const thisEnd = this._resolvedEnd();
+    const otherEnd = other._resolvedEnd();
     if (!thisEnd || !otherEnd) {
       return false;
     }
@@ -4630,11 +4843,13 @@ var ChronosPeriod = class _ChronosPeriod {
     }
     const chunks = [];
     let current = this._start.clone();
+    const subStep = splitInterval.total("days") >= 1 ? { days: 1 } : { milliseconds: 1 };
     while (current.isSameOrBefore(this._end)) {
-      const chunkEnd = current.add(splitInterval.toDuration()).subtract({ days: 1 });
+      const nextStart = current.add(splitInterval.toDuration());
+      const chunkEnd = nextStart.subtract(subStep);
       const end = chunkEnd.isAfter(this._end) ? this._end : chunkEnd;
       chunks.push(new _ChronosPeriod(current, end, this._interval));
-      current = current.add(splitInterval.toDuration());
+      current = nextStart;
     }
     return chunks;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chronos-ts",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "A comprehensive TypeScript library for date and time manipulation, inspired by Carbon PHP. Features immutable API, intervals, periods, timezones, and i18n support.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",