ts-time-utils 4.0.1 → 4.4.0

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Plugin system for extending ChainedDate with custom methods
  *
@@ -19,38 +20,26 @@
  * chain(new Date()).nextMonday().format('YYYY-MM-DD');
  * ```
  */
-// Import ChainedDate class directly - safe because chain.js doesn't import plugins.js
-// We need the actual class (not just the type) to modify its prototype
-let ChainedDateConstructor = null;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extend = extend;
+exports.uninstall = uninstall;
+exports.getRegisteredPlugins = getRegisteredPlugins;
+exports.getPluginMethods = getPluginMethods;
+exports.isPluginRegistered = isPluginRegistered;
+const chain_js_1 = require("./chain.cjs");
 /**
- * Get ChainedDate class lazily to ensure it's fully initialized
+ * Get ChainedDate class for prototype mutation.
+ * Importing `plugins` now brings in `chain` directly, so the class is available
+ * without a hidden global handshake.
  */
 function getChainedDate() {
-    if (!ChainedDateConstructor) {
-        // Use dynamic import that works in both CJS and ESM
-        try {
-            // Try ESM import path first
-            ChainedDateConstructor = globalThis.__chainedDateClass;
-            if (!ChainedDateConstructor) {
-                // Fallback: The class will be set by chain.js when it loads
-                throw new Error('ChainedDate not yet loaded. Import chain.js before using plugins.');
-            }
-        }
-        catch (e) {
-            throw new Error('ChainedDate class not available. Ensure chain.js is imported before registering plugins.');
-        }
+    if (!chain_js_1.ChainedDate) {
+        throw new Error('ChainedDate export is not available yet. Import chain.js before registering plugins.');
     }
-    return ChainedDateConstructor;
-}
-/**
- * Initialize the plugin system with ChainedDate class
- * This is called automatically when chain.js is imported
- * @internal
- */
-export function __initPluginSystem(ChainedDateClass) {
-    ChainedDateConstructor = ChainedDateClass;
+    return chain_js_1.ChainedDate;
 }
 const registry = {};
+const methodStates = {};
 /**
  * Extend ChainedDate with custom methods
  *
@@ -76,27 +65,27 @@ const registry = {};
  * chain(new Date()).addBusinessDays(5);
  * ```
  */
-export function extend(pluginName, methods) {
+function extend(pluginName, methods) {
     if (registry[pluginName]) {
         throw new Error(`Plugin "${pluginName}" is already registered. Use a different name or uninstall first.`);
     }
-    // Get ChainedDate class and save original methods before overwriting
     const ChainedDateClass = getChainedDate();
-    const originalMethods = new Map();
     Object.entries(methods).forEach(([methodName, fn]) => {
-        // Save original method if it exists
+        const current = ChainedDateClass.prototype[methodName];
+        if (!methodStates[methodName]) {
+            methodStates[methodName] = {
+                original: typeof current === 'function' ? current : undefined,
+                owners: []
+            };
+        }
         if (methodName in ChainedDateClass.prototype) {
-            const original = ChainedDateClass.prototype[methodName];
-            if (typeof original === 'function') {
-                originalMethods.set(methodName, original);
-            }
             console.warn(`Method "${methodName}" already exists on ChainedDate and will be overwritten`);
         }
+        methodStates[methodName].owners.push(pluginName);
         // Add the plugin method
         ChainedDateClass.prototype[methodName] = fn;
     });
-    // Register the plugin with its original methods
-    registry[pluginName] = { plugin: methods, originalMethods };
+    registry[pluginName] = { plugin: methods };
 }
 /**
  * Remove a plugin and its methods from ChainedDate
@@ -108,25 +97,37 @@ export function extend(pluginName, methods) {
  * uninstall('businessDays');
  * ```
  */
-export function uninstall(pluginName) {
+function uninstall(pluginName) {
     const entry = registry[pluginName];
     if (!entry) {
         throw new Error(`Plugin "${pluginName}" is not registered`);
     }
-    // Get ChainedDate class and restore/remove methods
     const ChainedDateClass = getChainedDate();
     Object.keys(entry.plugin).forEach((methodName) => {
-        // If there was an original method, restore it
-        const original = entry.originalMethods.get(methodName);
-        if (original) {
-            ChainedDateClass.prototype[methodName] = original;
+        const state = methodStates[methodName];
+        if (!state) {
+            delete ChainedDateClass.prototype[methodName];
+            return;
+        }
+        state.owners = state.owners.filter((owner) => owner !== pluginName);
+        const nextOwner = state.owners[state.owners.length - 1];
+        if (nextOwner) {
+            const nextPlugin = registry[nextOwner];
+            if (nextPlugin && methodName in nextPlugin.plugin) {
+                ChainedDateClass.prototype[methodName] = nextPlugin.plugin[methodName];
+                return;
+            }
+            delete ChainedDateClass.prototype[methodName];
+            return;
+        }
+        if (state.original) {
+            ChainedDateClass.prototype[methodName] = state.original;
         }
         else {
-            // Otherwise, delete the method entirely
             delete ChainedDateClass.prototype[methodName];
         }
+        delete methodStates[methodName];
     });
-    // Remove from registry
     delete registry[pluginName];
 }
 /**
@@ -139,7 +140,7 @@ export function uninstall(pluginName) {
  * getRegisteredPlugins(); // ['businessDays', 'myPlugin']
  * ```
  */
-export function getRegisteredPlugins() {
+function getRegisteredPlugins() {
     return Object.keys(registry);
 }
 /**
@@ -153,7 +154,7 @@ export function getRegisteredPlugins() {
  * getPluginMethods('businessDays'); // ['addBusinessDays', 'subtractBusinessDays']
  * ```
  */
-export function getPluginMethods(pluginName) {
+function getPluginMethods(pluginName) {
     const entry = registry[pluginName];
     return entry ? Object.keys(entry.plugin) : [];
 }
@@ -168,6 +169,6 @@ export function getPluginMethods(pluginName) {
  * isPluginRegistered('businessDays'); // true
  * ```
  */
-export function isPluginRegistered(pluginName) {
+function isPluginRegistered(pluginName) {
     return pluginName in registry;
 }

package/dist/plugins.d.ts

@@ -19,12 +19,6 @@
  * chain(new Date()).nextMonday().format('YYYY-MM-DD');
  * ```
  */
-/**
- * Initialize the plugin system with ChainedDate class
- * This is called automatically when chain.js is imported
- * @internal
- */
-export declare function __initPluginSystem(ChainedDateClass: any): void;
 /**
  * Plugin function type - methods receive ChainedDate instance as `this`
  */

package/dist/plugins.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA0BH;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,gBAAgB,EAAE,GAAG,QAEvD;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,CAAC;CACtC;AAcD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAwBhE;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAqBlD;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAG7D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,iBAAiB;CAAG"}
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAgBH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,CAAC;CACtC;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAwBhE;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAqClD;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAG7D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,iBAAiB;CAAG"}

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),