temporal-fmt 0.9.80 → 0.9.82

package/dist/{chunk-Z245NHDT.js → chunk-4JMHI6E2.js}

@@ -1,7 +1,11 @@
 import {
   getTemporal,
   subscribeToTemporalChanges
-} from "./chunk-DFWTCRS3.js";
+} from "./chunk-JCJW2VOV.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-4JMHI6E2.js.map

package/dist/chunk-7XSIPXIR.js

@@ -0,0 +1,129 @@
+import {
+  compileFormat,
+  format,
+  formatToParts
+} from "./chunk-KWOTFJNY.js";
+import {
+  buildCapturingPattern,
+  compileParser,
+  enumerateValidSplits,
+  parse,
+  parseToParts,
+  safeParse,
+  tryParse
+} from "./chunk-W45J4E76.js";
+import {
+  tokenize
+} from "./chunk-AF3LHBDQ.js";
+import {
+  DEFAULT_LOCALE
+} from "./chunk-4JMHI6E2.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-7XSIPXIR.js.map

package/dist/chunk-7XSIPXIR.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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBA,IAAM,eAAe,oBAAI,IAA8B;AACvD,IAAM,iBAAiB;AAEvB,SAAS,WAAW,WAAmB,QAAgB;AACrD,QAAM,MAAM,SAAS,OAAO;AAC5B,QAAM,SAAS,aAAa,IAAI,GAAG;AACnC,MAAI,OAAQ,QAAO;AAEnB,MAAI,aAAa,QAAQ,gBAAgB;AACvC,UAAM,YAAY,aAAa,KAAK,EAAE,KAAK,EAAE;AAC7C,QAAI,cAAc,OAAW,cAAa,OAAO,SAAS;AAAA,EAC5D;AAEA,QAAM,UAAU,sBAAsB,SAAS,SAAS,GAAG,MAAM;AACjE,eAAa,IAAI,KAAK,OAAO;AAC7B,SAAO;AACT;AAMO,SAAS,cAAc,WAAmB,OAAe,UAAyB,CAAC,GAAY;AACpG,MAAI;AACF,QAAI,UAAU,SAAS,mBAAmB;AACxC,YAAM,IAAI;AAAA,QACR,yDAAyD,iBAAiB,oBAClE,UAAU,MAAM;AAAA,MAC1B;AAAA,IACF;AACA,UAAM,SAAS,QAAQ,UAAU;AACjC,UAAM,UAAU,WAAW,WAAW,MAAM;AAC5C,UAAM,QAAQ,QAAQ,MAAM,KAAK,KAAK;AACtC,QAAI,CAAC,MAAO,QAAO;AAEnB,eAAW,OAAO,QAAQ,eAAe;AACvC,YAAM,QAAQ,MAAM,SAAS,SAAS,IAAI,SAAS;AACnD,UAAI,CAAC,SAAS,qBAAqB,MAAM,MAAM,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,IAAI,MAAM,EAAE,WAAW,GAAG;AAC5F,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT,SAAS,OAAO;AACd,QAAI,iBAAiB,iBAAkB,OAAM,IAAI,MAAM,MAAM,OAAO;AACpE,UAAM;AAAA,EACR;AACF;;;ACzBA,SAAS,iBAAoB,WAAuB;AAClD,MAAI;AACF,WAAO,UAAU;AAAA,EACnB,SAAS,OAAO;AACd,QAAI,iBAAiB,kBAAkB;AACrC,YAAM,IAAI,MAAM,MAAM,OAAO;AAAA,IAC/B;AACA,UAAM;AAAA,EACR;AACF;AAEA,SAAS,wBAAwB,QAAkE;AACjG,SAAO,OAAO,KACV,SACA,EAAE,IAAI,OAAO,OAAO,IAAI,MAAM,OAAO,MAAM,OAAO,EAAE;AAC1D;AAEO,SAASA,QACd,UACA,WACA,UAAkC,CAAC,GAC3B;AACR,SAAO,iBAAiB,MAAM,OAAY,UAAU,WAAW,OAAO,CAAC;AACzE;AAEO,SAASC,eACd,UACA,WACA,UAAkC,CAAC,GAClB;AACjB,SAAO,iBAAiB,MAAM,cAAmB,UAAU,WAAW,OAAO,CAAC;AAChF;AAEO,SAASC,eAAc,WAAmC;AAC/D,QAAM,WAAW,iBAAiB,MAAM,cAAmB,SAAS,CAAC;AACrE,SAAO;AAAA,IACL,GAAG;AAAA,IACH,QAAQ,CAAC,UAAU,YAAY,iBAAiB,MAAM,SAAS,OAAO,UAAU,OAAO,CAAC;AAAA,IACxF,eAAe,CAAC,UAAU,YAAY,iBAAiB,MAAM,SAAS,cAAc,UAAU,OAAO,CAAC;AAAA,EACxG;AACF;AAEO,SAASC,OAAM,WAAmB,OAAe,UAAiC,CAAC,GAAwB;AAChH,SAAO,iBAAiB,MAAM,MAAW,WAAW,OAAO,OAAO,CAAC;AACrE;AAEO,SAASC,WACd,WACA,OACA,UAAiC,CAAC,GACX;AACvB,SAAO,wBAAwB,UAAe,WAAW,OAAO,OAAO,CAAC;AAC1E;AAEO,SAASC,UAAS,WAAmB,OAAe,UAAiC,CAAC,GAAwB;AACnH,SAAO,SAAc,WAAW,OAAO,OAAO;AAChD;AAEO,SAASC,cACd,WACA,OACA,UAAiC,CAAC,GACpB;AACd,SAAO,iBAAiB,MAAM,aAAkB,WAAW,OAAO,OAAO,CAAC;AAC5E;AAEO,SAASC,eAAc,WAAmB,UAAiC,CAAC,GAAyB;AAC1G,QAAM,WAAW,iBAAiB,MAAM,cAAmB,WAAW,OAAO,CAAC;AAC9E,SAAO;AAAA,IACL,GAAG;AAAA,IACH,OAAO,CAAC,OAAO,gBAAgB,iBAAiB,MAAM,SAAS,MAAM,OAAO,WAAW,CAAC;AAAA,IACxF,WAAW,CAAC,OAAO,gBAAgB,wBAAwB,SAAS,UAAU,OAAO,WAAW,CAAC;AAAA,IACjG,UAAU,CAAC,OAAO,gBAAgB,SAAS,SAAS,OAAO,WAAW;AAAA,IACtE,cAAc,CAAC,OAAO,gBAAgB,iBAAiB,MAAM,SAAS,aAAa,OAAO,WAAW,CAAC;AAAA,EACxG;AACF;","names":["format","formatToParts","compileFormat","parse","safeParse","tryParse","parseToParts","compileParser"]}

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

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

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

@@ -1,13 +1,13 @@
+import {
+  differenceInDays
+} from "./chunk-SC6ENLEB.js";
 import {
   DEFAULT_LOCALE
-} from "./chunk-Z245NHDT.js";
+} from "./chunk-4JMHI6E2.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-IEQCJPB5.js.map

package/dist/{chunk-DFWTCRS3.js → chunk-JCJW2VOV.js}

@@ -1,15 +1,18 @@
 // src/temporalProvider.ts
-var injectedTemporal;
-var onTemporalChanged = [];
+var TEMPORAL_PROVIDER_STATE = /* @__PURE__ */ Symbol.for("temporal-fmt.temporal-provider");
+var globalState = globalThis;
+var providerState = globalState[TEMPORAL_PROVIDER_STATE] ??= {
+  onTemporalChanged: []
+};
 function subscribeToTemporalChanges(listener) {
-  onTemporalChanged.push(listener);
+  providerState.onTemporalChanged.push(listener);
 }
 function setTemporal(temporal) {
-  injectedTemporal = temporal;
-  for (const listener of onTemporalChanged) listener();
+  providerState.injectedTemporal = temporal;
+  for (const listener of providerState.onTemporalChanged) listener();
 }
 function resolveTemporal() {
-  return injectedTemporal ?? globalThis.Temporal;
+  return providerState.injectedTemporal ?? globalThis.Temporal;
 }
 function getTemporal() {
   const temporal = resolveTemporal();
@@ -26,4 +29,4 @@ export {
   setTemporal,
   getTemporal
 };
-//# sourceMappingURL=chunk-DFWTCRS3.js.map
+//# sourceMappingURL=chunk-JCJW2VOV.js.map

package/dist/chunk-JCJW2VOV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/temporalProvider.ts"],"sourcesContent":["/*\n * Copyright 2026 DirazCoder\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// tsconfig here is lib: [\"ESNext\"] only, so there's no ambient Temporal\n// namespace type to lean on. everywhere else in the codebase we just read\n// fields off whatever Temporal-like object gets passed in (see TemporalLike\n// in tokens.ts) but this file is the one place that actually touches the\n// Temporal namespace itself — PlainDate.from and friends. parse() uses it\n// to build results, tokens.ts uses it to check native Intl<->Temporal\n// support. you can hand us your own implementation via setTemporal(), or\n// we just grab globalThis.Temporal if there is one\ninterface TemporalFactory {\n  from(fields: Record<string, number | string | undefined>, options?: { overflow?: 'constrain' | 'reject'; disambiguation?: 'compatible' | 'earlier' | 'later' | 'reject'; offset?: 'use' | 'ignore' | 'prefer' | 'reject' }): unknown;\n  // compare() is on the namespace, not instances (Temporal.PlainDate.compare).\n  // made optional since someone might hand us a stripped-down shim that\n  // doesn't bother implementing it\n  compare?(one: unknown, two: unknown): number;\n}\n\n// Instant doesn't use from(fields) like the others, it's\n// fromEpochMilliseconds / fromEpochNanoseconds. needs its own shape.\ninterface InstantFactory {\n  from(iso: string): unknown;\n  fromEpochMilliseconds(ms: number): unknown;\n  fromEpochMicroseconds(µs: number): unknown;\n  fromEpochNanoseconds(ns: bigint): unknown;\n}\n\n// Duration uses from(fields) too, but also has round() and compare()\ninterface DurationFactory extends TemporalFactory {\n  compare?(one: unknown, two: unknown): number;\n  prototype?: { round(options: unknown): unknown };\n}\n\n// PlainYearMonth / PlainMonthDay also just use from(fields) — same shape\n// as TemporalFactory really, kept as its own type so callers can narrow\nexport interface TemporalNamespace {\n  PlainDate: TemporalFactory;\n  PlainTime: TemporalFactory;\n  PlainDateTime: TemporalFactory;\n  ZonedDateTime: TemporalFactory;\n  Instant?: InstantFactory;\n  Duration?: DurationFactory;\n  PlainYearMonth?: TemporalFactory;\n  PlainMonthDay?: TemporalFactory;\n}\n\ninterface TemporalProviderState {\n  injectedTemporal?: TemporalNamespace;\n  onTemporalChanged: Array<() => void>;\n}\n\nconst TEMPORAL_PROVIDER_STATE = Symbol.for('temporal-fmt.temporal-provider');\nconst globalState = globalThis as unknown as Record<symbol, unknown>;\nconst providerState = (globalState[TEMPORAL_PROVIDER_STATE] ??= {\n  onTemporalChanged: [],\n}) as TemporalProviderState;\n\n// anything caching something tied to WHICH Temporal impl is active\n// (right now just tokens.ts's native-Intl probe) registers a listener\n// here so it knows to invalidate when setTemporal() swaps things out —\n// see setTemporal() below for why that matters. kept this as a plain\n// array instead of a full event emitter since all we need is \"call\n// everyone back, in order, no payload\" — didn't need unsubscribe either\nexport function subscribeToTemporalChanges(listener: () => void): void {\n  providerState.onTemporalChanged.push(listener);\n}\n\n/**\n * Explicitly hand temporal-fmt the Temporal implementation to use, instead\n * of relying on a global `Temporal`. Call this once, before your first\n * `format()`/`parse()`/`parseISO()`/etc.\n *\n * Call with no argument (or `undefined`) to clear the override and fall\n * back to `globalThis.Temporal` again.\n *\n * @example\n * import { Temporal } from 'temporal-polyfill';\n * import { setTemporal } from 'temporal-fmt';\n * setTemporal(Temporal);\n */\nexport function setTemporal(temporal?: TemporalNamespace): void {\n  providerState.injectedTemporal = temporal;\n  // tokens.ts caches its native-Intl probe result based on whatever\n  // Temporal was active the first time it ran. if that changes later\n  // (native -> polyfill, say) the cached result goes stale. so just reset\n  // everyone on any setTemporal() call — costs one extra probe re-run,\n  // worth it to not silently use a stale answer\n  for (const listener of providerState.onTemporalChanged) listener();\n}\n\nfunction resolveTemporal(): TemporalNamespace | undefined {\n  return providerState.injectedTemporal ?? (globalThis as unknown as { Temporal?: TemporalNamespace }).Temporal;\n}\n\nexport function getTemporal(): TemporalNamespace {\n  const temporal = resolveTemporal();\n  if (!temporal) {\n    throw new Error(\n      'temporal-fmt: parse() needs a Temporal implementation to construct its result. ' +\n      'Call setTemporal(Temporal) once at startup, or assign one to globalThis.Temporal ' +\n      '(native on Node 26+, or a polyfill like temporal-polyfill).'\n    );\n  }\n  return temporal;\n}\n"],"mappings":";AAiEA,IAAM,0BAA0B,uBAAO,IAAI,gCAAgC;AAC3E,IAAM,cAAc;AACpB,IAAM,gBAAiB,YAAY,uBAAuB,MAAM;AAAA,EAC9D,mBAAmB,CAAC;AACtB;AAQO,SAAS,2BAA2B,UAA4B;AACrE,gBAAc,kBAAkB,KAAK,QAAQ;AAC/C;AAeO,SAAS,YAAY,UAAoC;AAC9D,gBAAc,mBAAmB;AAMjC,aAAW,YAAY,cAAc,kBAAmB,UAAS;AACnE;AAEA,SAAS,kBAAiD;AACxD,SAAO,cAAc,oBAAqB,WAA2D;AACvG;AAEO,SAAS,cAAiC;AAC/C,QAAM,WAAW,gBAAgB;AACjC,MAAI,CAAC,UAAU;AACb,UAAM,IAAI;AAAA,MACR;AAAA,IAGF;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

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

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

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

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

package/dist/{chunk-WP7TBCTT.js → chunk-TIMSK72I.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-KWOTFJNY.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-TIMSK72I.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-5KP5H7X2.js → chunk-W45J4E76.js}

@@ -1,13 +1,13 @@
 import {
   applyParseNumbering,
   tokenize
-} from "./chunk-DMJWJTFY.js";
+} from "./chunk-AF3LHBDQ.js";
 import {
   DEFAULT_LOCALE
-} from "./chunk-Z245NHDT.js";
+} from "./chunk-4JMHI6E2.js";
 import {
   getTemporal
-} from "./chunk-DFWTCRS3.js";
+} from "./chunk-JCJW2VOV.js";
 import {
   MAX_FORMAT_LENGTH,
   MAX_INPUT_LENGTH
@@ -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-W45J4E76.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.cjs

@@ -29,13 +29,16 @@ __export(format_exports, {
 module.exports = __toCommonJS(format_exports);
 
 // src/temporalProvider.ts
-var injectedTemporal;
-var onTemporalChanged = [];
+var TEMPORAL_PROVIDER_STATE = /* @__PURE__ */ Symbol.for("temporal-fmt.temporal-provider");
+var globalState = globalThis;
+var providerState = globalState[TEMPORAL_PROVIDER_STATE] ??= {
+  onTemporalChanged: []
+};
 function subscribeToTemporalChanges(listener) {
-  onTemporalChanged.push(listener);
+  providerState.onTemporalChanged.push(listener);
 }
 function resolveTemporal() {
-  return injectedTemporal ?? globalThis.Temporal;
+  return providerState.injectedTemporal ?? globalThis.Temporal;
 }
 function getTemporal() {
   const temporal = resolveTemporal();