temporal-fmt 0.9.2 → 0.9.4

package/dist/parse.cjs

@@ -1,74 +1,1801 @@
-"use strict";var pe=Object.defineProperty;var Ge=Object.getOwnPropertyDescriptor;var Ke=Object.getOwnPropertyNames;var We=Object.prototype.hasOwnProperty;var Qe=(e,t)=>{for(var n in t)pe(e,n,{get:t[n],enumerable:!0})},je=(e,t,n,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of Ke(t))!We.call(e,o)&&o!==n&&pe(e,o,{get:()=>t[o],enumerable:!(r=Ge(t,o))||r.enumerable});return e};var qe=e=>je(pe({},"__esModule",{value:!0}),e);var _t={};Qe(_t,{compileParser:()=>At,parse:()=>de,parseToParts:()=>Ze,safeParse:()=>ze,tryParse:()=>Ve});module.exports=qe(_t);var Be,Je=[];function De(e){Je.push(e)}function et(){return Be??globalThis.Temporal}function se(){let e=et();if(!e)throw new Error("temporal-fmt: parse() needs a Temporal implementation to construct its result. Call setTemporal(Temporal) once at startup, or assign one to globalThis.Temporal (native on Node 26+, or a polyfill like temporal-polyfill).");return e}var E=class extends Error{code;input;format;token;position;expected;actual;reason;constructor(t,n){super(t),this.name="TemporalFmtError",this.code=n.code,this.input=n.input,this.format=n.format,this.token=n.token,this.position=n.position,this.expected=n.expected,this.actual=n.actual,this.reason=n.reason;let r=Error.captureStackTrace;typeof r=="function"&&r(this,this.constructor)}toJSON(){return{name:this.name,message:this.message,code:this.code,input:this.input,format:this.format,token:this.token,position:this.position,expected:this.expected,actual:this.actual,reason:this.reason}}},S=class extends E{constructor(t){let{message:n,...r}=t;super(n??`format string "${t.format??""}" has a syntax error${t.reason?`: ${t.reason}`:""}.`,{code:"FORMAT_SYNTAX_ERROR",...r}),this.name="FormatSyntaxError"}},I=class extends E{constructor(t){let{message:n,...r}=t;super(n??`token "${t.token??""}" is not a recognized temporal-fmt token${t.format?` in format string "${t.format}"`:""}.`,{code:"UNKNOWN_TOKEN",...r}),this.name="UnknownTokenError"}},T=class extends E{constructor(t){let{message:n,...r}=t;super(n??`input "${t.input??""}" does not match format "${t.format??""}"${t.reason?`: ${t.reason}`:""}.`,{code:"PARSE_MISMATCH",...r}),this.name="ParseMismatchError"}},L=class extends E{constructor(t){let{message:n,...r}=t;super(n??`input "${t.input??""}" does not describe a valid date${t.reason?`: ${t.reason}`:""}.`,{code:"INVALID_DATE",...r}),this.name="InvalidDateError"}};/* c8 ignore start @preserve -- InvalidTimeError is part of the public
-   error-class surface (exported from index.ts, code 'INVALID_TIME')
-   but nothing in this package constructs one. Investigated wiring it
-   in the same way InvalidTimeZoneError was just wired (see parse.ts's
-   zzz-validation loop): checked whether hour/minute/second have a
-   post-match semantic range check the way zone ids do. They don't —
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/parse.ts
+var parse_exports = {};
+__export(parse_exports, {
+  compileParser: () => compileParser,
+  parse: () => parse,
+  parseToParts: () => parseToParts,
+  safeParse: () => safeParse,
+  tryParse: () => tryParse
+});
+module.exports = __toCommonJS(parse_exports);
+
+// src/temporalProvider.ts
+var injectedTemporal;
+var onTemporalChanged = [];
+function subscribeToTemporalChanges(listener) {
+  onTemporalChanged.push(listener);
+}
+function resolveTemporal() {
+  return injectedTemporal ?? globalThis.Temporal;
+}
+function getTemporal() {
+  const temporal = resolveTemporal();
+  if (!temporal) {
+    throw new Error(
+      "temporal-fmt: parse() needs a Temporal implementation to construct its result. Call setTemporal(Temporal) once at startup, or assign one to globalThis.Temporal (native on Node 26+, or a polyfill like temporal-polyfill)."
+    );
+  }
+  return temporal;
+}
+
+// src/errors.ts
+var TemporalFmtError = class extends Error {
+  code;
+  input;
+  format;
+  token;
+  position;
+  expected;
+  actual;
+  reason;
+  constructor(message, fields) {
+    super(message);
+    this.name = "TemporalFmtError";
+    this.code = fields.code;
+    this.input = fields.input;
+    this.format = fields.format;
+    this.token = fields.token;
+    this.position = fields.position;
+    this.expected = fields.expected;
+    this.actual = fields.actual;
+    this.reason = fields.reason;
+    const capture = Error.captureStackTrace;
+    if (typeof capture === "function") {
+      capture(this, this.constructor);
+    }
+  }
+  // lets callers just call err.toJSON() for logging. plain Error doesn't
+  // serialize its non-enumerable fields on its own, so this picks them
+  // up explicitly
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      input: this.input,
+      format: this.format,
+      token: this.token,
+      position: this.position,
+      expected: this.expected,
+      actual: this.actual,
+      reason: this.reason
+    };
+  }
+};
+var FormatSyntaxError = class extends TemporalFmtError {
+  constructor(fields) {
+    const { message, ...rest } = fields;
+    super(
+      message ?? `format string "${fields.format ?? ""}" has a syntax error${fields.reason ? `: ${fields.reason}` : ""}.`,
+      { code: "FORMAT_SYNTAX_ERROR", ...rest }
+    );
+    this.name = "FormatSyntaxError";
+  }
+};
+var UnknownTokenError = class extends TemporalFmtError {
+  constructor(fields) {
+    const { message, ...rest } = fields;
+    super(
+      message ?? `token "${fields.token ?? ""}" is not a recognized temporal-fmt token${fields.format ? ` in format string "${fields.format}"` : ""}.`,
+      { code: "UNKNOWN_TOKEN", ...rest }
+    );
+    this.name = "UnknownTokenError";
+  }
+};
+var ParseMismatchError = class extends TemporalFmtError {
+  constructor(fields) {
+    const { message, ...rest } = fields;
+    super(
+      message ?? `input "${fields.input ?? ""}" does not match format "${fields.format ?? ""}"${fields.reason ? `: ${fields.reason}` : ""}.`,
+      { code: "PARSE_MISMATCH", ...rest }
+    );
+    this.name = "ParseMismatchError";
+  }
+};
+var InvalidDateError = class extends TemporalFmtError {
+  constructor(fields) {
+    const { message, ...rest } = fields;
+    super(
+      message ?? `input "${fields.input ?? ""}" does not describe a valid date${fields.reason ? `: ${fields.reason}` : ""}.`,
+      { code: "INVALID_DATE", ...rest }
+    );
+    this.name = "InvalidDateError";
+  }
+};
+/* c8 ignore start @preserve -- InvalidTimeError is part of the public
+   error-class surface (exported from index.ts, code 'INVALID_TIME') but
+   nothing in this package actually constructs one. went and checked
+   whether it could get wired in the same way InvalidTimeZoneError just
+   was (see parse.ts's zzz-validation loop) — does hour/minute/second have
+   a post-match semantic range check the way zone ids do? nope.
    pattern.ts's regex fragments for HH/H/hh/h/mm/m/ss/s already enforce
-   their valid ranges at the regex level (e.g. HH is '(?:[01]\d|2[0-3])',
-   which can't match "99" in the first place), so an out-of-range time
-   is rejected as a plain shape mismatch before any semantic check
-   could run. There's no live gap to hook this into without inventing a
-   redundant check purely to give this class a body. Left unconstructed
-   until the library actually has a real invalid-time case to report. *//* c8 ignore stop @preserve */var F=class extends E{constructor(t){let{message:n,...r}=t;super(n??`offset "${t.actual??""}" is invalid${t.reason?`: ${t.reason}`:""}.`,{code:"INVALID_OFFSET",...r}),this.name="InvalidOffsetError"}},G=class extends E{constructor(t){let{message:n,...r}=t;super(n??`time zone "${t.actual??""}" is not a recognized IANA time zone or fixed offset${t.reason?`: ${t.reason}`:""}.`,{code:"INVALID_TIME_ZONE",...r}),this.name="InvalidTimeZoneError"}};/* c8 ignore start @preserve -- InvalidCalendarError is part of the
+   their valid ranges right at the regex level (e.g. HH is
+   '(?:[01]\d|2[0-3])', which literally can't match "99"), so an
+   out-of-range time just gets rejected as a plain shape mismatch before
+   any semantic check would even run. no live gap to hook this into
+   without inventing a redundant check purely to give this class a body.
+   leaving it unconstructed until the library actually hits a real
+   invalid-time case worth reporting */
+/* c8 ignore stop @preserve */
+var InvalidOffsetError = class extends TemporalFmtError {
+  constructor(fields) {
+    const { message, ...rest } = fields;
+    super(
+      message ?? `offset "${fields.actual ?? ""}" is invalid${fields.reason ? `: ${fields.reason}` : ""}.`,
+      { code: "INVALID_OFFSET", ...rest }
+    );
+    this.name = "InvalidOffsetError";
+  }
+};
+var InvalidTimeZoneError = class extends TemporalFmtError {
+  constructor(fields) {
+    const { message, ...rest } = fields;
+    super(
+      message ?? `time zone "${fields.actual ?? ""}" is not a recognized IANA time zone or fixed offset${fields.reason ? `: ${fields.reason}` : ""}.`,
+      { code: "INVALID_TIME_ZONE", ...rest }
+    );
+    this.name = "InvalidTimeZoneError";
+  }
+};
+/* c8 ignore start @preserve -- InvalidCalendarError is part of the
    public error-class surface (exported from index.ts, code
-   'INVALID_CALENDAR') but nothing in this package constructs one.
-   Checked for a wiring opportunity the same way InvalidTimeZoneError
-   got one: there's no user-supplied calendar identifier anywhere in
-   the library to validate against a supported list. resolveCalendar()
+   'INVALID_CALENDAR') but same story as InvalidTimeError above — nothing
+   in this package constructs one. checked for a wiring opportunity the
+   same way: there's no user-supplied calendar identifier anywhere in the
+   library that we'd validate against a supported list. resolveCalendar()
    in parse.ts derives the calendar entirely from Intl's own resolution
-   of the locale string — it's never handed an arbitrary "calendar"
-   value a caller could get wrong. There's no live input to reject.
-   Left unconstructed until the library actually accepts a calendar
-   parameter that could be invalid. *//* c8 ignore stop @preserve */var R=class extends E{constructor(t){let{message:n,...r}=t;super(n??`input "${t.input??""}" is ambiguous${t.reason?`: ${t.reason}`:""}.`,{code:"AMBIGUOUS_INPUT",...r}),this.name="AmbiguousInputError"}},N=class extends E{constructor(t){let{message:n,...r}=t;super(n??`locale "${t.actual??""}" is not a valid BCP-47 tag${t.reason?`: ${t.reason}`:""}.`,{code:"INVALID_LOCALE",...r}),this.name="InvalidLocaleError"}};/* c8 ignore start @preserve -- unreachable from the current test suite,
-   see rationale above */function Me(e,t){let n=e.message;if(/unknown token|isn't a recognized token/.test(n))return new I({input:t.input,format:t.format,reason:n});if(/ambiguous/i.test(n))return new R({input:t.input,format:t.format,reason:n});if(/offset/.test(n)&&/out of range|exceeds|doesn't match the shape/i.test(n))return new F({input:t.input,format:t.format,reason:n});if(/no valid pattern matches/i.test(n))return new T({input:t.input,format:t.format,reason:n});if(/doesn't describe a valid date\/time|incomplete date|weekday token|quarter token/.test(n))return new L({input:t.input,format:t.format,reason:n});let r=n.toLowerCase();return r.includes("locale")&&(r.includes("produced no")||r.includes("not a valid"))||r.includes("cutoffs must be")?new N({input:t.input,format:t.format,reason:n}):/format string exceeds maximum length|input exceeds maximum length|unterminated quote|isn't a recognized token/i.test(n)?new S({input:t.input,format:t.format,reason:n}):new T({input:t.input,format:t.format,reason:n})}/* c8 ignore stop @preserve */var Le=new Map;var tt=[];function Oe(e){tt.push(e)}function Q(e){return e.replace(/_/g,"-")}var K=new Map,nt=500;function C(e){let t=K.get(e);if(t!==void 0)return t;let n;try{n=new Intl.Locale(e.replace(/_/g,"-")).toString().toLowerCase()}catch{n=e}if(K.size>=nt){let r=K.keys().next().value;r!==void 0&&K.delete(r)}return K.set(e,n),n}function he(e){try{new Intl.Locale(Q(e))}catch{throw new N({actual:e,reason:"not a valid BCP-47 locale tag"})}}var W=new Map,rt=500;function z(e,t,n){let r=e.formatToParts(t),o=r.findIndex(p=>p.type===n);/* c8 ignore start @preserve -- defensive guard against a real but
-   unreproducible failure mode: an Intl implementation that omits the
-   requested part type entirely for some locale. Checked every locale
-   with unusual dayPeriod/weekday/month rendering available in this
-   runtime's ICU data (ja-JP, zh-CN, th-TH, he-IL, ar-SA, ko-KR, fa-IR)
-   against the exact formatter options getLocaleVocab uses (notably
-   hour12: true for the dayPeriod formatter, which is what makes every
-   locale here actually emit a dayPeriod part — omitting it is what
-   produced a false "gap" during investigation). None omit their part
-   on this runtime. A different ICU version or a non-Node Intl
-   implementation could plausibly behave differently, so this stays a
-   real check rather than an assertion. *//* c8 ignore start @preserve */if(o===-1)throw new N({message:`temporal-fmt: locale produced no "${n}" part while building match vocabulary.`});/* c8 ignore stop @preserve */let a=r[o].value,s=r[o-1],m=r[o+1];return s?.type==="literal"&&!/\s/.test(s.value)&&(a=s.value+a),m?.type==="literal"&&!/\s/.test(m.value)&&(a=a+m.value),a}function ie(e,t,n){let r=new Map;for(let o=0;o<e.length;o++){let a=r.get(e[o]);if(a!==void 0)throw new Error(`temporal-fmt: locale "${n}" renders ${t} index ${a} and ${o} identically ("${e[o]}"). parse() can't reliably tell these apart for this locale/token, so this combination isn't supported.`);r.set(e[o],o)}}function M(e){let t=C(e);return Le.get(t)}function V(e){he(e);let t=C(e),n=Le.get(t);if(n)return n;let r=W.get(t);if(r)return r;let o=Q(e),a=new Intl.DateTimeFormat(o,{month:"long",timeZone:"UTC"}),s=new Intl.DateTimeFormat(o,{month:"short",timeZone:"UTC"}),m=[],p=[];for(let y=0;y<12;y++){let b=new Date(Date.UTC(2020,y,1));m.push(z(a,b,"month")),p.push(z(s,b,"month"))}ie(m,"MMMM month",e),ie(p,"MMM month",e);let l=new Intl.DateTimeFormat(o,{weekday:"long",timeZone:"UTC"}),c=new Intl.DateTimeFormat(o,{weekday:"short",timeZone:"UTC"}),i=[],d=[];for(let y=0;y<7;y++){let b=new Date(Date.UTC(2024,0,1+y));i.push(z(l,b,"weekday")),d.push(z(c,b,"weekday"))}ie(i,"EEEE weekday",e),ie(d,"EEE weekday",e);let u=new Intl.DateTimeFormat(o,{hour:"numeric",hour12:!0,timeZone:"UTC"}),h=z(u,new Date(Date.UTC(2020,0,1,1)),"dayPeriod"),k=z(u,new Date(Date.UTC(2020,0,1,13)),"dayPeriod"),$=[...new Set([h,k])],O={monthLong:m,monthShort:p,weekdayLong:i,weekdayShort:d,dayPeriod:$};if(W.size>=rt){let y=W.keys().next().value;y!==void 0&&W.delete(y)}return W.set(t,O),O}var ot=[0,31,59,90,120,151,181,212,243,273,304,334];function Pe(e){return e%4===0&&e%100!==0||e%400===0}function j(e){return Pe(e)?366:365}function q(e,t,n){let r=ot[t-1]+n;return t>2&&Pe(e)&&(r+=1),r}var ye=2e3;function at(e){let t=0;if(e>=ye)for(let r=ye;r<e;r++)t+=j(r);else for(let r=e;r<ye;r++)t-=j(r);return((5+t)%7+7)%7+1}function we(e,t,n,r){let a=q(e,t,n)+(4-r),s,m;a<1?(s=e-1,m=a+j(s)):a>j(e)?(s=e+1,m=a-j(e)):(s=e,m=a);let l=1+(4-at(s)+7)%7,c=1+Math.floor((m-l)/7);return{isoYear:s,week:c}}function g(e,t){let n=e<0,r=String(Math.abs(e)).padStart(t,"0");return n?"-"+r:r}g.fraction=function(t,n){let r=t.millisecond*1e6+(t.microsecond??0)*1e3+(t.nanosecond??0);return g(r,9).slice(0,n)};var me="en-US",B=new Map,st=500;function Ie(e,t){let n=JSON.stringify([C(e),t]),r=B.get(n);if(r)return r;if(B.size>=st){let o=B.keys().next().value;o!==void 0&&B.delete(o)}try{r=new Intl.DateTimeFormat(Q(e),t)}catch(o){throw new N({actual:e,reason:o.message})}return B.set(n,r),r}var J;De(()=>{J=void 0});function it(){if(J===void 0){J=!1;try{let e=se();new Intl.DateTimeFormat("en-US",{day:"numeric"}).formatToParts(e.PlainDate.from({year:1970,month:1,day:1})),J=!0}catch{}}return J}function ee(e,t,n,r){let o=e?.calendarId,a={...n,calendar:o&&o!=="iso8601"?o:"gregory"},s=e.toLocaleString;if(typeof s!="function"||s===Object.prototype.toLocaleString)throw new Error(`temporal-fmt: locale-aware part "${r}" needs a value that implements toLocaleString (a real Temporal object). A plain field bag cannot render locale-aware names \u2014 pass a Temporal.PlainDate/PlainDateTime/ZonedDateTime.`);if(!it())try{return s.call(e,Q(t),a)}catch(y){throw y instanceof RangeError?new N({actual:t,reason:y.message}):y}let{toInstant:m,timeZoneId:p}=e,l=typeof m=="function"&&typeof p=="string",c=l?e.toInstant():e,i={...a,...l?{timeZone:p}:{}},u=Ie(t,i).formatToParts(c),h=u.findIndex(y=>y.type===r);if(h===-1)throw new Error(`temporal-fmt: locale "${t}" produced no "${r}" part for this token. This usually means the Temporal object is missing the field the token needs.`);let k=u[h].value,$=u[h-1],O=u[h+1];return $?.type==="literal"&&!/\s/.test($.value)&&(k=$.value+k),O?.type==="literal"&&!/\s/.test(O.value)&&(k=k+O.value),k}function mt(e,t){let n=M(t);if(n)return e<12?n.dayPeriod[0]:n.dayPeriod[1];let r=new Date(Date.UTC(1970,0,1,e)),a=Ie(t,{hour:"numeric",hour12:!0,timeZone:"UTC"}).formatToParts(r).find(s=>s.type==="dayPeriod");if(!a)throw new Error(`temporal-fmt: locale "${t}" produced no "dayPeriod" part for token "a".`);return a.value}function v(e,t,n,r,o,a){return o&&a!==void 0&&a>=0&&a<o.length?o[a]:ee(e,t,n,r)}function Z(e,t){if(e==="+00:00"&&(t==="X"||t==="XX"||t==="XXX"))return"Z";let n=e[0],r=e.slice(1,3),o=e.slice(4,6);switch(t){case"X":case"x":return o==="00"?`${n}${r}`:`${n}${r}${o}`;case"XX":case"xx":return`${n}${r}${o}`;case"XXX":case"xxx":return`${n}${r}:${o}`}}var Fe=[["yyyy",e=>g(e.year,4),"year"],["yy",e=>{if(e.year<0)throw new Error(`temporal-fmt: token "yy" doesn't support negative years (got ${e.year}), since truncating to 2 digits would make it indistinguishable from a positive year. Use "yyyy" instead.`);return g(e.year%100,2)},"year"],["MMMM",(e,t)=>{let n=M(t);return v(e,t,{month:"long"},"month",n?.monthLong,e.month-1)},"month"],["MMM",(e,t)=>{let n=M(t);return v(e,t,{month:"short"},"month",n?.monthShort,e.month-1)},"month"],["MM",e=>g(e.month,2),"month"],["M",e=>String(e.month),"month"],["dd",e=>g(e.day,2),"day"],["d",e=>String(e.day),"day"],["EEEE",(e,t)=>{let n=M(t);return v(e,t,{weekday:"long"},"weekday",n?.weekdayLong,e.dayOfWeek-1)},"dayOfWeek"],["EEE",(e,t)=>{let n=M(t);return v(e,t,{weekday:"short"},"weekday",n?.weekdayShort,e.dayOfWeek-1)},"dayOfWeek"],["HH",e=>g(e.hour,2),"hour"],["H",e=>String(e.hour),"hour"],["hh",e=>g(e.hour%12||12,2),"hour"],["h",e=>String(e.hour%12||12),"hour"],["mm",e=>g(e.minute,2),"minute"],["m",e=>String(e.minute),"minute"],["ss",e=>g(e.second,2),"second"],["s",e=>String(e.second),"second"],["SSSSSSSSS",e=>g.fraction(e,9),"millisecond"],["SSSSSSSS",e=>g.fraction(e,8),"millisecond"],["SSSSSSS",e=>g.fraction(e,7),"millisecond"],["SSSSSS",e=>g.fraction(e,6),"millisecond"],["SSSSS",e=>g.fraction(e,5),"millisecond"],["SSSS",e=>g.fraction(e,4),"millisecond"],["SSS",e=>g.fraction(e,3),"millisecond"],["SS",e=>g.fraction(e,2),"millisecond"],["S",e=>g.fraction(e,1),"millisecond"],["a",(e,t)=>mt(e.hour,t),"hour"],["zzz",e=>e.timeZoneId,"timeZoneId"],["xxx",e=>Z(e.offset,"xxx"),"offset"],["xx",e=>Z(e.offset,"xx"),"offset"],["X",e=>Z(e.offset,"X"),"offset"],["XX",e=>Z(e.offset,"XX"),"offset"],["XXX",e=>Z(e.offset,"XXX"),"offset"],["x",e=>Z(e.offset,"x"),"offset"],["do",e=>{let t=e.day,n=t%10,r=t%100;return r>=11&&r<=13?t+"th":n===1?t+"st":n===2?t+"nd":n===3?t+"rd":t+"th"},"day"],["Q",e=>String(Math.ceil(e.month/3)),"month"],["QQQ",e=>"Q"+Math.ceil(e.month/3),"month"],["ww",e=>{let{week:t}=we(e.year,e.month,e.day,e.dayOfWeek);return g(t,2)},"dayOfWeek"],["RRRR",e=>{let{isoYear:t}=we(e.year,e.month,e.day,e.dayOfWeek);return g(t,4)},"dayOfWeek"],["D",e=>String(q(e.year,e.month,e.day)),"day"],["DD",e=>g(q(e.year,e.month,e.day),2),"day"],["DDD",e=>g(q(e.year,e.month,e.day),3),"day"],["LLLL",(e,t)=>{let n=M(t);return v(e,t,{month:"long"},"month",n?.monthLong,e.month-1)},"month"],["LLL",(e,t)=>{let n=M(t);return v(e,t,{month:"short"},"month",n?.monthShort,e.month-1)},"month"],["cccc",(e,t)=>{let n=M(t);return v(e,t,{weekday:"long"},"weekday",n?.weekdayLong,e.dayOfWeek-1)},"dayOfWeek"],["ccc",(e,t)=>{let n=M(t);return v(e,t,{weekday:"short"},"weekday",n?.weekdayShort,e.dayOfWeek-1)},"dayOfWeek"],["GGGG",(e,t)=>ee(e,t,{era:"long"},"era"),"year"],["G",(e,t)=>ee(e,t,{era:"short"},"era"),"year"],["zzzz",(e,t)=>ee(e,t,{timeZoneName:"longGeneric"},"timeZoneName"),"timeZoneId"],["z",(e,t)=>ee(e,t,{timeZoneName:"short"},"timeZoneName"),"timeZoneId"]];var ct=Fe.map(([e])=>e).sort((e,t)=>t.length-e.length);function ve(e){let t=[],n=0;for(;n<e.length;){let r=e[n];if(r==="'"){if(e[n+1]==="'"){Se(t,"'"),n+=2;continue}let a=n+1,s="",m=!1;for(;a<e.length;){if(e[a]==="'"){if(e[a+1]==="'"){s+="'",a+=2;continue}m=!0,a+=1;break}s+=e[a],a+=1}if(!m)throw new S({format:e,message:`temporal-fmt: unterminated quote in format string "${e}"`});Se(t,s),n=a;continue}let o=ct.find(a=>e.startsWith(a,n));if(o){let a=o[o.length-1];if(e[n+o.length]===a){let s=n+o.length;for(;e[s]===a;)s+=1;throw new I({format:e,token:e.slice(n,s),message:`temporal-fmt: "${e.slice(n,s)}" in format string "${e}" isn't a recognized token \u2014 did you mean "${o}"?`})}t.push({kind:"token",value:o}),n+=o.length;continue}Se(t,r),n+=1}return t}function Se(e,t){let n=e[e.length-1];n&&n.kind==="literal"?n.value+=t:e.push({kind:"literal",value:t})}function ut(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function te(e,t=!1){let n=e.map(ut);return t?`(?:${n.map(dt).join("|")})`:`(?:${n.join("|")})`}function dt(e){return e.replace(/[a-zA-Z]/g,t=>`[${t.toLowerCase()}${t.toUpperCase()}]`)}var lt="(?:UTC|[+-]\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{1,9})?)?|[A-Za-z_]+(?:[+-]\\d{1,2})?(?:\\/[A-Za-z0-9_+-]+)*)",gt={X:"(?:Z|[+-]\\d{2}(?:\\d{2})?)",XX:"(?:Z|[+-]\\d{4})",XXX:"(?:Z|[+-]\\d{2}:\\d{2})",x:"[+-]\\d{2}(?:\\d{2})?",xx:"[+-]\\d{4}",xxx:"[+-]\\d{2}:\\d{2}"};function ft(){return lt}var ce;function pt(){return ce||(ce=new Set(Intl.supportedValuesOf("timeZone")),ce.add("UTC")),ce}var ht=/^[+-]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;function ke(e){return ht.test(e)||pt().has(e)}var yt={yy:"\\d{2}",MM:"(?:0[1-9]|1[0-2])",M:"(?:1[0-2]|[1-9])",dd:"(?:0[1-9]|[12]\\d|3[01])",d:"(?:[12]\\d|3[01]|[1-9])",HH:"(?:[01]\\d|2[0-3])",H:"(?:1\\d|2[0-3]|[0-9])",hh:"(?:0[1-9]|1[0-2])",h:"(?:1[0-2]|[1-9])",mm:"(?:[0-5]\\d)",m:"(?:[1-5]\\d|[0-9])",ss:"(?:[0-5]\\d)",s:"(?:[1-5]\\d|[0-9])",SSSSSSSSS:"\\d{9}",SSSSSSSS:"\\d{8}",SSSSSSS:"\\d{7}",SSSSSS:"\\d{6}",SSSSS:"\\d{5}",SSSS:"\\d{4}",SSS:"\\d{3}",SS:"\\d{2}",S:"\\d",Q:"[1-4]"},wt="Q[1-4]",St=new Set(["do","ww","RRRR","D","DD","DDD","LLLL","LLL","cccc","ccc","GGGG","G","zzzz","z"]),kt="-?\\d{4}",bt="-?\\d{4,}",be=new Set(["yyyy","yy","MM","M","dd","d","HH","H","hh","h","mm","m","ss","s","SSSSSSSSS","SSSSSSSS","SSSSSSS","SSSSSS","SSSSS","SSSS","SSS","SS","S"]);function ue(e,t,n){if(e==="yyyy")return n!==void 0&&be.has(n)?kt:bt;let r=yt[e];if(r)return r;if(e==="QQQ")return wt;if(St.has(e))throw new I({token:e,message:`temporal-fmt: token "${e}" 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").`});let o=V(t);switch(e){case"MMMM":return te(o.monthLong);case"MMM":return te(o.monthShort);case"EEEE":return te(o.weekdayLong);case"EEE":return te(o.weekdayShort);case"a":return te(o.dayPeriod,!0);case"zzz":return ft();case"X":case"XX":case"XXX":case"x":case"xx":case"xxx":return gt[e];default:throw new I({token:e,message:`temporal-fmt: unknown token "${e}"`})}}var Ae=new Set(["M","d","H","h","m","s"]),xt={M:[{digits:1,min:1,max:9},{digits:2,min:10,max:12}],d:[{digits:1,min:1,max:9},{digits:2,min:10,max:31}],H:[{digits:1,min:0,max:9},{digits:2,min:10,max:23}],h:[{digits:1,min:1,max:9},{digits:2,min:10,max:12}],m:[{digits:1,min:0,max:9},{digits:2,min:10,max:59}],s:[{digits:1,min:0,max:9},{digits:2,min:10,max:59}]};function xe(e,t){let n=new Map;function r(o,a){let s=`${o}:${a}`,m=n.get(s);if(m)return m;if(o===t.length){let i=a===e.length?[[]]:[];return n.set(s,i),i}let p=t[o],l=xt[p];/* c8 ignore start @preserve -- defensive guard, not reachable through
-   the public API. enumerateValidSplits's only caller (parse.ts, both
-   call sites) passes run.tokens straight from
-   pattern.ambiguousRuns, which parsePattern.ts only ever populates
-   with tokens already checked against UNPADDED_NUMERIC_TOKENS — the
-   exact same key set as UNPADDED_NUMERIC_RANGES. There's no path
-   where a token reaches here without having already passed that
-   check. */if(!l)throw new Error(`temporal-fmt: internal error \u2014 "${p}" is not an unpadded numeric token`);/* c8 ignore stop @preserve */let c=[];for(let{digits:i,min:d,max:u}of l){if(a+i>e.length)continue;let h=e.slice(a,a+i);if(i===2&&h[0]==="0")continue;let k=Number(h);if(!(k<d||k>u)){for(let $ of r(o+1,a+i))if(c.push([k,...$]),c.length===2)break;if(c.length===2)break}}return n.set(s,c),c}return r(0,0)}function Et(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}var _e=12;function Tt(e){return Math.ceil(Math.log2(Math.max(e,1)))}function Ee(e){return e===void 0?!1:e.kind==="literal"?/^[0-9]/.test(e.value):be.has(e.value)}function Ce(e,t){let n=[],r=[],o="",a=0,s=0,m={names:[],tokens:[]},p=l=>{if(m.tokens.length===1){let c=m.names[0],i=m.tokens[0];o+=`(?<${c}>${ue(i,t)})`,Ee(l)&&(s+=1)}else if(m.tokens.length>=2){let c=`r${a++}`,i=m.tokens.length;o+=`(?<${c}>\\d{${i},${i*2}})`,r.push({groupName:c,groupNames:m.names,tokens:m.tokens}),Ee(l)&&(s+=Tt(i+1))}m={names:[],tokens:[]}};for(let[l,c]of e.entries()){if(c.kind==="literal"){p(c),o+=Et(c.value);continue}if(Ae.has(c.value)){let h=`g${a++}`;n.push({name:h,token:c.value}),m.names.push(h),m.tokens.push(c.value);continue}p(c);let i=`g${a++}`;n.push({name:i,token:c.value});let d=e[l+1],u=d?.kind==="token"?d.value:void 0;c.value==="yyyy"&&u===void 0&&Ee(d)?o+=`(?<${i}>${ue(c.value,t,"M")})`:o+=`(?<${i}>${ue(c.value,t,u)})`}if(p(void 0),s>_e)throw new S({reason:`format string has too many variable-width numeric tokens glued to digit-consuming neighbors (ambiguity score ${s} > ${_e}). This shape makes the regex engine backtrack exponentially on near-miss input. Add a non-digit separator between these tokens (e.g. "-" or " ") or use their padded forms (MM/dd/HH/mm/ss).`});return{regex:new RegExp(`^(?:${o})$`,"ud"),groups:n,ambiguousRuns:r}}var $t=new Set(["latn","arab","deva","beng","guru","gujr","orya","tamldec","telu","knda","mlym","fullwide","hanidec"]),Xe=new Map;function Nt(e){let t=Xe.get(e);if(t)return t;/* c8 ignore start @preserve -- dead by construction, not just
-   untested: both callers (convertDigits, convertDigitsToAscii) already
-   return early on system === 'latn' before calling getDigitMap at all,
-   so this function is never invoked with 'latn'. Kept as a defensive
-   fallback rather than trusting that stays true for any future
-   caller. */if(e==="latn"){t={};for(let n=0;n<10;n++)t[String(n)]=String(n)}else{/* c8 ignore stop @preserve */let n=new Intl.NumberFormat("en-US-u-nu-"+e,{useGrouping:!1});t={};for(let r=0;r<10;r++)t[String(r)]=n.format(r)}return Xe.set(e,t),t}function Dt(e,t){if(t==="latn")return e;if(!$t.has(t))throw new N({actual:t,reason:`numbering system "${t}" is not supported.`});let n=Nt(t),r={};for(let a of Object.keys(n))r[n[a]]=a;let o="";for(let a of e)o+=r[a]??a;return o}function Te(e,t){let n=t.parseNumberingSystem??"latn";return n==="latn"?e:Dt(e,n)}var Y=new Map,Mt=500;Oe(()=>{Y.clear()});function Ne(e,t){let n=JSON.stringify([C(t),e]),r=Y.get(n);if(r)return r;if(Y.size>=Mt){let o=Y.keys().next().value;o!==void 0&&Y.delete(o)}return r=Ce(ve(e),t),Y.set(n,r),r}var U=new Map,Lt=500;function Ot(e){he(e);let t=C(e);if(U.has(t))return U.get(t);if(U.size>=Lt){let s=U.keys().next().value;s!==void 0&&U.delete(s)}let n,r=t.split("-"),o=r.indexOf("u"),a=o===-1?-1:r.indexOf("ca",o+1);if(a!==-1&&a+1<r.length){let s=new Intl.DateTimeFormat(t).resolvedOptions().calendar;n=s==="gregory"?void 0:s}return U.set(t,n),n}function Pt(e,t){if(e==="Z"){/* c8 ignore start @preserve -- unreachable: lowercase tokens' regex
-   (OFFSET_SHAPES in pattern.ts) has no "Z" alternative at all, so
-   raw === 'Z' can only ever be reached when token is one of the
-   uppercase variants (X/XX/XXX). A lowercase token can't even
-   capture "Z" as `raw` in the first place. */if(t==="x"||t==="xx"||t==="xxx")throw new Error(`temporal-fmt: offset token "${t}" doesn't accept "Z" \u2014 only the uppercase variants (X/XX/XXX) emit "Z" for UTC. Use "+00:00", "+0000", or "+00" depending on the variant's width.`);/* c8 ignore stop @preserve */return"+00:00"}let n=e[0];/* c8 ignore start @preserve -- unreachable: raw is a regex-captured
-   group from an offset token, and every OFFSET_SHAPES pattern
-   (pattern.ts) is anchored to either "Z" or a leading [+-]. raw's
-   first character can never be anything else by the time it reaches
-   this function. */if(n!=="+"&&n!=="-")throw new Error(`temporal-fmt: offset "${e}" for token "${t}" doesn't start with "+", "-", or "Z".`);/* c8 ignore stop @preserve */let r=e.slice(1),o,a;if(r.length===2){/* c8 ignore start @preserve -- unreachable: each offset token's own
-   regex shape in OFFSET_SHAPES (pattern.ts) already gates which
-   body shapes it can capture. Only X and x ever match a 2-digit
-   body — XX/xx/XXX/xxx's regexes can't produce one — so this
-   mismatch can never actually fire through parse(). */if(t!=="X"&&t!=="x")throw new Error(`temporal-fmt: offset token "${t}" can't match "${e}" \u2014 it requires minutes, but "${e}" has none.`);/* c8 ignore stop @preserve */o=r,a="00"}else if(r.length===4){/* c8 ignore start @preserve -- unreachable, same reason as the
-   2-digit case above: XXX/xxx's regex requires a colon, so it can
-   never capture a 4-digit no-colon body in the first place. */if(t==="XXX"||t==="xxx")throw new Error(`temporal-fmt: offset token "${t}" can't match "${e}" \u2014 it requires a colon between hours and minutes (e.g. "${n}${r.slice(0,2)}:${r.slice(2)}").`);/* c8 ignore stop @preserve */o=r.slice(0,2),a=r.slice(2,4)}else if(r.length===5&&r[2]===":"){/* c8 ignore start @preserve -- unreachable, same reason again: only
-   XXX/xxx's regex can produce a colon-shaped body; X/x/XX/xx never
-   capture one. */if(t!=="XXX"&&t!=="xxx")throw new Error(`temporal-fmt: offset token "${t}" can't match "${e}" \u2014 it doesn't use a colon (use "${n}${r.slice(0,2)}${r.slice(3)}" instead).`);/* c8 ignore stop @preserve */o=r.slice(0,2),a=r.slice(3,5);/* c8 ignore start @preserve -- unreachable: every offset token's
-   regex only ever produces a body of length 2, length 4, or length 5
-   with a colon at index 2 (see OFFSET_SHAPES in pattern.ts) — no
-   shape falls outside those three cases, so this else arm can't be
-   taken through parse(). Kept as an exhaustiveness fallback so
-   hoursStr/minutesStr are assigned on every path TypeScript can see. */}else throw new Error(`temporal-fmt: offset "${e}" doesn't match the shape token "${t}" accepts.`);/* c8 ignore stop @preserve */let s=Number(o),m=Number(a);if(s>14)throw new F({actual:e,message:`temporal-fmt: offset hours ${s} in "${e}" out of range (max 14 \u2014 Kiritimati, Line Islands is +14:00).`});if(m>59)throw new F({actual:e,message:`temporal-fmt: offset minutes ${m} in "${e}" out of range (max 59).`});if(n==="+"&&s===14&&m!==0)throw new F({actual:e,message:`temporal-fmt: offset "${e}" exceeds the maximum supported UTC offset of +14:00.`});if(n==="-"&&s===12&&m!==0)throw new F({actual:e,message:`temporal-fmt: offset "${e}" exceeds the maximum supported negative UTC offset of -12:00.`});return`${n}${o}:${a}`}function f(e,t,n){e[t]=n}function It(e,t,n,r,o){let a=V(r);switch(t){case"yyyy":f(e,"year",Number(n));break;case"yy":f(e,"twoDigitYear",Number(n));break;case"MM":case"M":f(e,"month",Number(n));break;case"MMMM":f(e,"month",a.monthLong.indexOf(n)+1);break;case"MMM":f(e,"month",a.monthShort.indexOf(n)+1);break;case"dd":case"d":f(e,"day",Number(n));break;case"EEEE":f(e,"weekdayRaw",n),f(e,"weekdayExpected",a.weekdayLong.indexOf(n)+1);break;case"EEE":f(e,"weekdayRaw",n),f(e,"weekdayExpected",a.weekdayShort.indexOf(n)+1);break;case"HH":case"H":f(e,"hour",Number(n));break;case"hh":case"h":f(e,"hour12",Number(n));break;case"mm":case"m":f(e,"minute",Number(n));break;case"ss":case"s":f(e,"second",Number(n));break;case"S":case"SS":case"SSS":case"SSSS":case"SSSSS":case"SSSSSS":case"SSSSSSS":case"SSSSSSSS":case"SSSSSSSSS":{let s=Number(n.padEnd(9,"0"));f(e,"millisecond",Math.floor(s/1e6)),f(e,"microsecond",Math.floor(s/1e3)%1e3),f(e,"nanosecond",s%1e3);break}case"a":{let s=a.dayPeriod.findIndex(m=>m.toLowerCase()===n.toLowerCase());/* c8 ignore start @preserve -- unreachable: the 'a' token's regex
-   fragment (pattern.ts's alternation() over vocab.dayPeriod) can
-   only ever capture a case-insensitive match of one of
-   vocab.dayPeriod's own entries. Both the regex and this lookup
-   derive their vocab from the same `locale` via getLocaleVocab(),
-   so periodIndex can't come back negative through parse(). */if(s<0)throw new Error(`temporal-fmt: unknown day period "${n}" for locale "${r}".`);/* c8 ignore stop @preserve */f(e,"dayPeriodRaw",n),f(e,"isPM",s===1);break}case"zzz":f(e,"timeZoneId",n);break;case"X":case"XX":case"XXX":case"x":case"xx":case"xxx":f(e,"offsetString",Pt(n,t));break;case"Q":f(e,"quarter",Number(n));break;case"QQQ":f(e,"quarter",Number(n.slice(1)));break}}function Re(e,t){let n=t.indexOf("d");if(n!==-1){let r=e.filter(o=>o[n]<=12);if(r.length>0)return r[0]}return e[0]}function Ft(e){if(e.year!==void 0&&e.twoDigitYear!==void 0)throw new S({message:'temporal-fmt: format string mixes "yyyy" and "yy" year representations.'});if(e.year!==void 0)return e.year;if(e.twoDigitYear!==void 0)return e.twoDigitYear<=68?2e3+e.twoDigitYear:1900+e.twoDigitYear}function vt(e,t,n){if(e.hour!==void 0&&e.hour12!==void 0)throw new S({format:t,message:`temporal-fmt: format string "${t}" mixes a 24-hour token ("HH"/"H") with a 12-hour token ("hh"/"h").`});if(e.hour!==void 0){if(e.dayPeriodRaw!==void 0){let r=V(n),o=e.hour<12?r.dayPeriod[0]:r.dayPeriod[1];if(e.dayPeriodRaw.toLowerCase()!==o?.toLowerCase())throw new S({format:t,message:`temporal-fmt: format string "${t}" contains a day period that contradicts the 24-hour value.`})}return e.hour}if(e.hour12!==void 0){if(e.isPM===void 0)throw new S({format:t,message:`temporal-fmt: format string "${t}" uses a 12-hour token ("hh"/"h") without an "a" token, so parse() can't tell AM from PM.`});return e.hour12%12+(e.isPM?12:0)}}function de(e,t,n={}){if(e.length>1e3)throw new S({format:e,message:`temporal-fmt: format string exceeds maximum length of ${1e3} characters (got ${e.length}).`});if(t.length>1e5)throw new S({input:t,message:`temporal-fmt: input exceeds maximum length of ${1e5} characters (got ${t.length}).`});n.parseNumberingSystem&&(t=Te(t,n));let r=n.locale??me,o=Ot(r),a=Ne(e,r),s=a.regex.exec(t);if(!s)throw new T({input:t,format:e,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(a.groups.length===0)throw new T({format:e,reason:`format string "${e}" has no tokens \u2014 nothing to parse into a value.`,message:`temporal-fmt: format string "${e}" has no tokens \u2014 nothing to parse into a value.`});for(let{name:w,token:x}of a.groups)if(x==="zzz"&&!ke(s.groups[w]))throw new G({input:t,format:e,actual:s.groups[w],reason:"not a recognized IANA time zone identifier"});let m=new Map;for(let w of a.ambiguousRuns){let x=s.groups[w.groupName],D=xe(x,w.tokens);if(D.length===0)throw new T({input:t,format:e,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(D.length>1){if(!n.lenient)throw new R({input:t,format:e,message:`temporal-fmt: "${x}" in format string "${e}" is ambiguous \u2014 ${D.length} different ways to read tokens "${w.tokens.join("")}" (with no separator between them) are all individually valid (e.g. ${JSON.stringify(D[0])} vs ${JSON.stringify(D[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.`});let X=Re(D,w.tokens);w.groupNames.forEach((fe,He)=>m.set(fe,String(X[He])))}else w.groupNames.forEach((X,fe)=>m.set(X,String(D[0][fe])))}let p={};for(let{name:w,token:x}of a.groups){let D=m.get(w)??s.groups[w];It(p,x,D,r,e)}let l=Ft(p),c=vt(p,e,r),{month:i,day:d,minute:u,second:h,millisecond:k,microsecond:$,nanosecond:O,timeZoneId:y,offsetString:b,weekdayExpected:le,weekdayRaw:Ue,quarter:ge}=p,Ye=l!==void 0||i!==void 0||d!==void 0,A=l!==void 0&&i!==void 0&&d!==void 0;if(Ye&&!A)throw new L({format:e,message:`temporal-fmt: format string "${e}" has an incomplete date \u2014 year, month, and day tokens must all be present together.`});let re=c!==void 0||u!==void 0||h!==void 0||k!==void 0;if(y!==void 0&&!(A&&re))throw new S({format:e,message:`temporal-fmt: format string "${e}" has a "zzz" token but needs a full date and time to build a ZonedDateTime.`});if(b!==void 0&&!(A&&re))throw new S({format:e,message:`temporal-fmt: format string "${e}" has an offset token (X/XX/XXX/x/xx/xxx) but needs a full date and time to build a ZonedDateTime.`});if(le!==void 0&&!A)throw new S({format:e,message:`temporal-fmt: format string "${e}" has a weekday token ("EEEE"/"EEE") but needs a full date to validate it against.`});if(!A&&!re)throw new S({format:e,message:`temporal-fmt: format string "${e}" has no date or time tokens to parse.`});let H=se(),_={hour:c??0,minute:u??0,second:h??0,millisecond:k??0,microsecond:$??0,nanosecond:O??0},oe=o?{calendar:o}:{},ae={overflow:"reject"},P;try{if(y!==void 0){let w={overflow:"reject",offset:"prefer"};if(P=H.ZonedDateTime.from({year:l,month:i,day:d,..._,...oe,timeZone:y,...b!==void 0?{offset:b}:{}},w),b!==void 0){let x=P;if(x.hour!==_.hour||x.minute!==_.minute||x.second!==_.second)throw new L({input:t,format:e,message:`"${y}" has no such wall-clock time on this date \u2014 it falls in a DST gap, not an ambiguous or valid instant.`});let X=x.offset;if(X!==b)throw new T({input:t,format:e,message:`has both a "zzz" zone (${y}) and an offset token (${b}), but the zone's actual offset at this date/time is ${X}, not ${b}.`})}}else b!==void 0?P=H.ZonedDateTime.from({year:l,month:i,day:d,..._,...oe,timeZone:b},ae):A&&re?P=H.PlainDateTime.from({year:l,month:i,day:d,..._,...oe},ae):A?P=H.PlainDate.from({year:l,month:i,day:d,...oe},ae):P=H.PlainTime.from(_,ae)}catch(w){throw new L({input:t,format:e,message:`temporal-fmt: "${t}" doesn't describe a valid date/time for format "${e}": ${w.message}`})}if(le!==void 0){let w=P.dayOfWeek;if(w!==le){let x=V(r);throw new L({input:t,format:e,message:`temporal-fmt: "${Ue}" doesn't match the actual weekday (${x.weekdayLong[w-1]}) for the parsed date.`})}}if(ge!==void 0&&i!==void 0){let w=Math.ceil(i/3);if(ge!==w)throw new L({format:e,message:`temporal-fmt: format string "${e}" contains a quarter token (Q/QQQ) whose value (Q${ge}) disagrees with the parsed month's actual quarter \u2014 month ${i} is in Q${w}.`})}return P}function ze(e,t,n={}){try{return{ok:!0,value:de(e,t,n)}}catch(r){/* c8 ignore start @preserve */return r instanceof E?{ok:!1,error:r}:{ok:!1,error:Me(r,{input:t,format:e})}}/* c8 ignore stop @preserve */}function Ve(e,t,n={}){try{return de(e,t,n)}catch{return}}function Ze(e,t,n={}){if(e.length>1e3)throw new S({format:e,message:`temporal-fmt: format string exceeds maximum length of ${1e3} characters (got ${e.length}).`});if(t.length>1e5)throw new S({input:t,message:`temporal-fmt: input exceeds maximum length of ${1e5} characters (got ${t.length}).`});n.parseNumberingSystem&&(t=Te(t,n));let r=n.locale??me,o=Ne(e,r),a=o.regex.exec(t);if(!a)throw new T({input:t,format:e,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(o.groups.length===0)throw new T({format:e,reason:`format string "${e}" has no tokens \u2014 nothing to parse into a value.`,message:`temporal-fmt: format string "${e}" has no tokens \u2014 nothing to parse into a value.`});for(let{name:i,token:d}of o.groups)if(d==="zzz"&&!ke(a.groups[i]))throw new G({input:t,format:e,actual:a.groups[i],reason:"not a recognized IANA time zone identifier"});let s=new Map;for(let i of o.ambiguousRuns){let d=a.groups[i.groupName],u=xe(d,i.tokens);if(u.length===0)throw new T({input:t,format:e,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(u.length>1){if(!n.lenient)throw new R({input:t,format:e,message:`temporal-fmt: "${d}" in format string "${e}" is ambiguous \u2014 ${u.length} different ways to read tokens "${i.tokens.join("")}" (with no separator between them) are all individually valid (e.g. ${JSON.stringify(u[0])} vs ${JSON.stringify(u[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.`});let h=Re(u,i.tokens);i.groupNames.forEach((k,$)=>s.set(k,String(h[$])))}else i.groupNames.forEach((h,k)=>s.set(h,String(u[0][k])))}let m=[],l=a.indices?.groups,c=0;for(let{name:i,token:d}of o.groups){let u=s.get(i)??a.groups[i],h=!s.has(i)&&l?.[i],k=h?h[0]:(a.index??0)+c;m.push({token:d,raw:u,position:k}),c+=u.length}return m}function At(e,t={}){if(e.length>1e3)throw new S({format:e,message:`temporal-fmt: format string exceeds maximum length of ${1e3} characters (got ${e.length}).`});let n=t.locale??me,r=Ne(e,n);return{formatStr:e,pattern:r,parse(o,a={}){return de(e,o,{locale:n,...a})},safeParse(o,a={}){return ze(e,o,{locale:n,...a})},tryParse(o,a={}){return Ve(e,o,{locale:n,...a})},parseToParts(o,a={}){return Ze(e,o,{locale:n,...a})}}}0&&(module.exports={compileParser,parse,parseToParts,safeParse,tryParse});
+   of the locale string — it's never handed an arbitrary "calendar" value
+   a caller could actually get wrong. no live input to reject here.
+   leaving it unconstructed until the library accepts an actual calendar
+   parameter that could be invalid */
+/* c8 ignore stop @preserve */
+var AmbiguousInputError = class extends TemporalFmtError {
+  constructor(fields) {
+    const { message, ...rest } = fields;
+    super(
+      message ?? `input "${fields.input ?? ""}" is ambiguous${fields.reason ? `: ${fields.reason}` : ""}.`,
+      { code: "AMBIGUOUS_INPUT", ...rest }
+    );
+    this.name = "AmbiguousInputError";
+  }
+};
+var InvalidLocaleError = class extends TemporalFmtError {
+  constructor(fields) {
+    const { message, ...rest } = fields;
+    super(
+      message ?? `locale "${fields.actual ?? ""}" is not a valid BCP-47 tag${fields.reason ? `: ${fields.reason}` : ""}.`,
+      { code: "INVALID_LOCALE", ...rest }
+    );
+    this.name = "InvalidLocaleError";
+  }
+};
+/* c8 ignore start @preserve -- unreachable from the current test suite,
+   see rationale above */
+function wrapUntypedError(err, context) {
+  const msg = err.message;
+  if (/unknown token|isn't a recognized token/.test(msg)) {
+    return new UnknownTokenError({ input: context.input, format: context.format, reason: msg });
+  }
+  if (/ambiguous/i.test(msg)) {
+    return new AmbiguousInputError({ input: context.input, format: context.format, reason: msg });
+  }
+  if (/offset/.test(msg) && /out of range|exceeds|doesn't match the shape/i.test(msg)) {
+    return new InvalidOffsetError({ input: context.input, format: context.format, reason: msg });
+  }
+  if (/no valid pattern matches/i.test(msg)) {
+    return new ParseMismatchError({ input: context.input, format: context.format, reason: msg });
+  }
+  if (/doesn't describe a valid date\/time|incomplete date|weekday token|quarter token/.test(msg)) {
+    return new InvalidDateError({ input: context.input, format: context.format, reason: msg });
+  }
+  const lowerMsg = msg.toLowerCase();
+  const mentionsLocale = lowerMsg.includes("locale");
+  if (mentionsLocale && (lowerMsg.includes("produced no") || lowerMsg.includes("not a valid")) || lowerMsg.includes("cutoffs must be")) {
+    return new InvalidLocaleError({ input: context.input, format: context.format, reason: msg });
+  }
+  if (/format string exceeds maximum length|input exceeds maximum length|unterminated quote|isn't a recognized token/i.test(msg)) {
+    return new FormatSyntaxError({ input: context.input, format: context.format, reason: msg });
+  }
+  return new ParseMismatchError({ input: context.input, format: context.format, reason: msg });
+}
+/* c8 ignore stop @preserve */
+
+// src/localeVocab.ts
+var customVocabs = /* @__PURE__ */ new Map();
+var onVocabChanged = [];
+function subscribeToVocabChanges(listener) {
+  onVocabChanged.push(listener);
+}
+function normalizeLocaleTag(locale) {
+  return locale.replace(/_/g, "-");
+}
+var canonicalKeyCache = /* @__PURE__ */ new Map();
+var MAX_CANONICAL_KEY_CACHE = 500;
+function canonicalCacheKey(locale) {
+  const hit = canonicalKeyCache.get(locale);
+  if (hit !== void 0) return hit;
+  let key;
+  try {
+    key = new Intl.Locale(locale.replace(/_/g, "-")).toString().toLowerCase();
+  } catch {
+    key = locale;
+  }
+  if (canonicalKeyCache.size >= MAX_CANONICAL_KEY_CACHE) {
+    const oldestKey = canonicalKeyCache.keys().next().value;
+    if (oldestKey !== void 0) canonicalKeyCache.delete(oldestKey);
+  }
+  canonicalKeyCache.set(locale, key);
+  return key;
+}
+function assertValidLocaleTag(locale) {
+  try {
+    new Intl.Locale(normalizeLocaleTag(locale));
+  } catch {
+    throw new InvalidLocaleError({
+      actual: locale,
+      reason: "not a valid BCP-47 locale tag"
+    });
+  }
+}
+var vocabCache = /* @__PURE__ */ new Map();
+var MAX_VOCAB_CACHE_SIZE = 500;
+function partValue(formatter, date, type) {
+  const parts = formatter.formatToParts(date);
+  const index = parts.findIndex((p) => p.type === type);
+  /* c8 ignore start @preserve -- defensive guard against a real but
+     unreproducible failure mode: an Intl implementation that omits the
+     requested part type entirely for some locale. Checked every locale
+     with unusual dayPeriod/weekday/month rendering available in this
+     runtime's ICU data (ja-JP, zh-CN, th-TH, he-IL, ar-SA, ko-KR, fa-IR)
+     against the exact formatter options getLocaleVocab uses (notably
+     hour12: true for the dayPeriod formatter, which is what makes every
+     locale here actually emit a dayPeriod part — omitting it is what
+     produced a false "gap" during investigation). None omit their part
+     on this runtime. A different ICU version or a non-Node Intl
+     implementation could plausibly behave differently, so this stays a
+     real check rather than an assertion. */
+  /* c8 ignore start @preserve */
+  if (index === -1) {
+    throw new InvalidLocaleError({
+      message: `temporal-fmt: locale produced no "${type}" part while building match vocabulary.`
+    });
+  }
+  /* c8 ignore stop @preserve */
+  let value = parts[index].value;
+  const prev = parts[index - 1];
+  const next = parts[index + 1];
+  if (prev?.type === "literal" && !/\s/.test(prev.value)) value = prev.value + value;
+  if (next?.type === "literal" && !/\s/.test(next.value)) value = value + next.value;
+  return value;
+}
+function assertNoCollision(names, label, locale) {
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < names.length; i++) {
+    const prior = seen.get(names[i]);
+    if (prior !== void 0) {
+      throw new Error(
+        `temporal-fmt: locale "${locale}" renders ${label} index ${prior} and ${i} identically ("${names[i]}"). parse() can't reliably tell these apart for this locale/token, so this combination isn't supported.`
+      );
+    }
+    seen.set(names[i], i);
+  }
+}
+function getCustomVocab(locale) {
+  const cacheKey = canonicalCacheKey(locale);
+  return customVocabs.get(cacheKey);
+}
+function getLocaleVocab(locale) {
+  assertValidLocaleTag(locale);
+  const cacheKey = canonicalCacheKey(locale);
+  const custom = customVocabs.get(cacheKey);
+  if (custom) {
+    return custom;
+  }
+  const cached = vocabCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const intlLocale = normalizeLocaleTag(locale);
+  const monthLongFmt = new Intl.DateTimeFormat(intlLocale, { month: "long", timeZone: "UTC" });
+  const monthShortFmt = new Intl.DateTimeFormat(intlLocale, { month: "short", timeZone: "UTC" });
+  const monthLong = [];
+  const monthShort = [];
+  for (let m = 0; m < 12; m++) {
+    const date = new Date(Date.UTC(2020, m, 1));
+    monthLong.push(partValue(monthLongFmt, date, "month"));
+    monthShort.push(partValue(monthShortFmt, date, "month"));
+  }
+  assertNoCollision(monthLong, "MMMM month", locale);
+  assertNoCollision(monthShort, "MMM month", locale);
+  const weekdayLongFmt = new Intl.DateTimeFormat(intlLocale, { weekday: "long", timeZone: "UTC" });
+  const weekdayShortFmt = new Intl.DateTimeFormat(intlLocale, { weekday: "short", timeZone: "UTC" });
+  const weekdayLong = [];
+  const weekdayShort = [];
+  for (let d = 0; d < 7; d++) {
+    const date = new Date(Date.UTC(2024, 0, 1 + d));
+    weekdayLong.push(partValue(weekdayLongFmt, date, "weekday"));
+    weekdayShort.push(partValue(weekdayShortFmt, date, "weekday"));
+  }
+  assertNoCollision(weekdayLong, "EEEE weekday", locale);
+  assertNoCollision(weekdayShort, "EEE weekday", locale);
+  const dayPeriodFmt = new Intl.DateTimeFormat(intlLocale, { hour: "numeric", hour12: true, timeZone: "UTC" });
+  const am = partValue(dayPeriodFmt, new Date(Date.UTC(2020, 0, 1, 1)), "dayPeriod");
+  const pm = partValue(dayPeriodFmt, new Date(Date.UTC(2020, 0, 1, 13)), "dayPeriod");
+  const dayPeriod = [.../* @__PURE__ */ new Set([am, pm])];
+  const vocab = { monthLong, monthShort, weekdayLong, weekdayShort, dayPeriod };
+  if (vocabCache.size >= MAX_VOCAB_CACHE_SIZE) {
+    const oldestKey = vocabCache.keys().next().value;
+    if (oldestKey !== void 0) vocabCache.delete(oldestKey);
+  }
+  vocabCache.set(cacheKey, vocab);
+  return vocab;
+}
+
+// src/isoWeek.ts
+var CUMULATIVE_DAYS_BY_MONTH = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
+function isGregorianLeapYear(year) {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+function daysInYear(year) {
+  return isGregorianLeapYear(year) ? 366 : 365;
+}
+function dayOfYear(year, month, day) {
+  let doy = CUMULATIVE_DAYS_BY_MONTH[month - 1] + day;
+  if (month > 2 && isGregorianLeapYear(year)) doy += 1;
+  return doy;
+}
+var REFERENCE_YEAR = 2e3;
+function dayOfWeekOfJan1(year) {
+  let offset = 0;
+  if (year >= REFERENCE_YEAR) {
+    for (let y = REFERENCE_YEAR; y < year; y++) offset += daysInYear(y);
+  } else {
+    for (let y = year; y < REFERENCE_YEAR; y++) offset -= daysInYear(y);
+  }
+  const zeroIndexed = ((6 - 1 + offset) % 7 + 7) % 7;
+  return zeroIndexed + 1;
+}
+function isoWeekYearAndWeek(year, month, day, dayOfWeek) {
+  const doy = dayOfYear(year, month, day);
+  const thursdayDoyRelative = doy + (4 - dayOfWeek);
+  let isoYear;
+  let thursdayDoy;
+  if (thursdayDoyRelative < 1) {
+    isoYear = year - 1;
+    thursdayDoy = thursdayDoyRelative + daysInYear(isoYear);
+  } else if (thursdayDoyRelative > daysInYear(year)) {
+    isoYear = year + 1;
+    thursdayDoy = thursdayDoyRelative - daysInYear(year);
+  } else {
+    isoYear = year;
+    thursdayDoy = thursdayDoyRelative;
+  }
+  const jan1Dow = dayOfWeekOfJan1(isoYear);
+  const firstThursdayDoy = 1 + (4 - jan1Dow + 7) % 7;
+  const week = 1 + Math.floor((thursdayDoy - firstThursdayDoy) / 7);
+  return { isoYear, week };
+}
+
+// src/tokens.ts
+function pad(n, len) {
+  const negative = n < 0;
+  const digits = String(Math.abs(n)).padStart(len, "0");
+  return negative ? "-" + digits : digits;
+}
+pad.fraction = function formatFraction(t, width) {
+  const nanoOfSecond = t.millisecond * 1e6 + (t.microsecond ?? 0) * 1e3 + (t.nanosecond ?? 0);
+  return pad(nanoOfSecond, 9).slice(0, width);
+};
+var DEFAULT_LOCALE = "en-US";
+var formatterCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 500;
+function getFormatter(locale, options) {
+  const key = JSON.stringify([canonicalCacheKey(locale), options]);
+  let formatter = formatterCache.get(key);
+  if (formatter) {
+    return formatter;
+  }
+  if (formatterCache.size >= MAX_CACHE_SIZE) {
+    const oldestKey = formatterCache.keys().next().value;
+    if (oldestKey !== void 0) formatterCache.delete(oldestKey);
+  }
+  try {
+    formatter = new Intl.DateTimeFormat(normalizeLocaleTag(locale), options);
+  } catch (err) {
+    throw new InvalidLocaleError({ actual: locale, reason: err.message });
+  }
+  formatterCache.set(key, formatter);
+  return formatter;
+}
+var nativeSupport;
+subscribeToTemporalChanges(() => {
+  nativeSupport = void 0;
+});
+function intlSupportsNativeTemporal() {
+  if (nativeSupport === void 0) {
+    nativeSupport = false;
+    try {
+      const temporal = getTemporal();
+      new Intl.DateTimeFormat("en-US", { day: "numeric" }).formatToParts(temporal.PlainDate.from({ year: 1970, month: 1, day: 1 }));
+      nativeSupport = true;
+    } catch {
+    }
+  }
+  return nativeSupport;
+}
+function intlPart(temporal, locale, options, partType) {
+  const calendar = temporal?.calendarId;
+  const formatterOptions = {
+    ...options,
+    calendar: calendar && calendar !== "iso8601" ? calendar : "gregory"
+  };
+  const ls = temporal.toLocaleString;
+  if (typeof ls !== "function" || ls === Object.prototype.toLocaleString) {
+    throw new Error(
+      `temporal-fmt: locale-aware part "${partType}" needs a value that implements toLocaleString (a real Temporal object). A plain field bag cannot render locale-aware names \u2014 pass a Temporal.PlainDate/PlainDateTime/ZonedDateTime.`
+    );
+  }
+  if (!intlSupportsNativeTemporal()) {
+    try {
+      return ls.call(temporal, normalizeLocaleTag(locale), formatterOptions);
+    } catch (err) {
+      if (err instanceof RangeError) {
+        throw new InvalidLocaleError({ actual: locale, reason: err.message });
+      }
+      throw err;
+    }
+  }
+  const { toInstant, timeZoneId } = temporal;
+  const isZoned = typeof toInstant === "function" && typeof timeZoneId === "string";
+  const intlSafeTemporal = isZoned ? temporal.toInstant() : temporal;
+  const nativeOptions = {
+    ...formatterOptions,
+    ...isZoned ? { timeZone: timeZoneId } : {}
+  };
+  const formatter = getFormatter(locale, nativeOptions);
+  const parts = formatter.formatToParts(intlSafeTemporal);
+  const index = parts.findIndex((p) => p.type === partType);
+  if (index === -1) {
+    throw new Error(
+      `temporal-fmt: locale "${locale}" produced no "${partType}" part for this token. This usually means the Temporal object is missing the field the token needs.`
+    );
+  }
+  let value = parts[index].value;
+  const prev = parts[index - 1];
+  const next = parts[index + 1];
+  if (prev?.type === "literal" && !/\s/.test(prev.value)) value = prev.value + value;
+  if (next?.type === "literal" && !/\s/.test(next.value)) value = value + next.value;
+  return value;
+}
+function dayPeriodPart(hour, locale) {
+  const custom = getCustomVocab(locale);
+  if (custom) {
+    return hour < 12 ? custom.dayPeriod[0] : custom.dayPeriod[1];
+  }
+  const date = new Date(Date.UTC(1970, 0, 1, hour));
+  const formatter = getFormatter(locale, { hour: "numeric", hour12: true, timeZone: "UTC" });
+  const part = formatter.formatToParts(date).find((p) => p.type === "dayPeriod");
+  if (!part) {
+    throw new Error(`temporal-fmt: locale "${locale}" produced no "dayPeriod" part for token "a".`);
+  }
+  return part.value;
+}
+function localeAwareName(temporal, locale, options, partType, customArray, customIndex) {
+  if (customArray && customIndex !== void 0 && customIndex >= 0 && customIndex < customArray.length) {
+    return customArray[customIndex];
+  }
+  return intlPart(temporal, locale, options, partType);
+}
+function formatOffset(offset, variant) {
+  if (offset === "+00:00" && (variant === "X" || variant === "XX" || variant === "XXX")) {
+    return "Z";
+  }
+  if (offset.length > 6) {
+    if (variant === "xxx") {
+      return offset;
+    }
+    throw new Error(
+      `temporal-fmt: token "${variant}" cannot represent the offset "${offset}", which has a seconds component. None of the X/XX/XXX/x/xx tokens support offset seconds; use "xxx" instead, which formats the full offset unchanged.`
+    );
+  }
+  const sign = offset[0];
+  const hours = offset.slice(1, 3);
+  const minutes = offset.slice(4, 6);
+  switch (variant) {
+    case "X":
+    case "x":
+      return minutes === "00" ? `${sign}${hours}` : `${sign}${hours}${minutes}`;
+    case "XX":
+    case "xx":
+      return `${sign}${hours}${minutes}`;
+    case "XXX":
+    case "xxx":
+      return `${sign}${hours}:${minutes}`;
+  }
+}
+var TOKENS = [
+  ["yyyy", (t) => pad(t.year, 4), "year"],
+  ["yy", (t) => {
+    if (t.year < 0) {
+      throw new Error(
+        `temporal-fmt: token "yy" doesn't support negative years (got ${t.year}), since truncating to 2 digits would make it indistinguishable from a positive year. Use "yyyy" instead.`
+      );
+    }
+    return pad(t.year % 100, 2);
+  }, "year"],
+  // Unpadded year — no minimum width, unlike yyyy's fixed 4 digits.
+  // pad(n, 0) still does the right thing here: Math.abs(n) with no
+  // padStart floor just yields the plain digit string, and the sign
+  // handling (split off before padding) already covers negative years,
+  // so this doesn't need its own sign branch the way "yy" does.
+  ["y", (t) => pad(t.year, 0), "year"],
+  ["MMMM", (t, locale) => {
+    const custom = getCustomVocab(locale);
+    return localeAwareName(t, locale, { month: "long" }, "month", custom?.monthLong, t.month - 1);
+  }, "month"],
+  ["MMM", (t, locale) => {
+    const custom = getCustomVocab(locale);
+    return localeAwareName(t, locale, { month: "short" }, "month", custom?.monthShort, t.month - 1);
+  }, "month"],
+  ["MM", (t) => pad(t.month, 2), "month"],
+  ["M", (t) => String(t.month), "month"],
+  ["dd", (t) => pad(t.day, 2), "day"],
+  ["d", (t) => String(t.day), "day"],
+  ["EEEE", (t, locale) => {
+    const custom = getCustomVocab(locale);
+    return localeAwareName(t, locale, { weekday: "long" }, "weekday", custom?.weekdayLong, t.dayOfWeek - 1);
+  }, "dayOfWeek"],
+  ["EEE", (t, locale) => {
+    const custom = getCustomVocab(locale);
+    return localeAwareName(t, locale, { weekday: "short" }, "weekday", custom?.weekdayShort, t.dayOfWeek - 1);
+  }, "dayOfWeek"],
+  ["HH", (t) => pad(t.hour, 2), "hour"],
+  ["H", (t) => String(t.hour), "hour"],
+  ["hh", (t) => pad(t.hour % 12 || 12, 2), "hour"],
+  ["h", (t) => String(t.hour % 12 || 12), "hour"],
+  ["mm", (t) => pad(t.minute, 2), "minute"],
+  ["m", (t) => String(t.minute), "minute"],
+  ["ss", (t) => pad(t.second, 2), "second"],
+  ["s", (t) => String(t.second), "second"],
+  // Fractional-second tokens, S through SSSSSSSSS (1-9 digits). Each token
+  // formats a slice of the same underlying nanosecond-of-second value —
+  // combining millisecond/microsecond/nanosecond into one 9-digit number
+  // and truncating to the token's width — so "SSS" keeps meaning exactly
+  // what it always meant (3-digit milliseconds) while wider tokens expose
+  // the precision Temporal actually carries. formatFraction below is the
+  // shared implementation; see its comment for the truncate-not-round
+  // rule and why.
+  ["SSSSSSSSS", (t) => pad.fraction(t, 9), "millisecond"],
+  ["SSSSSSSS", (t) => pad.fraction(t, 8), "millisecond"],
+  ["SSSSSSS", (t) => pad.fraction(t, 7), "millisecond"],
+  ["SSSSSS", (t) => pad.fraction(t, 6), "millisecond"],
+  ["SSSSS", (t) => pad.fraction(t, 5), "millisecond"],
+  ["SSSS", (t) => pad.fraction(t, 4), "millisecond"],
+  ["SSS", (t) => pad.fraction(t, 3), "millisecond"],
+  ["SS", (t) => pad.fraction(t, 2), "millisecond"],
+  ["S", (t) => pad.fraction(t, 1), "millisecond"],
+  // dayPeriod text is locale-specific (AM/PM in en-US, م/ص in ar-EG) but
+  // still needs .hour on the input to compute which period it is
+  ["a", (t, locale) => dayPeriodPart(t.hour, locale), "hour"],
+  ["zzz", (t) => t.timeZoneId, "timeZoneId"],
+  // Numeric UTC offset tokens (date-fns/Unicode-LDML family). Only
+  // ZonedDateTime carries an offset, so the field check in format() throws
+  // the same "requires offset, which this Temporal object doesn't have"
+  // error zzz throws on PlainDate/PlainTime/PlainDateTime — same
+  // validation path, just a different field name. See formatOffset above
+  // for the per-variant width and Z/numeric distinction.
+  ["xxx", (t) => formatOffset(t.offset, "xxx"), "offset"],
+  ["xx", (t) => formatOffset(t.offset, "xx"), "offset"],
+  ["X", (t) => formatOffset(t.offset, "X"), "offset"],
+  ["XX", (t) => formatOffset(t.offset, "XX"), "offset"],
+  ["XXX", (t) => formatOffset(t.offset, "XXX"), "offset"],
+  ["x", (t) => formatOffset(t.offset, "x"), "offset"],
+  // Ordinal day (1st, 2nd, 3rd, ... 21st). English suffix rules only —
+  // locale-aware ordinals ("2." in de-DE, "2日" in ja-JP) are out of scope,
+  // since the rest of this library routes locale-specific names through
+  // Intl.DateTimeFormat, and Intl has no part type for ordinals. Format-only:
+  // the suffix isn't structurally distinguishable from a literal in a parse
+  // context (a "st"/"nd"/"rd"/"th" suffix isn't a digit and would collide
+  // with any adjacent literal text), so there's no good way to read it back.
+  ["do", (t) => {
+    const day = t.day;
+    const lastDigit = day % 10;
+    const lastTwoDigits = day % 100;
+    if (lastTwoDigits >= 11 && lastTwoDigits <= 13) {
+      return day + "th";
+    }
+    if (lastDigit === 1) return day + "st";
+    if (lastDigit === 2) return day + "nd";
+    if (lastDigit === 3) return day + "rd";
+    return day + "th";
+  }, "day"],
+  // Quarter computed from month: 1-3=Q1, 4-6=Q2, 7-9=Q3, 10-12=Q4.
+  // `Q` is plain numeric, `QQQ` renders as "Q3" — same convention as
+  // date-fns's `Q` and `QQQ` for parity with the most common prior art.
+  // Both format and parse; parse() cross-checks Q/QQQ against the parsed
+  // month in the same spirit as the EEEE-vs-date cross-check.
+  ["Q", (t) => String(Math.ceil(t.month / 3)), "month"],
+  ["QQQ", (t) => "Q" + Math.ceil(t.month / 3), "month"],
+  // ISO 8601 week and week-numbering year. Both are format-only — parsing
+  // "ww"/"RRRR" back into a real date requires resolving an ISO week + a
+  // weekday (or some other disambiguator) to a specific date, which is a
+  // different parsing surface than the token-based parse() here. The
+  // ISO-week year (RRRR) can differ from the calendar year at the boundary:
+  // Dec 29-31 often belong to week 1 of the *next* year; Jan 1-3 often
+  // belong to week 52/53 of the *previous* year. See isoWeekYearAndWeek().
+  ["ww", (t) => {
+    const { week } = isoWeekYearAndWeek(t.year, t.month, t.day, t.dayOfWeek);
+    return pad(week, 2);
+  }, "dayOfWeek"],
+  ["RRRR", (t) => {
+    const { isoYear } = isoWeekYearAndWeek(t.year, t.month, t.day, t.dayOfWeek);
+    return pad(isoYear, 4);
+  }, "dayOfWeek"],
+  // Day of year — number of days since Jan 1 (1-366). Three widths:
+  //   D    — unpadded (1, 2, 366)
+  //   DD   — 2-digit minimum (zero-padded if <100)
+  //   DDD  — 3-digit zero-padded (001, 002, 366)
+  // Format-only — parsing day-of-year requires resolving against a year,
+  // which is a different shape from the token-based parse() surface.
+  // The dayOfYearHelper() in calendarUtils.ts covers the same field for
+  // callers who need the numeric value.
+  ["D", (t) => String(dayOfYear(t.year, t.month, t.day)), "day"],
+  ["DD", (t) => pad(dayOfYear(t.year, t.month, t.day), 2), "day"],
+  ["DDD", (t) => pad(dayOfYear(t.year, t.month, t.day), 3), "day"],
+  // Stand-alone month — uses Intl's stand-alone form. In most locales
+  // (en, fr, de, es) this is identical to MMMM/MMM. In Slavic/Baltic
+  // locales (cs, sk, pl, ru) the stand-alone form differs from the
+  // format form (nominative vs genitive case). LLLL = long, LLL = short.
+  ["LLLL", (t, locale) => {
+    const custom = getCustomVocab(locale);
+    return localeAwareName(t, locale, { month: "long" }, "month", custom?.monthLong, t.month - 1);
+  }, "month"],
+  ["LLL", (t, locale) => {
+    const custom = getCustomVocab(locale);
+    return localeAwareName(t, locale, { month: "short" }, "month", custom?.monthShort, t.month - 1);
+  }, "month"],
+  // Stand-alone weekday — same pattern as stand-alone month but for
+  // weekday names. cccc = long, ccc = short.
+  ["cccc", (t, locale) => {
+    const custom = getCustomVocab(locale);
+    return localeAwareName(t, locale, { weekday: "long" }, "weekday", custom?.weekdayLong, t.dayOfWeek - 1);
+  }, "dayOfWeek"],
+  ["ccc", (t, locale) => {
+    const custom = getCustomVocab(locale);
+    return localeAwareName(t, locale, { weekday: "short" }, "weekday", custom?.weekdayShort, t.dayOfWeek - 1);
+  }, "dayOfWeek"],
+  // Era — locale-aware ("AD"/"BC" in en, "ap. J.-C."/"av. J.-C." in fr).
+  // GGGG = long, G = short. Format-only.
+  ["GGGG", (t, locale) => {
+    return intlPart(t, locale, { era: "long" }, "era");
+  }, "year"],
+  ["G", (t, locale) => {
+    return intlPart(t, locale, { era: "short" }, "era");
+  }, "year"],
+  // Localized timezone name — uses Intl's longLocalized/short timezone
+  // name option. Format-only — these names are locale-dependent and
+  // vary by season (EST vs EDT), so parsing them back requires a
+  // lookup table that isn't practical to ship.
+  ["zzzz", (t, locale) => {
+    return intlPart(t, locale, { timeZoneName: "longGeneric" }, "timeZoneName");
+  }, "timeZoneId"],
+  ["z", (t, locale) => {
+    return intlPart(t, locale, { timeZoneName: "short" }, "timeZoneName");
+  }, "timeZoneId"]
+];
+
+// src/tokenize.ts
+var SORTED_TOKEN_STRINGS = TOKENS.map(([tok]) => tok).sort((a, b) => b.length - a.length);
+function tokenize(format) {
+  const pieces = [];
+  let i = 0;
+  while (i < format.length) {
+    const ch = format[i];
+    if (ch === "'") {
+      if (format[i + 1] === "'") {
+        appendLiteral(pieces, "'");
+        i += 2;
+        continue;
+      }
+      let j = i + 1;
+      let literal = "";
+      let closed = false;
+      while (j < format.length) {
+        if (format[j] === "'") {
+          if (format[j + 1] === "'") {
+            literal += "'";
+            j += 2;
+            continue;
+          }
+          closed = true;
+          j += 1;
+          break;
+        }
+        literal += format[j];
+        j += 1;
+      }
+      if (!closed) {
+        throw new FormatSyntaxError({
+          format,
+          message: `temporal-fmt: unterminated quote in format string "${format}"`
+        });
+      }
+      appendLiteral(pieces, literal);
+      i = j;
+      continue;
+    }
+    const match = SORTED_TOKEN_STRINGS.find((tok) => format.startsWith(tok, i));
+    if (match) {
+      const runChar = match[match.length - 1];
+      if (format[i + match.length] === runChar) {
+        let end = i + match.length;
+        while (format[end] === runChar) end += 1;
+        throw new UnknownTokenError({
+          format,
+          token: format.slice(i, end),
+          message: `temporal-fmt: "${format.slice(i, end)}" in format string "${format}" isn't a recognized token \u2014 did you mean "${match}"?`
+        });
+      }
+      pieces.push({ kind: "token", value: match });
+      i += match.length;
+      continue;
+    }
+    appendLiteral(pieces, ch);
+    i += 1;
+  }
+  return pieces;
+}
+function appendLiteral(pieces, value) {
+  const last = pieces[pieces.length - 1];
+  if (last && last.kind === "literal") {
+    last.value += value;
+  } else {
+    pieces.push({ kind: "literal", value });
+  }
+}
+
+// src/pattern.ts
+function escapeRegExp(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function alternation(values, caseInsensitive = false) {
+  const escaped = values.map(escapeRegExp);
+  if (!caseInsensitive) return `(?:${escaped.join("|")})`;
+  return `(?:${escaped.map(foldCase).join("|")})`;
+}
+function foldCase(value) {
+  return value.replace(/[a-zA-Z]/g, (ch) => `[${ch.toLowerCase()}${ch.toUpperCase()}]`);
+}
+var TIME_ZONE_SHAPE = "(?:UTC|[+-]\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{1,9})?)?|[A-Za-z_]+(?:[+-]\\d{1,2})?(?:\\/[A-Za-z0-9_+-]+)*)";
+var OFFSET_SHAPES = {
+  X: "(?:Z|[+-]\\d{2}(?:\\d{2})?)",
+  XX: "(?:Z|[+-]\\d{4})",
+  XXX: "(?:Z|[+-]\\d{2}:\\d{2})",
+  x: "[+-]\\d{2}(?:\\d{2})?",
+  xx: "[+-]\\d{4}",
+  xxx: "[+-]\\d{2}:\\d{2}"
+};
+function getTimeZoneFragment() {
+  return TIME_ZONE_SHAPE;
+}
+var validZoneSet;
+function getValidZoneSet() {
+  if (!validZoneSet) {
+    validZoneSet = new Set(Intl.supportedValuesOf("timeZone"));
+    validZoneSet.add("UTC");
+  }
+  return validZoneSet;
+}
+var FIXED_OFFSET_RE = /^[+-]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/;
+function isValidTimeZone(raw) {
+  if (FIXED_OFFSET_RE.test(raw) || getValidZoneSet().has(raw)) return true;
+  try {
+    getTemporal().ZonedDateTime.from({
+      year: 2026,
+      month: 1,
+      day: 1,
+      hour: 0,
+      minute: 0,
+      second: 0,
+      timeZone: raw
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var NUMERIC_FRAGMENTS = {
+  yy: "\\d{2}",
+  MM: "(?:0[1-9]|1[0-2])",
+  M: "(?:1[0-2]|[1-9])",
+  dd: "(?:0[1-9]|[12]\\d|3[01])",
+  d: "(?:[12]\\d|3[01]|[1-9])",
+  HH: "(?:[01]\\d|2[0-3])",
+  H: "(?:1\\d|2[0-3]|[0-9])",
+  hh: "(?:0[1-9]|1[0-2])",
+  h: "(?:1[0-2]|[1-9])",
+  mm: "(?:[0-5]\\d)",
+  m: "(?:[1-5]\\d|[0-9])",
+  ss: "(?:[0-5]\\d)",
+  s: "(?:[1-5]\\d|[0-9])",
+  SSSSSSSSS: "\\d{9}",
+  SSSSSSSS: "\\d{8}",
+  SSSSSSS: "\\d{7}",
+  SSSSSS: "\\d{6}",
+  SSSSS: "\\d{5}",
+  SSSS: "\\d{4}",
+  SSS: "\\d{3}",
+  SS: "\\d{2}",
+  S: "\\d",
+  // Q is always a single digit 1-4 (no padding variant, so no width ambiguity
+  // with adjacent digit tokens the way M/d/H/m/s have).
+  Q: "[1-4]"
+};
+var QQQ_FRAGMENT = "Q[1-4]";
+var FORMAT_ONLY_TOKENS = /* @__PURE__ */ new Set(["do", "ww", "RRRR", "D", "DD", "DDD", "LLLL", "LLL", "cccc", "ccc", "GGGG", "G", "zzzz", "z"]);
+var YYYY_EXACT = "-?\\d{4}";
+var YYYY_EXTENDED = "-?\\d{4,}";
+var Y_FRAGMENT = "-?\\d+";
+var DIGIT_LEADING_TOKENS = /* @__PURE__ */ new Set([
+  "yyyy",
+  "yy",
+  "y",
+  "MM",
+  "M",
+  "dd",
+  "d",
+  "HH",
+  "H",
+  "hh",
+  "h",
+  "mm",
+  "m",
+  "ss",
+  "s",
+  "SSSSSSSSS",
+  "SSSSSSSS",
+  "SSSSSSS",
+  "SSSSSS",
+  "SSSSS",
+  "SSSS",
+  "SSS",
+  "SS",
+  "S"
+]);
+var UNBOUNDED_WIDTH_TOKENS = /* @__PURE__ */ new Set(["y"]);
+function tokenFragment(token, locale, nextToken) {
+  if (token === "yyyy") {
+    return nextToken !== void 0 && DIGIT_LEADING_TOKENS.has(nextToken) ? YYYY_EXACT : YYYY_EXTENDED;
+  }
+  if (token === "y") {
+    return Y_FRAGMENT;
+  }
+  const numeric = NUMERIC_FRAGMENTS[token];
+  if (numeric) {
+    return numeric;
+  }
+  if (token === "QQQ") {
+    return QQQ_FRAGMENT;
+  }
+  if (FORMAT_ONLY_TOKENS.has(token)) {
+    throw new UnknownTokenError({
+      token,
+      message: `temporal-fmt: token "${token}" is format-only \u2014 it can't be parsed back into a value. Use a different token in the parse format string (e.g. "d" for "do", "MM" for "ww").`
+    });
+  }
+  const vocab = getLocaleVocab(locale);
+  switch (token) {
+    case "MMMM":
+      return alternation(vocab.monthLong);
+    case "MMM":
+      return alternation(vocab.monthShort);
+    case "EEEE":
+      return alternation(vocab.weekdayLong);
+    case "EEE":
+      return alternation(vocab.weekdayShort);
+    // Case-insensitive on purpose: "pm"/"Pm"/"PM" all mean the same thing,
+    // and unlike the Md-glue ambiguity elsewhere in this file, there's no
+    // second valid reading to guess wrong — so rejecting on case buys no
+    // correctness, only friction against real-world data (mixed-case CSV
+    // exports, lowercase log timestamps).
+    case "a":
+      return alternation(vocab.dayPeriod, true);
+    case "zzz":
+      return getTimeZoneFragment();
+    case "X":
+    case "XX":
+    case "XXX":
+    case "x":
+    case "xx":
+    case "xxx":
+      return OFFSET_SHAPES[token];
+    /* c8 ignore start @preserve -- defensive guard, not reachable through
+       the public API. tokenFragment's only caller (buildCapturingPattern
+       in parsePattern.ts) always passes piece.value straight from
+       tokenize.ts, which only ever emits strings from tokens.ts's TOKENS
+       table. Every token in that table is handled above: the numeric
+       ones via NUMERIC_FRAGMENTS, QQQ via QQQ_FRAGMENT, the format-only
+       ones via the FORMAT_ONLY_TOKENS check earlier in this function, and
+       everything else via one of the switch cases. There's no token
+       string that can reach this default without either tokens.ts
+       registering something new or tokenize.ts being bypassed, neither of
+       which happens on the parse() path. */
+    default:
+      throw new UnknownTokenError({ token, message: `temporal-fmt: unknown token "${token}"` });
+  }
+}
+var UNPADDED_NUMERIC_TOKENS = /* @__PURE__ */ new Set(["M", "d", "H", "h", "m", "s"]);
+var UNPADDED_NUMERIC_RANGES = {
+  M: [{ digits: 1, min: 1, max: 9 }, { digits: 2, min: 10, max: 12 }],
+  d: [{ digits: 1, min: 1, max: 9 }, { digits: 2, min: 10, max: 31 }],
+  H: [{ digits: 1, min: 0, max: 9 }, { digits: 2, min: 10, max: 23 }],
+  h: [{ digits: 1, min: 1, max: 9 }, { digits: 2, min: 10, max: 12 }],
+  m: [{ digits: 1, min: 0, max: 9 }, { digits: 2, min: 10, max: 59 }],
+  s: [{ digits: 1, min: 0, max: 9 }, { digits: 2, min: 10, max: 59 }]
+};
+function enumerateValidSplits(digits, tokens) {
+  const memo = /* @__PURE__ */ new Map();
+  function solve(tokenIndex, offset) {
+    const key = `${tokenIndex}:${offset}`;
+    const cached = memo.get(key);
+    if (cached) {
+      return cached;
+    }
+    if (tokenIndex === tokens.length) {
+      const result = offset === digits.length ? [[]] : [];
+      memo.set(key, result);
+      return result;
+    }
+    const token = tokens[tokenIndex];
+    const ranges = UNPADDED_NUMERIC_RANGES[token];
+    /* c8 ignore start @preserve -- defensive guard, not reachable through
+       the public API. enumerateValidSplits's only caller (parse.ts, both
+       call sites) passes run.tokens straight from
+       pattern.ambiguousRuns, which parsePattern.ts only ever populates
+       with tokens already checked against UNPADDED_NUMERIC_TOKENS — the
+       exact same key set as UNPADDED_NUMERIC_RANGES. There's no path
+       where a token reaches here without having already passed that
+       check. */
+    if (!ranges) {
+      throw new Error(`temporal-fmt: internal error \u2014 "${token}" is not an unpadded numeric token`);
+    }
+    /* c8 ignore stop @preserve */
+    const results = [];
+    for (const { digits: width, min, max } of ranges) {
+      if (offset + width > digits.length) continue;
+      const piece = digits.slice(offset, offset + width);
+      if (width === 2 && piece[0] === "0") continue;
+      const value = Number(piece);
+      if (value < min || value > max) continue;
+      for (const restSplit of solve(tokenIndex + 1, offset + width)) {
+        results.push([value, ...restSplit]);
+        if (results.length === 2) break;
+      }
+      if (results.length === 2) break;
+    }
+    memo.set(key, results);
+    return results;
+  }
+  return solve(0, 0);
+}
+
+// src/parsePattern.ts
+function escapeRegExp2(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var MAX_AMBIGUITY_BITS = 12;
+function widthChoicesBits(choices) {
+  return Math.ceil(Math.log2(Math.max(choices, 1)));
+}
+function isDigitConsumingStart(piece) {
+  if (piece === void 0) return false;
+  if (piece.kind === "literal") return /^[0-9]/.test(piece.value);
+  return DIGIT_LEADING_TOKENS.has(piece.value);
+}
+function buildCapturingPattern(pieces, locale) {
+  const groups = [];
+  const ambiguousRuns = [];
+  let source = "";
+  let i = 0;
+  let ambiguityBits = 0;
+  let currentRun = { names: [], tokens: [] };
+  const flushRun = (nextPiece) => {
+    if (currentRun.tokens.length === 1) {
+      const name = currentRun.names[0];
+      const token = currentRun.tokens[0];
+      source += `(?<${name}>${tokenFragment(token, locale)})`;
+      if (isDigitConsumingStart(nextPiece)) ambiguityBits += 1;
+    } else if (currentRun.tokens.length >= 2) {
+      const runName = `r${i++}`;
+      const tokenCount = currentRun.tokens.length;
+      source += `(?<${runName}>\\d{${tokenCount},${tokenCount * 2}})`;
+      ambiguousRuns.push({
+        groupName: runName,
+        groupNames: currentRun.names,
+        tokens: currentRun.tokens
+      });
+      if (isDigitConsumingStart(nextPiece)) {
+        ambiguityBits += widthChoicesBits(tokenCount + 1);
+      }
+    }
+    currentRun = { names: [], tokens: [] };
+  };
+  for (const [idx, piece] of pieces.entries()) {
+    if (piece.kind === "literal") {
+      flushRun(piece);
+      source += escapeRegExp2(piece.value);
+      continue;
+    }
+    if (UNPADDED_NUMERIC_TOKENS.has(piece.value)) {
+      const name2 = `g${i++}`;
+      groups.push({ name: name2, token: piece.value });
+      currentRun.names.push(name2);
+      currentRun.tokens.push(piece.value);
+      continue;
+    }
+    flushRun(piece);
+    const name = `g${i++}`;
+    groups.push({ name, token: piece.value });
+    const nextPiece = pieces[idx + 1];
+    const nextToken = nextPiece?.kind === "token" ? nextPiece.value : void 0;
+    if (UNBOUNDED_WIDTH_TOKENS.has(piece.value) && isDigitConsumingStart(nextPiece)) {
+      throw new FormatSyntaxError({
+        reason: `token "${piece.value}" has no fixed width \u2014 it can't be placed directly next to another digit-reading token or a literal that starts with a digit, since there's no way to tell where "${piece.value}" ends and the next field begins. Add a non-digit separator (e.g. "-" or " ") after it.`
+      });
+    }
+    if (piece.value === "yyyy" && nextToken === void 0 && isDigitConsumingStart(nextPiece)) {
+      source += `(?<${name}>${tokenFragment(piece.value, locale, "M")})`;
+    } else {
+      source += `(?<${name}>${tokenFragment(piece.value, locale, nextToken)})`;
+    }
+  }
+  flushRun(void 0);
+  if (ambiguityBits > MAX_AMBIGUITY_BITS) {
+    throw new FormatSyntaxError({
+      reason: `format string has too many variable-width numeric tokens glued to digit-consuming neighbors (ambiguity score ${ambiguityBits} > ${MAX_AMBIGUITY_BITS}). This shape makes the regex engine backtrack exponentially on near-miss input. Add a non-digit separator between these tokens (e.g. "-" or " ") or use their padded forms (MM/dd/HH/mm/ss).`
+    });
+  }
+  return { regex: new RegExp(`^(?:${source})$`, "ud"), groups, ambiguousRuns };
+}
+
+// src/constants.ts
+var MAX_FORMAT_LENGTH = 1e3;
+var MAX_INPUT_LENGTH = 1e5;
+
+// src/numbering.ts
+var SUPPORTED_NUMBERING_SYSTEMS = /* @__PURE__ */ new Set([
+  "latn",
+  "arab",
+  "deva",
+  "beng",
+  "guru",
+  "gujr",
+  "orya",
+  "tamldec",
+  "telu",
+  "knda",
+  "mlym",
+  "fullwide",
+  "hanidec"
+]);
+var digitMapCache = /* @__PURE__ */ new Map();
+function getDigitMap(system) {
+  let map = digitMapCache.get(system);
+  if (map) return map;
+  /* c8 ignore start @preserve -- this branch is dead by construction, not
+     just untested: both callers (convertDigits, convertDigitsToAscii)
+     already bail out early on system === 'latn' before ever calling
+     getDigitMap, so it never actually gets invoked with 'latn'. keeping
+     it anyway as a defensive fallback rather than betting that stays
+     true forever */
+  if (system === "latn") {
+    map = {};
+    for (let i = 0; i < 10; i++) map[String(i)] = String(i);
+  } else {
+    /* c8 ignore stop @preserve */
+    const fmt = new Intl.NumberFormat("en-US-u-nu-" + system, { useGrouping: false });
+    map = {};
+    for (let i = 0; i < 10; i++) {
+      map[String(i)] = fmt.format(i);
+    }
+  }
+  digitMapCache.set(system, map);
+  return map;
+}
+function convertDigitsToAscii(s, system) {
+  if (system === "latn") return s;
+  if (!SUPPORTED_NUMBERING_SYSTEMS.has(system)) {
+    throw new InvalidLocaleError({ actual: system, reason: `numbering system "${system}" is not supported.` });
+  }
+  const map = getDigitMap(system);
+  const reverse = {};
+  for (const k of Object.keys(map)) reverse[map[k]] = k;
+  let result = "";
+  for (const ch of s) {
+    result += reverse[ch] ?? ch;
+  }
+  return result;
+}
+function applyParseNumbering(s, options) {
+  const system = options.parseNumberingSystem ?? "latn";
+  if (system === "latn") return s;
+  return convertDigitsToAscii(s, system);
+}
+
+// src/parse.ts
+var patternCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE2 = 500;
+subscribeToVocabChanges(() => {
+  patternCache.clear();
+});
+function getPattern(formatStr, locale) {
+  const key = JSON.stringify([canonicalCacheKey(locale), formatStr]);
+  let pattern = patternCache.get(key);
+  if (pattern) {
+    return pattern;
+  }
+  if (patternCache.size >= MAX_CACHE_SIZE2) {
+    const oldestKey = patternCache.keys().next().value;
+    if (oldestKey !== void 0) patternCache.delete(oldestKey);
+  }
+  pattern = buildCapturingPattern(tokenize(formatStr), locale);
+  patternCache.set(key, pattern);
+  return pattern;
+}
+var calendarCache = /* @__PURE__ */ new Map();
+var MAX_CALENDAR_CACHE_SIZE = 500;
+function resolveCalendar(locale) {
+  assertValidLocaleTag(locale);
+  const canonicalLocale = canonicalCacheKey(locale);
+  if (calendarCache.has(canonicalLocale)) {
+    return calendarCache.get(canonicalLocale);
+  }
+  if (calendarCache.size >= MAX_CALENDAR_CACHE_SIZE) {
+    const oldestKey = calendarCache.keys().next().value;
+    if (oldestKey !== void 0) calendarCache.delete(oldestKey);
+  }
+  let calendar;
+  const parts = canonicalLocale.split("-");
+  const extensionIndex = parts.indexOf("u");
+  const calendarKeyIndex = extensionIndex === -1 ? -1 : parts.indexOf("ca", extensionIndex + 1);
+  if (calendarKeyIndex !== -1 && calendarKeyIndex + 1 < parts.length) {
+    const resolved = new Intl.DateTimeFormat(canonicalLocale).resolvedOptions().calendar;
+    calendar = resolved === "gregory" ? void 0 : resolved;
+  }
+  calendarCache.set(canonicalLocale, calendar);
+  return calendar;
+}
+function parseOffsetString(raw, token) {
+  if (raw === "Z") {
+    /* c8 ignore start @preserve -- unreachable: lowercase tokens' regex
+       (OFFSET_SHAPES in pattern.ts) has no "Z" alternative at all, so
+       raw === 'Z' can only ever be reached when token is one of the
+       uppercase variants (X/XX/XXX). A lowercase token can't even
+       capture "Z" as `raw` in the first place. */
+    if (token === "x" || token === "xx" || token === "xxx") {
+      throw new Error(
+        `temporal-fmt: offset token "${token}" doesn't accept "Z" \u2014 only the uppercase variants (X/XX/XXX) emit "Z" for UTC. Use "+00:00", "+0000", or "+00" depending on the variant's width.`
+      );
+    }
+    /* c8 ignore stop @preserve */
+    return "+00:00";
+  }
+  const sign = raw[0];
+  /* c8 ignore start @preserve -- unreachable: raw is a regex-captured
+     group from an offset token, and every OFFSET_SHAPES pattern
+     (pattern.ts) is anchored to either "Z" or a leading [+-]. raw's
+     first character can never be anything else by the time it reaches
+     this function. */
+  if (sign !== "+" && sign !== "-") {
+    throw new Error(`temporal-fmt: offset "${raw}" for token "${token}" doesn't start with "+", "-", or "Z".`);
+  }
+  /* c8 ignore stop @preserve */
+  const body = raw.slice(1);
+  let hoursStr;
+  let minutesStr;
+  if (body.length === 2) {
+    /* c8 ignore start @preserve -- unreachable: each offset token's own
+       regex shape in OFFSET_SHAPES (pattern.ts) already gates which
+       body shapes it can capture. Only X and x ever match a 2-digit
+       body — XX/xx/XXX/xxx's regexes can't produce one — so this
+       mismatch can never actually fire through parse(). */
+    if (token !== "X" && token !== "x") {
+      throw new Error(
+        `temporal-fmt: offset token "${token}" can't match "${raw}" \u2014 it requires minutes, but "${raw}" has none.`
+      );
+    }
+    /* c8 ignore stop @preserve */
+    hoursStr = body;
+    minutesStr = "00";
+  } else if (body.length === 4) {
+    /* c8 ignore start @preserve -- unreachable, same reason as the
+       2-digit case above: XXX/xxx's regex requires a colon, so it can
+       never capture a 4-digit no-colon body in the first place. */
+    if (token === "XXX" || token === "xxx") {
+      throw new Error(
+        `temporal-fmt: offset token "${token}" can't match "${raw}" \u2014 it requires a colon between hours and minutes (e.g. "${sign}${body.slice(0, 2)}:${body.slice(2)}").`
+      );
+    }
+    /* c8 ignore stop @preserve */
+    hoursStr = body.slice(0, 2);
+    minutesStr = body.slice(2, 4);
+  } else if (body.length === 5 && body[2] === ":") {
+    /* c8 ignore start @preserve -- unreachable, same reason again: only
+       XXX/xxx's regex can produce a colon-shaped body; X/x/XX/xx never
+       capture one. */
+    if (token !== "XXX" && token !== "xxx") {
+      throw new Error(
+        `temporal-fmt: offset token "${token}" can't match "${raw}" \u2014 it doesn't use a colon (use "${sign}${body.slice(0, 2)}${body.slice(3)}" instead).`
+      );
+    }
+    /* c8 ignore stop @preserve */
+    hoursStr = body.slice(0, 2);
+    minutesStr = body.slice(3, 5);
+    /* c8 ignore start @preserve -- unreachable: every offset token's
+       regex only ever produces a body of length 2, length 4, or length 5
+       with a colon at index 2 (see OFFSET_SHAPES in pattern.ts) — no
+       shape falls outside those three cases, so this else arm can't be
+       taken through parse(). Kept as an exhaustiveness fallback so
+       hoursStr/minutesStr are assigned on every path TypeScript can see. */
+  } else {
+    throw new Error(`temporal-fmt: offset "${raw}" doesn't match the shape token "${token}" accepts.`);
+  }
+  /* c8 ignore stop @preserve */
+  const hours = Number(hoursStr);
+  const minutes = Number(minutesStr);
+  if (hours > 14) {
+    throw new InvalidOffsetError({
+      actual: raw,
+      message: `temporal-fmt: offset hours ${hours} in "${raw}" out of range (max 14 \u2014 Kiritimati, Line Islands is +14:00).`
+    });
+  }
+  if (minutes > 59) {
+    throw new InvalidOffsetError({
+      actual: raw,
+      message: `temporal-fmt: offset minutes ${minutes} in "${raw}" out of range (max 59).`
+    });
+  }
+  if (sign === "+" && hours === 14 && minutes !== 0) {
+    throw new InvalidOffsetError({
+      actual: raw,
+      message: `temporal-fmt: offset "${raw}" exceeds the maximum supported UTC offset of +14:00.`
+    });
+  }
+  if (sign === "-" && hours === 12 && minutes !== 0) {
+    throw new InvalidOffsetError({
+      actual: raw,
+      message: `temporal-fmt: offset "${raw}" exceeds the maximum supported negative UTC offset of -12:00.`
+    });
+  }
+  return `${sign}${hoursStr}:${minutesStr}`;
+}
+function assignField(fields, key, value) {
+  fields[key] = value;
+}
+function applyGroup(fields, token, raw, locale, formatStr) {
+  const vocab = getLocaleVocab(locale);
+  switch (token) {
+    case "yyyy":
+    case "y":
+      assignField(fields, "year", Number(raw));
+      break;
+    case "yy":
+      assignField(fields, "twoDigitYear", Number(raw));
+      break;
+    case "MM":
+    case "M":
+      assignField(fields, "month", Number(raw));
+      break;
+    case "MMMM":
+      assignField(fields, "month", vocab.monthLong.indexOf(raw) + 1);
+      break;
+    case "MMM":
+      assignField(fields, "month", vocab.monthShort.indexOf(raw) + 1);
+      break;
+    case "dd":
+    case "d":
+      assignField(fields, "day", Number(raw));
+      break;
+    case "EEEE":
+      assignField(fields, "weekdayRaw", raw);
+      assignField(fields, "weekdayExpected", vocab.weekdayLong.indexOf(raw) + 1);
+      break;
+    case "EEE":
+      assignField(fields, "weekdayRaw", raw);
+      assignField(fields, "weekdayExpected", vocab.weekdayShort.indexOf(raw) + 1);
+      break;
+    case "HH":
+    case "H":
+      assignField(fields, "hour", Number(raw));
+      break;
+    case "hh":
+    case "h":
+      assignField(fields, "hour12", Number(raw));
+      break;
+    case "mm":
+    case "m":
+      assignField(fields, "minute", Number(raw));
+      break;
+    case "ss":
+    case "s":
+      assignField(fields, "second", Number(raw));
+      break;
+    case "S":
+    case "SS":
+    case "SSS":
+    case "SSSS":
+    case "SSSSS":
+    case "SSSSSS":
+    case "SSSSSSS":
+    case "SSSSSSSS":
+    case "SSSSSSSSS": {
+      const nanoOfSecond = Number(raw.padEnd(9, "0"));
+      assignField(fields, "millisecond", Math.floor(nanoOfSecond / 1e6));
+      assignField(fields, "microsecond", Math.floor(nanoOfSecond / 1e3) % 1e3);
+      assignField(fields, "nanosecond", nanoOfSecond % 1e3);
+      break;
+    }
+    case "a": {
+      const periodIndex = vocab.dayPeriod.findIndex((p) => p.toLowerCase() === raw.toLowerCase());
+      /* c8 ignore start @preserve -- unreachable: the 'a' token's regex
+         fragment (pattern.ts's alternation() over vocab.dayPeriod) can
+         only ever capture a case-insensitive match of one of
+         vocab.dayPeriod's own entries. Both the regex and this lookup
+         derive their vocab from the same `locale` via getLocaleVocab(),
+         so periodIndex can't come back negative through parse(). */
+      if (periodIndex < 0) throw new Error(`temporal-fmt: unknown day period "${raw}" for locale "${locale}".`);
+      /* c8 ignore stop @preserve */
+      assignField(fields, "dayPeriodRaw", raw);
+      assignField(fields, "isPM", periodIndex === 1);
+      break;
+    }
+    case "zzz":
+      assignField(fields, "timeZoneId", raw);
+      break;
+    case "X":
+    case "XX":
+    case "XXX":
+    case "x":
+    case "xx":
+    case "xxx":
+      assignField(fields, "offsetString", parseOffsetString(raw, token));
+      break;
+    case "Q":
+      assignField(fields, "quarter", Number(raw));
+      break;
+    case "QQQ":
+      assignField(fields, "quarter", Number(raw.slice(1)));
+      break;
+  }
+}
+function pickLenientSplit(splits, tokens) {
+  const dayIndex = tokens.indexOf("d");
+  if (dayIndex !== -1) {
+    const smallDaySplits = splits.filter((s) => s[dayIndex] <= 12);
+    if (smallDaySplits.length > 0) {
+      return smallDaySplits[0];
+    }
+  }
+  return splits[0];
+}
+function resolveYear(fields) {
+  if (fields.year !== void 0 && fields.twoDigitYear !== void 0) {
+    throw new FormatSyntaxError({
+      message: 'temporal-fmt: format string mixes a full-year token ("yyyy"/"y") with the two-digit "yy" token.'
+    });
+  }
+  if (fields.year !== void 0) return fields.year;
+  if (fields.twoDigitYear !== void 0) {
+    return fields.twoDigitYear <= 68 ? 2e3 + fields.twoDigitYear : 1900 + fields.twoDigitYear;
+  }
+  return void 0;
+}
+function resolveHour(fields, formatStr, locale) {
+  if (fields.hour !== void 0 && fields.hour12 !== void 0) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" mixes a 24-hour token ("HH"/"H") with a 12-hour token ("hh"/"h").`
+    });
+  }
+  if (fields.hour !== void 0) {
+    if (fields.dayPeriodRaw !== void 0) {
+      throw new FormatSyntaxError({
+        format: formatStr,
+        message: `temporal-fmt: format string "${formatStr}" mixes a 24-hour token ("HH"/"H") with a day-period token ("a"). Both describe the same field; use one or the other, not both.`
+      });
+    }
+    return fields.hour;
+  }
+  if (fields.hour12 !== void 0) {
+    if (fields.isPM === void 0) {
+      throw new FormatSyntaxError({
+        format: formatStr,
+        message: `temporal-fmt: format string "${formatStr}" uses a 12-hour token ("hh"/"h") without an "a" token, so parse() can't tell AM from PM.`
+      });
+    }
+    return fields.hour12 % 12 + (fields.isPM ? 12 : 0);
+  }
+  return void 0;
+}
+function parse(formatStr, input, options = {}) {
+  if (formatStr.length > MAX_FORMAT_LENGTH) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
+    });
+  }
+  if (input.length > MAX_INPUT_LENGTH) {
+    throw new FormatSyntaxError({
+      input,
+      message: `temporal-fmt: input exceeds maximum length of ${MAX_INPUT_LENGTH} characters (got ${input.length}).`
+    });
+  }
+  if (options.parseNumberingSystem) {
+    input = applyParseNumbering(input, options);
+  }
+  const locale = options.locale ?? DEFAULT_LOCALE;
+  const calendar = resolveCalendar(locale);
+  const pattern = getPattern(formatStr, locale);
+  const match = pattern.regex.exec(input);
+  if (!match) {
+    throw new ParseMismatchError({
+      input,
+      format: formatStr,
+      // reason set explicitly (not just message): parse.test.js's
+      // "safeParse: failure returns { ok: false, error } with a
+      // TemporalFmtError" asserts result.error.reason carries the
+      // underlying detail text, matching what wrapUntypedError used to
+      // populate when this message reached it as a caught plain Error.
+      reason: "no valid pattern matches the format string and input shape",
+      message: `temporal-fmt: no valid pattern matches the format string and input shape`
+    });
+  }
+  if (pattern.groups.length === 0) {
+    throw new ParseMismatchError({
+      format: formatStr,
+      // reason set explicitly: errors.test.js's "format string with no
+      // tokens at all falls through to ParseMismatchError" asserts
+      // error.reason matches /has no tokens/.
+      reason: `format string "${formatStr}" has no tokens \u2014 nothing to parse into a value.`,
+      message: `temporal-fmt: format string "${formatStr}" has no tokens \u2014 nothing to parse into a value.`
+    });
+  }
+  for (const { name, token } of pattern.groups) {
+    if (token === "zzz" && !isValidTimeZone(match.groups[name])) {
+      throw new InvalidTimeZoneError({
+        input,
+        format: formatStr,
+        actual: match.groups[name],
+        reason: "not a recognized IANA time zone identifier"
+      });
+    }
+  }
+  const runValues = /* @__PURE__ */ new Map();
+  for (const run of pattern.ambiguousRuns) {
+    const runDigits = match.groups[run.groupName];
+    const splits = enumerateValidSplits(runDigits, run.tokens);
+    if (splits.length === 0) {
+      throw new ParseMismatchError({
+        input,
+        format: formatStr,
+        reason: "no valid pattern matches the format string and input shape",
+        message: `temporal-fmt: no valid pattern matches the format string and input shape`
+      });
+    }
+    if (splits.length > 1) {
+      if (!options.lenient) {
+        throw new AmbiguousInputError({
+          input,
+          format: formatStr,
+          message: `temporal-fmt: "${runDigits}" in format string "${formatStr}" is ambiguous \u2014 ${splits.length} different ways to read tokens "${run.tokens.join("")}" (with no separator between them) are all individually valid (e.g. ${JSON.stringify(splits[0])} vs ${JSON.stringify(splits[1])}). parse() won't guess; add a separator between these tokens, or use their padded form (e.g. "MM" instead of "M") so each one has a fixed width. Pass { lenient: true } to opt into a documented heuristic that picks one.`
+        });
+      }
+      const picked = pickLenientSplit(splits, run.tokens);
+      run.groupNames.forEach((name, idx) => runValues.set(name, String(picked[idx])));
+    } else {
+      run.groupNames.forEach((name, idx) => runValues.set(name, String(splits[0][idx])));
+    }
+  }
+  const fields = {};
+  for (const { name, token } of pattern.groups) {
+    const raw = runValues.get(name) ?? match.groups[name];
+    applyGroup(fields, token, raw, locale, formatStr);
+  }
+  const year = resolveYear(fields);
+  const hour = resolveHour(fields, formatStr, locale);
+  const { month, day, minute, second, millisecond, microsecond, nanosecond, timeZoneId, offsetString, weekdayExpected, weekdayRaw, quarter } = fields;
+  const hasAnyDatePart = year !== void 0 || month !== void 0 || day !== void 0;
+  const hasFullDate = year !== void 0 && month !== void 0 && day !== void 0;
+  if (hasAnyDatePart && !hasFullDate) {
+    throw new InvalidDateError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has an incomplete date \u2014 year, month, and day tokens must all be present together.`
+    });
+  }
+  const hasTime = hour !== void 0 || minute !== void 0 || second !== void 0 || millisecond !== void 0;
+  if (timeZoneId !== void 0 && !(hasFullDate && hasTime)) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has a "zzz" token but needs a full date and time to build a ZonedDateTime.`
+    });
+  }
+  if (offsetString !== void 0 && !(hasFullDate && hasTime)) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has an offset token (X/XX/XXX/x/xx/xxx) but needs a full date and time to build a ZonedDateTime.`
+    });
+  }
+  if (weekdayExpected !== void 0 && !hasFullDate) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has a weekday token ("EEEE"/"EEE") but needs a full date to validate it against.`
+    });
+  }
+  if (!hasFullDate && !hasTime) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string "${formatStr}" has no date or time tokens to parse.`
+    });
+  }
+  const temporal = getTemporal();
+  const timeFields = {
+    hour: hour ?? 0,
+    minute: minute ?? 0,
+    second: second ?? 0,
+    millisecond: millisecond ?? 0,
+    microsecond: microsecond ?? 0,
+    nanosecond: nanosecond ?? 0
+  };
+  const calendarField = calendar ? { calendar } : {};
+  const reject = { overflow: "reject" };
+  let result;
+  try {
+    if (timeZoneId !== void 0) {
+      const zoneOptions = { overflow: "reject", offset: "prefer" };
+      result = temporal.ZonedDateTime.from(
+        {
+          year,
+          month,
+          day,
+          ...timeFields,
+          ...calendarField,
+          timeZone: timeZoneId,
+          ...offsetString !== void 0 ? { offset: offsetString } : {}
+        },
+        zoneOptions
+      );
+      if (offsetString !== void 0) {
+        const zdt = result;
+        const wallClockShifted = zdt.hour !== timeFields.hour || zdt.minute !== timeFields.minute || zdt.second !== timeFields.second;
+        if (wallClockShifted) {
+          throw new InvalidDateError({
+            input,
+            format: formatStr,
+            message: `"${timeZoneId}" has no such wall-clock time on this date \u2014 it falls in a DST gap, not an ambiguous or valid instant.`
+          });
+        }
+        const actualOffset = zdt.offset;
+        if (actualOffset !== offsetString) {
+          throw new ParseMismatchError({
+            input,
+            format: formatStr,
+            message: `has both a "zzz" zone (${timeZoneId}) and an offset token (${offsetString}), but the zone's actual offset at this date/time is ${actualOffset}, not ${offsetString}.`
+          });
+        }
+      }
+    } else if (offsetString !== void 0) {
+      throw new ParseMismatchError({
+        input,
+        format: formatStr,
+        message: `format string "${formatStr}" has an offset token but no "zzz" zone token. An offset does not identify a time zone by itself \u2014 add "zzz" to the pattern, or parse into a PlainDateTime/PlainDate/PlainTime if a zone isn't needed.`
+      });
+    } else if (hasFullDate && hasTime) {
+      result = temporal.PlainDateTime.from({ year, month, day, ...timeFields, ...calendarField }, reject);
+    } else if (hasFullDate) {
+      result = temporal.PlainDate.from({ year, month, day, ...calendarField }, reject);
+    } else {
+      result = temporal.PlainTime.from(timeFields, reject);
+    }
+  } catch (err) {
+    throw new InvalidDateError({
+      input,
+      format: formatStr,
+      message: `temporal-fmt: "${input}" doesn't describe a valid date/time for format "${formatStr}": ${err.message}`
+    });
+  }
+  if (weekdayExpected !== void 0) {
+    const actual = result.dayOfWeek;
+    if (actual !== weekdayExpected) {
+      const vocab = getLocaleVocab(locale);
+      throw new InvalidDateError({
+        input,
+        format: formatStr,
+        message: `temporal-fmt: "${weekdayRaw}" doesn't match the actual weekday (${vocab.weekdayLong[actual - 1]}) for the parsed date.`
+      });
+    }
+  }
+  if (quarter !== void 0 && month !== void 0) {
+    const expectedQuarter = Math.ceil(month / 3);
+    if (quarter !== expectedQuarter) {
+      throw new InvalidDateError({
+        format: formatStr,
+        message: `temporal-fmt: format string "${formatStr}" contains a quarter token (Q/QQQ) whose value (Q${quarter}) disagrees with the parsed month's actual quarter \u2014 month ${month} is in Q${expectedQuarter}.`
+      });
+    }
+  }
+  return result;
+}
+function safeParse(formatStr, input, options = {}) {
+  try {
+    return { ok: true, value: parse(formatStr, input, options) };
+  } catch (err) {
+    /* c8 ignore start @preserve */
+    if (err instanceof TemporalFmtError) {
+      return { ok: false, error: err };
+    }
+    return { ok: false, error: wrapUntypedError(err, { input, format: formatStr }) };
+  }
+  /* c8 ignore stop @preserve */
+}
+function tryParse(formatStr, input, options = {}) {
+  try {
+    return parse(formatStr, input, options);
+  } catch {
+    return void 0;
+  }
+}
+function parseToParts(formatStr, input, options = {}) {
+  if (formatStr.length > MAX_FORMAT_LENGTH) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
+    });
+  }
+  if (input.length > MAX_INPUT_LENGTH) {
+    throw new FormatSyntaxError({
+      input,
+      message: `temporal-fmt: input exceeds maximum length of ${MAX_INPUT_LENGTH} characters (got ${input.length}).`
+    });
+  }
+  if (options.parseNumberingSystem) {
+    input = applyParseNumbering(input, options);
+  }
+  const locale = options.locale ?? DEFAULT_LOCALE;
+  const pattern = getPattern(formatStr, locale);
+  const match = pattern.regex.exec(input);
+  if (!match) {
+    throw new ParseMismatchError({
+      input,
+      format: formatStr,
+      // reason set explicitly (not just message): parse.test.js's
+      // "safeParse: failure returns { ok: false, error } with a
+      // TemporalFmtError" asserts result.error.reason carries the
+      // underlying detail text, matching what wrapUntypedError used to
+      // populate when this message reached it as a caught plain Error.
+      reason: "no valid pattern matches the format string and input shape",
+      message: `temporal-fmt: no valid pattern matches the format string and input shape`
+    });
+  }
+  if (pattern.groups.length === 0) {
+    throw new ParseMismatchError({
+      format: formatStr,
+      // reason set explicitly: errors.test.js's "format string with no
+      // tokens at all falls through to ParseMismatchError" asserts
+      // error.reason matches /has no tokens/.
+      reason: `format string "${formatStr}" has no tokens \u2014 nothing to parse into a value.`,
+      message: `temporal-fmt: format string "${formatStr}" has no tokens \u2014 nothing to parse into a value.`
+    });
+  }
+  for (const { name, token } of pattern.groups) {
+    if (token === "zzz" && !isValidTimeZone(match.groups[name])) {
+      throw new InvalidTimeZoneError({
+        input,
+        format: formatStr,
+        actual: match.groups[name],
+        reason: "not a recognized IANA time zone identifier"
+      });
+    }
+  }
+  const runValues = /* @__PURE__ */ new Map();
+  for (const run of pattern.ambiguousRuns) {
+    const runDigits = match.groups[run.groupName];
+    const splits = enumerateValidSplits(runDigits, run.tokens);
+    if (splits.length === 0) {
+      throw new ParseMismatchError({
+        input,
+        format: formatStr,
+        reason: "no valid pattern matches the format string and input shape",
+        message: `temporal-fmt: no valid pattern matches the format string and input shape`
+      });
+    }
+    if (splits.length > 1) {
+      if (!options.lenient) {
+        throw new AmbiguousInputError({
+          input,
+          format: formatStr,
+          message: `temporal-fmt: "${runDigits}" in format string "${formatStr}" is ambiguous \u2014 ${splits.length} different ways to read tokens "${run.tokens.join("")}" (with no separator between them) are all individually valid (e.g. ${JSON.stringify(splits[0])} vs ${JSON.stringify(splits[1])}). parse() won't guess; add a separator between these tokens, or use their padded form (e.g. "MM" instead of "M") so each one has a fixed width. Pass { lenient: true } to opt into a documented heuristic that picks one.`
+        });
+      }
+      const picked = pickLenientSplit(splits, run.tokens);
+      run.groupNames.forEach((name, idx) => runValues.set(name, String(picked[idx])));
+    } else {
+      run.groupNames.forEach((name, idx) => runValues.set(name, String(splits[0][idx])));
+    }
+  }
+  const parts = [];
+  const indices = match.indices;
+  const groupIndices = indices?.groups;
+  let consumed = 0;
+  for (const { name, token } of pattern.groups) {
+    const raw = runValues.get(name) ?? match.groups[name];
+    const fromIndices = !runValues.has(name) && groupIndices?.[name];
+    const position = fromIndices ? fromIndices[0] : (match.index ?? 0) + consumed;
+    parts.push({ token, raw, position });
+    consumed += raw.length;
+  }
+  return parts;
+}
+function compileParser(formatStr, options = {}) {
+  if (formatStr.length > MAX_FORMAT_LENGTH) {
+    throw new FormatSyntaxError({
+      format: formatStr,
+      message: `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
+    });
+  }
+  const locale = options.locale ?? DEFAULT_LOCALE;
+  const pattern = getPattern(formatStr, locale);
+  return {
+    formatStr,
+    pattern,
+    parse(input, opts = {}) {
+      return parse(formatStr, input, { locale, ...opts });
+    },
+    safeParse(input, opts = {}) {
+      return safeParse(formatStr, input, { locale, ...opts });
+    },
+    tryParse(input, opts = {}) {
+      return tryParse(formatStr, input, { locale, ...opts });
+    },
+    parseToParts(input, opts = {}) {
+      return parseToParts(formatStr, input, { locale, ...opts });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileParser,
+  parse,
+  parseToParts,
+  safeParse,
+  tryParse
+});
 //# sourceMappingURL=parse.cjs.map