@himanshu-sorathiya/datetime 1.0.1

package/README.md

@@ -0,0 +1,270 @@
+# Date & Time Utilities
+
+A strictly client-side, fully type-safe, zero-dependency toolkit for parsing, querying, manipulating, and formatting dates in TypeScript. Every function is a pure, immutable transformation — no wrapper classes, no prototype patching, no hidden global state.
+
+## Motivation (Why this module?)
+
+Native `Date` math is a minefield: months are 0-based, mutation happens in place, arithmetic silently overflows across month boundaries, and adding raw milliseconds breaks the moment a DST transition is crossed. Giant wrapper libraries like Moment.js solve some of this, but drag in mutable object instances, a heavyweight locale bundle, and an API surface that actively encourages chained mutation bugs.
+
+This module takes a different approach — a flat set of small, composable functions built on four non-negotiable pillars:
+
+- **Strict immutability.** Every public function funnels its input through a single `toDate()` gateway. If the input is already a `Date`, it is cloned via `new Date(input.getTime())` before anything touches it. No function in this engine can ever mutate the caller's original reference — which means you can chain ten operations on the same variable without ever worrying about spooky-action-at-a-distance bugs.
+- **DST-safe calendar math.** Calendar-level operations (`addDays`, `addWeeks`, `startOfWeek`, etc.) use `setDate()` / `setMonth()` / `setFullYear()` rather than raw millisecond arithmetic. This forces the runtime to preserve local wall-clock time across Daylight Saving Time boundaries, instead of silently shifting `14:00` to `15:00` when a day is added.
+- **Human-readable, 1-based months.** `getMonth()`, `setMonth()`, and `createDate()` all use `1 = January … 12 = December`, eliminating the classic native-`Date` off-by-one bug at the source.
+- **End-of-month & leap-year clamping.** Adding a month to January 31st gives you February 28th — not an accidental rollover into March. Adding a year to February 29th gives you February 28th of the following year. The engine clamps instead of overflowing.
+- **Zero-dependency localization.** All textual formatting (month names, weekday names, AM/PM, relative time, pluralization) is delegated entirely to the native `Intl` API. There are no hardcoded translation dictionaries to download, version, or fall out of date.
+
+## Import Syntax
+
+```tsx
+// Preferred
+import { toDate, addDays, format, isPast } from "@himanshu-sorathiya/react-kit/datetime";
+// Or
+import { toDate, addDays, format, isPast } from "@himanshu-sorathiya/react-kit";
+```
+
+## Basic Usage
+
+```ts
+import { toDate, addDays, format } from "@himanshu-sorathiya/react-kit/datetime";
+
+const input = toDate("2026-07-16"); // parsed once, safely
+const dueDate = addDays(input, 14); // 14 days later, DST-safe
+
+console.log(format(dueDate, "MMMM dd, yyyy"));
+// → "July 30, 2026"
+```
+
+## API Reference
+
+### Core & Getters
+
+The immutability gateway and primitive getters. Every other function in the library is built on top of these.
+
+| Function | Returns | Notes |
+| --- | --- | --- |
+| `toDate(input)` | `Date` | Clones if already a `Date`; parses if `string` / `number`. The immutability gateway used internally by every other function. |
+| `isDate(value)` | `boolean` | Type guard — `value instanceof Date`. |
+| `isValid(date)` | `boolean` | `isDate(date) && !isNaN(date.getTime())`. |
+| `createDate(year, month, day?)` | `Date` | **1-based month.** Overflow-clamped: `createDate(2026, 2, 31)` → Feb 28, not a rollover into March. `day` defaults to `1`. |
+| `getYear(date)` | `number` | |
+| `getMonth(date)` | `number` | **1-based** (1–12), unlike native `getMonth()`. |
+| `getDate(date)` | `number` | Day of month (1–31). |
+| `getHours(date)` | `number` | Local time (0–23). |
+| `getMinutes(date)` | `number` | 0–59. |
+| `getSeconds(date)` | `number` | 0–59. |
+| `getMilliseconds(date)` | `number` | 0–999. |
+| `getTimestamp(date)` | `number` | Epoch milliseconds — prefer this over repeated `isBefore()` calls in hot loops. |
+| `getDayOfWeek(date)` | `number` | 0 = Sunday … 6 = Saturday (local time). |
+| `getDaysInMonth(date)` | `number` | Leap-year aware. |
+| `getQuarter(date)` | `number` | 1–4. |
+| `getDayOfYear(date)` | `number` | 1–366, DST-safe (computed from start-of-day timestamps). |
+
+### Queries (Predicates)
+
+Pure boolean functions. No date values are ever returned here — only `true` or `false`, and **invalid inputs always resolve to `false`**, never `NaN` or a thrown error.
+
+| Function | Notes |
+| --- | --- |
+| `isSameDay(a, b)` | Ignores time component. |
+| `isSameMonth(a, b)` | Checks year too — October 2025 ≠ October 2026. |
+| `isSameYear(a, b)` | |
+| `isSameQuarter(a, b)` | Checks year too. |
+| `isSameWeek(a, b, weekStartsOn?)` | Defaults to Sunday start (`0`); pass `1` for Monday / ISO. |
+| `isSameHour(a, b)` | Checks full date + hour. |
+| `isSameMinute(a, b)` | Checks full date + hour + minute. |
+| `isSameSecond(a, b)` | Checks full date + H:M:S. |
+| `isSameTime(a, b)` | Checks H:M:S only — ignores the calendar date entirely. |
+| `isBefore(date, compareDate)` | Strict millisecond comparison. |
+| `isAfter(date, compareDate)` | Strict millisecond comparison. |
+| `isEqual(a, b)` | Fixes native `Date` object-reference inequality by comparing timestamps. |
+| `compareAsc(left, right)` | Array sort comparator: returns `-1`, `0`, or `1`. |
+| `compareDesc(left, right)` | Reverse array sort comparator: returns `1`, `0`, or `-1`. |
+| `isWithinRange(date, start, end)` | Inclusive. **Auto-swaps an inverted `start`/`end`** instead of returning `false`. |
+| `isOverlapping(rangeA, rangeB)` | Strict — exact boundary touches (`rangeA.end === rangeB.start`) return `false`. |
+| `isToday(date)` | Local timezone. |
+| `isYesterday(date)` | Local timezone. |
+| `isTomorrow(date)` | Local timezone. |
+| `isPast(date)` | Strict millisecond comparison against `Date.now()`. |
+| `isFuture(date)` | Strict millisecond comparison against `Date.now()`. |
+| `isThisWeek(date, weekStartsOn?)` | |
+| `isThisMonth(date)` | |
+| `isThisYear(date)` | |
+| `isFirstDayOfMonth(date)` | `getDate() === 1`. |
+| `isLastDayOfMonth(date)` | Detects the month change after advancing one day. |
+| `isWeekend(date)` | Saturday or Sunday, local time. |
+| `isWeekday(date)` | Monday–Friday, local time. |
+| `isAM(date)` | Hour is before noon (0–11). |
+| `isPM(date)` | Hour is noon or later (12–23). |
+| `isLeapYear(yearOrDate)` | Accepts a raw `number` **or** a `Date`. Standard Gregorian rule. |
+| `isInLeapYear(date)` | Convenience wrapper — extracts the year and delegates to `isLeapYear`. |
+
+### Manipulation
+
+Date arithmetic, field setters, period snapping, difference calculations, and range utilities. **Every function returns a new `Date`; originals are never mutated.**
+
+**Add / Sub**
+
+| Function | Notes |
+| --- | --- |
+| `addMilliseconds` / `subMilliseconds` | Raw millisecond math (safe — no calendar quirks at this granularity). |
+| `addSeconds` / `subSeconds` | Raw millisecond math. |
+| `addMinutes` / `subMinutes` | Raw millisecond math. |
+| `addHours` / `subHours` | Raw millisecond math. |
+| `addDays` / `subDays` | Uses `setDate()` — DST transitions never shift the time-of-day component. |
+| `addWeeks` / `subWeeks` | Delegates to `addDays(date, amount * 7)`. |
+| `addMonths` / `subMonths` | End-of-month clamped: `addMonths(Jan 31, 1)` → Feb 28, not Mar 3. |
+| `addYears` / `subYears` | Leap-year clamped: `addYears(Feb 29 2024, 1)` → Feb 28 2025. |
+
+**Set** (same overflow-clamping guarantees as their `add` counterparts)
+
+| Function | Notes |
+| --- | --- |
+| `setYear(date, year)` | Leap-year clamped, same as `addYears`. |
+| `setMonth(date, month)` | **1-based.** End-of-month clamped, same as `addMonths`. |
+| `setDate(date, day)` | Clamps to `[1, daysInMonth]` — never overflows into the next month. Use `addDays` to intentionally roll over. |
+| `setHours(date, hours)` | Out-of-bounds values follow native rollover behavior. |
+| `setMinutes(date, minutes)` | |
+| `setSeconds(date, seconds)` | |
+| `setMilliseconds(date, ms)` | |
+
+**Start / End of Period**
+
+| Function | Notes |
+| --- | --- |
+| `startOfDay` / `endOfDay` | `00:00:00.000` / `23:59:59.999`. |
+| `startOfHour` / `endOfHour` | |
+| `startOfMinute` / `endOfMinute` | |
+| `startOfWeek(date, weekStartsOn?)` | Defaults to Sunday (`0`). |
+| `endOfWeek(date, weekStartsOn?)` | Defaults to Sunday (`0`). |
+| `startOfMonth` / `endOfMonth` | `endOfMonth` uses the "day 0 of next month" trick — automatically leap-year correct. |
+| `startOfQuarter` / `endOfQuarter` | |
+| `startOfYear` / `endOfYear` | |
+
+**Differences** (signed integer — positive means the left argument is later)
+
+| Function | Notes |
+| --- | --- |
+| `differenceInMilliseconds(left, right)` | Base primitive for all sub-day differences. |
+| `differenceInSeconds` / `differenceInMinutes` / `differenceInHours` | Truncated (`Math.trunc`). |
+| `differenceInDays` | Both inputs snapped to `startOfDay()` first, then `Math.round()` — DST-safe. |
+| `differenceInWeeks` | `Math.trunc(differenceInDays / 7)`. |
+| `differenceInMonths` | Returns only **completed** months (Jan 31 → Feb 1 is `0`, not `1`). |
+| `differenceInYears` | Returns only **completed** years; correctly handles Feb 29 birthdays. |
+| `getOverlappingDaysInInterval(left, right)` | Calculates the number of overlapping 24-hour periods between two `DateInterval`s. |
+
+**Business Days** (weekends excluded — no holiday calendar)
+
+| Function | Notes |
+| --- | --- |
+| `addBusinessDays(date, amount)` | Traverses one day at a time skipping Sat/Sun. Negative amounts traverse backward. |
+| `differenceInBusinessDays(left, right)` | O(n % 7) — counts full weeks as 5 days each, then iterates the remainder. |
+
+**Range & Array**
+
+| Function | Notes |
+| --- | --- |
+| `clampDate(date, min, max)` | Enforces `minDate` / `maxDate` picker constraints without mutation. |
+| `min(dates[])` | Earliest date in the array. Returns `null` for an empty array. |
+| `max(dates[])` | Latest date in the array. Returns `null` for an empty array. |
+| `closestTo(date, datesArray[])` | Nearest date by absolute difference. Returns `null` for an empty array. |
+| `eachMinuteOfInterval(interval, step?)` | Generates a date for every `step` minute (defaults to 1). |
+| `eachHourOfInterval(interval, step?)` | Generates a date for every `step` hour (defaults to 1). |
+| `eachDayOfInterval(interval)` | Every calendar day, inclusive of both boundaries. |
+| `eachWeekOfInterval(interval, weekStartsOn?)` | First day of every week in the interval. |
+| `eachMonthOfInterval(interval)` | First day of every month in the interval. |
+| `eachYearOfInterval(interval)` | January 1st of every year in the interval. |
+
+**Unix Timestamps**
+
+| Function | Notes |
+| --- | --- |
+| `fromUnixTime(seconds)` | Converts Unix epoch **seconds** (not ms) to a `Date`. |
+| `toUnixTime(date)` | Converts to Unix epoch **seconds**, truncated. |
+
+**Rounding & ISO Weeks**
+
+| Function | Notes |
+| --- | --- |
+| `roundToNearestMinutes(date, step)` | Snaps to the nearest multiple of `step` minutes. |
+| `getISOWeek(date)` | ISO-8601 week number (1–53); Week 1 contains the year's first Thursday. |
+| `setISOWeek(date, week)` | Shifts the date to the same weekday within the target ISO week. |
+
+**Duration**
+
+| Function | Notes |
+| --- | --- |
+| `intervalToDuration(interval)` | Cascades an interval into `{ years, months, days, hours, minutes, seconds }` largest-to-smallest, so units never double-count. |
+| `durationToMilliseconds(duration)` | Approximate total — see [Gotchas](#gotchas--edge-cases). |
+
+### Formatting & Parsing
+
+Locale-aware formatting and parsing powered entirely by the native `Intl` API.
+
+| Function | Notes |
+| --- | --- |
+| `format(date, formatString, options?)` | Token-based pattern formatting (`"yyyy-MM-dd"`, etc.). Supports `'literal text'` escaping. |
+| `formatDate(date, locale?, options?)` | Thin wrapper over `Intl.DateTimeFormat` — use for strict, options-driven localization. |
+| `formatRelativeTime(date, baseDate?, locale?)` | Wraps `Intl.RelativeTimeFormat`; auto-selects the most meaningful unit (seconds → years). |
+| `formatDistance(date, baseDate, options?)` | "less than a minute", "about 2 hours", etc. Supports `addSuffix`. |
+| `formatDistanceStrict(date, baseDate, options?)` | Strict unit distance without fuzzy words. Enforces specific units and rounding. |
+| `formatDistanceToNow(date, options?)` | Convenience wrapper over `formatDistance` against current time. |
+| `formatDistanceIntl(date, baseDate, options?)` | `Intl`-powered exact relative time (e.g. "in 2 days", "3 hours ago"). |
+| `formatRelative(date, baseDate, options?)` | "Today at 2:00 PM", "Tomorrow at...", "Last Friday at...". |
+| `formatISO(date, options?)` | ISO 8601 using the **local** timezone offset, unlike native `toISOString()`. |
+| `formatRFC3339(date, options?)` | RFC 3339 — the internet-protocol profile of ISO 8601. Outputs `"Z"` for UTC offset. |
+| `formatISO9075(date, options?)` | The SQL datetime standard (space separator, no offset) used by Postgres/MySQL/SQLite. |
+| `formatRFC2822(date)` | Email/HTTP header format. Day and month names are always English per the RFC spec. |
+| `formatDuration(duration, options?)` | Human-readable duration string with `Intl.PluralRules`-correct pluralization. |
+| `toISOString(date)` | Thin wrapper over native `toISOString()` — always UTC, always ends in `"Z"`. |
+| `parseISO(isoString)` | **Strict** ISO 8601 parser — rejects locale-specific/ambiguous formats (unlike the permissive `toDate()`). |
+
+## Advanced Usage & Examples
+
+### Safe Date Chaining
+
+Because every function clones its input before touching it, you can chain operations inline without ever worrying about a downstream call mutating an upstream reference:
+
+```ts
+import {
+  startOfWeek,
+  addBusinessDays,
+  format,
+} from "@himanshu-sorathiya/react-kit/datetime";
+
+const today = new Date();
+
+const dueDate = format(
+  addBusinessDays(startOfWeek(today, 1), 3), // Monday-start week + 3 business days
+  "EEEE, MMMM dd yyyy",
+);
+
+console.log(dueDate); // → "Thursday, July 16 2026"
+console.log(today); // → untouched — the original reference was never mutated
+```
+
+`startOfWeek` clones `today` before snapping it to Monday, `addBusinessDays` clones that result again before walking forward — so `today` is guaranteed to still point at the exact instant it was created, no matter how many functions are chained on top of it.
+
+## Real-World Use Cases
+
+- Building custom date-picker calendar grids, including blank-cell padding before the 1st and "Today" highlighting.
+- Calculating user trial or subscription expiration dates, and the number of days remaining.
+- Rendering localized activity/timeline feeds ("3 hours ago", "in 2 days") without a translation bundle.
+- Validating age restrictions (e.g. 18+) on signup or KYC forms.
+- Drawing Gantt chart bars and interval overlays from raw start/end dates.
+- Detecting scheduling conflicts or double-bookings in calendar and meeting-room apps.
+- Snapping free-form time selections to fixed appointment slots (e.g. rounding to the nearest 15 minutes).
+- Computing business-day SLAs and shipping/delivery estimates while skipping weekends.
+- Generating recurring event occurrences across a bounded date range.
+- Formatting timestamps for API payloads, database inserts, and email headers (RFC 3339, ISO 9075, RFC 2822).
+
+## Gotchas & Edge Cases
+
+- **Local timezone mandate.** The entire library operates in the runtime's local timezone. Parsing a UTC string (e.g. via `toDate()`) converts it to local time under the hood — there is no "UTC mode."
+- **Graceful failures, not exceptions.** All numeric getters return `NaN` and all query/predicate functions return `false` when given an invalid date input. Nothing in this library throws on bad input.
+- **Day-level past/future checks.** `isPast(startOfDay(today))` evaluates to `true`, because midnight of the current day is already in the past. If you need to know whether a *calendar day* (not a timestamp) is yesterday or older, use `isBefore(date, startOfDay(new Date()))` instead of `isPast()` directly.
+- **Zero-duration overlaps.** `isOverlapping` treats an exact boundary touch (Event A ends exactly when Event B starts) as **not** overlapping — it returns `false`. This holds true even for zero-duration events (`start === end`) that land precisely on a boundary.
+- **`durationToMilliseconds` is an approximation — never use it for arithmetic.** It computes years and months using mean averages (365.25 days/year, 30.4375 days/month) because their true length varies. It is intended strictly for **sorting and comparing** the relative size of durations. Using its output to actually advance a clock or a calendar date will introduce drift.
+- **`intervalToDuration` always returns an absolute duration.** It strips away chronological direction: even if `interval.start` is chronologically *after* `interval.end`, the returned `Duration` is always positive.
+- **`format` vs. `formatDate`.** Prefer `formatDate` when you need strict, correct localization — it delegates fully to `Intl.DateTimeFormat`, which natively supports non-Gregorian calendars and Eastern Arabic numerals. The `format` token parser, by contrast, builds its output from padded native getters, so it **always** produces Western Arabic numerals (0–9) on the **Gregorian calendar**, regardless of the `locale` option passed.
+- **`formatDuration`'s locale support is partial.** It uses `Intl.PluralRules` to select the grammatically correct plural form (correctly handling languages like Arabic, which has six plural categories) — but the unit label strings themselves ("years", "months", "days", …) are currently hardcoded to English only.

package/dist/index.d.ts

@@ -0,0 +1,285 @@
+export declare function addBusinessDays(date: DateInput, amount: number): Date;
+
+export declare function addDays(date: DateInput, amount: number): Date;
+
+export declare function addHours(date: DateInput, amount: number): Date;
+
+export declare function addMilliseconds(date: DateInput, amount: number): Date;
+
+export declare function addMinutes(date: DateInput, amount: number): Date;
+
+export declare function addMonths(date: DateInput, amount: number): Date;
+
+export declare function addSeconds(date: DateInput, amount: number): Date;
+
+export declare function addWeeks(date: DateInput, amount: number): Date;
+
+export declare function addYears(date: DateInput, amount: number): Date;
+
+export declare function clampDate(date: DateInput, min: DateInput, max: DateInput): Date;
+
+export declare function closestTo(date: DateInput, datesArray: Date[]): Date | null;
+
+export declare function compareAsc(dateLeft: DateInput, dateRight: DateInput): number;
+
+export declare function compareDesc(dateLeft: DateInput, dateRight: DateInput): number;
+
+export declare function createDate(year: number, month: number, day?: number): Date;
+
+declare type DateInput = Date | number | string;
+
+declare type DateInterval = {
+    start: Date;
+    end: Date;
+};
+
+declare type DateRange = {
+    start: Date;
+    end: Date;
+};
+
+export declare function differenceInBusinessDays(dateLeft: DateInput, dateRight: DateInput): number;
+
+export declare function differenceInDays(dateLeft: DateInput, dateRight: DateInput): number;
+
+export declare function differenceInHours(dateLeft: DateInput, dateRight: DateInput): number;
+
+export declare function differenceInMilliseconds(dateLeft: DateInput, dateRight: DateInput): number;
+
+export declare function differenceInMinutes(dateLeft: DateInput, dateRight: DateInput): number;
+
+export declare function differenceInMonths(dateLeft: DateInput, dateRight: DateInput): number;
+
+export declare function differenceInSeconds(dateLeft: DateInput, dateRight: DateInput): number;
+
+export declare function differenceInWeeks(dateLeft: DateInput, dateRight: DateInput): number;
+
+export declare function differenceInYears(dateLeft: DateInput, dateRight: DateInput): number;
+
+declare type Duration = {
+    years?: number;
+    months?: number;
+    weeks?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+};
+
+export declare function durationToMilliseconds(duration: Duration): number;
+
+export declare function eachDayOfInterval(interval: DateInterval): Date[];
+
+export declare function eachHourOfInterval(interval: DateInterval, step?: number): Date[];
+
+export declare function eachMinuteOfInterval(interval: DateInterval, step?: number): Date[];
+
+export declare function eachMonthOfInterval(interval: DateInterval): Date[];
+
+export declare function eachWeekOfInterval(interval: DateInterval, weekStartsOn?: WeekStartsOn): Date[];
+
+export declare function eachYearOfInterval(interval: DateInterval): Date[];
+
+export declare function endOfDay(date: DateInput): Date;
+
+export declare function endOfHour(date: DateInput): Date;
+
+export declare function endOfMinute(date: DateInput): Date;
+
+export declare function endOfMonth(date: DateInput): Date;
+
+export declare function endOfQuarter(date: DateInput): Date;
+
+export declare function endOfWeek(date: DateInput, weekStartsOn?: WeekStartsOn): Date;
+
+export declare function endOfYear(date: DateInput): Date;
+
+export declare function format(date: DateInput, formatString: string, options?: {
+    locale?: string;
+}): string;
+
+export declare function formatDate(date: DateInput, locale?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+
+export declare function formatDuration(duration: Duration, options?: {
+    format?: ReadonlyArray<keyof Duration>;
+    zero?: boolean;
+    delimiter?: string;
+    locale?: string;
+}): string;
+
+export declare function formatISO(date: DateInput, options?: {
+    format?: 'extended' | 'basic';
+    representation?: 'complete' | 'date' | 'time';
+}): string;
+
+export declare function formatISO9075(date: DateInput, options?: {
+    representation?: 'complete' | 'date' | 'time';
+}): string;
+
+export declare function formatRelativeTime(date: DateInput, baseDate?: DateInput, locale?: string | string[]): string;
+
+export declare function formatRFC2822(date: DateInput): string;
+
+export declare function formatRFC3339(date: DateInput, options?: {
+    fractionDigits?: 0 | 1 | 2 | 3;
+}): string;
+
+export declare function fromUnixTime(seconds: number): Date;
+
+export declare function getDate(date: DateInput): number;
+
+export declare function getDayOfWeek(date: DateInput): number;
+
+export declare function getDayOfYear(date: DateInput): number;
+
+export declare function getDaysInMonth(date: DateInput): number;
+
+export declare function getHours(date: DateInput): number;
+
+export declare function getISOWeek(date: DateInput): number;
+
+export declare function getMilliseconds(date: DateInput): number;
+
+export declare function getMinutes(date: DateInput): number;
+
+export declare function getMonth(date: DateInput): number;
+
+export declare function getOverlappingDaysInInterval(intervalLeft: DateInterval, intervalRight: DateInterval): number;
+
+export declare function getQuarter(date: DateInput): number;
+
+export declare function getSeconds(date: DateInput): number;
+
+export declare function getTimestamp(date: DateInput): number;
+
+export declare function getYear(date: DateInput): number;
+
+export declare function intervalToDuration(interval: DateInterval): Duration;
+
+export declare function isAfter(date: DateInput, compareDate: DateInput): boolean;
+
+export declare function isAM(date: DateInput): boolean;
+
+export declare function isBefore(date: DateInput, compareDate: DateInput): boolean;
+
+export declare function isDate(value: unknown): value is Date;
+
+export declare function isEqual(dateA: DateInput, dateB: DateInput): boolean;
+
+export declare function isFirstDayOfMonth(date: DateInput): boolean;
+
+export declare function isFuture(date: DateInput): boolean;
+
+export declare function isInLeapYear(date: DateInput): boolean;
+
+export declare function isLastDayOfMonth(date: DateInput): boolean;
+
+export declare function isLeapYear(yearOrDate: number | Date): boolean;
+
+export declare function isOverlapping(rangeA: DateRange, rangeB: DateRange): boolean;
+
+export declare function isPast(date: DateInput): boolean;
+
+export declare function isPM(date: DateInput): boolean;
+
+export declare function isSameDay(dateA: DateInput, dateB: DateInput): boolean;
+
+export declare function isSameHour(dateA: DateInput, dateB: DateInput): boolean;
+
+export declare function isSameMinute(dateA: DateInput, dateB: DateInput): boolean;
+
+export declare function isSameMonth(dateA: DateInput, dateB: DateInput): boolean;
+
+export declare function isSameQuarter(dateA: DateInput, dateB: DateInput): boolean;
+
+export declare function isSameSecond(dateA: DateInput, dateB: DateInput): boolean;
+
+export declare function isSameTime(dateA: DateInput, dateB: DateInput): boolean;
+
+export declare function isSameWeek(dateA: DateInput, dateB: DateInput, weekStartsOn?: WeekStartsOn): boolean;
+
+export declare function isSameYear(dateA: DateInput, dateB: DateInput): boolean;
+
+export declare function isThisMonth(date: DateInput): boolean;
+
+export declare function isThisWeek(date: DateInput, weekStartsOn?: WeekStartsOn): boolean;
+
+export declare function isThisYear(date: DateInput): boolean;
+
+export declare function isToday(date: DateInput): boolean;
+
+export declare function isTomorrow(date: DateInput): boolean;
+
+export declare function isValid(date: Date): boolean;
+
+export declare function isWeekday(date: DateInput): boolean;
+
+export declare function isWeekend(date: DateInput): boolean;
+
+export declare function isWithinRange(date: DateInput, start: DateInput, end: DateInput): boolean;
+
+export declare function isYesterday(date: DateInput): boolean;
+
+export declare function max(dates: Date[]): Date | null;
+
+export declare function min(dates: Date[]): Date | null;
+
+export declare function parseISO(isoString: string): Date;
+
+export declare function roundToNearestMinutes(date: DateInput, step: number): Date;
+
+export declare function setDate(date: DateInput, day: number): Date;
+
+export declare function setHours(date: DateInput, hours: number): Date;
+
+export declare function setISOWeek(date: DateInput, week: number): Date;
+
+export declare function setMilliseconds(date: DateInput, ms: number): Date;
+
+export declare function setMinutes(date: DateInput, minutes: number): Date;
+
+export declare function setMonth(date: DateInput, month: number): Date;
+
+export declare function setSeconds(date: DateInput, seconds: number): Date;
+
+export declare function setYear(date: DateInput, year: number): Date;
+
+export declare function startOfDay(date: DateInput): Date;
+
+export declare function startOfHour(date: DateInput): Date;
+
+export declare function startOfMinute(date: DateInput): Date;
+
+export declare function startOfMonth(date: DateInput): Date;
+
+export declare function startOfQuarter(date: DateInput): Date;
+
+export declare function startOfWeek(date: DateInput, weekStartsOn?: WeekStartsOn): Date;
+
+export declare function startOfYear(date: DateInput): Date;
+
+export declare function subDays(date: DateInput, amount: number): Date;
+
+export declare function subHours(date: DateInput, amount: number): Date;
+
+export declare function subMilliseconds(date: DateInput, amount: number): Date;
+
+export declare function subMinutes(date: DateInput, amount: number): Date;
+
+export declare function subMonths(date: DateInput, amount: number): Date;
+
+export declare function subSeconds(date: DateInput, amount: number): Date;
+
+export declare function subWeeks(date: DateInput, amount: number): Date;
+
+export declare function subYears(date: DateInput, amount: number): Date;
+
+export declare function toDate(input: DateInput): Date;
+
+export declare function toISOString(date: DateInput): string;
+
+export declare function toUnixTime(date: DateInput): number;
+
+declare type WeekStartsOn = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+export { }

package/dist/index.js

@@ -0,0 +1,630 @@
+//#region src/core.ts
+function e(e) {
+	return e instanceof Date ? new Date(e.getTime()) : typeof e != "number" && typeof e != "string" ? /* @__PURE__ */ new Date(NaN) : new Date(e);
+}
+function t(e) {
+	return e instanceof Date;
+}
+function n(e) {
+	return t(e) && !isNaN(e.getTime());
+}
+function r(e, t, n = 1) {
+	let r = new Date(e, t - 1, n);
+	return r.getMonth() === t - 1 ? r : new Date(e, t, 0);
+}
+function i(t) {
+	return e(t).getFullYear();
+}
+function a(t) {
+	return e(t).getMonth() + 1;
+}
+function o(t) {
+	return e(t).getDate();
+}
+function s(t) {
+	return e(t).getHours();
+}
+function c(t) {
+	return e(t).getMinutes();
+}
+function l(t) {
+	return e(t).getSeconds();
+}
+function u(t) {
+	return e(t).getMilliseconds();
+}
+function d(t) {
+	return e(t).getTime();
+}
+function f(t) {
+	return e(t).getDay();
+}
+function p(t) {
+	let n = e(t);
+	return new Date(n.getFullYear(), n.getMonth() + 1, 0).getDate();
+}
+function m(t) {
+	return Math.ceil((e(t).getMonth() + 1) / 3);
+}
+function h(t) {
+	let n = e(t), r = new Date(n.getFullYear(), 0, 1, 0, 0, 0, 0), i = new Date(n.getFullYear(), n.getMonth(), n.getDate(), 0, 0, 0, 0);
+	return Math.round((i.getTime() - r.getTime()) / 864e5) + 1;
+}
+//#endregion
+//#region src/manipulation.ts
+function g(t, n) {
+	return new Date(e(t).getTime() + n);
+}
+function _(t, n) {
+	return new Date(e(t).getTime() + n * V);
+}
+function v(t, n) {
+	return new Date(e(t).getTime() + n * H);
+}
+function y(t, n) {
+	return new Date(e(t).getTime() + n * U);
+}
+function b(t, n) {
+	let r = e(t);
+	return r.setDate(r.getDate() + n), r;
+}
+function x(e, t) {
+	return b(e, t * 7);
+}
+function S(t, n) {
+	let r = e(t), i = r.getDate();
+	return r.setDate(1), r.setMonth(r.getMonth() + n), r.setDate(Math.min(i, p(r))), r;
+}
+function C(t, n) {
+	let r = e(t), i = r.getMonth();
+	return r.setFullYear(r.getFullYear() + n), r.getMonth() !== i && r.setDate(0), r;
+}
+function w(e, t) {
+	return g(e, -t);
+}
+function ee(e, t) {
+	return _(e, -t);
+}
+function te(e, t) {
+	return v(e, -t);
+}
+function ne(e, t) {
+	return y(e, -t);
+}
+function re(e, t) {
+	return b(e, -t);
+}
+function ie(e, t) {
+	return x(e, -t);
+}
+function ae(e, t) {
+	return S(e, -t);
+}
+function oe(e, t) {
+	return C(e, -t);
+}
+function se(t, n) {
+	let r = e(t), i = r.getMonth();
+	return r.setFullYear(n), r.getMonth() !== i && r.setDate(0), r;
+}
+function T(t, n) {
+	let r = e(t), i = r.getDate();
+	return r.setDate(1), r.setMonth(n - 1), r.setDate(Math.min(i, p(r))), r;
+}
+function ce(t, n) {
+	let r = e(t), i = p(r);
+	return r.setDate(Math.min(Math.max(1, n), i)), r;
+}
+function le(t, n) {
+	let r = e(t);
+	return r.setHours(n), r;
+}
+function ue(t, n) {
+	let r = e(t);
+	return r.setMinutes(n), r;
+}
+function de(t, n) {
+	let r = e(t);
+	return r.setSeconds(n), r;
+}
+function fe(t, n) {
+	let r = e(t);
+	return r.setMilliseconds(n), r;
+}
+function E(t) {
+	let n = e(t);
+	return n.setHours(0, 0, 0, 0), n;
+}
+function pe(t) {
+	let n = e(t);
+	return n.setHours(23, 59, 59, 999), n;
+}
+function D(t) {
+	let n = e(t);
+	return n.setMinutes(0, 0, 0), n;
+}
+function me(t) {
+	let n = e(t);
+	return n.setMinutes(59, 59, 999), n;
+}
+function O(t) {
+	let n = e(t);
+	return n.setSeconds(0, 0), n;
+}
+function he(t) {
+	let n = e(t);
+	return n.setSeconds(59, 999), n;
+}
+function k(t, n = 0) {
+	let r = e(t), i = (r.getDay() - n + 7) % 7;
+	return r.setDate(r.getDate() - i), r.setHours(0, 0, 0, 0), r;
+}
+function ge(e, t = 0) {
+	let n = k(e, t);
+	return n.setDate(n.getDate() + 6), n.setHours(23, 59, 59, 999), n;
+}
+function A(t) {
+	let n = e(t);
+	return n.setDate(1), n.setHours(0, 0, 0, 0), n;
+}
+function _e(t) {
+	let n = e(t);
+	return new Date(n.getFullYear(), n.getMonth() + 1, 0, 23, 59, 59, 999);
+}
+function ve(t) {
+	let n = e(t), r = n.getMonth() - n.getMonth() % 3;
+	return new Date(n.getFullYear(), r, 1, 0, 0, 0, 0);
+}
+function ye(t) {
+	let n = e(t), r = n.getMonth() - n.getMonth() % 3 + 2;
+	return new Date(n.getFullYear(), r + 1, 0, 23, 59, 59, 999);
+}
+function j(t) {
+	let n = e(t);
+	return new Date(n.getFullYear(), 0, 1, 0, 0, 0, 0);
+}
+function M(t) {
+	let n = e(t);
+	return new Date(n.getFullYear(), 11, 31, 23, 59, 59, 999);
+}
+function N(t, n) {
+	return e(t).getTime() - e(n).getTime();
+}
+function P(e, t) {
+	return Math.trunc(N(e, t) / V);
+}
+function F(e, t) {
+	return Math.trunc(N(e, t) / H);
+}
+function I(e, t) {
+	return Math.trunc(N(e, t) / U);
+}
+function L(t, n) {
+	let r = E(e(t)), i = E(e(n));
+	return Math.round((r.getTime() - i.getTime()) / W);
+}
+function be(e, t) {
+	return Math.trunc(L(e, t) / 7);
+}
+function R(t, n) {
+	let r = e(t), i = e(n), a = r.getFullYear() - i.getFullYear(), o = r.getMonth() - i.getMonth(), s = a * 12 + o, c = S(i, s);
+	return s > 0 && c.getTime() > r.getTime() ? s - 1 : s < 0 && c.getTime() < r.getTime() ? s + 1 : s;
+}
+function z(t, n) {
+	let r = e(t), i = e(n), a = r.getFullYear() - i.getFullYear(), o = C(i, a);
+	return a > 0 && o.getTime() > r.getTime() ? a - 1 : a < 0 && o.getTime() < r.getTime() ? a + 1 : a;
+}
+function xe(t, n) {
+	let r = e(t), i = n < 0 ? -1 : 1, a = Math.abs(n);
+	for (; a > 0;) {
+		r.setDate(r.getDate() + i);
+		let e = r.getDay();
+		e !== 0 && e !== 6 && a--;
+	}
+	return r;
+}
+function Se(t, n) {
+	let r = E(e(t)), i = E(e(n)), a = L(r, i);
+	if (a === 0) return 0;
+	let o = a > 0 ? 1 : -1, s = Math.abs(a), c = Math.floor(s / 7) * 5, l = new Date(i);
+	for (let e = 0; e < s % 7; e++) {
+		l.setDate(l.getDate() + o);
+		let e = l.getDay();
+		e !== 0 && e !== 6 && c++;
+	}
+	return c * o;
+}
+function Ce(t, r, i) {
+	let a = e(t), o = e(r), s = e(i);
+	return !n(a) || !n(o) || !n(s) ? /* @__PURE__ */ new Date(NaN) : a.getTime() < o.getTime() ? o : a.getTime() > s.getTime() ? s : a;
+}
+function we(e) {
+	return e.length === 0 ? null : new Date(Math.min(...e.map((e) => e.getTime())));
+}
+function Te(e) {
+	return e.length === 0 ? null : new Date(Math.max(...e.map((e) => e.getTime())));
+}
+function Ee(t, r) {
+	if (r.length === 0) return null;
+	let i = e(t);
+	if (!n(i)) return /* @__PURE__ */ new Date(NaN);
+	let a = i.getTime();
+	return r.reduce((e, t) => n(t) && Math.abs(t.getTime() - a) < Math.abs(e.getTime() - a) ? t : e);
+}
+function De(t, n = 1) {
+	let r = [], i = O(e(t.start)), a = O(e(t.end)), o = new Date(i), s = Math.trunc(n);
+	if (s < 1 || Number.isNaN(s)) return r;
+	for (; o.getTime() <= a.getTime();) r.push(new Date(o)), o.setMinutes(o.getMinutes() + s);
+	return r;
+}
+function Oe(t, n = 1) {
+	let r = [], i = D(e(t.start)), a = D(e(t.end)), o = new Date(i), s = Math.trunc(n);
+	if (s < 1 || Number.isNaN(s)) return r;
+	for (; o.getTime() <= a.getTime();) r.push(new Date(o)), o.setHours(o.getHours() + s);
+	return r;
+}
+function ke(t) {
+	let n = [], r = E(e(t.start)), i = E(e(t.end)), a = new Date(r);
+	for (; a.getTime() <= i.getTime();) n.push(new Date(a)), a.setDate(a.getDate() + 1);
+	return n;
+}
+function Ae(t, n = 0) {
+	let r = [], i = k(e(t.start), n), a = k(e(t.end), n), o = new Date(i);
+	for (; o.getTime() <= a.getTime();) r.push(new Date(o)), o.setDate(o.getDate() + 7);
+	return r;
+}
+function je(t) {
+	let n = [], r = A(e(t.start)), i = A(e(t.end)), a = new Date(r);
+	for (; a.getTime() <= i.getTime();) n.push(new Date(a)), a.setMonth(a.getMonth() + 1);
+	return n;
+}
+function Me(t) {
+	let n = [], r = j(e(t.start)), i = j(e(t.end)), a = new Date(r);
+	for (; a.getTime() <= i.getTime();) n.push(new Date(a)), a.setFullYear(a.getFullYear() + 1);
+	return n;
+}
+function Ne(e) {
+	return /* @__PURE__ */ new Date(e * 1e3);
+}
+function Pe(t) {
+	return Math.floor(e(t).getTime() / 1e3);
+}
+function Fe(t, n) {
+	let r = n * H;
+	return new Date(Math.round(e(t).getTime() / r) * r);
+}
+function B(t) {
+	let n = e(t), r = n.getDay() || 7;
+	n.setDate(n.getDate() + 4 - r);
+	let i = new Date(n.getFullYear(), 0, 1);
+	return Math.ceil(((n.getTime() - i.getTime()) / W + 1) / 7);
+}
+function Ie(t, n) {
+	let r = e(t), i = B(r);
+	return r.setDate(r.getDate() + (n - i) * 7), r;
+}
+function Le(t) {
+	let n = e(t.start), r = e(t.end), [i, a] = n.getTime() <= r.getTime() ? [n, r] : [r, n], o = z(a, i), s = C(i, o), c = R(a, s), l = S(s, c), u = L(a, l), d = b(l, u), f = I(a, d), p = y(d, f), m = F(a, p);
+	return {
+		years: o,
+		months: c,
+		days: u,
+		hours: f,
+		minutes: m,
+		seconds: P(a, v(p, m))
+	};
+}
+function Re(e) {
+	let t = 365.25 * W, n = 30.4375 * W;
+	return (e.years ?? 0) * t + (e.months ?? 0) * n + (e.weeks ?? 0) * 7 * W + (e.days ?? 0) * W + (e.hours ?? 0) * U + (e.minutes ?? 0) * H + (e.seconds ?? 0) * V;
+}
+function ze(t, r) {
+	let i = e(t.start), a = e(t.end), o = e(r.start), s = e(r.end);
+	if (!n(i) || !n(a) || !n(o) || !n(s)) return NaN;
+	let c = i.getTime(), l = a.getTime(), u = o.getTime(), d = s.getTime(), [f, p] = c <= l ? [c, l] : [l, c], [m, h] = u <= d ? [u, d] : [d, u];
+	return f < h && p > m ? Math.ceil(((p > h ? h : p) - (f < m ? m : f)) / W) : 0;
+}
+//#endregion
+//#region src/constants.ts
+var V = 1e3, H = 6e4, U = 36e5, W = 864e5, G = {
+	yyyy: (e) => String(e.getFullYear()).padStart(4, "0"),
+	yy: (e) => String(e.getFullYear()).slice(-2),
+	MMMM: (e, t) => new Intl.DateTimeFormat(t, { month: "long" }).format(e),
+	MMM: (e, t) => new Intl.DateTimeFormat(t, { month: "short" }).format(e),
+	MM: (e) => String(e.getMonth() + 1).padStart(2, "0"),
+	M: (e) => String(e.getMonth() + 1),
+	dd: (e) => String(e.getDate()).padStart(2, "0"),
+	d: (e) => String(e.getDate()),
+	EEEE: (e, t) => new Intl.DateTimeFormat(t, { weekday: "long" }).format(e),
+	EEE: (e, t) => new Intl.DateTimeFormat(t, { weekday: "short" }).format(e),
+	E: (e, t) => new Intl.DateTimeFormat(t, { weekday: "short" }).format(e),
+	HH: (e) => String(e.getHours()).padStart(2, "0"),
+	H: (e) => String(e.getHours()),
+	hh: (e) => String(e.getHours() % 12 || 12).padStart(2, "0"),
+	h: (e) => String(e.getHours() % 12 || 12),
+	mm: (e) => String(e.getMinutes()).padStart(2, "0"),
+	ss: (e) => String(e.getSeconds()).padStart(2, "0"),
+	SSS: (e) => String(e.getMilliseconds()).padStart(3, "0"),
+	a: (e, t) => new Intl.DateTimeFormat(t, {
+		hour: "numeric",
+		hour12: !0
+	}).formatToParts(e).find((e) => e.type === "dayPeriod")?.value ?? "",
+	Q: (e) => String(Math.ceil((e.getMonth() + 1) / 3)),
+	w: (e) => String(B(e)),
+	D: (e) => String(h(e)),
+	xxx: (e) => {
+		let t = q(e);
+		return `${t.sign}${t.hours}:${t.minutes}`;
+	},
+	xx: (e) => {
+		let t = q(e);
+		return `${t.sign}${t.hours}${t.minutes}`;
+	},
+	x: (e) => {
+		let t = q(e);
+		return `${t.sign}${t.hours}`;
+	}
+}, Be = RegExp("'[^']*'|" + Object.keys(G).sort((e, t) => t.length - e.length).join("|"), "g"), Ve = [
+	"Sun",
+	"Mon",
+	"Tue",
+	"Wed",
+	"Thu",
+	"Fri",
+	"Sat"
+], He = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+], Ue = [
+	"years",
+	"months",
+	"weeks",
+	"days",
+	"hours",
+	"minutes",
+	"seconds"
+], K = {
+	years: ["year", "years"],
+	months: ["month", "months"],
+	weeks: ["week", "weeks"],
+	days: ["day", "days"],
+	hours: ["hour", "hours"],
+	minutes: ["minute", "minutes"],
+	seconds: ["second", "seconds"]
+}, We = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/;
+//#endregion
+//#region src/internals.ts
+function q(e) {
+	let t = e.getTimezoneOffset(), n = t <= 0 ? "+" : "-", r = Math.abs(t);
+	return {
+		sign: n,
+		hours: String(Math.floor(r / 60)).padStart(2, "0"),
+		minutes: String(r % 60).padStart(2, "0")
+	};
+}
+function J(e, t) {
+	let n = new Date(e), r = (n.getDay() - t + 7) % 7;
+	return n.setDate(n.getDate() - r), n.setHours(0, 0, 0, 0), n;
+}
+//#endregion
+//#region src/queries.ts
+function Y(t, r) {
+	let i = e(t), a = e(r);
+	return !n(i) || !n(a) ? !1 : i.getFullYear() === a.getFullYear() && i.getMonth() === a.getMonth() && i.getDate() === a.getDate();
+}
+function X(t, r) {
+	let i = e(t), a = e(r);
+	return !n(i) || !n(a) ? !1 : i.getFullYear() === a.getFullYear() && i.getMonth() === a.getMonth();
+}
+function Z(t, r) {
+	let i = e(t), a = e(r);
+	return !n(i) || !n(a) ? !1 : i.getFullYear() === a.getFullYear();
+}
+function Ge(t, r) {
+	let i = e(t), a = e(r);
+	if (!n(i) || !n(a)) return !1;
+	let o = Math.ceil((i.getMonth() + 1) / 3), s = Math.ceil((a.getMonth() + 1) / 3);
+	return i.getFullYear() === a.getFullYear() && o === s;
+}
+function Q(t, r, i = 0) {
+	let a = e(t), o = e(r);
+	return !n(a) || !n(o) ? !1 : J(a, i).getTime() === J(o, i).getTime();
+}
+function Ke(t, r) {
+	let i = e(t), a = e(r);
+	return !n(i) || !n(a) ? !1 : i.getFullYear() === a.getFullYear() && i.getMonth() === a.getMonth() && i.getDate() === a.getDate() && i.getHours() === a.getHours();
+}
+function qe(t, r) {
+	let i = e(t), a = e(r);
+	return !n(i) || !n(a) ? !1 : i.getFullYear() === a.getFullYear() && i.getMonth() === a.getMonth() && i.getDate() === a.getDate() && i.getHours() === a.getHours() && i.getMinutes() === a.getMinutes();
+}
+function Je(t, r) {
+	let i = e(t), a = e(r);
+	return !n(i) || !n(a) ? !1 : i.getFullYear() === a.getFullYear() && i.getMonth() === a.getMonth() && i.getDate() === a.getDate() && i.getHours() === a.getHours() && i.getMinutes() === a.getMinutes() && i.getSeconds() === a.getSeconds();
+}
+function Ye(t, r) {
+	let i = e(t), a = e(r);
+	return !n(i) || !n(a) ? !1 : i.getHours() === a.getHours() && i.getMinutes() === a.getMinutes() && i.getSeconds() === a.getSeconds();
+}
+function Xe(t, r) {
+	let i = e(t), a = e(r);
+	if (!n(i) || !n(a)) return NaN;
+	let o = i.getTime() - a.getTime();
+	return o < 0 ? -1 : +(o > 0);
+}
+function Ze(t, r) {
+	let i = e(t), a = e(r);
+	if (!n(i) || !n(a)) return NaN;
+	let o = i.getTime() - a.getTime();
+	return o > 0 ? -1 : +(o < 0);
+}
+function Qe(t, r) {
+	let i = e(t), a = e(r);
+	return !n(i) || !n(a) ? !1 : i.getTime() < a.getTime();
+}
+function $e(t, r) {
+	let i = e(t), a = e(r);
+	return !n(i) || !n(a) ? !1 : i.getTime() > a.getTime();
+}
+function et(t, r) {
+	let i = e(t), a = e(r);
+	return !n(i) || !n(a) ? !1 : i.getTime() === a.getTime();
+}
+function tt(t, r, i) {
+	let a = e(t), o = e(r), s = e(i);
+	return !n(a) || !n(o) || !n(s) ? !1 : (o.getTime() > s.getTime() && ([o, s] = [s, o]), a.getTime() >= o.getTime() && a.getTime() <= s.getTime());
+}
+function nt(e, t) {
+	return !n(e.start) || !n(e.end) || !n(t.start) || !n(t.end) ? !1 : e.start.getTime() < t.end.getTime() && e.end.getTime() > t.start.getTime();
+}
+function rt(e) {
+	return Y(e, /* @__PURE__ */ new Date());
+}
+function it(e) {
+	let t = /* @__PURE__ */ new Date();
+	return t.setDate(t.getDate() - 1), Y(e, t);
+}
+function at(e) {
+	let t = /* @__PURE__ */ new Date();
+	return t.setDate(t.getDate() + 1), Y(e, t);
+}
+function ot(t) {
+	let r = e(t);
+	return n(r) ? r.getTime() < Date.now() : !1;
+}
+function st(t) {
+	let r = e(t);
+	return n(r) ? r.getTime() > Date.now() : !1;
+}
+function ct(e, t = 0) {
+	return Q(e, /* @__PURE__ */ new Date(), t);
+}
+function lt(e) {
+	return X(e, /* @__PURE__ */ new Date());
+}
+function ut(e) {
+	return Z(e, /* @__PURE__ */ new Date());
+}
+function dt(t) {
+	let r = e(t);
+	return n(r) ? r.getDate() === 1 : !1;
+}
+function ft(t) {
+	let r = e(t);
+	if (!n(r)) return !1;
+	let i = new Date(r);
+	return i.setDate(i.getDate() + 1), i.getMonth() !== r.getMonth();
+}
+function pt(t) {
+	let r = e(t);
+	if (!n(r)) return !1;
+	let i = r.getDay();
+	return i === 0 || i === 6;
+}
+function mt(t) {
+	let r = e(t);
+	if (!n(r)) return !1;
+	let i = r.getDay();
+	return i >= 1 && i <= 5;
+}
+function ht(t) {
+	let r = e(t);
+	return n(r) ? r.getHours() < 12 : !1;
+}
+function gt(t) {
+	let r = e(t);
+	return n(r) ? r.getHours() >= 12 : !1;
+}
+function $(e) {
+	let t;
+	if (e instanceof Date) {
+		if (!n(e)) return !1;
+		t = e.getFullYear();
+	} else t = e;
+	return t % 4 == 0 && t % 100 != 0 || t % 400 == 0;
+}
+function _t(t) {
+	let r = e(t);
+	return n(r) ? $(r.getFullYear()) : !1;
+}
+//#endregion
+//#region src/format.ts
+function vt(t, r, i) {
+	let a = e(t);
+	if (!n(a)) return "Invalid Date";
+	let o = i?.locale ?? "default";
+	return r.replace(Be, (e) => {
+		if (e.startsWith("'")) {
+			let t = e.slice(1, -1);
+			return t === "" ? "'" : t;
+		}
+		let t = G[e];
+		return t(a, o);
+	});
+}
+function yt(t, r = "default", i = {}) {
+	let a = e(t);
+	return n(a) ? new Intl.DateTimeFormat(r, i).format(a) : "Invalid Date";
+}
+function bt(t, r = /* @__PURE__ */ new Date(), i = "default") {
+	let a = e(t), o = e(r);
+	if (!n(a) || !n(o)) return "Invalid Date";
+	let s = new Intl.RelativeTimeFormat(i, { numeric: "auto" }), c = Math.abs.bind(Math), l = P(a, o), u = F(a, o), d = I(a, o), f = L(a, o), p = Math.trunc(f / 7), m = Math.round(f / 30.4375), h = Math.round(f / 365.25);
+	return c(l) < 60 ? s.format(l, "second") : c(u) < 60 ? s.format(u, "minute") : c(d) < 24 ? s.format(d, "hour") : c(f) < 7 ? s.format(f, "day") : c(p) < 4 ? s.format(p, "week") : c(m) < 12 ? s.format(m, "month") : s.format(h, "year");
+}
+function xt(t, r) {
+	let i = e(t);
+	if (!n(i)) return "Invalid Date";
+	let a = r?.format ?? "extended", o = r?.representation ?? "complete", s = a === "extended" ? "-" : "", c = a === "extended" ? ":" : "", l = String(i.getFullYear()).padStart(4, "0"), u = String(i.getMonth() + 1).padStart(2, "0"), d = String(i.getDate()).padStart(2, "0"), f = String(i.getHours()).padStart(2, "0"), p = String(i.getMinutes()).padStart(2, "0"), m = String(i.getSeconds()).padStart(2, "0"), h = q(i), g = `${h.sign}${h.hours}${c}${h.minutes}`, _ = `${l}${s}${u}${s}${d}`, v = `${f}${c}${p}${c}${m}`;
+	return o === "date" ? _ : o === "time" ? `${v}${g}` : `${_}T${v}${g}`;
+}
+function St(t, r) {
+	let i = e(t);
+	if (!n(i)) return "Invalid Date";
+	let a = r?.fractionDigits ?? 0;
+	return `${String(i.getFullYear()).padStart(4, "0")}-${String(i.getMonth() + 1).padStart(2, "0")}-${String(i.getDate()).padStart(2, "0")}T${String(i.getHours()).padStart(2, "0")}:${String(i.getMinutes()).padStart(2, "0")}:${String(i.getSeconds()).padStart(2, "0")}${a > 0 ? "." + String(i.getMilliseconds()).padStart(3, "0").slice(0, a) : ""}${i.getTimezoneOffset() === 0 ? "Z" : (() => {
+		let e = q(i);
+		return `${e.sign}${e.hours}:${e.minutes}`;
+	})()}`;
+}
+function Ct(t, r) {
+	let i = e(t);
+	if (!n(i)) return "Invalid Date";
+	let a = r?.representation ?? "complete", o = String(i.getFullYear()).padStart(4, "0"), s = String(i.getMonth() + 1).padStart(2, "0"), c = String(i.getDate()).padStart(2, "0"), l = String(i.getHours()).padStart(2, "0"), u = String(i.getMinutes()).padStart(2, "0"), d = String(i.getSeconds()).padStart(2, "0");
+	return a === "date" ? `${o}-${s}-${c}` : a === "time" ? `${l}:${u}:${d}` : `${o}-${s}-${c} ${l}:${u}:${d}`;
+}
+function wt(t) {
+	let r = e(t);
+	if (!n(r)) return "Invalid Date";
+	let i = Ve[r.getDay()], a = String(r.getDate()).padStart(2, "0"), o = He[r.getMonth()], s = r.getFullYear(), c = String(r.getHours()).padStart(2, "0"), l = String(r.getMinutes()).padStart(2, "0"), u = String(r.getSeconds()).padStart(2, "0"), d = q(r);
+	return `${i}, ${a} ${o} ${s} ${c}:${l}:${u} ${d.sign}${d.hours}${d.minutes}`;
+}
+function Tt(e, t) {
+	let n = t?.zero ?? !1, r = t?.delimiter ?? ", ", i = t?.locale ?? "default", a = t?.format ?? Ue, o = new Intl.PluralRules(i), s = new Intl.NumberFormat(i), c = [];
+	for (let t of a) {
+		let r = e[t] ?? 0;
+		if (r === 0 && !n) continue;
+		let [i, a] = K[t], l = o.select(r) === "one" ? i : a;
+		c.push(`${s.format(r)} ${l}`);
+	}
+	return c.join(r);
+}
+function Et(t) {
+	let r = e(t);
+	return n(r) ? r.toISOString() : "Invalid Date";
+}
+function Dt(e) {
+	return We.test(e.trim()) ? new Date(e) : /* @__PURE__ */ new Date(NaN);
+}
+//#endregion
+export { xe as addBusinessDays, b as addDays, y as addHours, g as addMilliseconds, v as addMinutes, S as addMonths, _ as addSeconds, x as addWeeks, C as addYears, Ce as clampDate, Ee as closestTo, Xe as compareAsc, Ze as compareDesc, r as createDate, Se as differenceInBusinessDays, L as differenceInDays, I as differenceInHours, N as differenceInMilliseconds, F as differenceInMinutes, R as differenceInMonths, P as differenceInSeconds, be as differenceInWeeks, z as differenceInYears, Re as durationToMilliseconds, ke as eachDayOfInterval, Oe as eachHourOfInterval, De as eachMinuteOfInterval, je as eachMonthOfInterval, Ae as eachWeekOfInterval, Me as eachYearOfInterval, pe as endOfDay, me as endOfHour, he as endOfMinute, _e as endOfMonth, ye as endOfQuarter, ge as endOfWeek, M as endOfYear, vt as format, yt as formatDate, Tt as formatDuration, xt as formatISO, Ct as formatISO9075, wt as formatRFC2822, St as formatRFC3339, bt as formatRelativeTime, Ne as fromUnixTime, o as getDate, f as getDayOfWeek, h as getDayOfYear, p as getDaysInMonth, s as getHours, B as getISOWeek, u as getMilliseconds, c as getMinutes, a as getMonth, ze as getOverlappingDaysInInterval, m as getQuarter, l as getSeconds, d as getTimestamp, i as getYear, Le as intervalToDuration, ht as isAM, $e as isAfter, Qe as isBefore, t as isDate, et as isEqual, dt as isFirstDayOfMonth, st as isFuture, _t as isInLeapYear, ft as isLastDayOfMonth, $ as isLeapYear, nt as isOverlapping, gt as isPM, ot as isPast, Y as isSameDay, Ke as isSameHour, qe as isSameMinute, X as isSameMonth, Ge as isSameQuarter, Je as isSameSecond, Ye as isSameTime, Q as isSameWeek, Z as isSameYear, lt as isThisMonth, ct as isThisWeek, ut as isThisYear, rt as isToday, at as isTomorrow, n as isValid, mt as isWeekday, pt as isWeekend, tt as isWithinRange, it as isYesterday, Te as max, we as min, Dt as parseISO, Fe as roundToNearestMinutes, ce as setDate, le as setHours, Ie as setISOWeek, fe as setMilliseconds, ue as setMinutes, T as setMonth, de as setSeconds, se as setYear, E as startOfDay, D as startOfHour, O as startOfMinute, A as startOfMonth, ve as startOfQuarter, k as startOfWeek, j as startOfYear, re as subDays, ne as subHours, w as subMilliseconds, te as subMinutes, ae as subMonths, ee as subSeconds, ie as subWeeks, oe as subYears, e as toDate, Et as toISOString, Pe as toUnixTime };

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "@himanshu-sorathiya/datetime",
+	"version": "1.0.1",
+	"description": "A strictly client-side, fully type-safe, zero-dependency toolkit for parsing, querying, manipulating, and formatting dates in TypeScript. Every function is a pure, immutable transformation — no wrapper classes, no prototype patching, no hidden global state.",
+	"type": "module",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"files": [
+		"dist"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"dev": "vite",
+		"build": "tsc -b && vite build",
+		"lint": "eslint .",
+		"preview": "vite preview",
+		"format": "prettier . --write"
+	},
+	"devDependencies": {
+		"@microsoft/api-extractor": "^7.58.12",
+		"@types/node": "^26.1.1",
+		"prettier": "^3.9.6",
+		"typescript": "~6.0.2",
+		"vite": "^8.1.1",
+		"vite-plugin-dts": "^5.0.3"
+	}
+}