temporal-fmt 0.9.2 → 0.9.4

package/dist/format.cjs

@@ -1,39 +1,837 @@
-"use strict";var V=Object.defineProperty;var Q=Object.getOwnPropertyDescriptor;var J=Object.getOwnPropertyNames;var ee=Object.prototype.hasOwnProperty;var te=(e,t)=>{for(var n in t)V(e,n,{get:t[n],enumerable:!0})},ne=(e,t,n,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of J(t))!ee.call(e,i)&&i!==n&&V(e,i,{get:()=>t[i],enumerable:!(o=Q(t,i))||o.enumerable});return e};var oe=e=>ne(V({},"__esModule",{value:!0}),e);var Le={};te(Le,{_getPieces:()=>Ee,_handlerFor:()=>be,compileFormat:()=>ke,format:()=>we,formatToParts:()=>Te});module.exports=oe(Le);var re,ae=[];function W(e){ae.push(e)}function ie(){return re??globalThis.Temporal}function K(){let e=ie();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 w=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 o=Error.captureStackTrace;typeof o=="function"&&o(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}}},c=class extends w{constructor(t){let{message:n,...o}=t;super(n??`format string "${t.format??""}" has a syntax error${t.reason?`: ${t.reason}`:""}.`,{code:"FORMAT_SYNTAX_ERROR",...o}),this.name="FormatSyntaxError"}},d=class extends w{constructor(t){let{message:n,...o}=t;super(n??`token "${t.token??""}" is not a recognized temporal-fmt token${t.format?` in format string "${t.format}"`:""}.`,{code:"UNKNOWN_TOKEN",...o}),this.name="UnknownTokenError"}};/* 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/format.ts
+var format_exports = {};
+__export(format_exports, {
+  _getPieces: () => _getPieces,
+  _handlerFor: () => _handlerFor,
+  compileFormat: () => compileFormat,
+  format: () => format,
+  formatToParts: () => formatToParts
+});
+module.exports = __toCommonJS(format_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";
+  }
+};
+/* 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 *//* 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 */
+/* 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 g=class extends w{constructor(t){let{message:n,...o}=t;super(n??`locale "${t.actual??""}" is not a valid BCP-47 tag${t.reason?`: ${t.reason}`:""}.`,{code:"INVALID_LOCALE",...o}),this.name="InvalidLocaleError"}};/* c8 ignore start @preserve -- unreachable from the current test suite,
-   see rationale above *//* c8 ignore stop @preserve */var se=new Map;function R(e){return e.replace(/_/g,"-")}var T=new Map,me=500;function X(e){let t=T.get(e);if(t!==void 0)return t;let n;try{n=new Intl.Locale(e.replace(/_/g,"-")).toString().toLowerCase()}catch{n=e}if(T.size>=me){let o=T.keys().next().value;o!==void 0&&T.delete(o)}return T.set(e,n),n}function u(e){let t=X(e);return se.get(t)}var ce=[0,31,59,90,120,151,181,212,243,273,304,334];function Y(e){return e%4===0&&e%100!==0||e%400===0}function k(e){return Y(e)?366:365}function E(e,t,n){let o=ce[t-1]+n;return t>2&&Y(e)&&(o+=1),o}var U=2e3;function le(e){let t=0;if(e>=U)for(let o=U;o<e;o++)t+=k(o);else for(let o=e;o<U;o++)t-=k(o);return((5+t)%7+7)%7+1}function Z(e,t,n,o){let a=E(e,t,n)+(4-o),r,s;a<1?(r=e-1,s=a+k(r)):a>k(e)?(r=e+1,s=a-k(e)):(r=e,s=a);let I=1+(4-le(r)+7)%7,M=1+Math.floor((s-I)/7);return{isoYear:r,week:M}}function m(e,t){let n=e<0,o=String(Math.abs(e)).padStart(t,"0");return n?"-"+o:o}m.fraction=function(t,n){let o=t.millisecond*1e6+(t.microsecond??0)*1e3+(t.nanosecond??0);return m(o,9).slice(0,n)};var S="en-US",b=new Map,ue=500;function j(e,t){let n=JSON.stringify([X(e),t]),o=b.get(n);if(o)return o;if(b.size>=ue){let i=b.keys().next().value;i!==void 0&&b.delete(i)}try{o=new Intl.DateTimeFormat(R(e),t)}catch(i){throw new g({actual:e,reason:i.message})}return b.set(n,o),o}var L;W(()=>{L=void 0});function de(){if(L===void 0){L=!1;try{let e=K();new Intl.DateTimeFormat("en-US",{day:"numeric"}).formatToParts(e.PlainDate.from({year:1970,month:1,day:1})),L=!0}catch{}}return L}function F(e,t,n,o){let i=e?.calendarId,a={...n,calendar:i&&i!=="iso8601"?i:"gregory"},r=e.toLocaleString;if(typeof r!="function"||r===Object.prototype.toLocaleString)throw new Error(`temporal-fmt: locale-aware part "${o}" 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(!de())try{return r.call(e,R(t),a)}catch(y){throw y instanceof RangeError?new g({actual:t,reason:y.message}):y}let{toInstant:s,timeZoneId:l}=e,I=typeof s=="function"&&typeof l=="string",M=I?e.toInstant():e,B={...a,...I?{timeZone:l}:{}},v=j(t,B).formatToParts(M),N=v.findIndex(y=>y.type===o);if(N===-1)throw new Error(`temporal-fmt: locale "${t}" produced no "${o}" part for this token. This usually means the Temporal object is missing the field the token needs.`);let h=v[N].value,_=v[N-1],C=v[N+1];return _?.type==="literal"&&!/\s/.test(_.value)&&(h=_.value+h),C?.type==="literal"&&!/\s/.test(C.value)&&(h=h+C.value),h}function pe(e,t){let n=u(t);if(n)return e<12?n.dayPeriod[0]:n.dayPeriod[1];let o=new Date(Date.UTC(1970,0,1,e)),a=j(t,{hour:"numeric",hour12:!0,timeZone:"UTC"}).formatToParts(o).find(r=>r.type==="dayPeriod");if(!a)throw new Error(`temporal-fmt: locale "${t}" produced no "dayPeriod" part for token "a".`);return a.value}function p(e,t,n,o,i,a){return i&&a!==void 0&&a>=0&&a<i.length?i[a]:F(e,t,n,o)}function f(e,t){if(e==="+00:00"&&(t==="X"||t==="XX"||t==="XXX"))return"Z";let n=e[0],o=e.slice(1,3),i=e.slice(4,6);switch(t){case"X":case"x":return i==="00"?`${n}${o}`:`${n}${o}${i}`;case"XX":case"xx":return`${n}${o}${i}`;case"XXX":case"xxx":return`${n}${o}:${i}`}}var A=[["yyyy",e=>m(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 m(e.year%100,2)},"year"],["MMMM",(e,t)=>{let n=u(t);return p(e,t,{month:"long"},"month",n?.monthLong,e.month-1)},"month"],["MMM",(e,t)=>{let n=u(t);return p(e,t,{month:"short"},"month",n?.monthShort,e.month-1)},"month"],["MM",e=>m(e.month,2),"month"],["M",e=>String(e.month),"month"],["dd",e=>m(e.day,2),"day"],["d",e=>String(e.day),"day"],["EEEE",(e,t)=>{let n=u(t);return p(e,t,{weekday:"long"},"weekday",n?.weekdayLong,e.dayOfWeek-1)},"dayOfWeek"],["EEE",(e,t)=>{let n=u(t);return p(e,t,{weekday:"short"},"weekday",n?.weekdayShort,e.dayOfWeek-1)},"dayOfWeek"],["HH",e=>m(e.hour,2),"hour"],["H",e=>String(e.hour),"hour"],["hh",e=>m(e.hour%12||12,2),"hour"],["h",e=>String(e.hour%12||12),"hour"],["mm",e=>m(e.minute,2),"minute"],["m",e=>String(e.minute),"minute"],["ss",e=>m(e.second,2),"second"],["s",e=>String(e.second),"second"],["SSSSSSSSS",e=>m.fraction(e,9),"millisecond"],["SSSSSSSS",e=>m.fraction(e,8),"millisecond"],["SSSSSSS",e=>m.fraction(e,7),"millisecond"],["SSSSSS",e=>m.fraction(e,6),"millisecond"],["SSSSS",e=>m.fraction(e,5),"millisecond"],["SSSS",e=>m.fraction(e,4),"millisecond"],["SSS",e=>m.fraction(e,3),"millisecond"],["SS",e=>m.fraction(e,2),"millisecond"],["S",e=>m.fraction(e,1),"millisecond"],["a",(e,t)=>pe(e.hour,t),"hour"],["zzz",e=>e.timeZoneId,"timeZoneId"],["xxx",e=>f(e.offset,"xxx"),"offset"],["xx",e=>f(e.offset,"xx"),"offset"],["X",e=>f(e.offset,"X"),"offset"],["XX",e=>f(e.offset,"XX"),"offset"],["XXX",e=>f(e.offset,"XXX"),"offset"],["x",e=>f(e.offset,"x"),"offset"],["do",e=>{let t=e.day,n=t%10,o=t%100;return o>=11&&o<=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}=Z(e.year,e.month,e.day,e.dayOfWeek);return m(t,2)},"dayOfWeek"],["RRRR",e=>{let{isoYear:t}=Z(e.year,e.month,e.day,e.dayOfWeek);return m(t,4)},"dayOfWeek"],["D",e=>String(E(e.year,e.month,e.day)),"day"],["DD",e=>m(E(e.year,e.month,e.day),2),"day"],["DDD",e=>m(E(e.year,e.month,e.day),3),"day"],["LLLL",(e,t)=>{let n=u(t);return p(e,t,{month:"long"},"month",n?.monthLong,e.month-1)},"month"],["LLL",(e,t)=>{let n=u(t);return p(e,t,{month:"short"},"month",n?.monthShort,e.month-1)},"month"],["cccc",(e,t)=>{let n=u(t);return p(e,t,{weekday:"long"},"weekday",n?.weekdayLong,e.dayOfWeek-1)},"dayOfWeek"],["ccc",(e,t)=>{let n=u(t);return p(e,t,{weekday:"short"},"weekday",n?.weekdayShort,e.dayOfWeek-1)},"dayOfWeek"],["GGGG",(e,t)=>F(e,t,{era:"long"},"era"),"year"],["G",(e,t)=>F(e,t,{era:"short"},"era"),"year"],["zzzz",(e,t)=>F(e,t,{timeZoneName:"longGeneric"},"timeZoneName"),"timeZoneId"],["z",(e,t)=>F(e,t,{timeZoneName:"short"},"timeZoneName"),"timeZoneId"]];var ge=A.map(([e])=>e).sort((e,t)=>t.length-e.length);function H(e){let t=[],n=0;for(;n<e.length;){let o=e[n];if(o==="'"){if(e[n+1]==="'"){z(t,"'"),n+=2;continue}let a=n+1,r="",s=!1;for(;a<e.length;){if(e[a]==="'"){if(e[a+1]==="'"){r+="'",a+=2;continue}s=!0,a+=1;break}r+=e[a],a+=1}if(!s)throw new c({format:e,message:`temporal-fmt: unterminated quote in format string "${e}"`});z(t,r),n=a;continue}let i=ge.find(a=>e.startsWith(a,n));if(i){let a=i[i.length-1];if(e[n+i.length]===a){let r=n+i.length;for(;e[r]===a;)r+=1;throw new d({format:e,token:e.slice(n,r),message:`temporal-fmt: "${e.slice(n,r)}" in format string "${e}" isn't a recognized token \u2014 did you mean "${i}"?`})}t.push({kind:"token",value:i}),n+=i.length;continue}z(t,o),n+=1}return t}function z(e,t){let n=e[e.length-1];n&&n.kind==="literal"?n.value+=t:e.push({kind:"literal",value:t})}var G=new Set(["latn","arab","deva","beng","guru","gujr","orya","tamldec","telu","knda","mlym","fullwide","hanidec"]),q=new Map;function fe(e){let t=q.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 o=0;o<10;o++)t[String(o)]=n.format(o)}return q.set(e,t),t}function he(e,t){if(t==="latn")return e;if(!G.has(t))throw new g({actual:t,reason:`numbering system "${t}" is not supported. Supported: ${[...G].join(", ")}.`});let n=fe(t),o="";for(let i of e)i>="0"&&i<="9"?o+=n[i]??i:o+=i;return o}function x(e,t){let n=t.numberingSystem??"latn";return n==="latn"?e:he(e,n)}var O=new Map(A.map(([e,t,n])=>[e,{fn:t,field:n}])),$=new Map,ye=500;function P(e){let t=$.get(e);if(t)return t;if($.size>=ye){let n=$.keys().next().value;n!==void 0&&$.delete(n)}return t=H(e),$.set(e,t),t}function we(e,t,n={}){if(t.length>1e3)throw new c({format:t,message:`temporal-fmt: format string exceeds maximum length of ${1e3} characters (got ${t.length}).`});let o=n.locale??S,i=P(t),a="";for(let r of i){if(r.kind==="literal"){a+=r.value;continue}let s=O.get(r.value);/* c8 ignore start @preserve -- unreachable: tokenize() only ever emits
-   tokens present in TOKENS, and HANDLER_BY_TOKEN is built from that
-   same list, so every token piece.value can hold already has an entry
-   here. Same defensive-guard category as the twin checks in
-   analyze.ts/formatDuration.ts. */if(!s)throw new d({token:r.value,format:t,message:`temporal-fmt: unknown token "${r.value}"`});/* c8 ignore stop @preserve */if(e[s.field]===void 0)throw new c({format:t,token:r.value,message:`temporal-fmt: token "${r.value}" requires "${s.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`});a+=s.fn(e,o)}return x(a,n)}function Te(e,t,n={}){if(t.length>1e3)throw new c({format:t,message:`temporal-fmt: format string exceeds maximum length of ${1e3} characters (got ${t.length}).`});let o=n.locale??S,i=P(t),a=[];for(let r of i){if(r.kind==="literal"){let l=a[a.length-1];/* c8 ignore start @preserve -- unreachable through tokenize()'s own
-   output: appendLiteral() in tokenize.ts already merges every
-   adjacent literal character before pieces ever reaches here, so
-   two 'literal' pieces never sit back-to-back in the array this
-   loop walks. Kept as defense-in-depth in case that invariant ever
-   changes upstream. */if(l&&l.type==="literal")l.value+=r.value;else{/* c8 ignore stop @preserve */a.push({type:"literal",value:r.value})}continue}let s=O.get(r.value);/* c8 ignore start @preserve -- unreachable, see the note in format() above */if(!s)throw new d({token:r.value,format:t,message:`temporal-fmt: unknown token "${r.value}"`});/* c8 ignore stop @preserve */if(e[s.field]===void 0)throw new c({format:t,token:r.value,message:`temporal-fmt: token "${r.value}" requires "${s.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`});a.push({type:"token",value:x(s.fn(e,o),n),token:r.value})}return a}function ke(e){if(e.length>1e3)throw new c({format:e,message:`temporal-fmt: format string exceeds maximum length of ${1e3} characters (got ${e.length}).`});let t=P(e);return{formatStr:e,pieces:t,format(n,o={}){let i=o.locale??S,a="";for(let r of t){if(r.kind==="literal"){a+=r.value;continue}let s=O.get(r.value);if(!s)throw new d({token:r.value,format:e,message:`temporal-fmt: unknown token "${r.value}"`});if(n[s.field]===void 0)throw new c({format:e,token:r.value,message:`temporal-fmt: token "${r.value}" requires "${s.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`});a+=s.fn(n,i)}return x(a,o)},formatToParts(n,o={}){let i=o.locale??S,a=[];for(let r of t){if(r.kind==="literal"){let l=a[a.length-1];l&&l.type==="literal"?l.value+=r.value:a.push({type:"literal",value:r.value});continue}let s=O.get(r.value);if(!s)throw new d({token:r.value,format:e,message:`temporal-fmt: unknown token "${r.value}"`});if(n[s.field]===void 0)throw new c({format:e,token:r.value,message:`temporal-fmt: token "${r.value}" requires "${s.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`});a.push({type:"token",value:x(s.fn(n,i),o),token:r.value})}return a}}}function Ee(e){return P(e)}function be(e){return O.get(e)}0&&(module.exports={_getPieces,_handlerFor,compileFormat,format,formatToParts});
+   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 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 */
+/* c8 ignore stop @preserve */
+
+// src/localeVocab.ts
+var customVocabs = /* @__PURE__ */ new Map();
+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 getCustomVocab(locale) {
+  const cacheKey = canonicalCacheKey(locale);
+  return customVocabs.get(cacheKey);
+}
+
+// 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(format2) {
+  const pieces = [];
+  let i = 0;
+  while (i < format2.length) {
+    const ch = format2[i];
+    if (ch === "'") {
+      if (format2[i + 1] === "'") {
+        appendLiteral(pieces, "'");
+        i += 2;
+        continue;
+      }
+      let j = i + 1;
+      let literal = "";
+      let closed = false;
+      while (j < format2.length) {
+        if (format2[j] === "'") {
+          if (format2[j + 1] === "'") {
+            literal += "'";
+            j += 2;
+            continue;
+          }
+          closed = true;
+          j += 1;
+          break;
+        }
+        literal += format2[j];
+        j += 1;
+      }
+      if (!closed) {
+        throw new FormatSyntaxError({
+          format: format2,
+          message: `temporal-fmt: unterminated quote in format string "${format2}"`
+        });
+      }
+      appendLiteral(pieces, literal);
+      i = j;
+      continue;
+    }
+    const match = SORTED_TOKEN_STRINGS.find((tok) => format2.startsWith(tok, i));
+    if (match) {
+      const runChar = match[match.length - 1];
+      if (format2[i + match.length] === runChar) {
+        let end = i + match.length;
+        while (format2[end] === runChar) end += 1;
+        throw new UnknownTokenError({
+          format: format2,
+          token: format2.slice(i, end),
+          message: `temporal-fmt: "${format2.slice(i, end)}" in format string "${format2}" isn't a recognized token \u2014 did you mean "${match}"?`
+        });
+      }
+      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/constants.ts
+var MAX_FORMAT_LENGTH = 1e3;
+
+// 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 convertDigits(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. Supported: ${[...SUPPORTED_NUMBERING_SYSTEMS].join(", ")}.` });
+  }
+  const map = getDigitMap(system);
+  let result = "";
+  for (const ch of s) {
+    if (ch >= "0" && ch <= "9") {
+      result += map[ch] ?? ch;
+    } else {
+      result += ch;
+    }
+  }
+  return result;
+}
+function applyNumbering(s, options) {
+  const system = options.numberingSystem ?? "latn";
+  if (system === "latn") return s;
+  return convertDigits(s, system);
+}
+
+// src/format.ts
+var HANDLER_BY_TOKEN = new Map(TOKENS.map(([tok, fn, field]) => [tok, { fn, field }]));
+var tokenizeCache = /* @__PURE__ */ new Map();
+var MAX_TOKENIZE_CACHE_SIZE = 500;
+function getPieces(formatStr) {
+  let pieces = tokenizeCache.get(formatStr);
+  if (pieces) return pieces;
+  if (tokenizeCache.size >= MAX_TOKENIZE_CACHE_SIZE) {
+    const oldestKey = tokenizeCache.keys().next().value;
+    if (oldestKey !== void 0) tokenizeCache.delete(oldestKey);
+  }
+  pieces = tokenize(formatStr);
+  tokenizeCache.set(formatStr, pieces);
+  return pieces;
+}
+function format(temporal, 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 pieces = getPieces(formatStr);
+  let result = "";
+  for (const piece of pieces) {
+    if (piece.kind === "literal") {
+      result += piece.value;
+      continue;
+    }
+    const handler = HANDLER_BY_TOKEN.get(piece.value);
+    /* c8 ignore start @preserve -- unreachable: tokenize() only ever emits
+       tokens present in TOKENS, and HANDLER_BY_TOKEN is built from that
+       same list, so every token piece.value can hold already has an entry
+       here. Same defensive-guard category as the twin checks in
+       analyze.ts/formatDuration.ts. */
+    if (!handler) {
+      throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token "${piece.value}"` });
+    }
+    /* c8 ignore stop @preserve */
+    if (temporal[handler.field] === void 0) {
+      throw new FormatSyntaxError({
+        format: formatStr,
+        token: piece.value,
+        message: `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
+      });
+    }
+    result += handler.fn(temporal, locale);
+  }
+  return applyNumbering(result, options);
+}
+function formatToParts(temporal, 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 pieces = getPieces(formatStr);
+  const result = [];
+  for (const piece of pieces) {
+    if (piece.kind === "literal") {
+      const last = result[result.length - 1];
+      /* c8 ignore start @preserve -- unreachable through tokenize()'s own
+         output: appendLiteral() in tokenize.ts already merges every
+         adjacent literal character before pieces ever reaches here, so
+         two 'literal' pieces never sit back-to-back in the array this
+         loop walks. Kept as defense-in-depth in case that invariant ever
+         changes upstream. */
+      if (last && last.type === "literal") {
+        last.value += piece.value;
+      } else {
+        /* c8 ignore stop @preserve */
+        result.push({ type: "literal", value: piece.value });
+      }
+      continue;
+    }
+    const handler = HANDLER_BY_TOKEN.get(piece.value);
+    /* c8 ignore start @preserve -- unreachable, see the note in format() above */
+    if (!handler) {
+      throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token "${piece.value}"` });
+    }
+    /* c8 ignore stop @preserve */
+    if (temporal[handler.field] === void 0) {
+      throw new FormatSyntaxError({
+        format: formatStr,
+        token: piece.value,
+        message: `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
+      });
+    }
+    result.push({ type: "token", value: applyNumbering(handler.fn(temporal, locale), options), token: piece.value });
+  }
+  return result;
+}
+function compileFormat(formatStr) {
+  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 pieces = getPieces(formatStr);
+  return {
+    formatStr,
+    pieces,
+    format(temporal, options = {}) {
+      const locale = options.locale ?? DEFAULT_LOCALE;
+      let result = "";
+      for (const piece of pieces) {
+        if (piece.kind === "literal") {
+          result += piece.value;
+          continue;
+        }
+        const handler = HANDLER_BY_TOKEN.get(piece.value);
+        if (!handler) throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token "${piece.value}"` });
+        if (temporal[handler.field] === void 0) {
+          throw new FormatSyntaxError({
+            format: formatStr,
+            token: piece.value,
+            message: `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
+          });
+        }
+        result += handler.fn(temporal, locale);
+      }
+      return applyNumbering(result, options);
+    },
+    formatToParts(temporal, options = {}) {
+      const locale = options.locale ?? DEFAULT_LOCALE;
+      const out = [];
+      for (const piece of pieces) {
+        if (piece.kind === "literal") {
+          const last = out[out.length - 1];
+          if (last && last.type === "literal") last.value += piece.value;
+          else out.push({ type: "literal", value: piece.value });
+          continue;
+        }
+        const handler = HANDLER_BY_TOKEN.get(piece.value);
+        if (!handler) throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token "${piece.value}"` });
+        if (temporal[handler.field] === void 0) {
+          throw new FormatSyntaxError({
+            format: formatStr,
+            token: piece.value,
+            message: `temporal-fmt: token "${piece.value}" requires "${handler.field}", which this Temporal object doesn't have. (e.g. PlainDate has no time fields, PlainTime has no date fields)`
+          });
+        }
+        out.push({ type: "token", value: applyNumbering(handler.fn(temporal, locale), options), token: piece.value });
+      }
+      return out;
+    }
+  };
+}
+function _getPieces(formatStr) {
+  return getPieces(formatStr);
+}
+function _handlerFor(token) {
+  return HANDLER_BY_TOKEN.get(token);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _getPieces,
+  _handlerFor,
+  compileFormat,
+  format,
+  formatToParts
+});
 //# sourceMappingURL=format.cjs.map