temporal-fmt 0.9.71 → 0.9.80

package/dist/chunk-UGYSEYUQ.js

@@ -0,0 +1,168 @@
+import {
+  asDateFieldView
+} from "./chunk-KEPIXQK7.js";
+import {
+  dayOfWeekFromCivil,
+  daysFromCivil
+} from "./chunk-BLZDBPSV.js";
+
+// src/comparison.ts
+function toComparableMs(view) {
+  const days = daysFromCivil(view.year, view.month, view.day);
+  const MS_PER_HOUR = 36e5;
+  const MS_PER_MINUTE = 6e4;
+  const MS_PER_SECOND = 1e3;
+  return days * 864e5 + (view.hour ?? 0) * MS_PER_HOUR + (view.minute ?? 0) * MS_PER_MINUTE + (view.second ?? 0) * MS_PER_SECOND + (view.millisecond ?? 0);
+}
+function asDateTimeFieldView(value) {
+  const v = asDateFieldView(value);
+  return v;
+}
+function compare(a, b) {
+  const av = asDateTimeFieldView(a);
+  const bv = asDateTimeFieldView(b);
+  const am = toComparableMs(av);
+  const bm = toComparableMs(bv);
+  if (am < bm) return -1;
+  if (am > bm) return 1;
+  return 0;
+}
+function isEqual(a, b) {
+  return compare(a, b) === 0;
+}
+function isBefore(a, b) {
+  return compare(a, b) < 0;
+}
+function isAfter(a, b) {
+  return compare(a, b) > 0;
+}
+function min(values) {
+  if (!Array.isArray(values) || values.length === 0) {
+    throw new Error("temporal-fmt: min() requires a non-empty array of values.");
+  }
+  let best = values[0];
+  for (let i = 1; i < values.length; i++) {
+    if (compare(values[i], best) < 0) best = values[i];
+  }
+  return best;
+}
+function max(values) {
+  if (!Array.isArray(values) || values.length === 0) {
+    throw new Error("temporal-fmt: max() requires a non-empty array of values.");
+  }
+  let best = values[0];
+  for (let i = 1; i < values.length; i++) {
+    if (compare(values[i], best) > 0) best = values[i];
+  }
+  return best;
+}
+function clamp(value, lo, hi) {
+  if (compare(value, lo) < 0) return lo;
+  if (compare(value, hi) > 0) return hi;
+  return value;
+}
+function isBetween(value, lo, hi) {
+  return compare(value, lo) >= 0 && compare(value, hi) <= 0;
+}
+function readYearMonthDay(value) {
+  const v = asDateFieldView(value);
+  return { year: v.year, month: v.month, day: v.day };
+}
+function todayYearMonthDay() {
+  const now = /* @__PURE__ */ new Date();
+  return { year: now.getFullYear(), month: now.getMonth() + 1, day: now.getDate() };
+}
+function dateEqualYearMonthDay(a, b) {
+  return a.year === b.year && a.month === b.month && a.day === b.day;
+}
+function isSameDay(value, reference) {
+  return dateEqualYearMonthDay(readYearMonthDay(value), readYearMonthDay(reference));
+}
+function isToday(value) {
+  return dateEqualYearMonthDay(readYearMonthDay(value), todayYearMonthDay());
+}
+function tomorrowYearMonthDay() {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() + 1);
+  return { year: d.getFullYear(), month: d.getMonth() + 1, day: d.getDate() };
+}
+function yesterdayYearMonthDay() {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() - 1);
+  return { year: d.getFullYear(), month: d.getMonth() + 1, day: d.getDate() };
+}
+function isTomorrow(value) {
+  return dateEqualYearMonthDay(readYearMonthDay(value), tomorrowYearMonthDay());
+}
+function isYesterday(value) {
+  return dateEqualYearMonthDay(readYearMonthDay(value), yesterdayYearMonthDay());
+}
+function sameWeek(yearA, monthA, dayA, yearB, monthB, dayB) {
+  const daysSince = (y, m, d) => {
+    return daysFromCivil(y, m, d);
+  };
+  const a = daysSince(yearA, monthA, dayA);
+  const b = daysSince(yearB, monthB, dayB);
+  if (Math.abs(a - b) >= 7) return false;
+  const weekdayOf = (y, m, d) => {
+    return dayOfWeekFromCivil(y, m, d);
+  };
+  const wa = a - (weekdayOf(yearA, monthA, dayA) - 1);
+  const wb = b - (weekdayOf(yearB, monthB, dayB) - 1);
+  return wa === wb;
+}
+function isSameWeek(value, reference) {
+  const a = readYearMonthDay(value);
+  const b = readYearMonthDay(reference);
+  return sameWeek(a.year, a.month, a.day, b.year, b.month, b.day);
+}
+function isSameMonth(value, reference) {
+  const a = readYearMonthDay(value);
+  const b = readYearMonthDay(reference);
+  return a.year === b.year && a.month === b.month;
+}
+function isSameQuarter(value, reference) {
+  const a = readYearMonthDay(value);
+  const b = readYearMonthDay(reference);
+  return a.year === b.year && Math.ceil(a.month / 3) === Math.ceil(b.month / 3);
+}
+function isSameYear(value, reference) {
+  return readYearMonthDay(value).year === readYearMonthDay(reference).year;
+}
+function isWeekend(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`temporal-fmt: isWeekend() expected a Temporal value, got ${String(value)}.`);
+  }
+  const v = value;
+  if (typeof v.dayOfWeek !== "number") {
+    throw new Error(
+      `temporal-fmt: isWeekend() needs a value with a dayOfWeek field (PlainDate / PlainDateTime / ZonedDateTime).`
+    );
+  }
+  return v.dayOfWeek === 6 || v.dayOfWeek === 7;
+}
+function isWeekday(value) {
+  return !isWeekend(value);
+}
+
+export {
+  compare,
+  isEqual,
+  isBefore,
+  isAfter,
+  min,
+  max,
+  clamp,
+  isBetween,
+  isSameDay,
+  isToday,
+  isTomorrow,
+  isYesterday,
+  isSameWeek,
+  isSameMonth,
+  isSameQuarter,
+  isSameYear,
+  isWeekend,
+  isWeekday
+};
+//# sourceMappingURL=chunk-UGYSEYUQ.js.map

package/dist/chunk-UGYSEYUQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/comparison.ts"],"sourcesContent":["/*\n * Copyright 2026 DirazCoder\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// Comparison helpers. Pure functions over the field\n// shape, no Temporal namespace needed — same convention as\n// calendarUtils.ts. All comparisons are field-based, not identity-based,\n// so a polyfill PlainDate compares equal to a native PlainDate with the\n// same year/month/day.\n\nimport { asDateFieldView, type DateFieldView } from './calendarUtils.js';\nimport { dayOfWeekFromCivil, daysFromCivil } from './isoWeek.js';\n\ninterface DateTimeFieldView extends DateFieldView {\n  hour?: number;\n  minute?: number;\n  second?: number;\n  millisecond?: number;\n}\n\nfunction toComparableMs(view: DateTimeFieldView): number {\n  // Exact proleptic-Gregorian day count (Howard Hinnant's days_from_civil,\n  // same algorithm arithmetic.ts/interval.ts use) plus the time-of-day —\n  // NOT an approximation. The previous implementation multiplied the\n  // year offset by an average 365.2425 days/year, on the theory that the\n  // error \"is constant for any given year, so it cancels out in a diff\".\n  // That's only true when both dates fall in the same year: the year\n  // term's error differs by up to ~0.76 days between adjacent years\n  // (365.2425 vs 365/366 actual), which corrupts cross-year comparisons\n  // near the boundary — e.g. isAfter(2025-01-01T00:00, 2024-12-31T18:12)\n  // returned false (truth: ~5.8h after), and isEqual() returned true for\n  // instants ~18h apart (2025-01-01T00:00 vs 2024-12-31T05:49:12).\n  // Exact arithmetic has no such error term. The day count itself comes\n  // from isoWeek.ts's daysFromCivil (Howard Hinnant's days_from_civil:\n  // O(1), correct for negative years — the inlined era formula this\n  // replaced double-corrected pre-year-0 dates by a day via Math.floor\n  // of the -399-offset numerator).\n  const days = daysFromCivil(view.year!, view.month!, view.day!);\n\n  const MS_PER_HOUR = 3_600_000;\n  const MS_PER_MINUTE = 60_000;\n  const MS_PER_SECOND = 1_000;\n\n  return days * 86_400_000\n    + (view.hour ?? 0) * MS_PER_HOUR\n    + (view.minute ?? 0) * MS_PER_MINUTE\n    + (view.second ?? 0) * MS_PER_SECOND\n    + (view.millisecond ?? 0);\n}\n\nfunction asDateTimeFieldView(value: unknown): DateTimeFieldView {\n  const v = asDateFieldView(value);\n  return v as DateTimeFieldView;\n}\n\n// Returns < 0 if a < b, 0 if a === b, > 0 if a > b. Same convention as\n// Array.prototype.sort and Temporal.PlainDate.compare. Lets callers\n// pass this directly as a comparator.\nexport function compare(a: unknown, b: unknown): number {\n  const av = asDateTimeFieldView(a);\n  const bv = asDateTimeFieldView(b);\n  const am = toComparableMs(av);\n  const bm = toComparableMs(bv);\n  if (am < bm) return -1;\n  if (am > bm) return 1;\n  return 0;\n}\n\nexport function isEqual(a: unknown, b: unknown): boolean {\n  return compare(a, b) === 0;\n}\n\nexport function isBefore(a: unknown, b: unknown): boolean {\n  return compare(a, b) < 0;\n}\n\nexport function isAfter(a: unknown, b: unknown): boolean {\n  return compare(a, b) > 0;\n}\n\nexport function min(values: unknown[]): unknown {\n  if (!Array.isArray(values) || values.length === 0) {\n    throw new Error('temporal-fmt: min() requires a non-empty array of values.');\n  }\n  let best = values[0];\n  for (let i = 1; i < values.length; i++) {\n    if (compare(values[i], best) < 0) best = values[i];\n  }\n  return best;\n}\n\nexport function max(values: unknown[]): unknown {\n  if (!Array.isArray(values) || values.length === 0) {\n    throw new Error('temporal-fmt: max() requires a non-empty array of values.');\n  }\n  let best = values[0];\n  for (let i = 1; i < values.length; i++) {\n    if (compare(values[i], best) > 0) best = values[i];\n  }\n  return best;\n}\n\nexport function clamp(value: unknown, lo: unknown, hi: unknown): unknown {\n  if (compare(value, lo) < 0) return lo;\n  if (compare(value, hi) > 0) return hi;\n  return value;\n}\n\nexport function isBetween(value: unknown, lo: unknown, hi: unknown): boolean {\n  return compare(value, lo) >= 0 && compare(value, hi) <= 0;\n}\n\n// Semantic helpers — same-day/week/month/quarter/year tests. Useful for\n// UI (\"is this event today?\") and for grouping/aggregation. All take a\n// reference value to compare against; the \"isToday\" / \"isTomorrow\" /\n// \"isYesterday\" variants compute the reference from the current system\n// date themselves so callers don't have to.\nfunction readYearMonthDay(value: unknown): { year: number; month: number; day: number } {\n  const v = asDateFieldView(value);\n  return { year: v.year!, month: v.month!, day: v.day! };\n}\n\nfunction todayYearMonthDay(): { year: number; month: number; day: number } {\n  const now = new Date();\n  return { year: now.getFullYear(), month: now.getMonth() + 1, day: now.getDate() };\n}\n\nfunction dateEqualYearMonthDay(a: { year: number; month: number; day: number }, b: { year: number; month: number; day: number }): boolean {\n  return a.year === b.year && a.month === b.month && a.day === b.day;\n}\n\nexport function isSameDay(value: unknown, reference: unknown): boolean {\n  return dateEqualYearMonthDay(readYearMonthDay(value), readYearMonthDay(reference));\n}\n\nexport function isToday(value: unknown): boolean {\n  return dateEqualYearMonthDay(readYearMonthDay(value), todayYearMonthDay());\n}\n\nfunction tomorrowYearMonthDay(): { year: number; month: number; day: number } {\n  const d = new Date();\n  d.setDate(d.getDate() + 1);\n  return { year: d.getFullYear(), month: d.getMonth() + 1, day: d.getDate() };\n}\n\nfunction yesterdayYearMonthDay(): { year: number; month: number; day: number } {\n  const d = new Date();\n  d.setDate(d.getDate() - 1);\n  return { year: d.getFullYear(), month: d.getMonth() + 1, day: d.getDate() };\n}\n\nexport function isTomorrow(value: unknown): boolean {\n  return dateEqualYearMonthDay(readYearMonthDay(value), tomorrowYearMonthDay());\n}\n\nexport function isYesterday(value: unknown): boolean {\n  return dateEqualYearMonthDay(readYearMonthDay(value), yesterdayYearMonthDay());\n}\n\nfunction sameWeek(yearA: number, monthA: number, dayA: number, yearB: number, monthB: number, dayB: number): boolean {\n  // Same week iff the dates are within 7 days of each other AND the earlier\n  // one's weekday is ≤ the later one's weekday (so we don't say \"Sun and\n  // the following Mon are in the same week\" — ISO weeks run Mon-Sun).\n  // Easier: compute ISO week numbers via isoWeekYearAndWeek, compare both\n  // year and week. That handles the year-boundary case (Dec 31 vs Jan 1 of\n  // the next year, which can be in the same ISO week).\n  // Local import to avoid module-cycle: isoWeek.ts doesn't import from here.\n  // Lazy require-style dynamic via inline static import at top would be\n  // cleaner; this inline computation is fine for a pure helper.\n  // ...actually let's just compute weekday offsets directly. Same-ISO-week\n  // iff |d1 - d2| < 7 days AND the earlier date's ISO weekday ≤ the later\n  // date's ISO weekday so they fall in the same Mon-Sun span.\n  const daysSince = (y: number, m: number, d: number): number => {\n    // daysFromCivil: O(1), correct for negative years. (The inlined\n    // formula this replaced was the one remaining copy of the\n    // Math.floor-of-offset era bug — see daysFromCivil's comment.)\n    return daysFromCivil(y, m, d);\n  };\n  const a = daysSince(yearA, monthA, dayA);\n  const b = daysSince(yearB, monthB, dayB);\n  if (Math.abs(a - b) >= 7) return false;\n  // Same week iff both dates round to the same Monday. Compute the\n  // Monday-of-week for each: subtract (weekday - 1) days, where weekday\n  // is 1=Mon..7=Sun. Use the standard Zeller formula for weekday.\n  const weekdayOf = (y: number, m: number, d: number): number => {\n    // O(1) proleptic-Gregorian weekday from isoWeek.ts's dayOfWeekFromCivil.\n    // The old Date.UTC(y, m-1, d) form remapped years 0-99 to 1900-1999\n    // (ECMAScript spec), computing the weekday of the wrong century for\n    // first-century dates.\n    return dayOfWeekFromCivil(y, m, d);\n  };\n  const wa = a - (weekdayOf(yearA, monthA, dayA) - 1);\n  const wb = b - (weekdayOf(yearB, monthB, dayB) - 1);\n  return wa === wb;\n}\n\nexport function isSameWeek(value: unknown, reference: unknown): boolean {\n  const a = readYearMonthDay(value);\n  const b = readYearMonthDay(reference);\n  return sameWeek(a.year, a.month, a.day, b.year, b.month, b.day);\n}\n\nexport function isSameMonth(value: unknown, reference: unknown): boolean {\n  const a = readYearMonthDay(value);\n  const b = readYearMonthDay(reference);\n  return a.year === b.year && a.month === b.month;\n}\n\nexport function isSameQuarter(value: unknown, reference: unknown): boolean {\n  const a = readYearMonthDay(value);\n  const b = readYearMonthDay(reference);\n  return a.year === b.year && Math.ceil(a.month / 3) === Math.ceil(b.month / 3);\n}\n\nexport function isSameYear(value: unknown, reference: unknown): boolean {\n  return readYearMonthDay(value).year === readYearMonthDay(reference).year;\n}\n\n// isWeekend / isWeekday depend on dayOfWeek — present on PlainDate,\n// PlainDateTime, ZonedDateTime, but NOT on PlainTime. Callers passing\n// PlainTime get a descriptive throw. Doesn't call asDateFieldView\n// because that would reject PlainTime (no year/month/day) before\n// reaching the dayOfWeek check — and the error we want here is the\n// \"no dayOfWeek field\" one, not the \"no date fields\" one.\nexport function isWeekend(value: unknown): boolean {\n  if (typeof value !== 'object' || value === null) {\n    throw new Error(`temporal-fmt: isWeekend() expected a Temporal value, got ${String(value)}.`);\n  }\n  const v = value as { dayOfWeek?: unknown };\n  if (typeof v.dayOfWeek !== 'number') {\n    throw new Error(\n      `temporal-fmt: isWeekend() needs a value with a dayOfWeek field (PlainDate / PlainDateTime / ZonedDateTime).`\n    );\n  }\n  // 6=Sat, 7=Sun in Temporal's Mon=1..Sun=7 numbering.\n  return v.dayOfWeek === 6 || v.dayOfWeek === 7;\n}\n\nexport function isWeekday(value: unknown): boolean {\n  return !isWeekend(value);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-3SC5AVSY.js → chunk-WEVNKOQA.js}

@@ -1,6 +1,6 @@
 import {
   DEFAULT_LOCALE
-} from "./chunk-BQET6RUR.js";
+} from "./chunk-Z245NHDT.js";
 import {
   InvalidLocaleError,
   normalizeLocaleTag
@@ -62,4 +62,4 @@ export {
   formatRelative,
   formatRelativeToNow
 };
-//# sourceMappingURL=chunk-3SC5AVSY.js.map
+//# sourceMappingURL=chunk-WEVNKOQA.js.map

package/dist/chunk-WP7TBCTT.js

@@ -0,0 +1,241 @@
+import {
+  format,
+  formatToParts
+} from "./chunk-HGRT37LT.js";
+import {
+  normalizeLocaleTag
+} from "./chunk-QRLQ7RR7.js";
+import {
+  compare
+} from "./chunk-UGYSEYUQ.js";
+import {
+  asDateFieldView
+} from "./chunk-KEPIXQK7.js";
+import {
+  daysFromCivil
+} from "./chunk-BLZDBPSV.js";
+
+// src/interval.ts
+function interval(start, end, bounds = "closed") {
+  const cmp = compare(start, end);
+  if (cmp > 0) {
+    throw new Error(
+      `temporal-fmt: interval start must be \u2264 end (got start > end). Pass them in chronological order.`
+    );
+  }
+  return { start, end, bounds };
+}
+function startIncluded(bounds) {
+  return bounds === "closed" || bounds === "half-open-end";
+}
+function endIncluded(bounds) {
+  return bounds === "closed" || bounds === "half-open-start";
+}
+function contains(iv, value) {
+  const startCmp = compare(value, iv.start);
+  const endCmp = compare(value, iv.end);
+  const afterStart = startIncluded(iv.bounds) ? startCmp >= 0 : startCmp > 0;
+  const beforeEnd = endIncluded(iv.bounds) ? endCmp <= 0 : endCmp < 0;
+  return afterStart && beforeEnd;
+}
+function overlaps(a, b) {
+  return intersects(a, b);
+}
+function intersects(a, b) {
+  const loCmp = compare(a.start, b.start);
+  const lo = loCmp >= 0 ? a.start : b.start;
+  const hiCmp = compare(a.end, b.end);
+  const hi = hiCmp <= 0 ? a.end : b.end;
+  const inner = compare(lo, hi);
+  if (inner < 0) return true;
+  if (inner > 0) return false;
+  return contains(a, lo) && contains(b, lo);
+}
+function isBefore(a, b) {
+  return compare(a.end, b.start) < 0;
+}
+function isAfter(a, b) {
+  return compare(a.start, b.end) > 0;
+}
+function intersection(a, b) {
+  if (!intersects(a, b)) return null;
+  const aStartLater = compare(a.start, b.start) > 0;
+  const start = aStartLater ? a.start : b.start;
+  const aEndEarlier = compare(a.end, b.end) < 0;
+  const end = aEndEarlier ? a.end : b.end;
+  const startInc = aStartLater ? startIncluded(a.bounds) : compare(b.start, a.start) > 0 ? startIncluded(b.bounds) : startIncluded(a.bounds) && startIncluded(b.bounds);
+  const endInc = aEndEarlier ? endIncluded(a.bounds) : compare(a.end, b.end) > 0 ? endIncluded(b.bounds) : endIncluded(a.bounds) && endIncluded(b.bounds);
+  const bounds = startInc ? endInc ? "closed" : "half-open-end" : endInc ? "half-open-start" : "open";
+  return { start, end, bounds };
+}
+function union(a, b) {
+  if (!intersects(a, b)) return null;
+  const aStartEarlier = compare(a.start, b.start) < 0;
+  const start = aStartEarlier ? a.start : b.start;
+  const aEndLater = compare(a.end, b.end) > 0;
+  const end = aEndLater ? a.end : b.end;
+  const startInc = aStartEarlier ? startIncluded(a.bounds) : compare(b.start, a.start) < 0 ? startIncluded(b.bounds) : startIncluded(a.bounds) || startIncluded(b.bounds);
+  const endInc = aEndLater ? endIncluded(a.bounds) : compare(a.end, b.end) < 0 ? endIncluded(b.bounds) : endIncluded(a.bounds) || endIncluded(b.bounds);
+  const bounds = startInc ? endInc ? "closed" : "half-open-end" : endInc ? "half-open-start" : "open";
+  return { start, end, bounds };
+}
+function difference(a, b) {
+  if (!intersects(a, b)) return [a];
+  const result = [];
+  if (compare(a.start, b.start) < 0) {
+    const endInc = contains(a, b.start) && !contains(b, b.start);
+    result.push({
+      start: a.start,
+      end: b.start,
+      bounds: startIncluded(a.bounds) ? endInc ? "closed" : "half-open-end" : endInc ? "half-open-start" : "open"
+    });
+  }
+  if (compare(a.end, b.end) > 0) {
+    const startInc = contains(a, b.end) && !contains(b, b.end);
+    result.push({
+      start: b.end,
+      end: a.end,
+      bounds: startInc ? endIncluded(a.bounds) ? "closed" : "half-open-end" : endIncluded(a.bounds) ? "half-open-start" : "open"
+    });
+  }
+  return result;
+}
+var subtract = difference;
+function mergeIntervals(intervals) {
+  if (intervals.length === 0) return [];
+  const sorted = [...intervals].sort((a, b) => compare(a.start, b.start));
+  const result = [{ ...sorted[0] }];
+  for (let i = 1; i < sorted.length; i++) {
+    const current = sorted[i];
+    const last = result[result.length - 1];
+    const touching = compare(last.end, current.start) === 0;
+    const touchMerges = touching && (endIncluded(last.bounds) || startIncluded(current.bounds));
+    if (intersects(last, current) || touchMerges) {
+      const endCmp = compare(current.end, last.end);
+      if (endCmp > 0) {
+        last.end = current.end;
+        last.bounds = startIncluded(last.bounds) ? endIncluded(current.bounds) ? "closed" : "half-open-end" : endIncluded(current.bounds) ? "half-open-start" : "open";
+      } else if (endCmp === 0) {
+        last.bounds = startIncluded(last.bounds) ? endIncluded(last.bounds) || endIncluded(current.bounds) ? "closed" : "half-open-end" : endIncluded(last.bounds) || endIncluded(current.bounds) ? "half-open-start" : "open";
+      }
+    } else {
+      result.push({ ...current });
+    }
+  }
+  return result;
+}
+var MAX_DATE_MS = 864e13;
+function splitInterval(iv, n) {
+  if (n <= 0) throw new Error(`temporal-fmt: splitInterval requires n > 0 (got ${n}).`);
+  if (n === 1) return [iv];
+  const startFields = asDateFieldView(iv.start);
+  const endFields = asDateFieldView(iv.end);
+  const startMs = toMs(startFields);
+  const endMs = toMs(endFields);
+  if (Math.abs(startMs) > MAX_DATE_MS || Math.abs(endMs) > MAX_DATE_MS) {
+    throw new RangeError(
+      `temporal-fmt: splitInterval() endpoints are outside the representable Date range (approximately \xB1275,760 years). Split the interval into smaller ranges first.`
+    );
+  }
+  const step = (endMs - startMs) / n;
+  const result = [];
+  const ivStartInc = startIncluded(iv.bounds);
+  const ivEndInc = endIncluded(iv.bounds);
+  for (let i = 0; i < n; i++) {
+    const sliceStart = startMs + i * step;
+    const sliceEnd = i === n - 1 ? endMs : sliceStart + step;
+    const startInc = i === 0 ? ivStartInc : true;
+    const endInc = i === n - 1 ? ivEndInc : false;
+    result.push({
+      start: fromMs(sliceStart, startFields),
+      end: fromMs(sliceEnd, endFields),
+      // The 'half-open-start' arm on the last line below is structurally
+      // unreachable: startInc is false only for slice 0 (later slices
+      // start included), and slice 0's endInc is always false (only the
+      // last slice carries the input's end inclusivity) — a slice with an
+      // exclusive start AND inclusive end would require n === 1, which
+      // returns [iv] unchanged above. The other arms are live and covered.
+      /* c8 ignore next 3 @preserve */
+      bounds: startInc ? endInc ? "closed" : "half-open-end" : endInc ? "half-open-start" : "open"
+    });
+  }
+  return result;
+}
+function toMs(v) {
+  const days = daysFromCivil(v.year, v.month, v.day);
+  return days * 864e5 + (v.hour ?? 0) * 36e5 + (v.minute ?? 0) * 6e4 + (v.second ?? 0) * 1e3 + (v.millisecond ?? 0);
+}
+function fromMs(ms, base) {
+  const MS_PER_DAY = 864e5;
+  const dayOverflow = Math.floor(ms / MS_PER_DAY);
+  let withinDay = ms % MS_PER_DAY;
+  if (withinDay < 0) withinDay += MS_PER_DAY;
+  const hour = Math.floor(withinDay / 36e5);
+  const minute = Math.floor(withinDay % 36e5 / 6e4);
+  const second = Math.floor(withinDay % 6e4 / 1e3);
+  const millisecond = withinDay % 1e3;
+  const newMs = dayOverflow * MS_PER_DAY;
+  const d = new Date(newMs);
+  return {
+    ...base,
+    year: d.getUTCFullYear(),
+    month: d.getUTCMonth() + 1,
+    day: d.getUTCDate(),
+    hour,
+    minute,
+    second,
+    millisecond
+  };
+}
+function formatRange(iv, formatStr, options = {}) {
+  try {
+    const startStr = format(iv.start, formatStr, options);
+    const endStr = format(iv.end, formatStr, options);
+    return `${startStr} \u2013 ${endStr}`;
+  } catch (err) {
+    try {
+      const fmt = new Intl.DateTimeFormat(normalizeLocaleTag(options.locale ?? "en-US"), {});
+      const startDate = toJSDate(iv.start);
+      const endDate = toJSDate(iv.end);
+      return fmt.formatRange(startDate, endDate);
+    } catch {
+      throw err;
+    }
+  }
+}
+function formatRangeToParts(iv, formatStr, options = {}) {
+  const startParts = formatToParts(iv.start, formatStr, options);
+  const endParts = formatToParts(iv.end, formatStr, options);
+  const result = [...startParts];
+  result.push({ type: "literal", value: " \u2013 " });
+  result.push(...endParts);
+  return result;
+}
+function toJSDate(value) {
+  const v = value;
+  if (typeof v?.toInstant === "function") {
+    return new Date(v.toInstant().epochMilliseconds);
+  }
+  if (typeof v?.year === "number" && typeof v?.month === "number" && typeof v?.day === "number") {
+    return new Date(Date.UTC(v.year, v.month - 1, v.day, v.hour ?? 0, v.minute ?? 0, v.second ?? 0, v.millisecond ?? 0));
+  }
+  throw new Error(`temporal-fmt: formatRange() expected Temporal values with year/month/day, got ${typeof value}.`);
+}
+
+export {
+  interval,
+  contains,
+  overlaps,
+  intersects,
+  isBefore,
+  isAfter,
+  intersection,
+  union,
+  difference,
+  subtract,
+  mergeIntervals,
+  splitInterval,
+  formatRange,
+  formatRangeToParts
+};
+//# sourceMappingURL=chunk-WP7TBCTT.js.map

package/dist/chunk-WP7TBCTT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/interval.ts"],"sourcesContent":["/*\n * Copyright 2026 DirazCoder\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// Intervals / ranges. An interval is a pair of\n// (start, end) Temporal values with bounds semantics: open, closed,\n// or half-open. Operations: contains, overlaps, intersects, isBefore,\n// isAfter, intersection, union, difference, subtract, mergeIntervals,\n// splitInterval. Plus formatRange / formatRangeToParts with intelligent\n// collapsing.\n//\n// All operations are field-based (no instanceof), matching the rest of\n// the library. Internally uses the comparison helpers from comparison.ts\n// to order endpoints.\n\nimport { compare } from './comparison.js';\nimport { formatToParts, format as baseFormat, type FormattedPart } from './format.js';\nimport { asDateFieldView, type DateFieldView } from './calendarUtils.js';\nimport { normalizeLocaleTag } from './localeVocab.js';\nimport { daysFromCivil } from './isoWeek.js';\nimport type { FormatOptions } from './tokens.js';\n\nexport type IntervalBounds = 'open' | 'closed' | 'half-open-start' | 'half-open-end';\n\nexport interface Interval {\n  start: unknown;\n  end: unknown;\n  bounds: IntervalBounds;\n}\n\nexport function interval(start: unknown, end: unknown, bounds: IntervalBounds = 'closed'): Interval {\n  // Validate that start ≤ end, otherwise the interval is malformed.\n  const cmp = compare(start, end);\n  if (cmp > 0) {\n    throw new Error(\n      `temporal-fmt: interval start must be ≤ end (got start > end). Pass them in chronological order.`\n    );\n  }\n  return { start, end, bounds };\n}\n\n// Inclusive containment check accounting for bounds semantics.\n// - 'closed': [start, end] — both endpoints included\n// - 'open': (start, end) — neither endpoint included\n// - 'half-open-start': (start, end] — start excluded, end included\n// - 'half-open-end': [start, end) — start included, end excluded\n//\n// The two half-open conditions below used to have their labels swapped —\n// 'half-open-end' excluded the start and included the end (the exact\n// behavior 'half-open-start' documents, and vice versa) — which made\n// contains() disagree with difference() (whose labels were correct all\n// along) and silently broke splitInterval's partition (see below).\n// startOpen/beginOpen naming below says which *endpoint* is excluded, so\n// the mapping to the label can't drift again.\nfunction startIncluded(bounds: IntervalBounds): boolean {\n  return bounds === 'closed' || bounds === 'half-open-end';\n}\nfunction endIncluded(bounds: IntervalBounds): boolean {\n  return bounds === 'closed' || bounds === 'half-open-start';\n}\n\nexport function contains(iv: Interval, value: unknown): boolean {\n  const startCmp = compare(value, iv.start);\n  const endCmp = compare(value, iv.end);\n  const afterStart = startIncluded(iv.bounds) ? startCmp >= 0 : startCmp > 0;\n  const beforeEnd = endIncluded(iv.bounds) ? endCmp <= 0 : endCmp < 0;\n  return afterStart && beforeEnd;\n}\n\n// Two intervals overlap iff their ranges intersect, regardless of bounds.\n// intersects() is the boolean form; intersection() returns the actual\n// overlap interval.\nexport function overlaps(a: Interval, b: Interval): boolean {\n  return intersects(a, b);\n}\n\nexport function intersects(a: Interval, b: Interval): boolean {\n  // Two intervals intersect iff they share at least one point. The old\n  // version returned true whenever the spans touched, regardless of\n  // bounds — so (Jan 1, Jan 5) and (Jan 5, Jan 10), which share no point\n  // (Jan 5 belongs to neither), reported as overlapping, and\n  // intersection() returned a degenerate non-empty-looking result for\n  // the empty intersection. Computing the candidate shared span and\n  // consulting contains() at the single shared point handles every\n  // bounds combination uniformly.\n  const loCmp = compare(a.start, b.start);\n  const lo = loCmp >= 0 ? a.start : b.start; // later start\n  const hiCmp = compare(a.end, b.end);\n  const hi = hiCmp <= 0 ? a.end : b.end; // earlier end\n  const inner = compare(lo, hi);\n  if (inner < 0) return true; // strictly inside — a real span is shared\n  if (inner > 0) return false; // spans don't reach each other\n  // lo === hi: the only possible shared point is that single value —\n  // it has to be contained in BOTH intervals.\n  return contains(a, lo) && contains(b, lo);\n}\n\nexport function isBefore(a: Interval, b: Interval): boolean {\n  return compare(a.end, b.start) < 0;\n}\n\nexport function isAfter(a: Interval, b: Interval): boolean {\n  return compare(a.start, b.end) > 0;\n}\n\n// Returns the intersection of two intervals, or null if they don't\n// overlap. The result's bounds at each endpoint come from whichever\n// interval OWNS that endpoint (the later start, the earlier end) — when\n// both intervals supply the same endpoint, intersection inclusivity is\n// the AND of the two (a point is in a∩b only if it's in both).\nexport function intersection(a: Interval, b: Interval): Interval | null {\n  if (!intersects(a, b)) return null;\n  const aStartLater = compare(a.start, b.start) > 0;\n  const start = aStartLater ? a.start : b.start;\n  const aEndEarlier = compare(a.end, b.end) < 0;\n  const end = aEndEarlier ? a.end : b.end;\n  // Start-side inclusivity: owned by the later-start interval, or the\n  // conjunction when the starts are equal.\n  const startInc = aStartLater\n    ? startIncluded(a.bounds)\n    : compare(b.start, a.start) > 0\n      ? startIncluded(b.bounds)\n      : startIncluded(a.bounds) && startIncluded(b.bounds);\n  // End-side inclusivity: owned by the earlier-end interval, or the\n  // conjunction when the ends are equal.\n  const endInc = aEndEarlier\n    ? endIncluded(a.bounds)\n    : compare(a.end, b.end) > 0\n      ? endIncluded(b.bounds)\n      : endIncluded(a.bounds) && endIncluded(b.bounds);\n  const bounds: IntervalBounds = startInc\n    ? (endInc ? 'closed' : 'half-open-end')\n    : (endInc ? 'half-open-start' : 'open');\n  return { start, end, bounds };\n}\n\n// Returns the union of two intervals (the smallest interval containing\n// both), or null if they don't overlap (caller should use mergeIntervals\n// for that case). Union inclusivity at each endpoint comes from the\n// interval that extends further, or the disjunction when both reach the\n// same endpoint.\nexport function union(a: Interval, b: Interval): Interval | null {\n  if (!intersects(a, b)) return null;\n  const aStartEarlier = compare(a.start, b.start) < 0;\n  const start = aStartEarlier ? a.start : b.start;\n  const aEndLater = compare(a.end, b.end) > 0;\n  const end = aEndLater ? a.end : b.end;\n  const startInc = aStartEarlier\n    ? startIncluded(a.bounds)\n    : compare(b.start, a.start) < 0\n      ? startIncluded(b.bounds)\n      : startIncluded(a.bounds) || startIncluded(b.bounds);\n  const endInc = aEndLater\n    ? endIncluded(a.bounds)\n    : compare(a.end, b.end) < 0\n      ? endIncluded(b.bounds)\n      : endIncluded(a.bounds) || endIncluded(b.bounds);\n  const bounds: IntervalBounds = startInc\n    ? (endInc ? 'closed' : 'half-open-end')\n    : (endInc ? 'half-open-start' : 'open');\n  return { start, end, bounds };\n}\n\n// Returns the part of `a` that is not in `b`. May produce 0, 1, or 2\n// intervals depending on the overlap shape.\n//\n// Bounds semantics: each surviving piece keeps the inclusivity of the\n// original endpoint it inherits from `a`, and the endpoint created by the\n// cut is always exclusive (it is `b`'s edge, which belongs to the removed\n// overlap). The old implementation derived both bounds from a lossy\n// helper that collapsed several of these combinations — the pieces'\n// endpoints were right, but the bounds metadata was stricter than the\n// actual remainder for open/half-open inputs.\nexport function difference(a: Interval, b: Interval): Interval[] {\n  if (!intersects(a, b)) return [a];\n  const result: Interval[] = [];\n  // Part of `a` before `b` starts. Its end is b.start; that point stays\n  // in the remainder iff a still contains it AND b doesn't — a cut edge\n  // is only removed when the removed interval actually includes it (a\n  // cut against an open-bounded b used to drop the edge point even\n  // though b never owned it).\n  if (compare(a.start, b.start) < 0) {\n    const endInc = contains(a, b.start) && !contains(b, b.start);\n    result.push({\n      start: a.start,\n      end: b.start,\n      bounds: startIncluded(a.bounds)\n        ? (endInc ? 'closed' : 'half-open-end')\n        : (endInc ? 'half-open-start' : 'open'),\n    });\n  }\n  // Part of `a` after `b` ends — mirror image of the above.\n  if (compare(a.end, b.end) > 0) {\n    const startInc = contains(a, b.end) && !contains(b, b.end);\n    result.push({\n      start: b.end,\n      end: a.end,\n      bounds: startInc\n        ? (endIncluded(a.bounds) ? 'closed' : 'half-open-end')\n        : (endIncluded(a.bounds) ? 'half-open-start' : 'open'),\n    });\n  }\n  return result;\n}\n\n// Alias for difference() — \"subtract\" reads more naturally at some\n// call sites than \"difference\" does.\nexport const subtract = difference;\n\n// Merges a list of intervals, combining overlapping ones. Returns a\n// sorted list of disjoint intervals. The inputs are treated as\n// immutable — the merged result carries shallow copies of any interval\n// object it extends, so a caller's own `end` reference is never\n// reassigned under them (mergeIntervals used to write `last.end =\n// current.end` straight into the caller's object).\nexport function mergeIntervals(intervals: Interval[]): Interval[] {\n  if (intervals.length === 0) return [];\n  const sorted = [...intervals].sort((a, b) => compare(a.start, b.start));\n  // Shallow-copy EVERY interval placed into the result, not just the\n  // first — the inputs are documented as immutable and the merged\n  // object is mutated below (last.end is reassigned), so aliasing any\n  // input would write through to the caller's objects. Non-merged\n  // intervals used to be pushed by reference.\n  const result: Interval[] = [{ ...sorted[0]! }];\n  for (let i = 1; i < sorted.length; i++) {\n    const current = sorted[i]!;\n    const last = result[result.length - 1]!;\n    // Touching endpoints merge only when at least one interval actually\n    // contains the shared point — [1,5) + [5,10] union to [1,10], but\n    // (1,5) + (5,10) leave a hole at exactly 5 and must stay separate.\n    // (Plain overlaps always merge, per intersects().)\n    const touching = compare(last.end, current.start) === 0;\n    const touchMerges = touching && (endIncluded(last.bounds) || startIncluded(current.bounds));\n    if (intersects(last, current) || touchMerges) {\n      // Extend to the farther end, carrying that interval's end\n      // inclusivity over (and when the ends are equal, the union of the\n      // two end inclusivities).\n      const endCmp = compare(current.end, last.end);\n      if (endCmp > 0) {\n        last.end = current.end;\n        last.bounds = startIncluded(last.bounds)\n          ? (endIncluded(current.bounds) ? 'closed' : 'half-open-end')\n          : (endIncluded(current.bounds) ? 'half-open-start' : 'open');\n      } else if (endCmp === 0) {\n        last.bounds = startIncluded(last.bounds)\n          ? (endIncluded(last.bounds) || endIncluded(current.bounds) ? 'closed' : 'half-open-end')\n          : (endIncluded(last.bounds) || endIncluded(current.bounds) ? 'half-open-start' : 'open');\n      }\n    } else {\n      result.push({ ...current });\n    }\n  }\n  return result;\n}\n\n// Widest instant JS Date can represent (±8.64e15 ms, i.e. ±100,000,000\n// days from the Unix epoch). splitInterval rebuilds endpoints via Date,\n// so anything outside this window would silently produce Invalid Date\n// objects with NaN year/month/day fields — reject it descriptively\n// instead.\nconst MAX_DATE_MS = 8.64e15;\n\n// Splits an interval into N equal sub-intervals. Throws if N ≤ 0.\n// Equality is by ms-distance between start and end — for date ranges\n// this approximates \"equal time slices\", which is the most useful\n// interpretation. For calendar-bound splits (e.g. \"split this month\n// into weeks\"), callers should use recurrence() instead.\nexport function splitInterval(iv: Interval, n: number): Interval[] {\n  if (n <= 0) throw new Error(`temporal-fmt: splitInterval requires n > 0 (got ${n}).`);\n  if (n === 1) return [iv];\n  const startFields = asDateFieldView(iv.start) as DateFieldView & { hour?: number; minute?: number; second?: number; millisecond?: number };\n  const endFields = asDateFieldView(iv.end) as DateFieldView & { hour?: number; minute?: number; second?: number; millisecond?: number };\n  const startMs = toMs(startFields);\n  const endMs = toMs(endFields);\n  if (Math.abs(startMs) > MAX_DATE_MS || Math.abs(endMs) > MAX_DATE_MS) {\n    throw new RangeError(\n      `temporal-fmt: splitInterval() endpoints are outside the representable Date range ` +\n      `(approximately ±275,760 years). Split the interval into smaller ranges first.`\n    );\n  }\n  const step = (endMs - startMs) / n;\n  const result: Interval[] = [];\n  // A partition: slice 0 keeps the caller's start inclusivity, slices\n  // 1..n-1 start exactly where the previous slice ended (exclusively),\n  // so their starts are INCLUDED, and every slice except the last\n  // excludes its end; the last slice keeps the caller's end inclusivity.\n  // Together: [s0, s1) [s1, s2) ... [s_{n-1}, s_n] for a closed input —\n  // every point in exactly one slice. (The old version labeled the\n  // middle slices 'half-open-start' — which under the pre-fix, swapped\n  // contains() semantics accidentally behaved like [s, e) — and left\n  // the ORIGINAL end point out of the last slice entirely.)\n  const ivStartInc = startIncluded(iv.bounds);\n  const ivEndInc = endIncluded(iv.bounds);\n  for (let i = 0; i < n; i++) {\n    const sliceStart = startMs + i * step;\n    const sliceEnd = i === n - 1 ? endMs : sliceStart + step;\n    const startInc = i === 0 ? ivStartInc : true;\n    const endInc = i === n - 1 ? ivEndInc : false;\n    result.push({\n      start: fromMs(sliceStart, startFields),\n      end: fromMs(sliceEnd, endFields),\n      // The 'half-open-start' arm on the last line below is structurally\n      // unreachable: startInc is false only for slice 0 (later slices\n      // start included), and slice 0's endInc is always false (only the\n      // last slice carries the input's end inclusivity) — a slice with an\n      // exclusive start AND inclusive end would require n === 1, which\n      // returns [iv] unchanged above. The other arms are live and covered.\n      /* c8 ignore next 3 @preserve */\n      bounds: startInc\n        ? (endInc ? 'closed' : 'half-open-end')\n        : (endInc ? 'half-open-start' : 'open'),\n    });\n  }\n  return result;\n}\n\nfunction toMs(v: DateFieldView & { hour?: number; minute?: number; second?: number; millisecond?: number }): number {\n  // daysFromCivil (isoWeek.ts) is the O(1) Hinnant day count, correct\n  // for negative years. The formula previously inlined here carried a\n  // Math.floor applied to Hinnant's -399-offset numerator — a double\n  // correction that shifted every pre-year-0 date by one day (the\n  // offset form is only equivalent under truncating division, which JS\n  // doesn't have).\n  const days = daysFromCivil(v.year!, v.month!, v.day!);\n  return days * 86_400_000\n    + (v.hour ?? 0) * 3_600_000\n    + (v.minute ?? 0) * 60_000\n    + (v.second ?? 0) * 1_000\n    + (v.millisecond ?? 0);\n}\n\nfunction fromMs(ms: number, base: DateFieldView & { hour?: number; minute?: number; second?: number; millisecond?: number }): DateFieldView {\n  const MS_PER_DAY = 86_400_000;\n  const dayOverflow = Math.floor(ms / MS_PER_DAY);\n  let withinDay = ms % MS_PER_DAY;\n  if (withinDay < 0) withinDay += MS_PER_DAY;\n  const hour = Math.floor(withinDay / 3_600_000);\n  const minute = Math.floor((withinDay % 3_600_000) / 60_000);\n  const second = Math.floor((withinDay % 60_000) / 1_000);\n  const millisecond = withinDay % 1_000;\n  // `ms` (and therefore `dayOverflow`) is already an absolute epoch-ms /\n  // epoch-day value — toMs() computed it via Howard Hinnant's algorithm\n  // from scratch, not as an offset from `base`. So the date only needs\n  // reconstructing from the Unix epoch itself; `base` is just a template\n  // for whatever extra (non-date) fields get spread into the result.\n  // (Previously this added dayOverflow on top of base's own epoch-ms,\n  // double-counting base's offset and landing tens of thousands of days\n  // away from the intended date for any non-epoch base.)\n  const newMs = dayOverflow * MS_PER_DAY;\n  const d = new Date(newMs);\n  return {\n    ...base,\n    year: d.getUTCFullYear(),\n    month: d.getUTCMonth() + 1,\n    day: d.getUTCDate(),\n    hour,\n    minute,\n    second,\n    millisecond,\n  };\n}\n\n// Formats an interval as a single string, collapsing shared fields.\n// E.g. \"August 4 – August 6, 2026\" rather than \"August 4, 2026 – August 6, 2026\".\n// Uses Intl.DateTimeFormat's formatRange when available (most engines),\n// falling back to format(start, fmt) + '–' + format(end, fmt) when not.\n\nexport function formatRange(\n  iv: Interval,\n  formatStr: string,\n  options: FormatOptions = {},\n): string {\n  // The formatStr parameter is this function's contract — the caller\n  // asked for their token format on both endpoints. Honor it first:\n  // format each side with the caller's format string and join with an\n  // en dash. (This used to try Intl.DateTimeFormat.formatRange() first,\n  // which ignores formatStr entirely — formatRange(iv, 'yyyy-MM-dd')\n  // silently returned locale-default output like \"8/4/2026 – 8/6/2026\"\n  // instead of \"2026-08-04 – 2026-08-06\".) Intl's range collapsing is\n  // kept as a fallback for inputs the token path can't render.\n  try {\n    const startStr = baseFormat(iv.start as Parameters<typeof baseFormat>[0], formatStr, options);\n    const endStr = baseFormat(iv.end as Parameters<typeof baseFormat>[0], formatStr, options);\n    return `${startStr} – ${endStr}`;\n  } catch (err) {\n    // Fallback: Intl.DateTimeFormat.formatRange is the standard\n    // mechanism with native field-collapse behavior, but it has no\n    // knowledge of the caller's token format string.\n    try {\n      const fmt = new Intl.DateTimeFormat(normalizeLocaleTag(options.locale ?? 'en-US'), {});\n      // Cast the interval endpoints to Date for the Intl call. Both\n      // endpoints must be Temporal values that can convert to a Date;\n      // for non-ZonedDateTime values we synthesize a Date via the field\n      // shape (year/month/day/hour/...).\n      const startDate = toJSDate(iv.start);\n      const endDate = toJSDate(iv.end);\n      return fmt.formatRange(startDate, endDate);\n    } catch {\n      // Neither path could render — surface the token-path error, since\n      // the formatStr contract is the primary one.\n      throw err;\n    }\n  }\n}\n\nexport function formatRangeToParts(\n  iv: Interval,\n  formatStr: string,\n  options: FormatOptions = {},\n): FormattedPart[] {\n  // Best-effort: returns formatToParts for the start, then a literal\n  // \" – \" part, then formatToParts for the end. Doesn't currently\n  // expose Intl.DateTimeFormat.formatRangeToParts's collapsed shape —\n  // that would require mapping Intl's part types back to temporal-fmt's\n  // token strings, which is locale-dependent and not stable across\n  // engines.\n  const startParts = formatToParts(iv.start as Parameters<typeof formatToParts>[0], formatStr, options);\n  const endParts = formatToParts(iv.end as Parameters<typeof formatToParts>[0], formatStr, options);\n  const result: FormattedPart[] = [...startParts];\n  result.push({ type: 'literal', value: ' – ' });\n  result.push(...endParts);\n  return result;\n}\n\nfunction toJSDate(value: unknown): Date {\n  const v = value as { year?: number; month?: number; day?: number; hour?: number; minute?: number; second?: number; millisecond?: number; toInstant?: () => { epochMilliseconds: number } };\n  if (typeof v?.toInstant === 'function') {\n    return new Date(v.toInstant().epochMilliseconds);\n  }\n  if (typeof v?.year === 'number' && typeof v?.month === 'number' && typeof v?.day === 'number') {\n    return new Date(Date.UTC(v.year, v.month - 1, v.day, v.hour ?? 0, v.minute ?? 0, v.second ?? 0, v.millisecond ?? 0));\n  }\n  throw new Error(`temporal-fmt: formatRange() expected Temporal values with year/month/day, got ${typeof value}.`);\n}"],"mappings":"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","names":[]}

package/dist/{chunk-BQET6RUR.js → chunk-Z245NHDT.js}

@@ -359,26 +359,9 @@ var TOKENS = [
     return intlPart(t, locale, { timeZoneName: "short" }, "timeZoneName");
   }, "timeZoneId"]
 ];
-var registeredTokens = /* @__PURE__ */ new Map();
-var rebuildListeners = [];
-function onTokenTableChange(listener) {
-  rebuildListeners.push(listener);
-}
-function getEffectiveTokens() {
-  const merged = new Map(TOKENS.map((t) => [t[0], t]));
-  for (const [name, entry] of registeredTokens) merged.set(name, entry);
-  return [...merged.values()];
-}
-function registerToken(token) {
-  registeredTokens.set(token[0], token);
-  for (const listener of rebuildListeners) listener();
-}
 
 export {
   DEFAULT_LOCALE,
-  TOKENS,
-  onTokenTableChange,
-  getEffectiveTokens,
-  registerToken
+  TOKENS
 };
-//# sourceMappingURL=chunk-BQET6RUR.js.map
+//# sourceMappingURL=chunk-Z245NHDT.js.map