temporal-fmt 0.9.2 → 0.9.4

package/dist/chunk-FBPHNRVW.js

@@ -0,0 +1,2939 @@
+import {
+  getNextTransition,
+  getPreviousTransition,
+  possibleInstantsFor,
+  resolveZoned
+} from "./chunk-H7YQX25T.js";
+import {
+  balanceDuration,
+  ceil,
+  compareDuration,
+  floor,
+  formatDurationToParts,
+  formatISODuration,
+  parseDuration,
+  parseISODuration,
+  subtractDuration,
+  truncate
+} from "./chunk-ACKKWH5Z.js";
+import {
+  _handlerFor,
+  compileFormat,
+  format,
+  formatToParts
+} from "./chunk-4N3WCGEY.js";
+import {
+  getLocale,
+  hasLocale
+} from "./chunk-UOPAV3WX.js";
+import {
+  UNPADDED_NUMERIC_TOKENS,
+  compileParser,
+  parse
+} from "./chunk-5UTV5VP6.js";
+import {
+  tokenize
+} from "./chunk-M3GDTHMT.js";
+import {
+  DEFAULT_LOCALE,
+  TOKENS
+} from "./chunk-L24NPTAJ.js";
+import {
+  getTemporal
+} from "./chunk-ZQZF5EXW.js";
+import {
+  MAX_FORMAT_LENGTH
+} from "./chunk-YEUASGDK.js";
+import {
+  FormatSyntaxError,
+  InvalidDateError,
+  normalizeLocaleTag
+} from "./chunk-EGUUO6LE.js";
+import {
+  between,
+  clamp,
+  compare,
+  formatRRule,
+  isAfter,
+  isBefore,
+  isBetween,
+  isEqual,
+  isSameDay,
+  isSameMonth,
+  isSameQuarter,
+  isSameWeek,
+  isSameYear,
+  isToday,
+  isTomorrow,
+  isWeekday,
+  isYesterday,
+  parseRRule
+} from "./chunk-VNIUIQA4.js";
+import {
+  add
+} from "./chunk-TSLPIURC.js";
+import {
+  asDateFieldView,
+  getMonth,
+  getWeekday,
+  isLeapMonth,
+  isLeapYear,
+  monthsInYear,
+  weekOfYear,
+  weekYear
+} from "./chunk-HXY2GUUM.js";
+
+// src/relativeGrammar.ts
+var MAX_REGISTERED_GRAMMARS = 100;
+var registeredGrammars = [];
+function registerRelativeGrammar(grammar) {
+  if (typeof grammar.language !== "string" || grammar.language.length === 0) {
+    throw new Error("temporal-fmt: registerRelativeGrammar requires a non-empty language string.");
+  }
+  if (!Array.isArray(grammar.matchers) || grammar.matchers.length === 0) {
+    throw new Error("temporal-fmt: registerRelativeGrammar requires at least one matcher.");
+  }
+  const existingIdx = registeredGrammars.findIndex((g) => g.language === grammar.language);
+  if (existingIdx >= 0) {
+    registeredGrammars[existingIdx] = grammar;
+  } else {
+    if (registeredGrammars.length >= MAX_REGISTERED_GRAMMARS) {
+      throw new RangeError(`temporal-fmt: registerRelativeGrammar reached the ${MAX_REGISTERED_GRAMMARS}-grammar limit.`);
+    }
+    registeredGrammars.push(grammar);
+  }
+}
+function tryRegisteredGrammar(language, input, reference) {
+  for (const grammar of registeredGrammars) {
+    if (grammar.language !== language) continue;
+    for (const matcher of grammar.matchers) {
+      const match = matcher(input);
+      if (match === null) continue;
+      const temporal = getTemporal();
+      if (match.resolve) {
+        const fields = match.resolve(reference);
+        return temporal.PlainDate.from(fields, { overflow: "reject" });
+      }
+      return temporal.PlainDate.from(
+        { year: match.year ?? reference.year, month: match.month ?? reference.month, day: match.day ?? reference.day },
+        { overflow: "reject" }
+      );
+    }
+  }
+  return null;
+}
+function listRegisteredGrammars() {
+  return registeredGrammars.map((g) => g.language);
+}
+
+// src/parseRelative.ts
+function normalizeForMatch(s) {
+  return s.toLowerCase().replace(/ä/g, "ae").replace(/ö/g, "oe").replace(/ü/g, "ue").replace(/ß/g, "ss").normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+function levenshtein(a, b) {
+  /* c8 ignore start @preserve -- unreachable through the only call
+   * site (fuzzyCorrectEnglish): `a` is always a word that already
+   * failed the `vocabulary.includes(word)` exact-match check, so
+   * a === b never holds against any `b` drawn from that same
+   * vocabulary; and neither `a` (split from a non-empty normalized
+   * string) nor `b` (a vocabulary entry) is ever empty. Kept as
+   * general-purpose guards in case levenshtein() gets a second caller
+   * later. */
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  /* c8 ignore stop @preserve */
+  let prev = new Array(b.length + 1);
+  let curr = new Array(b.length + 1);
+  for (let j = 0; j <= b.length; j++) prev[j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(
+        prev[j] + 1,
+        // deletion
+        curr[j - 1] + 1,
+        // insertion
+        prev[j - 1] + cost
+        // substitution
+      );
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[b.length];
+}
+var FUZZY_MAX_DISTANCE = 2;
+var MAX_RELATIVE_INPUT_LENGTH = 4096;
+var MAX_RELATIVE_WORDS = 32;
+function buildEnglishFuzzyVocabulary() {
+  return [
+    ...ENGLISH_WEEKDAYS,
+    ...ENGLISH_MONTHS,
+    ...ENGLISH_MONTH_SHORT,
+    "today",
+    "tomorrow",
+    "yesterday",
+    "next",
+    "last",
+    "this",
+    "in",
+    "ago",
+    "day",
+    "days",
+    "week",
+    "weeks",
+    "month",
+    "months",
+    "year",
+    "years"
+  ].map(normalizeForMatch);
+}
+var englishFuzzyVocabulary;
+function getEnglishFuzzyVocabulary() {
+  if (!englishFuzzyVocabulary) englishFuzzyVocabulary = Object.freeze(buildEnglishFuzzyVocabulary());
+  return englishFuzzyVocabulary;
+}
+function fuzzyCorrectEnglish(normalized) {
+  const vocabulary = getEnglishFuzzyVocabulary();
+  const words = normalized.split(" ");
+  if (normalized.length > MAX_RELATIVE_INPUT_LENGTH || words.length > MAX_RELATIVE_WORDS) {
+    throw new RangeError(
+      `temporal-fmt: parseRelative fuzzy input is too large (maximum ${MAX_RELATIVE_INPUT_LENGTH} characters and ${MAX_RELATIVE_WORDS} words).`
+    );
+  }
+  let changed = false;
+  const corrected = words.map((word) => {
+    if (/^\d+(?:st|nd|rd|th)?$/.test(word)) return word;
+    if (vocabulary.includes(word)) return word;
+    let best;
+    let bestDist = FUZZY_MAX_DISTANCE + 1;
+    for (const candidate of vocabulary) {
+      const dist = levenshtein(word, candidate);
+      if (dist < bestDist) {
+        bestDist = dist;
+        best = candidate;
+      }
+    }
+    if (best !== void 0 && bestDist <= FUZZY_MAX_DISTANCE) {
+      changed = true;
+      return best;
+    }
+    return word;
+  });
+  return changed ? corrected.join(" ") : void 0;
+}
+function readYear(reference) {
+  if (typeof reference.year !== "number") {
+    throw new Error("temporal-fmt: parseRelative reference date is missing year.");
+  }
+  return reference.year;
+}
+function readMonth(reference) {
+  if (typeof reference.month !== "number") {
+    throw new Error("temporal-fmt: parseRelative reference date is missing month.");
+  }
+  return reference.month;
+}
+function readDay(reference) {
+  if (typeof reference.day !== "number") {
+    throw new Error("temporal-fmt: parseRelative reference date is missing day.");
+  }
+  return reference.day;
+}
+function extractDayOfWeek(reference) {
+  const dow = reference.dayOfWeek;
+  if (typeof dow !== "number") {
+    throw new Error(
+      "temporal-fmt: parseRelative needs a reference date exposing dayOfWeek (a Temporal.PlainDate / PlainDateTime / ZonedDateTime)."
+    );
+  }
+  return dow;
+}
+function nameAlternation(names) {
+  const normalized = names.map(normalizeForMatch);
+  const sorted = [...normalized].sort((a, b) => b.length - a.length);
+  return sorted.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+}
+function buildPlainDate(temporal, year, month, day) {
+  return temporal.PlainDate.from({ year, month, day }, { overflow: "reject" });
+}
+function addDays(temporal, reference, days) {
+  const refDate = temporal.PlainDate.from({
+    year: readYear(reference),
+    month: readMonth(reference),
+    day: readDay(reference)
+  });
+  return refDate.add({ days });
+}
+function addUnits(temporal, reference, count, unit) {
+  const refDate = temporal.PlainDate.from({
+    year: readYear(reference),
+    month: readMonth(reference),
+    day: readDay(reference)
+  });
+  const duration = {};
+  if (unit === "day") duration.days = count;
+  if (unit === "week") duration.weeks = count;
+  if (unit === "month") duration.months = count;
+  if (unit === "year") duration.years = count;
+  return refDate.add(duration);
+}
+function weekdayOffset(rel, refDow, targetDow) {
+  if (rel === "next") {
+    let diff = targetDow - refDow;
+    if (diff <= 0) diff += 7;
+    return diff;
+  }
+  if (rel === "last") {
+    let diff = targetDow - refDow;
+    if (diff >= 0) diff -= 7;
+    return diff;
+  }
+  return targetDow - refDow;
+}
+function resolveToNextOccurrence(temporal, reference, month, day) {
+  const refYear = readYear(reference);
+  const refDate = temporal.PlainDate.from({
+    year: refYear,
+    month: readMonth(reference),
+    day: readDay(reference)
+  });
+  if (!temporal.PlainDate.compare) {
+    throw new Error("temporal-fmt: parseRelative needs Temporal.PlainDate.compare to resolve month-day phrases; the active implementation does not expose it.");
+  }
+  try {
+    const thisYear = temporal.PlainDate.from({ year: refYear, month, day }, { overflow: "reject" });
+    if (temporal.PlainDate.compare(thisYear, refDate) >= 0) {
+      return thisYear;
+    }
+    return temporal.PlainDate.from({ year: refYear + 1, month, day }, { overflow: "reject" });
+  } catch (err) {
+    try {
+      return temporal.PlainDate.from({ year: refYear + 1, month, day }, { overflow: "reject" });
+    } catch {
+      throw new Error(
+        `temporal-fmt: parseRelative can't resolve month ${month} day ${day} \u2014 it isn't a valid date in either ${refYear} or ${refYear + 1}. Original error: ${err.message}`
+      );
+    }
+  }
+}
+function weekdayIndexFromName(name, names) {
+  const normalized = normalizeForMatch(name);
+  const idx = names.findIndex((n) => normalizeForMatch(n) === normalized);
+  /* c8 ignore start @preserve -- unreachable: every caller passes a
+   * name captured by nameAlternation(names), which builds its regex
+   * alternation from this same list under the same normalizeForMatch
+   * transform. The regex can't match anything findIndex() wouldn't
+   * also find here. Defensive throw kept for the type checker and as
+   * a tripwire if that invariant ever breaks. Ignore comment sits on
+   * the `if` itself, not just the throw inside it — c8 tracks the
+   * branch outcome (was the true side ever taken) separately from the
+   * statements inside, so excluding only the inner throw still leaves
+   * the branch itself flagged as uncovered. */
+  if (idx < 0) {
+    throw new Error(`temporal-fmt: parseRelative internal error \u2014 weekday "${name}" not in names list.`);
+  }
+  /* c8 ignore stop @preserve */
+  return idx + 1;
+}
+function monthIndexFromName(name, longNames, shortNames = []) {
+  const normalized = normalizeForMatch(name);
+  const longIdx = longNames.findIndex((n) => normalizeForMatch(n) === normalized);
+  if (longIdx >= 0) return longIdx + 1;
+  const shortIdx = shortNames.findIndex((n) => normalizeForMatch(n) === normalized);
+  if (shortIdx >= 0) return shortIdx + 1;
+  /* c8 ignore start @preserve -- unreachable: every caller passes a name
+   * captured by nameAlternation([...longNames, ...shortNames]), so the
+   * regex alternation and these two findIndex() scans are built from
+   * the same lists under the same normalizeForMatch transform. Kept as
+   * a tripwire for the type checker in case that invariant ever breaks. */
+  throw new Error(`temporal-fmt: parseRelative internal error \u2014 month "${name}" not in names list.`);
+  /* c8 ignore stop @preserve */
+}
+var ENGLISH_WEEKDAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+var ENGLISH_MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
+var ENGLISH_MONTH_SHORT = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var ENGLISH_GRAMMAR = {
+  supportedHint: 'Supported: weekday refs ("next Tuesday"), day offsets ("today"/"tomorrow"/"yesterday"), unit offsets ("in 3 days", "2 weeks ago"), and month-day ("March 5th").',
+  matchers: [
+    // today / tomorrow / yesterday — exact match, most rigid shape.
+    // Checked first because they're the most common phrase class.
+    {
+      pattern: /^today$/i,
+      resolve: (_m, ctx) => buildPlainDate(ctx.temporal, readYear(ctx.reference), readMonth(ctx.reference), readDay(ctx.reference))
+    },
+    {
+      pattern: /^tomorrow$/i,
+      resolve: (_m, ctx) => addDays(ctx.temporal, ctx.reference, 1)
+    },
+    {
+      pattern: /^yesterday$/i,
+      resolve: (_m, ctx) => addDays(ctx.temporal, ctx.reference, -1)
+    },
+    // weekday references: "next/last/this Tuesday". Capture the relative
+    // word and the weekday name separately, then resolve via +7 / -7.
+    {
+      pattern: new RegExp(`^(next|last|this)\\s+(${nameAlternation(ENGLISH_WEEKDAYS)})$`, "i"),
+      resolve: (m, ctx) => {
+        const rel = m[1].toLowerCase();
+        const targetDow = weekdayIndexFromName(m[2], ENGLISH_WEEKDAYS);
+        const refDow = extractDayOfWeek(ctx.reference);
+        return addDays(ctx.temporal, ctx.reference, weekdayOffset(rel, refDow, targetDow));
+      }
+    },
+    // unit offsets: "in 3 days", "2 weeks ago", "in 1 month", "1 year ago".
+    // Two shapes share this matcher — leading "in" (future) or trailing
+    // "ago" (past). Both lead with <number> <unit>.
+    {
+      pattern: /^(in\s+)?(\d+)\s+(day|week|month|year)s?(?:\s+ago)?$/i,
+      resolve: (m, ctx) => {
+        const inPrefix = m[1];
+        const count = m[2];
+        const unitName = m[3].toLowerCase();
+        const hasIn = !!inPrefix;
+        const hasAgo = /\bago\b/i.test(m[0]);
+        if (!hasIn && !hasAgo) {
+          throw new Error(
+            `temporal-fmt: parseRelative can't tell whether "${m[0]}" is past or future \u2014 use "in ${count} ${unitName}s" or "${count} ${unitName}s ago".`
+          );
+        }
+        const sign = hasIn ? 1 : -1;
+        return addUnits(ctx.temporal, ctx.reference, sign * Number(count), unitName);
+      }
+    },
+    // month-day without year, e.g. "March 5th", "March 5", "March 5, 2026"
+    // (year is ignored if present). The ordinal suffix is decorative —
+    // strip it. The day-of-month is a 1- or 2-digit number.
+    {
+      pattern: new RegExp(`^(${nameAlternation([...ENGLISH_MONTHS, ...ENGLISH_MONTH_SHORT])})\\s+(\\d{1,2})(?:st|nd|rd|th)?(?:,?\\s*(\\d{4}))?$`, "i"),
+      resolve: (m, ctx) => {
+        const month = monthIndexFromName(m[1], ENGLISH_MONTHS, ENGLISH_MONTH_SHORT);
+        const day = Number(m[2]);
+        return resolveToNextOccurrence(ctx.temporal, ctx.reference, month, day);
+      }
+    }
+  ]
+};
+var SPANISH_WEEKDAYS = ["lunes", "martes", "mi\xE9rcoles", "jueves", "viernes", "s\xE1bado", "domingo"];
+var SPANISH_MONTHS = ["enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"];
+var SPANISH_MONTH_SHORT = ["ene", "feb", "mar", "abr", "may", "jun", "jul", "ago", "sept", "oct", "nov", "dic"];
+var SPANISH_GRAMMAR = {
+  supportedHint: 'Frases soportadas: referencias de d\xEDa de la semana ("el pr\xF3ximo lunes", "el lunes pasado", "este martes"), offsets de d\xEDa ("hoy"/"ma\xF1ana"/"ayer"), offsets de unidad ("en 3 d\xEDas", "hace 2 semanas"), y mes-d\xEDa ("5 de marzo").',
+  matchers: [
+    {
+      pattern: /^hoy$/i,
+      resolve: (_m, ctx) => buildPlainDate(ctx.temporal, readYear(ctx.reference), readMonth(ctx.reference), readDay(ctx.reference))
+    },
+    {
+      pattern: /^ma[ñn]ana$/i,
+      resolve: (_m, ctx) => addDays(ctx.temporal, ctx.reference, 1)
+    },
+    {
+      pattern: /^ayer$/i,
+      resolve: (_m, ctx) => addDays(ctx.temporal, ctx.reference, -1)
+    },
+    // weekday references. Spanish has three common shapes, all meaning
+    // the same thing per rel word:
+    //   "el próximo lunes" / "próximo lunes"  → next
+    //   "el lunes próximo"                    → next (suffix variant)
+    //   "el lunes pasado" / "lunes pasado"    → last
+    //   "este lunes"                          → this
+    // Capture the rel word from whichever shape matched, then resolve
+    // the same way English does.
+    {
+      pattern: new RegExp(
+        `^(?:el\\s+)?(?:(pr[o\xF3]ximo|pasado)\\s+(${nameAlternation(SPANISH_WEEKDAYS)})|(${nameAlternation(SPANISH_WEEKDAYS)})\\s+(pr[o\xF3]ximo|pasado)|este\\s+(${nameAlternation(SPANISH_WEEKDAYS)}))$`,
+        "i"
+      ),
+      resolve: (m, ctx) => {
+        let relWord;
+        let weekdayName;
+        if (m[1] && m[2]) {
+          relWord = m[1];
+          weekdayName = m[2];
+        } else if (m[3] && m[4]) {
+          weekdayName = m[3];
+          relWord = m[4];
+        } else {
+          relWord = "este";
+          weekdayName = m[5];
+        }
+        const rel = normalizeForMatch(relWord) === "proximo" ? "next" : relWord.toLowerCase() === "este" ? "this" : "last";
+        const targetDow = weekdayIndexFromName(weekdayName, SPANISH_WEEKDAYS);
+        const refDow = extractDayOfWeek(ctx.reference);
+        return addDays(ctx.temporal, ctx.reference, weekdayOffset(rel, refDow, targetDow));
+      }
+    },
+    // unit offsets. Spanish uses distinct markers:
+    //   "en 3 días" / "dentro de 3 días" → future
+    //   "hace 2 semanas"                → past
+    // Both shapes lead with the marker, unlike English where one
+    // shape leads and the other trails.
+    {
+      pattern: new RegExp(
+        `^(?:(en|dentro\\s+de)\\s+(\\d+)\\s+(d[i\xED]a|semana|mes|a[\xF1n]o)s?|(\\d+)\\s+(d[i\xED]a|semana|mes|a[\xF1n]o)s?\\s+(hace))$`,
+        "i"
+      ),
+      resolve: (m, ctx) => {
+        let count;
+        let unitWord;
+        let sign;
+        if (m[1] && m[2] && m[3]) {
+          count = m[2];
+          unitWord = m[3];
+          sign = 1;
+        } else {
+          count = m[4];
+          unitWord = m[5];
+          sign = -1;
+        }
+        const unit = unitWordToEnglish(unitWord);
+        return addUnits(ctx.temporal, ctx.reference, sign * Number(count), unit);
+      }
+    },
+    // "hace 2 semanas" — the primary past-offset shape. Matcher kept
+    // separate from the future "en/dentro de" matcher above because
+    // Spanish word order differs between the two (marker-first for
+    // past, marker-first for future too, but with different markers).
+    {
+      pattern: new RegExp(`^hace\\s+(\\d+)\\s+(d[i\xED]a|semana|mes|a[\xF1n]o)s?$`, "i"),
+      resolve: (m, ctx) => {
+        const count = Number(m[1]);
+        const unit = unitWordToEnglish(m[2]);
+        return addUnits(ctx.temporal, ctx.reference, -count, unit);
+      }
+    },
+    // bare "N <unit>" without "en" / "hace" — throw, since direction
+    // is ambiguous. Matched AFTER the directional shapes so the
+    // directional ones win when their marker is present.
+    {
+      pattern: new RegExp(`^(\\d+)\\s+(d[i\xED]a|semana|mes|a[\xF1n]o)s?$`, "i"),
+      resolve: (m, _ctx) => {
+        throw new Error(
+          `temporal-fmt: parseRelative no puede decidir si "${m[0]}" es pasado o futuro \u2014 usa "en ${m[1]} ${m[2]}s" o "hace ${m[1]} ${m[2]}s".`
+        );
+      }
+    },
+    // month-day: "5 de marzo" (day first), "5 de marzo de 2026" (year
+    // ignored if present). Day is 1-2 digits, with optional trailing
+    // "." (rare in Spanish but tolerated).
+    {
+      pattern: new RegExp(
+        `^(\\d{1,2})\\.?\\s+de\\s+(${nameAlternation([...SPANISH_MONTHS, ...SPANISH_MONTH_SHORT])})(?:\\s+de\\s+(\\d{4}))?$`,
+        "i"
+      ),
+      resolve: (m, ctx) => {
+        const day = Number(m[1]);
+        const month = monthIndexFromName(m[2], SPANISH_MONTHS, SPANISH_MONTH_SHORT);
+        return resolveToNextOccurrence(ctx.temporal, ctx.reference, month, day);
+      }
+    }
+  ]
+};
+var FRENCH_WEEKDAYS = ["lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi", "dimanche"];
+var FRENCH_MONTHS = ["janvier", "f\xE9vrier", "mars", "avril", "mai", "juin", "juillet", "ao\xFBt", "septembre", "octobre", "novembre", "d\xE9cembre"];
+var FRENCH_MONTH_SHORT = ["janv.", "f\xE9vr.", "mars", "avr.", "mai", "juin", "juil.", "ao\xFBt", "sept.", "oct.", "nov.", "d\xE9c."];
+var FRENCH_GRAMMAR = {
+  supportedHint: `Phrases prises en charge : r\xE9f\xE9rences de jour de la semaine ("lundi prochain", "mardi dernier", "ce mercredi"), d\xE9calages de jour ("aujourd'hui"/"demain"/"hier"), d\xE9calages d'unit\xE9 ("dans 3 jours", "il y a 2 semaines"), et mois-jour ("5 mars").`,
+  matchers: [
+    {
+      pattern: /^aujourd'hui$/i,
+      resolve: (_m, ctx) => buildPlainDate(ctx.temporal, readYear(ctx.reference), readMonth(ctx.reference), readDay(ctx.reference))
+    },
+    {
+      pattern: /^demain$/i,
+      resolve: (_m, ctx) => addDays(ctx.temporal, ctx.reference, 1)
+    },
+    {
+      pattern: /^hier$/i,
+      resolve: (_m, ctx) => addDays(ctx.temporal, ctx.reference, -1)
+    },
+    // weekday references: "lundi prochain" (next), "lundi dernier"
+    // (last), "ce lundi" (this). The relative word follows the
+    // weekday for next/last, precedes it for this.
+    {
+      pattern: new RegExp(
+        `^(?:(${nameAlternation(FRENCH_WEEKDAYS)})\\s+(prochain|dernier)|ce\\s+(${nameAlternation(FRENCH_WEEKDAYS)}))$`,
+        "i"
+      ),
+      resolve: (m, ctx) => {
+        let rel;
+        let weekdayName;
+        if (m[1] && m[2]) {
+          weekdayName = m[1];
+          rel = m[2].toLowerCase() === "prochain" ? "next" : "last";
+        } else {
+          rel = "this";
+          weekdayName = m[3];
+        }
+        const targetDow = weekdayIndexFromName(weekdayName, FRENCH_WEEKDAYS);
+        const refDow = extractDayOfWeek(ctx.reference);
+        return addDays(ctx.temporal, ctx.reference, weekdayOffset(rel, refDow, targetDow));
+      }
+    },
+    // past: "il y a 2 semaines" — multi-word marker.
+    {
+      pattern: new RegExp(`^il\\s+y\\s+a\\s+(\\d+)\\s+(jour|semaine|mois|an|ann[e\xE9e]e)s?$`, "i"),
+      resolve: (m, ctx) => {
+        const count = Number(m[1]);
+        const unit = unitWordToEnglish(m[2]);
+        return addUnits(ctx.temporal, ctx.reference, -count, unit);
+      }
+    },
+    // future: "dans 3 jours"
+    {
+      pattern: new RegExp(`^dans\\s+(\\d+)\\s+(jour|semaine|mois|an|ann[e\xE9e]e)s?$`, "i"),
+      resolve: (m, ctx) => {
+        const count = Number(m[1]);
+        const unit = unitWordToEnglish(m[2]);
+        return addUnits(ctx.temporal, ctx.reference, count, unit);
+      }
+    },
+    // bare "N <unit>" without marker — throw.
+    {
+      pattern: new RegExp(`^(\\d+)\\s+(jour|semaine|mois|an|ann[e\xE9e]e)s?$`, "i"),
+      resolve: (m, _ctx) => {
+        throw new Error(
+          `temporal-fmt: parseRelative ne peut pas d\xE9terminer si "${m[0]}" est pass\xE9 ou futur \u2014 utilisez "dans ${m[1]} ${m[2]}s" ou "il y a ${m[1]} ${m[2]}s".`
+        );
+      }
+    },
+    // month-day: "5 mars" (day first, no separator word). Year ignored.
+    {
+      pattern: new RegExp(
+        `^(\\d{1,2})\\s+(${nameAlternation([...FRENCH_MONTHS, ...FRENCH_MONTH_SHORT])})(?:\\s+(\\d{4}))?$`,
+        "i"
+      ),
+      resolve: (m, ctx) => {
+        const day = Number(m[1]);
+        const month = monthIndexFromName(m[2], FRENCH_MONTHS, FRENCH_MONTH_SHORT);
+        return resolveToNextOccurrence(ctx.temporal, ctx.reference, month, day);
+      }
+    }
+  ]
+};
+var GERMAN_WEEKDAYS = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"];
+var GERMAN_MONTHS = ["Januar", "Februar", "M\xE4rz", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
+var GERMAN_MONTH_SHORT = ["Jan", "Feb", "M\xE4r", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"];
+var GERMAN_GRAMMAR = {
+  supportedHint: 'Unterst\xFCtzte Phrasen: Wochentag-Bez\xFCge ("n\xE4chsten Dienstag", "letzten Freitag", "diesen Montag"), Tages-Offsets ("heute"/"morgen"/"gestern"), Einheiten-Offsets ("in 3 Tagen", "vor 2 Wochen"), und Monat-Tag ("5. M\xE4rz").',
+  matchers: [
+    {
+      pattern: /^heute$/i,
+      resolve: (_m, ctx) => buildPlainDate(ctx.temporal, readYear(ctx.reference), readMonth(ctx.reference), readDay(ctx.reference))
+    },
+    {
+      pattern: /^morgen$/i,
+      resolve: (_m, ctx) => addDays(ctx.temporal, ctx.reference, 1)
+    },
+    {
+      pattern: /^gestern$/i,
+      resolve: (_m, ctx) => addDays(ctx.temporal, ctx.reference, -1)
+    },
+    // weekday references: "nächsten Dienstag" (next), "letzten
+    // Dienstag" (last), "diesen Dienstag" (this). Adjective precedes
+    // the weekday; case varies (nächsten/letzten/diesen all take the
+    // weak-declension -en/-en/-en ending when no article, which is
+    // convenient — one regex alternation covers all three.
+    {
+      pattern: new RegExp(`^(n(?:ae|a|\xE4)chsten|letzten|diesen)\\s+(${nameAlternation(GERMAN_WEEKDAYS)})$`, "i"),
+      resolve: (m, ctx) => {
+        const adj = normalizeForMatch(m[1]);
+        const rel = adj === "nachsten" || adj === "naechsten" ? "next" : adj === "diesen" ? "this" : "last";
+        const targetDow = weekdayIndexFromName(m[2], GERMAN_WEEKDAYS);
+        const refDow = extractDayOfWeek(ctx.reference);
+        return addDays(ctx.temporal, ctx.reference, weekdayOffset(rel, refDow, targetDow));
+      }
+    },
+    // past: "vor 2 Wochen"
+    {
+      pattern: new RegExp(`^vor\\s+(\\d+)\\s+(Tag(?:e|n|en)?|Woche(?:n)?|Monat(?:e|n|en)?|Jahr(?:e|n|en)?)$`, "i"),
+      resolve: (m, ctx) => {
+        const count = Number(m[1]);
+        const unit = unitWordToEnglish(m[2]);
+        return addUnits(ctx.temporal, ctx.reference, -count, unit);
+      }
+    },
+    // future: "in 3 Tagen"
+    {
+      pattern: new RegExp(`^in\\s+(\\d+)\\s+(Tag(?:e|n|en)?|Woche(?:n)?|Monat(?:e|n|en)?|Jahr(?:e|n|en)?)$`, "i"),
+      resolve: (m, ctx) => {
+        const count = Number(m[1]);
+        const unit = unitWordToEnglish(m[2]);
+        return addUnits(ctx.temporal, ctx.reference, count, unit);
+      }
+    },
+    // bare "N <unit>" without "in" or "vor" — throw.
+    {
+      pattern: new RegExp(`^(\\d+)\\s+(Tag(?:e|n|en)?|Woche(?:n)?|Monat(?:e|n|en)?|Jahr(?:e|n|en)?)$`, "i"),
+      resolve: (m, _ctx) => {
+        throw new Error(
+          `temporal-fmt: parseRelative kann nicht erkennen, ob "${m[0]}" Vergangenheit oder Zukunft ist \u2014 verwende "in ${m[1]} ${m[2]}" oder "vor ${m[1]} ${m[2]}".`
+        );
+      }
+    },
+    // month-day: "5. März" (day-first with period). Year ignored.
+    {
+      pattern: new RegExp(
+        `^(\\d{1,2})\\.?\\s+(${nameAlternation([...GERMAN_MONTHS, ...GERMAN_MONTH_SHORT, "Maerz", "Maer"])})(?:\\s+(\\d{4}))?$`,
+        "i"
+      ),
+      resolve: (m, ctx) => {
+        const day = Number(m[1]);
+        const month = monthIndexFromName(m[2], GERMAN_MONTHS, GERMAN_MONTH_SHORT);
+        return resolveToNextOccurrence(ctx.temporal, ctx.reference, month, day);
+      }
+    }
+  ]
+};
+var GRAMMARS = {
+  en: ENGLISH_GRAMMAR,
+  es: SPANISH_GRAMMAR,
+  fr: FRENCH_GRAMMAR,
+  de: GERMAN_GRAMMAR
+};
+function grammarForLocale(locale) {
+  if (!locale) return ENGLISH_GRAMMAR;
+  try {
+    const tag = new Intl.Locale(locale.replace(/_/g, "-"));
+    const lang = tag.language.toLowerCase();
+    return GRAMMARS[lang] ?? ENGLISH_GRAMMAR;
+  } catch {
+    return ENGLISH_GRAMMAR;
+  }
+}
+function languageOf(locale) {
+  if (!locale) return "en";
+  try {
+    return new Intl.Locale(locale.replace(/_/g, "-")).language.toLowerCase();
+  } catch {
+    return "en";
+  }
+}
+function unitWordToEnglish(word) {
+  const w = normalizeForMatch(word);
+  if (w === "day" || w === "week" || w === "month" || w === "year") return w;
+  if (w === "dia") return "day";
+  if (w === "semana") return "week";
+  if (w === "mes") return "month";
+  if (w === "ano" || w === "a\xF1o") return "year";
+  if (w === "jour") return "day";
+  if (w === "semaine") return "week";
+  if (w === "mois") return "month";
+  if (w === "an" || w === "annee") return "year";
+  if (w === "tag" || w === "tagen") return "day";
+  if (w === "woche" || w === "wochen") return "week";
+  if (w === "monat" || w === "monaten") return "month";
+  if (w === "jahr" || w === "jahren") return "year";
+  /* c8 ignore start @preserve -- unreachable: every caller passes a word
+   * captured by a regex alternation built from exactly these unit-word
+   * forms (day/week/month/year across en/es/fr/de), so the branches
+   * above already cover every string that can reach this function.
+   * Kept as a tripwire for the type checker in case a grammar adds a
+   * unit word here without a matching regex update. */
+  throw new Error(`temporal-fmt: parseRelative internal error \u2014 unrecognized unit word "${word}".`);
+  /* c8 ignore stop @preserve */
+}
+function parseRelative(input, referenceDate, options = {}) {
+  const reference = referenceDate;
+  const temporal = getTemporal();
+  const trimmed = (input ?? "").trim().replace(/\s+/g, " ");
+  if (trimmed.length === 0) {
+    throw new Error("temporal-fmt: parseRelative got an empty input string.");
+  }
+  if (trimmed.length > MAX_RELATIVE_INPUT_LENGTH) {
+    throw new RangeError(
+      `temporal-fmt: parseRelative input is too large (maximum ${MAX_RELATIVE_INPUT_LENGTH} characters).`
+    );
+  }
+  const normalized = normalizeForMatch(trimmed);
+  const grammar = grammarForLocale(options.locale);
+  const ctx = { temporal, reference };
+  const registered = tryRegisteredGrammar(languageOf(options.locale), trimmed, {
+    year: reference.year,
+    month: reference.month,
+    day: reference.day,
+    dayOfWeek: reference.dayOfWeek
+  });
+  if (registered !== null) {
+    return registered;
+  }
+  const tryMatch = (text) => {
+    for (const matcher of grammar.matchers) {
+      const match = text.match(matcher.pattern);
+      if (match) {
+        return matcher.resolve(match, ctx);
+      }
+    }
+    return NO_MATCH;
+  };
+  const exactResult = tryMatch(normalized);
+  if (exactResult !== NO_MATCH) {
+    return exactResult;
+  }
+  if (options.fuzzy) {
+    if (grammar !== ENGLISH_GRAMMAR) {
+      throw new Error(
+        `temporal-fmt: parseRelative's { fuzzy: true } option currently only supports English. Pass no locale (or locale: 'en'), or omit { fuzzy: true } for this locale.`
+      );
+    }
+    const corrected = fuzzyCorrectEnglish(normalized);
+    if (corrected !== void 0) {
+      const fuzzyResult = tryMatch(corrected);
+      if (fuzzyResult !== NO_MATCH) {
+        return fuzzyResult;
+      }
+    }
+  }
+  throw new Error(
+    `temporal-fmt: parseRelative doesn't recognize "${trimmed}". ` + grammar.supportedHint
+  );
+}
+var NO_MATCH = /* @__PURE__ */ Symbol("temporal-fmt: parseRelative no match");
+
+// src/tokenMetadata.ts
+var TYPES_WITH = {
+  year: ["PlainDate", "PlainDateTime", "ZonedDateTime", "PlainYearMonth"],
+  month: ["PlainDate", "PlainDateTime", "ZonedDateTime", "PlainYearMonth", "PlainMonthDay"],
+  day: ["PlainDate", "PlainDateTime", "ZonedDateTime", "PlainMonthDay"],
+  hour: ["PlainTime", "PlainDateTime", "ZonedDateTime", "Instant"],
+  minute: ["PlainTime", "PlainDateTime", "ZonedDateTime", "Instant"],
+  second: ["PlainTime", "PlainDateTime", "ZonedDateTime", "Instant"],
+  millisecond: ["PlainTime", "PlainDateTime", "ZonedDateTime", "Instant"],
+  dayOfWeek: ["PlainDate", "PlainDateTime", "ZonedDateTime"],
+  timeZoneId: ["ZonedDateTime"],
+  offset: ["ZonedDateTime"]
+};
+var TOKEN_METADATA = {
+  yyyy: {
+    meaning: "Four-digit year (preserves sign for BCE; no truncation).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.year,
+    roundTripSafe: true
+  },
+  yy: {
+    meaning: "Two-digit year (year % 100). Throws on negative years.",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.year,
+    roundTripSafe: false
+  },
+  y: {
+    meaning: "Unpadded year, any width (preserves sign for BCE; no truncation, no minimum digits). Cannot sit directly next to another digit-reading token or a literal starting with a digit \u2014 there would be no way to tell where it ends.",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.year,
+    roundTripSafe: true
+  },
+  MMMM: {
+    meaning: 'Long month name (locale-aware, e.g. "January", "janvier").',
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: true,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.month,
+    roundTripSafe: true
+  },
+  MMM: {
+    meaning: 'Short month name (locale-aware, e.g. "Jan", "janv.").',
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: true,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.month,
+    roundTripSafe: true
+  },
+  MM: {
+    meaning: "Two-digit month (01-12, zero-padded).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.month,
+    roundTripSafe: true
+  },
+  M: {
+    meaning: "One- or two-digit month (1-12, no padding).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.month,
+    roundTripSafe: true
+  },
+  dd: {
+    meaning: "Two-digit day-of-month (01-31, zero-padded).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.day,
+    roundTripSafe: true
+  },
+  d: {
+    meaning: "One- or two-digit day-of-month (1-31, no padding).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.day,
+    roundTripSafe: true
+  },
+  EEEE: {
+    meaning: 'Long weekday name (locale-aware, e.g. "Monday", "lundi"). Parse cross-checks against the parsed date.',
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: true,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.dayOfWeek,
+    roundTripSafe: true
+  },
+  EEE: {
+    meaning: 'Short weekday name (locale-aware, e.g. "Mon", "lun."). Parse cross-checks against the parsed date.',
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: true,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.dayOfWeek,
+    roundTripSafe: true
+  },
+  HH: {
+    meaning: "Two-digit hour, 24-hour clock (00-23, zero-padded).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.hour,
+    roundTripSafe: true
+  },
+  H: {
+    meaning: "One- or two-digit hour, 24-hour clock (0-23, no padding).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.hour,
+    roundTripSafe: true
+  },
+  hh: {
+    meaning: "Two-digit hour, 12-hour clock (01-12, zero-padded). Requires `a` token on parse.",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.hour,
+    roundTripSafe: true
+  },
+  h: {
+    meaning: "One- or two-digit hour, 12-hour clock (1-12, no padding). Requires `a` token on parse.",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.hour,
+    roundTripSafe: true
+  },
+  mm: {
+    meaning: "Two-digit minute (00-59, zero-padded).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.minute,
+    roundTripSafe: true
+  },
+  m: {
+    meaning: "One- or two-digit minute (0-59, no padding).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.minute,
+    roundTripSafe: true
+  },
+  ss: {
+    meaning: "Two-digit second (00-59, zero-padded).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.second,
+    roundTripSafe: true
+  },
+  s: {
+    meaning: "One- or two-digit second (0-59, no padding).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.second,
+    roundTripSafe: true
+  },
+  S: {
+    meaning: "Fractional second, 1 digit (tenths of a second).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.millisecond,
+    roundTripSafe: true
+  },
+  SS: {
+    meaning: "Fractional second, 2 digits (hundredths of a second).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.millisecond,
+    roundTripSafe: true
+  },
+  SSS: {
+    meaning: "Fractional second, 3 digits (milliseconds).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.millisecond,
+    roundTripSafe: true
+  },
+  SSSS: {
+    meaning: "Fractional second, 4 digits (tens of microseconds).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.millisecond,
+    roundTripSafe: true
+  },
+  SSSSS: {
+    meaning: "Fractional second, 5 digits (hundred-thousandths of a second).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.millisecond,
+    roundTripSafe: true
+  },
+  SSSSSS: {
+    meaning: "Fractional second, 6 digits (microseconds).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.millisecond,
+    roundTripSafe: true
+  },
+  SSSSSSS: {
+    meaning: "Fractional second, 7 digits (tens of nanoseconds).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.millisecond,
+    roundTripSafe: true
+  },
+  SSSSSSSS: {
+    meaning: "Fractional second, 8 digits (hundred-millionths of a second).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.millisecond,
+    roundTripSafe: true
+  },
+  SSSSSSSSS: {
+    meaning: "Fractional second, 9 digits (nanoseconds).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.millisecond,
+    roundTripSafe: true
+  },
+  a: {
+    meaning: 'Day period (locale-aware: "AM"/"PM", "\u5348\u524D"/"\u5348\u5F8C", etc.). Required alongside 12-hour tokens on parse.',
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: true,
+    calendarSensitive: false,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.hour,
+    roundTripSafe: true
+  },
+  zzz: {
+    meaning: 'IANA time zone id (e.g. "America/New_York") or fixed offset ("+05:30"). Requires full date+time on parse.',
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: true,
+    supportedTypes: TYPES_WITH.timeZoneId,
+    roundTripSafe: true
+  },
+  X: {
+    meaning: "Numeric UTC offset, short (Z for UTC, \xB1HH[MM] otherwise). Minutes omitted when zero.",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: true,
+    supportedTypes: TYPES_WITH.offset,
+    roundTripSafe: true
+  },
+  XX: {
+    meaning: "Numeric UTC offset, no colon (Z for UTC, \xB1HHMM otherwise).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: true,
+    supportedTypes: TYPES_WITH.offset,
+    roundTripSafe: true
+  },
+  XXX: {
+    meaning: "Numeric UTC offset, with colon (Z for UTC, \xB1HH:MM otherwise).",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: true,
+    supportedTypes: TYPES_WITH.offset,
+    roundTripSafe: true
+  },
+  x: {
+    meaning: "Numeric UTC offset, short, never Z (always \xB1HH[MM]). Lowercase variant of X.",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: true,
+    supportedTypes: TYPES_WITH.offset,
+    roundTripSafe: true
+  },
+  xx: {
+    meaning: "Numeric UTC offset, no colon, never Z (always \xB1HHMM). Lowercase variant of XX.",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: true,
+    supportedTypes: TYPES_WITH.offset,
+    roundTripSafe: true
+  },
+  xxx: {
+    meaning: "Numeric UTC offset, with colon, never Z (always \xB1HH:MM). Lowercase variant of XXX.",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: false,
+    timezoneSensitive: true,
+    supportedTypes: TYPES_WITH.offset,
+    roundTripSafe: true
+  },
+  do: {
+    meaning: 'Ordinal day-of-month with English suffix ("1st", "2nd", "3rd", "4th", ... 21st, 22nd, ...). Format-only \u2014 not parseable.',
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.day,
+    roundTripSafe: false
+  },
+  Q: {
+    meaning: "Quarter as a digit (1-4). Derived from month.",
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.month,
+    roundTripSafe: true
+  },
+  QQQ: {
+    meaning: 'Quarter with "Q" prefix ("Q1".."Q4"). Derived from month.',
+    formatCapable: true,
+    parseCapable: true,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.month,
+    roundTripSafe: true
+  },
+  ww: {
+    meaning: "ISO 8601 week number (01-53). Format-only \u2014 week alone can't reconstruct a date.",
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.dayOfWeek,
+    roundTripSafe: false
+  },
+  RRRR: {
+    meaning: "ISO 8601 week-numbering year (4-digit, may differ from calendar year at year boundaries). Format-only.",
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.dayOfWeek,
+    roundTripSafe: false
+  },
+  D: {
+    meaning: "Day of year, unpadded (1-366). Format-only \u2014 parsing requires resolving against a year.",
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.day,
+    roundTripSafe: false
+  },
+  DD: {
+    meaning: "Day of year, 2-digit minimum (01-366). Format-only.",
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.day,
+    roundTripSafe: false
+  },
+  DDD: {
+    meaning: "Day of year, 3-digit zero-padded (001-366). Format-only.",
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: false,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.day,
+    roundTripSafe: false
+  },
+  LLLL: {
+    meaning: "Stand-alone long month name (nominative case in Slavic locales). Identical to MMMM in most locales.",
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: true,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.month,
+    roundTripSafe: true
+  },
+  LLL: {
+    meaning: "Stand-alone short month name. Identical to MMM in most locales.",
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: true,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.month,
+    roundTripSafe: true
+  },
+  cccc: {
+    meaning: "Stand-alone long weekday name. Identical to EEEE in most locales.",
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: true,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.dayOfWeek,
+    roundTripSafe: true
+  },
+  ccc: {
+    meaning: "Stand-alone short weekday name. Identical to EEE in most locales.",
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: true,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.dayOfWeek,
+    roundTripSafe: true
+  },
+  GGGG: {
+    meaning: 'Long era name (locale-aware, e.g. "Anno Domini"/"Before Christ"). Format-only.',
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: true,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.year,
+    roundTripSafe: false
+  },
+  G: {
+    meaning: 'Short era name (locale-aware, e.g. "AD"/"BC"). Format-only.',
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: true,
+    calendarSensitive: true,
+    timezoneSensitive: false,
+    supportedTypes: TYPES_WITH.year,
+    roundTripSafe: false
+  },
+  zzzz: {
+    meaning: 'Localized long timezone name (e.g. "Eastern Standard Time"). Format-only.',
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: true,
+    calendarSensitive: false,
+    timezoneSensitive: true,
+    supportedTypes: TYPES_WITH.timeZoneId,
+    roundTripSafe: false
+  },
+  z: {
+    meaning: 'Localized short timezone name (e.g. "EST"). Format-only.',
+    formatCapable: true,
+    parseCapable: false,
+    localeSensitive: true,
+    calendarSensitive: false,
+    timezoneSensitive: true,
+    supportedTypes: TYPES_WITH.timeZoneId,
+    roundTripSafe: false
+  }
+};
+var ALL_TOKEN_NAMES = Object.keys(TOKEN_METADATA);
+
+// src/analyze.ts
+function tokenizeFormat(formatStr) {
+  return tokenize(formatStr);
+}
+function listTokens() {
+  return TOKENS.map(([name]) => ({ name, metadata: TOKEN_METADATA[name] }));
+}
+function tokenInfo(name) {
+  return TOKEN_METADATA[name];
+}
+function analyzeFormat(formatStr) {
+  if (formatStr.length > MAX_FORMAT_LENGTH) {
+    throw new Error(
+      `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
+    );
+  }
+  const pieces = tokenize(formatStr);
+  const tokens = [];
+  const requiredFields = /* @__PURE__ */ new Set();
+  const compatibleTypesSet = /* @__PURE__ */ new Set();
+  let parseable = true;
+  let localeSensitive = false;
+  let calendarSensitive = false;
+  let timezoneSensitive = false;
+  let roundTripSafe = true;
+  const warnings = [];
+  let offset = 0;
+  const unpaddedRun = [];
+  const flushRun = () => {
+    if (unpaddedRun.length >= 2) {
+      warnings.push({
+        code: "AMBIGUOUS_NUMERIC_RUN",
+        message: `Adjacent unpadded numeric tokens "${unpaddedRun.join("")}" with no separator can be ambiguous to parse. Add a separator or use the padded form (e.g. "MM" instead of "M").`
+      });
+    }
+    unpaddedRun.length = 0;
+  };
+  for (const piece of pieces) {
+    if (piece.kind === "literal") {
+      offset += piece.value.length;
+      flushRun();
+      continue;
+    }
+    const metadata = TOKEN_METADATA[piece.value];
+    if (!metadata) {
+      warnings.push({
+        code: "UNKNOWN_TOKEN_NO_METADATA",
+        message: `Token "${piece.value}" is recognized by the tokenizer but has no metadata entry in tokenMetadata.ts \u2014 this is a bug in temporal-fmt.`
+      });
+      offset += piece.value.length;
+      continue;
+    }
+    tokens.push({ name: piece.value, position: offset, metadata });
+    const handler = _handlerFor(piece.value);
+    if (handler) {
+      requiredFields.add(handler.field);
+    }
+    if (tokens.length === 1) {
+      for (const t of metadata.supportedTypes) compatibleTypesSet.add(t);
+    } else {
+      const stillCompatible = /* @__PURE__ */ new Set();
+      for (const t of compatibleTypesSet) {
+        if (metadata.supportedTypes.includes(t)) stillCompatible.add(t);
+      }
+      compatibleTypesSet.clear();
+      for (const t of stillCompatible) compatibleTypesSet.add(t);
+    }
+    if (!metadata.parseCapable) {
+      parseable = false;
+      warnings.push({
+        code: "FORMAT_ONLY_TOKEN",
+        message: `Token "${piece.value}" is format-only \u2014 it can't be parsed back into a value. Use a parse-capable variant (e.g. "d" instead of "do") if you need round-trip.`
+      });
+    }
+    if (metadata.localeSensitive) localeSensitive = true;
+    if (metadata.calendarSensitive) calendarSensitive = true;
+    if (metadata.timezoneSensitive) timezoneSensitive = true;
+    if (!metadata.roundTripSafe) roundTripSafe = false;
+    if (UNPADDED_NUMERIC_TOKENS.has(piece.value)) {
+      unpaddedRun.push(piece.value);
+    } else {
+      flushRun();
+    }
+    offset += piece.value.length;
+  }
+  flushRun();
+  const tokenNames = tokens.map((t) => t.name);
+  const has12Hour = tokenNames.some((t) => t === "hh" || t === "h");
+  const has24Hour = tokenNames.some((t) => t === "HH" || t === "H");
+  const hasAPeriod = tokenNames.some((t) => t === "a");
+  if (has12Hour && !hasAPeriod) {
+    warnings.push({
+      code: "TWELVE_HOUR_WITHOUT_A",
+      message: `12-hour token ("hh"/"h") used without an "a" (AM/PM) token \u2014 parse() can't tell AM from PM and throws at runtime.`
+    });
+  }
+  if (has12Hour && has24Hour) {
+    warnings.push({
+      code: "MIXED_12_AND_24_HOUR",
+      message: "Mixing 24-hour and 12-hour tokens \u2014 parse() refuses to guess which is authoritative and throws at runtime."
+    });
+  }
+  const hasOffset = tokenNames.some((t) => t === "X" || t === "XX" || t === "XXX" || t === "x" || t === "xx" || t === "xxx");
+  const hasZzz = tokenNames.some((t) => t === "zzz");
+  if (hasOffset && hasZzz) {
+    warnings.push({
+      code: "ZZZ_WITH_OFFSET_TOKEN",
+      message: `Format string has both "zzz" and an offset token \u2014 parse() cross-checks them and throws if the parsed offset disagrees with the zone's actual offset.`
+    });
+  }
+  if (hasOffset && !requiredFields.has("year")) {
+    warnings.push({
+      code: "OFFSET_WITHOUT_FULL_DATE",
+      message: "Offset token used without a full date \u2014 parse() needs a complete date and time to build a ZonedDateTime and throws at runtime otherwise."
+    });
+  }
+  return {
+    tokens,
+    requiredFields: [...requiredFields].sort(),
+    compatibleTypes: [...compatibleTypesSet].sort(),
+    parseable,
+    localeSensitive,
+    calendarSensitive,
+    timezoneSensitive,
+    // Ambiguous iff at least one warning fired about an ambiguous run.
+    ambiguous: warnings.some((w) => w.code === "AMBIGUOUS_NUMERIC_RUN"),
+    roundTripSafe: roundTripSafe && parseable,
+    warnings
+  };
+}
+function explainFormat(formatStr) {
+  const analysis = analyzeFormat(formatStr);
+  const lines = [];
+  lines.push(`Format string: "${formatStr}"`);
+  lines.push(`Tokens (${analysis.tokens.length}):`);
+  for (const t of analysis.tokens) {
+    lines.push(`  ${t.name} @${t.position} \u2014 ${t.metadata.meaning}`);
+  }
+  if (analysis.requiredFields.length > 0) {
+    lines.push(`Required fields: ${analysis.requiredFields.join(", ")}`);
+  }
+  if (analysis.compatibleTypes.length > 0) {
+    lines.push(`Compatible Temporal types: ${analysis.compatibleTypes.join(", ")}`);
+  }
+  lines.push(`Parseable: ${analysis.parseable ? "yes" : "no"}`);
+  lines.push(`Locale-sensitive: ${analysis.localeSensitive ? "yes" : "no"}`);
+  lines.push(`Calendar-sensitive: ${analysis.calendarSensitive ? "yes" : "no"}`);
+  lines.push(`Timezone-sensitive: ${analysis.timezoneSensitive ? "yes" : "no"}`);
+  lines.push(`Ambiguous: ${analysis.ambiguous ? "yes" : "no"}`);
+  lines.push(`Round-trip safe: ${analysis.roundTripSafe ? "yes" : "no"}`);
+  if (analysis.warnings.length > 0) {
+    lines.push("Warnings:");
+    for (const w of analysis.warnings) {
+      lines.push(`  [${w.code}] ${w.message}`);
+    }
+  }
+  return lines.join("\n");
+}
+function isValidFormat(formatStr) {
+  if (formatStr.length > MAX_FORMAT_LENGTH) return false;
+  try {
+    tokenize(formatStr);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateFormat(formatStr) {
+  const analysis = analyzeFormat(formatStr);
+  return analysis;
+}
+function fieldForToken(token) {
+  return _handlerFor(token)?.field;
+}
+
+// src/serialization.ts
+function parseISO(input) {
+  const temporal = getTemporal();
+  try {
+    if (/^\d{4}-\d{2}-\d{2}T/.test(input) || /T\d{2}:\d{2}/.test(input)) {
+      if (/[zZ]$/.test(input) || /[+-]\d{2}:?\d{2}$/.test(input)) {
+        let iso = input;
+        if (/[zZ]$/.test(iso)) {
+          iso = iso.slice(0, -1) + "+00:00[UTC]";
+        } else {
+          const offsetMatch = /([+-]\d{2}:?\d{2})$/.exec(iso);
+          if (offsetMatch) {
+            iso = `${iso}[${offsetMatch[1]}]`;
+          }
+        }
+        return temporal.ZonedDateTime.from(iso, { overflow: "reject" });
+      }
+      return temporal.PlainDateTime.from(input, { overflow: "reject" });
+    }
+    if (/^\d{4}-\d{2}-\d{2}/.test(input)) {
+      return temporal.PlainDate.from(input, { overflow: "reject" });
+    }
+    if (/^\d{2}:\d{2}/.test(input)) {
+      return temporal.PlainTime.from(input);
+    }
+    throw new Error(`temporal-fmt: parseISO("${input}") doesn't look like an ISO 8601 string.`);
+  } catch (err) {
+    throw new InvalidDateError({ input, reason: err.message });
+  }
+}
+function formatISO(value) {
+  const v = value;
+  if (typeof v?.toString !== "function") {
+    throw new FormatSyntaxError({ reason: `formatISO() expects a Temporal value with toString(), got ${typeof value}.` });
+  }
+  return v.toString();
+}
+function parseRFC3339(input) {
+  const re = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(\.\d+)?([Zz]|[+-]\d{2}:\d{2})$/;
+  const m = re.exec(input);
+  if (!m) {
+    throw new FormatSyntaxError({ input, reason: "does not match RFC 3339 date-time grammar" });
+  }
+  const iso = input.replace(/[tT]/, "T").replace(/[zZ]$/, "+00:00[UTC]");
+  return parseISO(iso);
+}
+function formatRFC3339(value) {
+  const s = formatISO(value);
+  if (!/^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\.[0-9]+)?(Z|[+-][0-9]{2}:[0-9]{2})$/.test(s)) {
+    throw new FormatSyntaxError({ input: s, reason: "value did not produce RFC 3339-compliant output" });
+  }
+  return s;
+}
+function parseRFC2822(input) {
+  const RFC2822_SHAPE = /^(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s+)?\d{1,2}\s+(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{2,4}\s+\d{2}:\d{2}(?::\d{2})?\s+(?:[+-]\d{4}|[A-Za-z]{1,5})$/;
+  if (!RFC2822_SHAPE.test(input.trim())) {
+    throw new FormatSyntaxError({ input, reason: "not a valid RFC 2822 date" });
+  }
+  const ms = Date.parse(input);
+  if (Number.isNaN(ms)) {
+    throw new FormatSyntaxError({ input, reason: "not a valid RFC 2822 date" });
+  }
+  return requireInstant().fromEpochMilliseconds(ms);
+}
+function formatRFC2822(value) {
+  const v = value;
+  let ms;
+  if (typeof v?.toEpochMilliseconds === "function") {
+    ms = v.toEpochMilliseconds();
+  } else if (typeof v?.epochMilliseconds === "number") {
+    ms = v.epochMilliseconds;
+  } else if (typeof v?.toInstant === "function") {
+    const inst = v.toInstant();
+    if (typeof inst.epochMilliseconds === "number") {
+      ms = inst.epochMilliseconds;
+    }
+  }
+  if (ms === void 0) {
+    throw new FormatSyntaxError({ reason: `formatRFC2822() expects a value with epochMilliseconds, toEpochMilliseconds(), or toInstant(), got ${typeof value}.` });
+  }
+  return formatRFC2822FromMs(ms);
+}
+function formatRFC2822FromMs(ms) {
+  try {
+    const fmt = new Intl.DateTimeFormat("en-US", {
+      weekday: "short",
+      day: "2-digit",
+      month: "short",
+      year: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      timeZone: "UTC",
+      timeZoneName: "shortOffset",
+      hour12: false
+    });
+    const parts = fmt.formatToParts(new Date(ms));
+    const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
+    const tzRaw = get("timeZoneName");
+    const tzMatch = tzRaw?.match(/GMT([+-])(\d+)(?::(\d+))?/);
+    let tz;
+    if (tzMatch) {
+      const sign = tzMatch[1];
+      const hours = tzMatch[2].padStart(2, "0");
+      const minutes = (tzMatch[3] ?? "0").padStart(2, "0");
+      tz = `${sign}${hours}${minutes}`;
+      /* c8 ignore start @preserve -- timeZone is hardcoded to 'UTC' above,
+         which always resolves cleanly, so shortOffset always returns a
+         parseable "GMT+0"-shaped string in this environment's ICU. This
+         branch only guards against an ICU build whose shortOffset output
+         doesn't match the regex; can't trigger it without mocking Intl.
+         The ignore starts before the closing brace of the if-block so it
+         covers the whole else-branch node c8 tracks as a single unit. */
+    } else {
+      tz = "+0000";
+    }
+    /* c8 ignore stop @preserve */
+    let hour = get("hour");
+    /* c8 ignore start @preserve -- hour12:false with a fixed UTC zone
+       never yields "24" in this environment's ICU (midnight formats as
+       "00"). Some ICU versions/locales are documented to emit "24" for
+       hour12:false, so this stays as a defensive normalization; not
+       reachable here without mocking Intl.DateTimeFormat's output. */
+    if (hour === "24") hour = "00";
+    /* c8 ignore stop @preserve */
+    return `${get("weekday")}, ${get("day")} ${get("month")} ${get("year")} ${hour}:${get("minute")}:${get("second")} ${tz}`;
+    /* c8 ignore start @preserve -- Intl.DateTimeFormat is constructed
+       above with a literal, always-valid timeZone: 'UTC' and no other
+       user input reaches the constructor or formatToParts call, so this
+       catch can't be triggered through the public API in a normal Intl
+       environment (e.g. Node with full-icu). Kept as a genuine fallback
+       for runtimes with a broken or absent Intl implementation. */
+  } catch {
+    const d = new Date(ms);
+    const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    const wd = days[d.getUTCDay()];
+    const dd = String(d.getUTCDate()).padStart(2, "0");
+    const mon = months[d.getUTCMonth()];
+    const yyyy = d.getUTCFullYear();
+    const hh = String(d.getUTCHours()).padStart(2, "0");
+    const mm = String(d.getUTCMinutes()).padStart(2, "0");
+    const ss = String(d.getUTCSeconds()).padStart(2, "0");
+    return `${wd}, ${dd} ${mon} ${yyyy} ${hh}:${mm}:${ss} +0000`;
+  }
+  /* c8 ignore stop @preserve */
+}
+function parseHTTPDate(input) {
+  const trimmed = input.trim();
+  const ms = Date.parse(trimmed);
+  if (Number.isNaN(ms)) {
+    throw new FormatSyntaxError({ input, reason: "not a valid HTTP-date" });
+  }
+  return requireInstant().fromEpochMilliseconds(ms);
+}
+function formatHTTPDate(value) {
+  const instant = value?.toInstant?.() ?? value;
+  const ms = typeof instant === "object" && instant !== null && "epochMilliseconds" in instant ? instant.epochMilliseconds : (() => {
+    throw new FormatSyntaxError({ reason: `formatHTTPDate() expects an Instant or ZonedDateTime, got ${typeof value}.` });
+  })();
+  const d = new Date(ms);
+  const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const wd = days[d.getUTCDay()];
+  const dd = String(d.getUTCDate()).padStart(2, "0");
+  const mon = months[d.getUTCMonth()];
+  const yyyy = d.getUTCFullYear();
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  const ss = String(d.getUTCSeconds()).padStart(2, "0");
+  return `${wd}, ${dd} ${mon} ${yyyy} ${hh}:${mm}:${ss} GMT`;
+}
+function getInstant(value) {
+  const v = value;
+  if (typeof v?.toInstant === "function") {
+    const inst = v.toInstant();
+    if (typeof inst.epochNanoseconds === "bigint") {
+      return { epochMilliseconds: inst.epochMilliseconds, epochNanoseconds: inst.epochNanoseconds };
+    }
+    return { epochMilliseconds: inst.epochMilliseconds, epochNanoseconds: BigInt(inst.epochMilliseconds) * 1000000n };
+  }
+  if (typeof v?.epochNanoseconds === "bigint") {
+    return { epochMilliseconds: Number(v.epochNanoseconds / 1000000n), epochNanoseconds: v.epochNanoseconds };
+  }
+  if (typeof v?.epochMilliseconds === "number") {
+    return { epochMilliseconds: v.epochMilliseconds, epochNanoseconds: BigInt(v.epochMilliseconds) * 1000000n };
+  }
+  throw new FormatSyntaxError({ reason: `expected an Instant or ZonedDateTime, got ${typeof value}.` });
+}
+function requireInstant() {
+  const t = getTemporal().Instant;
+  if (!t) throw new Error("temporal-fmt: Temporal.Instant is not available in this implementation.");
+  return t;
+}
+function toUnixSeconds(value) {
+  return getInstant(value).epochMilliseconds / 1e3;
+}
+function fromUnixSeconds(seconds) {
+  return requireInstant().fromEpochMilliseconds(seconds * 1e3);
+}
+function fromUnixMilliseconds(ms) {
+  return requireInstant().fromEpochMilliseconds(ms);
+}
+function fromUnixMicroseconds(\u00B5s) {
+  return requireInstant().fromEpochNanoseconds(BigInt(\u00B5s) * 1000n);
+}
+function fromUnixNanoseconds(ns) {
+  return requireInstant().fromEpochNanoseconds(ns);
+}
+function toUnixMilliseconds(value) {
+  return getInstant(value).epochMilliseconds;
+}
+function toUnixMicroseconds(value) {
+  const { epochNanoseconds } = getInstant(value);
+  return Number(epochNanoseconds / 1000n);
+}
+function toUnixNanoseconds(value) {
+  return getInstant(value).epochNanoseconds;
+}
+function parseSQL(input) {
+  const trimmed = input.trim();
+  const parseImpl = getParseImpl();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+    return parseImpl("yyyy-MM-dd", trimmed);
+  }
+  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(trimmed)) {
+    return parseImpl("yyyy-MM-dd HH:mm:ss", trimmed);
+  }
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(trimmed)) {
+    return parseISO(trimmed);
+  }
+  throw new FormatSyntaxError({ input, reason: "not a recognized SQL date/time format" });
+}
+function formatSQL(value) {
+  const v = value;
+  const formatImpl = getFormatImpl();
+  if (typeof v?.hour === "number") {
+    return formatImpl(value, "yyyy-MM-dd HH:mm:ss");
+  }
+  return formatImpl(value, "yyyy-MM-dd");
+}
+
+// src/config.ts
+var DEFAULT_CONFIG = {
+  locale: DEFAULT_LOCALE,
+  numberingSystem: "latn",
+  firstDayOfWeek: 1,
+  roundingMode: "nearest",
+  disambiguation: "compatible",
+  overflow: "reject",
+  parseLenient: false,
+  durationShowZeroValues: false
+};
+function createConfig(overrides = {}) {
+  const merged = { ...DEFAULT_CONFIG, ...overrides };
+  if (typeof merged.locale !== "string" || merged.locale.length === 0) {
+    throw new Error(`temporal-fmt: config.locale must be a non-empty string (got ${String(merged.locale)}).`);
+  }
+  if (merged.firstDayOfWeek !== 1 && merged.firstDayOfWeek !== 7) {
+    throw new Error(`temporal-fmt: config.firstDayOfWeek must be 1 (Monday) or 7 (Sunday) (got ${merged.firstDayOfWeek}).`);
+  }
+  if (!["nearest", "floor", "ceil", "trunc"].includes(merged.roundingMode)) {
+    throw new Error(`temporal-fmt: config.roundingMode "${merged.roundingMode}" is not recognized.`);
+  }
+  if (!["compatible", "earlier", "later", "reject"].includes(merged.disambiguation)) {
+    throw new Error(`temporal-fmt: config.disambiguation "${merged.disambiguation}" is not recognized.`);
+  }
+  if (!["constrain", "reject"].includes(merged.overflow)) {
+    throw new Error(`temporal-fmt: config.overflow "${merged.overflow}" is not recognized.`);
+  }
+  return Object.freeze(merged);
+}
+function mergeWithConfig(config, perCall) {
+  if (!config) return perCall;
+  const extras = {};
+  if (perCall.locale === void 0) extras.locale = config.locale;
+  if (perCall.calendar === void 0 && config.calendar !== void 0) extras.calendar = config.calendar;
+  if (perCall.timezone === void 0 && config.timezone !== void 0) extras.timezone = config.timezone;
+  if (perCall.numberingSystem === void 0) extras.numberingSystem = config.numberingSystem;
+  if (perCall.lenient === void 0 && config.parseLenient) extras.lenient = true;
+  return { ...perCall, ...extras };
+}
+
+// src/businessCalendar.ts
+function createBusinessCalendar(options = {}) {
+  const weekend = new Set(options.weekend ?? [6, 7]);
+  const workingHours = { ...options.workingHours ?? {} };
+  for (let i = 1; i <= 7; i++) {
+    if (workingHours[i] === void 0) {
+      workingHours[i] = weekend.has(i) ? 0 : 8;
+    }
+  }
+  return {
+    weekend,
+    holidays: options.holidays,
+    workingHours,
+    halfDays: new Set(options.halfDays ?? [])
+  };
+}
+function isBusinessDay(cal, value) {
+  const v = value;
+  let dow = v.dayOfWeek;
+  if (typeof v.year === "number" && typeof v.month === "number" && typeof v.day === "number") {
+    const d = new Date(Date.UTC(v.year, v.month - 1, v.day));
+    const jsDow = d.getUTCDay();
+    dow = jsDow === 0 ? 7 : jsDow;
+  }
+  if (typeof dow !== "number") {
+    throw new Error("temporal-fmt: isBusinessDay() needs a value with dayOfWeek (or year/month/day to compute it).");
+  }
+  if (cal.weekend.has(dow)) return false;
+  if (cal.holidays && cal.holidays.isHoliday(value)) return false;
+  return true;
+}
+function nextBusinessDay(cal, value) {
+  let candidate = add(value, 1, "days");
+  for (let i = 0; i < 14; i++) {
+    if (isBusinessDay(cal, candidate)) return candidate;
+    candidate = add(candidate, 1, "days");
+  }
+  throw new Error("temporal-fmt: nextBusinessDay() gave up after 14 days \u2014 likely a misconfigured calendar (e.g. all days are weekends or holidays).");
+}
+function previousBusinessDay(cal, value) {
+  let candidate = add(value, -1, "days");
+  for (let i = 0; i < 14; i++) {
+    if (isBusinessDay(cal, candidate)) return candidate;
+    candidate = add(candidate, -1, "days");
+  }
+  throw new Error("temporal-fmt: previousBusinessDay() gave up after 14 days \u2014 likely a misconfigured calendar.");
+}
+var MAX_BUSINESS_DAY_TRAVERSAL = 1e5;
+function assertBusinessDayCount(days) {
+  if (!Number.isSafeInteger(days)) {
+    throw new RangeError(
+      `temporal-fmt: business-day count must be a finite safe integer (got ${days}).`
+    );
+  }
+}
+function compareDateFields(a, b) {
+  const av = a;
+  const bv = b;
+  const ay = av.year * 1e4 + av.month * 100 + av.day;
+  const by = bv.year * 1e4 + bv.month * 100 + bv.day;
+  return ay - by;
+}
+function addBusinessDays(cal, value, days) {
+  assertBusinessDayCount(days);
+  if (days === 0) return value;
+  const sign = days > 0 ? 1 : -1;
+  const absDays = Math.abs(days);
+  if (absDays > MAX_BUSINESS_DAY_TRAVERSAL) {
+    throw new RangeError(
+      `temporal-fmt: addBusinessDays() exceeded the ${MAX_BUSINESS_DAY_TRAVERSAL}-day limit.`
+    );
+  }
+  let candidate = value;
+  for (let i = 0; i < absDays; i++) {
+    candidate = sign > 0 ? nextBusinessDay(cal, candidate) : previousBusinessDay(cal, candidate);
+  }
+  return candidate;
+}
+function subtractBusinessDays(cal, value, days) {
+  assertBusinessDayCount(days);
+  return addBusinessDays(cal, value, -days);
+}
+function differenceInBusinessDays(cal, a, b) {
+  const rawDirection = compareDateFields(b, a);
+  if (rawDirection === 0) return 0;
+  const direction = rawDirection > 0 ? 1 : -1;
+  let candidate = a;
+  let count = 0;
+  let traversedDays = 0;
+  while (compareDateFields(candidate, b) !== 0) {
+    candidate = add(candidate, direction, "days");
+    traversedDays++;
+    if (traversedDays > MAX_BUSINESS_DAY_TRAVERSAL) {
+      throw new RangeError(
+        `temporal-fmt: differenceInBusinessDays() exceeded the ${MAX_BUSINESS_DAY_TRAVERSAL}-day traversal limit.`
+      );
+    }
+    if (isBusinessDay(cal, candidate)) count += direction;
+  }
+  return count;
+}
+
+// src/holidays.ts
+var MAX_HOLIDAY_YEAR_RANGE = 5e3;
+function createHolidayCalendar(specs) {
+  const cache = /* @__PURE__ */ new Map();
+  function forYear(year) {
+    let list = cache.get(year);
+    if (list) return list;
+    list = specs.map((s) => {
+      let md;
+      if (s.compute) {
+        md = s.compute(year);
+      } else {
+        md = { month: s.month, day: s.day };
+      }
+      return { ...md, name: s.name };
+    });
+    cache.set(year, list);
+    return list;
+  }
+  return {
+    isHoliday(value) {
+      const v = value;
+      if (typeof v.year !== "number" || typeof v.month !== "number" || typeof v.day !== "number") {
+        throw new Error("temporal-fmt: isHoliday() needs a value with year/month/day.");
+      }
+      const list = forYear(v.year);
+      return list.some((h) => h.month === v.month && h.day === v.day);
+    },
+    holidaysBetween(start, end) {
+      const sv = start;
+      const ev = end;
+      if (typeof sv?.year !== "number" || typeof ev?.year !== "number") {
+        throw new Error("temporal-fmt: holidaysBetween() needs start/end values with year/month/day.");
+      }
+      if (ev.year - sv.year > MAX_HOLIDAY_YEAR_RANGE) {
+        throw new RangeError(
+          `temporal-fmt: holidaysBetween() year range (${sv.year}\u2013${ev.year}) exceeds the ${MAX_HOLIDAY_YEAR_RANGE}-year limit. Split the query into smaller ranges.`
+        );
+      }
+      const result = [];
+      for (let y = sv.year; y <= ev.year; y++) {
+        const list = forYear(y);
+        for (const h of list) {
+          const date = { year: y, month: h.month, day: h.day };
+          if (compare(date, sv) >= 0 && compare(date, ev) <= 0) {
+            result.push({ year: y, month: h.month, day: h.day });
+          }
+        }
+      }
+      return result;
+    }
+  };
+}
+function nextHoliday(cal, value) {
+  let candidate = add(value, 1, "days");
+  for (let i = 0; i < 365 * 5; i++) {
+    if (cal.isHoliday(candidate)) return candidate;
+    candidate = add(candidate, 1, "days");
+  }
+  return void 0;
+}
+function previousHoliday(cal, value) {
+  let candidate = add(value, -1, "days");
+  for (let i = 0; i < 365 * 5; i++) {
+    if (cal.isHoliday(candidate)) return candidate;
+    candidate = add(candidate, -1, "days");
+  }
+  return void 0;
+}
+function holidaysBetween(cal, start, end) {
+  return cal.holidaysBetween(start, end);
+}
+
+// src/ideData.ts
+function tokenFamily(name) {
+  if (/^y+$/.test(name)) return "Year";
+  if (/^[ML]+$/.test(name)) return "Month";
+  if (/^[decD]+$/.test(name)) return "Day";
+  if (/^[Ec]+$/.test(name)) return "Weekday";
+  if (/^[Qq]+$/.test(name)) return "Quarter";
+  if (/^[Gg]+$/.test(name)) return "Era";
+  if (/^[Hh]+$/.test(name)) return "Hour";
+  if (/^m+$/.test(name)) return "Minute";
+  if (/^s+$/.test(name)) return "Second";
+  if (/^S+$/.test(name)) return "Fractional Second";
+  if (name === "a") return "Day Period";
+  if (name === "zzz") return "Time Zone";
+  if (/^[Xx]+$/.test(name)) return "UTC Offset";
+  if (name === "do") return "Ordinal Day";
+  if (name === "ww" || name === "RRRR") return "ISO Week";
+  return "Other";
+}
+function getAutocompleteData() {
+  return ALL_TOKEN_NAMES.map((name) => {
+    const meta = TOKEN_METADATA[name];
+    return {
+      label: name,
+      detail: meta.meaning,
+      documentation: [
+        meta.meaning,
+        ``,
+        `Format-capable: ${meta.formatCapable}`,
+        `Parse-capable: ${meta.parseCapable}`,
+        `Locale-sensitive: ${meta.localeSensitive}`,
+        `Calendar-sensitive: ${meta.calendarSensitive}`,
+        `Timezone-sensitive: ${meta.timezoneSensitive}`,
+        `Round-trip safe: ${meta.roundTripSafe}`,
+        `Supported types: ${meta.supportedTypes.join(", ")}`
+      ].join("\n"),
+      family: tokenFamily(name)
+    };
+  });
+}
+function getHoverDocs() {
+  const result = {};
+  for (const name of ALL_TOKEN_NAMES) {
+    const meta = TOKEN_METADATA[name];
+    result[name] = {
+      signature: name,
+      summary: meta.meaning,
+      details: [
+        // every entry in TOKEN_METADATA currently has formatCapable:
+        // true (verified: 51/51). The 'no' branch reflects real,
+        // intended behavior for a future format-incapable token —
+        // there's no such token today, so this isn't reachable data,
+        // not dead logic. Every other field on this line has real
+        // true/false variance across the token table and is exercised
+        // by this same loop running over ALL_TOKEN_NAMES.
+        /* c8 ignore next */
+        `Format-capable: ${meta.formatCapable ? "yes" : "no"}`,
+        `Parse-capable: ${meta.parseCapable ? "yes" : "no"}`,
+        `Locale-sensitive: ${meta.localeSensitive ? "yes" : "no"}`,
+        `Calendar-sensitive: ${meta.calendarSensitive ? "yes" : "no"}`,
+        `Timezone-sensitive: ${meta.timezoneSensitive ? "yes" : "no"}`,
+        `Round-trip safe: ${meta.roundTripSafe ? "yes" : "no"}`,
+        `Supported types: ${meta.supportedTypes.join(", ")}`
+      ].join("\n")
+    };
+  }
+  return result;
+}
+function getInlineDiagnostics(formatStr) {
+  const analysis = analyzeFormat(formatStr);
+  const diagnostics = [];
+  for (const warning of analysis.warnings) {
+    let message = warning.message;
+    let suggestion;
+    if (warning.code === "TWELVE_HOUR_WITHOUT_A") {
+      suggestion = 'Add an "a" token (e.g. "h:mm a") or use "H:mm" for 24-hour.';
+    } else if (warning.code === "MIXED_12_AND_24_HOUR") {
+      suggestion = 'Pick one form: "HH:mm" for 24-hour or "h:mm a" for 12-hour.';
+    } else if (warning.code === "AMBIGUOUS_NUMERIC_RUN") {
+      suggestion = 'Add a separator or use padded forms (e.g. "MM" instead of "M").';
+    } else if (warning.code === "FORMAT_ONLY_TOKEN") {
+      suggestion = 'Use a parse-capable variant (e.g. "d" instead of "do").';
+    }
+    diagnostics.push({
+      startColumn: 0,
+      endColumn: formatStr.length,
+      severity: "warning",
+      message,
+      code: warning.code,
+      suggestion
+    });
+  }
+  return diagnostics;
+}
+var DAYJS_TO_TEMPORAL_FMT = [
+  { from: "YYYY", to: "yyyy" },
+  { from: "YY", to: "yy" },
+  { from: "MMMM", to: "MMMM" },
+  { from: "MMM", to: "MMM" },
+  { from: "MM", to: "MM" },
+  { from: "M", to: "M" },
+  { from: "DD", to: "dd" },
+  { from: "D", to: "d" },
+  { from: "Do", to: null, notes: `Ordinal day (AdvancedFormat) \u2014 use temporal-fmt's own "do" token instead.` },
+  { from: "dddd", to: "EEEE" },
+  { from: "ddd", to: "EEE" },
+  { from: "dd", to: null, notes: 'Min-name weekday (e.g. "Tu") \u2014 temporal-fmt has no equivalent width.' },
+  { from: "d", to: null, notes: 'Numeric weekday (0-6) \u2014 no temporal-fmt equivalent; not the same as "d" here, which is day-of-month.' },
+  { from: "HH", to: "HH" },
+  { from: "H", to: "H" },
+  { from: "hh", to: "hh" },
+  { from: "h", to: "h" },
+  { from: "kk", to: null, notes: "Hour 1-24 (AdvancedFormat) \u2014 no temporal-fmt equivalent." },
+  { from: "k", to: null, notes: "Hour 1-24 (AdvancedFormat) \u2014 no temporal-fmt equivalent." },
+  { from: "mm", to: "mm" },
+  { from: "m", to: "m" },
+  { from: "ss", to: "ss" },
+  { from: "s", to: "s" },
+  { from: "SSS", to: "SSS" },
+  { from: "A", to: "a", notes: "Uppercase AM/PM in Day.js \u2014 temporal-fmt is always lowercase." },
+  { from: "a", to: "a" },
+  { from: "ZZ", to: "XX", notes: "Numeric UTC offset, no colon." },
+  { from: "Z", to: "XXX", notes: "Numeric UTC offset with colon." },
+  { from: "X", to: null, notes: "Unix timestamp (seconds) \u2014 use fromUnixSeconds() instead." },
+  { from: "x", to: null, notes: "Unix timestamp (ms) \u2014 use fromUnixMilliseconds() instead." },
+  { from: "Qo", to: null, notes: "Ordinal quarter (AdvancedFormat) \u2014 no temporal-fmt equivalent." },
+  { from: "Q", to: "Q" },
+  { from: "Mo", to: null, notes: "Ordinal month (AdvancedFormat) \u2014 no temporal-fmt equivalent." },
+  { from: "ww", to: "ww" },
+  { from: "wo", to: null, notes: "Ordinal ISO week (AdvancedFormat) \u2014 no temporal-fmt equivalent." },
+  { from: "w", to: null, notes: `Unpadded ISO week \u2014 temporal-fmt's "ww" is always 2-digit.` },
+  { from: "gggg", to: "RRRR", notes: "Week-numbering year, not the calendar year \u2014 same caveat as temporal-fmt's RRRR." },
+  { from: "L", to: null, notes: "Localized date format (AdvancedFormat) \u2014 write the format string out explicitly." },
+  { from: "LL", to: null, notes: "Localized date format (AdvancedFormat) \u2014 write the format string out explicitly." },
+  { from: "LLL", to: null, notes: "Localized date format (AdvancedFormat) \u2014 write the format string out explicitly." },
+  { from: "LLLL", to: null, notes: "Localized date format (AdvancedFormat) \u2014 write the format string out explicitly." },
+  { from: "LT", to: null, notes: "Localized time format (AdvancedFormat) \u2014 write the format string out explicitly." },
+  { from: "LTS", to: null, notes: "Localized time format (AdvancedFormat) \u2014 write the format string out explicitly." }
+];
+var DATE_FNS_TO_TEMPORAL_FMT = [
+  { from: "yyyy", to: "yyyy" },
+  { from: "yy", to: "yy" },
+  { from: "y", to: null, notes: 'Unpadded calendar year, opt-in via useAdditionalWeekYearTokens \u2014 temporal-fmt has no unpadded-year token; use "yyyy".' },
+  { from: "MMMM", to: "MMMM" },
+  { from: "MMM", to: "MMM" },
+  { from: "MM", to: "MM" },
+  { from: "M", to: "M" },
+  { from: "LLLL", to: "LLLL" },
+  { from: "LLL", to: "LLL" },
+  { from: "dd", to: "dd" },
+  { from: "d", to: "d" },
+  { from: "do", to: "do" },
+  { from: "DDD", to: "DDD" },
+  { from: "DD", to: "DD" },
+  { from: "D", to: "D", notes: `Day-of-year, opt-in via useAdditionalDayOfYearTokens \u2014 matches temporal-fmt's own "D" already.` },
+  { from: "EEEE", to: "EEEE" },
+  { from: "EEE", to: "EEE" },
+  { from: "eeee", to: null, notes: "Locale-aware numeric weekday \u2014 no temporal-fmt equivalent." },
+  { from: "cccc", to: "cccc" },
+  { from: "ccc", to: "ccc" },
+  { from: "HH", to: "HH" },
+  { from: "H", to: "H" },
+  { from: "hh", to: "hh" },
+  { from: "h", to: "h" },
+  { from: "mm", to: "mm" },
+  { from: "m", to: "m" },
+  { from: "ss", to: "ss" },
+  { from: "s", to: "s" },
+  { from: "SSS", to: "SSS" },
+  { from: "a", to: "a" },
+  { from: "aaa", to: "a" },
+  { from: "XXX", to: "XXX" },
+  { from: "XX", to: "XX" },
+  { from: "X", to: "X", notes: `Opt-in via useAdditionalDayOfYearTokens-adjacent rules in date-fns v3+; matches temporal-fmt's own "X" already.` },
+  { from: "xxx", to: "xxx" },
+  { from: "xx", to: "xx" },
+  { from: "x", to: "x" },
+  { from: "zzzz", to: "zzzz" },
+  { from: "zzz", to: "zzz" },
+  { from: "z", to: "z" },
+  { from: "QQQ", to: "QQQ" },
+  { from: "Q", to: "Q" },
+  { from: "GGGG", to: "GGGG" },
+  { from: "GGG", to: null, notes: 'Abbreviated era \u2014 temporal-fmt only has "G" (short) and "GGGG" (long).' },
+  { from: "GG", to: null, notes: 'Abbreviated era \u2014 temporal-fmt only has "G" (short) and "GGGG" (long).' },
+  { from: "G", to: "G" },
+  { from: "ww", to: "ww" },
+  { from: "w", to: null, notes: `Unpadded local week number \u2014 temporal-fmt's "ww" is ISO-week and always 2-digit.` },
+  { from: "RRRR", to: "RRRR" },
+  { from: "R", to: null, notes: `Unpadded ISO week-numbering year \u2014 temporal-fmt's "RRRR" is always 4-digit.` },
+  { from: "Y", to: null, notes: 'Week-numbering year (locale week rules), opt-in \u2014 no temporal-fmt equivalent; "RRRR" is ISO week-numbering, a different rule set.' },
+  { from: "PPPP", to: null, notes: "Localized composite format \u2014 write the format string out explicitly." },
+  { from: "PPP", to: null, notes: "Localized composite format \u2014 write the format string out explicitly." },
+  { from: "PP", to: null, notes: "Localized composite format \u2014 write the format string out explicitly." },
+  { from: "P", to: null, notes: "Localized composite format \u2014 write the format string out explicitly." },
+  { from: "pppp", to: null, notes: "Localized composite format \u2014 write the format string out explicitly." },
+  { from: "ppp", to: null, notes: "Localized composite format \u2014 write the format string out explicitly." },
+  { from: "pp", to: null, notes: "Localized composite format \u2014 write the format string out explicitly." },
+  { from: "p", to: null, notes: "Localized composite format \u2014 write the format string out explicitly." }
+];
+function previewFormat(formatStr, sample) {
+  const value = sample ?? {
+    year: 2026,
+    month: 8,
+    day: 4,
+    hour: 15,
+    minute: 45,
+    second: 30,
+    millisecond: 123,
+    dayOfWeek: 2,
+    timeZoneId: "UTC",
+    offset: "+00:00",
+    calendarId: "iso8601"
+  };
+  return format(value, formatStr, { locale: "en-US" });
+}
+function getDocUrl(tokenName) {
+  void tokenName;
+  return "README.md#token-reference";
+}
+
+// src/codemod.ts
+function splitOnBrackets(source) {
+  const pieces = [];
+  let i = 0;
+  while (i < source.length) {
+    if (source[i] === "[") {
+      const end = source.indexOf("]", i + 1);
+      if (end === -1) {
+        pieces.push({ kind: "token", value: source.slice(i) });
+        break;
+      }
+      pieces.push({ kind: "literal", value: source.slice(i + 1, end) });
+      i = end + 1;
+    } else {
+      let j = i;
+      while (j < source.length && source[j] !== "[") j += 1;
+      pieces.push({ kind: "token", value: source.slice(i, j) });
+      i = j;
+    }
+  }
+  return pieces;
+}
+function splitIntoRuns(span, sortedFrom) {
+  const pieces = [];
+  let i = 0;
+  while (i < span.length) {
+    const match = sortedFrom.find((tok) => span.startsWith(tok, i));
+    if (match) {
+      pieces.push({ kind: "token", value: match });
+      i += match.length;
+      continue;
+    }
+    const last = pieces[pieces.length - 1];
+    if (last && last.kind === "literal") {
+      last.value += span[i];
+    } else {
+      pieces.push({ kind: "literal", value: span[i] });
+    }
+    i += 1;
+  }
+  return pieces;
+}
+function translate(source, table, sourceLibLabel) {
+  const byFrom = new Map(table.map((hint) => [hint.from, hint.to]));
+  const sortedFrom = [...byFrom.keys()].sort((a, b) => b.length - a.length);
+  const bracketPieces = splitOnBrackets(source);
+  let out = "";
+  for (const piece of bracketPieces) {
+    if (piece.kind === "literal") {
+      out += `'${piece.value.replace(/'/g, "''")}'`;
+      continue;
+    }
+    for (const run of splitIntoRuns(piece.value, sortedFrom)) {
+      if (run.kind === "token") {
+        const mapped = byFrom.get(run.value);
+        if (mapped === void 0 || mapped === null) {
+          throw new Error(
+            `temporal-fmt: "${run.value}" has no ${sourceLibLabel} -> temporal-fmt mapping (in format string "${source}"). Write the equivalent temporal-fmt token in by hand, or wrap it in brackets if it was meant as literal text.`
+          );
+        }
+        out += mapped;
+      } else if (/[a-zA-Z]/.test(run.value)) {
+        out += `'${run.value.replace(/'/g, "''")}'`;
+      } else {
+        out += run.value;
+      }
+    }
+  }
+  return out;
+}
+function translateDayjsFormatString(formatStr) {
+  return translate(formatStr, DAYJS_TO_TEMPORAL_FMT, "Day.js");
+}
+function translateDateFnsFormatString(formatStr) {
+  return translate(formatStr, DATE_FNS_TO_TEMPORAL_FMT, "date-fns");
+}
+
+// src/runtime.ts
+var formatOverride;
+var parseOverride;
+function getFormatImpl() {
+  return formatOverride ? formatOverride.impl : format;
+}
+function getParseImpl() {
+  return parseOverride ? parseOverride.impl : parse;
+}
+var OverrideConflictError = class extends Error {
+  constructor(point, existingOwner, attemptedBy) {
+    super(
+      `temporal-fmt: "${point}" is already overridden by mod "${existingOwner}" \u2014 mod "${attemptedBy}" can't also override it. Only one mod may hold each override point; if "${attemptedBy}" needs "${existingOwner}"'s behavior included, that logic needs to move into whichever mod ends up owning the override, not be layered through a second overrideFormat()/overrideParse() call.`
+    );
+    this.point = point;
+    this.existingOwner = existingOwner;
+    this.attemptedBy = attemptedBy;
+    this.name = "OverrideConflictError";
+  }
+  point;
+  existingOwner;
+  attemptedBy;
+};
+function setFormatOverride(impl, installedBy) {
+  if (formatOverride) throw new OverrideConflictError("format", formatOverride.installedBy, installedBy);
+  formatOverride = { impl, installedBy };
+}
+function setParseOverride(impl, installedBy) {
+  if (parseOverride) throw new OverrideConflictError("parse", parseOverride.installedBy, installedBy);
+  parseOverride = { impl, installedBy };
+}
+function createOverridable(base, pointName) {
+  let current;
+  return {
+    get: () => current ? current.impl : base,
+    set: (impl, installedBy) => {
+      if (current) throw new OverrideConflictError(pointName, current.installedBy, installedBy);
+      current = { impl, installedBy };
+    },
+    /* c8 ignore start @preserve -- reset() is only ever called from
+     * _resetGeneratedOverridesForTesting(), which itself is a
+     * vitest-only escape hatch not exported from dist/index.js (see its
+     * own doc comment below) — so this function has no path reachable
+     * from test/*.test.js, which imports only the public dist/index.js
+     * surface. Covered instead by vitest/modApi.unit.test.ts's afterEach
+     * hook, which calls _resetGeneratedOverridesForTesting() directly
+     * against src/runtime.js on every run. */
+    reset: () => {
+      current = void 0;
+    }
+    /* c8 ignore stop @preserve */
+  };
+}
+var compileFormatRegistry = createOverridable(compileFormat, "compileFormat");
+var compileParserRegistry = createOverridable(compileParser, "compileParser");
+var parseRelativeRegistry = createOverridable(parseRelative, "parseRelative");
+var explainFormatRegistry = createOverridable(explainFormat, "explainFormat");
+var tokenizeFormatRegistry = createOverridable(tokenizeFormat, "tokenizeFormat");
+var listTokensRegistry = createOverridable(listTokens, "listTokens");
+var tokenInfoRegistry = createOverridable(tokenInfo, "tokenInfo");
+var isValidFormatRegistry = createOverridable(isValidFormat, "isValidFormat");
+var validateFormatRegistry = createOverridable(validateFormat, "validateFormat");
+var fieldForTokenRegistry = createOverridable(fieldForToken, "fieldForToken");
+var monthsInYearRegistry = createOverridable(monthsInYear, "monthsInYear");
+var isLeapYearRegistry = createOverridable(isLeapYear, "isLeapYear");
+var isLeapMonthRegistry = createOverridable(isLeapMonth, "isLeapMonth");
+var weekOfYearRegistry = createOverridable(weekOfYear, "weekOfYear");
+var weekYearRegistry = createOverridable(weekYear, "weekYear");
+var getMonthRegistry = createOverridable(getMonth, "getMonth");
+var getWeekdayRegistry = createOverridable(getWeekday, "getWeekday");
+var isEqualRegistry = createOverridable(isEqual, "isEqual");
+var isBeforeRegistry = createOverridable(isBefore, "isBefore");
+var isAfterRegistry = createOverridable(isAfter, "isAfter");
+var clampRegistry = createOverridable(clamp, "clamp");
+var isBetweenRegistry = createOverridable(isBetween, "isBetween");
+var isTodayRegistry = createOverridable(isToday, "isToday");
+var isTomorrowRegistry = createOverridable(isTomorrow, "isTomorrow");
+var isYesterdayRegistry = createOverridable(isYesterday, "isYesterday");
+var isSameDayRegistry = createOverridable(isSameDay, "isSameDay");
+var isSameWeekRegistry = createOverridable(isSameWeek, "isSameWeek");
+var isSameMonthRegistry = createOverridable(isSameMonth, "isSameMonth");
+var isSameQuarterRegistry = createOverridable(isSameQuarter, "isSameQuarter");
+var isSameYearRegistry = createOverridable(isSameYear, "isSameYear");
+var isWeekdayRegistry = createOverridable(isWeekday, "isWeekday");
+var floorRegistry = createOverridable(floor, "floor");
+var ceilRegistry = createOverridable(ceil, "ceil");
+var truncateRegistry = createOverridable(truncate, "truncate");
+var parseRFC3339Registry = createOverridable(parseRFC3339, "parseRFC3339");
+var formatRFC3339Registry = createOverridable(formatRFC3339, "formatRFC3339");
+var parseRFC2822Registry = createOverridable(parseRFC2822, "parseRFC2822");
+var parseHTTPDateRegistry = createOverridable(parseHTTPDate, "parseHTTPDate");
+var fromUnixMicrosecondsRegistry = createOverridable(fromUnixMicroseconds, "fromUnixMicroseconds");
+var fromUnixNanosecondsRegistry = createOverridable(fromUnixNanoseconds, "fromUnixNanoseconds");
+var toUnixSecondsRegistry = createOverridable(toUnixSeconds, "toUnixSeconds");
+var toUnixMillisecondsRegistry = createOverridable(toUnixMilliseconds, "toUnixMilliseconds");
+var toUnixMicrosecondsRegistry = createOverridable(toUnixMicroseconds, "toUnixMicroseconds");
+var toUnixNanosecondsRegistry = createOverridable(toUnixNanoseconds, "toUnixNanoseconds");
+var parseSQLRegistry = createOverridable(parseSQL, "parseSQL");
+var formatSQLRegistry = createOverridable(formatSQL, "formatSQL");
+var formatDurationToPartsRegistry = createOverridable(formatDurationToParts, "formatDurationToParts");
+var parseDurationRegistry = createOverridable(parseDuration, "parseDuration");
+var parseISODurationRegistry = createOverridable(parseISODuration, "parseISODuration");
+var formatISODurationRegistry = createOverridable(formatISODuration, "formatISODuration");
+var balanceDurationRegistry = createOverridable(balanceDuration, "balanceDuration");
+var compareDurationRegistry = createOverridable(compareDuration, "compareDuration");
+var subtractDurationRegistry = createOverridable(subtractDuration, "subtractDuration");
+var getLocaleRegistry = createOverridable(getLocale, "getLocale");
+var hasLocaleRegistry = createOverridable(hasLocale, "hasLocale");
+var createConfigRegistry = createOverridable(createConfig, "createConfig");
+var mergeWithConfigRegistry = createOverridable(mergeWithConfig, "mergeWithConfig");
+var listRegisteredGrammarsRegistry = createOverridable(listRegisteredGrammars, "listRegisteredGrammars");
+var intervalRegistry = createOverridable(interval, "interval");
+var overlapsRegistry = createOverridable(overlaps, "overlaps");
+var intersectionRegistry = createOverridable(intersection, "intersection");
+var unionRegistry = createOverridable(union, "union");
+var mergeIntervalsRegistry = createOverridable(mergeIntervals, "mergeIntervals");
+var formatRangeToPartsRegistry = createOverridable(formatRangeToParts, "formatRangeToParts");
+var betweenRegistry = createOverridable(between, "between");
+var parseRRuleRegistry = createOverridable(parseRRule, "parseRRule");
+var formatRRuleRegistry = createOverridable(formatRRule, "formatRRule");
+var createBusinessCalendarRegistry = createOverridable(createBusinessCalendar, "createBusinessCalendar");
+var subtractBusinessDaysRegistry = createOverridable(subtractBusinessDays, "subtractBusinessDays");
+var nextHolidayRegistry = createOverridable(nextHoliday, "nextHoliday");
+var previousHolidayRegistry = createOverridable(previousHoliday, "previousHoliday");
+var resolveZonedRegistry = createOverridable(resolveZoned, "resolveZoned");
+var getNextTransitionRegistry = createOverridable(getNextTransition, "getNextTransition");
+var getPreviousTransitionRegistry = createOverridable(getPreviousTransition, "getPreviousTransition");
+var possibleInstantsForRegistry = createOverridable(possibleInstantsFor, "possibleInstantsFor");
+var getAutocompleteDataRegistry = createOverridable(getAutocompleteData, "getAutocompleteData");
+var getHoverDocsRegistry = createOverridable(getHoverDocs, "getHoverDocs");
+var getInlineDiagnosticsRegistry = createOverridable(getInlineDiagnostics, "getInlineDiagnostics");
+var previewFormatRegistry = createOverridable(previewFormat, "previewFormat");
+var getDocUrlRegistry = createOverridable(getDocUrl, "getDocUrl");
+var translateDateFnsFormatStringRegistry = createOverridable(translateDateFnsFormatString, "translateDateFnsFormatString");
+var getCompileFormatImpl = compileFormatRegistry.get;
+var setCompileFormatOverride = compileFormatRegistry.set;
+var getCompileParserImpl = compileParserRegistry.get;
+var setCompileParserOverride = compileParserRegistry.set;
+var getParseRelativeImpl = parseRelativeRegistry.get;
+var setParseRelativeOverride = parseRelativeRegistry.set;
+var getExplainFormatImpl = explainFormatRegistry.get;
+var setExplainFormatOverride = explainFormatRegistry.set;
+var getTokenizeFormatImpl = tokenizeFormatRegistry.get;
+var setTokenizeFormatOverride = tokenizeFormatRegistry.set;
+var getListTokensImpl = listTokensRegistry.get;
+var setListTokensOverride = listTokensRegistry.set;
+var getTokenInfoImpl = tokenInfoRegistry.get;
+var setTokenInfoOverride = tokenInfoRegistry.set;
+var getIsValidFormatImpl = isValidFormatRegistry.get;
+var setIsValidFormatOverride = isValidFormatRegistry.set;
+var getValidateFormatImpl = validateFormatRegistry.get;
+var setValidateFormatOverride = validateFormatRegistry.set;
+var getFieldForTokenImpl = fieldForTokenRegistry.get;
+var setFieldForTokenOverride = fieldForTokenRegistry.set;
+var getMonthsInYearImpl = monthsInYearRegistry.get;
+var setMonthsInYearOverride = monthsInYearRegistry.set;
+var getIsLeapYearImpl = isLeapYearRegistry.get;
+var setIsLeapYearOverride = isLeapYearRegistry.set;
+var getIsLeapMonthImpl = isLeapMonthRegistry.get;
+var setIsLeapMonthOverride = isLeapMonthRegistry.set;
+var getWeekOfYearImpl = weekOfYearRegistry.get;
+var setWeekOfYearOverride = weekOfYearRegistry.set;
+var getWeekYearImpl = weekYearRegistry.get;
+var setWeekYearOverride = weekYearRegistry.set;
+var getGetMonthImpl = getMonthRegistry.get;
+var setGetMonthOverride = getMonthRegistry.set;
+var getGetWeekdayImpl = getWeekdayRegistry.get;
+var setGetWeekdayOverride = getWeekdayRegistry.set;
+var getIsEqualImpl = isEqualRegistry.get;
+var setIsEqualOverride = isEqualRegistry.set;
+var getIsBeforeImpl = isBeforeRegistry.get;
+var setIsBeforeOverride = isBeforeRegistry.set;
+var getIsAfterImpl = isAfterRegistry.get;
+var setIsAfterOverride = isAfterRegistry.set;
+var getClampImpl = clampRegistry.get;
+var setClampOverride = clampRegistry.set;
+var getIsBetweenImpl = isBetweenRegistry.get;
+var setIsBetweenOverride = isBetweenRegistry.set;
+var getIsTodayImpl = isTodayRegistry.get;
+var setIsTodayOverride = isTodayRegistry.set;
+var getIsTomorrowImpl = isTomorrowRegistry.get;
+var setIsTomorrowOverride = isTomorrowRegistry.set;
+var getIsYesterdayImpl = isYesterdayRegistry.get;
+var setIsYesterdayOverride = isYesterdayRegistry.set;
+var getIsSameDayImpl = isSameDayRegistry.get;
+var setIsSameDayOverride = isSameDayRegistry.set;
+var getIsSameWeekImpl = isSameWeekRegistry.get;
+var setIsSameWeekOverride = isSameWeekRegistry.set;
+var getIsSameMonthImpl = isSameMonthRegistry.get;
+var setIsSameMonthOverride = isSameMonthRegistry.set;
+var getIsSameQuarterImpl = isSameQuarterRegistry.get;
+var setIsSameQuarterOverride = isSameQuarterRegistry.set;
+var getIsSameYearImpl = isSameYearRegistry.get;
+var setIsSameYearOverride = isSameYearRegistry.set;
+var getIsWeekdayImpl = isWeekdayRegistry.get;
+var setIsWeekdayOverride = isWeekdayRegistry.set;
+var getFloorImpl = floorRegistry.get;
+var setFloorOverride = floorRegistry.set;
+var getCeilImpl = ceilRegistry.get;
+var setCeilOverride = ceilRegistry.set;
+var getTruncateImpl = truncateRegistry.get;
+var setTruncateOverride = truncateRegistry.set;
+var getParseRFC3339Impl = parseRFC3339Registry.get;
+var setParseRFC3339Override = parseRFC3339Registry.set;
+var getFormatRFC3339Impl = formatRFC3339Registry.get;
+var setFormatRFC3339Override = formatRFC3339Registry.set;
+var getParseRFC2822Impl = parseRFC2822Registry.get;
+var setParseRFC2822Override = parseRFC2822Registry.set;
+var getParseHTTPDateImpl = parseHTTPDateRegistry.get;
+var setParseHTTPDateOverride = parseHTTPDateRegistry.set;
+var getFromUnixMicrosecondsImpl = fromUnixMicrosecondsRegistry.get;
+var setFromUnixMicrosecondsOverride = fromUnixMicrosecondsRegistry.set;
+var getFromUnixNanosecondsImpl = fromUnixNanosecondsRegistry.get;
+var setFromUnixNanosecondsOverride = fromUnixNanosecondsRegistry.set;
+var getToUnixSecondsImpl = toUnixSecondsRegistry.get;
+var setToUnixSecondsOverride = toUnixSecondsRegistry.set;
+var getToUnixMillisecondsImpl = toUnixMillisecondsRegistry.get;
+var setToUnixMillisecondsOverride = toUnixMillisecondsRegistry.set;
+var getToUnixMicrosecondsImpl = toUnixMicrosecondsRegistry.get;
+var setToUnixMicrosecondsOverride = toUnixMicrosecondsRegistry.set;
+var getToUnixNanosecondsImpl = toUnixNanosecondsRegistry.get;
+var setToUnixNanosecondsOverride = toUnixNanosecondsRegistry.set;
+var getParseSQLImpl = parseSQLRegistry.get;
+var setParseSQLOverride = parseSQLRegistry.set;
+var getFormatSQLImpl = formatSQLRegistry.get;
+var setFormatSQLOverride = formatSQLRegistry.set;
+var getFormatDurationToPartsImpl = formatDurationToPartsRegistry.get;
+var setFormatDurationToPartsOverride = formatDurationToPartsRegistry.set;
+var getParseDurationImpl = parseDurationRegistry.get;
+var setParseDurationOverride = parseDurationRegistry.set;
+var getParseISODurationImpl = parseISODurationRegistry.get;
+var setParseISODurationOverride = parseISODurationRegistry.set;
+var getFormatISODurationImpl = formatISODurationRegistry.get;
+var setFormatISODurationOverride = formatISODurationRegistry.set;
+var getBalanceDurationImpl = balanceDurationRegistry.get;
+var setBalanceDurationOverride = balanceDurationRegistry.set;
+var getCompareDurationImpl = compareDurationRegistry.get;
+var setCompareDurationOverride = compareDurationRegistry.set;
+var getSubtractDurationImpl = subtractDurationRegistry.get;
+var setSubtractDurationOverride = subtractDurationRegistry.set;
+var getGetLocaleImpl = getLocaleRegistry.get;
+var setGetLocaleOverride = getLocaleRegistry.set;
+var getHasLocaleImpl = hasLocaleRegistry.get;
+var setHasLocaleOverride = hasLocaleRegistry.set;
+var getCreateConfigImpl = createConfigRegistry.get;
+var setCreateConfigOverride = createConfigRegistry.set;
+var getMergeWithConfigImpl = mergeWithConfigRegistry.get;
+var setMergeWithConfigOverride = mergeWithConfigRegistry.set;
+var getListRegisteredGrammarsImpl = listRegisteredGrammarsRegistry.get;
+var setListRegisteredGrammarsOverride = listRegisteredGrammarsRegistry.set;
+var getIntervalImpl = intervalRegistry.get;
+var setIntervalOverride = intervalRegistry.set;
+var getOverlapsImpl = overlapsRegistry.get;
+var setOverlapsOverride = overlapsRegistry.set;
+var getIntersectionImpl = intersectionRegistry.get;
+var setIntersectionOverride = intersectionRegistry.set;
+var getUnionImpl = unionRegistry.get;
+var setUnionOverride = unionRegistry.set;
+var getMergeIntervalsImpl = mergeIntervalsRegistry.get;
+var setMergeIntervalsOverride = mergeIntervalsRegistry.set;
+var getFormatRangeToPartsImpl = formatRangeToPartsRegistry.get;
+var setFormatRangeToPartsOverride = formatRangeToPartsRegistry.set;
+var getBetweenImpl = betweenRegistry.get;
+var setBetweenOverride = betweenRegistry.set;
+var getParseRRuleImpl = parseRRuleRegistry.get;
+var setParseRRuleOverride = parseRRuleRegistry.set;
+var getFormatRRuleImpl = formatRRuleRegistry.get;
+var setFormatRRuleOverride = formatRRuleRegistry.set;
+var getCreateBusinessCalendarImpl = createBusinessCalendarRegistry.get;
+var setCreateBusinessCalendarOverride = createBusinessCalendarRegistry.set;
+var getSubtractBusinessDaysImpl = subtractBusinessDaysRegistry.get;
+var setSubtractBusinessDaysOverride = subtractBusinessDaysRegistry.set;
+var getNextHolidayImpl = nextHolidayRegistry.get;
+var setNextHolidayOverride = nextHolidayRegistry.set;
+var getPreviousHolidayImpl = previousHolidayRegistry.get;
+var setPreviousHolidayOverride = previousHolidayRegistry.set;
+var getResolveZonedImpl = resolveZonedRegistry.get;
+var setResolveZonedOverride = resolveZonedRegistry.set;
+var getGetNextTransitionImpl = getNextTransitionRegistry.get;
+var setGetNextTransitionOverride = getNextTransitionRegistry.set;
+var getGetPreviousTransitionImpl = getPreviousTransitionRegistry.get;
+var setGetPreviousTransitionOverride = getPreviousTransitionRegistry.set;
+var getPossibleInstantsForImpl = possibleInstantsForRegistry.get;
+var setPossibleInstantsForOverride = possibleInstantsForRegistry.set;
+var getGetAutocompleteDataImpl = getAutocompleteDataRegistry.get;
+var setGetAutocompleteDataOverride = getAutocompleteDataRegistry.set;
+var getGetHoverDocsImpl = getHoverDocsRegistry.get;
+var setGetHoverDocsOverride = getHoverDocsRegistry.set;
+var getGetInlineDiagnosticsImpl = getInlineDiagnosticsRegistry.get;
+var setGetInlineDiagnosticsOverride = getInlineDiagnosticsRegistry.set;
+var getPreviewFormatImpl = previewFormatRegistry.get;
+var setPreviewFormatOverride = previewFormatRegistry.set;
+var getGetDocUrlImpl = getDocUrlRegistry.get;
+var setGetDocUrlOverride = getDocUrlRegistry.set;
+var getTranslateDateFnsFormatStringImpl = translateDateFnsFormatStringRegistry.get;
+var setTranslateDateFnsFormatStringOverride = translateDateFnsFormatStringRegistry.set;
+
+// 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 contains(iv, value) {
+  const startCmp = compare(value, iv.start);
+  const endCmp = compare(value, iv.end);
+  const afterStart = iv.bounds === "open" || iv.bounds === "half-open-end" ? startCmp > 0 : startCmp >= 0;
+  const beforeEnd = iv.bounds === "open" || iv.bounds === "half-open-start" ? endCmp < 0 : endCmp <= 0;
+  return afterStart && beforeEnd;
+}
+function overlaps(a, b) {
+  return intersects(a, b);
+}
+function intersects(a, b) {
+  if (compare(a.end, b.start) < 0) return false;
+  if (compare(a.start, b.end) > 0) return false;
+  return true;
+}
+function isBefore2(a, b) {
+  return compare(a.end, b.start) < 0;
+}
+function isAfter2(a, b) {
+  return compare(a.start, b.end) > 0;
+}
+function intersection(a, b) {
+  if (!intersects(a, b)) return null;
+  const start = compare(a.start, b.start) >= 0 ? a.start : b.start;
+  const end = compare(a.end, b.end) <= 0 ? a.end : b.end;
+  const startBoundsOpen = a.bounds === "open" || a.bounds === "half-open-end" || (b.bounds === "open" || b.bounds === "half-open-end");
+  const endBoundsOpen = a.bounds === "open" || a.bounds === "half-open-start" || (b.bounds === "open" || b.bounds === "half-open-start");
+  const bounds = startBoundsOpen && endBoundsOpen ? "open" : startBoundsOpen ? "half-open-end" : endBoundsOpen ? "half-open-start" : "closed";
+  return { start, end, bounds };
+}
+function union(a, b) {
+  if (!intersects(a, b)) return null;
+  const start = compare(a.start, b.start) <= 0 ? a.start : b.start;
+  const end = compare(a.end, b.end) >= 0 ? a.end : b.end;
+  const startBoundsOpen = (a.bounds === "open" || a.bounds === "half-open-end") && (b.bounds === "open" || b.bounds === "half-open-end");
+  const endBoundsOpen = (a.bounds === "open" || a.bounds === "half-open-start") && (b.bounds === "open" || b.bounds === "half-open-start");
+  const bounds = startBoundsOpen && endBoundsOpen ? "open" : startBoundsOpen ? "half-open-end" : endBoundsOpen ? "half-open-start" : "closed";
+  return { start, end, bounds };
+}
+function difference(a, b) {
+  if (!intersects(a, b)) return [a];
+  const result = [];
+  const aStartIncluded = a.bounds === "closed" || a.bounds === "half-open-end";
+  const aEndIncluded = a.bounds === "closed" || a.bounds === "half-open-start";
+  if (compare(a.start, b.start) < 0) {
+    result.push({ start: a.start, end: b.start, bounds: aStartIncluded ? "half-open-end" : "open" });
+  }
+  if (compare(a.end, b.end) > 0) {
+    result.push({ start: b.end, end: a.end, bounds: aEndIncluded ? "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];
+    if (intersects(last, current) || compare(last.end, current.start) === 0) {
+      if (compare(current.end, last.end) > 0) {
+        last.end = current.end;
+      }
+    } 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 = [];
+  for (let i = 0; i < n; i++) {
+    const sliceStart = startMs + i * step;
+    const sliceEnd = i === n - 1 ? endMs : sliceStart + step;
+    result.push({
+      start: fromMs(sliceStart, startFields),
+      end: fromMs(sliceEnd, endFields),
+      bounds: i === 0 ? iv.bounds : "half-open-start"
+    });
+  }
+  return result;
+}
+function toMs(v) {
+  const y = v.year, m = v.month, d = v.day;
+  const y2 = m <= 2 ? y - 1 : y;
+  const era = Math.floor((y2 >= 0 ? y2 : y2 - 399) / 400);
+  const yoe = y2 - era * 400;
+  const m2 = m > 2 ? m - 3 : m + 9;
+  const doy = Math.floor((153 * m2 + 2) / 5) + d - 1;
+  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+  const days = era * 146097 + doe - 719468;
+  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 format2 = getFormatImpl();
+    const startStr = format2(iv.start, formatStr, options);
+    const endStr = format2(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 {
+  registerRelativeGrammar,
+  TOKEN_METADATA,
+  ALL_TOKEN_NAMES,
+  analyzeFormat,
+  parseISO,
+  formatISO,
+  formatRFC2822,
+  formatHTTPDate,
+  fromUnixSeconds,
+  fromUnixMilliseconds,
+  DEFAULT_CONFIG,
+  interval,
+  contains,
+  overlaps,
+  intersects,
+  isBefore2 as isBefore,
+  isAfter2 as isAfter,
+  intersection,
+  union,
+  difference,
+  subtract,
+  mergeIntervals,
+  splitInterval,
+  formatRange,
+  formatRangeToParts,
+  isBusinessDay,
+  nextBusinessDay,
+  previousBusinessDay,
+  addBusinessDays,
+  differenceInBusinessDays,
+  createHolidayCalendar,
+  holidaysBetween,
+  DAYJS_TO_TEMPORAL_FMT,
+  DATE_FNS_TO_TEMPORAL_FMT,
+  translateDayjsFormatString,
+  getFormatImpl,
+  getParseImpl,
+  OverrideConflictError,
+  setFormatOverride,
+  setParseOverride,
+  getCompileFormatImpl,
+  setCompileFormatOverride,
+  getCompileParserImpl,
+  setCompileParserOverride,
+  getParseRelativeImpl,
+  setParseRelativeOverride,
+  getExplainFormatImpl,
+  setExplainFormatOverride,
+  getTokenizeFormatImpl,
+  setTokenizeFormatOverride,
+  getListTokensImpl,
+  setListTokensOverride,
+  getTokenInfoImpl,
+  setTokenInfoOverride,
+  getIsValidFormatImpl,
+  setIsValidFormatOverride,
+  getValidateFormatImpl,
+  setValidateFormatOverride,
+  getFieldForTokenImpl,
+  setFieldForTokenOverride,
+  getMonthsInYearImpl,
+  setMonthsInYearOverride,
+  getIsLeapYearImpl,
+  setIsLeapYearOverride,
+  getIsLeapMonthImpl,
+  setIsLeapMonthOverride,
+  getWeekOfYearImpl,
+  setWeekOfYearOverride,
+  getWeekYearImpl,
+  setWeekYearOverride,
+  getGetMonthImpl,
+  setGetMonthOverride,
+  getGetWeekdayImpl,
+  setGetWeekdayOverride,
+  getIsEqualImpl,
+  setIsEqualOverride,
+  getIsBeforeImpl,
+  setIsBeforeOverride,
+  getIsAfterImpl,
+  setIsAfterOverride,
+  getClampImpl,
+  setClampOverride,
+  getIsBetweenImpl,
+  setIsBetweenOverride,
+  getIsTodayImpl,
+  setIsTodayOverride,
+  getIsTomorrowImpl,
+  setIsTomorrowOverride,
+  getIsYesterdayImpl,
+  setIsYesterdayOverride,
+  getIsSameDayImpl,
+  setIsSameDayOverride,
+  getIsSameWeekImpl,
+  setIsSameWeekOverride,
+  getIsSameMonthImpl,
+  setIsSameMonthOverride,
+  getIsSameQuarterImpl,
+  setIsSameQuarterOverride,
+  getIsSameYearImpl,
+  setIsSameYearOverride,
+  getIsWeekdayImpl,
+  setIsWeekdayOverride,
+  getFloorImpl,
+  setFloorOverride,
+  getCeilImpl,
+  setCeilOverride,
+  getTruncateImpl,
+  setTruncateOverride,
+  getParseRFC3339Impl,
+  setParseRFC3339Override,
+  getFormatRFC3339Impl,
+  setFormatRFC3339Override,
+  getParseRFC2822Impl,
+  setParseRFC2822Override,
+  getParseHTTPDateImpl,
+  setParseHTTPDateOverride,
+  getFromUnixMicrosecondsImpl,
+  setFromUnixMicrosecondsOverride,
+  getFromUnixNanosecondsImpl,
+  setFromUnixNanosecondsOverride,
+  getToUnixSecondsImpl,
+  setToUnixSecondsOverride,
+  getToUnixMillisecondsImpl,
+  setToUnixMillisecondsOverride,
+  getToUnixMicrosecondsImpl,
+  setToUnixMicrosecondsOverride,
+  getToUnixNanosecondsImpl,
+  setToUnixNanosecondsOverride,
+  getParseSQLImpl,
+  setParseSQLOverride,
+  getFormatSQLImpl,
+  setFormatSQLOverride,
+  getFormatDurationToPartsImpl,
+  setFormatDurationToPartsOverride,
+  getParseDurationImpl,
+  setParseDurationOverride,
+  getParseISODurationImpl,
+  setParseISODurationOverride,
+  getFormatISODurationImpl,
+  setFormatISODurationOverride,
+  getBalanceDurationImpl,
+  setBalanceDurationOverride,
+  getCompareDurationImpl,
+  setCompareDurationOverride,
+  getSubtractDurationImpl,
+  setSubtractDurationOverride,
+  getGetLocaleImpl,
+  setGetLocaleOverride,
+  getHasLocaleImpl,
+  setHasLocaleOverride,
+  getCreateConfigImpl,
+  setCreateConfigOverride,
+  getMergeWithConfigImpl,
+  setMergeWithConfigOverride,
+  getListRegisteredGrammarsImpl,
+  setListRegisteredGrammarsOverride,
+  getIntervalImpl,
+  setIntervalOverride,
+  getOverlapsImpl,
+  setOverlapsOverride,
+  getIntersectionImpl,
+  setIntersectionOverride,
+  getUnionImpl,
+  setUnionOverride,
+  getMergeIntervalsImpl,
+  setMergeIntervalsOverride,
+  getFormatRangeToPartsImpl,
+  setFormatRangeToPartsOverride,
+  getBetweenImpl,
+  setBetweenOverride,
+  getParseRRuleImpl,
+  setParseRRuleOverride,
+  getFormatRRuleImpl,
+  setFormatRRuleOverride,
+  getCreateBusinessCalendarImpl,
+  setCreateBusinessCalendarOverride,
+  getSubtractBusinessDaysImpl,
+  setSubtractBusinessDaysOverride,
+  getNextHolidayImpl,
+  setNextHolidayOverride,
+  getPreviousHolidayImpl,
+  setPreviousHolidayOverride,
+  getResolveZonedImpl,
+  setResolveZonedOverride,
+  getGetNextTransitionImpl,
+  setGetNextTransitionOverride,
+  getGetPreviousTransitionImpl,
+  setGetPreviousTransitionOverride,
+  getPossibleInstantsForImpl,
+  setPossibleInstantsForOverride,
+  getGetAutocompleteDataImpl,
+  setGetAutocompleteDataOverride,
+  getGetHoverDocsImpl,
+  setGetHoverDocsOverride,
+  getGetInlineDiagnosticsImpl,
+  setGetInlineDiagnosticsOverride,
+  getPreviewFormatImpl,
+  setPreviewFormatOverride,
+  getGetDocUrlImpl,
+  setGetDocUrlOverride,
+  getTranslateDateFnsFormatStringImpl,
+  setTranslateDateFnsFormatStringOverride
+};
+//# sourceMappingURL=chunk-FBPHNRVW.js.map