ts-time-utils 4.1.0 → 4.4.0

package/dist/{precision.js → precision.cjs}

@@ -1,11 +1,47 @@
+"use strict";
 /**
  * @fileoverview High-precision time utilities
  * Handles nanoseconds, BigInt timestamps, sub-millisecond operations
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEAP_SECONDS = exports.ValidDate = void 0;
+exports.createNanosecondTimestamp = createNanosecondTimestamp;
+exports.fromNanoseconds = fromNanoseconds;
+exports.dateToNanoseconds = dateToNanoseconds;
+exports.nanosecondsToDate = nanosecondsToDate;
+exports.addNanoseconds = addNanoseconds;
+exports.subtractNanoseconds = subtractNanoseconds;
+exports.compareNanoseconds = compareNanoseconds;
+exports.nowNanoseconds = nowNanoseconds;
+exports.formatNanoseconds = formatNanoseconds;
+exports.parseNanoseconds = parseNanoseconds;
+exports.createHighResDuration = createHighResDuration;
+exports.addHighResDuration = addHighResDuration;
+exports.subtractHighResDuration = subtractHighResDuration;
+exports.highResDurationToMs = highResDurationToMs;
+exports.msToHighResDuration = msToHighResDuration;
+exports.toBigIntMs = toBigIntMs;
+exports.fromBigIntMs = fromBigIntMs;
+exports.toBigIntSeconds = toBigIntSeconds;
+exports.fromBigIntSeconds = fromBigIntSeconds;
+exports.addBigIntMs = addBigIntMs;
+exports.subtractBigIntMs = subtractBigIntMs;
+exports.diffBigIntMs = diffBigIntMs;
+exports.isInDSTGap = isInDSTGap;
+exports.isInDSTOverlap = isInDSTOverlap;
+exports.getDSTTransitionsInYear = getDSTTransitionsInYear;
+exports.resolveAmbiguousTime = resolveAmbiguousTime;
+exports.ensureValidDate = ensureValidDate;
+exports.parseValidDate = parseValidDate;
+exports.assertValidDate = assertValidDate;
+exports.leapSecondsBetween = leapSecondsBetween;
+exports.isNearLeapSecond = isNearLeapSecond;
+exports.taiToUtc = taiToUtc;
+exports.utcToTai = utcToTai;
 /**
  * Create a nanosecond timestamp from components
  */
-export function createNanosecondTimestamp(milliseconds, nanoseconds = 0) {
+function createNanosecondTimestamp(milliseconds, nanoseconds = 0) {
     // Normalize: ensure nanoseconds is 0-999999
     const extraMs = Math.floor(nanoseconds / 1000000);
     const normalizedNs = nanoseconds % 1000000;
@@ -20,7 +56,7 @@ export function createNanosecondTimestamp(milliseconds, nanoseconds = 0) {
 /**
  * Create a nanosecond timestamp from BigInt
  */
-export function fromNanoseconds(totalNs) {
+function fromNanoseconds(totalNs) {
     const ms = Number(totalNs / BigInt(1000000));
     const ns = Number(totalNs % BigInt(1000000));
     return {
@@ -32,32 +68,32 @@ export function fromNanoseconds(totalNs) {
 /**
  * Create a nanosecond timestamp from a Date
  */
-export function dateToNanoseconds(date) {
+function dateToNanoseconds(date) {
     return createNanosecondTimestamp(date.getTime(), 0);
 }
 /**
  * Convert nanosecond timestamp to Date (loses sub-millisecond precision)
  */
-export function nanosecondsToDate(timestamp) {
+function nanosecondsToDate(timestamp) {
     return new Date(timestamp.milliseconds);
 }
 /**
  * Add two nanosecond timestamps
  */
-export function addNanoseconds(a, b) {
+function addNanoseconds(a, b) {
     return fromNanoseconds(a.totalNanoseconds + b.totalNanoseconds);
 }
 /**
  * Subtract nanosecond timestamps
  */
-export function subtractNanoseconds(a, b) {
+function subtractNanoseconds(a, b) {
     return fromNanoseconds(a.totalNanoseconds - b.totalNanoseconds);
 }
 /**
  * Compare nanosecond timestamps
  * @returns -1 if a < b, 0 if equal, 1 if a > b
  */
-export function compareNanoseconds(a, b) {
+function compareNanoseconds(a, b) {
     if (a.totalNanoseconds < b.totalNanoseconds)
         return -1;
     if (a.totalNanoseconds > b.totalNanoseconds)
@@ -68,7 +104,7 @@ export function compareNanoseconds(a, b) {
  * Get current time with nanosecond precision (if available)
  * Falls back to millisecond precision if performance.now() not available
  */
-export function nowNanoseconds() {
+function nowNanoseconds() {
     const now = Date.now();
     // Try to get sub-millisecond precision from performance.now()
     if (typeof performance !== 'undefined' && performance.now) {
@@ -81,7 +117,7 @@ export function nowNanoseconds() {
 /**
  * Format nanosecond timestamp to ISO string with sub-millisecond precision
  */
-export function formatNanoseconds(timestamp) {
+function formatNanoseconds(timestamp) {
     const date = nanosecondsToDate(timestamp);
     const isoBase = date.toISOString().slice(0, -1); // Remove trailing 'Z'
     // Add nanoseconds (6 additional digits after milliseconds)
@@ -91,7 +127,7 @@ export function formatNanoseconds(timestamp) {
 /**
  * Parse ISO string with nanosecond precision
  */
-export function parseNanoseconds(isoString) {
+function parseNanoseconds(isoString) {
     // Match ISO format: 2024-03-25T14:30:45.123456789Z
     const match = isoString.match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3,9})Z?$/);
     if (!match) {
@@ -114,7 +150,7 @@ export function parseNanoseconds(isoString) {
 /**
  * Create a high-resolution duration
  */
-export function createHighResDuration(seconds, nanoseconds = 0) {
+function createHighResDuration(seconds, nanoseconds = 0) {
     // Normalize: carry over extra seconds from nanoseconds
     const extraSeconds = Math.floor(nanoseconds / 1000000000);
     const normalizedNs = nanoseconds % 1000000000;
@@ -126,7 +162,7 @@ export function createHighResDuration(seconds, nanoseconds = 0) {
 /**
  * Add two high-resolution durations
  */
-export function addHighResDuration(a, b) {
+function addHighResDuration(a, b) {
     const totalNs = a.nanoseconds + b.nanoseconds;
     const extraSeconds = Math.floor(totalNs / 1000000000);
     const ns = totalNs % 1000000000;
@@ -138,7 +174,7 @@ export function addHighResDuration(a, b) {
 /**
  * Subtract high-resolution durations
  */
-export function subtractHighResDuration(a, b) {
+function subtractHighResDuration(a, b) {
     let totalNs = a.nanoseconds - b.nanoseconds;
     let seconds = a.seconds - b.seconds;
     if (totalNs < 0) {
@@ -150,13 +186,13 @@ export function subtractHighResDuration(a, b) {
 /**
  * Convert high-resolution duration to milliseconds
  */
-export function highResDurationToMs(duration) {
+function highResDurationToMs(duration) {
     return duration.seconds * 1000 + duration.nanoseconds / 1000000;
 }
 /**
  * Convert milliseconds to high-resolution duration
  */
-export function msToHighResDuration(ms) {
+function msToHighResDuration(ms) {
     const seconds = Math.floor(ms / 1000);
     const nanoseconds = Math.round((ms % 1000) * 1000000);
     return { seconds, nanoseconds };
@@ -165,45 +201,45 @@ export function msToHighResDuration(ms) {
 /**
  * Convert Unix epoch milliseconds to BigInt
  */
-export function toBigIntMs(date) {
+function toBigIntMs(date) {
     return BigInt(date.getTime());
 }
 /**
  * Convert BigInt milliseconds to Date
  */
-export function fromBigIntMs(ms) {
+function fromBigIntMs(ms) {
     return new Date(Number(ms));
 }
 /**
  * Convert Unix epoch seconds to BigInt
  */
-export function toBigIntSeconds(date) {
+function toBigIntSeconds(date) {
     return BigInt(Math.floor(date.getTime() / 1000));
 }
 /**
  * Convert BigInt seconds to Date
  */
-export function fromBigIntSeconds(seconds) {
+function fromBigIntSeconds(seconds) {
     return new Date(Number(seconds) * 1000);
 }
 /**
  * Add milliseconds (as BigInt) to a date
  */
-export function addBigIntMs(date, ms) {
+function addBigIntMs(date, ms) {
     const current = toBigIntMs(date);
     return fromBigIntMs(current + ms);
 }
 /**
  * Subtract milliseconds (as BigInt) from a date
  */
-export function subtractBigIntMs(date, ms) {
+function subtractBigIntMs(date, ms) {
     const current = toBigIntMs(date);
     return fromBigIntMs(current - ms);
 }
 /**
  * Calculate difference between dates in BigInt milliseconds
  */
-export function diffBigIntMs(a, b) {
+function diffBigIntMs(a, b) {
     return toBigIntMs(a) - toBigIntMs(b);
 }
 /**
@@ -211,7 +247,7 @@ export function diffBigIntMs(a, b) {
  * @param date - Date to check
  * @param timeZone - IANA timezone (optional, uses local if not provided)
  */
-export function isInDSTGap(date, timeZone) {
+function isInDSTGap(date, timeZone) {
     if (timeZone) {
         // For specific timezone, we need to check around this time
         const formatter = new Intl.DateTimeFormat('en-US', {
@@ -255,7 +291,7 @@ export function isInDSTGap(date, timeZone) {
  * @param date - Date to check
  * @param timeZone - IANA timezone (optional, uses local if not provided)
  */
-export function isInDSTOverlap(date, timeZone) {
+function isInDSTOverlap(date, timeZone) {
     if (timeZone) {
         // Similar approach as isInDSTGap but for fall-back
         // This is harder to detect accurately without full TZ database
@@ -272,7 +308,7 @@ export function isInDSTOverlap(date, timeZone) {
 /**
  * Find DST transitions in a year for local timezone
  */
-export function getDSTTransitionsInYear(year) {
+function getDSTTransitionsInYear(year) {
     const transitions = [];
     let prevOffset = new Date(year, 0, 1).getTimezoneOffset();
     // Check each day of the year
@@ -312,7 +348,7 @@ export function getDSTTransitionsInYear(year) {
  * @param date - Potentially ambiguous date
  * @param prefer - Prefer 'earlier' or 'later' interpretation
  */
-export function resolveAmbiguousTime(date, prefer = 'earlier') {
+function resolveAmbiguousTime(date, prefer = 'earlier') {
     if (!isInDSTOverlap(date)) {
         return date;
     }
@@ -333,7 +369,7 @@ export function resolveAmbiguousTime(date, prefer = 'earlier') {
 /**
  * Validated Date wrapper that guarantees a valid date
  */
-export class ValidDate {
+class ValidDate {
     constructor(date) {
         this._date = date;
     }
@@ -394,16 +430,17 @@ export class ValidDate {
         return this._date.toLocaleString(locale, options);
     }
 }
+exports.ValidDate = ValidDate;
 /**
  * Ensure a date is valid, with fallback
  */
-export function ensureValidDate(date, fallback = new Date()) {
+function ensureValidDate(date, fallback = new Date()) {
     return isNaN(date.getTime()) ? fallback : date;
 }
 /**
  * Parse date with validation
  */
-export function parseValidDate(input) {
+function parseValidDate(input) {
     if (input instanceof Date) {
         return isNaN(input.getTime()) ? null : input;
     }
@@ -413,7 +450,7 @@ export function parseValidDate(input) {
 /**
  * Assert date is valid, throws if not
  */
-export function assertValidDate(date, message) {
+function assertValidDate(date, message) {
     if (isNaN(date.getTime())) {
         throw new Error(message || 'Invalid Date');
     }
@@ -423,7 +460,7 @@ export function assertValidDate(date, message) {
  * Known leap seconds (added at end of these dates, 23:59:60 UTC)
  * List from https://www.ietf.org/timezones/data/leap-seconds.list
  */
-export const LEAP_SECONDS = [
+exports.LEAP_SECONDS = [
     new Date('1972-06-30T23:59:59Z'),
     new Date('1972-12-31T23:59:59Z'),
     new Date('1973-12-31T23:59:59Z'),
@@ -455,9 +492,9 @@ export const LEAP_SECONDS = [
 /**
  * Get number of leap seconds between two dates
  */
-export function leapSecondsBetween(start, end) {
+function leapSecondsBetween(start, end) {
     let count = 0;
-    for (const ls of LEAP_SECONDS) {
+    for (const ls of exports.LEAP_SECONDS) {
         if (ls >= start && ls < end) {
             count++;
         }
@@ -467,15 +504,15 @@ export function leapSecondsBetween(start, end) {
 /**
  * Check if a date is near a leap second (within 1 second)
  */
-export function isNearLeapSecond(date) {
+function isNearLeapSecond(date) {
     const time = date.getTime();
-    return LEAP_SECONDS.some(ls => Math.abs(ls.getTime() - time) <= 1000);
+    return exports.LEAP_SECONDS.some(ls => Math.abs(ls.getTime() - time) <= 1000);
 }
 /**
  * Convert TAI (International Atomic Time) to UTC
  * TAI = UTC + accumulated leap seconds + 10 (initial offset)
  */
-export function taiToUtc(taiMs) {
+function taiToUtc(taiMs) {
     // Count leap seconds before this TAI time
     const utcApprox = new Date(taiMs);
     const leapSeconds = leapSecondsBetween(new Date(0), utcApprox);
@@ -485,7 +522,7 @@ export function taiToUtc(taiMs) {
 /**
  * Convert UTC to TAI
  */
-export function utcToTai(date) {
+function utcToTai(date) {
     const leapSeconds = leapSecondsBetween(new Date(0), date);
     return date.getTime() + (leapSeconds + 10) * 1000;
 }

package/dist/{rangePresets.js → rangePresets.cjs}

@@ -1,6 +1,27 @@
+"use strict";
 /**
  * Predefined date range helpers for common time periods
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANGE_PRESETS = void 0;
+exports.today = today;
+exports.yesterday = yesterday;
+exports.tomorrow = tomorrow;
+exports.lastNDays = lastNDays;
+exports.nextNDays = nextNDays;
+exports.thisWeek = thisWeek;
+exports.lastWeek = lastWeek;
+exports.nextWeek = nextWeek;
+exports.thisMonth = thisMonth;
+exports.lastMonth = lastMonth;
+exports.nextMonth = nextMonth;
+exports.thisYear = thisYear;
+exports.lastYear = lastYear;
+exports.nextYear = nextYear;
+exports.rollingWindowDays = rollingWindowDays;
+exports.quarterRange = quarterRange;
+exports.lastQuarter = lastQuarter;
+exports.nextQuarter = nextQuarter;
 function todayRange(now = new Date()) {
     const start = new Date(now);
     start.setHours(0, 0, 0, 0);
@@ -8,33 +29,33 @@ function todayRange(now = new Date()) {
     end.setDate(end.getDate() + 1);
     return { start, end };
 }
-export function today(now = new Date()) { return todayRange(now); }
-export function yesterday(now = new Date()) {
+function today(now = new Date()) { return todayRange(now); }
+function yesterday(now = new Date()) {
     const t = todayRange(now);
     const end = new Date(t.start); // yesterday end equals today start
     const start = new Date(end);
     start.setDate(start.getDate() - 1);
     return { start, end };
 }
-export function tomorrow(now = new Date()) {
+function tomorrow(now = new Date()) {
     const t = todayRange(now);
     t.start.setDate(t.start.getDate() + 1);
     t.end.setDate(t.end.getDate() + 1);
     return t;
 }
-export function lastNDays(n, now = new Date()) {
+function lastNDays(n, now = new Date()) {
     const end = new Date(now);
     const start = new Date(end);
     start.setDate(start.getDate() - n);
     return { start, end };
 }
-export function nextNDays(n, now = new Date()) {
+function nextNDays(n, now = new Date()) {
     const start = new Date(now);
     const end = new Date(start);
     end.setDate(end.getDate() + n);
     return { start, end };
 }
-export function thisWeek(now = new Date()) {
+function thisWeek(now = new Date()) {
     const start = new Date(now);
     const day = start.getDay(); // 0 Sunday
     start.setHours(0, 0, 0, 0);
@@ -43,78 +64,78 @@ export function thisWeek(now = new Date()) {
     end.setDate(end.getDate() + 7);
     return { start, end };
 }
-export function lastWeek(now = new Date()) {
+function lastWeek(now = new Date()) {
     const w = thisWeek(now);
     w.start.setDate(w.start.getDate() - 7);
     w.end.setDate(w.end.getDate() - 7);
     return w;
 }
-export function nextWeek(now = new Date()) {
+function nextWeek(now = new Date()) {
     const w = thisWeek(now);
     w.start.setDate(w.start.getDate() + 7);
     w.end.setDate(w.end.getDate() + 7);
     return w;
 }
-export function thisMonth(now = new Date()) {
+function thisMonth(now = new Date()) {
     const start = new Date(now.getFullYear(), now.getMonth(), 1);
     const end = new Date(now.getFullYear(), now.getMonth() + 1, 1);
     return { start, end };
 }
-export function lastMonth(now = new Date()) {
+function lastMonth(now = new Date()) {
     const m = thisMonth(now);
     m.start.setMonth(m.start.getMonth() - 1);
     m.end.setMonth(m.end.getMonth() - 1);
     return m;
 }
-export function nextMonth(now = new Date()) {
+function nextMonth(now = new Date()) {
     const m = thisMonth(now);
     m.start.setMonth(m.start.getMonth() + 1);
     m.end.setMonth(m.end.getMonth() + 1);
     return m;
 }
-export function thisYear(now = new Date()) {
+function thisYear(now = new Date()) {
     const start = new Date(now.getFullYear(), 0, 1);
     const end = new Date(now.getFullYear() + 1, 0, 1);
     return { start, end };
 }
-export function lastYear(now = new Date()) {
+function lastYear(now = new Date()) {
     const y = thisYear(now);
     y.start.setFullYear(y.start.getFullYear() - 1);
     y.end.setFullYear(y.end.getFullYear() - 1);
     return y;
 }
-export function nextYear(now = new Date()) {
+function nextYear(now = new Date()) {
     const y = thisYear(now);
     y.start.setFullYear(y.start.getFullYear() + 1);
     y.end.setFullYear(y.end.getFullYear() + 1);
     return y;
 }
-export function rollingWindowDays(days, now = new Date()) {
+function rollingWindowDays(days, now = new Date()) {
     const end = new Date(now);
     const start = new Date(end);
     start.setDate(start.getDate() - days);
     return { start, end };
 }
-export function quarterRange(now = new Date()) {
+function quarterRange(now = new Date()) {
     const q = Math.floor(now.getMonth() / 3); // 0-3
     const start = new Date(now.getFullYear(), q * 3, 1);
     const end = new Date(now.getFullYear(), q * 3 + 3, 1);
     return { start, end };
 }
-export function lastQuarter(now = new Date()) {
+function lastQuarter(now = new Date()) {
     const q = quarterRange(now);
     q.start.setMonth(q.start.getMonth() - 3);
     q.end.setMonth(q.end.getMonth() - 3);
     return q;
 }
-export function nextQuarter(now = new Date()) {
+function nextQuarter(now = new Date()) {
     const q = quarterRange(now);
     q.start.setMonth(q.start.getMonth() + 3);
     q.end.setMonth(q.end.getMonth() + 3);
     return q;
 }
 /** Map of preset functions for dynamic access */
-export const RANGE_PRESETS = {
+exports.RANGE_PRESETS = {
     today, yesterday, tomorrow,
     last7Days: (now) => lastNDays(7, now),
     last30Days: (now) => lastNDays(30, now),

package/dist/{recurrence.js → recurrence.cjs}

@@ -1,8 +1,16 @@
+"use strict";
 /**
  * @fileoverview Recurring events and pattern-based date generation utilities
  * Provides RRULE-inspired recurrence patterns for creating repeating events
  */
-import { addTime } from './calculate.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRecurrence = createRecurrence;
+exports.getNextOccurrence = getNextOccurrence;
+exports.getOccurrencesBetween = getOccurrencesBetween;
+exports.isRecurrenceDate = isRecurrenceDate;
+exports.isValidRecurrenceRule = isValidRecurrenceRule;
+exports.recurrenceToString = recurrenceToString;
+const calculate_js_1 = require("./calculate.cjs");
 /**
  * Creates a recurrence pattern generator
  * @param rule - The recurrence rule defining the pattern
@@ -34,7 +42,7 @@ import { addTime } from './calculate.js';
  * });
  * ```
  */
-export function createRecurrence(rule) {
+function createRecurrence(rule) {
     const startDate = new Date(rule.startDate);
     return {
         rule,
@@ -43,19 +51,17 @@ export function createRecurrence(rule) {
         isRecurrenceDate: (date) => isRecurrenceDate(date, rule),
         getAllOccurrences: (limit = 100) => {
             const occurrences = [];
-            let current = new Date(startDate);
-            let count = 0;
-            while (count < limit) {
+            let current = new Date(startDate.getTime() - 1);
+            while (occurrences.length < limit) {
                 if (rule.until && current > new Date(rule.until))
                     break;
-                if (rule.count && count >= rule.count)
+                if (rule.count && occurrences.length >= rule.count)
                     break;
                 const next = getNextOccurrence(rule, current);
                 if (!next)
                     break;
                 occurrences.push(next);
                 current = new Date(next.getTime() + 1);
-                count++;
             }
             return occurrences;
         }
@@ -79,7 +85,7 @@ export function createRecurrence(rule) {
  * // Returns Date('2024-01-07') - every other day
  * ```
  */
-export function getNextOccurrence(rule, afterDate) {
+function getNextOccurrence(rule, afterDate) {
     const after = afterDate ? new Date(afterDate) : new Date();
     const start = new Date(rule.startDate);
     // If afterDate is before start, check if start matches
@@ -94,7 +100,7 @@ export function getNextOccurrence(rule, afterDate) {
     }
     // Start searching from the day after 'after'
     // We want strictly greater than after, so start from the next potential occurrence
-    let candidate = addTime(after, 1, 'day');
+    let candidate = (0, calculate_js_1.addTime)(after, 1, 'day');
     // Preserve time from start date
     candidate.setHours(start.getHours(), start.getMinutes(), start.getSeconds(), start.getMilliseconds());
     const maxIterations = 1000; // Prevent infinite loops
@@ -137,7 +143,7 @@ export function getNextOccurrence(rule, afterDate) {
  * // Returns all Mondays and Fridays in January 2024
  * ```
  */
-export function getOccurrencesBetween(rule, start, end, limit = 1000) {
+function getOccurrencesBetween(rule, start, end, limit = 1000) {
     const startDate = new Date(start);
     const endDate = new Date(end);
     const occurrences = [];
@@ -179,7 +185,7 @@ export function getOccurrencesBetween(rule, start, end, limit = 1000) {
  * isRecurrenceDate(new Date('2024-01-09'), rule); // false (Tuesday)
  * ```
  */
-export function isRecurrenceDate(date, rule) {
+function isRecurrenceDate(date, rule) {
     const checkDate = new Date(date);
     const start = new Date(rule.startDate);
     // Must be on or after start date
@@ -210,7 +216,7 @@ export function isRecurrenceDate(date, rule) {
  * }); // false
  * ```
  */
-export function isValidRecurrenceRule(rule) {
+function isValidRecurrenceRule(rule) {
     if (!rule.frequency || !rule.startDate)
         return false;
     const validFrequencies = ['daily', 'weekly', 'monthly', 'yearly'];
@@ -264,7 +270,7 @@ export function isValidRecurrenceRule(rule) {
  * // "Every 2 weeks on Monday, Wednesday, Friday"
  * ```
  */
-export function recurrenceToString(rule) {
+function recurrenceToString(rule) {
     const interval = rule.interval || 1;
     let result = interval === 1 ? 'Every' : `Every ${interval}`;
     switch (rule.frequency) {
@@ -378,27 +384,27 @@ function getNextCandidate(date, rule) {
         case 'daily':
             // For daily recurrence, always increment by 1 day to check each day
             // matchesRecurrenceRule will filter based on interval
-            return addTime(date, 1, 'day');
+            return (0, calculate_js_1.addTime)(date, 1, 'day');
         case 'weekly':
             // If we have specific weekdays, try next day, otherwise skip full interval
             if (rule.byWeekday && rule.byWeekday.length > 0) {
-                return addTime(date, 1, 'day');
+                return (0, calculate_js_1.addTime)(date, 1, 'day');
             }
-            return addTime(date, interval * 7, 'day');
+            return (0, calculate_js_1.addTime)(date, interval * 7, 'day');
         case 'monthly':
             // If we have specific days of month, try next day, otherwise skip full interval
             if (rule.byMonthDay && rule.byMonthDay.length > 0) {
-                return addTime(date, 1, 'day');
+                return (0, calculate_js_1.addTime)(date, 1, 'day');
             }
-            return addTime(date, interval, 'month');
+            return (0, calculate_js_1.addTime)(date, interval, 'month');
         case 'yearly':
             // If we have specific months or days, try next day, otherwise skip full interval
             if ((rule.byMonth && rule.byMonth.length > 0) ||
                 (rule.byMonthDay && rule.byMonthDay.length > 0)) {
-                return addTime(date, 1, 'day');
+                return (0, calculate_js_1.addTime)(date, 1, 'day');
             }
-            return addTime(date, interval, 'year');
+            return (0, calculate_js_1.addTime)(date, interval, 'year');
         default:
-            return addTime(date, 1, 'day');
+            return (0, calculate_js_1.addTime)(date, 1, 'day');
     }
 }

package/dist/recurrence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recurrence.d.ts","sourceRoot":"","sources":["../src/recurrence.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAuB,MAAM,YAAY,CAAC;AAGjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc;;oCAKjB,SAAS;mCACV,SAAS,OAAO,SAAS,UAAU,MAAM;6BAE/C,SAAS;;EAqBrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAyC1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,SAAS,EACd,KAAK,SAAO,GACX,IAAI,EAAE,CA6BR;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAW/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAgC5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CA6C/D"}
+{"version":3,"file":"recurrence.d.ts","sourceRoot":"","sources":["../src/recurrence.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAuB,MAAM,YAAY,CAAC;AAGjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc;;oCAKjB,SAAS;mCACV,SAAS,OAAO,SAAS,UAAU,MAAM;6BAE/C,SAAS;;EAmBrC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CAyC1F;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,SAAS,EACd,KAAK,SAAO,GACX,IAAI,EAAE,CA6BR;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAW/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,OAAO,CAgC5E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CA6C/D"}