temporal-fmt 0.9.80 → 0.9.81

package/dist/chunk-6FPOCDZV.js

@@ -0,0 +1,129 @@
+import {
+  compileFormat,
+  format,
+  formatToParts
+} from "./chunk-ACGCGXP5.js";
+import {
+  buildCapturingPattern,
+  compileParser,
+  enumerateValidSplits,
+  parse,
+  parseToParts,
+  safeParse,
+  tryParse
+} from "./chunk-EEPLAE3H.js";
+import {
+  tokenize
+} from "./chunk-EXIJZ4JG.js";
+import {
+  DEFAULT_LOCALE
+} from "./chunk-GRBQ5FRO.js";
+import {
+  MAX_FORMAT_LENGTH
+} from "./chunk-SOPTTXUI.js";
+import {
+  TemporalFmtError
+} from "./chunk-QRLQ7RR7.js";
+
+// src/legacy/matchesFormat.ts
+var patternCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 500;
+function getPattern(formatStr, locale) {
+  const key = locale + "\0" + formatStr;
+  const cached = patternCache.get(key);
+  if (cached) return cached;
+  if (patternCache.size >= MAX_CACHE_SIZE) {
+    const oldestKey = patternCache.keys().next().value;
+    if (oldestKey !== void 0) patternCache.delete(oldestKey);
+  }
+  const pattern = buildCapturingPattern(tokenize(formatStr), locale);
+  patternCache.set(key, pattern);
+  return pattern;
+}
+function matchesFormat(formatStr, input, options = {}) {
+  try {
+    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 locale = options.locale ?? DEFAULT_LOCALE;
+    const pattern = getPattern(formatStr, locale);
+    const match = pattern.regex.exec(input);
+    if (!match) return false;
+    for (const run of pattern.ambiguousRuns) {
+      const range = match.indices?.groups?.[run.groupName];
+      if (!range || enumerateValidSplits(input.slice(range[0], range[1]), run.tokens).length === 0) {
+        return false;
+      }
+    }
+    return true;
+  } catch (error) {
+    if (error instanceof TemporalFmtError) throw new Error(error.message);
+    throw error;
+  }
+}
+
+// src/legacy/index.ts
+function withLegacyErrors(operation) {
+  try {
+    return operation();
+  } catch (error) {
+    if (error instanceof TemporalFmtError) {
+      throw new Error(error.message);
+    }
+    throw error;
+  }
+}
+function toLegacySafeParseResult(result) {
+  return result.ok ? result : { ok: false, error: new Error(result.error.message) };
+}
+function format2(temporal, formatStr, options = {}) {
+  return withLegacyErrors(() => format(temporal, formatStr, options));
+}
+function formatToParts2(temporal, formatStr, options = {}) {
+  return withLegacyErrors(() => formatToParts(temporal, formatStr, options));
+}
+function compileFormat2(formatStr) {
+  const compiled = withLegacyErrors(() => compileFormat(formatStr));
+  return {
+    ...compiled,
+    format: (temporal, options) => withLegacyErrors(() => compiled.format(temporal, options)),
+    formatToParts: (temporal, options) => withLegacyErrors(() => compiled.formatToParts(temporal, options))
+  };
+}
+function parse2(formatStr, input, options = {}) {
+  return withLegacyErrors(() => parse(formatStr, input, options));
+}
+function safeParse2(formatStr, input, options = {}) {
+  return toLegacySafeParseResult(safeParse(formatStr, input, options));
+}
+function tryParse2(formatStr, input, options = {}) {
+  return tryParse(formatStr, input, options);
+}
+function parseToParts2(formatStr, input, options = {}) {
+  return withLegacyErrors(() => parseToParts(formatStr, input, options));
+}
+function compileParser2(formatStr, options = {}) {
+  const compiled = withLegacyErrors(() => compileParser(formatStr, options));
+  return {
+    ...compiled,
+    parse: (input, callOptions) => withLegacyErrors(() => compiled.parse(input, callOptions)),
+    safeParse: (input, callOptions) => toLegacySafeParseResult(compiled.safeParse(input, callOptions)),
+    tryParse: (input, callOptions) => compiled.tryParse(input, callOptions),
+    parseToParts: (input, callOptions) => withLegacyErrors(() => compiled.parseToParts(input, callOptions))
+  };
+}
+
+export {
+  matchesFormat,
+  format2 as format,
+  formatToParts2 as formatToParts,
+  compileFormat2 as compileFormat,
+  parse2 as parse,
+  safeParse2 as safeParse,
+  tryParse2 as tryParse,
+  parseToParts2 as parseToParts,
+  compileParser2 as compileParser
+};
+//# sourceMappingURL=chunk-6FPOCDZV.js.map

package/dist/chunk-6FPOCDZV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/legacy/matchesFormat.ts","../src/legacy/index.ts"],"sourcesContent":["/*\n * Copyright 2026 DirazCoder\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { DEFAULT_LOCALE, type FormatOptions } from '../tokens.js';\nimport { tokenize } from '../tokenize.js';\nimport { buildCapturingPattern, type CapturingPattern } from '../parsePattern.js';\nimport { MAX_FORMAT_LENGTH } from '../constants.js';\nimport { TemporalFmtError } from '../errors.js';\nimport { enumerateValidSplits } from '../pattern.js';\n\nconst patternCache = new Map<string, CapturingPattern>();\nconst MAX_CACHE_SIZE = 500;\n\nfunction getPattern(formatStr: string, locale: string) {\n  const key = locale + '\\0' + formatStr;\n  const cached = patternCache.get(key);\n  if (cached) return cached;\n\n  if (patternCache.size >= MAX_CACHE_SIZE) {\n    const oldestKey = patternCache.keys().next().value;\n    if (oldestKey !== undefined) patternCache.delete(oldestKey);\n  }\n\n  const pattern = buildCapturingPattern(tokenize(formatStr), locale);\n  patternCache.set(key, pattern);\n  return pattern;\n}\n\n/**\n * Checks whether `input` could plausibly be output from `format()` for the\n * given format. It checks shape and locale vocabulary, not date validity.\n */\nexport function matchesFormat(formatStr: string, input: string, options: FormatOptions = {}): boolean {\n  try {\n    if (formatStr.length > MAX_FORMAT_LENGTH) {\n      throw new Error(\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 pattern = getPattern(formatStr, locale);\n    const match = pattern.regex.exec(input);\n    if (!match) return false;\n\n    for (const run of pattern.ambiguousRuns) {\n      const range = match.indices?.groups?.[run.groupName];\n      if (!range || enumerateValidSplits(input.slice(range[0], range[1]), run.tokens).length === 0) {\n        return false;\n      }\n    }\n    return true;\n  } catch (error) {\n    if (error instanceof TemporalFmtError) throw new Error(error.message);\n    throw error;\n  }\n}\n","/*\n * Copyright 2026 DirazCoder\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  format as typedFormat,\n  formatToParts as typedFormatToParts,\n  compileFormat as typedCompileFormat,\n  type CompiledFormat,\n  type FormattedPart,\n} from '../format.js';\nimport {\n  parse as typedParse,\n  safeParse as typedSafeParse,\n  tryParse as typedTryParse,\n  parseToParts as typedParseToParts,\n  compileParser as typedCompileParser,\n  type CompiledParser,\n  type ParsedPart,\n} from '../parse.js';\nimport type { TemporalLike } from '../tokens.js';\nimport type { NumberingFormatOptions, NumberingParseOptions } from '../numbering.js';\nimport { TemporalFmtError } from '../errors.js';\n\nexport type LegacySafeParseResult =\n  | { ok: true; value: unknown }\n  | { ok: false; error: Error };\n\nexport type LegacyCompiledParser = Omit<CompiledParser, 'safeParse'> & {\n  safeParse(input: string, options?: NumberingParseOptions): LegacySafeParseResult;\n};\n\nfunction withLegacyErrors<T>(operation: () => T): T {\n  try {\n    return operation();\n  } catch (error) {\n    if (error instanceof TemporalFmtError) {\n      throw new Error(error.message);\n    }\n    throw error;\n  }\n}\n\nfunction toLegacySafeParseResult(result: ReturnType<typeof typedSafeParse>): LegacySafeParseResult {\n  return result.ok\n    ? result\n    : { ok: false, error: new Error(result.error.message) };\n}\n\nexport function format(\n  temporal: TemporalLike,\n  formatStr: string,\n  options: NumberingFormatOptions = {},\n): string {\n  return withLegacyErrors(() => typedFormat(temporal, formatStr, options));\n}\n\nexport function formatToParts(\n  temporal: TemporalLike,\n  formatStr: string,\n  options: NumberingFormatOptions = {},\n): FormattedPart[] {\n  return withLegacyErrors(() => typedFormatToParts(temporal, formatStr, options));\n}\n\nexport function compileFormat(formatStr: string): CompiledFormat {\n  const compiled = withLegacyErrors(() => typedCompileFormat(formatStr));\n  return {\n    ...compiled,\n    format: (temporal, options) => withLegacyErrors(() => compiled.format(temporal, options)),\n    formatToParts: (temporal, options) => withLegacyErrors(() => compiled.formatToParts(temporal, options)),\n  };\n}\n\nexport function parse(formatStr: string, input: string, options: NumberingParseOptions = {}): unknown | undefined {\n  return withLegacyErrors(() => typedParse(formatStr, input, options));\n}\n\nexport function safeParse(\n  formatStr: string,\n  input: string,\n  options: NumberingParseOptions = {},\n): LegacySafeParseResult {\n  return toLegacySafeParseResult(typedSafeParse(formatStr, input, options));\n}\n\nexport function tryParse(formatStr: string, input: string, options: NumberingParseOptions = {}): unknown | undefined {\n  return typedTryParse(formatStr, input, options);\n}\n\nexport function parseToParts(\n  formatStr: string,\n  input: string,\n  options: NumberingParseOptions = {},\n): ParsedPart[] {\n  return withLegacyErrors(() => typedParseToParts(formatStr, input, options));\n}\n\nexport function compileParser(formatStr: string, options: NumberingParseOptions = {}): LegacyCompiledParser {\n  const compiled = withLegacyErrors(() => typedCompileParser(formatStr, options));\n  return {\n    ...compiled,\n    parse: (input, callOptions) => withLegacyErrors(() => compiled.parse(input, callOptions)),\n    safeParse: (input, callOptions) => toLegacySafeParseResult(compiled.safeParse(input, callOptions)),\n    tryParse: (input, callOptions) => compiled.tryParse(input, callOptions),\n    parseToParts: (input, callOptions) => withLegacyErrors(() => compiled.parseToParts(input, callOptions)),\n  };\n}\n\nexport { matchesFormat } from './matchesFormat.js';\n"],"mappings":"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","names":["format","formatToParts","compileFormat","parse","safeParse","tryParse","parseToParts","compileParser"]}

package/dist/{chunk-HGRT37LT.js → chunk-ACGCGXP5.js}

@@ -1,11 +1,11 @@
 import {
   applyNumbering,
   tokenize
-} from "./chunk-DMJWJTFY.js";
+} from "./chunk-EXIJZ4JG.js";
 import {
   DEFAULT_LOCALE,
   TOKENS
-} from "./chunk-Z245NHDT.js";
+} from "./chunk-GRBQ5FRO.js";
 import {
   MAX_FORMAT_LENGTH
 } from "./chunk-SOPTTXUI.js";
@@ -189,4 +189,4 @@ export {
   _getPieces,
   _handlerFor
 };
-//# sourceMappingURL=chunk-HGRT37LT.js.map
+//# sourceMappingURL=chunk-ACGCGXP5.js.map

package/dist/{chunk-WP7TBCTT.js → chunk-E4DD23HH.js}

@@ -1,19 +1,19 @@
-import {
-  format,
-  formatToParts
-} from "./chunk-HGRT37LT.js";
-import {
-  normalizeLocaleTag
-} from "./chunk-QRLQ7RR7.js";
 import {
   compare
 } from "./chunk-UGYSEYUQ.js";
 import {
   asDateFieldView
 } from "./chunk-KEPIXQK7.js";
+import {
+  format,
+  formatToParts
+} from "./chunk-ACGCGXP5.js";
 import {
   daysFromCivil
 } from "./chunk-BLZDBPSV.js";
+import {
+  normalizeLocaleTag
+} from "./chunk-QRLQ7RR7.js";
 
 // src/interval.ts
 function interval(start, end, bounds = "closed") {
@@ -238,4 +238,4 @@ export {
   formatRange,
   formatRangeToParts
 };
-//# sourceMappingURL=chunk-WP7TBCTT.js.map
+//# sourceMappingURL=chunk-E4DD23HH.js.map

package/dist/{chunk-5KP5H7X2.js → chunk-EEPLAE3H.js}

@@ -1,10 +1,10 @@
 import {
   applyParseNumbering,
   tokenize
-} from "./chunk-DMJWJTFY.js";
+} from "./chunk-EXIJZ4JG.js";
 import {
   DEFAULT_LOCALE
-} from "./chunk-Z245NHDT.js";
+} from "./chunk-GRBQ5FRO.js";
 import {
   getTemporal
 } from "./chunk-DFWTCRS3.js";
@@ -975,10 +975,12 @@ function compileParser(formatStr, options = {}) {
 export {
   FORMAT_ONLY_TOKENS,
   UNPADDED_NUMERIC_TOKENS,
+  enumerateValidSplits,
+  buildCapturingPattern,
   parse,
   safeParse,
   tryParse,
   parseToParts,
   compileParser
 };
-//# sourceMappingURL=chunk-5KP5H7X2.js.map
+//# sourceMappingURL=chunk-EEPLAE3H.js.map

package/dist/{chunk-DMJWJTFY.js → chunk-EXIJZ4JG.js}

@@ -1,7 +1,7 @@
 import {
   DEFAULT_LOCALE,
   TOKENS
-} from "./chunk-Z245NHDT.js";
+} from "./chunk-GRBQ5FRO.js";
 import {
   FormatSyntaxError,
   InvalidLocaleError,
@@ -199,4 +199,4 @@ export {
   applyNumbering,
   applyParseNumbering
 };
-//# sourceMappingURL=chunk-DMJWJTFY.js.map
+//# sourceMappingURL=chunk-EXIJZ4JG.js.map

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

@@ -2,6 +2,10 @@ import {
   getTemporal,
   subscribeToTemporalChanges
 } from "./chunk-DFWTCRS3.js";
+import {
+  dayOfYear,
+  isoWeekYearAndWeek
+} from "./chunk-BLZDBPSV.js";
 import {
   FormatSyntaxError,
   InvalidLocaleError,
@@ -10,10 +14,6 @@ import {
   normalizeLocaleTag,
   partValue
 } from "./chunk-QRLQ7RR7.js";
-import {
-  dayOfYear,
-  isoWeekYearAndWeek
-} from "./chunk-BLZDBPSV.js";
 
 // src/tokens.ts
 function requireFields(t, token, ...fields) {
@@ -364,4 +364,4 @@ export {
   DEFAULT_LOCALE,
   TOKENS
 };
-//# sourceMappingURL=chunk-Z245NHDT.js.map
+//# sourceMappingURL=chunk-GRBQ5FRO.js.map

package/dist/{chunk-WEVNKOQA.js → chunk-TDQYKYVJ.js}

@@ -1,13 +1,13 @@
+import {
+  differenceInDays
+} from "./chunk-SC6ENLEB.js";
 import {
   DEFAULT_LOCALE
-} from "./chunk-Z245NHDT.js";
+} from "./chunk-GRBQ5FRO.js";
 import {
   InvalidLocaleError,
   normalizeLocaleTag
 } from "./chunk-QRLQ7RR7.js";
-import {
-  differenceInDays
-} from "./chunk-SC6ENLEB.js";
 
 // src/relativeTime.ts
 var rtfCache = /* @__PURE__ */ new Map();
@@ -62,4 +62,4 @@ export {
   formatRelative,
   formatRelativeToNow
 };
-//# sourceMappingURL=chunk-WEVNKOQA.js.map
+//# sourceMappingURL=chunk-TDQYKYVJ.js.map

package/dist/{chunk-LHR5PCP4.js → chunk-UYKKGBZ3.js}

@@ -1,6 +1,12 @@
+import {
+  asDateFieldView
+} from "./chunk-KEPIXQK7.js";
 import {
   MAX_FORMAT_LENGTH
 } from "./chunk-SOPTTXUI.js";
+import {
+  daysFromCivil
+} from "./chunk-BLZDBPSV.js";
 import {
   FormatSyntaxError,
   InvalidDurationError,
@@ -8,12 +14,6 @@ import {
   canonicalCacheKey,
   normalizeLocaleTag
 } from "./chunk-QRLQ7RR7.js";
-import {
-  asDateFieldView
-} from "./chunk-KEPIXQK7.js";
-import {
-  daysFromCivil
-} from "./chunk-BLZDBPSV.js";
 
 // src/rounding.ts
 var MS_PER_UNIT = {
@@ -578,4 +578,4 @@ export {
   addDuration,
   subtractDuration
 };
-//# sourceMappingURL=chunk-LHR5PCP4.js.map
+//# sourceMappingURL=chunk-UYKKGBZ3.js.map

package/dist/{chunk-64UB3WDT.js → chunk-YQGUTK4E.js}

@@ -1,9 +1,9 @@
-import {
-  getTemporal
-} from "./chunk-DFWTCRS3.js";
 import {
   add
 } from "./chunk-SC6ENLEB.js";
+import {
+  getTemporal
+} from "./chunk-DFWTCRS3.js";
 
 // src/timezone.ts
 function resolveZoned(fields, timeZone, options = {}) {
@@ -232,4 +232,4 @@ export {
   getTransitions,
   possibleInstantsFor
 };
-//# sourceMappingURL=chunk-64UB3WDT.js.map
+//# sourceMappingURL=chunk-YQGUTK4E.js.map

package/dist/duration.js

@@ -9,11 +9,11 @@ import {
   roundDuration,
   subtractDuration,
   totalDuration
-} from "./chunk-LHR5PCP4.js";
-import "./chunk-SOPTTXUI.js";
-import "./chunk-QRLQ7RR7.js";
+} from "./chunk-UYKKGBZ3.js";
 import "./chunk-KEPIXQK7.js";
+import "./chunk-SOPTTXUI.js";
 import "./chunk-BLZDBPSV.js";
+import "./chunk-QRLQ7RR7.js";
 export {
   addDuration,
   balanceDuration,

package/dist/format.js

@@ -4,13 +4,13 @@ import {
   compileFormat,
   format,
   formatToParts
-} from "./chunk-HGRT37LT.js";
-import "./chunk-DMJWJTFY.js";
-import "./chunk-Z245NHDT.js";
+} from "./chunk-ACGCGXP5.js";
+import "./chunk-EXIJZ4JG.js";
+import "./chunk-GRBQ5FRO.js";
 import "./chunk-DFWTCRS3.js";
 import "./chunk-SOPTTXUI.js";
-import "./chunk-QRLQ7RR7.js";
 import "./chunk-BLZDBPSV.js";
+import "./chunk-QRLQ7RR7.js";
 export {
   _getPieces,
   _handlerFor,

package/dist/index.cjs

@@ -167,8 +167,18 @@ __export(index_exports, {
   isWeekend: () => isWeekend,
   isYesterday: () => isYesterday,
   isZonedDateTime: () => isZonedDateTime,
+  legacyCompileFormat: () => compileFormat2,
+  legacyCompileParser: () => compileParser2,
+  legacyFormat: () => format2,
+  legacyFormatToParts: () => formatToParts2,
+  legacyMatchesFormat: () => matchesFormat,
+  legacyParse: () => parse2,
+  legacyParseToParts: () => parseToParts2,
+  legacySafeParse: () => safeParse2,
+  legacyTryParse: () => tryParse2,
   listRegisteredGrammars: () => listRegisteredGrammars,
   listTokens: () => listTokens,
+  matchesFormat: () => matchesFormat,
   max: () => max,
   mergeIntervals: () => mergeIntervals,
   mergeWithConfig: () => mergeWithConfig,
@@ -1075,13 +1085,13 @@ var TOKENS = [
 
 // src/tokenize.ts
 var SORTED_TOKEN_STRINGS = TOKENS.map(([tok]) => tok).sort((a, b) => b.length - a.length);
-function tokenizeWithSpans(format2) {
+function tokenizeWithSpans(format3) {
   const pieces = [];
   let i = 0;
-  while (i < format2.length) {
-    const ch = format2[i];
+  while (i < format3.length) {
+    const ch = format3[i];
     if (ch === "'") {
-      if (format2[i + 1] === "'") {
+      if (format3[i + 1] === "'") {
         appendLiteral(pieces, "'", i, i + 2);
         i += 2;
         continue;
@@ -1089,9 +1099,9 @@ function tokenizeWithSpans(format2) {
       let j = i + 1;
       let literal = "";
       let closed = false;
-      while (j < format2.length) {
-        if (format2[j] === "'") {
-          if (format2[j + 1] === "'") {
+      while (j < format3.length) {
+        if (format3[j] === "'") {
+          if (format3[j + 1] === "'") {
             literal += "'";
             j += 2;
             continue;
@@ -1100,29 +1110,29 @@ function tokenizeWithSpans(format2) {
           j += 1;
           break;
         }
-        literal += format2[j];
+        literal += format3[j];
         j += 1;
       }
       if (!closed) {
         throw new FormatSyntaxError({
-          format: format2,
-          message: `temporal-fmt: unterminated quote in format string "${format2}"`
+          format: format3,
+          message: `temporal-fmt: unterminated quote in format string "${format3}"`
         });
       }
       appendLiteral(pieces, literal, i, j);
       i = j;
       continue;
     }
-    const match = SORTED_TOKEN_STRINGS.find((tok) => format2.startsWith(tok, i));
+    const match = SORTED_TOKEN_STRINGS.find((tok) => format3.startsWith(tok, i));
     if (match) {
       const runChar = match[match.length - 1];
-      if (format2[i + match.length] === runChar) {
+      if (format3[i + match.length] === runChar) {
         let end = i + match.length;
-        while (format2[end] === runChar) end += 1;
+        while (format3[end] === runChar) end += 1;
         throw new UnknownTokenError({
-          format: format2,
-          token: format2.slice(i, end),
-          message: `temporal-fmt: "${format2.slice(i, end)}" in format string "${format2}" isn't a recognized token \u2014 did you mean "${match}"?`
+          format: format3,
+          token: format3.slice(i, end),
+          message: `temporal-fmt: "${format3.slice(i, end)}" in format string "${format3}" isn't a recognized token \u2014 did you mean "${match}"?`
         });
       }
       pieces.push({ kind: "token", value: match, start: i, end: i + match.length });
@@ -1134,8 +1144,8 @@ function tokenizeWithSpans(format2) {
   }
   return pieces;
 }
-function tokenize(format2) {
-  return tokenizeWithSpans(format2).map(({ kind, value }) => ({ kind, value }));
+function tokenize(format3) {
+  return tokenizeWithSpans(format3).map(({ kind, value }) => ({ kind, value }));
 }
 function appendLiteral(pieces, value, start, end) {
   const last = pieces[pieces.length - 1];
@@ -2366,6 +2376,96 @@ function compileParser(formatStr, options = {}) {
   };
 }
 
+// src/legacy/matchesFormat.ts
+var patternCache2 = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE3 = 500;
+function getPattern2(formatStr, locale) {
+  const key = locale + "\0" + formatStr;
+  const cached = patternCache2.get(key);
+  if (cached) return cached;
+  if (patternCache2.size >= MAX_CACHE_SIZE3) {
+    const oldestKey = patternCache2.keys().next().value;
+    if (oldestKey !== void 0) patternCache2.delete(oldestKey);
+  }
+  const pattern = buildCapturingPattern(tokenize(formatStr), locale);
+  patternCache2.set(key, pattern);
+  return pattern;
+}
+function matchesFormat(formatStr, input, options = {}) {
+  try {
+    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 locale = options.locale ?? DEFAULT_LOCALE;
+    const pattern = getPattern2(formatStr, locale);
+    const match = pattern.regex.exec(input);
+    if (!match) return false;
+    for (const run of pattern.ambiguousRuns) {
+      const range = match.indices?.groups?.[run.groupName];
+      if (!range || enumerateValidSplits(input.slice(range[0], range[1]), run.tokens).length === 0) {
+        return false;
+      }
+    }
+    return true;
+  } catch (error) {
+    if (error instanceof TemporalFmtError) throw new Error(error.message);
+    throw error;
+  }
+}
+
+// src/legacy/index.ts
+function withLegacyErrors(operation) {
+  try {
+    return operation();
+  } catch (error) {
+    if (error instanceof TemporalFmtError) {
+      throw new Error(error.message);
+    }
+    throw error;
+  }
+}
+function toLegacySafeParseResult(result) {
+  return result.ok ? result : { ok: false, error: new Error(result.error.message) };
+}
+function format2(temporal, formatStr, options = {}) {
+  return withLegacyErrors(() => format(temporal, formatStr, options));
+}
+function formatToParts2(temporal, formatStr, options = {}) {
+  return withLegacyErrors(() => formatToParts(temporal, formatStr, options));
+}
+function compileFormat2(formatStr) {
+  const compiled = withLegacyErrors(() => compileFormat(formatStr));
+  return {
+    ...compiled,
+    format: (temporal, options) => withLegacyErrors(() => compiled.format(temporal, options)),
+    formatToParts: (temporal, options) => withLegacyErrors(() => compiled.formatToParts(temporal, options))
+  };
+}
+function parse2(formatStr, input, options = {}) {
+  return withLegacyErrors(() => parse(formatStr, input, options));
+}
+function safeParse2(formatStr, input, options = {}) {
+  return toLegacySafeParseResult(safeParse(formatStr, input, options));
+}
+function tryParse2(formatStr, input, options = {}) {
+  return tryParse(formatStr, input, options);
+}
+function parseToParts2(formatStr, input, options = {}) {
+  return withLegacyErrors(() => parseToParts(formatStr, input, options));
+}
+function compileParser2(formatStr, options = {}) {
+  const compiled = withLegacyErrors(() => compileParser(formatStr, options));
+  return {
+    ...compiled,
+    parse: (input, callOptions) => withLegacyErrors(() => compiled.parse(input, callOptions)),
+    safeParse: (input, callOptions) => toLegacySafeParseResult(compiled.safeParse(input, callOptions)),
+    tryParse: (input, callOptions) => compiled.tryParse(input, callOptions),
+    parseToParts: (input, callOptions) => withLegacyErrors(() => compiled.parseToParts(input, callOptions))
+  };
+}
+
 // src/formatDuration.ts
 var DURATION_UNITS = {
   y: { longSingular: "year", longPlural: "years", shortSingular: "yr", shortPlural: "yrs", field: "years", intlUnit: "year" },
@@ -2378,13 +2478,13 @@ var DURATION_UNITS = {
   S: { longSingular: "millisecond", longPlural: "milliseconds", shortSingular: "ms", shortPlural: "ms", field: "milliseconds", intlUnit: "millisecond" }
 };
 var DURATION_TOKEN_STRINGS = Object.keys(DURATION_UNITS).flatMap((single) => [single + single + single, single + single, single]).sort((a, b) => b.length - a.length);
-function tokenizeDuration(format2) {
+function tokenizeDuration(format3) {
   const pieces = [];
   let i = 0;
-  while (i < format2.length) {
-    const ch = format2[i];
+  while (i < format3.length) {
+    const ch = format3[i];
     if (ch === "'") {
-      if (format2[i + 1] === "'") {
+      if (format3[i + 1] === "'") {
         appendLiteral2(pieces, "'");
         i += 2;
         continue;
@@ -2392,9 +2492,9 @@ function tokenizeDuration(format2) {
       let j = i + 1;
       let literal = "";
       let closed = false;
-      while (j < format2.length) {
-        if (format2[j] === "'") {
-          if (format2[j + 1] === "'") {
+      while (j < format3.length) {
+        if (format3[j] === "'") {
+          if (format3[j + 1] === "'") {
             literal += "'";
             j += 2;
             continue;
@@ -2403,17 +2503,17 @@ function tokenizeDuration(format2) {
           j += 1;
           break;
         }
-        literal += format2[j];
+        literal += format3[j];
         j += 1;
       }
       if (!closed) {
-        throw new Error(`temporal-fmt: unterminated quote in duration format string "${format2}"`);
+        throw new Error(`temporal-fmt: unterminated quote in duration format string "${format3}"`);
       }
       appendLiteral2(pieces, literal);
       i = j;
       continue;
     }
-    const match = DURATION_TOKEN_STRINGS.find((tok) => format2.startsWith(tok, i));
+    const match = DURATION_TOKEN_STRINGS.find((tok) => format3.startsWith(tok, i));
     if (match) {
       const unit = match[0];
       const form = match.length === 1 ? "numeric" : match.length === 2 ? "short" : "long";
@@ -7222,8 +7322,18 @@ function translateDateFnsFormatString(formatStr) {
   isWeekend,
   isYesterday,
   isZonedDateTime,
+  legacyCompileFormat,
+  legacyCompileParser,
+  legacyFormat,
+  legacyFormatToParts,
+  legacyMatchesFormat,
+  legacyParse,
+  legacyParseToParts,
+  legacySafeParse,
+  legacyTryParse,
   listRegisteredGrammars,
   listTokens,
+  matchesFormat,
   max,
   mergeIntervals,
   mergeWithConfig,