temporal-fmt 0.9.2 → 0.9.4

package/dist/interval.js

@@ -1,2 +1,47 @@
-import{a,b,c,d,e,f,g,h,i,j,k,l,m,n}from"./chunk-F4RGUDA3.js";import"./chunk-4JWGUR4O.js";import"./chunk-R52YOKI3.js";import"./chunk-C5YESWFT.js";import"./chunk-3MZLTVP3.js";import"./chunk-5U5WJ465.js";import"./chunk-UJR6DHXY.js";import"./chunk-EHLRZULM.js";import"./chunk-C6ZZ62ET.js";export{b as contains,i as difference,m as formatRange,n as formatRangeToParts,g as intersection,d as intersects,a as interval,f as isAfter,e as isBefore,k as mergeIntervals,c as overlaps,l as splitInterval,j as subtract,h as union};
+import {
+  contains,
+  difference,
+  formatRange,
+  formatRangeToParts,
+  intersection,
+  intersects,
+  interval,
+  isAfter,
+  isBefore,
+  mergeIntervals,
+  overlaps,
+  splitInterval,
+  subtract,
+  union
+} from "./chunk-FBPHNRVW.js";
+import "./chunk-H7YQX25T.js";
+import "./chunk-ACKKWH5Z.js";
+import "./chunk-4N3WCGEY.js";
+import "./chunk-UOPAV3WX.js";
+import "./chunk-5UTV5VP6.js";
+import "./chunk-M3GDTHMT.js";
+import "./chunk-L24NPTAJ.js";
+import "./chunk-ZQZF5EXW.js";
+import "./chunk-YEUASGDK.js";
+import "./chunk-EGUUO6LE.js";
+import "./chunk-VNIUIQA4.js";
+import "./chunk-TSLPIURC.js";
+import "./chunk-HXY2GUUM.js";
+import "./chunk-MKPDLQKD.js";
+export {
+  contains,
+  difference,
+  formatRange,
+  formatRangeToParts,
+  intersection,
+  intersects,
+  interval,
+  isAfter,
+  isBefore,
+  mergeIntervals,
+  overlaps,
+  splitInterval,
+  subtract,
+  union
+};
 //# sourceMappingURL=interval.js.map

package/dist/localeRegistry.cjs

@@ -1,36 +1,379 @@
-"use strict";var L=Object.defineProperty;var R=Object.getOwnPropertyDescriptor;var K=Object.getOwnPropertyNames;var q=Object.prototype.hasOwnProperty;var v=(t,e)=>{for(var r in e)L(t,r,{get:e[r],enumerable:!0})},z=(t,e,r,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of K(e))!q.call(t,n)&&n!==r&&L(t,n,{get:()=>e[n],enumerable:!(o=R(e,n))||o.enumerable});return t};var B=t=>z(L({},"__esModule",{value:!0}),t);var tt={};v(tt,{getLocale:()=>J,hasLocale:()=>Q,registerLocale:()=>W});module.exports=B(tt);var E=class extends Error{code;input;format;token;position;expected;actual;reason;constructor(e,r){super(e),this.name="TemporalFmtError",this.code=r.code,this.input=r.input,this.format=r.format,this.token=r.token,this.position=r.position,this.expected=r.expected,this.actual=r.actual,this.reason=r.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}}};/* 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/localeRegistry.ts
+var localeRegistry_exports = {};
+__export(localeRegistry_exports, {
+  getLocale: () => getLocale,
+  hasLocale: () => hasLocale,
+  registerLocale: () => registerLocale
+});
+module.exports = __toCommonJS(localeRegistry_exports);
+
+// 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
+    };
+  }
+};
+/* 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 c=class extends E{constructor(e){let{message:r,...o}=e;super(r??`locale "${e.actual??""}" is not a valid BCP-47 tag${e.reason?`: ${e.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 f=new Map,V=500,b=256,I=256;function G(t,e){let r=[{key:"monthLong",length:12,label:"long month names"},{key:"monthShort",length:12,label:"short month names"},{key:"weekdayLong",length:7,label:"long weekday names"},{key:"weekdayShort",length:7,label:"short weekday names"},{key:"dayPeriod",length:2,label:"day period markers (AM/PM-equivalent)"}];for(let{key:o,length:n,label:a}of r){let s=t[o];if(s===void 0)throw new Error(`temporal-fmt: registerLocaleVocab for locale "${e}" is missing required field "${o}" (${a}).`);if(!Array.isArray(s))throw new Error(`temporal-fmt: registerLocaleVocab for locale "${e}": "${o}" must be an array, got ${typeof s}.`);if(s.length!==n)throw new Error(`temporal-fmt: registerLocaleVocab for locale "${e}": "${o}" must have exactly ${n} entries (got ${s.length}) \u2014 ${a}.`);s.forEach((i,g)=>{if(typeof i!="string"||i.length===0)throw new Error(`temporal-fmt: registerLocaleVocab for locale "${e}": "${o}[${g}]" must be a non-empty string, got ${String(i)}.`);if(i.length>I)throw new RangeError(`temporal-fmt: registerLocaleVocab for locale "${e}": "${o}[${g}]" is too long (maximum ${I} characters).`)})}if(u(t.monthLong,"MMMM month",e),u(t.monthShort,"MMM month",e),u(t.weekdayLong,"EEEE weekday",e),u(t.weekdayShort,"EEE weekday",e),t.dayPeriod[0]===t.dayPeriod[1])throw new Error(`temporal-fmt: registerLocaleVocab for locale "${e}": dayPeriod entries must differ (both are "${t.dayPeriod[0]}"); otherwise parse() can't tell AM from PM.`)}var X=[];function x(t,e){if(typeof t!="string"||t.length===0)throw new Error(`temporal-fmt: registerLocaleVocab requires a non-empty locale string, got ${String(t)}.`);if(t.length>b)throw new RangeError(`temporal-fmt: registerLocaleVocab locale is too long (maximum ${b} characters).`);G(e,t);let r=_(t);if(!f.has(r)&&f.size>=V)throw new RangeError(`temporal-fmt: registerLocaleVocab reached the ${V}-locale limit.`);f.set(r,{monthLong:[...e.monthLong],monthShort:[...e.monthShort],weekdayLong:[...e.weekdayLong],weekdayShort:[...e.weekdayShort],dayPeriod:[...e.dayPeriod]}),l.delete(r);for(let o of X)o()}function F(t){return t.replace(/_/g,"-")}var p=new Map,H=500;function _(t){let e=p.get(t);if(e!==void 0)return e;let r;try{r=new Intl.Locale(t.replace(/_/g,"-")).toString().toLowerCase()}catch{r=t}if(p.size>=H){let o=p.keys().next().value;o!==void 0&&p.delete(o)}return p.set(t,r),r}function Z(t){try{new Intl.Locale(F(t))}catch{throw new c({actual:t,reason:"not a valid BCP-47 locale tag"})}}var l=new Map,Y=500;function d(t,e,r){let o=t.formatToParts(e),n=o.findIndex(g=>g.type===r);/* 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(n===-1)throw new c({message:`temporal-fmt: locale produced no "${r}" part while building match vocabulary.`});/* c8 ignore stop @preserve */let a=o[n].value,s=o[n-1],i=o[n+1];return s?.type==="literal"&&!/\s/.test(s.value)&&(a=s.value+a),i?.type==="literal"&&!/\s/.test(i.value)&&(a=a+i.value),a}function u(t,e,r){let o=new Map;for(let n=0;n<t.length;n++){let a=o.get(t[n]);if(a!==void 0)throw new Error(`temporal-fmt: locale "${r}" renders ${e} index ${a} and ${n} identically ("${t[n]}"). parse() can't reliably tell these apart for this locale/token, so this combination isn't supported.`);o.set(t[n],n)}}function S(t){Z(t);let e=_(t),r=f.get(e);if(r)return r;let o=l.get(e);if(o)return o;let n=F(t),a=new Intl.DateTimeFormat(n,{month:"long",timeZone:"UTC"}),s=new Intl.DateTimeFormat(n,{month:"short",timeZone:"UTC"}),i=[],g=[];for(let m=0;m<12;m++){let h=new Date(Date.UTC(2020,m,1));i.push(d(a,h,"month")),g.push(d(s,h,"month"))}u(i,"MMMM month",t),u(g,"MMM month",t);let N=new Intl.DateTimeFormat(n,{weekday:"long",timeZone:"UTC"}),O=new Intl.DateTimeFormat(n,{weekday:"short",timeZone:"UTC"}),w=[],y=[];for(let m=0;m<7;m++){let h=new Date(Date.UTC(2024,0,1+m));w.push(d(N,h,"weekday")),y.push(d(O,h,"weekday"))}u(w,"EEEE weekday",t),u(y,"EEE weekday",t);let A=new Intl.DateTimeFormat(n,{hour:"numeric",hour12:!0,timeZone:"UTC"}),D=d(A,new Date(Date.UTC(2020,0,1,1)),"dayPeriod"),P=d(A,new Date(Date.UTC(2020,0,1,13)),"dayPeriod"),U=[...new Set([D,P])],k={monthLong:i,monthShort:g,weekdayLong:w,weekdayShort:y,dayPeriod:U};if(l.size>=Y){let m=l.keys().next().value;m!==void 0&&l.delete(m)}return l.set(e,k),k}var $=new Map,M=256,C=256;function T(t){try{return new Intl.Locale(t.replace(/_/g,"-")).toString().toLowerCase()}catch{return t}}function W(t,e){if(typeof t!="string"||t.length===0)throw new c({actual:String(t),reason:"locale string must be non-empty"});if(t.length>M)throw new c({actual:String(t.length),reason:`locale tag must be at most ${M} characters`});x(t,e),j(e,t);let r=T(t);$.set(r,{...e})}function j(t,e){let r=(o,n,a)=>{if(o!==void 0){if(!Array.isArray(o))throw new c({actual:String(o),reason:`locale "${e}": "${n}" must be an array`});if(o.length!==a)throw new c({actual:String(o.length),reason:`locale "${e}": "${n}" must have ${a} entries (got ${o.length})`});for(let s=0;s<o.length;s++){if(typeof o[s]!="string"||o[s].length===0)throw new c({actual:String(o[s]),reason:`locale "${e}": "${n}[${s}]" must be a non-empty string`});if(o[s].length>C)throw new c({actual:String(o[s].length),reason:`locale "${e}": "${n}[${s}]" must be at most ${C} characters`})}}};r(t.quartersLong,"quartersLong",4),r(t.quartersShort,"quartersShort",4),r(t.erasLong,"erasLong",2),r(t.erasShort,"erasShort",2),r(t.ordinals,"ordinals",4)}function J(t){let e=T(t),r=$.get(e);if(r)return r;try{return{...S(t)}}catch{return}}function Q(t){let e=T(t);return $.has(e)}0&&(module.exports={getLocale,hasLocale,registerLocale});
+   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();
+var MAX_CUSTOM_VOCABS = 500;
+var MAX_LOCALE_TAG_LENGTH = 256;
+var MAX_VOCAB_ENTRY_LENGTH = 256;
+function assertValidVocab(vocab, locale) {
+  const required = [
+    { key: "monthLong", length: 12, label: "long month names" },
+    { key: "monthShort", length: 12, label: "short month names" },
+    { key: "weekdayLong", length: 7, label: "long weekday names" },
+    { key: "weekdayShort", length: 7, label: "short weekday names" },
+    { key: "dayPeriod", length: 2, label: "day period markers (AM/PM-equivalent)" }
+  ];
+  for (const { key, length, label } of required) {
+    const value = vocab[key];
+    if (value === void 0) {
+      throw new Error(
+        `temporal-fmt: registerLocaleVocab for locale "${locale}" is missing required field "${key}" (${label}).`
+      );
+    }
+    if (!Array.isArray(value)) {
+      throw new Error(
+        `temporal-fmt: registerLocaleVocab for locale "${locale}": "${key}" must be an array, got ${typeof value}.`
+      );
+    }
+    if (value.length !== length) {
+      throw new Error(
+        `temporal-fmt: registerLocaleVocab for locale "${locale}": "${key}" must have exactly ${length} entries (got ${value.length}) \u2014 ${label}.`
+      );
+    }
+    value.forEach((entry, i) => {
+      if (typeof entry !== "string" || entry.length === 0) {
+        throw new Error(
+          `temporal-fmt: registerLocaleVocab for locale "${locale}": "${key}[${i}]" must be a non-empty string, got ${String(entry)}.`
+        );
+      }
+      if (entry.length > MAX_VOCAB_ENTRY_LENGTH) {
+        throw new RangeError(
+          `temporal-fmt: registerLocaleVocab for locale "${locale}": "${key}[${i}]" is too long (maximum ${MAX_VOCAB_ENTRY_LENGTH} characters).`
+        );
+      }
+    });
+  }
+  assertNoCollision(vocab.monthLong, "MMMM month", locale);
+  assertNoCollision(vocab.monthShort, "MMM month", locale);
+  assertNoCollision(vocab.weekdayLong, "EEEE weekday", locale);
+  assertNoCollision(vocab.weekdayShort, "EEE weekday", locale);
+  if (vocab.dayPeriod[0] === vocab.dayPeriod[1]) {
+    throw new Error(
+      `temporal-fmt: registerLocaleVocab for locale "${locale}": dayPeriod entries must differ (both are "${vocab.dayPeriod[0]}"); otherwise parse() can't tell AM from PM.`
+    );
+  }
+}
+var onVocabChanged = [];
+function registerLocaleVocab(locale, vocab) {
+  if (typeof locale !== "string" || locale.length === 0) {
+    throw new Error(`temporal-fmt: registerLocaleVocab requires a non-empty locale string, got ${String(locale)}.`);
+  }
+  if (locale.length > MAX_LOCALE_TAG_LENGTH) {
+    throw new RangeError(`temporal-fmt: registerLocaleVocab locale is too long (maximum ${MAX_LOCALE_TAG_LENGTH} characters).`);
+  }
+  assertValidVocab(vocab, locale);
+  const cacheKey = canonicalCacheKey(locale);
+  if (!customVocabs.has(cacheKey) && customVocabs.size >= MAX_CUSTOM_VOCABS) {
+    throw new RangeError(`temporal-fmt: registerLocaleVocab reached the ${MAX_CUSTOM_VOCABS}-locale limit.`);
+  }
+  customVocabs.set(cacheKey, {
+    monthLong: [...vocab.monthLong],
+    monthShort: [...vocab.monthShort],
+    weekdayLong: [...vocab.weekdayLong],
+    weekdayShort: [...vocab.weekdayShort],
+    dayPeriod: [...vocab.dayPeriod]
+  });
+  vocabCache.delete(cacheKey);
+  for (const listener of onVocabChanged) 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 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/localeRegistry.ts
+var extendedVocabs = /* @__PURE__ */ new Map();
+var MAX_LOCALE_TAG_LENGTH2 = 256;
+var MAX_VOCAB_STRING_LENGTH = 256;
+function canonicalKey(locale) {
+  try {
+    return new Intl.Locale(locale.replace(/_/g, "-")).toString().toLowerCase();
+  } catch {
+    return locale;
+  }
+}
+function registerLocale(locale, vocab) {
+  if (typeof locale !== "string" || locale.length === 0) {
+    throw new InvalidLocaleError({ actual: String(locale), reason: "locale string must be non-empty" });
+  }
+  if (locale.length > MAX_LOCALE_TAG_LENGTH2) {
+    throw new InvalidLocaleError({ actual: String(locale.length), reason: `locale tag must be at most ${MAX_LOCALE_TAG_LENGTH2} characters` });
+  }
+  registerLocaleVocab(locale, vocab);
+  validateExtended(vocab, locale);
+  const key = canonicalKey(locale);
+  extendedVocabs.set(key, { ...vocab });
+}
+function validateExtended(vocab, locale) {
+  const checkArray = (val, key, length) => {
+    if (val === void 0) return;
+    if (!Array.isArray(val)) {
+      throw new InvalidLocaleError({ actual: String(val), reason: `locale "${locale}": "${key}" must be an array` });
+    }
+    if (val.length !== length) {
+      throw new InvalidLocaleError({ actual: String(val.length), reason: `locale "${locale}": "${key}" must have ${length} entries (got ${val.length})` });
+    }
+    for (let i = 0; i < val.length; i++) {
+      if (typeof val[i] !== "string" || val[i].length === 0) {
+        throw new InvalidLocaleError({ actual: String(val[i]), reason: `locale "${locale}": "${key}[${i}]" must be a non-empty string` });
+      }
+      if (val[i].length > MAX_VOCAB_STRING_LENGTH) {
+        throw new InvalidLocaleError({ actual: String(val[i].length), reason: `locale "${locale}": "${key}[${i}]" must be at most ${MAX_VOCAB_STRING_LENGTH} characters` });
+      }
+    }
+  };
+  checkArray(vocab.quartersLong, "quartersLong", 4);
+  checkArray(vocab.quartersShort, "quartersShort", 4);
+  checkArray(vocab.erasLong, "erasLong", 2);
+  checkArray(vocab.erasShort, "erasShort", 2);
+  checkArray(vocab.ordinals, "ordinals", 4);
+}
+function getLocale(locale) {
+  const key = canonicalKey(locale);
+  const ext = extendedVocabs.get(key);
+  if (ext) return ext;
+  try {
+    const base = getLocaleVocab(locale);
+    return { ...base };
+  } catch {
+    return void 0;
+  }
+}
+function hasLocale(locale) {
+  const key = canonicalKey(locale);
+  return extendedVocabs.has(key);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLocale,
+  hasLocale,
+  registerLocale
+});
 //# sourceMappingURL=localeRegistry.cjs.map