@gobrand/tiempo 2.2.2 → 2.3.0

package/dist/addMonths.d.ts

@@ -0,0 +1,37 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Adds the specified number of months to a datetime.
+ *
+ * Properly handles month-end dates and calendar edge cases through Temporal API.
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param months - Number of months to add (can be negative to subtract)
+ * @returns ZonedDateTime with months added, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * // From Instant (always UTC)
+ * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ * const result = addMonths(instant, 3);
+ * // 2025-04-20T12:00:00Z[UTC] (3 months later)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // From ZonedDateTime (preserves timezone)
+ * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');
+ * const result = addMonths(zoned, 6);
+ * // 2025-07-20T15:30:00-04:00[America/New_York]
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Month-end handling
+ * const instant = Temporal.Instant.from('2025-01-31T12:00:00Z');
+ * const result = addMonths(instant, 1);
+ * // 2025-02-28T12:00:00Z[UTC] (Jan 31 → Feb 28)
+ * ```
+ */
+export declare function addMonths(input: Temporal.Instant | Temporal.ZonedDateTime, months: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=addMonths.d.ts.map

package/dist/addMonths.d.ts.map

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

package/dist/addMonths.js

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

package/dist/addMonths.js.map

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

package/dist/addMonths.test.d.ts

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

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

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

package/dist/addNanoseconds.d.ts

@@ -0,0 +1,36 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Adds the specified number of nanoseconds to a datetime.
+ *
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param nanoseconds - Number of nanoseconds to add (can be negative to subtract)
+ * @returns ZonedDateTime with nanoseconds added, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * // From Instant (always UTC)
+ * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ * const result = addNanoseconds(instant, 500);
+ * // 2025-01-20T12:00:00.000000500Z[UTC] (500 nanoseconds later)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // From ZonedDateTime (preserves timezone)
+ * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');
+ * const result = addNanoseconds(zoned, 1000);
+ * // 2025-01-20T15:30:00.000001-05:00[America/New_York]
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Negative values subtract nanoseconds
+ * const instant = Temporal.Instant.from('2025-01-20T12:00:00.000001Z');
+ * const result = addNanoseconds(instant, -500);
+ * // 2025-01-20T12:00:00.000000500Z[UTC] (500 nanoseconds earlier)
+ * ```
+ */
+export declare function addNanoseconds(input: Temporal.Instant | Temporal.ZonedDateTime, nanoseconds: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=addNanoseconds.d.ts.map

package/dist/addNanoseconds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addNanoseconds.d.ts","sourceRoot":"","sources":["../src/addNanoseconds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,aAAa,EAChD,WAAW,EAAE,MAAM,GAClB,QAAQ,CAAC,aAAa,CAGxB"}

package/dist/addNanoseconds.js

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

package/dist/addNanoseconds.js.map

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

package/dist/addNanoseconds.test.d.ts

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

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

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

package/dist/addSeconds.d.ts

@@ -0,0 +1,36 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Adds the specified number of seconds to a datetime.
+ *
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param seconds - Number of seconds to add (can be negative to subtract)
+ * @returns ZonedDateTime with seconds added, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * // From Instant (always UTC)
+ * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ * const result = addSeconds(instant, 45);
+ * // 2025-01-20T12:00:45Z[UTC] (45 seconds later)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // From ZonedDateTime (preserves timezone)
+ * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');
+ * const result = addSeconds(zoned, 3600);
+ * // 2025-01-20T16:30:00-05:00[America/New_York]
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Negative values subtract seconds
+ * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ * const result = addSeconds(instant, -30);
+ * // 2025-01-20T11:59:30Z[UTC] (30 seconds earlier)
+ * ```
+ */
+export declare function addSeconds(input: Temporal.Instant | Temporal.ZonedDateTime, seconds: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=addSeconds.d.ts.map

package/dist/addSeconds.d.ts.map

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

package/dist/addSeconds.js

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

package/dist/addSeconds.js.map

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

package/dist/addSeconds.test.d.ts

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

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

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

package/dist/addWeeks.d.ts

@@ -0,0 +1,37 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Adds the specified number of weeks to a datetime.
+ *
+ * Properly handles DST transitions and calendar edge cases through Temporal API.
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param weeks - Number of weeks to add (can be negative to subtract)
+ * @returns ZonedDateTime with weeks added, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * // From Instant (always UTC)
+ * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ * const result = addWeeks(instant, 2);
+ * // 2025-02-03T12:00:00Z[UTC] (2 weeks later)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // From ZonedDateTime (preserves timezone)
+ * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');
+ * const result = addWeeks(zoned, 2);
+ * // 2025-02-03T15:30:00-05:00[America/New_York]
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Negative values subtract weeks
+ * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ * const result = addWeeks(instant, -1);
+ * // 2025-01-13T12:00:00Z[UTC] (1 week earlier)
+ * ```
+ */
+export declare function addWeeks(input: Temporal.Instant | Temporal.ZonedDateTime, weeks: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=addWeeks.d.ts.map

package/dist/addWeeks.d.ts.map

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

package/dist/addWeeks.js

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

package/dist/addWeeks.js.map

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

package/dist/addWeeks.test.d.ts

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

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

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

package/dist/addYears.d.ts

@@ -0,0 +1,37 @@
+import type { Temporal } from '@js-temporal/polyfill';
+/**
+ * Adds the specified number of years to a datetime.
+ *
+ * Properly handles leap years and calendar edge cases through Temporal API.
+ * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.
+ *
+ * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime
+ * @param years - Number of years to add (can be negative to subtract)
+ * @returns ZonedDateTime with years added, in the same timezone as input
+ *
+ * @example
+ * ```ts
+ * // From Instant (always UTC)
+ * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');
+ * const result = addYears(instant, 2);
+ * // 2027-01-20T12:00:00Z[UTC] (2 years later)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // From ZonedDateTime (preserves timezone)
+ * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');
+ * const result = addYears(zoned, 1);
+ * // 2026-01-20T15:30:00-05:00[America/New_York]
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Leap year handling
+ * const instant = Temporal.Instant.from('2024-02-29T12:00:00Z');
+ * const result = addYears(instant, 1);
+ * // 2025-02-28T12:00:00Z[UTC] (Feb 29 → Feb 28)
+ * ```
+ */
+export declare function addYears(input: Temporal.Instant | Temporal.ZonedDateTime, years: number): Temporal.ZonedDateTime;
+//# sourceMappingURL=addYears.d.ts.map

package/dist/addYears.d.ts.map

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

package/dist/addYears.js

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

package/dist/addYears.js.map

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

package/dist/addYears.test.d.ts

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

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

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

package/dist/chunk-2XHAHSB6.js

@@ -0,0 +1,14 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/addMinutes.ts
+function addMinutes(input, minutes) {
+  const zonedDateTime = normalizeTemporalInput(input);
+  return zonedDateTime.add({ minutes });
+}
+
+export {
+  addMinutes
+};
+//# sourceMappingURL=chunk-2XHAHSB6.js.map

package/dist/chunk-2XHAHSB6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addMinutes.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of minutes to a datetime.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param minutes - Number of minutes to add (can be negative to subtract)\n * @returns ZonedDateTime with minutes added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addMinutes(instant, 30);\n * // 2025-01-20T12:30:00Z[UTC] (30 minutes later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addMinutes(zoned, 90);\n * // 2025-01-20T17:00:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract minutes\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addMinutes(instant, -15);\n * // 2025-01-20T11:45:00Z[UTC] (15 minutes earlier)\n * ```\n */\nexport function addMinutes(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  minutes: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ minutes });\n}\n"],"mappings":";;;;;AAoCO,SAAS,WACd,OACA,SACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,QAAQ,CAAC;AACtC;","names":[]}

package/dist/chunk-4NJMCCUM.js

@@ -0,0 +1,14 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/addHours.ts
+function addHours(input, hours) {
+  const zonedDateTime = normalizeTemporalInput(input);
+  return zonedDateTime.add({ hours });
+}
+
+export {
+  addHours
+};
+//# sourceMappingURL=chunk-4NJMCCUM.js.map

package/dist/chunk-4NJMCCUM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addHours.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of hours to a datetime.\n *\n * Properly handles DST transitions through Temporal API.\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param hours - Number of hours to add (can be negative to subtract)\n * @returns ZonedDateTime with hours added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addHours(instant, 3);\n * // 2025-01-20T15:00:00Z[UTC] (3 hours later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addHours(zoned, 24);\n * // 2025-01-21T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract hours\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addHours(instant, -5);\n * // 2025-01-20T07:00:00Z[UTC] (5 hours earlier)\n * ```\n */\nexport function addHours(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  hours: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ hours });\n}\n"],"mappings":";;;;;AAqCO,SAAS,SACd,OACA,OACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,MAAM,CAAC;AACpC;","names":[]}

package/dist/chunk-52NEOY34.js

@@ -0,0 +1,13 @@
+import {
+  addMonths
+} from "./chunk-7ATM7AXL.js";
+
+// src/subMonths.ts
+function subMonths(input, months) {
+  return addMonths(input, -months);
+}
+
+export {
+  subMonths
+};
+//# sourceMappingURL=chunk-52NEOY34.js.map

package/dist/chunk-52NEOY34.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subMonths.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { addMonths } from './addMonths';\n\n/**\n * Subtracts the specified number of months from a datetime.\n *\n * This is a convenience wrapper around addMonths with negated value.\n * Properly handles month-end dates and calendar edge cases through Temporal API.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param months - Number of months to subtract\n * @returns ZonedDateTime with months subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-04-20T12:00:00Z');\n * const result = subMonths(instant, 3);\n * // 2025-01-20T12:00:00Z[UTC] (3 months earlier)\n * ```\n */\nexport function subMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  months: number\n): Temporal.ZonedDateTime {\n  return addMonths(input, -months);\n}\n"],"mappings":";;;;;AAoBO,SAAS,UACd,OACA,QACwB;AACxB,SAAO,UAAU,OAAO,CAAC,MAAM;AACjC;","names":[]}

package/dist/chunk-7ATM7AXL.js

@@ -0,0 +1,14 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/addMonths.ts
+function addMonths(input, months) {
+  const zonedDateTime = normalizeTemporalInput(input);
+  return zonedDateTime.add({ months });
+}
+
+export {
+  addMonths
+};
+//# sourceMappingURL=chunk-7ATM7AXL.js.map

package/dist/chunk-7ATM7AXL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addMonths.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of months to a datetime.\n *\n * Properly handles month-end dates and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param months - Number of months to add (can be negative to subtract)\n * @returns ZonedDateTime with months added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addMonths(instant, 3);\n * // 2025-04-20T12:00:00Z[UTC] (3 months later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addMonths(zoned, 6);\n * // 2025-07-20T15:30:00-04:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Month-end handling\n * const instant = Temporal.Instant.from('2025-01-31T12:00:00Z');\n * const result = addMonths(instant, 1);\n * // 2025-02-28T12:00:00Z[UTC] (Jan 31 → Feb 28)\n * ```\n */\nexport function addMonths(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  months: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ months });\n}\n"],"mappings":";;;;;AAqCO,SAAS,UACd,OACA,QACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,OAAO,CAAC;AACrC;","names":[]}

package/dist/chunk-A5VVBYNT.js

@@ -0,0 +1,14 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/addMilliseconds.ts
+function addMilliseconds(input, milliseconds) {
+  const zonedDateTime = normalizeTemporalInput(input);
+  return zonedDateTime.add({ milliseconds });
+}
+
+export {
+  addMilliseconds
+};
+//# sourceMappingURL=chunk-A5VVBYNT.js.map

package/dist/chunk-A5VVBYNT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addMilliseconds.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of milliseconds to a datetime.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param milliseconds - Number of milliseconds to add (can be negative to subtract)\n * @returns ZonedDateTime with milliseconds added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addMilliseconds(instant, 500);\n * // 2025-01-20T12:00:00.500Z[UTC] (500 milliseconds later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addMilliseconds(zoned, 1500);\n * // 2025-01-20T15:30:01.500-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract milliseconds\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.500Z');\n * const result = addMilliseconds(instant, -250);\n * // 2025-01-20T12:00:00.250Z[UTC] (250 milliseconds earlier)\n * ```\n */\nexport function addMilliseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  milliseconds: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ milliseconds });\n}\n"],"mappings":";;;;;AAoCO,SAAS,gBACd,OACA,cACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,aAAa,CAAC;AAC3C;","names":[]}

package/dist/chunk-ADQTZVMH.js

@@ -0,0 +1,15 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/isSameMonth.ts
+function isSameMonth(date1, date2) {
+  const zoned1 = normalizeTemporalInput(date1);
+  const zoned2 = normalizeTemporalInput(date2);
+  return zoned1.year === zoned2.year && zoned1.month === zoned2.month;
+}
+
+export {
+  isSameMonth
+};
+//# sourceMappingURL=chunk-ADQTZVMH.js.map

package/dist/chunk-ADQTZVMH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameMonth.ts"],"sourcesContent":["import type{ Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall in the same calendar month and year.\n * Compares the year and month fields directly.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their\n * timezone is preserved. Convert to a common timezone before calling if\n * you need to compare from a specific perspective.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if both dates are in the same calendar month, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same month\n * const start = Temporal.ZonedDateTime.from('2025-01-01T08:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-31T23:59:59Z[UTC]');\n *\n * isSameMonth(start, end); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different months\n * const jan = Temporal.ZonedDateTime.from('2025-01-31T23:59:59Z[UTC]');\n * const feb = Temporal.ZonedDateTime.from('2025-02-01T00:00:00Z[UTC]');\n *\n * isSameMonth(jan, feb); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local calendar months\n * const ny = Temporal.ZonedDateTime.from('2025-01-31T23:00:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-02-01T13:00:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different calendar months from each person's perspective\n * isSameMonth(ny, tokyo); // false (Jan in NY, Feb in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameMonth(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both Feb in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameMonth(ny, tokyo.withTimeZone('America/New_York')); // true (both Jan in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-01T00:00:00Z');\n * const instant2 = Temporal.Instant.from('2025-01-31T23:59:59Z');\n *\n * isSameMonth(instant1, instant2); // true (both Jan 2025 in UTC)\n * ```\n */\nexport function isSameMonth(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned1 = normalizeTemporalInput(date1);\n  const zoned2 = normalizeTemporalInput(date2);\n\n  return zoned1.year === zoned2.year && zoned1.month === zoned2.month;\n}\n"],"mappings":";;;;;AA0DO,SAAS,YACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SAAO,OAAO,SAAS,OAAO,QAAQ,OAAO,UAAU,OAAO;AAChE;","names":[]}

package/dist/chunk-AHMKY474.js

@@ -0,0 +1,13 @@
+import {
+  addYears
+} from "./chunk-Q2F3HEXB.js";
+
+// src/subYears.ts
+function subYears(input, years) {
+  return addYears(input, -years);
+}
+
+export {
+  subYears
+};
+//# sourceMappingURL=chunk-AHMKY474.js.map

package/dist/chunk-AHMKY474.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subYears.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { addYears } from './addYears';\n\n/**\n * Subtracts the specified number of years from a datetime.\n *\n * This is a convenience wrapper around addYears with negated value.\n * Properly handles leap years and calendar edge cases through Temporal API.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param years - Number of years to subtract\n * @returns ZonedDateTime with years subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = subYears(instant, 2);\n * // 2023-01-20T12:00:00Z[UTC] (2 years earlier)\n * ```\n */\nexport function subYears(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  years: number\n): Temporal.ZonedDateTime {\n  return addYears(input, -years);\n}\n"],"mappings":";;;;;AAoBO,SAAS,SACd,OACA,OACwB;AACxB,SAAO,SAAS,OAAO,CAAC,KAAK;AAC/B;","names":[]}

package/dist/chunk-BH2YB4MV.js

@@ -0,0 +1,13 @@
+import {
+  addSeconds
+} from "./chunk-NRD5HRZV.js";
+
+// src/subSeconds.ts
+function subSeconds(input, seconds) {
+  return addSeconds(input, -seconds);
+}
+
+export {
+  subSeconds
+};
+//# sourceMappingURL=chunk-BH2YB4MV.js.map

package/dist/chunk-BH2YB4MV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subSeconds.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { addSeconds } from './addSeconds';\n\n/**\n * Subtracts the specified number of seconds from a datetime.\n *\n * This is a convenience wrapper around addSeconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param seconds - Number of seconds to subtract\n * @returns ZonedDateTime with seconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:45Z');\n * const result = subSeconds(instant, 30);\n * // 2025-01-20T12:00:15Z[UTC] (30 seconds earlier)\n * ```\n */\nexport function subSeconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  seconds: number\n): Temporal.ZonedDateTime {\n  return addSeconds(input, -seconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,WACd,OACA,SACwB;AACxB,SAAO,WAAW,OAAO,CAAC,OAAO;AACnC;","names":[]}

package/dist/chunk-BQBLSXK2.js

@@ -0,0 +1,13 @@
+import {
+  addMicroseconds
+} from "./chunk-V27NUBXQ.js";
+
+// src/subMicroseconds.ts
+function subMicroseconds(input, microseconds) {
+  return addMicroseconds(input, -microseconds);
+}
+
+export {
+  subMicroseconds
+};
+//# sourceMappingURL=chunk-BQBLSXK2.js.map

package/dist/chunk-BQBLSXK2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subMicroseconds.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { addMicroseconds } from './addMicroseconds';\n\n/**\n * Subtracts the specified number of microseconds from a datetime.\n *\n * This is a convenience wrapper around addMicroseconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param microseconds - Number of microseconds to subtract\n * @returns ZonedDateTime with microseconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.001Z');\n * const result = subMicroseconds(instant, 500);\n * // 2025-01-20T12:00:00.000500Z[UTC] (500 microseconds earlier)\n * ```\n */\nexport function subMicroseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  microseconds: number\n): Temporal.ZonedDateTime {\n  return addMicroseconds(input, -microseconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,gBACd,OACA,cACwB;AACxB,SAAO,gBAAgB,OAAO,CAAC,YAAY;AAC7C;","names":[]}

package/dist/chunk-CY746ZUQ.js

@@ -0,0 +1,15 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/isSameSecond.ts
+function isSameSecond(date1, date2) {
+  const zoned1 = normalizeTemporalInput(date1);
+  const zoned2 = normalizeTemporalInput(date2);
+  return zoned1.year === zoned2.year && zoned1.month === zoned2.month && zoned1.day === zoned2.day && zoned1.hour === zoned2.hour && zoned1.minute === zoned2.minute && zoned1.second === zoned2.second;
+}
+
+export {
+  isSameSecond
+};
+//# sourceMappingURL=chunk-CY746ZUQ.js.map

package/dist/chunk-CY746ZUQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameSecond.ts"],"sourcesContent":["import type{ Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall in the same second.\n * Compares the year, month, day, hour, minute, and second fields directly.\n * Ignores sub-second precision (milliseconds, microseconds, nanoseconds).\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their\n * timezone is preserved. Convert to a common timezone before calling if\n * you need to compare from a specific perspective.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if both dates are in the same second, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same second\n * const time1 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.000Z[UTC]');\n * const time2 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.999Z[UTC]');\n *\n * isSameSecond(time1, time2); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different seconds\n * const sec45 = Temporal.ZonedDateTime.from('2025-01-20T14:30:45Z[UTC]');\n * const sec46 = Temporal.ZonedDateTime.from('2025-01-20T14:30:46Z[UTC]');\n *\n * isSameSecond(sec45, sec46); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local seconds\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:45.123-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:45.987+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local seconds from each person's perspective\n * isSameSecond(ny, tokyo); // false (14:30:45 in NY, 04:30:45 in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameSecond(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:30:45 in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameSecond(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:30:45 in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T14:30:45.123Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:30:45.999Z');\n *\n * isSameSecond(instant1, instant2); // true (both 14:30:45 in UTC)\n * ```\n */\nexport function isSameSecond(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned1 = normalizeTemporalInput(date1);\n  const zoned2 = normalizeTemporalInput(date2);\n\n  return (\n    zoned1.year === zoned2.year &&\n    zoned1.month === zoned2.month &&\n    zoned1.day === zoned2.day &&\n    zoned1.hour === zoned2.hour &&\n    zoned1.minute === zoned2.minute &&\n    zoned1.second === zoned2.second\n  );\n}\n"],"mappings":";;;;;AA2DO,SAAS,aACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SACE,OAAO,SAAS,OAAO,QACvB,OAAO,UAAU,OAAO,SACxB,OAAO,QAAQ,OAAO,OACtB,OAAO,SAAS,OAAO,QACvB,OAAO,WAAW,OAAO,UACzB,OAAO,WAAW,OAAO;AAE7B;","names":[]}

package/dist/chunk-DT2EWLHU.js

@@ -0,0 +1,14 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/addWeeks.ts
+function addWeeks(input, weeks) {
+  const zonedDateTime = normalizeTemporalInput(input);
+  return zonedDateTime.add({ weeks });
+}
+
+export {
+  addWeeks
+};
+//# sourceMappingURL=chunk-DT2EWLHU.js.map

package/dist/chunk-DT2EWLHU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addWeeks.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of weeks to a datetime.\n *\n * Properly handles DST transitions and calendar edge cases through Temporal API.\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param weeks - Number of weeks to add (can be negative to subtract)\n * @returns ZonedDateTime with weeks added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addWeeks(instant, 2);\n * // 2025-02-03T12:00:00Z[UTC] (2 weeks later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addWeeks(zoned, 2);\n * // 2025-02-03T15:30:00-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract weeks\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addWeeks(instant, -1);\n * // 2025-01-13T12:00:00Z[UTC] (1 week earlier)\n * ```\n */\nexport function addWeeks(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  weeks: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ weeks });\n}\n"],"mappings":";;;;;AAqCO,SAAS,SACd,OACA,OACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,MAAM,CAAC;AACpC;","names":[]}

package/dist/chunk-EEQ3REET.js

@@ -0,0 +1,15 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/isSameHour.ts
+function isSameHour(date1, date2) {
+  const zoned1 = normalizeTemporalInput(date1);
+  const zoned2 = normalizeTemporalInput(date2);
+  return zoned1.year === zoned2.year && zoned1.month === zoned2.month && zoned1.day === zoned2.day && zoned1.hour === zoned2.hour;
+}
+
+export {
+  isSameHour
+};
+//# sourceMappingURL=chunk-EEQ3REET.js.map

package/dist/chunk-EEQ3REET.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/isSameHour.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Returns true if both datetimes fall in the same hour.\n * Compares the year, month, day, and hour fields directly.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their\n * timezone is preserved. Convert to a common timezone before calling if\n * you need to compare from a specific perspective.\n *\n * @param date1 - First datetime (Instant or ZonedDateTime)\n * @param date2 - Second datetime (Instant or ZonedDateTime)\n * @returns true if both dates are in the same hour, false otherwise\n *\n * @example\n * ```ts\n * // Same timezone, same hour\n * const start = Temporal.ZonedDateTime.from('2025-01-20T14:00:00Z[UTC]');\n * const end = Temporal.ZonedDateTime.from('2025-01-20T14:59:59.999Z[UTC]');\n *\n * isSameHour(start, end); // true\n * ```\n *\n * @example\n * ```ts\n * // Same timezone, different hours\n * const hour14 = Temporal.ZonedDateTime.from('2025-01-20T14:59:59Z[UTC]');\n * const hour15 = Temporal.ZonedDateTime.from('2025-01-20T15:00:00Z[UTC]');\n *\n * isSameHour(hour14, hour15); // false\n * ```\n *\n * @example\n * ```ts\n * // Different timezones - compares their local hours\n * const ny = Temporal.ZonedDateTime.from('2025-01-20T14:30:00-05:00[America/New_York]');\n * const tokyo = Temporal.ZonedDateTime.from('2025-01-21T04:30:00+09:00[Asia/Tokyo]');\n *\n * // Same instant, different local hours from each person's perspective\n * isSameHour(ny, tokyo); // false (14:xx in NY, 04:xx in Tokyo)\n *\n * // Convert to UTC to compare in UTC timezone\n * isSameHour(ny.withTimeZone('UTC'), tokyo.withTimeZone('UTC')); // true (both 19:xx in UTC)\n *\n * // Convert to NY timezone to compare from NY perspective\n * isSameHour(ny, tokyo.withTimeZone('America/New_York')); // true (both 14:xx in NY)\n * ```\n *\n * @example\n * ```ts\n * // Instant inputs are converted to UTC\n * const instant1 = Temporal.Instant.from('2025-01-20T14:15:30Z');\n * const instant2 = Temporal.Instant.from('2025-01-20T14:45:50Z');\n *\n * isSameHour(instant1, instant2); // true (both 14:xx in UTC)\n * ```\n */\nexport function isSameHour(\n  date1: Temporal.Instant | Temporal.ZonedDateTime,\n  date2: Temporal.Instant | Temporal.ZonedDateTime\n): boolean {\n  const zoned1 = normalizeTemporalInput(date1);\n  const zoned2 = normalizeTemporalInput(date2);\n\n  return (\n    zoned1.year === zoned2.year &&\n    zoned1.month === zoned2.month &&\n    zoned1.day === zoned2.day &&\n    zoned1.hour === zoned2.hour\n  );\n}\n"],"mappings":";;;;;AA0DO,SAAS,WACd,OACA,OACS;AACT,QAAM,SAAS,uBAAuB,KAAK;AAC3C,QAAM,SAAS,uBAAuB,KAAK;AAE3C,SACE,OAAO,SAAS,OAAO,QACvB,OAAO,UAAU,OAAO,SACxB,OAAO,QAAQ,OAAO,OACtB,OAAO,SAAS,OAAO;AAE3B;","names":[]}

package/dist/chunk-EYO2ZJLH.js

@@ -0,0 +1,14 @@
+import {
+  normalizeTemporalInput
+} from "./chunk-MJSZNWCV.js";
+
+// src/addNanoseconds.ts
+function addNanoseconds(input, nanoseconds) {
+  const zonedDateTime = normalizeTemporalInput(input);
+  return zonedDateTime.add({ nanoseconds });
+}
+
+export {
+  addNanoseconds
+};
+//# sourceMappingURL=chunk-EYO2ZJLH.js.map

package/dist/chunk-EYO2ZJLH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/addNanoseconds.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { normalizeTemporalInput } from './shared/normalizeTemporalInput';\n\n/**\n * Adds the specified number of nanoseconds to a datetime.\n *\n * Instant inputs are converted to UTC. For ZonedDateTime inputs, their timezone is preserved.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param nanoseconds - Number of nanoseconds to add (can be negative to subtract)\n * @returns ZonedDateTime with nanoseconds added, in the same timezone as input\n *\n * @example\n * ```ts\n * // From Instant (always UTC)\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00Z');\n * const result = addNanoseconds(instant, 500);\n * // 2025-01-20T12:00:00.000000500Z[UTC] (500 nanoseconds later)\n * ```\n *\n * @example\n * ```ts\n * // From ZonedDateTime (preserves timezone)\n * const zoned = Temporal.ZonedDateTime.from('2025-01-20T15:30:00-05:00[America/New_York]');\n * const result = addNanoseconds(zoned, 1000);\n * // 2025-01-20T15:30:00.000001-05:00[America/New_York]\n * ```\n *\n * @example\n * ```ts\n * // Negative values subtract nanoseconds\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.000001Z');\n * const result = addNanoseconds(instant, -500);\n * // 2025-01-20T12:00:00.000000500Z[UTC] (500 nanoseconds earlier)\n * ```\n */\nexport function addNanoseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  nanoseconds: number\n): Temporal.ZonedDateTime {\n  const zonedDateTime = normalizeTemporalInput(input);\n  return zonedDateTime.add({ nanoseconds });\n}\n"],"mappings":";;;;;AAoCO,SAAS,eACd,OACA,aACwB;AACxB,QAAM,gBAAgB,uBAAuB,KAAK;AAClD,SAAO,cAAc,IAAI,EAAE,YAAY,CAAC;AAC1C;","names":[]}

package/dist/chunk-HDBH7RTY.js

@@ -0,0 +1,13 @@
+import {
+  addMilliseconds
+} from "./chunk-A5VVBYNT.js";
+
+// src/subMilliseconds.ts
+function subMilliseconds(input, milliseconds) {
+  return addMilliseconds(input, -milliseconds);
+}
+
+export {
+  subMilliseconds
+};
+//# sourceMappingURL=chunk-HDBH7RTY.js.map

package/dist/chunk-HDBH7RTY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/subMilliseconds.ts"],"sourcesContent":["import type { Temporal } from '@js-temporal/polyfill';\nimport { addMilliseconds } from './addMilliseconds';\n\n/**\n * Subtracts the specified number of milliseconds from a datetime.\n *\n * This is a convenience wrapper around addMilliseconds with negated value.\n *\n * @param input - A Temporal.Instant (UTC) or Temporal.ZonedDateTime\n * @param milliseconds - Number of milliseconds to subtract\n * @returns ZonedDateTime with milliseconds subtracted, in the same timezone as input\n *\n * @example\n * ```ts\n * const instant = Temporal.Instant.from('2025-01-20T12:00:00.500Z');\n * const result = subMilliseconds(instant, 250);\n * // 2025-01-20T12:00:00.250Z[UTC] (250 milliseconds earlier)\n * ```\n */\nexport function subMilliseconds(\n  input: Temporal.Instant | Temporal.ZonedDateTime,\n  milliseconds: number\n): Temporal.ZonedDateTime {\n  return addMilliseconds(input, -milliseconds);\n}\n"],"mappings":";;;;;AAmBO,SAAS,gBACd,OACA,cACwB;AACxB,SAAO,gBAAgB,OAAO,CAAC,YAAY;AAC7C;","names":[]}