temporal-fmt 0.8.982 → 0.9.0

package/dist/{chunk-FRS42YLM.js → chunk-AXQLUIDY.js}

@@ -1,14 +1,18 @@
 import {
   applyNumbering,
   tokenize
-} from "./chunk-6MIVOWWX.js";
+} from "./chunk-M33NSC4E.js";
 import {
   DEFAULT_LOCALE,
   TOKENS
-} from "./chunk-XIKLQMF7.js";
+} from "./chunk-VSUCBUTC.js";
 import {
   MAX_FORMAT_LENGTH
 } from "./chunk-EDUFSRWJ.js";
+import {
+  FormatSyntaxError,
+  UnknownTokenError
+} from "./chunk-O6GVMBLW.js";
 
 // src/format.ts
 var HANDLER_BY_TOKEN = new Map(TOKENS.map(([tok, fn, field]) => [tok, { fn, field }]));
@@ -27,9 +31,10 @@ function getPieces(formatStr) {
 }
 function format(temporal, formatStr, options = {}) {
   if (formatStr.length > MAX_FORMAT_LENGTH) {
-    throw new Error(
-      `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.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 pieces = getPieces(formatStr);
@@ -46,13 +51,15 @@ function format(temporal, formatStr, options = {}) {
        here. Same defensive-guard category as the twin checks in
        analyze.ts/formatDuration.ts. */
     if (!handler) {
-      throw new Error(`temporal-fmt: unknown token "${piece.value}"`);
+      throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token "${piece.value}"` });
     }
     /* c8 ignore stop @preserve */
     if (temporal[handler.field] === void 0) {
-      throw new Error(
-        `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
-      );
+      throw new FormatSyntaxError({
+        format: formatStr,
+        token: piece.value,
+        message: `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
+      });
     }
     result += handler.fn(temporal, locale);
   }
@@ -60,9 +67,10 @@ function format(temporal, formatStr, options = {}) {
 }
 function formatToParts(temporal, formatStr, options = {}) {
   if (formatStr.length > MAX_FORMAT_LENGTH) {
-    throw new Error(
-      `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.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 pieces = getPieces(formatStr);
@@ -87,13 +95,15 @@ function formatToParts(temporal, formatStr, options = {}) {
     const handler = HANDLER_BY_TOKEN.get(piece.value);
     /* c8 ignore start @preserve -- unreachable, see the note in format() above */
     if (!handler) {
-      throw new Error(`temporal-fmt: unknown token "${piece.value}"`);
+      throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token "${piece.value}"` });
     }
     /* c8 ignore stop @preserve */
     if (temporal[handler.field] === void 0) {
-      throw new Error(
-        `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
-      );
+      throw new FormatSyntaxError({
+        format: formatStr,
+        token: piece.value,
+        message: `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
+      });
     }
     result.push({ type: "token", value: applyNumbering(handler.fn(temporal, locale), options), token: piece.value });
   }
@@ -101,9 +111,10 @@ function formatToParts(temporal, formatStr, options = {}) {
 }
 function compileFormat(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}).`
-    );
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
+    });
   }
   const pieces = getPieces(formatStr);
   return {
@@ -118,11 +129,13 @@ function compileFormat(formatStr) {
           continue;
         }
         const handler = HANDLER_BY_TOKEN.get(piece.value);
-        if (!handler) throw new Error(`temporal-fmt: unknown token "${piece.value}"`);
+        if (!handler) throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token "${piece.value}"` });
         if (temporal[handler.field] === void 0) {
-          throw new Error(
-            `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
-          );
+          throw new FormatSyntaxError({
+            format: formatStr,
+            token: piece.value,
+            message: `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
+          });
         }
         result += handler.fn(temporal, locale);
       }
@@ -139,11 +152,13 @@ function compileFormat(formatStr) {
           continue;
         }
         const handler = HANDLER_BY_TOKEN.get(piece.value);
-        if (!handler) throw new Error(`temporal-fmt: unknown token "${piece.value}"`);
+        if (!handler) throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token "${piece.value}"` });
         if (temporal[handler.field] === void 0) {
-          throw new Error(
-            `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
-          );
+          throw new FormatSyntaxError({
+            format: formatStr,
+            token: piece.value,
+            message: `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
+          });
         }
         out.push({ type: "token", value: applyNumbering(handler.fn(temporal, locale), options), token: piece.value });
       }
@@ -165,4 +180,4 @@ export {
   _getPieces,
   _handlerFor
 };
-//# sourceMappingURL=chunk-FRS42YLM.js.map
+//# sourceMappingURL=chunk-AXQLUIDY.js.map

package/dist/chunk-AXQLUIDY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/format.ts"],"sourcesContent":["import { TOKENS, DEFAULT_LOCALE, type TemporalLike, type FormatOptions } from './tokens.js';\nimport { tokenize, type Piece } from './tokenize.js';\nimport { MAX_FORMAT_LENGTH } from './constants.js';\nimport { applyNumbering, type NumberingFormatOptions } from './numbering.js';\nimport { FormatSyntaxError, UnknownTokenError } from './errors.js';\n\nconst HANDLER_BY_TOKEN = new Map(TOKENS.map(([tok, fn, field]) => [tok, { fn, field }]));\n\n// Pre-tokenized format strings, keyed by (formatStr) — locale doesn't\n// change the tokenization step, only the per-token rendering, so the\n// piece list is shared across locales. Same eviction shape as the\n// other caches in this library.\nconst tokenizeCache = new Map<string, Piece[]>();\nconst MAX_TOKENIZE_CACHE_SIZE = 500;\n\nfunction getPieces(formatStr: string): Piece[] {\n  let pieces = tokenizeCache.get(formatStr);\n  if (pieces) return pieces;\n  if (tokenizeCache.size >= MAX_TOKENIZE_CACHE_SIZE) {\n    const oldestKey = tokenizeCache.keys().next().value;\n    if (oldestKey !== undefined) tokenizeCache.delete(oldestKey);\n  }\n  pieces = tokenize(formatStr);\n  tokenizeCache.set(formatStr, pieces);\n  return pieces;\n}\n\n/**\n * Format a Temporal.PlainDate, PlainTime, PlainDateTime, or ZonedDateTime\n * using a date-fns-style token string.\n *\n * @example\n * format(Temporal.Now.plainDateISO(), 'yyyy-MM-dd') // \"2026-08-04\"\n * format(zdt, \"MMM d, yyyy 'at' h:mm a\") // \"Aug 4, 2026 at 3:45 PM\"\n * format(zdt, 'MMMM d, yyyy', { locale: 'fr-FR' }) // \"août 4, 2026\"\n *\n * Throws on a token the input type doesn't support (e.g. 'HH' on a PlainDate).\n */\nexport function format(temporal: TemporalLike, formatStr: string, options: NumberingFormatOptions = {}): string {\n  if (formatStr.length > MAX_FORMAT_LENGTH) {\n    throw new FormatSyntaxError({\n      format: formatStr,\n      message:\n        `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters ` +\n        `(got ${formatStr.length}).`,\n    });\n  }\n\n  const locale = options.locale ?? DEFAULT_LOCALE;\n  const pieces = getPieces(formatStr);\n  let result = '';\n\n  for (const piece of pieces) {\n    if (piece.kind === 'literal') {\n      result += piece.value;\n      continue;\n    }\n\n    const handler = HANDLER_BY_TOKEN.get(piece.value);\n    /* c8 ignore start @preserve -- unreachable: tokenize() only ever emits\n       tokens present in TOKENS, and HANDLER_BY_TOKEN is built from that\n       same list, so every token piece.value can hold already has an entry\n       here. Same defensive-guard category as the twin checks in\n       analyze.ts/formatDuration.ts. */\n    if (!handler) {\n      throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token \"${piece.value}\"` });\n    }\n    /* c8 ignore stop @preserve */\n\n    if (temporal[handler.field] === undefined) {\n      throw new FormatSyntaxError({\n        format: formatStr,\n        token: piece.value,\n        message:\n          `temporal-fmt: token \"${piece.value}\" requires \"${handler.field}\", ` +\n          `which this Temporal object doesn't have. ` +\n          `(e.g. PlainDate has no time fields, PlainTime has no date fields)`,\n      });\n    }\n\n    result += handler.fn(temporal, locale);\n  }\n\n  // Numeral transliteration happens last and only on request — every\n  // upstream token handler still emits plain ASCII digits, so this is\n  // the single place output digits can diverge from that default.\n  return applyNumbering(result, options);\n}\n\n// Shape mirrors Intl.DateTimeFormat.formatToParts: each entry is either\n// a literal (carrying no token info) or a token piece (carrying the\n// token string and the formatted value). Letting callers iterate parts\n// means they can build custom output — strip a token, swap a separator,\n// render each token to its own DOM node — without re-implementing the\n// tokenizer or the field-check logic.\nexport interface FormattedPart {\n  type: 'literal' | 'token';\n  value: string;\n  // Present when `type === 'token'`. Carries the token string (e.g. \"yyyy\")\n  // so a caller can look up its metadata via tokenInfo() from analyze.ts.\n  token?: string;\n}\n\nexport function formatToParts(temporal: TemporalLike, formatStr: string, options: NumberingFormatOptions = {}): FormattedPart[] {\n  if (formatStr.length > MAX_FORMAT_LENGTH) {\n    throw new FormatSyntaxError({\n      format: formatStr,\n      message:\n        `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters ` +\n        `(got ${formatStr.length}).`,\n    });\n  }\n  const locale = options.locale ?? DEFAULT_LOCALE;\n  const pieces = getPieces(formatStr);\n  const result: FormattedPart[] = [];\n  for (const piece of pieces) {\n    if (piece.kind === 'literal') {\n      // Collapse adjacent literals so formatToParts stays consistent with\n      // how format() walks pieces — a multi-char literal \"at \" is one\n      // entry, not one per character. Same merge logic as appendLiteral\n      // in tokenize.ts.\n      const last = result[result.length - 1];\n      /* c8 ignore start @preserve -- unreachable through tokenize()'s own\n         output: appendLiteral() in tokenize.ts already merges every\n         adjacent literal character before pieces ever reaches here, so\n         two 'literal' pieces never sit back-to-back in the array this\n         loop walks. Kept as defense-in-depth in case that invariant ever\n         changes upstream. */\n      if (last && last.type === 'literal') {\n        last.value += piece.value;\n      } else {\n        /* c8 ignore stop @preserve */\n        result.push({ type: 'literal', value: piece.value });\n      }\n      continue;\n    }\n    const handler = HANDLER_BY_TOKEN.get(piece.value);\n    /* c8 ignore start @preserve -- unreachable, see the note in format() above */\n    if (!handler) {\n      throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token \"${piece.value}\"` });\n    }\n    /* c8 ignore stop @preserve */\n    if (temporal[handler.field] === undefined) {\n      throw new FormatSyntaxError({\n        format: formatStr,\n        token: piece.value,\n        message:\n          `temporal-fmt: token \"${piece.value}\" requires \"${handler.field}\", ` +\n          `which this Temporal object doesn't have. ` +\n          `(e.g. PlainDate has no time fields, PlainTime has no date fields)`,\n      });\n    }\n    // Numeral transliteration applies per-token-part here, rather than\n    // once at the end like format() does, so a caller styling individual\n    // parts (e.g. one <span> per token) still gets correctly-transliterated\n    // digits in each part instead of plain ASCII.\n    result.push({ type: 'token', value: applyNumbering(handler.fn(temporal, locale), options), token: piece.value });\n  }\n  return result;\n}\n\n// Pre-compiles a format string into an object whose format()/formatToParts()\n// methods skip the tokenization step on every call. The tokenizeCache in\n// this module means a plain format(temporal, fmt) call already pays only\n// a Map lookup for tokenization after the first call, so compileFormat()\n// is mostly a typing/ergonomics affordance — useful for callers who want\n// to hold onto a compiled form explicitly (e.g. to inspect the pieces\n// via the .pieces property, or to pass the compiled object around\n// instead of the string).\nexport interface CompiledFormat {\n  format(temporal: TemporalLike, options?: NumberingFormatOptions): string;\n  formatToParts(temporal: TemporalLike, options?: NumberingFormatOptions): FormattedPart[];\n  readonly pieces: ReadonlyArray<Piece>;\n  readonly formatStr: string;\n}\n\nexport function compileFormat(formatStr: string): CompiledFormat {\n  if (formatStr.length > MAX_FORMAT_LENGTH) {\n    throw new FormatSyntaxError({\n      format: formatStr,\n      message:\n        `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters ` +\n        `(got ${formatStr.length}).`,\n    });\n  }\n  // Pre-tokenize once. Validation (unknown tokens, unterminated quotes)\n  // happens here, not lazily on first format() call — surfaces a bad\n  // format string at compile time rather than at first use, which is\n  // the point of compiling up front.\n  const pieces = getPieces(formatStr);\n  return {\n    formatStr,\n    pieces,\n    format(temporal: TemporalLike, options: NumberingFormatOptions = {}) {\n      const locale = options.locale ?? DEFAULT_LOCALE;\n      let result = '';\n      for (const piece of pieces) {\n        if (piece.kind === 'literal') {\n          result += piece.value;\n          continue;\n        }\n        const handler = HANDLER_BY_TOKEN.get(piece.value);\n        /* c8 ignore next -- unreachable, see the note in format() above */\n        if (!handler) throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token \"${piece.value}\"` });\n        if (temporal[handler.field] === undefined) {\n          throw new FormatSyntaxError({\n            format: formatStr,\n            token: piece.value,\n            message:\n              `temporal-fmt: token \"${piece.value}\" requires \"${handler.field}\", ` +\n              `which this Temporal object doesn't have. ` +\n              `(e.g. PlainDate has no time fields, PlainTime has no date fields)`,\n          });\n        }\n        result += handler.fn(temporal, locale);\n      }\n      return applyNumbering(result, options);\n    },\n    formatToParts(temporal: TemporalLike, options: NumberingFormatOptions = {}) {\n      const locale = options.locale ?? DEFAULT_LOCALE;\n      const out: FormattedPart[] = [];\n      for (const piece of pieces) {\n        if (piece.kind === 'literal') {\n          const last = out[out.length - 1];\n          /* c8 ignore next -- unreachable, see the note in formatToParts() above */\n          if (last && last.type === 'literal') last.value += piece.value;\n          else out.push({ type: 'literal', value: piece.value });\n          continue;\n        }\n        const handler = HANDLER_BY_TOKEN.get(piece.value);\n        /* c8 ignore next -- unreachable, see the note in format() above */\n        if (!handler) throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token \"${piece.value}\"` });\n        if (temporal[handler.field] === undefined) {\n          throw new FormatSyntaxError({\n            format: formatStr,\n            token: piece.value,\n            message:\n              `temporal-fmt: token \"${piece.value}\" requires \"${handler.field}\", ` +\n              `which this Temporal object doesn't have. ` +\n              `(e.g. PlainDate has no time fields, PlainTime has no date fields)`,\n          });\n        }\n        out.push({ type: 'token', value: applyNumbering(handler.fn(temporal, locale), options), token: piece.value });\n      }\n      return out;\n    },\n  };\n}\n\n// Exported so analyze.ts can reuse the same tokenization cache rather\n// than re-tokenizing when a caller asks for both a format() and an\n// analyzeFormat() on the same string.\nexport function _getPieces(formatStr: string): Piece[] {\n  return getPieces(formatStr);\n}\n\n// Exported for analyze.ts — same reason as above. The handler map is\n// the source of truth for \"what field does this token need\" — analyze\n// consumes it to compute requiredFields and compatibleTypes.\nexport function _handlerFor(token: string): { fn: (t: TemporalLike, locale: string) => string; field: keyof TemporalLike } | undefined {\n  return HANDLER_BY_TOKEN.get(token);\n}"],"mappings":"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","names":[]}

package/dist/{chunk-KCSGCK7L.js → chunk-CKVHXFX7.js}

@@ -1,10 +1,10 @@
 import {
   applyParseNumbering,
   tokenize
-} from "./chunk-6MIVOWWX.js";
+} from "./chunk-M33NSC4E.js";
 import {
   DEFAULT_LOCALE
-} from "./chunk-XIKLQMF7.js";
+} from "./chunk-VSUCBUTC.js";
 import {
   MAX_FORMAT_LENGTH,
   MAX_INPUT_LENGTH
@@ -13,14 +13,18 @@ import {
   getTemporal
 } from "./chunk-MXXYIMFJ.js";
 import {
+  AmbiguousInputError,
+  FormatSyntaxError,
+  InvalidDateError,
+  InvalidOffsetError,
   InvalidTimeZoneError,
+  ParseMismatchError,
   TemporalFmtError,
-  wrapUntypedError
-} from "./chunk-USONQ7MV.js";
-import {
+  UnknownTokenError,
   canonicalCacheKey,
-  getLocaleVocab
-} from "./chunk-3RLYULUQ.js";
+  getLocaleVocab,
+  wrapUntypedError
+} from "./chunk-O6GVMBLW.js";
 
 // src/pattern.ts
 function escapeRegExp(literal) {
@@ -126,9 +130,10 @@ function tokenFragment(token, locale, nextToken) {
     return QQQ_FRAGMENT;
   }
   if (FORMAT_ONLY_TOKENS.has(token)) {
-    throw new Error(
-      `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").`
-    );
+    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) {
@@ -168,7 +173,7 @@ function tokenFragment(token, locale, nextToken) {
        registering something new or tokenize.ts being bypassed, neither of
        which happens on the parse() path. */
     default:
-      throw new Error(`temporal-fmt: unknown token "${token}"`);
+      throw new UnknownTokenError({ token, message: `temporal-fmt: unknown token "${token}"` });
   }
 }
 var UNPADDED_NUMERIC_TOKENS = /* @__PURE__ */ new Set(["M", "d", "H", "h", "m", "s"]);
@@ -382,22 +387,28 @@ function parseOffsetString(raw, token) {
   const hours = Number(hoursStr);
   const minutes = Number(minutesStr);
   if (hours > 14) {
-    throw new Error(
-      `temporal-fmt: offset hours ${hours} in "${raw}" out of range (max 14 \u2014 Kiritimati, Line Islands is +14:00).`
-    );
+    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 Error(`temporal-fmt: offset minutes ${minutes} in "${raw}" out of range (max 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 Error(
-      `temporal-fmt: offset "${raw}" exceeds the maximum supported UTC offset of +14:00.`
-    );
+    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 Error(
-      `temporal-fmt: offset "${raw}" exceeds the maximum supported negative UTC offset of -12:00.`
-    );
+    throw new InvalidOffsetError({
+      actual: raw,
+      message: `temporal-fmt: offset "${raw}" exceeds the maximum supported negative UTC offset of -12:00.`
+    });
   }
   return `${sign}${hoursStr}:${minutesStr}`;
 }
@@ -511,9 +522,9 @@ function pickLenientSplit(splits, tokens) {
 }
 function resolveYear(fields) {
   if (fields.year !== void 0 && fields.twoDigitYear !== void 0) {
-    throw new Error(
-      'temporal-fmt: format string mixes "yyyy" and "yy" year representations.'
-    );
+    throw new FormatSyntaxError({
+      message: 'temporal-fmt: format string mixes "yyyy" and "yy" year representations.'
+    });
   }
   if (fields.year !== void 0) return fields.year;
   if (fields.twoDigitYear !== void 0) {
@@ -523,27 +534,30 @@ function resolveYear(fields) {
 }
 function resolveHour(fields, formatStr, locale) {
   if (fields.hour !== void 0 && fields.hour12 !== void 0) {
-    throw new Error(
-      `temporal-fmt: format string "${formatStr}" mixes a 24-hour token ("HH"/"H") with a 12-hour token ("hh"/"h").`
-    );
+    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) {
       const vocab = getLocaleVocab(locale);
       const expected = fields.hour < 12 ? vocab.dayPeriod[0] : vocab.dayPeriod[1];
       if (fields.dayPeriodRaw.toLowerCase() !== expected?.toLowerCase()) {
-        throw new Error(
-          `temporal-fmt: format string "${formatStr}" contains a day period that contradicts the 24-hour value.`
-        );
+        throw new FormatSyntaxError({
+          format: formatStr,
+          message: `temporal-fmt: format string "${formatStr}" contains a day period that contradicts the 24-hour value.`
+        });
       }
     }
     return fields.hour;
   }
   if (fields.hour12 !== void 0) {
     if (fields.isPM === void 0) {
-      throw new Error(
-        `temporal-fmt: format string "${formatStr}" uses a 12-hour token ("hh"/"h") without an "a" token, so parse() can't tell AM from PM.`
-      );
+      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);
   }
@@ -551,14 +565,16 @@ function resolveHour(fields, formatStr, locale) {
 }
 function parse(formatStr, input, options = {}) {
   if (formatStr.length > MAX_FORMAT_LENGTH) {
-    throw new Error(
-      `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.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 Error(
-      `temporal-fmt: input exceeds maximum length of ${MAX_INPUT_LENGTH} characters (got ${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);
@@ -568,10 +584,27 @@ function parse(formatStr, input, options = {}) {
   const pattern = getPattern(formatStr, locale);
   const match = pattern.regex.exec(input);
   if (!match) {
-    throw new Error(`temporal-fmt: no valid pattern matches the format string and input shape`);
+    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 Error(`temporal-fmt: format string "${formatStr}" has no tokens \u2014 nothing to parse into a value.`);
+    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])) {
@@ -589,9 +622,11 @@ function parse(formatStr, input, options = {}) {
     const splits = enumerateValidSplits(runDigits, run.tokens);
     if (splits.length > 1) {
       if (!options.lenient) {
-        throw new Error(
-          `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.`
-        );
+        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.`
+        });
       }
       runPicks.push({ groupNames: run.groupNames, values: pickLenientSplit(splits, run.tokens) });
     }
@@ -611,28 +646,35 @@ function parse(formatStr, input, options = {}) {
   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 Error(
-      `temporal-fmt: format string "${formatStr}" has an incomplete date \u2014 year, month, and day tokens must all be present together.`
-    );
+    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 Error(
-      `temporal-fmt: format string "${formatStr}" has a "zzz" token but needs a full date and time to build a ZonedDateTime.`
-    );
+    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 Error(
-      `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.`
-    );
+    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 Error(
-      `temporal-fmt: format string "${formatStr}" has a weekday token ("EEEE"/"EEE") but needs a full date to validate it against.`
-    );
+    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 Error(`temporal-fmt: format string "${formatStr}" has no date or time tokens to parse.`);
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has no date or time tokens to parse.`
+    });
   }
   const temporal = getTemporal();
   const timeFields = {
@@ -665,15 +707,19 @@ function parse(formatStr, input, options = {}) {
         const zdt = result;
         const wallClockShifted = zdt.hour !== timeFields.hour || zdt.minute !== timeFields.minute || zdt.second !== timeFields.second;
         if (wallClockShifted) {
-          throw new Error(
-            `"${timeZoneId}" has no such wall-clock time on this date \u2014 it falls in a DST gap, not an ambiguous or valid instant.`
-          );
+          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 Error(
-            `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}.`
-          );
+          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) {
@@ -686,25 +732,30 @@ function parse(formatStr, input, options = {}) {
       result = temporal.PlainTime.from(timeFields, reject);
     }
   } catch (err) {
-    throw new Error(
-      `temporal-fmt: "${input}" doesn't describe a valid date/time for format "${formatStr}": ${err.message}`
-    );
+    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 Error(
-        `temporal-fmt: "${weekdayRaw}" doesn't match the actual weekday (${vocab.weekdayLong[actual - 1]}) for the parsed date.`
-      );
+      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 Error(
-        `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}.`
-      );
+      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;
@@ -713,11 +764,13 @@ 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 {
@@ -728,14 +781,16 @@ function tryParse(formatStr, input, options = {}) {
 }
 function parseToParts(formatStr, input, options = {}) {
   if (formatStr.length > MAX_FORMAT_LENGTH) {
-    throw new Error(
-      `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.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 Error(
-      `temporal-fmt: input exceeds maximum length of ${MAX_INPUT_LENGTH} characters (got ${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);
@@ -744,10 +799,27 @@ function parseToParts(formatStr, input, options = {}) {
   const pattern = getPattern(formatStr, locale);
   const match = pattern.regex.exec(input);
   if (!match) {
-    throw new Error(`temporal-fmt: no valid pattern matches the format string and input shape`);
+    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 Error(`temporal-fmt: format string "${formatStr}" has no tokens \u2014 nothing to parse into a value.`);
+    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])) {
@@ -765,9 +837,11 @@ function parseToParts(formatStr, input, options = {}) {
     const splits = enumerateValidSplits(runDigits, run.tokens);
     if (splits.length > 1) {
       if (!options.lenient) {
-        throw new Error(
-          `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.`
-        );
+        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.`
+        });
       }
       runPicks.push({ groupNames: run.groupNames, values: pickLenientSplit(splits, run.tokens) });
     }
@@ -791,9 +865,10 @@ function parseToParts(formatStr, input, options = {}) {
 }
 function compileParser(formatStr, options = {}) {
   if (formatStr.length > MAX_FORMAT_LENGTH) {
-    throw new Error(
-      `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.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);
@@ -824,4 +899,4 @@ export {
   parseToParts,
   compileParser
 };
-//# sourceMappingURL=chunk-KCSGCK7L.js.map
+//# sourceMappingURL=chunk-CKVHXFX7.js.map