@vielzeug/tempo 1.0.6 → 2.0.0

package/dist/classify.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"classify.cjs","names":[],"sources":["../src/classify.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nimport type { TimeDiffResult, TimeDiffUnit, TimeInput, TimeOptions } from './types';\n\nimport { toInstant, toZoned } from './_convert';\nimport { inferSharedTimeZone, MS_PER_MONTH } from './_tz';\n\n// ─── Threshold sort cache ─────────────────────────────────────────────────────\n\ntype SortedThreshold<K extends string> = { key: K; ms: number }[];\n\nconst THRESHOLD_SORT_CACHE = new WeakMap<object, SortedThreshold<string>>();\n\nfunction getSortedThresholds<K extends string>(thresholds: Record<K, Temporal.DurationLike>): SortedThreshold<K> {\n  const cached = THRESHOLD_SORT_CACHE.get(thresholds);\n\n  if (cached) return cached as SortedThreshold<K>;\n\n  const sorted = (Object.keys(thresholds) as K[])\n    .map((key) => ({ key, ms: durationToMs(thresholds[key]) }))\n    .sort((a, b) => a.ms - b.ms);\n\n  THRESHOLD_SORT_CACHE.set(thresholds, sorted);\n\n  return sorted;\n}\n\n// ─── expires ─────────────────────────────────────────────────────────────────\n\n/**\n * Classifies a date into a user-defined bucket by comparing diff = date − now\n * against the provided thresholds (sorted ascending). Returns the key of the\n * first threshold the diff falls within, or `null` if no threshold matches.\n *\n * Thresholds accept negative durations to classify past dates. The function\n * requires `options.tz` when input is a `PlainDate` or `PlainDateTime`.\n *\n * **Performance:** threshold objects are cached by reference in a `WeakMap`. Define\n * the threshold record at module scope (not inline) so sorting is performed only once\n * per unique object.\n *\n * @example\n * ```ts\n * expires(expiresAt, {\n *   longExpired: { days: -30 },  // more than 30 days in the past\n *   expired:     { days: 0 },    // any past date\n *   critical:    { days: 3 },    // within 3 days\n *   warning:     { days: 14 },   // within 14 days\n *   safe:        { years: 100 }, // catch-all for far future\n * })\n * // → 'longExpired' | 'expired' | 'critical' | 'warning' | 'safe' | null\n * ```\n */\nexport function expires<K extends string>(\n  date: TimeInput,\n  thresholds: Record<K, Temporal.DurationLike>,\n  options: TimeOptions = {},\n  now = Temporal.Now.instant(),\n): K | null {\n  const dateMs = toInstant(date, options).epochMilliseconds;\n  const nowMs = now.epochMilliseconds;\n\n  // diff is positive for future dates, negative for past dates (date − now)\n  const diffMs = dateMs - nowMs;\n\n  for (const { key, ms } of getSortedThresholds(thresholds)) {\n    if (diffMs <= ms) return key;\n  }\n\n  return null;\n}\n\n/** Converts a `DurationLike` to approximate milliseconds for threshold comparison. */\nfunction durationToMs(duration: Temporal.DurationLike): number {\n  const d = Temporal.Duration.from(duration);\n\n  // Use approximate conversions — thresholds are human-defined boundaries, not calendar-precise.\n  return (\n    (d.years ?? 0) * 12 * MS_PER_MONTH +\n    (d.months ?? 0) * MS_PER_MONTH +\n    (d.weeks ?? 0) * 7 * 86_400_000 +\n    (d.days ?? 0) * 86_400_000 +\n    (d.hours ?? 0) * 3_600_000 +\n    (d.minutes ?? 0) * 60_000 +\n    (d.seconds ?? 0) * 1_000 +\n    (d.milliseconds ?? 0) +\n    (d.microseconds ?? 0) / 1_000 +\n    (d.nanoseconds ?? 0) / 1_000_000\n  );\n}\n\n// ─── timeDiff ─────────────────────────────────────────────────────────────────\n\nconst UNIT_ORDER: ReadonlyArray<{ field: keyof Temporal.Duration; unit: TimeDiffUnit }> = [\n  { field: 'years', unit: 'year' },\n  { field: 'months', unit: 'month' },\n  { field: 'weeks', unit: 'week' },\n  { field: 'days', unit: 'day' },\n  { field: 'hours', unit: 'hour' },\n  { field: 'minutes', unit: 'minute' },\n  { field: 'seconds', unit: 'second' },\n  { field: 'milliseconds', unit: 'millisecond' },\n];\n\nfunction sinceZoned(a: Temporal.ZonedDateTime, b: Temporal.ZonedDateTime): Temporal.Duration {\n  return Temporal.ZonedDateTime.compare(a, b) <= 0\n    ? b.since(a, { largestUnit: 'year' })\n    : a.since(b, { largestUnit: 'year' });\n}\n\nfunction pickLargestUnit(duration: Temporal.Duration): TimeDiffResult {\n  for (const { field, unit } of UNIT_ORDER) {\n    const value = Math.abs(duration[field] as number);\n\n    if (value > 0) return { unit, value };\n  }\n\n  return { unit: 'millisecond', value: 0 };\n}\n\n/**\n * Returns the absolute calendar-accurate difference between two dates as a\n * structured `{ unit, value }` in the largest meaningful unit.\n *\n * When `b` is omitted, the current instant is used.\n * Requires `options.tz` when inputs are `PlainDate`, `PlainDateTime`, or plain `Instant` with\n * calendar-unit precision. Throws when timezone cannot be inferred from inputs.\n *\n * @example\n * ```ts\n * timeDiff(\n *   parseInstant('2026-01-01T00:00:00Z'),\n *   parseInstant('2027-03-15T00:00:00Z'),\n * )\n * // { unit: 'year', value: 1 }\n * ```\n */\nexport function timeDiff(a: TimeInput, b?: TimeInput, options: TimeOptions = {}): TimeDiffResult {\n  const end: TimeInput = b ?? Temporal.Now.instant();\n\n  // Fast path: two Instants with no explicit tz — project to UTC for calendar-accurate units.\n  // Instants are absolute and timezone-independent; UTC is the canonical calendar context.\n  if (!options.tz && a instanceof Temporal.Instant && end instanceof Temporal.Instant) {\n    return pickLargestUnit(sinceZoned(a.toZonedDateTimeISO('UTC'), end.toZonedDateTimeISO('UTC')));\n  }\n\n  // Plain inputs or calendar-accurate comparison require a timezone.\n  const tz = inferSharedTimeZone([a, end], options);\n\n  return pickLargestUnit(sinceZoned(toZoned(a, { tz }), toZoned(end, { tz })));\n}\n"],"mappings":"gGAWA,IAAM,EAAuB,IAAI,QAEjC,SAAS,EAAsC,EAAkE,CAC/G,IAAM,EAAS,EAAqB,IAAI,CAAU,EAElD,GAAI,EAAQ,OAAO,EAEnB,IAAM,EAAU,OAAO,KAAK,CAAU,CAAC,CACpC,IAAK,IAAS,CAAE,MAAK,GAAI,EAAa,EAAW,EAAI,CAAE,EAAE,CAAC,CAC1D,MAAM,EAAG,IAAM,EAAE,GAAK,EAAE,EAAE,EAI7B,OAFA,EAAqB,IAAI,EAAY,CAAM,EAEpC,CACT,CA4BA,SAAgB,EACd,EACA,EACA,EAAuB,CAAC,EACxB,EAAM,EAAA,SAAS,IAAI,QAAQ,EACjB,CAKV,IAAM,EAJS,EAAA,UAAU,EAAM,CAAO,CAAC,CAAC,kBAC1B,EAAI,kBAKlB,IAAK,GAAM,CAAE,MAAK,QAAQ,EAAoB,CAAU,EACtD,GAAI,GAAU,EAAI,OAAO,EAG3B,OAAO,IACT,CAGA,SAAS,EAAa,EAAyC,CAC7D,IAAM,EAAI,EAAA,SAAS,SAAS,KAAK,CAAQ,EAGzC,OACG,EAAE,OAAS,GAAK,GAAK,EAAA,cACrB,EAAE,QAAU,GAAK,EAAA,cACjB,EAAE,OAAS,GAAK,EAAI,OACpB,EAAE,MAAQ,GAAK,OACf,EAAE,OAAS,GAAK,MAChB,EAAE,SAAW,GAAK,KAClB,EAAE,SAAW,GAAK,KAClB,EAAE,cAAgB,IAClB,EAAE,cAAgB,GAAK,KACvB,EAAE,aAAe,GAAK,GAE3B,CAIA,IAAM,EAAoF,CACxF,CAAE,MAAO,QAAS,KAAM,MAAO,EAC/B,CAAE,MAAO,SAAU,KAAM,OAAQ,EACjC,CAAE,MAAO,QAAS,KAAM,MAAO,EAC/B,CAAE,MAAO,OAAQ,KAAM,KAAM,EAC7B,CAAE,MAAO,QAAS,KAAM,MAAO,EAC/B,CAAE,MAAO,UAAW,KAAM,QAAS,EACnC,CAAE,MAAO,UAAW,KAAM,QAAS,EACnC,CAAE,MAAO,eAAgB,KAAM,aAAc,CAC/C,EAEA,SAAS,EAAW,EAA2B,EAA8C,CAC3F,OAAO,EAAA,SAAS,cAAc,QAAQ,EAAG,CAAC,GAAK,EAC3C,EAAE,MAAM,EAAG,CAAE,YAAa,MAAO,CAAC,EAClC,EAAE,MAAM,EAAG,CAAE,YAAa,MAAO,CAAC,CACxC,CAEA,SAAS,EAAgB,EAA6C,CACpE,IAAK,GAAM,CAAE,QAAO,UAAU,EAAY,CACxC,IAAM,EAAQ,KAAK,IAAI,EAAS,EAAgB,EAEhD,GAAI,EAAQ,EAAG,MAAO,CAAE,OAAM,OAAM,CACtC,CAEA,MAAO,CAAE,KAAM,cAAe,MAAO,CAAE,CACzC,CAmBA,SAAgB,EAAS,EAAc,EAAe,EAAuB,CAAC,EAAmB,CAC/F,IAAM,EAAiB,GAAK,EAAA,SAAS,IAAI,QAAQ,EAIjD,GAAI,CAAC,EAAQ,IAAM,aAAa,EAAA,SAAS,SAAW,aAAe,EAAA,SAAS,QAC1E,OAAO,EAAgB,EAAW,EAAE,mBAAmB,KAAK,EAAG,EAAI,mBAAmB,KAAK,CAAC,CAAC,EAI/F,IAAM,EAAK,EAAA,oBAAoB,CAAC,EAAG,CAAG,EAAG,CAAO,EAEhD,OAAO,EAAgB,EAAW,EAAA,QAAQ,EAAG,CAAE,IAAG,CAAC,EAAG,EAAA,QAAQ,EAAK,CAAE,IAAG,CAAC,CAAC,CAAC,CAC7E"}
+{"version":3,"file":"classify.cjs","names":[],"sources":["../src/classify.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nimport type {\n  ClassifyExpiryInput,\n  FixedDuration,\n  TimeDiffResult,\n  TimeDiffUnit,\n  TimeInput,\n  TimeZoneOptions,\n} from './types';\n\nimport { toInstant, toZoned } from './_convert';\nimport { inferSharedTimeZone } from './_tz';\nimport { TempoInvalidInputError } from './errors';\n\nconst MILLIS = {\n  day: 86_400_000,\n  hour: 3_600_000,\n  microsecond: 1 / 1_000,\n  millisecond: 1,\n  minute: 60_000,\n  nanosecond: 1 / 1_000_000,\n  second: 1_000,\n  week: 604_800_000,\n} as const;\nconst UNIT_ORDER: ReadonlyArray<{ field: keyof Temporal.Duration; unit: TimeDiffUnit }> = [\n  { field: 'years', unit: 'year' },\n  { field: 'months', unit: 'month' },\n  { field: 'weeks', unit: 'week' },\n  { field: 'days', unit: 'day' },\n  { field: 'hours', unit: 'hour' },\n  { field: 'minutes', unit: 'minute' },\n  { field: 'seconds', unit: 'second' },\n  { field: 'milliseconds', unit: 'millisecond' },\n];\n\n// Expiry classification is elapsed-time math. Calendar months and years are rejected rather than approximated.\nfunction fixedDurationToMilliseconds(input: FixedDuration): number {\n  const duration = Temporal.Duration.from(input);\n\n  if (duration.years || duration.months) {\n    throw new TempoInvalidInputError(\n      'classifyExpiry thresholds cannot contain months or years. Use fixed elapsed-time units.',\n    );\n  }\n\n  return (\n    duration.weeks * MILLIS.week +\n    duration.days * MILLIS.day +\n    duration.hours * MILLIS.hour +\n    duration.minutes * MILLIS.minute +\n    duration.seconds * MILLIS.second +\n    duration.milliseconds +\n    duration.microseconds * MILLIS.microsecond +\n    duration.nanoseconds * MILLIS.nanosecond\n  );\n}\n\nexport function classifyExpiry<K extends string>(input: ClassifyExpiryInput<K>): K | null {\n  const reference = input.relativeTo ?? Temporal.Now.instant();\n  const value = toInstant(input.value, input);\n  const elapsed = value.epochMilliseconds - reference.epochMilliseconds;\n  const thresholds = (Object.entries(input.thresholds) as Array<[K, FixedDuration]>)\n    .map(([key, duration]) => ({ key, max: fixedDurationToMilliseconds(duration) }))\n    .sort((left, right) => left.max - right.max);\n\n  return thresholds.find(({ max }) => elapsed <= max)?.key ?? null;\n}\n\nfunction pickLargestUnit(duration: Temporal.Duration): TimeDiffResult {\n  for (const { field, unit } of UNIT_ORDER) {\n    const value = Math.abs(duration[field] as number);\n\n    if (value > 0) return { unit, value };\n  }\n\n  return { unit: 'millisecond', value: 0 };\n}\n\nexport function timeDiff(\n  a: TimeInput,\n  b: TimeInput = Temporal.Now.instant(),\n  options: TimeZoneOptions = {},\n): TimeDiffResult {\n  if (!options.timeZone && a instanceof Temporal.Instant && b instanceof Temporal.Instant) {\n    const left = a.toZonedDateTimeISO('UTC');\n    const right = b.toZonedDateTimeISO('UTC');\n\n    return pickLargestUnit(\n      Temporal.ZonedDateTime.compare(left, right) <= 0\n        ? right.since(left, { largestUnit: 'year' })\n        : left.since(right, { largestUnit: 'year' }),\n    );\n  }\n\n  const timeZone = inferSharedTimeZone([a, b], options);\n  const left = toZoned(a, { timeZone });\n  const right = toZoned(b, { timeZone });\n\n  return pickLargestUnit(\n    Temporal.ZonedDateTime.compare(left, right) <= 0\n      ? right.since(left, { largestUnit: 'year' })\n      : left.since(right, { largestUnit: 'year' }),\n  );\n}\n"],"mappings":"0HAeA,IAAM,EAAS,CACb,IAAK,MACL,KAAM,KACN,YAAa,EAAI,IACjB,YAAa,EACb,OAAQ,IACR,WAAY,EAAI,IAChB,OAAQ,IACR,KAAM,MACR,EACM,EAAoF,CACxF,CAAE,MAAO,QAAS,KAAM,MAAO,EAC/B,CAAE,MAAO,SAAU,KAAM,OAAQ,EACjC,CAAE,MAAO,QAAS,KAAM,MAAO,EAC/B,CAAE,MAAO,OAAQ,KAAM,KAAM,EAC7B,CAAE,MAAO,QAAS,KAAM,MAAO,EAC/B,CAAE,MAAO,UAAW,KAAM,QAAS,EACnC,CAAE,MAAO,UAAW,KAAM,QAAS,EACnC,CAAE,MAAO,eAAgB,KAAM,aAAc,CAC/C,EAGA,SAAS,EAA4B,EAA8B,CACjE,IAAM,EAAW,EAAA,SAAS,SAAS,KAAK,CAAK,EAE7C,GAAI,EAAS,OAAS,EAAS,OAC7B,MAAM,IAAI,EAAA,uBACR,yFACF,EAGF,OACE,EAAS,MAAQ,EAAO,KACxB,EAAS,KAAO,EAAO,IACvB,EAAS,MAAQ,EAAO,KACxB,EAAS,QAAU,EAAO,OAC1B,EAAS,QAAU,EAAO,OAC1B,EAAS,aACT,EAAS,aAAe,EAAO,YAC/B,EAAS,YAAc,EAAO,UAElC,CAEA,SAAgB,EAAiC,EAAyC,CACxF,IAAM,EAAY,EAAM,YAAc,EAAA,SAAS,IAAI,QAAQ,EAErD,EADQ,EAAA,UAAU,EAAM,MAAO,CACrB,CAAA,CAAM,kBAAoB,EAAU,kBAKpD,OAJoB,OAAO,QAAQ,EAAM,UAAU,CAAC,CACjD,KAAK,CAAC,EAAK,MAAe,CAAE,MAAK,IAAK,EAA4B,CAAQ,CAAE,EAAE,CAAC,CAC/E,MAAM,EAAM,IAAU,EAAK,IAAM,EAAM,GAEnC,CAAA,CAAW,MAAM,CAAE,SAAU,GAAW,CAAG,CAAC,EAAE,KAAO,IAC9D,CAEA,SAAS,EAAgB,EAA6C,CACpE,IAAK,GAAM,CAAE,QAAO,UAAU,EAAY,CACxC,IAAM,EAAQ,KAAK,IAAI,EAAS,EAAgB,EAEhD,GAAI,EAAQ,EAAG,MAAO,CAAE,OAAM,OAAM,CACtC,CAEA,MAAO,CAAE,KAAM,cAAe,MAAO,CAAE,CACzC,CAEA,SAAgB,EACd,EACA,EAAe,EAAA,SAAS,IAAI,QAAQ,EACpC,EAA2B,CAAC,EACZ,CAChB,GAAI,CAAC,EAAQ,UAAY,aAAa,EAAA,SAAS,SAAW,aAAa,EAAA,SAAS,QAAS,CACvF,IAAM,EAAO,EAAE,mBAAmB,KAAK,EACjC,EAAQ,EAAE,mBAAmB,KAAK,EAExC,OAAO,EACL,EAAA,SAAS,cAAc,QAAQ,EAAM,CAAK,GAAK,EAC3C,EAAM,MAAM,EAAM,CAAE,YAAa,MAAO,CAAC,EACzC,EAAK,MAAM,EAAO,CAAE,YAAa,MAAO,CAAC,CAC/C,CACF,CAEA,IAAM,EAAW,EAAA,oBAAoB,CAAC,EAAG,CAAC,EAAG,CAAO,EAC9C,EAAO,EAAA,QAAQ,EAAG,CAAE,UAAS,CAAC,EAC9B,EAAQ,EAAA,QAAQ,EAAG,CAAE,UAAS,CAAC,EAErC,OAAO,EACL,EAAA,SAAS,cAAc,QAAQ,EAAM,CAAK,GAAK,EAC3C,EAAM,MAAM,EAAM,CAAE,YAAa,MAAO,CAAC,EACzC,EAAK,MAAM,EAAO,CAAE,YAAa,MAAO,CAAC,CAC/C,CACF"}

package/dist/classify.d.ts

@@ -1,46 +1,4 @@
-import { Temporal } from '@js-temporal/polyfill';
-import type { TimeDiffResult, TimeInput, TimeOptions } from './types';
-/**
- * Classifies a date into a user-defined bucket by comparing diff = date − now
- * against the provided thresholds (sorted ascending). Returns the key of the
- * first threshold the diff falls within, or `null` if no threshold matches.
- *
- * Thresholds accept negative durations to classify past dates. The function
- * requires `options.tz` when input is a `PlainDate` or `PlainDateTime`.
- *
- * **Performance:** threshold objects are cached by reference in a `WeakMap`. Define
- * the threshold record at module scope (not inline) so sorting is performed only once
- * per unique object.
- *
- * @example
- * ```ts
- * expires(expiresAt, {
- *   longExpired: { days: -30 },  // more than 30 days in the past
- *   expired:     { days: 0 },    // any past date
- *   critical:    { days: 3 },    // within 3 days
- *   warning:     { days: 14 },   // within 14 days
- *   safe:        { years: 100 }, // catch-all for far future
- * })
- * // → 'longExpired' | 'expired' | 'critical' | 'warning' | 'safe' | null
- * ```
- */
-export declare function expires<K extends string>(date: TimeInput, thresholds: Record<K, Temporal.DurationLike>, options?: TimeOptions, now?: Temporal.Instant): K | null;
-/**
- * Returns the absolute calendar-accurate difference between two dates as a
- * structured `{ unit, value }` in the largest meaningful unit.
- *
- * When `b` is omitted, the current instant is used.
- * Requires `options.tz` when inputs are `PlainDate`, `PlainDateTime`, or plain `Instant` with
- * calendar-unit precision. Throws when timezone cannot be inferred from inputs.
- *
- * @example
- * ```ts
- * timeDiff(
- *   parseInstant('2026-01-01T00:00:00Z'),
- *   parseInstant('2027-03-15T00:00:00Z'),
- * )
- * // { unit: 'year', value: 1 }
- * ```
- */
-export declare function timeDiff(a: TimeInput, b?: TimeInput, options?: TimeOptions): TimeDiffResult;
+import type { ClassifyExpiryInput, TimeDiffResult, TimeInput, TimeZoneOptions } from './types';
+export declare function classifyExpiry<K extends string>(input: ClassifyExpiryInput<K>): K | null;
+export declare function timeDiff(a: TimeInput, b?: TimeInput, options?: TimeZoneOptions): TimeDiffResult;
 //# sourceMappingURL=classify.d.ts.map

package/dist/classify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../src/classify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAgB,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA2BpF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EACtC,IAAI,EAAE,SAAS,EACf,UAAU,EAAE,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC5C,OAAO,GAAE,WAAgB,EACzB,GAAG,mBAAyB,GAC3B,CAAC,GAAG,IAAI,CAYV;AAkDD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,GAAE,WAAgB,GAAG,cAAc,CAa/F"}
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../src/classify.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EAEnB,cAAc,EAEd,SAAS,EACT,eAAe,EAChB,MAAM,SAAS,CAAC;AAiDjB,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,CASxF;AAYD,wBAAgB,QAAQ,CACtB,CAAC,EAAE,SAAS,EACZ,CAAC,GAAE,SAAkC,EACrC,OAAO,GAAE,eAAoB,GAC5B,cAAc,CAqBhB"}

package/dist/classify.js

@@ -1,27 +1,18 @@
-import { MS_PER_MONTH as e, inferSharedTimeZone as t } from "./_tz.js";
+import { TempoInvalidInputError as e } from "./errors.js";
+import { inferSharedTimeZone as t } from "./_tz.js";
 import { toInstant as n, toZoned as r } from "./_convert.js";
 import { Temporal as i } from "@js-temporal/polyfill";
 //#region src/classify.ts
-var a = /* @__PURE__ */ new WeakMap();
-function o(e) {
-	let t = a.get(e);
-	if (t) return t;
-	let n = Object.keys(e).map((t) => ({
-		key: t,
-		ms: c(e[t])
-	})).sort((e, t) => e.ms - t.ms);
-	return a.set(e, n), n;
-}
-function s(e, t, r = {}, a = i.Now.instant()) {
-	let s = n(e, r).epochMilliseconds - a.epochMilliseconds;
-	for (let { key: e, ms: n } of o(t)) if (s <= n) return e;
-	return null;
-}
-function c(t) {
-	let n = i.Duration.from(t);
-	return (n.years ?? 0) * 12 * e + (n.months ?? 0) * e + (n.weeks ?? 0) * 7 * 864e5 + (n.days ?? 0) * 864e5 + (n.hours ?? 0) * 36e5 + (n.minutes ?? 0) * 6e4 + (n.seconds ?? 0) * 1e3 + (n.milliseconds ?? 0) + (n.microseconds ?? 0) / 1e3 + (n.nanoseconds ?? 0) / 1e6;
-}
-var l = [
+var a = {
+	day: 864e5,
+	hour: 36e5,
+	microsecond: 1 / 1e3,
+	millisecond: 1,
+	minute: 6e4,
+	nanosecond: 1 / 1e6,
+	second: 1e3,
+	week: 6048e5
+}, o = [
 	{
 		field: "years",
 		unit: "year"
@@ -55,11 +46,20 @@ var l = [
 		unit: "millisecond"
 	}
 ];
-function u(e, t) {
-	return i.ZonedDateTime.compare(e, t) <= 0 ? t.since(e, { largestUnit: "year" }) : e.since(t, { largestUnit: "year" });
+function s(t) {
+	let n = i.Duration.from(t);
+	if (n.years || n.months) throw new e("classifyExpiry thresholds cannot contain months or years. Use fixed elapsed-time units.");
+	return n.weeks * a.week + n.days * a.day + n.hours * a.hour + n.minutes * a.minute + n.seconds * a.second + n.milliseconds + n.microseconds * a.microsecond + n.nanoseconds * a.nanosecond;
+}
+function c(e) {
+	let t = e.relativeTo ?? i.Now.instant(), r = n(e.value, e).epochMilliseconds - t.epochMilliseconds;
+	return Object.entries(e.thresholds).map(([e, t]) => ({
+		key: e,
+		max: s(t)
+	})).sort((e, t) => e.max - t.max).find(({ max: e }) => r <= e)?.key ?? null;
 }
-function d(e) {
-	for (let { field: t, unit: n } of l) {
+function l(e) {
+	for (let { field: t, unit: n } of o) {
 		let r = Math.abs(e[t]);
 		if (r > 0) return {
 			unit: n,
@@ -71,13 +71,15 @@ function d(e) {
 		value: 0
 	};
 }
-function f(e, n, a = {}) {
-	let o = n ?? i.Now.instant();
-	if (!a.tz && e instanceof i.Instant && o instanceof i.Instant) return d(u(e.toZonedDateTimeISO("UTC"), o.toZonedDateTimeISO("UTC")));
-	let s = t([e, o], a);
-	return d(u(r(e, { tz: s }), r(o, { tz: s })));
+function u(e, n = i.Now.instant(), a = {}) {
+	if (!a.timeZone && e instanceof i.Instant && n instanceof i.Instant) {
+		let t = e.toZonedDateTimeISO("UTC"), r = n.toZonedDateTimeISO("UTC");
+		return l(i.ZonedDateTime.compare(t, r) <= 0 ? r.since(t, { largestUnit: "year" }) : t.since(r, { largestUnit: "year" }));
+	}
+	let o = t([e, n], a), s = r(e, { timeZone: o }), c = r(n, { timeZone: o });
+	return l(i.ZonedDateTime.compare(s, c) <= 0 ? c.since(s, { largestUnit: "year" }) : s.since(c, { largestUnit: "year" }));
 }
 //#endregion
-export { s as expires, f as timeDiff };
+export { c as classifyExpiry, u as timeDiff };
 
 //# sourceMappingURL=classify.js.map

package/dist/classify.js.map

@@ -1 +1 @@
-{"version":3,"file":"classify.js","names":[],"sources":["../src/classify.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nimport type { TimeDiffResult, TimeDiffUnit, TimeInput, TimeOptions } from './types';\n\nimport { toInstant, toZoned } from './_convert';\nimport { inferSharedTimeZone, MS_PER_MONTH } from './_tz';\n\n// ─── Threshold sort cache ─────────────────────────────────────────────────────\n\ntype SortedThreshold<K extends string> = { key: K; ms: number }[];\n\nconst THRESHOLD_SORT_CACHE = new WeakMap<object, SortedThreshold<string>>();\n\nfunction getSortedThresholds<K extends string>(thresholds: Record<K, Temporal.DurationLike>): SortedThreshold<K> {\n  const cached = THRESHOLD_SORT_CACHE.get(thresholds);\n\n  if (cached) return cached as SortedThreshold<K>;\n\n  const sorted = (Object.keys(thresholds) as K[])\n    .map((key) => ({ key, ms: durationToMs(thresholds[key]) }))\n    .sort((a, b) => a.ms - b.ms);\n\n  THRESHOLD_SORT_CACHE.set(thresholds, sorted);\n\n  return sorted;\n}\n\n// ─── expires ─────────────────────────────────────────────────────────────────\n\n/**\n * Classifies a date into a user-defined bucket by comparing diff = date − now\n * against the provided thresholds (sorted ascending). Returns the key of the\n * first threshold the diff falls within, or `null` if no threshold matches.\n *\n * Thresholds accept negative durations to classify past dates. The function\n * requires `options.tz` when input is a `PlainDate` or `PlainDateTime`.\n *\n * **Performance:** threshold objects are cached by reference in a `WeakMap`. Define\n * the threshold record at module scope (not inline) so sorting is performed only once\n * per unique object.\n *\n * @example\n * ```ts\n * expires(expiresAt, {\n *   longExpired: { days: -30 },  // more than 30 days in the past\n *   expired:     { days: 0 },    // any past date\n *   critical:    { days: 3 },    // within 3 days\n *   warning:     { days: 14 },   // within 14 days\n *   safe:        { years: 100 }, // catch-all for far future\n * })\n * // → 'longExpired' | 'expired' | 'critical' | 'warning' | 'safe' | null\n * ```\n */\nexport function expires<K extends string>(\n  date: TimeInput,\n  thresholds: Record<K, Temporal.DurationLike>,\n  options: TimeOptions = {},\n  now = Temporal.Now.instant(),\n): K | null {\n  const dateMs = toInstant(date, options).epochMilliseconds;\n  const nowMs = now.epochMilliseconds;\n\n  // diff is positive for future dates, negative for past dates (date − now)\n  const diffMs = dateMs - nowMs;\n\n  for (const { key, ms } of getSortedThresholds(thresholds)) {\n    if (diffMs <= ms) return key;\n  }\n\n  return null;\n}\n\n/** Converts a `DurationLike` to approximate milliseconds for threshold comparison. */\nfunction durationToMs(duration: Temporal.DurationLike): number {\n  const d = Temporal.Duration.from(duration);\n\n  // Use approximate conversions — thresholds are human-defined boundaries, not calendar-precise.\n  return (\n    (d.years ?? 0) * 12 * MS_PER_MONTH +\n    (d.months ?? 0) * MS_PER_MONTH +\n    (d.weeks ?? 0) * 7 * 86_400_000 +\n    (d.days ?? 0) * 86_400_000 +\n    (d.hours ?? 0) * 3_600_000 +\n    (d.minutes ?? 0) * 60_000 +\n    (d.seconds ?? 0) * 1_000 +\n    (d.milliseconds ?? 0) +\n    (d.microseconds ?? 0) / 1_000 +\n    (d.nanoseconds ?? 0) / 1_000_000\n  );\n}\n\n// ─── timeDiff ─────────────────────────────────────────────────────────────────\n\nconst UNIT_ORDER: ReadonlyArray<{ field: keyof Temporal.Duration; unit: TimeDiffUnit }> = [\n  { field: 'years', unit: 'year' },\n  { field: 'months', unit: 'month' },\n  { field: 'weeks', unit: 'week' },\n  { field: 'days', unit: 'day' },\n  { field: 'hours', unit: 'hour' },\n  { field: 'minutes', unit: 'minute' },\n  { field: 'seconds', unit: 'second' },\n  { field: 'milliseconds', unit: 'millisecond' },\n];\n\nfunction sinceZoned(a: Temporal.ZonedDateTime, b: Temporal.ZonedDateTime): Temporal.Duration {\n  return Temporal.ZonedDateTime.compare(a, b) <= 0\n    ? b.since(a, { largestUnit: 'year' })\n    : a.since(b, { largestUnit: 'year' });\n}\n\nfunction pickLargestUnit(duration: Temporal.Duration): TimeDiffResult {\n  for (const { field, unit } of UNIT_ORDER) {\n    const value = Math.abs(duration[field] as number);\n\n    if (value > 0) return { unit, value };\n  }\n\n  return { unit: 'millisecond', value: 0 };\n}\n\n/**\n * Returns the absolute calendar-accurate difference between two dates as a\n * structured `{ unit, value }` in the largest meaningful unit.\n *\n * When `b` is omitted, the current instant is used.\n * Requires `options.tz` when inputs are `PlainDate`, `PlainDateTime`, or plain `Instant` with\n * calendar-unit precision. Throws when timezone cannot be inferred from inputs.\n *\n * @example\n * ```ts\n * timeDiff(\n *   parseInstant('2026-01-01T00:00:00Z'),\n *   parseInstant('2027-03-15T00:00:00Z'),\n * )\n * // { unit: 'year', value: 1 }\n * ```\n */\nexport function timeDiff(a: TimeInput, b?: TimeInput, options: TimeOptions = {}): TimeDiffResult {\n  const end: TimeInput = b ?? Temporal.Now.instant();\n\n  // Fast path: two Instants with no explicit tz — project to UTC for calendar-accurate units.\n  // Instants are absolute and timezone-independent; UTC is the canonical calendar context.\n  if (!options.tz && a instanceof Temporal.Instant && end instanceof Temporal.Instant) {\n    return pickLargestUnit(sinceZoned(a.toZonedDateTimeISO('UTC'), end.toZonedDateTimeISO('UTC')));\n  }\n\n  // Plain inputs or calendar-accurate comparison require a timezone.\n  const tz = inferSharedTimeZone([a, end], options);\n\n  return pickLargestUnit(sinceZoned(toZoned(a, { tz }), toZoned(end, { tz })));\n}\n"],"mappings":";;;;AAWA,IAAM,oBAAuB,IAAI,QAAyC;AAE1E,SAAS,EAAsC,GAAkE;CAC/G,IAAM,IAAS,EAAqB,IAAI,CAAU;CAElD,IAAI,GAAQ,OAAO;CAEnB,IAAM,IAAU,OAAO,KAAK,CAAU,CAAC,CACpC,KAAK,OAAS;EAAE;EAAK,IAAI,EAAa,EAAW,EAAI;CAAE,EAAE,CAAC,CAC1D,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE;CAI7B,OAFA,EAAqB,IAAI,GAAY,CAAM,GAEpC;AACT;AA4BA,SAAgB,EACd,GACA,GACA,IAAuB,CAAC,GACxB,IAAM,EAAS,IAAI,QAAQ,GACjB;CAKV,IAAM,IAJS,EAAU,GAAM,CAAO,CAAC,CAAC,oBAC1B,EAAI;CAKlB,KAAK,IAAM,EAAE,QAAK,WAAQ,EAAoB,CAAU,GACtD,IAAI,KAAU,GAAI,OAAO;CAG3B,OAAO;AACT;AAGA,SAAS,EAAa,GAAyC;CAC7D,IAAM,IAAI,EAAS,SAAS,KAAK,CAAQ;CAGzC,QACG,EAAE,SAAS,KAAK,KAAK,KACrB,EAAE,UAAU,KAAK,KACjB,EAAE,SAAS,KAAK,IAAI,SACpB,EAAE,QAAQ,KAAK,SACf,EAAE,SAAS,KAAK,QAChB,EAAE,WAAW,KAAK,OAClB,EAAE,WAAW,KAAK,OAClB,EAAE,gBAAgB,MAClB,EAAE,gBAAgB,KAAK,OACvB,EAAE,eAAe,KAAK;AAE3B;AAIA,IAAM,IAAoF;CACxF;EAAE,OAAO;EAAS,MAAM;CAAO;CAC/B;EAAE,OAAO;EAAU,MAAM;CAAQ;CACjC;EAAE,OAAO;EAAS,MAAM;CAAO;CAC/B;EAAE,OAAO;EAAQ,MAAM;CAAM;CAC7B;EAAE,OAAO;EAAS,MAAM;CAAO;CAC/B;EAAE,OAAO;EAAW,MAAM;CAAS;CACnC;EAAE,OAAO;EAAW,MAAM;CAAS;CACnC;EAAE,OAAO;EAAgB,MAAM;CAAc;AAC/C;AAEA,SAAS,EAAW,GAA2B,GAA8C;CAC3F,OAAO,EAAS,cAAc,QAAQ,GAAG,CAAC,KAAK,IAC3C,EAAE,MAAM,GAAG,EAAE,aAAa,OAAO,CAAC,IAClC,EAAE,MAAM,GAAG,EAAE,aAAa,OAAO,CAAC;AACxC;AAEA,SAAS,EAAgB,GAA6C;CACpE,KAAK,IAAM,EAAE,UAAO,aAAU,GAAY;EACxC,IAAM,IAAQ,KAAK,IAAI,EAAS,EAAgB;EAEhD,IAAI,IAAQ,GAAG,OAAO;GAAE;GAAM;EAAM;CACtC;CAEA,OAAO;EAAE,MAAM;EAAe,OAAO;CAAE;AACzC;AAmBA,SAAgB,EAAS,GAAc,GAAe,IAAuB,CAAC,GAAmB;CAC/F,IAAM,IAAiB,KAAK,EAAS,IAAI,QAAQ;CAIjD,IAAI,CAAC,EAAQ,MAAM,aAAa,EAAS,WAAW,aAAe,EAAS,SAC1E,OAAO,EAAgB,EAAW,EAAE,mBAAmB,KAAK,GAAG,EAAI,mBAAmB,KAAK,CAAC,CAAC;CAI/F,IAAM,IAAK,EAAoB,CAAC,GAAG,CAAG,GAAG,CAAO;CAEhD,OAAO,EAAgB,EAAW,EAAQ,GAAG,EAAE,MAAG,CAAC,GAAG,EAAQ,GAAK,EAAE,MAAG,CAAC,CAAC,CAAC;AAC7E"}
+{"version":3,"file":"classify.js","names":[],"sources":["../src/classify.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nimport type {\n  ClassifyExpiryInput,\n  FixedDuration,\n  TimeDiffResult,\n  TimeDiffUnit,\n  TimeInput,\n  TimeZoneOptions,\n} from './types';\n\nimport { toInstant, toZoned } from './_convert';\nimport { inferSharedTimeZone } from './_tz';\nimport { TempoInvalidInputError } from './errors';\n\nconst MILLIS = {\n  day: 86_400_000,\n  hour: 3_600_000,\n  microsecond: 1 / 1_000,\n  millisecond: 1,\n  minute: 60_000,\n  nanosecond: 1 / 1_000_000,\n  second: 1_000,\n  week: 604_800_000,\n} as const;\nconst UNIT_ORDER: ReadonlyArray<{ field: keyof Temporal.Duration; unit: TimeDiffUnit }> = [\n  { field: 'years', unit: 'year' },\n  { field: 'months', unit: 'month' },\n  { field: 'weeks', unit: 'week' },\n  { field: 'days', unit: 'day' },\n  { field: 'hours', unit: 'hour' },\n  { field: 'minutes', unit: 'minute' },\n  { field: 'seconds', unit: 'second' },\n  { field: 'milliseconds', unit: 'millisecond' },\n];\n\n// Expiry classification is elapsed-time math. Calendar months and years are rejected rather than approximated.\nfunction fixedDurationToMilliseconds(input: FixedDuration): number {\n  const duration = Temporal.Duration.from(input);\n\n  if (duration.years || duration.months) {\n    throw new TempoInvalidInputError(\n      'classifyExpiry thresholds cannot contain months or years. Use fixed elapsed-time units.',\n    );\n  }\n\n  return (\n    duration.weeks * MILLIS.week +\n    duration.days * MILLIS.day +\n    duration.hours * MILLIS.hour +\n    duration.minutes * MILLIS.minute +\n    duration.seconds * MILLIS.second +\n    duration.milliseconds +\n    duration.microseconds * MILLIS.microsecond +\n    duration.nanoseconds * MILLIS.nanosecond\n  );\n}\n\nexport function classifyExpiry<K extends string>(input: ClassifyExpiryInput<K>): K | null {\n  const reference = input.relativeTo ?? Temporal.Now.instant();\n  const value = toInstant(input.value, input);\n  const elapsed = value.epochMilliseconds - reference.epochMilliseconds;\n  const thresholds = (Object.entries(input.thresholds) as Array<[K, FixedDuration]>)\n    .map(([key, duration]) => ({ key, max: fixedDurationToMilliseconds(duration) }))\n    .sort((left, right) => left.max - right.max);\n\n  return thresholds.find(({ max }) => elapsed <= max)?.key ?? null;\n}\n\nfunction pickLargestUnit(duration: Temporal.Duration): TimeDiffResult {\n  for (const { field, unit } of UNIT_ORDER) {\n    const value = Math.abs(duration[field] as number);\n\n    if (value > 0) return { unit, value };\n  }\n\n  return { unit: 'millisecond', value: 0 };\n}\n\nexport function timeDiff(\n  a: TimeInput,\n  b: TimeInput = Temporal.Now.instant(),\n  options: TimeZoneOptions = {},\n): TimeDiffResult {\n  if (!options.timeZone && a instanceof Temporal.Instant && b instanceof Temporal.Instant) {\n    const left = a.toZonedDateTimeISO('UTC');\n    const right = b.toZonedDateTimeISO('UTC');\n\n    return pickLargestUnit(\n      Temporal.ZonedDateTime.compare(left, right) <= 0\n        ? right.since(left, { largestUnit: 'year' })\n        : left.since(right, { largestUnit: 'year' }),\n    );\n  }\n\n  const timeZone = inferSharedTimeZone([a, b], options);\n  const left = toZoned(a, { timeZone });\n  const right = toZoned(b, { timeZone });\n\n  return pickLargestUnit(\n    Temporal.ZonedDateTime.compare(left, right) <= 0\n      ? right.since(left, { largestUnit: 'year' })\n      : left.since(right, { largestUnit: 'year' }),\n  );\n}\n"],"mappings":";;;;;AAeA,IAAM,IAAS;CACb,KAAK;CACL,MAAM;CACN,aAAa,IAAI;CACjB,aAAa;CACb,QAAQ;CACR,YAAY,IAAI;CAChB,QAAQ;CACR,MAAM;AACR,GACM,IAAoF;CACxF;EAAE,OAAO;EAAS,MAAM;CAAO;CAC/B;EAAE,OAAO;EAAU,MAAM;CAAQ;CACjC;EAAE,OAAO;EAAS,MAAM;CAAO;CAC/B;EAAE,OAAO;EAAQ,MAAM;CAAM;CAC7B;EAAE,OAAO;EAAS,MAAM;CAAO;CAC/B;EAAE,OAAO;EAAW,MAAM;CAAS;CACnC;EAAE,OAAO;EAAW,MAAM;CAAS;CACnC;EAAE,OAAO;EAAgB,MAAM;CAAc;AAC/C;AAGA,SAAS,EAA4B,GAA8B;CACjE,IAAM,IAAW,EAAS,SAAS,KAAK,CAAK;CAE7C,IAAI,EAAS,SAAS,EAAS,QAC7B,MAAM,IAAI,EACR,yFACF;CAGF,OACE,EAAS,QAAQ,EAAO,OACxB,EAAS,OAAO,EAAO,MACvB,EAAS,QAAQ,EAAO,OACxB,EAAS,UAAU,EAAO,SAC1B,EAAS,UAAU,EAAO,SAC1B,EAAS,eACT,EAAS,eAAe,EAAO,cAC/B,EAAS,cAAc,EAAO;AAElC;AAEA,SAAgB,EAAiC,GAAyC;CACxF,IAAM,IAAY,EAAM,cAAc,EAAS,IAAI,QAAQ,GAErD,IADQ,EAAU,EAAM,OAAO,CACrB,CAAA,CAAM,oBAAoB,EAAU;CAKpD,OAJoB,OAAO,QAAQ,EAAM,UAAU,CAAC,CACjD,KAAK,CAAC,GAAK,QAAe;EAAE;EAAK,KAAK,EAA4B,CAAQ;CAAE,EAAE,CAAC,CAC/E,MAAM,GAAM,MAAU,EAAK,MAAM,EAAM,GAEnC,CAAA,CAAW,MAAM,EAAE,aAAU,KAAW,CAAG,CAAC,EAAE,OAAO;AAC9D;AAEA,SAAS,EAAgB,GAA6C;CACpE,KAAK,IAAM,EAAE,UAAO,aAAU,GAAY;EACxC,IAAM,IAAQ,KAAK,IAAI,EAAS,EAAgB;EAEhD,IAAI,IAAQ,GAAG,OAAO;GAAE;GAAM;EAAM;CACtC;CAEA,OAAO;EAAE,MAAM;EAAe,OAAO;CAAE;AACzC;AAEA,SAAgB,EACd,GACA,IAAe,EAAS,IAAI,QAAQ,GACpC,IAA2B,CAAC,GACZ;CAChB,IAAI,CAAC,EAAQ,YAAY,aAAa,EAAS,WAAW,aAAa,EAAS,SAAS;EACvF,IAAM,IAAO,EAAE,mBAAmB,KAAK,GACjC,IAAQ,EAAE,mBAAmB,KAAK;EAExC,OAAO,EACL,EAAS,cAAc,QAAQ,GAAM,CAAK,KAAK,IAC3C,EAAM,MAAM,GAAM,EAAE,aAAa,OAAO,CAAC,IACzC,EAAK,MAAM,GAAO,EAAE,aAAa,OAAO,CAAC,CAC/C;CACF;CAEA,IAAM,IAAW,EAAoB,CAAC,GAAG,CAAC,GAAG,CAAO,GAC9C,IAAO,EAAQ,GAAG,EAAE,YAAS,CAAC,GAC9B,IAAQ,EAAQ,GAAG,EAAE,YAAS,CAAC;CAErC,OAAO,EACL,EAAS,cAAc,QAAQ,GAAM,CAAK,KAAK,IAC3C,EAAM,MAAM,GAAM,EAAE,aAAa,OAAO,CAAC,IACzC,EAAK,MAAM,GAAO,EAAE,aAAa,OAAO,CAAC,CAC/C;AACF"}

package/dist/compare.cjs

@@ -1,2 +1,2 @@
-const e=require("./_tz.cjs"),t=require("./_convert.cjs"),n=require("./_floor.cjs");let r=require("@js-temporal/polyfill");function i(t,r,i,a){let o={tz:e.inferSharedTimeZone([t,r],a),weekStartsOn:a.weekStartsOn};return{left:n.floorToUnit(t,i,o),right:n.floorToUnit(r,i,o)}}function a(t,r,i,a,o){let s={tz:e.inferSharedTimeZone([t,r,i],o),weekStartsOn:o.weekStartsOn},c=n.floorToUnit(t,a,s),[l,u]=e.normalizeRange(n.floorToUnit(r,a,s),n.floorToUnit(i,a,s));return{lower:l,target:c,upper:u}}function o(e,n,a){if(!a.unit)return r.Temporal.Instant.compare(t.toInstant(e,a),t.toInstant(n,a));let{left:o,right:s}=i(e,n,a.unit,a);return r.Temporal.Instant.compare(o,s)}function s(e,t,n={}){return o(e,t,n)<0}function c(e,t,n={}){return o(e,t,n)>0}function l(e,t,n={}){return o(e,t,n)===0}function u(n,i,o,s={}){if(!s.unit){let a=t.toInstant(n,s),[c,l]=e.normalizeRange(t.toInstant(i,s),t.toInstant(o,s));return r.Temporal.Instant.compare(c,a)<=0&&r.Temporal.Instant.compare(a,l)<=0}let{lower:c,target:l,upper:u}=a(n,i,o,s.unit,s);return r.Temporal.Instant.compare(c,l)<=0&&r.Temporal.Instant.compare(l,u)<=0}function d(n,i,o,s={}){let c=n instanceof r.Temporal.ZonedDateTime,l=c?n.timeZoneId:void 0;if(!s.unit){let a=t.toInstant(n,s),[u,d]=e.normalizeRange(t.toInstant(i,s),t.toInstant(o,s)),f;return f=r.Temporal.Instant.compare(a,u)<0?u:r.Temporal.Instant.compare(a,d)>0?d:a,c&&l?f.toZonedDateTimeISO(l):f}let{lower:u,target:d,upper:f}=a(n,i,o,s.unit,s),p;p=r.Temporal.Instant.compare(d,u)<0?u:r.Temporal.Instant.compare(d,f)>0?f:d;let m=s.tz??l??e.inferSharedTimeZone([n,i,o],s);return c?p.toZonedDateTimeISO(m):p}exports.clamp=d,exports.isAfter=c,exports.isBefore=s,exports.isSame=l,exports.within=u;
+const e=require("./_tz.cjs"),t=require("./_convert.cjs"),n=require("./_floor.cjs");let r=require("@js-temporal/polyfill");function i(i,a,o){if(!o.unit)return r.Temporal.Instant.compare(t.toInstant(i,o),t.toInstant(a,o));let s={timeZone:e.inferSharedTimeZone([i,a],o),weekStartsOn:o.weekStartsOn};return r.Temporal.Instant.compare(n.floorToUnit(i,o.unit,s),n.floorToUnit(a,o.unit,s))}function a({end:r,start:i,value:a,...o}){if(!o.unit){let n=t.toInstant(a,o),[s,c]=e.normalizeRange(t.toInstant(i,o),t.toInstant(r,o));return{lower:s,target:n,upper:c}}let s={timeZone:e.inferSharedTimeZone([a,i,r],o),weekStartsOn:o.weekStartsOn},c=n.floorToUnit(a,o.unit,s),[l,u]=e.normalizeRange(n.floorToUnit(i,o.unit,s),n.floorToUnit(r,o.unit,s));return{lower:l,target:c,upper:u}}function o(e,t,n={}){return i(e,t,n)<0}function s(e,t,n={}){return i(e,t,n)>0}function c(e,t,n={}){return i(e,t,n)===0}function l(e){let{lower:t,target:n,upper:i}=a(e);return r.Temporal.Instant.compare(t,n)<=0&&r.Temporal.Instant.compare(n,i)<=0}function u(e){let{lower:t,target:n,upper:i}=a(e),o=r.Temporal.Instant.compare(n,t)<0?t:r.Temporal.Instant.compare(n,i)>0?i:n;return e.value instanceof r.Temporal.ZonedDateTime?o.toZonedDateTimeISO(e.timeZone??e.value.timeZoneId):o}exports.clamp=u,exports.contains=l,exports.isAfter=s,exports.isBefore=o,exports.isSame=c;
 //# sourceMappingURL=compare.cjs.map

package/dist/compare.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"compare.cjs","names":[],"sources":["../src/compare.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nimport type { BoundaryUnit, CompareOptions, TimeInput } from './types';\n\nimport { toInstant } from './_convert';\nimport { floorToUnit } from './_floor';\nimport { inferSharedTimeZone, normalizeRange } from './_tz';\n\n// ─── Internal helpers ─────────────────────────────────────────────────────────\n\nfunction resolveFlooredPair(\n  a: TimeInput,\n  b: TimeInput,\n  unit: BoundaryUnit,\n  options: CompareOptions,\n): { left: Temporal.Instant; right: Temporal.Instant } {\n  const tz = inferSharedTimeZone([a, b], options);\n  const unitOpts = { tz, weekStartsOn: options.weekStartsOn };\n\n  return {\n    left: floorToUnit(a, unit, unitOpts),\n    right: floorToUnit(b, unit, unitOpts),\n  };\n}\n\nfunction resolveFlooredTriple(\n  value: TimeInput,\n  start: TimeInput,\n  end: TimeInput,\n  unit: BoundaryUnit,\n  options: CompareOptions,\n): { lower: Temporal.Instant; target: Temporal.Instant; upper: Temporal.Instant } {\n  const tz = inferSharedTimeZone([value, start, end], options);\n  const unitOpts = { tz, weekStartsOn: options.weekStartsOn };\n  const target = floorToUnit(value, unit, unitOpts);\n  const [lower, upper] = normalizeRange(floorToUnit(start, unit, unitOpts), floorToUnit(end, unit, unitOpts));\n\n  return { lower, target, upper };\n}\n\nfunction compareByUnit(a: TimeInput, b: TimeInput, options: CompareOptions): number {\n  if (!options.unit) {\n    return Temporal.Instant.compare(toInstant(a, options), toInstant(b, options));\n  }\n\n  const { left, right } = resolveFlooredPair(a, b, options.unit, options);\n\n  return Temporal.Instant.compare(left, right);\n}\n\n// ─── Public API ───────────────────────────────────────────────────────────────\n\n/**\n * Returns `true` when `a` is strictly before `b` on the timeline.\n * Pass `options.unit` to compare by calendar boundary (e.g. same day).\n *\n * @example\n * ```ts\n * isBefore(parseInstant('2026-03-21T10:00:00Z'), parseInstant('2026-03-21T11:00:00Z'))\n * // true\n * ```\n */\nexport function isBefore(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) < 0;\n}\n\n/**\n * Returns `true` when `a` is strictly after `b` on the timeline.\n * Pass `options.unit` to compare by calendar boundary (e.g. same day).\n *\n * @example\n * ```ts\n * isAfter(parseInstant('2026-03-21T11:00:00Z'), parseInstant('2026-03-21T10:00:00Z'))\n * // true\n * ```\n */\nexport function isAfter(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) > 0;\n}\n\n/**\n * Returns `true` when `a` and `b` represent the same point (or boundary unit) in time.\n *\n * @example\n * ```ts\n * isSame(a, b, { tz: 'America/New_York', unit: 'day' })\n * // true when a and b fall on the same calendar day in New York\n * ```\n */\nexport function isSame(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) === 0;\n}\n\n/**\n * Returns `true` when `value` falls within `[start, end]` (inclusive, bounds normalized).\n * Pass `options.unit` to floor all three inputs to a calendar boundary before comparing.\n *\n * @example\n * ```ts\n * within(\n *   parseInstant('2026-03-21T11:00:00Z'),\n *   parseInstant('2026-03-21T10:00:00Z'),\n *   parseInstant('2026-03-21T12:00:00Z'),\n * ) // true\n * ```\n */\nexport function within(value: TimeInput, start: TimeInput, end: TimeInput, options: CompareOptions = {}): boolean {\n  if (!options.unit) {\n    const target = toInstant(value, options);\n    const [lower, upper] = normalizeRange(toInstant(start, options), toInstant(end, options));\n\n    return Temporal.Instant.compare(lower, target) <= 0 && Temporal.Instant.compare(target, upper) <= 0;\n  }\n\n  const { lower, target, upper } = resolveFlooredTriple(value, start, end, options.unit, options);\n\n  return Temporal.Instant.compare(lower, target) <= 0 && Temporal.Instant.compare(target, upper) <= 0;\n}\n\n/**\n * Clamps `value` to within `[start, end]` (bounds normalized).\n *\n * When `value` is a `ZonedDateTime`, returns a `ZonedDateTime` in the same timezone.\n * Otherwise returns an `Instant`.\n *\n * When `options.unit` is set, all three inputs are floored to that calendar boundary before\n * clamping — the result is at the start of the boundary unit, not the original time-of-day.\n *\n * @example\n * ```ts\n * clamp(\n *   parseInstant('2026-03-21T13:00:00Z'),\n *   parseInstant('2026-03-21T10:00:00Z'),\n *   parseInstant('2026-03-21T12:00:00Z'),\n * ).toString() // '2026-03-21T12:00:00Z'\n *\n * clamp(\n *   parseZoned('2026-03-21T13:00:00+00:00[UTC]'),\n *   parseZoned('2026-03-21T10:00:00+00:00[UTC]'),\n *   parseZoned('2026-03-21T12:00:00+00:00[UTC]'),\n * ).toString() // '2026-03-21T12:00:00+00:00[UTC]'\n * ```\n */\nexport function clamp(\n  value: Temporal.ZonedDateTime,\n  start: TimeInput,\n  end: TimeInput,\n  options?: CompareOptions,\n): Temporal.ZonedDateTime;\nexport function clamp(value: TimeInput, start: TimeInput, end: TimeInput, options?: CompareOptions): Temporal.Instant;\nexport function clamp(\n  value: TimeInput,\n  start: TimeInput,\n  end: TimeInput,\n  options: CompareOptions = {},\n): Temporal.Instant | Temporal.ZonedDateTime {\n  const isZoned = value instanceof Temporal.ZonedDateTime;\n  const tz = isZoned ? value.timeZoneId : undefined;\n\n  if (!options.unit) {\n    const target = toInstant(value, options);\n    const [lower, upper] = normalizeRange(toInstant(start, options), toInstant(end, options));\n\n    let clamped: Temporal.Instant;\n\n    if (Temporal.Instant.compare(target, lower) < 0) clamped = lower;\n    else if (Temporal.Instant.compare(target, upper) > 0) clamped = upper;\n    else clamped = target;\n\n    return isZoned && tz ? clamped.toZonedDateTimeISO(tz) : clamped;\n  }\n\n  const { lower, target, upper } = resolveFlooredTriple(value, start, end, options.unit, options);\n\n  let clamped: Temporal.Instant;\n\n  if (Temporal.Instant.compare(target, lower) < 0) clamped = lower;\n  else if (Temporal.Instant.compare(target, upper) > 0) clamped = upper;\n  else clamped = target;\n\n  // For unit-based clamping, resolve the output tz from options or from value's zone\n  const outTz = options.tz ?? tz ?? inferSharedTimeZone([value, start, end], options);\n\n  return isZoned ? clamped.toZonedDateTimeISO(outTz) : clamped;\n}\n"],"mappings":"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"}
+{"version":3,"file":"compare.cjs","names":[],"sources":["../src/compare.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nimport type { ClampInput, ContainsInput, CompareOptions, TimeInput } from './types';\n\nimport { toInstant } from './_convert';\nimport { floorToUnit } from './_floor';\nimport { inferSharedTimeZone, normalizeRange } from './_tz';\n\nfunction compareByUnit(a: TimeInput, b: TimeInput, options: CompareOptions): number {\n  if (!options.unit) return Temporal.Instant.compare(toInstant(a, options), toInstant(b, options));\n\n  const timeZone = inferSharedTimeZone([a, b], options);\n  const unitOptions = { timeZone, weekStartsOn: options.weekStartsOn };\n\n  return Temporal.Instant.compare(floorToUnit(a, options.unit, unitOptions), floorToUnit(b, options.unit, unitOptions));\n}\n\nfunction resolveRange({ end, start, value, ...options }: ContainsInput | ClampInput): {\n  lower: Temporal.Instant;\n  target: Temporal.Instant;\n  upper: Temporal.Instant;\n} {\n  if (!options.unit) {\n    const target = toInstant(value, options);\n    const [lower, upper] = normalizeRange(toInstant(start, options), toInstant(end, options));\n\n    return { lower, target, upper };\n  }\n\n  const timeZone = inferSharedTimeZone([value, start, end], options);\n  const unitOptions = { timeZone, weekStartsOn: options.weekStartsOn };\n  const target = floorToUnit(value, options.unit, unitOptions);\n  const [lower, upper] = normalizeRange(\n    floorToUnit(start, options.unit, unitOptions),\n    floorToUnit(end, options.unit, unitOptions),\n  );\n\n  return { lower, target, upper };\n}\n\nexport function isBefore(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) < 0;\n}\n\nexport function isAfter(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) > 0;\n}\n\nexport function isSame(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) === 0;\n}\n\nexport function contains(input: ContainsInput): boolean {\n  const { lower, target, upper } = resolveRange(input);\n\n  return Temporal.Instant.compare(lower, target) <= 0 && Temporal.Instant.compare(target, upper) <= 0;\n}\n\nexport function clamp(input: ClampInput & { value: Temporal.ZonedDateTime }): Temporal.ZonedDateTime;\nexport function clamp(input: ClampInput): Temporal.Instant;\nexport function clamp(input: ClampInput): Temporal.Instant | Temporal.ZonedDateTime {\n  const { lower, target, upper } = resolveRange(input);\n  const clamped =\n    Temporal.Instant.compare(target, lower) < 0 ? lower : Temporal.Instant.compare(target, upper) > 0 ? upper : target;\n\n  return input.value instanceof Temporal.ZonedDateTime\n    ? clamped.toZonedDateTimeISO(input.timeZone ?? input.value.timeZoneId)\n    : clamped;\n}\n"],"mappings":"0HAQA,SAAS,EAAc,EAAc,EAAc,EAAiC,CAClF,GAAI,CAAC,EAAQ,KAAM,OAAO,EAAA,SAAS,QAAQ,QAAQ,EAAA,UAAU,EAAG,CAAO,EAAG,EAAA,UAAU,EAAG,CAAO,CAAC,EAG/F,IAAM,EAAc,CAAE,SADL,EAAA,oBAAoB,CAAC,EAAG,CAAC,EAAG,CACvB,EAAU,aAAc,EAAQ,YAAa,EAEnE,OAAO,EAAA,SAAS,QAAQ,QAAQ,EAAA,YAAY,EAAG,EAAQ,KAAM,CAAW,EAAG,EAAA,YAAY,EAAG,EAAQ,KAAM,CAAW,CAAC,CACtH,CAEA,SAAS,EAAa,CAAE,MAAK,QAAO,QAAO,GAAG,GAI5C,CACA,GAAI,CAAC,EAAQ,KAAM,CACjB,IAAM,EAAS,EAAA,UAAU,EAAO,CAAO,EACjC,CAAC,EAAO,GAAS,EAAA,eAAe,EAAA,UAAU,EAAO,CAAO,EAAG,EAAA,UAAU,EAAK,CAAO,CAAC,EAExF,MAAO,CAAE,QAAO,SAAQ,OAAM,CAChC,CAGA,IAAM,EAAc,CAAE,SADL,EAAA,oBAAoB,CAAC,EAAO,EAAO,CAAG,EAAG,CACpC,EAAU,aAAc,EAAQ,YAAa,EAC7D,EAAS,EAAA,YAAY,EAAO,EAAQ,KAAM,CAAW,EACrD,CAAC,EAAO,GAAS,EAAA,eACrB,EAAA,YAAY,EAAO,EAAQ,KAAM,CAAW,EAC5C,EAAA,YAAY,EAAK,EAAQ,KAAM,CAAW,CAC5C,EAEA,MAAO,CAAE,QAAO,SAAQ,OAAM,CAChC,CAEA,SAAgB,EAAS,EAAc,EAAc,EAA0B,CAAC,EAAY,CAC1F,OAAO,EAAc,EAAG,EAAG,CAAO,EAAI,CACxC,CAEA,SAAgB,EAAQ,EAAc,EAAc,EAA0B,CAAC,EAAY,CACzF,OAAO,EAAc,EAAG,EAAG,CAAO,EAAI,CACxC,CAEA,SAAgB,EAAO,EAAc,EAAc,EAA0B,CAAC,EAAY,CACxF,OAAO,EAAc,EAAG,EAAG,CAAO,IAAM,CAC1C,CAEA,SAAgB,EAAS,EAA+B,CACtD,GAAM,CAAE,QAAO,SAAQ,SAAU,EAAa,CAAK,EAEnD,OAAO,EAAA,SAAS,QAAQ,QAAQ,EAAO,CAAM,GAAK,GAAK,EAAA,SAAS,QAAQ,QAAQ,EAAQ,CAAK,GAAK,CACpG,CAIA,SAAgB,EAAM,EAA8D,CAClF,GAAM,CAAE,QAAO,SAAQ,SAAU,EAAa,CAAK,EAC7C,EACJ,EAAA,SAAS,QAAQ,QAAQ,EAAQ,CAAK,EAAI,EAAI,EAAQ,EAAA,SAAS,QAAQ,QAAQ,EAAQ,CAAK,EAAI,EAAI,EAAQ,EAE9G,OAAO,EAAM,iBAAiB,EAAA,SAAS,cACnC,EAAQ,mBAAmB,EAAM,UAAY,EAAM,MAAM,UAAU,EACnE,CACN"}

package/dist/compare.d.ts

@@ -1,75 +1,11 @@
 import { Temporal } from '@js-temporal/polyfill';
-import type { CompareOptions, TimeInput } from './types';
-/**
- * Returns `true` when `a` is strictly before `b` on the timeline.
- * Pass `options.unit` to compare by calendar boundary (e.g. same day).
- *
- * @example
- * ```ts
- * isBefore(parseInstant('2026-03-21T10:00:00Z'), parseInstant('2026-03-21T11:00:00Z'))
- * // true
- * ```
- */
+import type { ClampInput, ContainsInput, CompareOptions, TimeInput } from './types';
 export declare function isBefore(a: TimeInput, b: TimeInput, options?: CompareOptions): boolean;
-/**
- * Returns `true` when `a` is strictly after `b` on the timeline.
- * Pass `options.unit` to compare by calendar boundary (e.g. same day).
- *
- * @example
- * ```ts
- * isAfter(parseInstant('2026-03-21T11:00:00Z'), parseInstant('2026-03-21T10:00:00Z'))
- * // true
- * ```
- */
 export declare function isAfter(a: TimeInput, b: TimeInput, options?: CompareOptions): boolean;
-/**
- * Returns `true` when `a` and `b` represent the same point (or boundary unit) in time.
- *
- * @example
- * ```ts
- * isSame(a, b, { tz: 'America/New_York', unit: 'day' })
- * // true when a and b fall on the same calendar day in New York
- * ```
- */
 export declare function isSame(a: TimeInput, b: TimeInput, options?: CompareOptions): boolean;
-/**
- * Returns `true` when `value` falls within `[start, end]` (inclusive, bounds normalized).
- * Pass `options.unit` to floor all three inputs to a calendar boundary before comparing.
- *
- * @example
- * ```ts
- * within(
- *   parseInstant('2026-03-21T11:00:00Z'),
- *   parseInstant('2026-03-21T10:00:00Z'),
- *   parseInstant('2026-03-21T12:00:00Z'),
- * ) // true
- * ```
- */
-export declare function within(value: TimeInput, start: TimeInput, end: TimeInput, options?: CompareOptions): boolean;
-/**
- * Clamps `value` to within `[start, end]` (bounds normalized).
- *
- * When `value` is a `ZonedDateTime`, returns a `ZonedDateTime` in the same timezone.
- * Otherwise returns an `Instant`.
- *
- * When `options.unit` is set, all three inputs are floored to that calendar boundary before
- * clamping — the result is at the start of the boundary unit, not the original time-of-day.
- *
- * @example
- * ```ts
- * clamp(
- *   parseInstant('2026-03-21T13:00:00Z'),
- *   parseInstant('2026-03-21T10:00:00Z'),
- *   parseInstant('2026-03-21T12:00:00Z'),
- * ).toString() // '2026-03-21T12:00:00Z'
- *
- * clamp(
- *   parseZoned('2026-03-21T13:00:00+00:00[UTC]'),
- *   parseZoned('2026-03-21T10:00:00+00:00[UTC]'),
- *   parseZoned('2026-03-21T12:00:00+00:00[UTC]'),
- * ).toString() // '2026-03-21T12:00:00+00:00[UTC]'
- * ```
- */
-export declare function clamp(value: Temporal.ZonedDateTime, start: TimeInput, end: TimeInput, options?: CompareOptions): Temporal.ZonedDateTime;
-export declare function clamp(value: TimeInput, start: TimeInput, end: TimeInput, options?: CompareOptions): Temporal.Instant;
+export declare function contains(input: ContainsInput): boolean;
+export declare function clamp(input: ClampInput & {
+    value: Temporal.ZonedDateTime;
+}): Temporal.ZonedDateTime;
+export declare function clamp(input: ClampInput): Temporal.Instant;
 //# sourceMappingURL=compare.d.ts.map

package/dist/compare.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../src/compare.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,KAAK,EAAgB,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAkDvE;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAE1F;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAEzF;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAExF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAWhH;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,KAAK,CACnB,KAAK,EAAE,QAAQ,CAAC,aAAa,EAC7B,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,SAAS,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,QAAQ,CAAC,aAAa,CAAC;AAC1B,wBAAgB,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,QAAQ,CAAC,OAAO,CAAC"}
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../src/compare.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAsCpF,wBAAgB,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAE1F;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAEzF;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,OAAO,GAAE,cAAmB,GAAG,OAAO,CAExF;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAItD;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG;IAAE,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAA;CAAE,GAAG,QAAQ,CAAC,aAAa,CAAC;AACrG,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAAC,OAAO,CAAC"}

package/dist/compare.js

@@ -3,69 +3,55 @@ import { toInstant as n } from "./_convert.js";
 import { floorToUnit as r } from "./_floor.js";
 import { Temporal as i } from "@js-temporal/polyfill";
 //#region src/compare.ts
-function a(t, n, i, a) {
-	let o = {
-		tz: e([t, n], a),
-		weekStartsOn: a.weekStartsOn
-	};
-	return {
-		left: r(t, i, o),
-		right: r(n, i, o)
+function a(t, a, o) {
+	if (!o.unit) return i.Instant.compare(n(t, o), n(a, o));
+	let s = {
+		timeZone: e([t, a], o),
+		weekStartsOn: o.weekStartsOn
 	};
+	return i.Instant.compare(r(t, o.unit, s), r(a, o.unit, s));
 }
-function o(n, i, a, o, s) {
+function o({ end: i, start: a, value: o, ...s }) {
+	if (!s.unit) {
+		let e = n(o, s), [r, c] = t(n(a, s), n(i, s));
+		return {
+			lower: r,
+			target: e,
+			upper: c
+		};
+	}
 	let c = {
-		tz: e([
-			n,
-			i,
-			a
+		timeZone: e([
+			o,
+			a,
+			i
 		], s),
 		weekStartsOn: s.weekStartsOn
-	}, l = r(n, o, c), [u, d] = t(r(i, o, c), r(a, o, c));
+	}, l = r(o, s.unit, c), [u, d] = t(r(a, s.unit, c), r(i, s.unit, c));
 	return {
 		lower: u,
 		target: l,
 		upper: d
 	};
 }
-function s(e, t, r) {
-	if (!r.unit) return i.Instant.compare(n(e, r), n(t, r));
-	let { left: o, right: s } = a(e, t, r.unit, r);
-	return i.Instant.compare(o, s);
+function s(e, t, n = {}) {
+	return a(e, t, n) < 0;
 }
 function c(e, t, n = {}) {
-	return s(e, t, n) < 0;
+	return a(e, t, n) > 0;
 }
 function l(e, t, n = {}) {
-	return s(e, t, n) > 0;
+	return a(e, t, n) === 0;
 }
-function u(e, t, n = {}) {
-	return s(e, t, n) === 0;
+function u(e) {
+	let { lower: t, target: n, upper: r } = o(e);
+	return i.Instant.compare(t, n) <= 0 && i.Instant.compare(n, r) <= 0;
 }
-function d(e, r, a, s = {}) {
-	if (!s.unit) {
-		let o = n(e, s), [c, l] = t(n(r, s), n(a, s));
-		return i.Instant.compare(c, o) <= 0 && i.Instant.compare(o, l) <= 0;
-	}
-	let { lower: c, target: l, upper: u } = o(e, r, a, s.unit, s);
-	return i.Instant.compare(c, l) <= 0 && i.Instant.compare(l, u) <= 0;
-}
-function f(r, a, s, c = {}) {
-	let l = r instanceof i.ZonedDateTime, u = l ? r.timeZoneId : void 0;
-	if (!c.unit) {
-		let e = n(r, c), [o, d] = t(n(a, c), n(s, c)), f;
-		return f = i.Instant.compare(e, o) < 0 ? o : i.Instant.compare(e, d) > 0 ? d : e, l && u ? f.toZonedDateTimeISO(u) : f;
-	}
-	let { lower: d, target: f, upper: p } = o(r, a, s, c.unit, c), m;
-	m = i.Instant.compare(f, d) < 0 ? d : i.Instant.compare(f, p) > 0 ? p : f;
-	let h = c.tz ?? u ?? e([
-		r,
-		a,
-		s
-	], c);
-	return l ? m.toZonedDateTimeISO(h) : m;
+function d(e) {
+	let { lower: t, target: n, upper: r } = o(e), a = i.Instant.compare(n, t) < 0 ? t : i.Instant.compare(n, r) > 0 ? r : n;
+	return e.value instanceof i.ZonedDateTime ? a.toZonedDateTimeISO(e.timeZone ?? e.value.timeZoneId) : a;
 }
 //#endregion
-export { f as clamp, l as isAfter, c as isBefore, u as isSame, d as within };
+export { d as clamp, u as contains, c as isAfter, s as isBefore, l as isSame };
 
 //# sourceMappingURL=compare.js.map

package/dist/compare.js.map

@@ -1 +1 @@
-{"version":3,"file":"compare.js","names":[],"sources":["../src/compare.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nimport type { BoundaryUnit, CompareOptions, TimeInput } from './types';\n\nimport { toInstant } from './_convert';\nimport { floorToUnit } from './_floor';\nimport { inferSharedTimeZone, normalizeRange } from './_tz';\n\n// ─── Internal helpers ─────────────────────────────────────────────────────────\n\nfunction resolveFlooredPair(\n  a: TimeInput,\n  b: TimeInput,\n  unit: BoundaryUnit,\n  options: CompareOptions,\n): { left: Temporal.Instant; right: Temporal.Instant } {\n  const tz = inferSharedTimeZone([a, b], options);\n  const unitOpts = { tz, weekStartsOn: options.weekStartsOn };\n\n  return {\n    left: floorToUnit(a, unit, unitOpts),\n    right: floorToUnit(b, unit, unitOpts),\n  };\n}\n\nfunction resolveFlooredTriple(\n  value: TimeInput,\n  start: TimeInput,\n  end: TimeInput,\n  unit: BoundaryUnit,\n  options: CompareOptions,\n): { lower: Temporal.Instant; target: Temporal.Instant; upper: Temporal.Instant } {\n  const tz = inferSharedTimeZone([value, start, end], options);\n  const unitOpts = { tz, weekStartsOn: options.weekStartsOn };\n  const target = floorToUnit(value, unit, unitOpts);\n  const [lower, upper] = normalizeRange(floorToUnit(start, unit, unitOpts), floorToUnit(end, unit, unitOpts));\n\n  return { lower, target, upper };\n}\n\nfunction compareByUnit(a: TimeInput, b: TimeInput, options: CompareOptions): number {\n  if (!options.unit) {\n    return Temporal.Instant.compare(toInstant(a, options), toInstant(b, options));\n  }\n\n  const { left, right } = resolveFlooredPair(a, b, options.unit, options);\n\n  return Temporal.Instant.compare(left, right);\n}\n\n// ─── Public API ───────────────────────────────────────────────────────────────\n\n/**\n * Returns `true` when `a` is strictly before `b` on the timeline.\n * Pass `options.unit` to compare by calendar boundary (e.g. same day).\n *\n * @example\n * ```ts\n * isBefore(parseInstant('2026-03-21T10:00:00Z'), parseInstant('2026-03-21T11:00:00Z'))\n * // true\n * ```\n */\nexport function isBefore(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) < 0;\n}\n\n/**\n * Returns `true` when `a` is strictly after `b` on the timeline.\n * Pass `options.unit` to compare by calendar boundary (e.g. same day).\n *\n * @example\n * ```ts\n * isAfter(parseInstant('2026-03-21T11:00:00Z'), parseInstant('2026-03-21T10:00:00Z'))\n * // true\n * ```\n */\nexport function isAfter(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) > 0;\n}\n\n/**\n * Returns `true` when `a` and `b` represent the same point (or boundary unit) in time.\n *\n * @example\n * ```ts\n * isSame(a, b, { tz: 'America/New_York', unit: 'day' })\n * // true when a and b fall on the same calendar day in New York\n * ```\n */\nexport function isSame(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) === 0;\n}\n\n/**\n * Returns `true` when `value` falls within `[start, end]` (inclusive, bounds normalized).\n * Pass `options.unit` to floor all three inputs to a calendar boundary before comparing.\n *\n * @example\n * ```ts\n * within(\n *   parseInstant('2026-03-21T11:00:00Z'),\n *   parseInstant('2026-03-21T10:00:00Z'),\n *   parseInstant('2026-03-21T12:00:00Z'),\n * ) // true\n * ```\n */\nexport function within(value: TimeInput, start: TimeInput, end: TimeInput, options: CompareOptions = {}): boolean {\n  if (!options.unit) {\n    const target = toInstant(value, options);\n    const [lower, upper] = normalizeRange(toInstant(start, options), toInstant(end, options));\n\n    return Temporal.Instant.compare(lower, target) <= 0 && Temporal.Instant.compare(target, upper) <= 0;\n  }\n\n  const { lower, target, upper } = resolveFlooredTriple(value, start, end, options.unit, options);\n\n  return Temporal.Instant.compare(lower, target) <= 0 && Temporal.Instant.compare(target, upper) <= 0;\n}\n\n/**\n * Clamps `value` to within `[start, end]` (bounds normalized).\n *\n * When `value` is a `ZonedDateTime`, returns a `ZonedDateTime` in the same timezone.\n * Otherwise returns an `Instant`.\n *\n * When `options.unit` is set, all three inputs are floored to that calendar boundary before\n * clamping — the result is at the start of the boundary unit, not the original time-of-day.\n *\n * @example\n * ```ts\n * clamp(\n *   parseInstant('2026-03-21T13:00:00Z'),\n *   parseInstant('2026-03-21T10:00:00Z'),\n *   parseInstant('2026-03-21T12:00:00Z'),\n * ).toString() // '2026-03-21T12:00:00Z'\n *\n * clamp(\n *   parseZoned('2026-03-21T13:00:00+00:00[UTC]'),\n *   parseZoned('2026-03-21T10:00:00+00:00[UTC]'),\n *   parseZoned('2026-03-21T12:00:00+00:00[UTC]'),\n * ).toString() // '2026-03-21T12:00:00+00:00[UTC]'\n * ```\n */\nexport function clamp(\n  value: Temporal.ZonedDateTime,\n  start: TimeInput,\n  end: TimeInput,\n  options?: CompareOptions,\n): Temporal.ZonedDateTime;\nexport function clamp(value: TimeInput, start: TimeInput, end: TimeInput, options?: CompareOptions): Temporal.Instant;\nexport function clamp(\n  value: TimeInput,\n  start: TimeInput,\n  end: TimeInput,\n  options: CompareOptions = {},\n): Temporal.Instant | Temporal.ZonedDateTime {\n  const isZoned = value instanceof Temporal.ZonedDateTime;\n  const tz = isZoned ? value.timeZoneId : undefined;\n\n  if (!options.unit) {\n    const target = toInstant(value, options);\n    const [lower, upper] = normalizeRange(toInstant(start, options), toInstant(end, options));\n\n    let clamped: Temporal.Instant;\n\n    if (Temporal.Instant.compare(target, lower) < 0) clamped = lower;\n    else if (Temporal.Instant.compare(target, upper) > 0) clamped = upper;\n    else clamped = target;\n\n    return isZoned && tz ? clamped.toZonedDateTimeISO(tz) : clamped;\n  }\n\n  const { lower, target, upper } = resolveFlooredTriple(value, start, end, options.unit, options);\n\n  let clamped: Temporal.Instant;\n\n  if (Temporal.Instant.compare(target, lower) < 0) clamped = lower;\n  else if (Temporal.Instant.compare(target, upper) > 0) clamped = upper;\n  else clamped = target;\n\n  // For unit-based clamping, resolve the output tz from options or from value's zone\n  const outTz = options.tz ?? tz ?? inferSharedTimeZone([value, start, end], options);\n\n  return isZoned ? clamped.toZonedDateTimeISO(outTz) : clamped;\n}\n"],"mappings":"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"}
+{"version":3,"file":"compare.js","names":[],"sources":["../src/compare.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nimport type { ClampInput, ContainsInput, CompareOptions, TimeInput } from './types';\n\nimport { toInstant } from './_convert';\nimport { floorToUnit } from './_floor';\nimport { inferSharedTimeZone, normalizeRange } from './_tz';\n\nfunction compareByUnit(a: TimeInput, b: TimeInput, options: CompareOptions): number {\n  if (!options.unit) return Temporal.Instant.compare(toInstant(a, options), toInstant(b, options));\n\n  const timeZone = inferSharedTimeZone([a, b], options);\n  const unitOptions = { timeZone, weekStartsOn: options.weekStartsOn };\n\n  return Temporal.Instant.compare(floorToUnit(a, options.unit, unitOptions), floorToUnit(b, options.unit, unitOptions));\n}\n\nfunction resolveRange({ end, start, value, ...options }: ContainsInput | ClampInput): {\n  lower: Temporal.Instant;\n  target: Temporal.Instant;\n  upper: Temporal.Instant;\n} {\n  if (!options.unit) {\n    const target = toInstant(value, options);\n    const [lower, upper] = normalizeRange(toInstant(start, options), toInstant(end, options));\n\n    return { lower, target, upper };\n  }\n\n  const timeZone = inferSharedTimeZone([value, start, end], options);\n  const unitOptions = { timeZone, weekStartsOn: options.weekStartsOn };\n  const target = floorToUnit(value, options.unit, unitOptions);\n  const [lower, upper] = normalizeRange(\n    floorToUnit(start, options.unit, unitOptions),\n    floorToUnit(end, options.unit, unitOptions),\n  );\n\n  return { lower, target, upper };\n}\n\nexport function isBefore(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) < 0;\n}\n\nexport function isAfter(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) > 0;\n}\n\nexport function isSame(a: TimeInput, b: TimeInput, options: CompareOptions = {}): boolean {\n  return compareByUnit(a, b, options) === 0;\n}\n\nexport function contains(input: ContainsInput): boolean {\n  const { lower, target, upper } = resolveRange(input);\n\n  return Temporal.Instant.compare(lower, target) <= 0 && Temporal.Instant.compare(target, upper) <= 0;\n}\n\nexport function clamp(input: ClampInput & { value: Temporal.ZonedDateTime }): Temporal.ZonedDateTime;\nexport function clamp(input: ClampInput): Temporal.Instant;\nexport function clamp(input: ClampInput): Temporal.Instant | Temporal.ZonedDateTime {\n  const { lower, target, upper } = resolveRange(input);\n  const clamped =\n    Temporal.Instant.compare(target, lower) < 0 ? lower : Temporal.Instant.compare(target, upper) > 0 ? upper : target;\n\n  return input.value instanceof Temporal.ZonedDateTime\n    ? clamped.toZonedDateTimeISO(input.timeZone ?? input.value.timeZoneId)\n    : clamped;\n}\n"],"mappings":";;;;;AAQA,SAAS,EAAc,GAAc,GAAc,GAAiC;CAClF,IAAI,CAAC,EAAQ,MAAM,OAAO,EAAS,QAAQ,QAAQ,EAAU,GAAG,CAAO,GAAG,EAAU,GAAG,CAAO,CAAC;CAG/F,IAAM,IAAc;EAAE,UADL,EAAoB,CAAC,GAAG,CAAC,GAAG,CACvB;EAAU,cAAc,EAAQ;CAAa;CAEnE,OAAO,EAAS,QAAQ,QAAQ,EAAY,GAAG,EAAQ,MAAM,CAAW,GAAG,EAAY,GAAG,EAAQ,MAAM,CAAW,CAAC;AACtH;AAEA,SAAS,EAAa,EAAE,QAAK,UAAO,UAAO,GAAG,KAI5C;CACA,IAAI,CAAC,EAAQ,MAAM;EACjB,IAAM,IAAS,EAAU,GAAO,CAAO,GACjC,CAAC,GAAO,KAAS,EAAe,EAAU,GAAO,CAAO,GAAG,EAAU,GAAK,CAAO,CAAC;EAExF,OAAO;GAAE;GAAO;GAAQ;EAAM;CAChC;CAGA,IAAM,IAAc;EAAE,UADL,EAAoB;GAAC;GAAO;GAAO;EAAG,GAAG,CACpC;EAAU,cAAc,EAAQ;CAAa,GAC7D,IAAS,EAAY,GAAO,EAAQ,MAAM,CAAW,GACrD,CAAC,GAAO,KAAS,EACrB,EAAY,GAAO,EAAQ,MAAM,CAAW,GAC5C,EAAY,GAAK,EAAQ,MAAM,CAAW,CAC5C;CAEA,OAAO;EAAE;EAAO;EAAQ;CAAM;AAChC;AAEA,SAAgB,EAAS,GAAc,GAAc,IAA0B,CAAC,GAAY;CAC1F,OAAO,EAAc,GAAG,GAAG,CAAO,IAAI;AACxC;AAEA,SAAgB,EAAQ,GAAc,GAAc,IAA0B,CAAC,GAAY;CACzF,OAAO,EAAc,GAAG,GAAG,CAAO,IAAI;AACxC;AAEA,SAAgB,EAAO,GAAc,GAAc,IAA0B,CAAC,GAAY;CACxF,OAAO,EAAc,GAAG,GAAG,CAAO,MAAM;AAC1C;AAEA,SAAgB,EAAS,GAA+B;CACtD,IAAM,EAAE,UAAO,WAAQ,aAAU,EAAa,CAAK;CAEnD,OAAO,EAAS,QAAQ,QAAQ,GAAO,CAAM,KAAK,KAAK,EAAS,QAAQ,QAAQ,GAAQ,CAAK,KAAK;AACpG;AAIA,SAAgB,EAAM,GAA8D;CAClF,IAAM,EAAE,UAAO,WAAQ,aAAU,EAAa,CAAK,GAC7C,IACJ,EAAS,QAAQ,QAAQ,GAAQ,CAAK,IAAI,IAAI,IAAQ,EAAS,QAAQ,QAAQ,GAAQ,CAAK,IAAI,IAAI,IAAQ;CAE9G,OAAO,EAAM,iBAAiB,EAAS,gBACnC,EAAQ,mBAAmB,EAAM,YAAY,EAAM,MAAM,UAAU,IACnE;AACN"}

package/dist/core.cjs

@@ -1,2 +1,2 @@
-const e=require("./errors.cjs"),t=require("./_tz.cjs"),n=require("./_convert.cjs");let r=require("@js-temporal/polyfill");function i(e){return r.Temporal.Now.zonedDateTimeISO(e)}function a(){return r.Temporal.Now.instant()}function o(t){try{return r.Temporal.ZonedDateTime.from(t)}catch{e.fail(`Invalid zoned date-time string: "${t}". Expected an ISO 8601 string with offset and timezone (e.g. 2026-03-21T10:00:00+01:00[Europe/Berlin]).`)}}function s(t){try{return r.Temporal.PlainDate.from(t)}catch{e.fail(`Invalid plain date string: "${t}". Expected an ISO 8601 date string (e.g. YYYY-MM-DD).`)}}function c(t){try{return r.Temporal.PlainDateTime.from(t)}catch{e.fail(`Invalid date/time string: "${t}". Expected an ISO 8601 date or date-time string (e.g. YYYY-MM-DD or YYYY-MM-DDTHH:mm:ss).`)}}function l(t){try{return r.Temporal.Instant.from(t)}catch{e.fail(`Invalid instant string: "${t}". Expected an ISO 8601 UTC string (e.g. YYYY-MM-DDTHH:mm:ssZ).`)}}function u(e,r,i={}){let a=t.inferTimeZone(e,i);return n.toZoned(e,{prefer:i.prefer,tz:a}).add(r)}function d(e,i,a={}){let{largestUnit:o,prefer:s,roundingIncrement:c,roundingMode:l,smallestUnit:u}=a,d={largestUnit:o,roundingIncrement:c,roundingMode:l,smallestUnit:u};if(!(o!==void 0&&t.CALENDAR_UNITS.has(o)||u!==void 0&&t.CALENDAR_UNITS.has(u))&&e instanceof r.Temporal.Instant&&i instanceof r.Temporal.Instant)return i.since(e,d);let f=t.inferSharedTimeZone([e,i],a);return n.toZoned(i,{prefer:s,tz:f}).since(n.toZoned(e,{prefer:s,tz:f}),d)}function f(e){return e instanceof r.Temporal.Instant||e instanceof r.Temporal.ZonedDateTime||e instanceof r.Temporal.PlainDateTime||e instanceof r.Temporal.PlainDate}function p(t,n){if(n===`zoned`)return o(t);if(n===`instant`)return l(t);if(n===`plain-datetime`)return c(t);if(n===`plain-date`)return s(t);try{return r.Temporal.ZonedDateTime.from(t)}catch{}try{return r.Temporal.Instant.from(t)}catch{}if(t.includes(`T`))try{return r.Temporal.PlainDateTime.from(t)}catch{}else try{return r.Temporal.PlainDate.from(t)}catch{}e.fail(`Unable to parse date/time string: "${t}". Expected ISO 8601 ZonedDateTime, Instant, PlainDateTime, or PlainDate.`)}exports.difference=d,exports.isValid=f,exports.now=i,exports.nowInstant=a,exports.parse=p,exports.parseInstant=l,exports.parsePlainDate=s,exports.parsePlainDateTime=c,exports.parseZoned=o,exports.shift=u;
+const e=require("./errors.cjs"),t=require("./_tz.cjs"),n=require("./_convert.cjs");let r=require("@js-temporal/polyfill");function i(t,n){try{return n.as===`zonedDateTime`?r.Temporal.ZonedDateTime.from(t):n.as===`instant`?r.Temporal.Instant.from(t):n.as===`plainDateTime`?r.Temporal.PlainDateTime.from(t):r.Temporal.PlainDate.from(t)}catch{e.fail(`Invalid ${n.as} ISO 8601 string: "${t}".`)}}function a(e){return r.Temporal.Now.zonedDateTimeISO(t.validateTimeZone(e.timeZone))}function o(){return r.Temporal.Now.instant()}function s(e,r,i={}){let a=t.inferTimeZone(e,i);return n.toZoned(e,{disambiguation:i.disambiguation,timeZone:a}).add(r)}function c(e){let{end:i,largestUnit:a,roundingIncrement:o,roundingMode:s,smallestUnit:c,start:l}=e,u={largestUnit:a,roundingIncrement:o,roundingMode:s,smallestUnit:c};if(!(a!==void 0&&t.CALENDAR_UNITS.has(a)||c!==void 0&&t.CALENDAR_UNITS.has(c))&&l instanceof r.Temporal.Instant&&i instanceof r.Temporal.Instant)return i.since(l,u);let d=t.inferSharedTimeZone([l,i],e),f={disambiguation:e.disambiguation,timeZone:d};return n.toZoned(i,f).since(n.toZoned(l,f),u)}function l(e){return e instanceof r.Temporal.Instant||e instanceof r.Temporal.ZonedDateTime||e instanceof r.Temporal.PlainDateTime||e instanceof r.Temporal.PlainDate}exports.difference=c,exports.isValid=l,exports.now=a,exports.nowInstant=o,exports.parse=i,exports.shift=s;
 //# sourceMappingURL=core.cjs.map

package/dist/core.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"core.cjs","names":[],"sources":["../src/core.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nimport type { CalendarUnit, DifferenceOptions, ParseAs, ShiftOptions, TimeInput } from './types';\n\nimport { toInstant, toZoned } from './_convert';\nimport { CALENDAR_UNITS, inferSharedTimeZone, inferTimeZone } from './_tz';\nimport { fail } from './errors';\n\ntype TimeOptionsWithTz = { tz: string };\n\n/**\n * Returns the current date and time in the given timezone.\n *\n * @example\n * ```ts\n * now('America/New_York').hour; // current hour in New York\n * ```\n */\nexport function now(tz: string): Temporal.ZonedDateTime {\n  return Temporal.Now.zonedDateTimeISO(tz);\n}\n\n/**\n * Returns the current absolute instant (UTC point in time).\n * Use this instead of `Temporal.Now.instant()` to avoid importing Temporal directly.\n *\n * @example\n * ```ts\n * timeDiff(nowInstant()) // { unit: 'millisecond', value: 0 } (compared to now)\n * expires(nowInstant(), { expired: { days: 0 }, safe: { years: 100 } }) // 'safe'\n * ```\n */\nexport function nowInstant(): Temporal.Instant {\n  return Temporal.Now.instant();\n}\n\n/**\n * Parses a full ISO 8601 zoned date-time string into a `ZonedDateTime`.\n * Use this instead of `Temporal.ZonedDateTime.from()` to avoid importing Temporal directly.\n *\n * @example\n * ```ts\n * parseZoned('2026-03-21T11:00:00+01:00[Europe/Berlin]')\n * parseZoned('2026-03-21T00:00:00[UTC]')\n * ```\n */\nexport function parseZoned(input: string): Temporal.ZonedDateTime {\n  try {\n    return Temporal.ZonedDateTime.from(input);\n  } catch {\n    fail(\n      `Invalid zoned date-time string: \"${input}\". Expected an ISO 8601 string with offset and timezone (e.g. 2026-03-21T10:00:00+01:00[Europe/Berlin]).`,\n    );\n  }\n}\n\n/**\n * Parses an ISO 8601 date-only string into a timezone-free `PlainDate`.\n * Use this instead of `Temporal.PlainDate.from()` to avoid importing Temporal directly.\n *\n * @example\n * ```ts\n * parsePlainDate('2026-03-21') // 2026-03-21\n * ```\n */\nexport function parsePlainDate(input: string): Temporal.PlainDate {\n  try {\n    return Temporal.PlainDate.from(input);\n  } catch {\n    fail(`Invalid plain date string: \"${input}\". Expected an ISO 8601 date string (e.g. YYYY-MM-DD).`);\n  }\n}\n\n/**\n * Parses an ISO 8601 string into a timezone-free `PlainDateTime` (wall-clock time).\n * Use {@link toInstant} or {@link inTz} to attach a timezone when needed.\n *\n * @example\n * ```ts\n * parsePlainDateTime('2026-03-21')             // 2026-03-21T00:00:00\n * parsePlainDateTime('2026-03-21T10:15:30')    // 2026-03-21T10:15:30\n * ```\n */\nexport function parsePlainDateTime(input: string): Temporal.PlainDateTime {\n  try {\n    return Temporal.PlainDateTime.from(input);\n  } catch {\n    fail(\n      `Invalid date/time string: \"${input}\". Expected an ISO 8601 date or date-time string (e.g. YYYY-MM-DD or YYYY-MM-DDTHH:mm:ss).`,\n    );\n  }\n}\n\n/**\n * Parses an ISO 8601 UTC string into an absolute `Instant`.\n *\n * @example\n * ```ts\n * parseInstant('2026-03-21T10:15:30Z')\n * ```\n */\nexport function parseInstant(input: string): Temporal.Instant {\n  try {\n    return Temporal.Instant.from(input);\n  } catch {\n    fail(`Invalid instant string: \"${input}\". Expected an ISO 8601 UTC string (e.g. YYYY-MM-DDTHH:mm:ssZ).`);\n  }\n}\n\n/**\n * DST-safe date arithmetic. Adds `duration` to `input` and returns the result as a\n * `ZonedDateTime`. Handles spring-forward and fall-back correctly.\n *\n * **Always returns a `ZonedDateTime`** — even when the input is an `Instant`.\n * Call `.toInstant()` on the result if you need an `Instant` back.\n * Requires `options.tz` when input is an `Instant`, `PlainDate`, or `PlainDateTime`.\n *\n * @example\n * ```ts\n * shift(parseZoned('2026-03-08T01:30:00-05:00[America/New_York]'), { hours: 1 })\n * // 2026-03-08T03:30:00-04:00[America/New_York]  (skipped the missing hour)\n *\n * // Instant input — tz required, result is ZonedDateTime\n * shift(parseInstant('2026-03-21T10:00:00Z'), { hours: 2 }, { tz: 'UTC' }).toInstant()\n * ```\n */\nexport function shift(\n  input: Temporal.ZonedDateTime,\n  duration: Temporal.DurationLike,\n  options?: ShiftOptions,\n): Temporal.ZonedDateTime;\nexport function shift(\n  input: Temporal.Instant | Temporal.PlainDate | Temporal.PlainDateTime,\n  duration: Temporal.DurationLike,\n  options: ShiftOptions & TimeOptionsWithTz,\n): Temporal.ZonedDateTime;\nexport function shift(\n  input: TimeInput,\n  duration: Temporal.DurationLike,\n  options: ShiftOptions = {},\n): Temporal.ZonedDateTime {\n  const tz = inferTimeZone(input, options);\n\n  return toZoned(input, { prefer: options.prefer, tz }).add(duration);\n}\n\n/**\n * Returns the calendar-aware duration between `start` and `end`.\n *\n * When both inputs are `Instant` and no calendar unit is requested, the fast\n * path skips timezone conversion. Calendar units (`day`, `week`, `month`, `year`)\n * always require a timezone — pass `options.tz` or use `ZonedDateTime` inputs.\n * `options.prefer` (DST disambiguation) is only meaningful for `PlainDateTime` inputs.\n *\n * @example\n * ```ts\n * difference(\n *   parseZoned('2026-03-08T00:00:00-05:00[America/New_York]'),\n *   parseZoned('2026-03-09T00:00:00-04:00[America/New_York]'),\n *   { largestUnit: 'hour' },\n * ).hours // 23  (DST spring-forward day)\n * ```\n */\nexport function difference(start: TimeInput, end: TimeInput, options: DifferenceOptions = {}): Temporal.Duration {\n  const { largestUnit, prefer, roundingIncrement, roundingMode, smallestUnit } = options;\n  const roundingOptions = { largestUnit, roundingIncrement, roundingMode, smallestUnit };\n\n  const needsCalendar =\n    (largestUnit !== undefined && CALENDAR_UNITS.has(largestUnit as CalendarUnit)) ||\n    (smallestUnit !== undefined && CALENDAR_UNITS.has(smallestUnit as CalendarUnit));\n\n  if (!needsCalendar && start instanceof Temporal.Instant && end instanceof Temporal.Instant) {\n    return end.since(start, roundingOptions as Temporal.DifferenceOptions<Temporal.TimeUnit>);\n  }\n\n  const tz = inferSharedTimeZone([start, end], options);\n\n  return toZoned(end, { prefer, tz }).since(toZoned(start, { prefer, tz }), roundingOptions);\n}\n\n/**\n * Type guard that checks whether `value` is a valid `TimeInput`.\n *\n * @example\n * ```ts\n * isValid(parseInstant('2026-03-21T10:00:00Z')) // true\n * isValid('2026-03-21')                         // false\n * ```\n */\nexport function isValid(value: unknown): value is TimeInput {\n  return (\n    value instanceof Temporal.Instant ||\n    value instanceof Temporal.ZonedDateTime ||\n    value instanceof Temporal.PlainDateTime ||\n    value instanceof Temporal.PlainDate\n  );\n}\n\n/**\n * Parses any ISO 8601 string into the most specific `TimeInput` type possible.\n * Tries ZonedDateTime → Instant → PlainDateTime → PlainDate in order.\n * Throws a descriptive `TypeError` if none match.\n *\n * Pass `as` to request a specific return type (throws if the string cannot be parsed as that type):\n *\n * @example\n * ```ts\n * parse('2026-03-21T11:00:00+01:00[Europe/Berlin]')           // TimeInput (auto-detect)\n * parse('2026-03-21T11:00:00+01:00[Europe/Berlin]', 'zoned')  // Temporal.ZonedDateTime\n * parse('2026-03-21T10:00:00Z', 'instant')                    // Temporal.Instant\n * parse('2026-03-21T10:00:00', 'plain-datetime')              // Temporal.PlainDateTime\n * parse('2026-03-21', 'plain-date')                           // Temporal.PlainDate\n * ```\n */\nexport function parse(input: string, as: 'zoned'): Temporal.ZonedDateTime;\nexport function parse(input: string, as: 'instant'): Temporal.Instant;\nexport function parse(input: string, as: 'plain-datetime'): Temporal.PlainDateTime;\nexport function parse(input: string, as: 'plain-date'): Temporal.PlainDate;\nexport function parse(input: string, as?: ParseAs): TimeInput;\nexport function parse(input: string, as?: ParseAs): TimeInput {\n  if (as === 'zoned') return parseZoned(input);\n\n  if (as === 'instant') return parseInstant(input);\n\n  if (as === 'plain-datetime') return parsePlainDateTime(input);\n\n  if (as === 'plain-date') return parsePlainDate(input);\n\n  try {\n    return Temporal.ZonedDateTime.from(input);\n  } catch {\n    /* try next format */\n  }\n\n  try {\n    return Temporal.Instant.from(input);\n  } catch {\n    /* try next format */\n  }\n\n  // Try PlainDateTime before PlainDate — a date-only string (no 'T') will also\n  // be accepted by PlainDateTime.from(), producing midnight, so we check the\n  // string to pick the most specific type.\n  if (input.includes('T')) {\n    try {\n      return Temporal.PlainDateTime.from(input);\n    } catch {\n      /* fall through to error */\n    }\n  } else {\n    try {\n      return Temporal.PlainDate.from(input);\n    } catch {\n      /* fall through to error */\n    }\n  }\n\n  fail(\n    `Unable to parse date/time string: \"${input}\". Expected ISO 8601 ZonedDateTime, Instant, PlainDateTime, or PlainDate.`,\n  );\n}\n"],"mappings":"0HAkBA,SAAgB,EAAI,EAAoC,CACtD,OAAO,EAAA,SAAS,IAAI,iBAAiB,CAAE,CACzC,CAYA,SAAgB,GAA+B,CAC7C,OAAO,EAAA,SAAS,IAAI,QAAQ,CAC9B,CAYA,SAAgB,EAAW,EAAuC,CAChE,GAAI,CACF,OAAO,EAAA,SAAS,cAAc,KAAK,CAAK,CAC1C,MAAQ,CACN,EAAA,KACE,oCAAoC,EAAM,yGAC5C,CACF,CACF,CAWA,SAAgB,EAAe,EAAmC,CAChE,GAAI,CACF,OAAO,EAAA,SAAS,UAAU,KAAK,CAAK,CACtC,MAAQ,CACN,EAAA,KAAK,+BAA+B,EAAM,uDAAuD,CACnG,CACF,CAYA,SAAgB,EAAmB,EAAuC,CACxE,GAAI,CACF,OAAO,EAAA,SAAS,cAAc,KAAK,CAAK,CAC1C,MAAQ,CACN,EAAA,KACE,8BAA8B,EAAM,2FACtC,CACF,CACF,CAUA,SAAgB,EAAa,EAAiC,CAC5D,GAAI,CACF,OAAO,EAAA,SAAS,QAAQ,KAAK,CAAK,CACpC,MAAQ,CACN,EAAA,KAAK,4BAA4B,EAAM,gEAAgE,CACzG,CACF,CA6BA,SAAgB,EACd,EACA,EACA,EAAwB,CAAC,EACD,CACxB,IAAM,EAAK,EAAA,cAAc,EAAO,CAAO,EAEvC,OAAO,EAAA,QAAQ,EAAO,CAAE,OAAQ,EAAQ,OAAQ,IAAG,CAAC,CAAC,CAAC,IAAI,CAAQ,CACpE,CAmBA,SAAgB,EAAW,EAAkB,EAAgB,EAA6B,CAAC,EAAsB,CAC/G,GAAM,CAAE,cAAa,SAAQ,oBAAmB,eAAc,gBAAiB,EACzE,EAAkB,CAAE,cAAa,oBAAmB,eAAc,cAAa,EAMrF,GAAI,EAHD,IAAgB,IAAA,IAAa,EAAA,eAAe,IAAI,CAA2B,GAC3E,IAAiB,IAAA,IAAa,EAAA,eAAe,IAAI,CAA4B,IAE1D,aAAiB,EAAA,SAAS,SAAW,aAAe,EAAA,SAAS,QACjF,OAAO,EAAI,MAAM,EAAO,CAAgE,EAG1F,IAAM,EAAK,EAAA,oBAAoB,CAAC,EAAO,CAAG,EAAG,CAAO,EAEpD,OAAO,EAAA,QAAQ,EAAK,CAAE,SAAQ,IAAG,CAAC,CAAC,CAAC,MAAM,EAAA,QAAQ,EAAO,CAAE,SAAQ,IAAG,CAAC,EAAG,CAAe,CAC3F,CAWA,SAAgB,EAAQ,EAAoC,CAC1D,OACE,aAAiB,EAAA,SAAS,SAC1B,aAAiB,EAAA,SAAS,eAC1B,aAAiB,EAAA,SAAS,eAC1B,aAAiB,EAAA,SAAS,SAE9B,CAuBA,SAAgB,EAAM,EAAe,EAAyB,CAC5D,GAAI,IAAO,QAAS,OAAO,EAAW,CAAK,EAE3C,GAAI,IAAO,UAAW,OAAO,EAAa,CAAK,EAE/C,GAAI,IAAO,iBAAkB,OAAO,EAAmB,CAAK,EAE5D,GAAI,IAAO,aAAc,OAAO,EAAe,CAAK,EAEpD,GAAI,CACF,OAAO,EAAA,SAAS,cAAc,KAAK,CAAK,CAC1C,MAAQ,CAER,CAEA,GAAI,CACF,OAAO,EAAA,SAAS,QAAQ,KAAK,CAAK,CACpC,MAAQ,CAER,CAKA,GAAI,EAAM,SAAS,GAAG,EACpB,GAAI,CACF,OAAO,EAAA,SAAS,cAAc,KAAK,CAAK,CAC1C,MAAQ,CAER,MAEA,GAAI,CACF,OAAO,EAAA,SAAS,UAAU,KAAK,CAAK,CACtC,MAAQ,CAER,CAGF,EAAA,KACE,sCAAsC,EAAM,0EAC9C,CACF"}
+{"version":3,"file":"core.cjs","names":[],"sources":["../src/core.ts"],"sourcesContent":["import { Temporal } from '@js-temporal/polyfill';\n\nimport type { CalendarUnit, DifferenceInput, ParseAs, ShiftOptions, TimeInput } from './types';\n\nimport { toZoned } from './_convert';\nimport { CALENDAR_UNITS, inferSharedTimeZone, inferTimeZone, validateTimeZone } from './_tz';\nimport { fail } from './errors';\n\n/** Parse intentionally requires an explicit result kind: time strings are ambiguous at system boundaries. */\nexport function parse(input: string, options: { as: 'zonedDateTime' }): Temporal.ZonedDateTime;\nexport function parse(input: string, options: { as: 'instant' }): Temporal.Instant;\nexport function parse(input: string, options: { as: 'plainDateTime' }): Temporal.PlainDateTime;\nexport function parse(input: string, options: { as: 'plainDate' }): Temporal.PlainDate;\nexport function parse(input: string, options: { as: ParseAs }): TimeInput {\n  try {\n    if (options.as === 'zonedDateTime') return Temporal.ZonedDateTime.from(input);\n\n    if (options.as === 'instant') return Temporal.Instant.from(input);\n\n    if (options.as === 'plainDateTime') return Temporal.PlainDateTime.from(input);\n\n    return Temporal.PlainDate.from(input);\n  } catch {\n    fail(`Invalid ${options.as} ISO 8601 string: \"${input}\".`);\n  }\n}\n\nexport function now(options: { timeZone: string }): Temporal.ZonedDateTime {\n  return Temporal.Now.zonedDateTimeISO(validateTimeZone(options.timeZone));\n}\n\nexport function nowInstant(): Temporal.Instant {\n  return Temporal.Now.instant();\n}\n\nexport function shift(\n  input: Temporal.ZonedDateTime,\n  duration: Temporal.DurationLike,\n  options?: ShiftOptions,\n): Temporal.ZonedDateTime;\nexport function shift(\n  input: Exclude<TimeInput, Temporal.ZonedDateTime>,\n  duration: Temporal.DurationLike,\n  options: ShiftOptions & { timeZone: string },\n): Temporal.ZonedDateTime;\nexport function shift(\n  input: TimeInput,\n  duration: Temporal.DurationLike,\n  options: ShiftOptions = {},\n): Temporal.ZonedDateTime {\n  const timeZone = inferTimeZone(input, options);\n\n  return toZoned(input, { disambiguation: options.disambiguation, timeZone }).add(duration);\n}\n\nexport function difference(input: DifferenceInput): Temporal.Duration {\n  const { end, largestUnit, roundingIncrement, roundingMode, smallestUnit, start } = input;\n  const rounding = { largestUnit, roundingIncrement, roundingMode, smallestUnit };\n  const needsCalendar =\n    (largestUnit !== undefined && CALENDAR_UNITS.has(largestUnit as CalendarUnit)) ||\n    (smallestUnit !== undefined && CALENDAR_UNITS.has(smallestUnit as CalendarUnit));\n\n  if (!needsCalendar && start instanceof Temporal.Instant && end instanceof Temporal.Instant) {\n    return end.since(start, rounding as Temporal.DifferenceOptions<Temporal.TimeUnit>);\n  }\n\n  const timeZone = inferSharedTimeZone([start, end], input);\n  const options = { disambiguation: input.disambiguation, timeZone };\n\n  return toZoned(end, options).since(toZoned(start, options), rounding);\n}\n\nexport function isValid(value: unknown): value is TimeInput {\n  return (\n    value instanceof Temporal.Instant ||\n    value instanceof Temporal.ZonedDateTime ||\n    value instanceof Temporal.PlainDateTime ||\n    value instanceof Temporal.PlainDate\n  );\n}\n"],"mappings":"0HAaA,SAAgB,EAAM,EAAe,EAAqC,CACxE,GAAI,CAOF,OANI,EAAQ,KAAO,gBAAwB,EAAA,SAAS,cAAc,KAAK,CAAK,EAExE,EAAQ,KAAO,UAAkB,EAAA,SAAS,QAAQ,KAAK,CAAK,EAE5D,EAAQ,KAAO,gBAAwB,EAAA,SAAS,cAAc,KAAK,CAAK,EAErE,EAAA,SAAS,UAAU,KAAK,CAAK,CACtC,MAAQ,CACN,EAAA,KAAK,WAAW,EAAQ,GAAG,qBAAqB,EAAM,GAAG,CAC3D,CACF,CAEA,SAAgB,EAAI,EAAuD,CACzE,OAAO,EAAA,SAAS,IAAI,iBAAiB,EAAA,iBAAiB,EAAQ,QAAQ,CAAC,CACzE,CAEA,SAAgB,GAA+B,CAC7C,OAAO,EAAA,SAAS,IAAI,QAAQ,CAC9B,CAYA,SAAgB,EACd,EACA,EACA,EAAwB,CAAC,EACD,CACxB,IAAM,EAAW,EAAA,cAAc,EAAO,CAAO,EAE7C,OAAO,EAAA,QAAQ,EAAO,CAAE,eAAgB,EAAQ,eAAgB,UAAS,CAAC,CAAC,CAAC,IAAI,CAAQ,CAC1F,CAEA,SAAgB,EAAW,EAA2C,CACpE,GAAM,CAAE,MAAK,cAAa,oBAAmB,eAAc,eAAc,SAAU,EAC7E,EAAW,CAAE,cAAa,oBAAmB,eAAc,cAAa,EAK9E,GAAI,EAHD,IAAgB,IAAA,IAAa,EAAA,eAAe,IAAI,CAA2B,GAC3E,IAAiB,IAAA,IAAa,EAAA,eAAe,IAAI,CAA4B,IAE1D,aAAiB,EAAA,SAAS,SAAW,aAAe,EAAA,SAAS,QACjF,OAAO,EAAI,MAAM,EAAO,CAAyD,EAGnF,IAAM,EAAW,EAAA,oBAAoB,CAAC,EAAO,CAAG,EAAG,CAAK,EAClD,EAAU,CAAE,eAAgB,EAAM,eAAgB,UAAS,EAEjE,OAAO,EAAA,QAAQ,EAAK,CAAO,CAAC,CAAC,MAAM,EAAA,QAAQ,EAAO,CAAO,EAAG,CAAQ,CACtE,CAEA,SAAgB,EAAQ,EAAoC,CAC1D,OACE,aAAiB,EAAA,SAAS,SAC1B,aAAiB,EAAA,SAAS,eAC1B,aAAiB,EAAA,SAAS,eAC1B,aAAiB,EAAA,SAAS,SAE9B"}