ts-time-utils 4.1.0 → 4.4.1

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"}

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

@@ -1,13 +1,28 @@
+"use strict";
 /**
  * @fileoverview Scheduling and booking utilities
  * Provides slot generation, availability checking, and conflict detection
  */
-import { dateRangeOverlap, mergeDateRanges } from './dateRange.js';
-import { isWorkingDay, isWorkingTime, DEFAULT_WORKING_HOURS, getWorkDayStart, getWorkDayEnd } from './workingHours.js';
-import { getOccurrencesBetween } from './recurrence.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SCHEDULING_CONFIG = void 0;
+exports.generateSlots = generateSlots;
+exports.generateSlotsForRange = generateSlotsForRange;
+exports.getAvailableSlots = getAvailableSlots;
+exports.findNextAvailable = findNextAvailable;
+exports.isSlotAvailable = isSlotAvailable;
+exports.findConflicts = findConflicts;
+exports.hasConflict = hasConflict;
+exports.addBuffer = addBuffer;
+exports.removeBuffer = removeBuffer;
+exports.expandRecurringAvailability = expandRecurringAvailability;
+exports.mergeBookings = mergeBookings;
+exports.splitSlot = splitSlot;
+const dateRange_js_1 = require("./dateRange.cjs");
+const workingHours_js_1 = require("./workingHours.cjs");
+const recurrence_js_1 = require("./recurrence.cjs");
 /** Default scheduling configuration */
-export const DEFAULT_SCHEDULING_CONFIG = {
-    workingHours: DEFAULT_WORKING_HOURS,
+exports.DEFAULT_SCHEDULING_CONFIG = {
+    workingHours: workingHours_js_1.DEFAULT_WORKING_HOURS,
     bufferMinutes: 0,
     slotDuration: 30,
     holidays: []
@@ -39,19 +54,19 @@ function isHoliday(date, holidays) {
  * // Returns 30-minute slots during working hours
  * ```
  */
-export function generateSlots(date, config = {}) {
+function generateSlots(date, config = {}) {
     const d = toDate(date);
-    const cfg = { ...DEFAULT_SCHEDULING_CONFIG, ...config };
-    const workingHours = cfg.workingHours ?? DEFAULT_WORKING_HOURS;
+    const cfg = { ...exports.DEFAULT_SCHEDULING_CONFIG, ...config };
+    const workingHours = cfg.workingHours ?? workingHours_js_1.DEFAULT_WORKING_HOURS;
     // Check if it's a working day and not a holiday
-    if (!isWorkingDay(d, workingHours))
+    if (!(0, workingHours_js_1.isWorkingDay)(d, workingHours))
         return [];
     if (cfg.holidays && isHoliday(d, cfg.holidays))
         return [];
     const slots = [];
     const slotDuration = cfg.slotDuration ?? 30;
-    const dayStart = getWorkDayStart(d, workingHours);
-    const dayEnd = getWorkDayEnd(d, workingHours);
+    const dayStart = (0, workingHours_js_1.getWorkDayStart)(d, workingHours);
+    const dayEnd = (0, workingHours_js_1.getWorkDayEnd)(d, workingHours);
     let current = new Date(dayStart);
     while (current < dayEnd) {
         const slotEnd = new Date(current.getTime() + slotDuration * 60 * 1000);
@@ -59,7 +74,7 @@ export function generateSlots(date, config = {}) {
         if (slotEnd <= dayEnd) {
             // Check if slot is during working time (not during breaks)
             const midpoint = new Date(current.getTime() + (slotDuration * 60 * 1000) / 2);
-            const available = isWorkingTime(midpoint, workingHours);
+            const available = (0, workingHours_js_1.isWorkingTime)(midpoint, workingHours);
             slots.push({
                 start: new Date(current),
                 end: new Date(slotEnd),
@@ -82,7 +97,7 @@ export function generateSlots(date, config = {}) {
  * const slots = generateSlotsForRange(range, { slotDuration: 60 });
  * ```
  */
-export function generateSlotsForRange(range, config = {}) {
+function generateSlotsForRange(range, config = {}) {
     const slots = [];
     const current = new Date(range.start);
     current.setHours(0, 0, 0, 0);
@@ -108,8 +123,8 @@ export function generateSlotsForRange(range, config = {}) {
  * const available = getAvailableSlots(new Date('2024-01-15'), bookings);
  * ```
  */
-export function getAvailableSlots(date, bookings, config = {}) {
-    const cfg = { ...DEFAULT_SCHEDULING_CONFIG, ...config };
+function getAvailableSlots(date, bookings, config = {}) {
+    const cfg = { ...exports.DEFAULT_SCHEDULING_CONFIG, ...config };
     const slots = generateSlots(date, cfg);
     const bufferMs = (cfg.bufferMinutes ?? 0) * 60 * 1000;
     return slots.map(slot => {
@@ -118,7 +133,7 @@ export function getAvailableSlots(date, bookings, config = {}) {
             start: new Date(slot.start.getTime() - bufferMs),
             end: new Date(slot.end.getTime() + bufferMs)
         };
-        const hasConflict = bookings.some(booking => dateRangeOverlap(checkRange, booking));
+        const hasConflict = bookings.some(booking => (0, dateRange_js_1.dateRangeOverlap)(checkRange, booking));
         return {
             ...slot,
             available: slot.available && !hasConflict
@@ -139,9 +154,9 @@ export function getAvailableSlots(date, bookings, config = {}) {
  * if (nextSlot) console.log(`Next 1-hour slot at ${nextSlot.start}`);
  * ```
  */
-export function findNextAvailable(after, bookings, duration, config = {}) {
+function findNextAvailable(after, bookings, duration, config = {}) {
     const startDate = toDate(after);
-    const cfg = { ...DEFAULT_SCHEDULING_CONFIG, ...config, slotDuration: duration };
+    const cfg = { ...exports.DEFAULT_SCHEDULING_CONFIG, ...config, slotDuration: duration };
     // Search up to 30 days ahead
     for (let dayOffset = 0; dayOffset < 30; dayOffset++) {
         const checkDate = new Date(startDate);
@@ -169,8 +184,8 @@ export function findNextAvailable(after, bookings, duration, config = {}) {
  * }
  * ```
  */
-export function isSlotAvailable(slot, bookings) {
-    return !bookings.some(booking => dateRangeOverlap(slot, booking));
+function isSlotAvailable(slot, bookings) {
+    return !bookings.some(booking => (0, dateRange_js_1.dateRangeOverlap)(slot, booking));
 }
 /**
  * Finds bookings that conflict with a proposed time range
@@ -186,8 +201,8 @@ export function isSlotAvailable(slot, bookings) {
  * }
  * ```
  */
-export function findConflicts(bookings, proposed) {
-    return bookings.filter(booking => dateRangeOverlap(booking, proposed));
+function findConflicts(bookings, proposed) {
+    return bookings.filter(booking => (0, dateRange_js_1.dateRangeOverlap)(booking, proposed));
 }
 /**
  * Checks if a proposed time range has any conflicts
@@ -202,8 +217,8 @@ export function findConflicts(bookings, proposed) {
  * }
  * ```
  */
-export function hasConflict(bookings, proposed) {
-    return bookings.some(booking => dateRangeOverlap(booking, proposed));
+function hasConflict(bookings, proposed) {
+    return bookings.some(booking => (0, dateRange_js_1.dateRangeOverlap)(booking, proposed));
 }
 /**
  * Adds buffer time around a slot
@@ -218,7 +233,7 @@ export function hasConflict(bookings, proposed) {
  * // buffered.start = 09:45, buffered.end = 11:15
  * ```
  */
-export function addBuffer(slot, bufferMinutes) {
+function addBuffer(slot, bufferMinutes) {
     const bufferMs = bufferMinutes * 60 * 1000;
     return {
         start: new Date(slot.start.getTime() - bufferMs),
@@ -238,7 +253,7 @@ export function addBuffer(slot, bufferMinutes) {
  * // original.start = 10:00, original.end = 11:00
  * ```
  */
-export function removeBuffer(slot, bufferMinutes) {
+function removeBuffer(slot, bufferMinutes) {
     const bufferMs = bufferMinutes * 60 * 1000;
     return {
         start: new Date(slot.start.getTime() + bufferMs),
@@ -263,8 +278,8 @@ export function removeBuffer(slot, bufferMinutes) {
  * const slots = expandRecurringAvailability(pattern, range);
  * ```
  */
-export function expandRecurringAvailability(pattern, range, config = {}) {
-    const occurrences = getOccurrencesBetween(pattern, range.start, range.end);
+function expandRecurringAvailability(pattern, range, config = {}) {
+    const occurrences = (0, recurrence_js_1.getOccurrencesBetween)(pattern, range.start, range.end);
     const slots = [];
     for (const occurrence of occurrences) {
         const daySlots = generateSlots(occurrence, config);
@@ -287,10 +302,10 @@ export function expandRecurringAvailability(pattern, range, config = {}) {
  * // [{ start: 09:00, end: 11:00 }]
  * ```
  */
-export function mergeBookings(bookings) {
+function mergeBookings(bookings) {
     if (bookings.length === 0)
         return [];
-    const ranges = mergeDateRanges(bookings);
+    const ranges = (0, dateRange_js_1.mergeDateRanges)(bookings);
     return ranges.map(range => ({
         start: range.start,
         end: range.end
@@ -309,7 +324,7 @@ export function mergeBookings(bookings) {
  * // before: 09:00-10:00, after: 10:00-11:00
  * ```
  */
-export function splitSlot(slot, at) {
+function splitSlot(slot, at) {
     const splitTime = toDate(at);
     if (splitTime <= slot.start || splitTime >= slot.end) {
         return null;

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

@@ -1,10 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeDate = serializeDate;
+exports.deserializeDate = deserializeDate;
+exports.createDateReviver = createDateReviver;
+exports.createDateReplacer = createDateReplacer;
+exports.parseISOString = parseISOString;
+exports.toEpochTimestamp = toEpochTimestamp;
+exports.fromEpochTimestamp = fromEpochTimestamp;
+exports.createEpochTimestamp = createEpochTimestamp;
+exports.toDateObject = toDateObject;
+exports.fromDateObject = fromDateObject;
+exports.isValidISODateString = isValidISODateString;
+exports.isValidEpochTimestamp = isValidEpochTimestamp;
+exports.cloneDate = cloneDate;
+exports.datesEqual = datesEqual;
+exports.now = now;
+exports.parseJSONWithDates = parseJSONWithDates;
+exports.stringifyWithDates = stringifyWithDates;
 /**
  * Safe JSON date serialization and deserialization utilities
  */
 /**
  * Safely serialize a date to JSON with various format options
  */
-export function serializeDate(date, options = {}) {
+function serializeDate(date, options = {}) {
     const { format = 'iso', includeTimezone = false, useUTC = false, precision = 'milliseconds', customFormat } = options;
     const dateObj = normalizeDate(date);
     if (!dateObj) {
@@ -30,7 +49,7 @@ export function serializeDate(date, options = {}) {
 /**
  * Safely deserialize a date from various formats
  */
-export function deserializeDate(serializedDate, options = {}) {
+function deserializeDate(serializedDate, options = {}) {
     const { useUTC = false } = options;
     try {
         if (typeof serializedDate === 'string') {
@@ -59,7 +78,7 @@ export function deserializeDate(serializedDate, options = {}) {
 /**
  * Create a safe JSON reviver function for automatic date parsing
  */
-export function createDateReviver(dateKeys = ['createdAt', 'updatedAt', 'date', 'timestamp'], options = {}) {
+function createDateReviver(dateKeys = ['createdAt', 'updatedAt', 'date', 'timestamp'], options = {}) {
     return (key, value) => {
         if (dateKeys.includes(key) && (typeof value === 'string' || typeof value === 'number')) {
             const parsed = deserializeDate(value, options);
@@ -71,7 +90,7 @@ export function createDateReviver(dateKeys = ['createdAt', 'updatedAt', 'date',
 /**
  * Create a safe JSON replacer function for automatic date serialization
  */
-export function createDateReplacer(dateKeys = ['createdAt', 'updatedAt', 'date', 'timestamp'], options = {}) {
+function createDateReplacer(dateKeys = ['createdAt', 'updatedAt', 'date', 'timestamp'], options = {}) {
     return (key, value) => {
         if (dateKeys.includes(key)) {
             if (value instanceof Date) {
@@ -91,7 +110,7 @@ export function createDateReplacer(dateKeys = ['createdAt', 'updatedAt', 'date',
 /**
  * Parse ISO string with better error handling
  */
-export function parseISOString(isoString, useUTC = false) {
+function parseISOString(isoString, useUTC = false) {
     if (!isoString || typeof isoString !== 'string') {
         return null;
     }
@@ -120,7 +139,7 @@ export function parseISOString(isoString, useUTC = false) {
 /**
  * Convert date to epoch timestamp with specified precision
  */
-export function toEpochTimestamp(date, precision = 'milliseconds') {
+function toEpochTimestamp(date, precision = 'milliseconds') {
     const dateObj = normalizeDate(date);
     if (!dateObj) {
         throw new Error('Invalid date provided for epoch conversion');
@@ -139,7 +158,7 @@ export function toEpochTimestamp(date, precision = 'milliseconds') {
 /**
  * Create date from epoch timestamp with specified precision
  */
-export function fromEpochTimestamp(timestamp, precision = 'milliseconds') {
+function fromEpochTimestamp(timestamp, precision = 'milliseconds') {
     let ms;
     switch (precision) {
         case 'seconds':
@@ -158,7 +177,7 @@ export function fromEpochTimestamp(timestamp, precision = 'milliseconds') {
 /**
  * Create epoch timestamp with metadata
  */
-export function createEpochTimestamp(date, precision = 'milliseconds', timezone) {
+function createEpochTimestamp(date, precision = 'milliseconds', timezone) {
     return {
         timestamp: toEpochTimestamp(date, precision),
         precision,
@@ -168,7 +187,7 @@ export function createEpochTimestamp(date, precision = 'milliseconds', timezone)
 /**
  * Convert date to safe object representation
  */
-export function toDateObject(date, includeTimezone = false) {
+function toDateObject(date, includeTimezone = false) {
     const dateObj = normalizeDate(date);
     if (!dateObj) {
         throw new Error('Invalid date provided for object conversion');
@@ -195,7 +214,7 @@ export function toDateObject(date, includeTimezone = false) {
 /**
  * Create date from object representation
  */
-export function fromDateObject(dateObj) {
+function fromDateObject(dateObj) {
     // Validate required fields
     if (!dateObj || typeof dateObj !== 'object') {
         throw new Error('Invalid date object provided');
@@ -228,7 +247,7 @@ export function fromDateObject(dateObj) {
 /**
  * Check if a string is a valid ISO date string for serialization
  */
-export function isValidISODateString(dateString) {
+function isValidISODateString(dateString) {
     if (!dateString || typeof dateString !== 'string') {
         return false;
     }
@@ -238,7 +257,7 @@ export function isValidISODateString(dateString) {
 /**
  * Check if a number is a valid epoch timestamp
  */
-export function isValidEpochTimestamp(timestamp, precision = 'milliseconds') {
+function isValidEpochTimestamp(timestamp, precision = 'milliseconds') {
     if (typeof timestamp !== 'number' || isNaN(timestamp)) {
         return false;
     }
@@ -265,14 +284,14 @@ export function isValidEpochTimestamp(timestamp, precision = 'milliseconds') {
 /**
  * Clone a date safely (avoids reference issues)
  */
-export function cloneDate(date) {
+function cloneDate(date) {
     const dateObj = normalizeDate(date);
     return dateObj ? new Date(dateObj.getTime()) : null;
 }
 /**
  * Compare two dates for equality (ignoring milliseconds if specified)
  */
-export function datesEqual(date1, date2, precision = 'milliseconds') {
+function datesEqual(date1, date2, precision = 'milliseconds') {
     const d1 = normalizeDate(date1);
     const d2 = normalizeDate(date2);
     if (!d1 || !d2) {
@@ -295,7 +314,7 @@ export function datesEqual(date1, date2, precision = 'milliseconds') {
 /**
  * Get current timestamp in various formats
  */
-export function now(format = 'date') {
+function now(format = 'date') {
     const current = new Date();
     switch (format) {
         case 'iso':
@@ -312,7 +331,7 @@ export function now(format = 'date') {
 /**
  * Safely handle JSON parsing with date conversion
  */
-export function parseJSONWithDates(jsonString, dateKeys, options) {
+function parseJSONWithDates(jsonString, dateKeys, options) {
     try {
         return JSON.parse(jsonString, createDateReviver(dateKeys, options));
     }
@@ -323,7 +342,7 @@ export function parseJSONWithDates(jsonString, dateKeys, options) {
 /**
  * Safely handle JSON stringification with date conversion
  */
-export function stringifyWithDates(obj, dateKeys, options, space) {
+function stringifyWithDates(obj, dateKeys, options, space) {
     try {
         return JSON.stringify(obj, createDateReplacer(dateKeys, options), space);
     }

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

@@ -1,8 +1,23 @@
+"use strict";
 /**
  * @fileoverview Temporal API compatibility layer
  * Provides Temporal-like objects that work with native Date
  * When Temporal ships natively, these become thin wrappers
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPlainDate = toPlainDate;
+exports.toPlainTime = toPlainTime;
+exports.toPlainDateTime = toPlainDateTime;
+exports.toZonedDateTime = toZonedDateTime;
+exports.toInstant = toInstant;
+exports.createDuration = createDuration;
+exports.parseDuration = parseDuration;
+exports.nowInstant = nowInstant;
+exports.nowPlainDateTime = nowPlainDateTime;
+exports.nowPlainDate = nowPlainDate;
+exports.nowPlainTime = nowPlainTime;
+exports.nowZonedDateTime = nowZonedDateTime;
+exports.fromTemporal = fromTemporal;
 // Helper functions
 function getWeekNumber(date) {
     const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
@@ -552,7 +567,7 @@ class InstantImpl {
         return new Date(this.epochMilliseconds);
     }
 }
-export function toPlainDate(dateOrYear, month, day) {
+function toPlainDate(dateOrYear, month, day) {
     if (dateOrYear instanceof Date) {
         return new PlainDateImpl(dateOrYear.getFullYear(), dateOrYear.getMonth() + 1, dateOrYear.getDate());
     }
@@ -561,7 +576,7 @@ export function toPlainDate(dateOrYear, month, day) {
     }
     return new PlainDateImpl(dateOrYear, month, day);
 }
-export function toPlainTime(dateOrHour, minute, second, millisecond) {
+function toPlainTime(dateOrHour, minute, second, millisecond) {
     if (dateOrHour instanceof Date) {
         return new PlainTimeImpl(dateOrHour.getHours(), dateOrHour.getMinutes(), dateOrHour.getSeconds(), dateOrHour.getMilliseconds());
     }
@@ -570,7 +585,7 @@ export function toPlainTime(dateOrHour, minute, second, millisecond) {
     }
     return new PlainTimeImpl(dateOrHour, minute, second, millisecond);
 }
-export function toPlainDateTime(dateOrYear, month, day, hour, minute, second, millisecond) {
+function toPlainDateTime(dateOrYear, month, day, hour, minute, second, millisecond) {
     if (dateOrYear instanceof Date) {
         return new PlainDateTimeImpl(dateOrYear.getFullYear(), dateOrYear.getMonth() + 1, dateOrYear.getDate(), dateOrYear.getHours(), dateOrYear.getMinutes(), dateOrYear.getSeconds(), dateOrYear.getMilliseconds());
     }
@@ -582,10 +597,10 @@ export function toPlainDateTime(dateOrYear, month, day, hour, minute, second, mi
 /**
  * Create a ZonedDateTime from a Date object and timezone
  */
-export function toZonedDateTime(date, timeZone) {
+function toZonedDateTime(date, timeZone) {
     return new ZonedDateTimeImpl(date.getTime(), timeZone);
 }
-export function toInstant(dateOrEpoch) {
+function toInstant(dateOrEpoch) {
     if (dateOrEpoch instanceof Date) {
         return new InstantImpl(dateOrEpoch.getTime());
     }
@@ -597,13 +612,13 @@ export function toInstant(dateOrEpoch) {
 /**
  * Create a Duration from components
  */
-export function createDuration(fields = {}) {
+function createDuration(fields = {}) {
     return new DurationImpl(fields);
 }
 /**
  * Parse an ISO 8601 duration string
  */
-export function parseDuration(str) {
+function parseDuration(str) {
     const match = str.match(/^(-)?P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/);
     if (!match)
         throw new Error(`Invalid duration: ${str}`);
@@ -625,36 +640,36 @@ export function parseDuration(str) {
 /**
  * Get current instant
  */
-export function nowInstant() {
+function nowInstant() {
     return new InstantImpl(Date.now());
 }
 /**
  * Get current PlainDateTime in local timezone
  */
-export function nowPlainDateTime() {
+function nowPlainDateTime() {
     return toPlainDateTime(new Date());
 }
 /**
  * Get current PlainDate in local timezone
  */
-export function nowPlainDate() {
+function nowPlainDate() {
     return toPlainDate(new Date());
 }
 /**
  * Get current PlainTime in local timezone
  */
-export function nowPlainTime() {
+function nowPlainTime() {
     return toPlainTime(new Date());
 }
 /**
  * Get current ZonedDateTime in specified timezone
  */
-export function nowZonedDateTime(timeZone) {
+function nowZonedDateTime(timeZone) {
     return toZonedDateTime(new Date(), timeZone);
 }
 /**
  * Convert Temporal-like object back to Date
  */
-export function fromTemporal(temporal) {
+function fromTemporal(temporal) {
     return temporal.toDate();
 }