temporal-fmt 0.9.2 → 0.9.4

package/dist/chunk-5UTV5VP6.js

@@ -0,0 +1,984 @@
+import {
+  applyParseNumbering,
+  tokenize
+} from "./chunk-M3GDTHMT.js";
+import {
+  DEFAULT_LOCALE
+} from "./chunk-L24NPTAJ.js";
+import {
+  getTemporal
+} from "./chunk-ZQZF5EXW.js";
+import {
+  MAX_FORMAT_LENGTH,
+  MAX_INPUT_LENGTH
+} from "./chunk-YEUASGDK.js";
+import {
+  AmbiguousInputError,
+  FormatSyntaxError,
+  InvalidDateError,
+  InvalidOffsetError,
+  InvalidTimeZoneError,
+  ParseMismatchError,
+  TemporalFmtError,
+  UnknownTokenError,
+  assertValidLocaleTag,
+  canonicalCacheKey,
+  getLocaleVocab,
+  subscribeToVocabChanges,
+  wrapUntypedError
+} from "./chunk-EGUUO6LE.js";
+
+// src/pattern.ts
+function escapeRegExp(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function alternation(values, caseInsensitive = false) {
+  const escaped = values.map(escapeRegExp);
+  if (!caseInsensitive) return `(?:${escaped.join("|")})`;
+  return `(?:${escaped.map(foldCase).join("|")})`;
+}
+function foldCase(value) {
+  return value.replace(/[a-zA-Z]/g, (ch) => `[${ch.toLowerCase()}${ch.toUpperCase()}]`);
+}
+var TIME_ZONE_SHAPE = "(?:UTC|[+-]\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{1,9})?)?|[A-Za-z_]+(?:[+-]\\d{1,2})?(?:\\/[A-Za-z0-9_+-]+)*)";
+var OFFSET_SHAPES = {
+  X: "(?:Z|[+-]\\d{2}(?:\\d{2})?)",
+  XX: "(?:Z|[+-]\\d{4})",
+  XXX: "(?:Z|[+-]\\d{2}:\\d{2})",
+  x: "[+-]\\d{2}(?:\\d{2})?",
+  xx: "[+-]\\d{4}",
+  xxx: "[+-]\\d{2}:\\d{2}"
+};
+function getTimeZoneFragment() {
+  return TIME_ZONE_SHAPE;
+}
+var validZoneSet;
+function getValidZoneSet() {
+  if (!validZoneSet) {
+    validZoneSet = new Set(Intl.supportedValuesOf("timeZone"));
+    validZoneSet.add("UTC");
+  }
+  return validZoneSet;
+}
+var FIXED_OFFSET_RE = /^[+-]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
+function isValidTimeZone(raw) {
+  if (FIXED_OFFSET_RE.test(raw) || getValidZoneSet().has(raw)) return true;
+  try {
+    getTemporal().ZonedDateTime.from({
+      year: 2026,
+      month: 1,
+      day: 1,
+      hour: 0,
+      minute: 0,
+      second: 0,
+      timeZone: raw
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var NUMERIC_FRAGMENTS = {
+  yy: "\\d{2}",
+  MM: "(?:0[1-9]|1[0-2])",
+  M: "(?:1[0-2]|[1-9])",
+  dd: "(?:0[1-9]|[12]\\d|3[01])",
+  d: "(?:[12]\\d|3[01]|[1-9])",
+  HH: "(?:[01]\\d|2[0-3])",
+  H: "(?:1\\d|2[0-3]|[0-9])",
+  hh: "(?:0[1-9]|1[0-2])",
+  h: "(?:1[0-2]|[1-9])",
+  mm: "(?:[0-5]\\d)",
+  m: "(?:[1-5]\\d|[0-9])",
+  ss: "(?:[0-5]\\d)",
+  s: "(?:[1-5]\\d|[0-9])",
+  SSSSSSSSS: "\\d{9}",
+  SSSSSSSS: "\\d{8}",
+  SSSSSSS: "\\d{7}",
+  SSSSSS: "\\d{6}",
+  SSSSS: "\\d{5}",
+  SSSS: "\\d{4}",
+  SSS: "\\d{3}",
+  SS: "\\d{2}",
+  S: "\\d",
+  // Q is always a single digit 1-4 (no padding variant, so no width ambiguity
+  // with adjacent digit tokens the way M/d/H/m/s have).
+  Q: "[1-4]"
+};
+var QQQ_FRAGMENT = "Q[1-4]";
+var FORMAT_ONLY_TOKENS = /* @__PURE__ */ new Set(["do", "ww", "RRRR", "D", "DD", "DDD", "LLLL", "LLL", "cccc", "ccc", "GGGG", "G", "zzzz", "z"]);
+var YYYY_EXACT = "-?\\d{4}";
+var YYYY_EXTENDED = "-?\\d{4,}";
+var Y_FRAGMENT = "-?\\d+";
+var DIGIT_LEADING_TOKENS = /* @__PURE__ */ new Set([
+  "yyyy",
+  "yy",
+  "y",
+  "MM",
+  "M",
+  "dd",
+  "d",
+  "HH",
+  "H",
+  "hh",
+  "h",
+  "mm",
+  "m",
+  "ss",
+  "s",
+  "SSSSSSSSS",
+  "SSSSSSSS",
+  "SSSSSSS",
+  "SSSSSS",
+  "SSSSS",
+  "SSSS",
+  "SSS",
+  "SS",
+  "S"
+]);
+var UNBOUNDED_WIDTH_TOKENS = /* @__PURE__ */ new Set(["y"]);
+function tokenFragment(token, locale, nextToken) {
+  if (token === "yyyy") {
+    return nextToken !== void 0 && DIGIT_LEADING_TOKENS.has(nextToken) ? YYYY_EXACT : YYYY_EXTENDED;
+  }
+  if (token === "y") {
+    return Y_FRAGMENT;
+  }
+  const numeric = NUMERIC_FRAGMENTS[token];
+  if (numeric) {
+    return numeric;
+  }
+  if (token === "QQQ") {
+    return QQQ_FRAGMENT;
+  }
+  if (FORMAT_ONLY_TOKENS.has(token)) {
+    throw new UnknownTokenError({
+      token,
+      message: `temporal-fmt: token "${token}" is format-only \u2014 it can't be parsed back into a value. Use a different token in the parse format string (e.g. "d" for "do", "MM" for "ww").`
+    });
+  }
+  const vocab = getLocaleVocab(locale);
+  switch (token) {
+    case "MMMM":
+      return alternation(vocab.monthLong);
+    case "MMM":
+      return alternation(vocab.monthShort);
+    case "EEEE":
+      return alternation(vocab.weekdayLong);
+    case "EEE":
+      return alternation(vocab.weekdayShort);
+    // Case-insensitive on purpose: "pm"/"Pm"/"PM" all mean the same thing,
+    // and unlike the Md-glue ambiguity elsewhere in this file, there's no
+    // second valid reading to guess wrong — so rejecting on case buys no
+    // correctness, only friction against real-world data (mixed-case CSV
+    // exports, lowercase log timestamps).
+    case "a":
+      return alternation(vocab.dayPeriod, true);
+    case "zzz":
+      return getTimeZoneFragment();
+    case "X":
+    case "XX":
+    case "XXX":
+    case "x":
+    case "xx":
+    case "xxx":
+      return OFFSET_SHAPES[token];
+    /* c8 ignore start @preserve -- defensive guard, not reachable through
+       the public API. tokenFragment's only caller (buildCapturingPattern
+       in parsePattern.ts) always passes piece.value straight from
+       tokenize.ts, which only ever emits strings from tokens.ts's TOKENS
+       table. Every token in that table is handled above: the numeric
+       ones via NUMERIC_FRAGMENTS, QQQ via QQQ_FRAGMENT, the format-only
+       ones via the FORMAT_ONLY_TOKENS check earlier in this function, and
+       everything else via one of the switch cases. There's no token
+       string that can reach this default without either tokens.ts
+       registering something new or tokenize.ts being bypassed, neither of
+       which happens on the parse() path. */
+    default:
+      throw new UnknownTokenError({ token, message: `temporal-fmt: unknown token "${token}"` });
+  }
+}
+var UNPADDED_NUMERIC_TOKENS = /* @__PURE__ */ new Set(["M", "d", "H", "h", "m", "s"]);
+var UNPADDED_NUMERIC_RANGES = {
+  M: [{ digits: 1, min: 1, max: 9 }, { digits: 2, min: 10, max: 12 }],
+  d: [{ digits: 1, min: 1, max: 9 }, { digits: 2, min: 10, max: 31 }],
+  H: [{ digits: 1, min: 0, max: 9 }, { digits: 2, min: 10, max: 23 }],
+  h: [{ digits: 1, min: 1, max: 9 }, { digits: 2, min: 10, max: 12 }],
+  m: [{ digits: 1, min: 0, max: 9 }, { digits: 2, min: 10, max: 59 }],
+  s: [{ digits: 1, min: 0, max: 9 }, { digits: 2, min: 10, max: 59 }]
+};
+function enumerateValidSplits(digits, tokens) {
+  const memo = /* @__PURE__ */ new Map();
+  function solve(tokenIndex, offset) {
+    const key = `${tokenIndex}:${offset}`;
+    const cached = memo.get(key);
+    if (cached) {
+      return cached;
+    }
+    if (tokenIndex === tokens.length) {
+      const result = offset === digits.length ? [[]] : [];
+      memo.set(key, result);
+      return result;
+    }
+    const token = tokens[tokenIndex];
+    const ranges = UNPADDED_NUMERIC_RANGES[token];
+    /* c8 ignore start @preserve -- defensive guard, not reachable through
+       the public API. enumerateValidSplits's only caller (parse.ts, both
+       call sites) passes run.tokens straight from
+       pattern.ambiguousRuns, which parsePattern.ts only ever populates
+       with tokens already checked against UNPADDED_NUMERIC_TOKENS — the
+       exact same key set as UNPADDED_NUMERIC_RANGES. There's no path
+       where a token reaches here without having already passed that
+       check. */
+    if (!ranges) {
+      throw new Error(`temporal-fmt: internal error \u2014 "${token}" is not an unpadded numeric token`);
+    }
+    /* c8 ignore stop @preserve */
+    const results = [];
+    for (const { digits: width, min, max } of ranges) {
+      if (offset + width > digits.length) continue;
+      const piece = digits.slice(offset, offset + width);
+      if (width === 2 && piece[0] === "0") continue;
+      const value = Number(piece);
+      if (value < min || value > max) continue;
+      for (const restSplit of solve(tokenIndex + 1, offset + width)) {
+        results.push([value, ...restSplit]);
+        if (results.length === 2) break;
+      }
+      if (results.length === 2) break;
+    }
+    memo.set(key, results);
+    return results;
+  }
+  return solve(0, 0);
+}
+
+// src/parsePattern.ts
+function escapeRegExp2(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var MAX_AMBIGUITY_BITS = 12;
+function widthChoicesBits(choices) {
+  return Math.ceil(Math.log2(Math.max(choices, 1)));
+}
+function isDigitConsumingStart(piece) {
+  if (piece === void 0) return false;
+  if (piece.kind === "literal") return /^[0-9]/.test(piece.value);
+  return DIGIT_LEADING_TOKENS.has(piece.value);
+}
+function buildCapturingPattern(pieces, locale) {
+  const groups = [];
+  const ambiguousRuns = [];
+  let source = "";
+  let i = 0;
+  let ambiguityBits = 0;
+  let currentRun = { names: [], tokens: [] };
+  const flushRun = (nextPiece) => {
+    if (currentRun.tokens.length === 1) {
+      const name = currentRun.names[0];
+      const token = currentRun.tokens[0];
+      source += `(?<${name}>${tokenFragment(token, locale)})`;
+      if (isDigitConsumingStart(nextPiece)) ambiguityBits += 1;
+    } else if (currentRun.tokens.length >= 2) {
+      const runName = `r${i++}`;
+      const tokenCount = currentRun.tokens.length;
+      source += `(?<${runName}>\\d{${tokenCount},${tokenCount * 2}})`;
+      ambiguousRuns.push({
+        groupName: runName,
+        groupNames: currentRun.names,
+        tokens: currentRun.tokens
+      });
+      if (isDigitConsumingStart(nextPiece)) {
+        ambiguityBits += widthChoicesBits(tokenCount + 1);
+      }
+    }
+    currentRun = { names: [], tokens: [] };
+  };
+  for (const [idx, piece] of pieces.entries()) {
+    if (piece.kind === "literal") {
+      flushRun(piece);
+      source += escapeRegExp2(piece.value);
+      continue;
+    }
+    if (UNPADDED_NUMERIC_TOKENS.has(piece.value)) {
+      const name2 = `g${i++}`;
+      groups.push({ name: name2, token: piece.value });
+      currentRun.names.push(name2);
+      currentRun.tokens.push(piece.value);
+      continue;
+    }
+    flushRun(piece);
+    const name = `g${i++}`;
+    groups.push({ name, token: piece.value });
+    const nextPiece = pieces[idx + 1];
+    const nextToken = nextPiece?.kind === "token" ? nextPiece.value : void 0;
+    if (UNBOUNDED_WIDTH_TOKENS.has(piece.value) && isDigitConsumingStart(nextPiece)) {
+      throw new FormatSyntaxError({
+        reason: `token "${piece.value}" has no fixed width \u2014 it can't be placed directly next to another digit-reading token or a literal that starts with a digit, since there's no way to tell where "${piece.value}" ends and the next field begins. Add a non-digit separator (e.g. "-" or " ") after it.`
+      });
+    }
+    if (piece.value === "yyyy" && nextToken === void 0 && isDigitConsumingStart(nextPiece)) {
+      source += `(?<${name}>${tokenFragment(piece.value, locale, "M")})`;
+    } else {
+      source += `(?<${name}>${tokenFragment(piece.value, locale, nextToken)})`;
+    }
+  }
+  flushRun(void 0);
+  if (ambiguityBits > MAX_AMBIGUITY_BITS) {
+    throw new FormatSyntaxError({
+      reason: `format string has too many variable-width numeric tokens glued to digit-consuming neighbors (ambiguity score ${ambiguityBits} > ${MAX_AMBIGUITY_BITS}). This shape makes the regex engine backtrack exponentially on near-miss input. Add a non-digit separator between these tokens (e.g. "-" or " ") or use their padded forms (MM/dd/HH/mm/ss).`
+    });
+  }
+  return { regex: new RegExp(`^(?:${source})$`, "ud"), groups, ambiguousRuns };
+}
+
+// src/parse.ts
+var patternCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 500;
+subscribeToVocabChanges(() => {
+  patternCache.clear();
+});
+function getPattern(formatStr, locale) {
+  const key = JSON.stringify([canonicalCacheKey(locale), formatStr]);
+  let pattern = patternCache.get(key);
+  if (pattern) {
+    return pattern;
+  }
+  if (patternCache.size >= MAX_CACHE_SIZE) {
+    const oldestKey = patternCache.keys().next().value;
+    if (oldestKey !== void 0) patternCache.delete(oldestKey);
+  }
+  pattern = buildCapturingPattern(tokenize(formatStr), locale);
+  patternCache.set(key, pattern);
+  return pattern;
+}
+var calendarCache = /* @__PURE__ */ new Map();
+var MAX_CALENDAR_CACHE_SIZE = 500;
+function resolveCalendar(locale) {
+  assertValidLocaleTag(locale);
+  const canonicalLocale = canonicalCacheKey(locale);
+  if (calendarCache.has(canonicalLocale)) {
+    return calendarCache.get(canonicalLocale);
+  }
+  if (calendarCache.size >= MAX_CALENDAR_CACHE_SIZE) {
+    const oldestKey = calendarCache.keys().next().value;
+    if (oldestKey !== void 0) calendarCache.delete(oldestKey);
+  }
+  let calendar;
+  const parts = canonicalLocale.split("-");
+  const extensionIndex = parts.indexOf("u");
+  const calendarKeyIndex = extensionIndex === -1 ? -1 : parts.indexOf("ca", extensionIndex + 1);
+  if (calendarKeyIndex !== -1 && calendarKeyIndex + 1 < parts.length) {
+    const resolved = new Intl.DateTimeFormat(canonicalLocale).resolvedOptions().calendar;
+    calendar = resolved === "gregory" ? void 0 : resolved;
+  }
+  calendarCache.set(canonicalLocale, calendar);
+  return calendar;
+}
+function parseOffsetString(raw, token) {
+  if (raw === "Z") {
+    /* c8 ignore start @preserve -- unreachable: lowercase tokens' regex
+       (OFFSET_SHAPES in pattern.ts) has no "Z" alternative at all, so
+       raw === 'Z' can only ever be reached when token is one of the
+       uppercase variants (X/XX/XXX). A lowercase token can't even
+       capture "Z" as `raw` in the first place. */
+    if (token === "x" || token === "xx" || token === "xxx") {
+      throw new Error(
+        `temporal-fmt: offset token "${token}" doesn't accept "Z" \u2014 only the uppercase variants (X/XX/XXX) emit "Z" for UTC. Use "+00:00", "+0000", or "+00" depending on the variant's width.`
+      );
+    }
+    /* c8 ignore stop @preserve */
+    return "+00:00";
+  }
+  const sign = raw[0];
+  /* c8 ignore start @preserve -- unreachable: raw is a regex-captured
+     group from an offset token, and every OFFSET_SHAPES pattern
+     (pattern.ts) is anchored to either "Z" or a leading [+-]. raw's
+     first character can never be anything else by the time it reaches
+     this function. */
+  if (sign !== "+" && sign !== "-") {
+    throw new Error(`temporal-fmt: offset "${raw}" for token "${token}" doesn't start with "+", "-", or "Z".`);
+  }
+  /* c8 ignore stop @preserve */
+  const body = raw.slice(1);
+  let hoursStr;
+  let minutesStr;
+  if (body.length === 2) {
+    /* c8 ignore start @preserve -- unreachable: each offset token's own
+       regex shape in OFFSET_SHAPES (pattern.ts) already gates which
+       body shapes it can capture. Only X and x ever match a 2-digit
+       body — XX/xx/XXX/xxx's regexes can't produce one — so this
+       mismatch can never actually fire through parse(). */
+    if (token !== "X" && token !== "x") {
+      throw new Error(
+        `temporal-fmt: offset token "${token}" can't match "${raw}" \u2014 it requires minutes, but "${raw}" has none.`
+      );
+    }
+    /* c8 ignore stop @preserve */
+    hoursStr = body;
+    minutesStr = "00";
+  } else if (body.length === 4) {
+    /* c8 ignore start @preserve -- unreachable, same reason as the
+       2-digit case above: XXX/xxx's regex requires a colon, so it can
+       never capture a 4-digit no-colon body in the first place. */
+    if (token === "XXX" || token === "xxx") {
+      throw new Error(
+        `temporal-fmt: offset token "${token}" can't match "${raw}" \u2014 it requires a colon between hours and minutes (e.g. "${sign}${body.slice(0, 2)}:${body.slice(2)}").`
+      );
+    }
+    /* c8 ignore stop @preserve */
+    hoursStr = body.slice(0, 2);
+    minutesStr = body.slice(2, 4);
+  } else if (body.length === 5 && body[2] === ":") {
+    /* c8 ignore start @preserve -- unreachable, same reason again: only
+       XXX/xxx's regex can produce a colon-shaped body; X/x/XX/xx never
+       capture one. */
+    if (token !== "XXX" && token !== "xxx") {
+      throw new Error(
+        `temporal-fmt: offset token "${token}" can't match "${raw}" \u2014 it doesn't use a colon (use "${sign}${body.slice(0, 2)}${body.slice(3)}" instead).`
+      );
+    }
+    /* c8 ignore stop @preserve */
+    hoursStr = body.slice(0, 2);
+    minutesStr = body.slice(3, 5);
+    /* c8 ignore start @preserve -- unreachable: every offset token's
+       regex only ever produces a body of length 2, length 4, or length 5
+       with a colon at index 2 (see OFFSET_SHAPES in pattern.ts) — no
+       shape falls outside those three cases, so this else arm can't be
+       taken through parse(). Kept as an exhaustiveness fallback so
+       hoursStr/minutesStr are assigned on every path TypeScript can see. */
+  } else {
+    throw new Error(`temporal-fmt: offset "${raw}" doesn't match the shape token "${token}" accepts.`);
+  }
+  /* c8 ignore stop @preserve */
+  const hours = Number(hoursStr);
+  const minutes = Number(minutesStr);
+  if (hours > 14) {
+    throw new InvalidOffsetError({
+      actual: raw,
+      message: `temporal-fmt: offset hours ${hours} in "${raw}" out of range (max 14 \u2014 Kiritimati, Line Islands is +14:00).`
+    });
+  }
+  if (minutes > 59) {
+    throw new InvalidOffsetError({
+      actual: raw,
+      message: `temporal-fmt: offset minutes ${minutes} in "${raw}" out of range (max 59).`
+    });
+  }
+  if (sign === "+" && hours === 14 && minutes !== 0) {
+    throw new InvalidOffsetError({
+      actual: raw,
+      message: `temporal-fmt: offset "${raw}" exceeds the maximum supported UTC offset of +14:00.`
+    });
+  }
+  if (sign === "-" && hours === 12 && minutes !== 0) {
+    throw new InvalidOffsetError({
+      actual: raw,
+      message: `temporal-fmt: offset "${raw}" exceeds the maximum supported negative UTC offset of -12:00.`
+    });
+  }
+  return `${sign}${hoursStr}:${minutesStr}`;
+}
+function assignField(fields, key, value) {
+  fields[key] = value;
+}
+function applyGroup(fields, token, raw, locale, formatStr) {
+  const vocab = getLocaleVocab(locale);
+  switch (token) {
+    case "yyyy":
+    case "y":
+      assignField(fields, "year", Number(raw));
+      break;
+    case "yy":
+      assignField(fields, "twoDigitYear", Number(raw));
+      break;
+    case "MM":
+    case "M":
+      assignField(fields, "month", Number(raw));
+      break;
+    case "MMMM":
+      assignField(fields, "month", vocab.monthLong.indexOf(raw) + 1);
+      break;
+    case "MMM":
+      assignField(fields, "month", vocab.monthShort.indexOf(raw) + 1);
+      break;
+    case "dd":
+    case "d":
+      assignField(fields, "day", Number(raw));
+      break;
+    case "EEEE":
+      assignField(fields, "weekdayRaw", raw);
+      assignField(fields, "weekdayExpected", vocab.weekdayLong.indexOf(raw) + 1);
+      break;
+    case "EEE":
+      assignField(fields, "weekdayRaw", raw);
+      assignField(fields, "weekdayExpected", vocab.weekdayShort.indexOf(raw) + 1);
+      break;
+    case "HH":
+    case "H":
+      assignField(fields, "hour", Number(raw));
+      break;
+    case "hh":
+    case "h":
+      assignField(fields, "hour12", Number(raw));
+      break;
+    case "mm":
+    case "m":
+      assignField(fields, "minute", Number(raw));
+      break;
+    case "ss":
+    case "s":
+      assignField(fields, "second", Number(raw));
+      break;
+    case "S":
+    case "SS":
+    case "SSS":
+    case "SSSS":
+    case "SSSSS":
+    case "SSSSSS":
+    case "SSSSSSS":
+    case "SSSSSSSS":
+    case "SSSSSSSSS": {
+      const nanoOfSecond = Number(raw.padEnd(9, "0"));
+      assignField(fields, "millisecond", Math.floor(nanoOfSecond / 1e6));
+      assignField(fields, "microsecond", Math.floor(nanoOfSecond / 1e3) % 1e3);
+      assignField(fields, "nanosecond", nanoOfSecond % 1e3);
+      break;
+    }
+    case "a": {
+      const periodIndex = vocab.dayPeriod.findIndex((p) => p.toLowerCase() === raw.toLowerCase());
+      /* c8 ignore start @preserve -- unreachable: the 'a' token's regex
+         fragment (pattern.ts's alternation() over vocab.dayPeriod) can
+         only ever capture a case-insensitive match of one of
+         vocab.dayPeriod's own entries. Both the regex and this lookup
+         derive their vocab from the same `locale` via getLocaleVocab(),
+         so periodIndex can't come back negative through parse(). */
+      if (periodIndex < 0) throw new Error(`temporal-fmt: unknown day period "${raw}" for locale "${locale}".`);
+      /* c8 ignore stop @preserve */
+      assignField(fields, "dayPeriodRaw", raw);
+      assignField(fields, "isPM", periodIndex === 1);
+      break;
+    }
+    case "zzz":
+      assignField(fields, "timeZoneId", raw);
+      break;
+    case "X":
+    case "XX":
+    case "XXX":
+    case "x":
+    case "xx":
+    case "xxx":
+      assignField(fields, "offsetString", parseOffsetString(raw, token));
+      break;
+    case "Q":
+      assignField(fields, "quarter", Number(raw));
+      break;
+    case "QQQ":
+      assignField(fields, "quarter", Number(raw.slice(1)));
+      break;
+  }
+}
+function pickLenientSplit(splits, tokens) {
+  const dayIndex = tokens.indexOf("d");
+  if (dayIndex !== -1) {
+    const smallDaySplits = splits.filter((s) => s[dayIndex] <= 12);
+    if (smallDaySplits.length > 0) {
+      return smallDaySplits[0];
+    }
+  }
+  return splits[0];
+}
+function resolveYear(fields) {
+  if (fields.year !== void 0 && fields.twoDigitYear !== void 0) {
+    throw new FormatSyntaxError({
+      message: 'temporal-fmt: format string mixes a full-year token ("yyyy"/"y") with the two-digit "yy" token.'
+    });
+  }
+  if (fields.year !== void 0) return fields.year;
+  if (fields.twoDigitYear !== void 0) {
+    return fields.twoDigitYear <= 68 ? 2e3 + fields.twoDigitYear : 1900 + fields.twoDigitYear;
+  }
+  return void 0;
+}
+function resolveHour(fields, formatStr, locale) {
+  if (fields.hour !== void 0 && fields.hour12 !== void 0) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" mixes a 24-hour token ("HH"/"H") with a 12-hour token ("hh"/"h").`
+    });
+  }
+  if (fields.hour !== void 0) {
+    if (fields.dayPeriodRaw !== void 0) {
+      throw new FormatSyntaxError({
+        format: formatStr,
+        message: `temporal-fmt: format string "${formatStr}" mixes a 24-hour token ("HH"/"H") with a day-period token ("a"). Both describe the same field; use one or the other, not both.`
+      });
+    }
+    return fields.hour;
+  }
+  if (fields.hour12 !== void 0) {
+    if (fields.isPM === void 0) {
+      throw new FormatSyntaxError({
+        format: formatStr,
+        message: `temporal-fmt: format string "${formatStr}" uses a 12-hour token ("hh"/"h") without an "a" token, so parse() can't tell AM from PM.`
+      });
+    }
+    return fields.hour12 % 12 + (fields.isPM ? 12 : 0);
+  }
+  return void 0;
+}
+function parse(formatStr, input, options = {}) {
+  if (formatStr.length > MAX_FORMAT_LENGTH) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
+    });
+  }
+  if (input.length > MAX_INPUT_LENGTH) {
+    throw new FormatSyntaxError({
+      input,
+      message: `temporal-fmt: input exceeds maximum length of ${MAX_INPUT_LENGTH} characters (got ${input.length}).`
+    });
+  }
+  if (options.parseNumberingSystem) {
+    input = applyParseNumbering(input, options);
+  }
+  const locale = options.locale ?? DEFAULT_LOCALE;
+  const calendar = resolveCalendar(locale);
+  const pattern = getPattern(formatStr, locale);
+  const match = pattern.regex.exec(input);
+  if (!match) {
+    throw new ParseMismatchError({
+      input,
+      format: formatStr,
+      // reason set explicitly (not just message): parse.test.js's
+      // "safeParse: failure returns { ok: false, error } with a
+      // TemporalFmtError" asserts result.error.reason carries the
+      // underlying detail text, matching what wrapUntypedError used to
+      // populate when this message reached it as a caught plain Error.
+      reason: "no valid pattern matches the format string and input shape",
+      message: `temporal-fmt: no valid pattern matches the format string and input shape`
+    });
+  }
+  if (pattern.groups.length === 0) {
+    throw new ParseMismatchError({
+      format: formatStr,
+      // reason set explicitly: errors.test.js's "format string with no
+      // tokens at all falls through to ParseMismatchError" asserts
+      // error.reason matches /has no tokens/.
+      reason: `format string "${formatStr}" has no tokens \u2014 nothing to parse into a value.`,
+      message: `temporal-fmt: format string "${formatStr}" has no tokens \u2014 nothing to parse into a value.`
+    });
+  }
+  for (const { name, token } of pattern.groups) {
+    if (token === "zzz" && !isValidTimeZone(match.groups[name])) {
+      throw new InvalidTimeZoneError({
+        input,
+        format: formatStr,
+        actual: match.groups[name],
+        reason: "not a recognized IANA time zone identifier"
+      });
+    }
+  }
+  const runValues = /* @__PURE__ */ new Map();
+  for (const run of pattern.ambiguousRuns) {
+    const runDigits = match.groups[run.groupName];
+    const splits = enumerateValidSplits(runDigits, run.tokens);
+    if (splits.length === 0) {
+      throw new ParseMismatchError({
+        input,
+        format: formatStr,
+        reason: "no valid pattern matches the format string and input shape",
+        message: `temporal-fmt: no valid pattern matches the format string and input shape`
+      });
+    }
+    if (splits.length > 1) {
+      if (!options.lenient) {
+        throw new AmbiguousInputError({
+          input,
+          format: formatStr,
+          message: `temporal-fmt: "${runDigits}" in format string "${formatStr}" is ambiguous \u2014 ${splits.length} different ways to read tokens "${run.tokens.join("")}" (with no separator between them) are all individually valid (e.g. ${JSON.stringify(splits[0])} vs ${JSON.stringify(splits[1])}). parse() won't guess; add a separator between these tokens, or use their padded form (e.g. "MM" instead of "M") so each one has a fixed width. Pass { lenient: true } to opt into a documented heuristic that picks one.`
+        });
+      }
+      const picked = pickLenientSplit(splits, run.tokens);
+      run.groupNames.forEach((name, idx) => runValues.set(name, String(picked[idx])));
+    } else {
+      run.groupNames.forEach((name, idx) => runValues.set(name, String(splits[0][idx])));
+    }
+  }
+  const fields = {};
+  for (const { name, token } of pattern.groups) {
+    const raw = runValues.get(name) ?? match.groups[name];
+    applyGroup(fields, token, raw, locale, formatStr);
+  }
+  const year = resolveYear(fields);
+  const hour = resolveHour(fields, formatStr, locale);
+  const { month, day, minute, second, millisecond, microsecond, nanosecond, timeZoneId, offsetString, weekdayExpected, weekdayRaw, quarter } = fields;
+  const hasAnyDatePart = year !== void 0 || month !== void 0 || day !== void 0;
+  const hasFullDate = year !== void 0 && month !== void 0 && day !== void 0;
+  if (hasAnyDatePart && !hasFullDate) {
+    throw new InvalidDateError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has an incomplete date \u2014 year, month, and day tokens must all be present together.`
+    });
+  }
+  const hasTime = hour !== void 0 || minute !== void 0 || second !== void 0 || millisecond !== void 0;
+  if (timeZoneId !== void 0 && !(hasFullDate && hasTime)) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has a "zzz" token but needs a full date and time to build a ZonedDateTime.`
+    });
+  }
+  if (offsetString !== void 0 && !(hasFullDate && hasTime)) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has an offset token (X/XX/XXX/x/xx/xxx) but needs a full date and time to build a ZonedDateTime.`
+    });
+  }
+  if (weekdayExpected !== void 0 && !hasFullDate) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has a weekday token ("EEEE"/"EEE") but needs a full date to validate it against.`
+    });
+  }
+  if (!hasFullDate && !hasTime) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has no date or time tokens to parse.`
+    });
+  }
+  const temporal = getTemporal();
+  const timeFields = {
+    hour: hour ?? 0,
+    minute: minute ?? 0,
+    second: second ?? 0,
+    millisecond: millisecond ?? 0,
+    microsecond: microsecond ?? 0,
+    nanosecond: nanosecond ?? 0
+  };
+  const calendarField = calendar ? { calendar } : {};
+  const reject = { overflow: "reject" };
+  let result;
+  try {
+    if (timeZoneId !== void 0) {
+      const zoneOptions = { overflow: "reject", offset: "prefer" };
+      result = temporal.ZonedDateTime.from(
+        {
+          year,
+          month,
+          day,
+          ...timeFields,
+          ...calendarField,
+          timeZone: timeZoneId,
+          ...offsetString !== void 0 ? { offset: offsetString } : {}
+        },
+        zoneOptions
+      );
+      if (offsetString !== void 0) {
+        const zdt = result;
+        const wallClockShifted = zdt.hour !== timeFields.hour || zdt.minute !== timeFields.minute || zdt.second !== timeFields.second;
+        if (wallClockShifted) {
+          throw new InvalidDateError({
+            input,
+            format: formatStr,
+            message: `"${timeZoneId}" has no such wall-clock time on this date \u2014 it falls in a DST gap, not an ambiguous or valid instant.`
+          });
+        }
+        const actualOffset = zdt.offset;
+        if (actualOffset !== offsetString) {
+          throw new ParseMismatchError({
+            input,
+            format: formatStr,
+            message: `has both a "zzz" zone (${timeZoneId}) and an offset token (${offsetString}), but the zone's actual offset at this date/time is ${actualOffset}, not ${offsetString}.`
+          });
+        }
+      }
+    } else if (offsetString !== void 0) {
+      throw new ParseMismatchError({
+        input,
+        format: formatStr,
+        message: `format string "${formatStr}" has an offset token but no "zzz" zone token. An offset does not identify a time zone by itself \u2014 add "zzz" to the pattern, or parse into a PlainDateTime/PlainDate/PlainTime if a zone isn't needed.`
+      });
+    } else if (hasFullDate && hasTime) {
+      result = temporal.PlainDateTime.from({ year, month, day, ...timeFields, ...calendarField }, reject);
+    } else if (hasFullDate) {
+      result = temporal.PlainDate.from({ year, month, day, ...calendarField }, reject);
+    } else {
+      result = temporal.PlainTime.from(timeFields, reject);
+    }
+  } catch (err) {
+    throw new InvalidDateError({
+      input,
+      format: formatStr,
+      message: `temporal-fmt: "${input}" doesn't describe a valid date/time for format "${formatStr}": ${err.message}`
+    });
+  }
+  if (weekdayExpected !== void 0) {
+    const actual = result.dayOfWeek;
+    if (actual !== weekdayExpected) {
+      const vocab = getLocaleVocab(locale);
+      throw new InvalidDateError({
+        input,
+        format: formatStr,
+        message: `temporal-fmt: "${weekdayRaw}" doesn't match the actual weekday (${vocab.weekdayLong[actual - 1]}) for the parsed date.`
+      });
+    }
+  }
+  if (quarter !== void 0 && month !== void 0) {
+    const expectedQuarter = Math.ceil(month / 3);
+    if (quarter !== expectedQuarter) {
+      throw new InvalidDateError({
+        format: formatStr,
+        message: `temporal-fmt: format string "${formatStr}" contains a quarter token (Q/QQQ) whose value (Q${quarter}) disagrees with the parsed month's actual quarter \u2014 month ${month} is in Q${expectedQuarter}.`
+      });
+    }
+  }
+  return result;
+}
+function safeParse(formatStr, input, options = {}) {
+  try {
+    return { ok: true, value: parse(formatStr, input, options) };
+  } catch (err) {
+    /* c8 ignore start @preserve */
+    if (err instanceof TemporalFmtError) {
+      return { ok: false, error: err };
+    }
+    return { ok: false, error: wrapUntypedError(err, { input, format: formatStr }) };
+  }
+  /* c8 ignore stop @preserve */
+}
+function tryParse(formatStr, input, options = {}) {
+  try {
+    return parse(formatStr, input, options);
+  } catch {
+    return void 0;
+  }
+}
+function parseToParts(formatStr, input, options = {}) {
+  if (formatStr.length > MAX_FORMAT_LENGTH) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
+    });
+  }
+  if (input.length > MAX_INPUT_LENGTH) {
+    throw new FormatSyntaxError({
+      input,
+      message: `temporal-fmt: input exceeds maximum length of ${MAX_INPUT_LENGTH} characters (got ${input.length}).`
+    });
+  }
+  if (options.parseNumberingSystem) {
+    input = applyParseNumbering(input, options);
+  }
+  const locale = options.locale ?? DEFAULT_LOCALE;
+  const pattern = getPattern(formatStr, locale);
+  const match = pattern.regex.exec(input);
+  if (!match) {
+    throw new ParseMismatchError({
+      input,
+      format: formatStr,
+      // reason set explicitly (not just message): parse.test.js's
+      // "safeParse: failure returns { ok: false, error } with a
+      // TemporalFmtError" asserts result.error.reason carries the
+      // underlying detail text, matching what wrapUntypedError used to
+      // populate when this message reached it as a caught plain Error.
+      reason: "no valid pattern matches the format string and input shape",
+      message: `temporal-fmt: no valid pattern matches the format string and input shape`
+    });
+  }
+  if (pattern.groups.length === 0) {
+    throw new ParseMismatchError({
+      format: formatStr,
+      // reason set explicitly: errors.test.js's "format string with no
+      // tokens at all falls through to ParseMismatchError" asserts
+      // error.reason matches /has no tokens/.
+      reason: `format string "${formatStr}" has no tokens \u2014 nothing to parse into a value.`,
+      message: `temporal-fmt: format string "${formatStr}" has no tokens \u2014 nothing to parse into a value.`
+    });
+  }
+  for (const { name, token } of pattern.groups) {
+    if (token === "zzz" && !isValidTimeZone(match.groups[name])) {
+      throw new InvalidTimeZoneError({
+        input,
+        format: formatStr,
+        actual: match.groups[name],
+        reason: "not a recognized IANA time zone identifier"
+      });
+    }
+  }
+  const runValues = /* @__PURE__ */ new Map();
+  for (const run of pattern.ambiguousRuns) {
+    const runDigits = match.groups[run.groupName];
+    const splits = enumerateValidSplits(runDigits, run.tokens);
+    if (splits.length === 0) {
+      throw new ParseMismatchError({
+        input,
+        format: formatStr,
+        reason: "no valid pattern matches the format string and input shape",
+        message: `temporal-fmt: no valid pattern matches the format string and input shape`
+      });
+    }
+    if (splits.length > 1) {
+      if (!options.lenient) {
+        throw new AmbiguousInputError({
+          input,
+          format: formatStr,
+          message: `temporal-fmt: "${runDigits}" in format string "${formatStr}" is ambiguous \u2014 ${splits.length} different ways to read tokens "${run.tokens.join("")}" (with no separator between them) are all individually valid (e.g. ${JSON.stringify(splits[0])} vs ${JSON.stringify(splits[1])}). parse() won't guess; add a separator between these tokens, or use their padded form (e.g. "MM" instead of "M") so each one has a fixed width. Pass { lenient: true } to opt into a documented heuristic that picks one.`
+        });
+      }
+      const picked = pickLenientSplit(splits, run.tokens);
+      run.groupNames.forEach((name, idx) => runValues.set(name, String(picked[idx])));
+    } else {
+      run.groupNames.forEach((name, idx) => runValues.set(name, String(splits[0][idx])));
+    }
+  }
+  const parts = [];
+  const indices = match.indices;
+  const groupIndices = indices?.groups;
+  let consumed = 0;
+  for (const { name, token } of pattern.groups) {
+    const raw = runValues.get(name) ?? match.groups[name];
+    const fromIndices = !runValues.has(name) && groupIndices?.[name];
+    const position = fromIndices ? fromIndices[0] : (match.index ?? 0) + consumed;
+    parts.push({ token, raw, position });
+    consumed += raw.length;
+  }
+  return parts;
+}
+function compileParser(formatStr, options = {}) {
+  if (formatStr.length > MAX_FORMAT_LENGTH) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
+    });
+  }
+  const locale = options.locale ?? DEFAULT_LOCALE;
+  const pattern = getPattern(formatStr, locale);
+  return {
+    formatStr,
+    pattern,
+    parse(input, opts = {}) {
+      return parse(formatStr, input, { locale, ...opts });
+    },
+    safeParse(input, opts = {}) {
+      return safeParse(formatStr, input, { locale, ...opts });
+    },
+    tryParse(input, opts = {}) {
+      return tryParse(formatStr, input, { locale, ...opts });
+    },
+    parseToParts(input, opts = {}) {
+      return parseToParts(formatStr, input, { locale, ...opts });
+    }
+  };
+}
+
+export {
+  FORMAT_ONLY_TOKENS,
+  UNPADDED_NUMERIC_TOKENS,
+  parse,
+  safeParse,
+  tryParse,
+  parseToParts,
+  compileParser
+};
+//# sourceMappingURL=chunk-5UTV5VP6.js.map