@gobrand/tiempo 2.2.3 → 2.3.1

package/dist/isSameNanosecond.d.ts

@@ -0,0 +1,59 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns true if both datetimes represent the exact same nanosecond.
+ * Compares all time fields: year, month, day, hour, minute, second, millisecond, microsecond, and nanosecond.
+ * This is the most precise comparison possible, representing exact instant equality in their respective timezones.
+ *
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their
+ * timezone is preserved. Convert to a common timezone before calling if
+ * you need to compare from a specific perspective.
+ *
+ * @param date1 - First datetime (Instant or ZonedDateTime)
+ * @param date2 - Second datetime (Instant or ZonedDateTime)
+ * @returns true if both dates are in the exact same nanosecond, false otherwise
+ *
+ * @example
+ * ```ts
+ * // Same timezone, exact same nanosecond
+ * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789Z[UTC]');
+ * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789Z[UTC]');
+ *
+ * isSameNanosecond(time1, time2); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Same timezone, different nanoseconds
+ * const ns789 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789Z[UTC]');
+ * const ns790 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456790Z[UTC]');
+ *
+ * isSameNanosecond(ns789, ns790); // false
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Different timezones - compares their local nanoseconds
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123456789-05:00[America/New_York]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.987654321+09:00[Asia/Tokyo]');
+ *
+ * // Same instant, different local nanoseconds from each person's perspective
+ * isSameNanosecond(ny, tokyo); // false (14:30:45.123456789 in NY, 04:30:45.987654321 in Tokyo)
+ *
+ * // Convert to UTC to compare in UTC timezone
+ * isSameNanosecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45.123456789 in UTC)
+ *
+ * // Convert to NY timezone to compare from NY perspective
+ * isSameNanosecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45.123456789 in NY)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Instant inputs are converted to UTC
+ * const instant1 = Temporal.Instant.from('2025-01-20T14:30:45.123456789Z');
+ * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.123456789Z');
+ *
+ * isSameNanosecond(instant1, instant2); // true
+ * ```
+ */
+export declare function isSameNanosecond(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
+//# sourceMappingURL=isSameNanosecond.d.ts.map

package/dist/isSameNanosecond.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameNanosecond.d.ts","sourceRoot":"","sources":["../src/isSameNanosecond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAI,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAeT"}

package/dist/isSameNanosecond.js

@@ -0,0 +1,8 @@
+import {
+  isSameNanosecond
+} from "./chunk-S63QUP4W.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  isSameNanosecond
+};
+//# sourceMappingURL=isSameNanosecond.js.map

package/dist/isSameNanosecond.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/isSameNanosecond.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=isSameNanosecond.test.d.ts.map

package/dist/isSameNanosecond.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameNanosecond.test.d.ts","sourceRoot":"","sources":["../src/isSameNanosecond.test.ts"],"names":[],"mappings":""}

package/dist/isSameSecond.d.ts

@@ -0,0 +1,59 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns true if both datetimes fall in the same second.
+ * Compares the year, month, day, hour, minute, and second fields directly.
+ * Ignores sub-second precision (milliseconds, microseconds, nanoseconds).
+ *
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their
+ * timezone is preserved. Convert to a common timezone before calling if
+ * you need to compare from a specific perspective.
+ *
+ * @param date1 - First datetime (Instant or ZonedDateTime)
+ * @param date2 - Second datetime (Instant or ZonedDateTime)
+ * @returns true if both dates are in the same second, false otherwise
+ *
+ * @example
+ * ```ts
+ * // Same timezone, same second
+ * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.000Z[UTC]');
+ * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.999Z[UTC]');
+ *
+ * isSameSecond(time1, time2); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Same timezone, different seconds
+ * const sec45 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45Z[UTC]');
+ * const sec46 = Temporal.ZonedDateTime.from('2025-01-20T14:30:46Z[UTC]');
+ *
+ * isSameSecond(sec45, sec46); // false
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Different timezones - compares their local seconds
+ * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123-05:00[America/New_York]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.987+09:00[Asia/Tokyo]');
+ *
+ * // Same instant, different local seconds from each person's perspective
+ * isSameSecond(ny, tokyo); // false (14:30:45 in NY, 04:30:45 in Tokyo)
+ *
+ * // Convert to UTC to compare in UTC timezone
+ * isSameSecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45 in UTC)
+ *
+ * // Convert to NY timezone to compare from NY perspective
+ * isSameSecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45 in NY)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Instant inputs are converted to UTC
+ * const instant1 = Temporal.Instant.from('2025-01-20T14:30:45.123Z');
+ * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.999Z');
+ *
+ * isSameSecond(instant1, instant2); // true (both 14:30:45 in UTC)
+ * ```
+ */
+export declare function isSameSecond(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
+//# sourceMappingURL=isSameSecond.d.ts.map

package/dist/isSameSecond.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameSecond.d.ts","sourceRoot":"","sources":["../src/isSameSecond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAI,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAYT"}

package/dist/isSameSecond.js

@@ -0,0 +1,8 @@
+import {
+  isSameSecond
+} from "./chunk-CY746ZUQ.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  isSameSecond
+};
+//# sourceMappingURL=isSameSecond.js.map

package/dist/isSameSecond.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/isSameSecond.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=isSameSecond.test.d.ts.map

package/dist/isSameSecond.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameSecond.test.d.ts","sourceRoot":"","sources":["../src/isSameSecond.test.ts"],"names":[],"mappings":""}

package/dist/isSameWeek.d.ts

@@ -0,0 +1,72 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns true if both datetimes fall in the same ISO 8601 week.
+ * Uses ISO week numbering where weeks start on Monday and the first week
+ * of the year is the week containing January 4th.
+ *
+ * Compares the yearOfWeek and weekOfYear fields directly.
+ *
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their
+ * timezone is preserved. Convert to a common timezone before calling if
+ * you need to compare from a specific perspective.
+ *
+ * @param date1 - First datetime (Instant or ZonedDateTime)
+ * @param date2 - Second datetime (Instant or ZonedDateTime)
+ * @returns true if both dates are in the same ISO week, false otherwise
+ *
+ * @example
+ * ```ts
+ * // Same timezone, same week (both in week 4 of 2025)
+ * const monday = Temporal.ZonedDateTime.from('2025-01-20T08:00:00Z[UTC]'); // Monday, Week 4
+ * const sunday = Temporal.ZonedDateTime.from('2025-01-26T23:59:59Z[UTC]'); // Sunday, Week 4
+ *
+ * isSameWeek(monday, sunday); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Same timezone, different weeks
+ * const week3 = Temporal.ZonedDateTime.from('2025-01-19T23:59:59Z[UTC]'); // Sunday, Week 3
+ * const week4 = Temporal.ZonedDateTime.from('2025-01-20T00:00:00Z[UTC]'); // Monday, Week 4
+ *
+ * isSameWeek(week3, week4); // false
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Different timezones - compares their local calendar weeks
+ * const ny = Temporal.ZonedDateTime.from('2025-01-26T23:00:00-05:00[America/New_York]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-27T13:00:00+09:00[Asia/Tokyo]');
+ *
+ * // Same instant, different local weeks from each person's perspective
+ * isSameWeek(ny, tokyo); // false (Week 4 Sun in NY, Week 5 Mon in Tokyo)
+ *
+ * // Convert to UTC to compare in UTC timezone
+ * isSameWeek(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both Week 5 in UTC)
+ *
+ * // Convert to NY timezone to compare from NY perspective
+ * isSameWeek(ny, tokyo.withTimeZone('America/New_York')); // true (both Week 4 in NY)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Instant inputs are converted to UTC
+ * const instant1 = Temporal.Instant.from('2025-01-20T00:00:00Z'); // Monday, Week 4
+ * const instant2 = Temporal.Instant.from('2025-01-26T23:59:59Z'); // Sunday, Week 4
+ *
+ * isSameWeek(instant1, instant2); // true (both Week 4 2025 in UTC)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // ISO week years can differ from calendar years
+ * // December 29, 2024 is in Week 52 of 2024
+ * const dec29 = Temporal.ZonedDateTime.from('2024-12-29T12:00:00Z[UTC]');
+ * // January 5, 2025 is in Week 1 of 2025
+ * const jan5 = Temporal.ZonedDateTime.from('2025-01-05T12:00:00Z[UTC]');
+ *
+ * isSameWeek(dec29, jan5); // false (different ISO weeks)
+ * ```
+ */
+export declare function isSameWeek(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
+//# sourceMappingURL=isSameWeek.d.ts.map

package/dist/isSameWeek.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameWeek.d.ts","sourceRoot":"","sources":["../src/isSameWeek.ts"],"names":[],"mappings":"AAAA,OAAO,KAAI,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAQT"}

package/dist/isSameWeek.js

@@ -0,0 +1,8 @@
+import {
+  isSameWeek
+} from "./chunk-JOD4ATPE.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  isSameWeek
+};
+//# sourceMappingURL=isSameWeek.js.map

package/dist/isSameWeek.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/isSameWeek.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=isSameWeek.test.d.ts.map

package/dist/isSameWeek.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameWeek.test.d.ts","sourceRoot":"","sources":["../src/isSameWeek.test.ts"],"names":[],"mappings":""}

package/dist/isSameYear.d.ts

@@ -0,0 +1,58 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Returns true if both datetimes fall in the same calendar year.
+ * Compares the year field directly.
+ *
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their
+ * timezone is preserved. Convert to a common timezone before calling if
+ * you need to compare from a specific perspective.
+ *
+ * @param date1 - First datetime (Instant or ZonedDateTime)
+ * @param date2 - Second datetime (Instant or ZonedDateTime)
+ * @returns true if both dates are in the same calendar year, false otherwise
+ *
+ * @example
+ * ```ts
+ * // Same timezone, same year
+ * const jan = Temporal.ZonedDateTime.from('2025-01-20T08:00:00Z[UTC]');
+ * const dec = Temporal.ZonedDateTime.from('2025-12-31T23:59:59Z[UTC]');
+ *
+ * isSameYear(jan, dec); // true
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Same timezone, different years
+ * const endOf2024 = Temporal.ZonedDateTime.from('2024-12-31T23:59:59Z[UTC]');
+ * const startOf2025 = Temporal.ZonedDateTime.from('2025-01-01T00:00:00Z[UTC]');
+ *
+ * isSameYear(endOf2024, startOf2025); // false
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Different timezones - compares their local calendar years
+ * const ny = Temporal.ZonedDateTime.from('2024-12-31T23:00:00-05:00[America/New_York]');
+ * const tokyo = Temporal.ZonedDateTime.from('2025-01-01T13:00:00+09:00[Asia/Tokyo]');
+ *
+ * // Same instant, different calendar years from each person's perspective
+ * isSameYear(ny, tokyo); // false (2024 in NY, 2025 in Tokyo)
+ *
+ * // Convert to UTC to compare in UTC timezone
+ * isSameYear(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 2025 in UTC)
+ *
+ * // Convert to NY timezone to compare from NY perspective
+ * isSameYear(ny, tokyo.withTimeZone('America/New_York')); // true (both 2024 in NY)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Instant inputs are converted to UTC
+ * const instant1 = Temporal.Instant.from('2025-01-01T00:00:00Z');
+ * const instant2 = Temporal.Instant.from('2025-12-31T23:59:59Z');
+ *
+ * isSameYear(instant1, instant2); // true (both 2025 in UTC)
+ * ```
+ */
+export declare function isSameYear(date1: Temporal.Instant | Temporal.ZonedDateTime, date2: Temporal.Instant | Temporal.ZonedDateTime): boolean;
+//# sourceMappingURL=isSameYear.d.ts.map

package/dist/isSameYear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameYear.d.ts","sourceRoot":"","sources":["../src/isSameYear.ts"],"names":[],"mappings":"AAAA,OAAO,KAAI,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,GAC/C,OAAO,CAKT"}

package/dist/isSameYear.js

@@ -0,0 +1,8 @@
+import {
+  isSameYear
+} from "./chunk-VLZ3HQQA.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  isSameYear
+};
+//# sourceMappingURL=isSameYear.js.map

package/dist/isSameYear.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/isSameYear.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=isSameYear.test.d.ts.map

package/dist/isSameYear.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSameYear.test.d.ts","sourceRoot":"","sources":["../src/isSameYear.test.ts"],"names":[],"mappings":""}

package/dist/subDays.d.ts

@@ -0,0 +1,20 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Subtracts the specified number of days from a datetime.
+ *
+ * This is a convenience wrapper around addDays with negated value.
+ * Properly handles DST transitions and calendar edge cases through Temporal API.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param days - Number of days to subtract
+ * @returns ZonedDateTime with days subtracted, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * const instant = Temporal.Instant.from('2025-01-25T12:00:00Z');
+ * const result = subDays(instant, 5);
+ * // 2025-01-20T12:00:00Z[UTC] (5 days earlier)
+ * ```
+ */
+export declare function subDays(input: Temporal.Instant | Temporal.ZonedDateTime, days: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=subDays.d.ts.map

package/dist/subDays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subDays.d.ts","sourceRoot":"","sources":["../src/subDays.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,IAAI,EAAE,MAAM,GACX,QAAQ,CAAC,aAAa,CAExB"}

package/dist/subDays.js

@@ -0,0 +1,9 @@
+import {
+  subDays
+} from "./chunk-YKBP3G7L.js";
+import "./chunk-L4SVABDH.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  subDays
+};
+//# sourceMappingURL=subDays.js.map

package/dist/subDays.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/subDays.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subDays.test.d.ts.map

package/dist/subDays.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subDays.test.d.ts","sourceRoot":"","sources":["../src/subDays.test.ts"],"names":[],"mappings":""}

package/dist/subHours.d.ts

@@ -0,0 +1,20 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Subtracts the specified number of hours from a datetime.
+ *
+ * This is a convenience wrapper around addHours with negated value.
+ * Properly handles DST transitions through Temporal API.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param hours - Number of hours to subtract
+ * @returns ZonedDateTime with hours subtracted, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * const instant = Temporal.Instant.from('2025-01-20T15:00:00Z');
+ * const result = subHours(instant, 3);
+ * // 2025-01-20T12:00:00Z[UTC] (3 hours earlier)
+ * ```
+ */
+export declare function subHours(input: Temporal.Instant | Temporal.ZonedDateTime, hours: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=subHours.d.ts.map

package/dist/subHours.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subHours.d.ts","sourceRoot":"","sources":["../src/subHours.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,KAAK,EAAE,MAAM,GACZ,QAAQ,CAAC,aAAa,CAExB"}

package/dist/subHours.js

@@ -0,0 +1,9 @@
+import {
+  subHours
+} from "./chunk-XW5MLXX5.js";
+import "./chunk-4NJMCCUM.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  subHours
+};
+//# sourceMappingURL=subHours.js.map

package/dist/subHours.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/subHours.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subHours.test.d.ts.map

package/dist/subHours.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subHours.test.d.ts","sourceRoot":"","sources":["../src/subHours.test.ts"],"names":[],"mappings":""}

package/dist/subMicroseconds.d.ts

@@ -0,0 +1,19 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Subtracts the specified number of microseconds from a datetime.
+ *
+ * This is a convenience wrapper around addMicroseconds with negated value.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param microseconds - Number of microseconds to subtract
+ * @returns ZonedDateTime with microseconds subtracted, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * const instant = Temporal.Instant.from('2025-01-20T12:00:00.001Z');
+ * const result = subMicroseconds(instant, 500);
+ * // 2025-01-20T12:00:00.000500Z[UTC] (500 microseconds earlier)
+ * ```
+ */
+export declare function subMicroseconds(input: Temporal.Instant | Temporal.ZonedDateTime, microseconds: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=subMicroseconds.d.ts.map

package/dist/subMicroseconds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subMicroseconds.d.ts","sourceRoot":"","sources":["../src/subMicroseconds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,YAAY,EAAE,MAAM,GACnB,QAAQ,CAAC,aAAa,CAExB"}

package/dist/subMicroseconds.js

@@ -0,0 +1,9 @@
+import {
+  subMicroseconds
+} from "./chunk-BQBLSXK2.js";
+import "./chunk-V27NUBXQ.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  subMicroseconds
+};
+//# sourceMappingURL=subMicroseconds.js.map

package/dist/subMicroseconds.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/subMicroseconds.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subMicroseconds.test.d.ts.map

package/dist/subMicroseconds.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subMicroseconds.test.d.ts","sourceRoot":"","sources":["../src/subMicroseconds.test.ts"],"names":[],"mappings":""}

package/dist/subMilliseconds.d.ts

@@ -0,0 +1,19 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Subtracts the specified number of milliseconds from a datetime.
+ *
+ * This is a convenience wrapper around addMilliseconds with negated value.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param milliseconds - Number of milliseconds to subtract
+ * @returns ZonedDateTime with milliseconds subtracted, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * const instant = Temporal.Instant.from('2025-01-20T12:00:00.500Z');
+ * const result = subMilliseconds(instant, 250);
+ * // 2025-01-20T12:00:00.250Z[UTC] (250 milliseconds earlier)
+ * ```
+ */
+export declare function subMilliseconds(input: Temporal.Instant | Temporal.ZonedDateTime, milliseconds: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=subMilliseconds.d.ts.map

package/dist/subMilliseconds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subMilliseconds.d.ts","sourceRoot":"","sources":["../src/subMilliseconds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,YAAY,EAAE,MAAM,GACnB,QAAQ,CAAC,aAAa,CAExB"}

package/dist/subMilliseconds.js

@@ -0,0 +1,9 @@
+import {
+  subMilliseconds
+} from "./chunk-HDBH7RTY.js";
+import "./chunk-A5VVBYNT.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  subMilliseconds
+};
+//# sourceMappingURL=subMilliseconds.js.map

package/dist/subMilliseconds.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/subMilliseconds.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subMilliseconds.test.d.ts.map

package/dist/subMilliseconds.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subMilliseconds.test.d.ts","sourceRoot":"","sources":["../src/subMilliseconds.test.ts"],"names":[],"mappings":""}

package/dist/subMinutes.d.ts

@@ -0,0 +1,19 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Subtracts the specified number of minutes from a datetime.
+ *
+ * This is a convenience wrapper around addMinutes with negated value.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param minutes - Number of minutes to subtract
+ * @returns ZonedDateTime with minutes subtracted, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * const instant = Temporal.Instant.from('2025-01-20T12:30:00Z');
+ * const result = subMinutes(instant, 15);
+ * // 2025-01-20T12:15:00Z[UTC] (15 minutes earlier)
+ * ```
+ */
+export declare function subMinutes(input: Temporal.Instant | Temporal.ZonedDateTime, minutes: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=subMinutes.d.ts.map

package/dist/subMinutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subMinutes.d.ts","sourceRoot":"","sources":["../src/subMinutes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,OAAO,EAAE,MAAM,GACd,QAAQ,CAAC,aAAa,CAExB"}

package/dist/subMinutes.js

@@ -0,0 +1,9 @@
+import {
+  subMinutes
+} from "./chunk-J6G2I2TU.js";
+import "./chunk-2XHAHSB6.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  subMinutes
+};
+//# sourceMappingURL=subMinutes.js.map

package/dist/subMinutes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/subMinutes.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subMinutes.test.d.ts.map

package/dist/subMinutes.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subMinutes.test.d.ts","sourceRoot":"","sources":["../src/subMinutes.test.ts"],"names":[],"mappings":""}

package/dist/subMonths.d.ts

@@ -0,0 +1,20 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Subtracts the specified number of months from a datetime.
+ *
+ * This is a convenience wrapper around addMonths with negated value.
+ * Properly handles month-end dates and calendar edge cases through Temporal API.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param months - Number of months to subtract
+ * @returns ZonedDateTime with months subtracted, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * const instant = Temporal.Instant.from('2025-04-20T12:00:00Z');
+ * const result = subMonths(instant, 3);
+ * // 2025-01-20T12:00:00Z[UTC] (3 months earlier)
+ * ```
+ */
+export declare function subMonths(input: Temporal.Instant | Temporal.ZonedDateTime, months: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=subMonths.d.ts.map

package/dist/subMonths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subMonths.d.ts","sourceRoot":"","sources":["../src/subMonths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,MAAM,EAAE,MAAM,GACb,QAAQ,CAAC,aAAa,CAExB"}

package/dist/subMonths.js

@@ -0,0 +1,9 @@
+import {
+  subMonths
+} from "./chunk-52NEOY34.js";
+import "./chunk-7ATM7AXL.js";
+import "./chunk-MJSZNWCV.js";
+export {
+  subMonths
+};
+//# sourceMappingURL=subMonths.js.map

package/dist/subMonths.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/subMonths.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subMonths.test.d.ts.map

package/dist/subMonths.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subMonths.test.d.ts","sourceRoot":"","sources":["../src/subMonths.test.ts"],"names":[],"mappings":""}