ts-time-utils 0.0.1

package/dist/interval.js

@@ -0,0 +1,86 @@
+/**
+ * Interval utilities: operations on time intervals [start, end)
+ */
+/** Create an interval ensuring start <= end */
+export function createInterval(start, end) {
+    const s = new Date(start);
+    const e = new Date(end);
+    if (isNaN(s.getTime()) || isNaN(e.getTime()) || s > e)
+        return null;
+    return { start: s, end: e };
+}
+/** Validate an object is a proper interval */
+export function isValidInterval(i) {
+    return !!i && i.start instanceof Date && i.end instanceof Date && !isNaN(i.start) && !isNaN(i.end) && i.start <= i.end;
+}
+/** Duration of interval in ms */
+export function intervalDuration(i) {
+    return i.end.getTime() - i.start.getTime();
+}
+/** Whether interval contains date (inclusive start, exclusive end) */
+export function intervalContains(i, date) {
+    const d = date instanceof Date ? date : new Date(date);
+    return d >= i.start && d < i.end;
+}
+/** Whether two intervals overlap */
+export function intervalsOverlap(a, b) {
+    return a.start < b.end && b.start < a.end;
+}
+/** Intersection of two intervals, or null */
+export function intervalIntersection(a, b) {
+    const start = a.start > b.start ? a.start : b.start;
+    const end = a.end < b.end ? a.end : b.end;
+    return start < end ? { start, end } : null;
+}
+/** Merge overlapping or touching intervals into a minimal set */
+export function mergeIntervals(intervals) {
+    if (intervals.length === 0)
+        return [];
+    const sorted = [...intervals].sort((a, b) => a.start.getTime() - b.start.getTime());
+    const result = [];
+    let current = { ...sorted[0] };
+    for (let i = 1; i < sorted.length; i++) {
+        const next = sorted[i];
+        if (next.start <= current.end) { // overlap or touching
+            if (next.end > current.end)
+                current.end = next.end;
+        }
+        else {
+            result.push(current);
+            current = { ...next };
+        }
+    }
+    result.push(current);
+    return result;
+}
+/** Subtract interval b from a (can split into 0,1,2 intervals) */
+export function subtractInterval(a, b) {
+    if (!intervalsOverlap(a, b))
+        return [a];
+    const parts = [];
+    if (b.start > a.start)
+        parts.push({ start: a.start, end: b.start });
+    if (b.end < a.end)
+        parts.push({ start: b.end, end: a.end });
+    return parts;
+}
+/** Split an interval into day-boundary intervals (UTC based) */
+export function splitIntervalByDay(i) {
+    const res = [];
+    let cursor = new Date(i.start);
+    while (cursor < i.end) {
+        const dayEnd = new Date(Date.UTC(cursor.getUTCFullYear(), cursor.getUTCMonth(), cursor.getUTCDate() + 1));
+        const end = dayEnd < i.end ? dayEnd : i.end;
+        res.push({ start: new Date(cursor), end: new Date(end) });
+        cursor = end;
+    }
+    return res;
+}
+/** Total covered duration of possibly overlapping intervals */
+export function totalIntervalCoverage(intervals) {
+    return mergeIntervals(intervals).reduce((sum, i) => sum + intervalDuration(i), 0);
+}
+/** Normalize array: filter invalid and merge */
+export function normalizeIntervals(intervals) {
+    return mergeIntervals(intervals.filter(isValidInterval));
+}

package/dist/parse.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Advanced date parsing utilities
+ */
+/**
+ * Parse various date formats intelligently
+ * @param input - date string, number, or Date object
+ */
+export declare function parseDate(input: string | number | Date): Date | null;
+/**
+ * Parse relative date strings like "tomorrow", "next monday", "2 weeks ago"
+ * @param input - relative date string
+ */
+export declare function parseRelativeDate(input: string): Date | null;
+/**
+ * Parse "time ago" strings like "5 minutes ago", "2 hours ago"
+ * @param input - time ago string
+ */
+export declare function parseTimeAgo(input: string): Date | null;
+/**
+ * Parse custom date format
+ * @param dateString - date string to parse
+ * @param format - format pattern (e.g., "YYYY-MM-DD", "DD/MM/YYYY")
+ */
+export declare function parseCustomFormat(dateString: string, format: string): Date | null;
+/**
+ * Try parsing with multiple formats
+ * @param dateString - date string to parse
+ * @param formats - array of format patterns to try
+ */
+export declare function parseManyFormats(dateString: string, formats: string[]): Date | null;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAuDpE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CA6C5D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAiBvD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAmDjF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,IAAI,CAMnF"}

package/dist/parse.js

@@ -0,0 +1,217 @@
+/**
+ * Advanced date parsing utilities
+ */
+/**
+ * Parse various date formats intelligently
+ * @param input - date string, number, or Date object
+ */
+export function parseDate(input) {
+    if (input instanceof Date) {
+        return isNaN(input.getTime()) ? null : input;
+    }
+    if (typeof input === 'number') {
+        const date = new Date(input);
+        return isNaN(date.getTime()) ? null : date;
+    }
+    if (typeof input !== 'string') {
+        return null;
+    }
+    // Try native Date parsing first, but validate the result
+    const nativeDate = new Date(input);
+    if (!isNaN(nativeDate.getTime())) {
+        // Additional validation for edge cases like "2025-02-30"
+        if (input.includes('-') && input.match(/^\d{4}-\d{2}-\d{2}/)) {
+            const [year, month, day] = input.split('-').map(Number);
+            const testDate = new Date(year, month - 1, day);
+            if (testDate.getFullYear() !== year || testDate.getMonth() !== month - 1 || testDate.getDate() !== day) {
+                return null;
+            }
+        }
+        return nativeDate;
+    }
+    // Try common patterns
+    const patterns = [
+        /^(\d{4})-(\d{2})-(\d{2})$/, // YYYY-MM-DD
+        /^(\d{2})\/(\d{2})\/(\d{4})$/, // MM/DD/YYYY
+        /^(\d{2})-(\d{2})-(\d{4})$/, // MM-DD-YYYY
+        /^(\d{4})(\d{2})(\d{2})$/, // YYYYMMDD
+    ];
+    for (const pattern of patterns) {
+        const match = input.match(pattern);
+        if (match) {
+            const [, first, second, third] = match;
+            // Try different interpretations based on pattern
+            if (pattern.source.includes('(\\d{4})')) {
+                // Year first format
+                const date = new Date(parseInt(first), parseInt(second) - 1, parseInt(third));
+                if (!isNaN(date.getTime()))
+                    return date;
+            }
+            else {
+                // Month/day first format (assuming US format)
+                const date = new Date(parseInt(third), parseInt(first) - 1, parseInt(second));
+                if (!isNaN(date.getTime()))
+                    return date;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Parse relative date strings like "tomorrow", "next monday", "2 weeks ago"
+ * @param input - relative date string
+ */
+export function parseRelativeDate(input) {
+    const now = new Date();
+    const lowercaseInput = input.toLowerCase().trim();
+    // Handle simple cases
+    switch (lowercaseInput) {
+        case 'now':
+        case 'today':
+            return new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        case 'yesterday':
+            return new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1);
+        case 'tomorrow':
+            return new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+    }
+    // Handle "X time ago" or "in X time"
+    const agoMatch = lowercaseInput.match(/^(\d+)\s+(second|minute|hour|day|week|month|year)s?\s+ago$/);
+    if (agoMatch) {
+        const [, amount, unit] = agoMatch;
+        return subtractTimeUnits(now, parseInt(amount), unit);
+    }
+    const inMatch = lowercaseInput.match(/^in\s+(\d+)\s+(second|minute|hour|day|week|month|year)s?$/);
+    if (inMatch) {
+        const [, amount, unit] = inMatch;
+        return addTimeUnits(now, parseInt(amount), unit);
+    }
+    // Handle "next/last weekday"
+    const weekdays = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+    const nextWeekdayMatch = lowercaseInput.match(/^next\s+(sunday|monday|tuesday|wednesday|thursday|friday|saturday)$/);
+    if (nextWeekdayMatch) {
+        const targetDay = weekdays.indexOf(nextWeekdayMatch[1]);
+        const daysUntilTarget = (targetDay - now.getDay() + 7) % 7 || 7;
+        return new Date(now.getFullYear(), now.getMonth(), now.getDate() + daysUntilTarget);
+    }
+    const lastWeekdayMatch = lowercaseInput.match(/^last\s+(sunday|monday|tuesday|wednesday|thursday|friday|saturday)$/);
+    if (lastWeekdayMatch) {
+        const targetDay = weekdays.indexOf(lastWeekdayMatch[1]);
+        const daysSinceTarget = (now.getDay() - targetDay + 7) % 7 || 7;
+        return new Date(now.getFullYear(), now.getMonth(), now.getDate() - daysSinceTarget);
+    }
+    return null;
+}
+/**
+ * Parse "time ago" strings like "5 minutes ago", "2 hours ago"
+ * @param input - time ago string
+ */
+export function parseTimeAgo(input) {
+    const now = new Date();
+    const lowercaseInput = input.toLowerCase().trim();
+    // Handle simple cases
+    if (lowercaseInput === 'just now' || lowercaseInput === 'now') {
+        return now;
+    }
+    // Handle "X time ago"
+    const match = lowercaseInput.match(/^(\d+)\s+(second|minute|hour|day|week|month|year)s?\s+ago$/);
+    if (match) {
+        const [, amount, unit] = match;
+        return subtractTimeUnits(now, parseInt(amount), unit);
+    }
+    return null;
+}
+/**
+ * Parse custom date format
+ * @param dateString - date string to parse
+ * @param format - format pattern (e.g., "YYYY-MM-DD", "DD/MM/YYYY")
+ */
+export function parseCustomFormat(dateString, format) {
+    // Simple implementation for common patterns
+    const formatMap = {
+        'YYYY-MM-DD': /^(\d{4})-(\d{2})-(\d{2})$/,
+        'DD/MM/YYYY': /^(\d{2})\/(\d{2})\/(\d{4})$/,
+        'MM/DD/YYYY': /^(\d{2})\/(\d{2})\/(\d{4})$/,
+        'DD-MM-YYYY': /^(\d{2})-(\d{2})-(\d{4})$/,
+        'MM-DD-YYYY': /^(\d{2})-(\d{2})-(\d{4})$/,
+    };
+    const regex = formatMap[format];
+    if (!regex)
+        return null;
+    const match = dateString.match(regex);
+    if (!match)
+        return null;
+    const [, first, second, third] = match;
+    let year, month, day;
+    switch (format) {
+        case 'YYYY-MM-DD':
+            year = parseInt(first);
+            month = parseInt(second) - 1;
+            day = parseInt(third);
+            break;
+        case 'DD/MM/YYYY':
+        case 'DD-MM-YYYY':
+            day = parseInt(first);
+            month = parseInt(second) - 1;
+            year = parseInt(third);
+            break;
+        case 'MM/DD/YYYY':
+        case 'MM-DD-YYYY':
+            month = parseInt(first) - 1;
+            day = parseInt(second);
+            year = parseInt(third);
+            break;
+        default:
+            return null;
+    }
+    const date = new Date(year, month, day);
+    // Validate that the date components match what was parsed
+    // This catches cases like February 30th which JS converts to March 2nd
+    if (date.getFullYear() !== year || date.getMonth() !== month || date.getDate() !== day) {
+        return null;
+    }
+    return isNaN(date.getTime()) ? null : date;
+}
+/**
+ * Try parsing with multiple formats
+ * @param dateString - date string to parse
+ * @param formats - array of format patterns to try
+ */
+export function parseManyFormats(dateString, formats) {
+    for (const format of formats) {
+        const result = parseCustomFormat(dateString, format);
+        if (result)
+            return result;
+    }
+    return null;
+}
+// Helper functions
+function addTimeUnits(date, amount, unit) {
+    const result = new Date(date);
+    switch (unit) {
+        case 'second':
+            result.setSeconds(result.getSeconds() + amount);
+            break;
+        case 'minute':
+            result.setMinutes(result.getMinutes() + amount);
+            break;
+        case 'hour':
+            result.setHours(result.getHours() + amount);
+            break;
+        case 'day':
+            result.setDate(result.getDate() + amount);
+            break;
+        case 'week':
+            result.setDate(result.getDate() + (amount * 7));
+            break;
+        case 'month':
+            result.setMonth(result.getMonth() + amount);
+            break;
+        case 'year':
+            result.setFullYear(result.getFullYear() + amount);
+            break;
+    }
+    return result;
+}
+function subtractTimeUnits(date, amount, unit) {
+    return addTimeUnits(date, -amount, unit);
+}

package/dist/performance.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Async time utilities for delays, timeouts, and performance
+ */
+/**
+ * Sleep for a specified number of milliseconds
+ * @param ms - milliseconds to sleep
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Add a timeout to any promise
+ * @param promise - promise to add timeout to
+ * @param ms - timeout in milliseconds
+ * @param timeoutMessage - optional timeout error message
+ */
+export declare function timeout<T>(promise: Promise<T>, ms: number, timeoutMessage?: string): Promise<T>;
+/**
+ * Debounce function - delays execution until after delay has passed since last call
+ * @param fn - function to debounce
+ * @param delay - delay in milliseconds
+ */
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * Throttle function - limits execution to once per delay period
+ * @param fn - function to throttle
+ * @param delay - delay in milliseconds
+ */
+export declare function throttle<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * Retry a promise-returning function with exponential backoff
+ * @param fn - function that returns a promise
+ * @param maxAttempts - maximum number of attempts
+ * @param baseDelay - base delay in milliseconds
+ * @param maxDelay - maximum delay in milliseconds
+ */
+export declare function retry<T>(fn: () => Promise<T>, maxAttempts?: number, baseDelay?: number, maxDelay?: number): Promise<T>;
+/**
+ * Stopwatch for measuring elapsed time
+ */
+export declare class Stopwatch {
+    private startTime;
+    private endTime;
+    private pausedTime;
+    private pauseStart;
+    /**
+     * Start the stopwatch
+     */
+    start(): void;
+    /**
+     * Stop the stopwatch
+     */
+    stop(): number;
+    /**
+     * Pause the stopwatch
+     */
+    pause(): void;
+    /**
+     * Resume the stopwatch
+     */
+    resume(): void;
+    /**
+     * Reset the stopwatch
+     */
+    reset(): void;
+    /**
+     * Get elapsed time without stopping
+     */
+    getElapsed(): number;
+    /**
+     * Check if stopwatch is running
+     */
+    isRunning(): boolean;
+    /**
+     * Check if stopwatch is paused
+     */
+    isPaused(): boolean;
+}
+/**
+ * Create a new stopwatch instance
+ */
+export declare function createStopwatch(): Stopwatch;
+/**
+ * Measure execution time of a synchronous function
+ * @param fn - function to measure
+ * @returns tuple of [result, elapsed time in ms]
+ */
+export declare function measureTime<T>(fn: () => T): [T, number];
+/**
+ * Measure execution time of an asynchronous function
+ * @param fn - async function to measure
+ * @returns promise that resolves to tuple of [result, elapsed time in ms]
+ */
+export declare function measureAsync<T>(fn: () => Promise<T>): Promise<[T, number]>;
+/**
+ * Benchmark result interface
+ */
+export interface BenchmarkResult {
+    totalTime: number;
+    averageTime: number;
+    minTime: number;
+    maxTime: number;
+    iterations: number;
+    opsPerSecond: number;
+}
+/**
+ * Benchmark a function by running it multiple times
+ * @param fn - function to benchmark
+ * @param iterations - number of iterations to run
+ */
+export declare function benchmark(fn: () => void, iterations?: number): BenchmarkResult;
+//# sourceMappingURL=performance.d.ts.map

package/dist/performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.d.ts","sourceRoot":"","sources":["../src/performance.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,MAAM,EACV,cAAc,SAAwB,GACrC,OAAO,CAAC,CAAC,CAAC,CAOZ;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,EAAE,EAAE,CAAC,EACL,KAAK,EAAE,MAAM,GACZ,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAOlC;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,EAAE,EAAE,CAAC,EACL,KAAK,EAAE,MAAM,GACZ,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,IAAI,CAUlC;AAED;;;;;;GAMG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,WAAW,GAAE,MAAU,EACvB,SAAS,GAAE,MAAa,EACxB,QAAQ,GAAE,MAAc,GACvB,OAAO,CAAC,CAAC,CAAC,CAwBZ;AAED;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,UAAU,CAAuB;IAEzC;;OAEG;IACH,KAAK,IAAI,IAAI;IAUb;;OAEG;IACH,IAAI,IAAI,MAAM;IAed;;OAEG;IACH,KAAK,IAAI,IAAI;IAUb;;OAEG;IACH,MAAM,IAAI,IAAI;IAQd;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb;;OAEG;IACH,UAAU,IAAI,MAAM;IAepB;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,QAAQ,IAAI,OAAO;CAGpB;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,SAAS,CAE3C;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAKvD;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAKhF;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,UAAU,GAAE,MAAa,GAAG,eAAe,CAsBpF"}

package/dist/performance.js

@@ -0,0 +1,222 @@
+/**
+ * Async time utilities for delays, timeouts, and performance
+ */
+/**
+ * Sleep for a specified number of milliseconds
+ * @param ms - milliseconds to sleep
+ */
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Add a timeout to any promise
+ * @param promise - promise to add timeout to
+ * @param ms - timeout in milliseconds
+ * @param timeoutMessage - optional timeout error message
+ */
+export function timeout(promise, ms, timeoutMessage = 'Operation timed out') {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(timeoutMessage)), ms))
+    ]);
+}
+/**
+ * Debounce function - delays execution until after delay has passed since last call
+ * @param fn - function to debounce
+ * @param delay - delay in milliseconds
+ */
+export function debounce(fn, delay) {
+    let timeoutId;
+    return (...args) => {
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(() => fn(...args), delay);
+    };
+}
+/**
+ * Throttle function - limits execution to once per delay period
+ * @param fn - function to throttle
+ * @param delay - delay in milliseconds
+ */
+export function throttle(fn, delay) {
+    let lastCall = 0;
+    return (...args) => {
+        const now = Date.now();
+        if (now - lastCall >= delay) {
+            lastCall = now;
+            fn(...args);
+        }
+    };
+}
+/**
+ * Retry a promise-returning function with exponential backoff
+ * @param fn - function that returns a promise
+ * @param maxAttempts - maximum number of attempts
+ * @param baseDelay - base delay in milliseconds
+ * @param maxDelay - maximum delay in milliseconds
+ */
+export async function retry(fn, maxAttempts = 3, baseDelay = 1000, maxDelay = 10000) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === maxAttempts) {
+                throw lastError;
+            }
+            // Exponential backoff with jitter
+            const delay = Math.min(baseDelay * Math.pow(2, attempt - 1) + Math.random() * 1000, maxDelay);
+            await sleep(delay);
+        }
+    }
+    throw lastError;
+}
+/**
+ * Stopwatch for measuring elapsed time
+ */
+export class Stopwatch {
+    constructor() {
+        this.startTime = null;
+        this.endTime = null;
+        this.pausedTime = 0;
+        this.pauseStart = null;
+    }
+    /**
+     * Start the stopwatch
+     */
+    start() {
+        if (this.startTime !== null) {
+            throw new Error('Stopwatch is already running');
+        }
+        this.startTime = performance.now();
+        this.endTime = null;
+        this.pausedTime = 0;
+        this.pauseStart = null;
+    }
+    /**
+     * Stop the stopwatch
+     */
+    stop() {
+        if (this.startTime === null) {
+            throw new Error('Stopwatch is not running');
+        }
+        if (this.pauseStart !== null) {
+            this.pausedTime += performance.now() - this.pauseStart;
+            this.pauseStart = null;
+        }
+        this.endTime = performance.now();
+        const elapsed = this.endTime - this.startTime - this.pausedTime;
+        return elapsed;
+    }
+    /**
+     * Pause the stopwatch
+     */
+    pause() {
+        if (this.startTime === null) {
+            throw new Error('Stopwatch is not running');
+        }
+        if (this.pauseStart !== null) {
+            throw new Error('Stopwatch is already paused');
+        }
+        this.pauseStart = performance.now();
+    }
+    /**
+     * Resume the stopwatch
+     */
+    resume() {
+        if (this.pauseStart === null) {
+            throw new Error('Stopwatch is not paused');
+        }
+        this.pausedTime += performance.now() - this.pauseStart;
+        this.pauseStart = null;
+    }
+    /**
+     * Reset the stopwatch
+     */
+    reset() {
+        this.startTime = null;
+        this.endTime = null;
+        this.pausedTime = 0;
+        this.pauseStart = null;
+    }
+    /**
+     * Get elapsed time without stopping
+     */
+    getElapsed() {
+        if (this.startTime === null) {
+            return 0;
+        }
+        const now = performance.now();
+        let pausedTime = this.pausedTime;
+        if (this.pauseStart !== null) {
+            pausedTime += now - this.pauseStart;
+        }
+        return now - this.startTime - pausedTime;
+    }
+    /**
+     * Check if stopwatch is running
+     */
+    isRunning() {
+        return this.startTime !== null && this.endTime === null && this.pauseStart === null;
+    }
+    /**
+     * Check if stopwatch is paused
+     */
+    isPaused() {
+        return this.pauseStart !== null;
+    }
+}
+/**
+ * Create a new stopwatch instance
+ */
+export function createStopwatch() {
+    return new Stopwatch();
+}
+/**
+ * Measure execution time of a synchronous function
+ * @param fn - function to measure
+ * @returns tuple of [result, elapsed time in ms]
+ */
+export function measureTime(fn) {
+    const start = performance.now();
+    const result = fn();
+    const elapsed = performance.now() - start;
+    return [result, elapsed];
+}
+/**
+ * Measure execution time of an asynchronous function
+ * @param fn - async function to measure
+ * @returns promise that resolves to tuple of [result, elapsed time in ms]
+ */
+export async function measureAsync(fn) {
+    const start = performance.now();
+    const result = await fn();
+    const elapsed = performance.now() - start;
+    return [result, elapsed];
+}
+/**
+ * Benchmark a function by running it multiple times
+ * @param fn - function to benchmark
+ * @param iterations - number of iterations to run
+ */
+export function benchmark(fn, iterations = 1000) {
+    const times = [];
+    for (let i = 0; i < iterations; i++) {
+        const [, elapsed] = measureTime(fn);
+        times.push(elapsed);
+    }
+    const totalTime = times.reduce((sum, time) => sum + time, 0);
+    const averageTime = totalTime / iterations;
+    const minTime = Math.min(...times);
+    const maxTime = Math.max(...times);
+    const opsPerSecond = 1000 / averageTime;
+    return {
+        totalTime,
+        averageTime,
+        minTime,
+        maxTime,
+        iterations,
+        opsPerSecond
+    };
+}