temporal-fmt 0.9.70 → 0.9.80

package/README.md

@@ -23,7 +23,7 @@ on 26+, or falling back to the Temporal implementation's own
 > **Just want `format`/`parse`, nothing else, ever?** Check out
 > [`temporal-fmt-lite`](https://github.com/DirazCoder/temporal-fmt-lite) —
 > a frozen snapshot of this library's original v0.8.2 surface: the same two
-> functions, the same locale support, no CLI/mods/recurrence/business-calendar
+> functions, the same locale support, no recurrence/business-calendar
 > weight to opt out of via subpaths, and no new tokens or exports getting
 > added later. Security and correctness fixes only, no LTS promise. If you
 > outgrow it, migrating to the full `temporal-fmt` is additive, not a rewrite.
@@ -50,7 +50,7 @@ That's the whole library for most use cases — `format(temporal, formatStr)` in
 
 Below Node 26, `Temporal` isn't global yet, so you'll need a polyfill first — see [Providing `Temporal`](#providing-temporal). On Node 26+ the snippet above just works.
 
-The package looks large on npm — locales, recurrence, business calendars, timezone disambiguation, an analyzer, config layers, a CLI — but none of that is required reading or required bundle weight. It's there behind its own subpaths for when you need it; see [Subpath imports](#subpath-imports) for the full list and [Formatting](#formatting)/[Parsing](#parsing) for the details on the two functions above.
+The package looks large on npm — locales, recurrence, business calendars, timezone disambiguation, an analyzer, config layers — but none of that is required reading or required bundle weight. It's there behind its own subpaths for when you need it; see [Subpath imports](#subpath-imports) for the full list and [Formatting](#formatting)/[Parsing](#parsing) for the details on the two functions above.
 
 ## Contents
 
@@ -75,11 +75,9 @@ The package looks large on npm — locales, recurrence, business calendars, time
 - [Config](#config)
 - [Extending with custom tokens](#extending-with-custom-tokens)
 - [IDE tooling data](#ide-tooling-data)
-- [CLI](#cli)
-- [Mods (advanced, optional)](#mods-advanced-optional) — full guide in [MODS.md](./MODS.md)
+- [Legacy mod documentation](#legacy-mod-documentation)
 - [Subpath imports](#subpath-imports)
 - [Migrating from Day.js or date-fns](#migrating-from-dayjs-or-date-fns)
-- [Known limitations](#known-limitations)
 - [Related tools](#related-tools)
 - [Testing](#testing)
 - [Contributing](#contributing)
@@ -199,6 +197,8 @@ parse('yyyy-Md', '2026-121', { lenient: true }).toString() // '2026-12-01'
 
 **Heuristic**: if one of the tokens in the ambiguous run is `d` (day), prefer the split where the day value is ≤ 12. The reasoning: someone who glues a run like `"121"` into an `Md` format is more likely to mean Dec 1 (M=12, d=1) than Jan 21 (M=1, d=21) — if they meant Jan 21, they'd more often write it with a separator or padding (`"1/21"`, `"01/21"`). It's not a guarantee, which is exactly why it's opt-in. When the heuristic doesn't narrow it down (both splits have day ≤ 12), or when there's no `d` token in the run at all (e.g. `Hm`), it falls back to the first valid split — deterministic, but arbitrary. Default behavior (lenient unset or `false`) is unchanged either way.
 
+Ambiguity is also easy to avoid outright — the same fixes the heuristic's reasoning hints at: zero-pad the tokens (`MM`/`dd`) or put a literal separator between them (`M/d`), and there's only ever one split to find. Unambiguous glued runs parse fine in strict mode: `"85"` against `yyyy-Md` has exactly one valid split (month 8, day 5), so only genuinely ambiguous input throws. One structural case always throws regardless of ambiguity: a glued run in a format string with no `yyyy` at all (`Md`, `dM`, `Hm` on their own) can never produce a date, since `parse()` needs year, month, and day together to build one (the incomplete-date error in [Typed errors](#typed-errors)).
+
 ### Offset tokens (`X`/`XX`/`XXX`/`x`/`xx`/`xxx`)
 
 The six offset tokens only work on `ZonedDateTime`. On a `PlainDate`/`PlainTime`/`PlainDateTime` they throw the same "requires offset, which this Temporal object doesn't have" error every other field-typed token throws when its field is missing.
@@ -207,6 +207,8 @@ Uppercase (`X`/`XX`/`XXX`) collapses `+00:00` to `Z` for UTC. Lowercase (`x`/`xx
 
 On parse, an offset token needs a full date and time to anchor the instant — same rule `zzz` enforces. With an offset token and no `zzz`, the resulting `ZonedDateTime`'s `timeZoneId` is the offset string itself (e.g. `"+09:00"`). With **both** `zzz` and an offset token, it's a cross-check: `zzz` wins for the result's `timeZoneId` (the IANA name is the meaningful label), and the offset token's value must match that zone's actual offset at the parsed instant. Disagreement throws rather than silently picking one — `parse('yyyy-MM-dd HH:mm zzz XXX', '2026-08-04 15:45 America/New_York +09:00')` throws, because August in New York is `-04:00`, not `+09:00`.
 
+Sub-minute historical offsets: the tokens read `ZonedDateTime`'s `offset` field, which is `±HH:MM` for any modern date but carries a seconds component for pre-railway local-mean-time zones (Europe/London before 1847 surfaces `-00:01:15`). `xxx` is the one variant with a slot for that — it passes a sub-minute offset through verbatim — while the other five throw a descriptive error recommending `xxx` rather than silently truncating the seconds away. Parse-side offset shapes have no seconds group, so a sub-minute offset can't be parsed back through a token; construct the `ZonedDateTime` directly if you need to round-trip one of those.
+
 Range: `-12:00` to `+14:00`, the IANA-supported range. Out-of-range values throw a descriptive error naming the bound.
 
 ## Locales
@@ -832,6 +834,17 @@ parse('yyyy-MM-dd', '٢٠٢٦-٠٨-٠٤', { parseNumberingSystem: 'arab' }).toSt
 
 The two option names are deliberately different (`numberingSystem` vs. `parseNumberingSystem`), not a naming inconsistency — the two directions aren't always symmetric. You might want Arabic-Indic digits in your UI output without expecting Arabic-Indic digits back on input, or the reverse, so a caller mixing `format()` and `parse()` options in one config object can set each independently. `formatToParts()` applies numbering per-part rather than once at the end, so a caller styling individual token parts (one `<span>` per token, say) still gets correctly-transliterated digits in each part instead of plain ASCII. An unsupported system name throws immediately rather than silently falling back to `'latn'`.
 
+Rather than hardcoding a system code, pass `'auto'` to use whichever numeral system the call's locale itself uses, resolved through `Intl.NumberFormat(locale).resolvedOptions().numberingSystem`:
+
+```js
+format(date, 'yyyy-MM-dd', { numberingSystem: 'auto', locale: 'ar-EG' }); // "٢٠٢٦-٠٨-٠٤" — ar-EG's native digits
+format(date, 'yyyy-MM-dd', { numberingSystem: 'auto', locale: 'bn-BD' }); // "২০২৬-০৮-০৪"
+format(date, 'yyyy-MM-dd', { numberingSystem: 'auto' });                  // "2026-08-04" — en-US defaults to latn
+parse('yyyy-MM-dd', '٢٠٢٦-٠٨-٠٤', { parseNumberingSystem: 'auto', locale: 'ar-EG' }); // same resolution, input direction
+```
+
+`'auto'` works the same on both sides and through `createConfig()` (a config's `numberingSystem: 'auto'` resolves per call, against whichever locale that call uses). When the locale's native system isn't one this library can transliterate (Thai digits, Lao, Myanmar, ...), `'auto'` falls back to `'latn'` rather than throwing — only a malformed locale tag throws. Unset still means `'latn'` everywhere; `'auto'` is an opt-in, not a default change.
+
 If you'd rather convert digits yourself instead of going through `format()`/`parse()`'s options — say, transliterating a string that came from somewhere else entirely — the underlying conversion is available directly:
 
 ```js
@@ -859,51 +872,18 @@ A handful of functions exist specifically to feed editor tooling — autocomplet
 - `getInlineDiagnostics(formatStr)` — diagnostics with position and suggested fixes for a given format string.
 - `previewFormat(formatStr, sample?)` — a live preview string for a format, given an optional sample value.
 - `getDocUrl(tokenName)` — a documentation URL for a token, currently pointing at this README's [Tokens](#tokens) section.
-- `DAYJS_TO_TEMPORAL_FMT` / `DATE_FNS_TO_TEMPORAL_FMT` — token conversion hint tables, the same ones the CLI's `translate` subcommand and any migration tooling draw from.
-
-## CLI
-
-The CLI ships in this package (`scripts/cli.mjs`) and reads/writes stdin/stdout. Run it via `npm run cli` inside a checkout of this repo, or `node scripts/cli.mjs` directly. Called with a subcommand it runs once and exits, same as any Unix tool — fine for scripts and CI:
+`DAYJS_TO_TEMPORAL_FMT` / `DATE_FNS_TO_TEMPORAL_FMT` expose token conversion hints for migration tooling.
 
-On Node 26+ the CLI uses native `Temporal` and needs nothing extra. Below that, it looks for a globally-installed [`temporal-polyfill`](https://github.com/fullcalendar/temporal-polyfill) and exits with an install hint if it can't find one — `temporal-fmt` itself ships with zero dependencies, so this one's on you: `npm install temporal-polyfill`.
-
-```sh
-temporal-fmt format "2026-08-04T15:45:30" "yyyy-MM-dd HH:mm:ss"
-temporal-fmt parse "yyyy-MM-dd" "2026-08-04"
-temporal-fmt inspect "MMMM d, yyyy 'at' h:mm a"
-temporal-fmt validate "yyyy-MM-dd HH:mm:ss"
-temporal-fmt translate dayjs "YYYY-MM-DD HH:mm:ss"
-```
+## Legacy mod documentation
 
-| Subcommand | What it does |
-|------------|---------------|
-| `format <iso-input> <format-string> [--locale=LOCALE]` | Formats an ISO date/time input against the given format string. |
-| `parse <format-string> <input> [--locale=LOCALE] [--lenient]` | Parses input against a format string, prints the resulting ISO value. |
-| `inspect <format-string>` | Prints `explainFormat`'s report on a format string. |
-| `validate <format-string>` | Prints `valid` or `invalid`. |
-| `translate <source-lib> <format-string>` | Translates a Day.js or date-fns format string to `temporal-fmt` tokens. |
+Starting with version **0.9.80**, mod support is entirely removed. The package
+does not discover, load, sandbox, or execute mods, and no mod loader or
+permission-management CLI is included. This also removes the package CLI.
 
-`translate` is implemented in-repo (`src/codemod.ts`) against the same token tables the IDE tooling data uses — no external package, no runtime dependency beyond this library itself. It throws on tokens with no `temporal-fmt` equivalent (`Do`/`P`/etc. — see the [migration table](#token-mapping)) rather than guessing.
-
-### Interactive mode
-
-Run `temporal-fmt` with no arguments to start a REPL:
-
-```
-$ temporal-fmt
-temporal-fmt interactive mode. Type a subcommand, "help", or "exit".
-temporal-fmt> format
-ISO input: 2026-08-04T15:45:30
-Format string: yyyy-MM-dd HH:mm:ss
-2026-08-04 15:45:30
-temporal-fmt> exit
-```
-
-Type a subcommand with all its arguments inline (`validate yyyy-MM-dd`) or just the subcommand name — the REPL prompts for whatever's missing, one field at a time. Errors print and the session keeps going; `exit`, `quit`, or Ctrl+D ends it. This is the same subcommand logic as one-shot mode, just wrapped in a loop that asks instead of exiting on a missing argument — one-shot stays there for scripting, and doesn't touch the REPL machinery.
-
-## Mods (advanced, optional)
-
-Mod support (0.9.4+) lets you extend or patch behavior without forking. MODS.md covers installing and running mods someone else wrote — the sandbox from the user side, permissions, load order, and what happens when a mod is broken. Writing your own mod is a separate guide, split by API level: API_DOCS/LEVEL_1.md (0.9.4–0.9.5), API_DOCS/LEVEL_2.md (0.9.6-0.9.61), and API_DOCS/LEVEL_3.md (0.9.70+).
+Historical documentation for prior versions is retained under
+[`LEGACY_VERSION_MODS/`](./LEGACY_VERSION_MODS/). It describes interfaces and
+behavior that are not available in 0.9.80 and later; do not use it as current
+usage guidance.
 
 ## Subpath imports
 
@@ -923,8 +903,6 @@ import { registerLocale } from 'temporal-fmt/locale';
 
 The rest of the API (arithmetic, comparison, rounding, intervals-adjacent helpers not listed above, business calendars, holidays, serialization, config, type guards, typed errors, the analyzer, and IDE tooling data) is only available from the main `temporal-fmt` entry point — there's no dedicated subpath for those yet.
 
-Two Node-only script subpaths exist outside the library API proper: `scripts/loadMods.mjs` (the mod loader, with its sandbox) and `scripts/modSandbox.mjs` (subprocess lifecycle for mods that installed runtime overrides). They ship in the package but aren't in the `exports` map — the loader is ESM-only and has no honest CommonJS twin, so you import them by path rather than by bare specifier. See [MODS.md](./MODS.md); most installs will never touch either.
-
 `sideEffects: false` is set in `package.json`, so a bundler with tree-shaking enabled genuinely drops what you don't import. Measured with esbuild: `import { format } from 'temporal-fmt/format'` bundles to ~27KB, versus ~68KB for the same single function pulled from the bare `temporal-fmt` entry — the main entry point re-exports everything, so anything imported from it drags the whole graph along regardless of what you actually call. If bundle size matters for your use case, import from the subpath, not the package root.
 
 ## Migrating from Day.js or date-fns
@@ -1018,21 +996,12 @@ function formatDate(date, formatStr, opts) {
 
 Migrate file by file, dropping the wrapper once nothing calls the old path anymore.
 
-## Known limitations
-
-- **Numerals default to Western digits** in numeric tokens, regardless of locale, unless you opt into `{ numberingSystem }` / `{ parseNumberingSystem }` — see [Numbering systems](#numbering-systems).
-- **Locale-aware tokens need Node 20+**, native or polyfilled. Untested below that.
-- **You must provide a Temporal implementation** on anything below Node 26 — see [Providing `Temporal`](#providing-temporal).
-- **Pre-1582 dates and locale-aware tokens don't mix well on native Temporal (Node 26+).** `MMMM`/`MMM`/`EEEE`/`EEE` can render the wrong month or weekday for dates before roughly 1582 CE. This is an ICU limitation, not a bug here: ICU's default Gregorian calendar cutover is October 15, 1582, so `Intl.DateTimeFormat.formatToParts()` silently reinterprets earlier dates under the Julian calendar even though `Temporal` itself uses a proleptic Gregorian calendar throughout — see [tc39/ecma402#1003](https://github.com/tc39/ecma402/issues/1003). Numeric tokens never touch `Intl` and aren't affected.
-- **Gluing two unpadded numeric tokens with no separator is ambiguous for some inputs**, and `parse()` throws rather than guessing (`Md`, `dM`, `Hm` against certain input). `"121"` against `yyyy-Md` could mean month 1/day 21 or month 12/day 1 — both valid, no single correct reading. Unambiguous inputs against the same format string parse fine (`"85"` against `yyyy-Md` has only one valid split). Fix it by zero-padding (`MM`/`dd`), adding a separator, or opting into `{ lenient: true }`. Note that `Md` (or `dM`/`Hm`) with no `yyyy` present always throws regardless of ambiguity — `parse()` needs year, month, and day together to build a date at all.
-- **Offset tokens can't express sub-minute historical offsets.** They read `ZonedDateTime.prototype.offset`, which Temporal exposes as `+HH:MM` for any modern date. Historical LMT offsets with seconds (Europe/London before 1847 was `+00:01:15`) aren't reachable through that field, and the offset tokens' regex shapes don't include a seconds group either. Construct the `ZonedDateTime` directly if you need to round-trip one of those. Offset range is bounded to `-12:00` through `+14:00` (Baker Island to Kiritimati) — `+14:01`/`-12:01` throw even though each digit is individually plausible, since no real zone uses an offset past that range.
-
 ## Related tools
 
 Neither of these ships as part of this repository — separate packages. **Both are now deprecated and archived** — single-maintainer bandwidth, no further updates — but the last published versions still work if you want them:
 
 - [`eslint-plugin-temporal-fmt`](https://www.npmjs.com/package/eslint-plugin-temporal-fmt) *(deprecated, archived)* — lints format strings for common mistakes (e.g. `hh` without `a`). This is what backed the `analyzeFormat(formatStr).warnings` check mentioned in [Introspection and the analyzer](#introspection-and-the-analyzer) — same underlying metadata, surfaced as a lint diagnostic instead of a runtime call.
-- [`temporal-fmt-codemod`](https://github.com/DirazCoder/temporal-fmt-codemod) *(deprecated, archived)* — a jscodeshift AST codemod that rewrote `dayjs(x).format(...)`/date-fns `format(...)` *call sites* across a codebase, not just format-string literals. A different job from the CLI's `translate` subcommand (see [CLI](#cli)), which only translates a format string you hand it and doesn't touch call sites; this was the option for migrating an entire codebase and rewriting the calls themselves.
+- [`temporal-fmt-codemod`](https://github.com/DirazCoder/temporal-fmt-codemod) *(deprecated, archived)* — a jscodeshift AST codemod that rewrote `dayjs(x).format(...)`/date-fns `format(...)` *call sites* across a codebase, not just format-string literals. It migrated an entire codebase and rewrote call sites rather than only translating format strings.
 
 ## Testing
 

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

@@ -1,10 +1,10 @@
 import {
   applyParseNumbering,
   tokenize
-} from "./chunk-N4SYRZIP.js";
+} from "./chunk-DMJWJTFY.js";
 import {
   DEFAULT_LOCALE
-} from "./chunk-BQDOTFGC.js";
+} from "./chunk-Z245NHDT.js";
 import {
   getTemporal
 } from "./chunk-DFWTCRS3.js";
@@ -26,7 +26,7 @@ import {
   getLocaleVocab,
   subscribeToVocabChanges,
   wrapUntypedError
-} from "./chunk-OLNU4LON.js";
+} from "./chunk-QRLQ7RR7.js";
 
 // src/pattern.ts
 function escapeRegExp(literal) {
@@ -981,4 +981,4 @@ export {
   parseToParts,
   compileParser
 };
-//# sourceMappingURL=chunk-6ZIYGBFN.js.map
+//# sourceMappingURL=chunk-5KP5H7X2.js.map

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

@@ -1,19 +1,17 @@
 import {
-  TOKENS,
-  getEffectiveTokens,
-  onTokenTableChange
-} from "./chunk-BQDOTFGC.js";
+  DEFAULT_LOCALE,
+  TOKENS
+} from "./chunk-Z245NHDT.js";
 import {
   FormatSyntaxError,
   InvalidLocaleError,
-  UnknownTokenError
-} from "./chunk-OLNU4LON.js";
+  UnknownTokenError,
+  canonicalCacheKey,
+  normalizeLocaleTag
+} from "./chunk-QRLQ7RR7.js";
 
 // src/tokenize.ts
 var SORTED_TOKEN_STRINGS = TOKENS.map(([tok]) => tok).sort((a, b) => b.length - a.length);
-onTokenTableChange(() => {
-  SORTED_TOKEN_STRINGS = getEffectiveTokens().map(([tok]) => tok).sort((a, b) => b.length - a.length);
-});
 function tokenizeWithSpans(format) {
   const pieces = [];
   let i = 0;
@@ -103,6 +101,31 @@ var SUPPORTED_NUMBERING_SYSTEMS = /* @__PURE__ */ new Set([
   "hanidec"
 ]);
 var digitMapCache = /* @__PURE__ */ new Map();
+var autoNumberingCache = /* @__PURE__ */ new Map();
+var MAX_AUTO_NUMBERING_CACHE = 500;
+function resolveAutoNumberingSystem(locale) {
+  const key = canonicalCacheKey(locale);
+  const cached = autoNumberingCache.get(key);
+  if (cached !== void 0) return cached;
+  let resolved;
+  try {
+    resolved = new Intl.NumberFormat(normalizeLocaleTag(locale)).resolvedOptions().numberingSystem;
+  } catch (err) {
+    throw new InvalidLocaleError({ actual: locale, reason: err.message });
+  }
+  const system = SUPPORTED_NUMBERING_SYSTEMS.has(resolved) ? resolved : "latn";
+  if (autoNumberingCache.size >= MAX_AUTO_NUMBERING_CACHE) {
+    const oldestKey = autoNumberingCache.keys().next().value;
+    if (oldestKey !== void 0) autoNumberingCache.delete(oldestKey);
+  }
+  autoNumberingCache.set(key, system);
+  return system;
+}
+function resolveRequestedSystem(requested, locale) {
+  if (requested === void 0) return "latn";
+  if (requested === "auto") return resolveAutoNumberingSystem(locale ?? DEFAULT_LOCALE);
+  return requested;
+}
 function getDigitMap(system) {
   let map = digitMapCache.get(system);
   if (map) return map;
@@ -157,12 +180,12 @@ function convertDigitsToAscii(s, system) {
   return result;
 }
 function applyNumbering(s, options) {
-  const system = options.numberingSystem ?? "latn";
+  const system = resolveRequestedSystem(options.numberingSystem, options.locale);
   if (system === "latn") return s;
   return convertDigits(s, system);
 }
 function applyParseNumbering(s, options) {
-  const system = options.parseNumberingSystem ?? "latn";
+  const system = resolveRequestedSystem(options.parseNumberingSystem, options.locale);
   if (system === "latn") return s;
   return convertDigitsToAscii(s, system);
 }
@@ -176,4 +199,4 @@ export {
   applyNumbering,
   applyParseNumbering
 };
-//# sourceMappingURL=chunk-N4SYRZIP.js.map
+//# sourceMappingURL=chunk-DMJWJTFY.js.map

package/dist/chunk-DMJWJTFY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tokenize.ts","../src/numbering.ts"],"sourcesContent":["/*\n * Copyright 2026 DirazCoder\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TOKENS } from './tokens.js';\nimport { FormatSyntaxError, UnknownTokenError } from './errors.js';\n\nexport type Piece =\n  | { kind: 'token'; value: string }\n  | { kind: 'literal'; value: string };\n\n// A piece plus its exact source span in the ORIGINAL format string.\n// `start`/`end` are UTF-16 code-unit indices, half-open [start, end).\n// Decoded literals can be shorter than their span ('' is 2 source\n// chars → 1 decoded quote), which is exactly why positions computed\n// from decoded lengths (the old approach in analyze.ts) drifted after\n// any quoted text.\nexport interface SpannedPiece {\n  kind: 'token' | 'literal';\n  value: string;\n  start: number;\n  end: number;\n}\n\n// gotta sort longest-first or the greedy scan grabs \"M\" when \"MMMM\" was actually there.\nconst SORTED_TOKEN_STRINGS = TOKENS.map(([tok]) => tok).sort((a, b) => b.length - a.length);\n\n/**\n * Splits a format string like `\"yyyy-MM-dd 'at' HH:mm\"` into token/literal\n * pieces, each with its exact source span. Text in single quotes is always\n * literal (e.g. write 'rd' in \"3rd\" so it's not read as the day token). A\n * doubled quote ('') means a literal quote character, both inside a quoted\n * span and standalone.\n */\nexport function tokenizeWithSpans(format: string): SpannedPiece[] {\n  const pieces: SpannedPiece[] = [];\n  let i = 0;\n\n  while (i < format.length) {\n    const ch = format[i];\n\n    if (ch === \"'\") {\n      // gotta check the doubled-quote case first, otherwise \"''best''\" parses wrong\n      if (format[i + 1] === \"'\") {\n        appendLiteral(pieces, \"'\", i, i + 2);\n        i += 2;\n        continue;\n      }\n\n      let j = i + 1;\n      let literal = '';\n      let closed = false;\n      while (j < format.length) {\n        if (format[j] === \"'\") {\n          if (format[j + 1] === \"'\") {\n            literal += \"'\";\n            j += 2;\n            continue;\n          }\n          closed = true;\n          j += 1;\n          break;\n        }\n        literal += format[j];\n        j += 1;\n      }\n\n      if (!closed) {\n        throw new FormatSyntaxError({\n          format,\n          message: `temporal-fmt: unterminated quote in format string \"${format}\"`,\n        });\n      }\n\n      appendLiteral(pieces, literal, i, j);\n      i = j;\n      continue;\n    }\n\n    const match = SORTED_TOKEN_STRINGS.find((tok) => format.startsWith(tok, i));\n    if (match) {\n      // this is already the longest token that starts here, so if there's\n      // one more of the same char after it, that's not a real token — it'd\n      // just silently fall through to whatever handles that next char and\n      // get glued onto this one. found this the hard way: \"zzzz\" was\n      // parsing as zzz + literal \"z\", \"MMMMM\" as MMMM + the M token. so now\n      // we just treat the whole overlong run as one bad token instead\n      const runChar = match[match.length - 1];\n      if (format[i + match.length] === runChar) {\n        let end = i + match.length;\n        while (format[end] === runChar) end += 1;\n        // UnknownTokenError, not FormatSyntaxError: wrapUntypedError's\n        // classifier already treats this exact message (\"isn't a\n        // recognized token\") as UNKNOWN_TOKEN (see errors.test.js's\n        // \"overlong token run classifies as UnknownTokenError\"), and a\n        // direct throw here needs to agree with what safeParse's fallback\n        // path would have classified it as.\n        throw new UnknownTokenError({\n          format,\n          token: format.slice(i, end),\n          message:\n            `temporal-fmt: \"${format.slice(i, end)}\" in format string \"${format}\" isn't a recognized token — ` +\n            `did you mean \"${match}\"?`,\n        });\n      }\n      pieces.push({ kind: 'token', value: match, start: i, end: i + match.length });\n      i += match.length;\n      continue;\n    }\n\n    // not a token or quote — pass through as-is\n    appendLiteral(pieces, ch, i, i + 1);\n    i += 1;\n  }\n\n  return pieces;\n}\n\n/**\n * Splits a format string like `\"yyyy-MM-dd 'at' HH:mm\"` into token/literal\n * pieces. Text in single quotes is always literal (e.g. write 'rd' in\n * \"3rd\" so it's not read as the day token). A doubled quote ('') means a\n * literal quote character, both inside a quoted span and standalone.\n */\nexport function tokenize(format: string): Piece[] {\n  return tokenizeWithSpans(format).map(({ kind, value }) => ({ kind, value }));\n}\n\n// merges into the previous piece if it's also a literal, so \"---\" is one\n// piece instead of three (spans track the full merged range)\nfunction appendLiteral(pieces: SpannedPiece[], value: string, start: number, end: number): void {\n  const last = pieces[pieces.length - 1];\n  if (last && last.kind === 'literal' && last.end === start) {\n    last.value += value;\n    last.end = end;\n  } else {\n    pieces.push({ kind: 'literal', value, start, end });\n  }\n}\n","/*\n * Copyright 2026 DirazCoder\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// numbering systems. latn (ASCII digits) is the default, but arab, deva,\n// beng, etc are all options, configurable per format call.\n//\n// the tokens in this lib always spit out ASCII digits normally (check\n// tokens.ts's pad() — just String(n), which is ASCII). this module bolts\n// on the ability to convert that output to a locale's native digits via\n// Intl.NumberFormat, since that's the standard way JS does digit\n// transliteration anyway.\n//\n// parse side is stricter: parse() only accepts ASCII digits, matches how\n// NUMERIC_FRAGMENTS is already built. parseNumberingSystem converts\n// input digits to ASCII first — an explicit opt-in per call, never\n// silently accepting any numeral system that shows up.\n//\n// both directions also accept 'auto': instead of requiring the caller to\n// know the ICU numbering-system code for their locale, ask\n// Intl.NumberFormat(locale).resolvedOptions().numberingSystem what the\n// locale itself uses and transliterate with that.\n\nimport { DEFAULT_LOCALE, type FormatOptions } from './tokens.js';\nimport { InvalidLocaleError } from './errors.js';\nimport { canonicalCacheKey, normalizeLocaleTag } from './localeVocab.js';\n\nexport type NumberingSystem = 'latn' | 'arab' | 'deva' | 'beng' | 'guru' | 'gujr' | 'orya' | 'tamldec' | 'telu' | 'knda' | 'mlym' | 'fullwide' | 'hanidec';\n\n// What a caller may pass as numberingSystem / parseNumberingSystem: an\n// explicit system name, or 'auto' to derive the system from the call's\n// locale. The `(string & {})` keeps arbitrary strings compiling (the\n// runtime still validates them against SUPPORTED_NUMBERING_SYSTEMS and\n// throws on unknown names, unchanged) while editors still offer the\n// known literals — 'latn', 'arab', ..., 'auto' — as completions.\nexport type NumberingSystemOption = NumberingSystem | 'auto' | (string & {});\n\n// every NumberingSystem value we support. latn's the default and\n// what the rest of this lib naturally produces\nexport const SUPPORTED_NUMBERING_SYSTEMS: ReadonlySet<string> = new Set([\n  'latn', 'arab', 'deva', 'beng', 'guru', 'gujr', 'orya', 'tamldec',\n  'telu', 'knda', 'mlym', 'fullwide', 'hanidec',\n]);\n\nconst digitMapCache = new Map<string, Record<string, string>>();\n\n// 'auto' resolutions, keyed by canonical locale tag (same key discipline\n// as every other locale-keyed cache in this library — 'ar_EG' and 'ar-EG'\n// fold together instead of costing two entries). Intl.NumberFormat\n// construction isn't free and format() runs in loops (a table of dates, one\n// row per record), so resolve each locale once. Bounded, evicting the\n// oldest insertion, mirroring formatterCache in tokens.ts.\nconst autoNumberingCache = new Map<string, string>();\nconst MAX_AUTO_NUMBERING_CACHE = 500;\n\n// Turns 'auto' into a concrete system by asking Intl what the locale\n// itself defaults to (ar-EG -> arab, bn-BD -> beng, en-US -> latn). When\n// the locale's native system isn't one this library can transliterate\n// (thai, laoo, mymr, ... — anything outside SUPPORTED_NUMBERING_SYSTEMS),\n// fall back to 'latn' rather than throwing: 'auto' means \"use whatever\n// this locale naturally uses, if you can\", not \"throw on locales with\n// numerals this library doesn't cover\". A malformed locale tag DOES\n// throw — typed InvalidLocaleError, matching getFormatter() in tokens.ts —\n// since asking to derive from a locale that doesn't exist is a caller bug,\n// not a data condition to paper over.\nfunction resolveAutoNumberingSystem(locale: string): string {\n  const key = canonicalCacheKey(locale);\n  const cached = autoNumberingCache.get(key);\n  if (cached !== undefined) return cached;\n  let resolved: string;\n  try {\n    resolved = new Intl.NumberFormat(normalizeLocaleTag(locale)).resolvedOptions().numberingSystem;\n  } catch (err) {\n    throw new InvalidLocaleError({ actual: locale, reason: (err as Error).message });\n  }\n  const system = SUPPORTED_NUMBERING_SYSTEMS.has(resolved) ? resolved : 'latn';\n  if (autoNumberingCache.size >= MAX_AUTO_NUMBERING_CACHE) {\n    // not real LRU, just evicts oldest insertion — fine for this key space\n    const oldestKey = autoNumberingCache.keys().next().value;\n    if (oldestKey !== undefined) autoNumberingCache.delete(oldestKey);\n  }\n  autoNumberingCache.set(key, system);\n  return system;\n}\n\n// Shared front door for both option names. undefined stays 'latn' — the\n// default is unchanged; 'auto' is an opt-in, not a new default. Anything\n// else passes through untouched for convertDigits/convertDigitsToAscii\n// to validate against the supported set (they throw on unknown names).\nfunction resolveRequestedSystem(requested: string | undefined, locale: string | undefined): string {\n  if (requested === undefined) return 'latn';\n  if (requested === 'auto') return resolveAutoNumberingSystem(locale ?? DEFAULT_LOCALE);\n  return requested;\n}\n\n// builds a digit-transliteration map per numbering system. renders 0-9\n// through Intl.NumberFormat in the target system, then builds the lookup\n// table from that. caching it since spinning up a formatter isn't free\n// and we reuse the same map for every digit we convert\nfunction getDigitMap(system: string): Record<string, string> {\n  let map = digitMapCache.get(system);\n  if (map) return map;\n  /* c8 ignore start @preserve -- this branch is dead by construction, not\n     just untested: both callers (convertDigits, convertDigitsToAscii)\n     already bail out early on system === 'latn' before ever calling\n     getDigitMap, so it never actually gets invoked with 'latn'. keeping\n     it anyway as a defensive fallback rather than betting that stays\n     true forever */\n  if (system === 'latn') {\n    map = {};\n    for (let i = 0; i < 10; i++) map[String(i)] = String(i);\n  } else {\n    /* c8 ignore stop @preserve */\n    const fmt = new Intl.NumberFormat('en-US-u-nu-' + system, { useGrouping: false });\n    map = {};\n    for (let i = 0; i < 10; i++) {\n      map[String(i)] = fmt.format(i);\n    }\n  }\n  digitMapCache.set(system, map);\n  return map;\n}\n\n// swaps every ASCII digit in `s` for its equivalent in the target\n// numbering system. anything that's not a digit passes through untouched\nexport function convertDigits(s: string, system: string): string {\n  if (system === 'latn') return s;\n  if (!SUPPORTED_NUMBERING_SYSTEMS.has(system)) {\n    throw new InvalidLocaleError({ actual: system, reason: `numbering system \"${system}\" is not supported. Supported: ${[...SUPPORTED_NUMBERING_SYSTEMS].join(', ')}.` });\n  }\n  const map = getDigitMap(system);\n  let result = '';\n  for (const ch of s) {\n    if (ch >= '0' && ch <= '9') {\n      // map[ch] is always populated for 0-9 — getDigitMap builds all ten\n      // keys for every system we support, and ch is already range-checked\n      // above. the ?? ch is really just there to satisfy TS about Record's\n      // implicit undefined, not because this path is actually reachable\n      /* c8 ignore next */\n      result += map[ch] ?? ch;\n    } else {\n      result += ch;\n    }\n  }\n  return result;\n}\n\n// inverse of convertDigits — takes non-ASCII digits back to ASCII. used\n// by parse() when someone passes an explicit numberingSystem option.\n// throws on anything unsupported\nexport function convertDigitsToAscii(s: string, system: string): string {\n  // same dead-by-construction thing as the 'latn' guard above —\n  // applyParseNumbering (the only caller) already returns early on\n  // 'latn' before this ever gets called, so system's never actually\n  // 'latn' here in practice. leaving the guard anyway in case someone\n  // calls this directly someday without going through that guard\n  /* c8 ignore next */\n  if (system === 'latn') return s;\n  if (!SUPPORTED_NUMBERING_SYSTEMS.has(system)) {\n    throw new InvalidLocaleError({ actual: system, reason: `numbering system \"${system}\" is not supported.` });\n  }\n  const map = getDigitMap(system);\n  // just flip the map around\n  const reverse: Record<string, string> = {};\n  for (const k of Object.keys(map)) reverse[map[k]!] = k;\n  let result = '';\n  for (const ch of s) {\n    result += reverse[ch] ?? ch;\n  }\n  return result;\n}\n\n// FormatOptions plus a numberingSystem field. pass { numberingSystem: 'arab' }\n// to format() to get Arabic-Indic digits out, or { numberingSystem: 'auto' }\n// to use whichever numeral system the call's locale itself defaults to\n// (ar-EG -> arab, bn-BD -> beng, en-US -> latn), resolved via\n// Intl.NumberFormat(locale).resolvedOptions().numberingSystem with a\n// 'latn' fallback for locales whose native system isn't supported here.\n// Unset still means 'latn' — 'auto' is an opt-in, not a default change.\nexport interface NumberingFormatOptions extends FormatOptions {\n  numberingSystem?: NumberingSystemOption;\n}\n\n// same idea but for the parse side. called parseNumberingSystem instead of\n// just numberingSystem so someone mixing format() and parse() options in\n// one config object can set both independently — the two directions\n// aren't always symmetric (you might want native digits out without\n// wanting to accept them back in, or vice versa). 'auto' works here too,\n// resolving from the parse call's own locale the same way the format\n// side does.\nexport interface NumberingParseOptions extends FormatOptions {\n  parseNumberingSystem?: NumberingSystemOption;\n}\n\n// format-path helper: takes format()'s ASCII output and converts digits\n// if numberingSystem was asked for. lives here so format.ts doesn't need\n// to know anything about numbering systems\nexport function applyNumbering(s: string, options: NumberingFormatOptions): string {\n  const system = resolveRequestedSystem(options.numberingSystem, options.locale);\n  if (system === 'latn') return s;\n  return convertDigits(s, system);\n}\n\n// parse-path helper: converts input digits to ASCII before matching, if\n// parseNumberingSystem got set. kept as a separate option name from the\n// format side so callers can be explicit about which direction they\n// actually want transliterated\nexport function applyParseNumbering(s: string, options: { parseNumberingSystem?: string; locale?: string }): string {\n  // both call sites for this (both in parse.ts) already guard with\n  // `if (options.parseNumberingSystem)` before calling, so an undefined\n  // parseNumberingSystem never actually reaches here from parse() itself —\n  // the undefined handling inside resolveRequestedSystem is dead by\n  // construction from that direction. leaving it in as a safety net\n  // rather than betting every future caller replicates the same guard\n  // (this is a public export; direct calls don't come pre-guarded).\n  const system = resolveRequestedSystem(options.parseNumberingSystem, options.locale);\n  if (system === 'latn') return s;\n  return convertDigitsToAscii(s, system);\n}"],"mappings":";;;;;;;;;;;;;AAqCA,IAAM,uBAAuB,OAAO,IAAI,CAAC,CAAC,GAAG,MAAM,GAAG,EAAE,KAAK,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM;AASnF,SAAS,kBAAkB,QAAgC;AAChE,QAAM,SAAyB,CAAC;AAChC,MAAI,IAAI;AAER,SAAO,IAAI,OAAO,QAAQ;AACxB,UAAM,KAAK,OAAO,CAAC;AAEnB,QAAI,OAAO,KAAK;AAEd,UAAI,OAAO,IAAI,CAAC,MAAM,KAAK;AACzB,sBAAc,QAAQ,KAAK,GAAG,IAAI,CAAC;AACnC,aAAK;AACL;AAAA,MACF;AAEA,UAAI,IAAI,IAAI;AACZ,UAAI,UAAU;AACd,UAAI,SAAS;AACb,aAAO,IAAI,OAAO,QAAQ;AACxB,YAAI,OAAO,CAAC,MAAM,KAAK;AACrB,cAAI,OAAO,IAAI,CAAC,MAAM,KAAK;AACzB,uBAAW;AACX,iBAAK;AACL;AAAA,UACF;AACA,mBAAS;AACT,eAAK;AACL;AAAA,QACF;AACA,mBAAW,OAAO,CAAC;AACnB,aAAK;AAAA,MACP;AAEA,UAAI,CAAC,QAAQ;AACX,cAAM,IAAI,kBAAkB;AAAA,UAC1B;AAAA,UACA,SAAS,sDAAsD,MAAM;AAAA,QACvE,CAAC;AAAA,MACH;AAEA,oBAAc,QAAQ,SAAS,GAAG,CAAC;AACnC,UAAI;AACJ;AAAA,IACF;AAEA,UAAM,QAAQ,qBAAqB,KAAK,CAAC,QAAQ,OAAO,WAAW,KAAK,CAAC,CAAC;AAC1E,QAAI,OAAO;AAOT,YAAM,UAAU,MAAM,MAAM,SAAS,CAAC;AACtC,UAAI,OAAO,IAAI,MAAM,MAAM,MAAM,SAAS;AACxC,YAAI,MAAM,IAAI,MAAM;AACpB,eAAO,OAAO,GAAG,MAAM,QAAS,QAAO;AAOvC,cAAM,IAAI,kBAAkB;AAAA,UAC1B;AAAA,UACA,OAAO,OAAO,MAAM,GAAG,GAAG;AAAA,UAC1B,SACE,kBAAkB,OAAO,MAAM,GAAG,GAAG,CAAC,uBAAuB,MAAM,mDAClD,KAAK;AAAA,QAC1B,CAAC;AAAA,MACH;AACA,aAAO,KAAK,EAAE,MAAM,SAAS,OAAO,OAAO,OAAO,GAAG,KAAK,IAAI,MAAM,OAAO,CAAC;AAC5E,WAAK,MAAM;AACX;AAAA,IACF;AAGA,kBAAc,QAAQ,IAAI,GAAG,IAAI,CAAC;AAClC,SAAK;AAAA,EACP;AAEA,SAAO;AACT;AAQO,SAAS,SAAS,QAAyB;AAChD,SAAO,kBAAkB,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,MAAM,OAAO,EAAE,MAAM,MAAM,EAAE;AAC7E;AAIA,SAAS,cAAc,QAAwB,OAAe,OAAe,KAAmB;AAC9F,QAAM,OAAO,OAAO,OAAO,SAAS,CAAC;AACrC,MAAI,QAAQ,KAAK,SAAS,aAAa,KAAK,QAAQ,OAAO;AACzD,SAAK,SAAS;AACd,SAAK,MAAM;AAAA,EACb,OAAO;AACL,WAAO,KAAK,EAAE,MAAM,WAAW,OAAO,OAAO,IAAI,CAAC;AAAA,EACpD;AACF;;;ACnGO,IAAM,8BAAmD,oBAAI,IAAI;AAAA,EACtE;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAQ;AAAA,EACxD;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAQ;AAAA,EAAY;AACtC,CAAC;AAED,IAAM,gBAAgB,oBAAI,IAAoC;AAQ9D,IAAM,qBAAqB,oBAAI,IAAoB;AACnD,IAAM,2BAA2B;AAYjC,SAAS,2BAA2B,QAAwB;AAC1D,QAAM,MAAM,kBAAkB,MAAM;AACpC,QAAM,SAAS,mBAAmB,IAAI,GAAG;AACzC,MAAI,WAAW,OAAW,QAAO;AACjC,MAAI;AACJ,MAAI;AACF,eAAW,IAAI,KAAK,aAAa,mBAAmB,MAAM,CAAC,EAAE,gBAAgB,EAAE;AAAA,EACjF,SAAS,KAAK;AACZ,UAAM,IAAI,mBAAmB,EAAE,QAAQ,QAAQ,QAAS,IAAc,QAAQ,CAAC;AAAA,EACjF;AACA,QAAM,SAAS,4BAA4B,IAAI,QAAQ,IAAI,WAAW;AACtE,MAAI,mBAAmB,QAAQ,0BAA0B;AAEvD,UAAM,YAAY,mBAAmB,KAAK,EAAE,KAAK,EAAE;AACnD,QAAI,cAAc,OAAW,oBAAmB,OAAO,SAAS;AAAA,EAClE;AACA,qBAAmB,IAAI,KAAK,MAAM;AAClC,SAAO;AACT;AAMA,SAAS,uBAAuB,WAA+B,QAAoC;AACjG,MAAI,cAAc,OAAW,QAAO;AACpC,MAAI,cAAc,OAAQ,QAAO,2BAA2B,UAAU,cAAc;AACpF,SAAO;AACT;AAMA,SAAS,YAAY,QAAwC;AAC3D,MAAI,MAAM,cAAc,IAAI,MAAM;AAClC,MAAI,IAAK,QAAO;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,MAAI,WAAW,QAAQ;AACrB,UAAM,CAAC;AACP,aAAS,IAAI,GAAG,IAAI,IAAI,IAAK,KAAI,OAAO,CAAC,CAAC,IAAI,OAAO,CAAC;AAAA,EACxD,OAAO;AAAA,IACL;AACA,UAAM,MAAM,IAAI,KAAK,aAAa,gBAAgB,QAAQ,EAAE,aAAa,MAAM,CAAC;AAChF,UAAM,CAAC;AACP,aAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AAC3B,UAAI,OAAO,CAAC,CAAC,IAAI,IAAI,OAAO,CAAC;AAAA,IAC/B;AAAA,EACF;AACA,gBAAc,IAAI,QAAQ,GAAG;AAC7B,SAAO;AACT;AAIO,SAAS,cAAc,GAAW,QAAwB;AAC/D,MAAI,WAAW,OAAQ,QAAO;AAC9B,MAAI,CAAC,4BAA4B,IAAI,MAAM,GAAG;AAC5C,UAAM,IAAI,mBAAmB,EAAE,QAAQ,QAAQ,QAAQ,qBAAqB,MAAM,kCAAkC,CAAC,GAAG,2BAA2B,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC;AAAA,EACtK;AACA,QAAM,MAAM,YAAY,MAAM;AAC9B,MAAI,SAAS;AACb,aAAW,MAAM,GAAG;AAClB,QAAI,MAAM,OAAO,MAAM,KAAK;AAM1B,gBAAU,IAAI,EAAE,KAAK;AAAA,IACvB,OAAO;AACL,gBAAU;AAAA,IACZ;AAAA,EACF;AACA,SAAO;AACT;AAKO,SAAS,qBAAqB,GAAW,QAAwB;AAOtE,MAAI,WAAW,OAAQ,QAAO;AAC9B,MAAI,CAAC,4BAA4B,IAAI,MAAM,GAAG;AAC5C,UAAM,IAAI,mBAAmB,EAAE,QAAQ,QAAQ,QAAQ,qBAAqB,MAAM,sBAAsB,CAAC;AAAA,EAC3G;AACA,QAAM,MAAM,YAAY,MAAM;AAE9B,QAAM,UAAkC,CAAC;AACzC,aAAW,KAAK,OAAO,KAAK,GAAG,EAAG,SAAQ,IAAI,CAAC,CAAE,IAAI;AACrD,MAAI,SAAS;AACb,aAAW,MAAM,GAAG;AAClB,cAAU,QAAQ,EAAE,KAAK;AAAA,EAC3B;AACA,SAAO;AACT;AA2BO,SAAS,eAAe,GAAW,SAAyC;AACjF,QAAM,SAAS,uBAAuB,QAAQ,iBAAiB,QAAQ,MAAM;AAC7E,MAAI,WAAW,OAAQ,QAAO;AAC9B,SAAO,cAAc,GAAG,MAAM;AAChC;AAMO,SAAS,oBAAoB,GAAW,SAAqE;AAQlH,QAAM,SAAS,uBAAuB,QAAQ,sBAAsB,QAAQ,MAAM;AAClF,MAAI,WAAW,OAAQ,QAAO;AAC9B,SAAO,qBAAqB,GAAG,MAAM;AACvC;","names":[]}

package/dist/{chunk-CGI4FL6H.js → chunk-FLMOMOAQ.js}

@@ -2,7 +2,7 @@ import {
   InvalidLocaleError,
   getLocaleVocab,
   registerLocaleVocab
-} from "./chunk-OLNU4LON.js";
+} from "./chunk-QRLQ7RR7.js";
 
 // src/localeRegistry.ts
 var extendedVocabs = /* @__PURE__ */ new Map();
@@ -72,4 +72,4 @@ export {
   getLocale,
   hasLocale
 };
-//# sourceMappingURL=chunk-CGI4FL6H.js.map
+//# sourceMappingURL=chunk-FLMOMOAQ.js.map

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

@@ -1,29 +1,23 @@
 import {
   applyNumbering,
   tokenize
-} from "./chunk-N4SYRZIP.js";
+} from "./chunk-DMJWJTFY.js";
 import {
   DEFAULT_LOCALE,
-  TOKENS,
-  getEffectiveTokens,
-  onTokenTableChange
-} from "./chunk-BQDOTFGC.js";
+  TOKENS
+} from "./chunk-Z245NHDT.js";
 import {
   MAX_FORMAT_LENGTH
 } from "./chunk-SOPTTXUI.js";
 import {
   FormatSyntaxError,
   UnknownTokenError
-} from "./chunk-OLNU4LON.js";
+} from "./chunk-QRLQ7RR7.js";
 
 // 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;
-onTokenTableChange(() => {
-  HANDLER_BY_TOKEN = new Map(getEffectiveTokens().map(([tok, fn, field]) => [tok, { fn, field }]));
-  tokenizeCache.clear();
-});
 function getPieces(formatStr) {
   let pieces = tokenizeCache.get(formatStr);
   if (pieces) return pieces;
@@ -195,4 +189,4 @@ export {
   _getPieces,
   _handlerFor
 };
-//# sourceMappingURL=chunk-UU2XN6N2.js.map
+//# sourceMappingURL=chunk-HGRT37LT.js.map

package/dist/chunk-HGRT37LT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/format.ts"],"sourcesContent":["/*\n * Copyright 2026 DirazCoder\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { TOKENS, DEFAULT_LOCALE, type TemporalLike, type FormatOptions } from './tokens.js';\nimport { tokenize, type Piece } from './tokenize.js';\nimport { MAX_FORMAT_LENGTH } from './constants.js';\nimport { applyNumbering, type NumberingFormatOptions } from './numbering.js';\nimport { FormatSyntaxError, UnknownTokenError } from './errors.js';\n\nconst HANDLER_BY_TOKEN = new Map(TOKENS.map(([tok, fn, field]) => [tok, { fn, field }]));\n\n// Pre-tokenized format strings, keyed by (formatStr) — locale doesn't\n// change the tokenization step, only the per-token rendering, so the\n// piece list is shared across locales. Same eviction shape as the\n// other caches in this library.\nconst tokenizeCache = new Map<string, Piece[]>();\nconst MAX_TOKENIZE_CACHE_SIZE = 500;\n\nfunction getPieces(formatStr: string): Piece[] {\n  let pieces = tokenizeCache.get(formatStr);\n  if (pieces) return pieces;\n  if (tokenizeCache.size >= MAX_TOKENIZE_CACHE_SIZE) {\n    const oldestKey = tokenizeCache.keys().next().value;\n    if (oldestKey !== undefined) tokenizeCache.delete(oldestKey);\n  }\n  pieces = tokenize(formatStr);\n  // Deep-freeze before caching: the SAME array instance is handed out\n  // by compileFormat().pieces and _getPieces() (documented as readonly\n  // inspection surface). Read-only at the type level alone didn't stop\n  // runtime mutation — a caller writing pieces[0].value used to poison\n  // the shared cache and corrupt every subsequent format() for that\n  // string process-wide. Frozen objects make the mutation attempt\n  // throw (ESM is strict mode) instead of silently corrupting state.\n  for (const piece of pieces) Object.freeze(piece);\n  Object.freeze(pieces);\n  tokenizeCache.set(formatStr, pieces);\n  return pieces;\n}\n\n/**\n * Format a Temporal.PlainDate, PlainTime, PlainDateTime, or ZonedDateTime\n * using a date-fns-style token string.\n *\n * @example\n * format(Temporal.Now.plainDateISO(), 'yyyy-MM-dd') // \"2026-08-04\"\n * format(zdt, \"MMM d, yyyy 'at' h:mm a\") // \"Aug 4, 2026 at 3:45 PM\"\n * format(zdt, 'MMMM d, yyyy', { locale: 'fr-FR' }) // \"août 4, 2026\"\n *\n * Throws on a token the input type doesn't support (e.g. 'HH' on a PlainDate).\n */\nexport function format(temporal: TemporalLike, formatStr: string, options: NumberingFormatOptions = {}): string {\n  if (formatStr.length > MAX_FORMAT_LENGTH) {\n    throw new FormatSyntaxError({\n      format: formatStr,\n      message:\n        `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters ` +\n        `(got ${formatStr.length}).`,\n    });\n  }\n  // Null/undefined input used to leak a raw V8 TypeError from the\n  // first field read (\"Cannot read properties of null (reading 'year')\")\n  // — every other entry point validates its input with a typed error,\n  // and null/undefined is by far the most common wrong input. A null\n  // `options` object hits the same class (the default parameter only\n  // covers undefined).\n  if (temporal === null || temporal === undefined) {\n    throw new FormatSyntaxError({\n      input: String(temporal),\n      reason: `format() expected a Temporal.PlainDate / PlainTime / PlainDateTime / ZonedDateTime (or a TemporalLike field bag), got ${String(temporal)}`,\n    });\n  }\n  const opts = options ?? {};\n\n  const locale = opts.locale ?? DEFAULT_LOCALE;\n  const pieces = getPieces(formatStr);\n  let result = '';\n\n  for (const piece of pieces) {\n    if (piece.kind === 'literal') {\n      result += piece.value;\n      continue;\n    }\n\n    const handler = HANDLER_BY_TOKEN.get(piece.value);\n    /* c8 ignore start @preserve -- unreachable: tokenize() only ever emits\n       tokens present in TOKENS, and HANDLER_BY_TOKEN is built from that\n       same list, so every token piece.value can hold already has an entry\n       here. Same defensive-guard category as the twin checks in\n       analyze.ts/formatDuration.ts. */\n    if (!handler) {\n      throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token \"${piece.value}\"` });\n    }\n    /* c8 ignore stop @preserve */\n\n    if (temporal[handler.field] === undefined) {\n      throw new FormatSyntaxError({\n        format: formatStr,\n        token: piece.value,\n        message:\n          `temporal-fmt: token \"${piece.value}\" requires \"${handler.field}\", ` +\n          `which this Temporal object doesn't have. ` +\n          `(e.g. PlainDate has no time fields, PlainTime has no date fields)`,\n      });\n    }\n\n    result += handler.fn(temporal, locale);\n  }\n\n  // Numeral transliteration happens last and only on request — every\n  // upstream token handler still emits plain ASCII digits, so this is\n  // the single place output digits can diverge from that default.\n  return applyNumbering(result, opts);\n}\n\n// Shape mirrors Intl.DateTimeFormat.formatToParts: each entry is either\n// a literal (carrying no token info) or a token piece (carrying the\n// token string and the formatted value). Letting callers iterate parts\n// means they can build custom output — strip a token, swap a separator,\n// render each token to its own DOM node — without re-implementing the\n// tokenizer or the field-check logic.\nexport interface FormattedPart {\n  type: 'literal' | 'token';\n  value: string;\n  // Present when `type === 'token'`. Carries the token string (e.g. \"yyyy\")\n  // so a caller can look up its metadata via tokenInfo() from analyze.ts.\n  token?: string;\n}\n\nexport function formatToParts(temporal: TemporalLike, formatStr: string, options: NumberingFormatOptions = {}): FormattedPart[] {\n  if (formatStr.length > MAX_FORMAT_LENGTH) {\n    throw new FormatSyntaxError({\n      format: formatStr,\n      message:\n        `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters ` +\n        `(got ${formatStr.length}).`,\n    });\n  }\n  const locale = options.locale ?? DEFAULT_LOCALE;\n  const pieces = getPieces(formatStr);\n  const result: FormattedPart[] = [];\n  for (const piece of pieces) {\n    if (piece.kind === 'literal') {\n      // Collapse adjacent literals so formatToParts stays consistent with\n      // how format() walks pieces — a multi-char literal \"at \" is one\n      // entry, not one per character. Same merge logic as appendLiteral\n      // in tokenize.ts.\n      const last = result[result.length - 1];\n      /* c8 ignore start @preserve -- unreachable through tokenize()'s own\n         output: appendLiteral() in tokenize.ts already merges every\n         adjacent literal character before pieces ever reaches here, so\n         two 'literal' pieces never sit back-to-back in the array this\n         loop walks. Kept as defense-in-depth in case that invariant ever\n         changes upstream. */\n      if (last && last.type === 'literal') {\n        last.value += piece.value;\n      } else {\n        /* c8 ignore stop @preserve */\n        result.push({ type: 'literal', value: piece.value });\n      }\n      continue;\n    }\n    const handler = HANDLER_BY_TOKEN.get(piece.value);\n    /* c8 ignore start @preserve -- unreachable, see the note in format() above */\n    if (!handler) {\n      throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token \"${piece.value}\"` });\n    }\n    /* c8 ignore stop @preserve */\n    if (temporal[handler.field] === undefined) {\n      throw new FormatSyntaxError({\n        format: formatStr,\n        token: piece.value,\n        message:\n          `temporal-fmt: token \"${piece.value}\" requires \"${handler.field}\", ` +\n          `which this Temporal object doesn't have. ` +\n          `(e.g. PlainDate has no time fields, PlainTime has no date fields)`,\n      });\n    }\n    // Numeral transliteration applies per-token-part here, rather than\n    // once at the end like format() does, so a caller styling individual\n    // parts (e.g. one <span> per token) still gets correctly-transliterated\n    // digits in each part instead of plain ASCII.\n    result.push({ type: 'token', value: applyNumbering(handler.fn(temporal, locale), options), token: piece.value });\n  }\n  return result;\n}\n\n// Pre-compiles a format string into an object whose format()/formatToParts()\n// methods skip the tokenization step on every call. The tokenizeCache in\n// this module means a plain format(temporal, fmt) call already pays only\n// a Map lookup for tokenization after the first call, so compileFormat()\n// is mostly a typing/ergonomics affordance — useful for callers who want\n// to hold onto a compiled form explicitly (e.g. to inspect the pieces\n// via the .pieces property, or to pass the compiled object around\n// instead of the string).\nexport interface CompiledFormat {\n  format(temporal: TemporalLike, options?: NumberingFormatOptions): string;\n  formatToParts(temporal: TemporalLike, options?: NumberingFormatOptions): FormattedPart[];\n  readonly pieces: ReadonlyArray<Piece>;\n  readonly formatStr: string;\n}\n\nexport function compileFormat(formatStr: string): CompiledFormat {\n  if (formatStr.length > MAX_FORMAT_LENGTH) {\n    throw new FormatSyntaxError({\n      format: formatStr,\n      message:\n        `temporal-fmt: format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters ` +\n        `(got ${formatStr.length}).`,\n    });\n  }\n  // Pre-tokenize once. Validation (unknown tokens, unterminated quotes)\n  // happens here, not lazily on first format() call — surfaces a bad\n  // format string at compile time rather than at first use, which is\n  // the point of compiling up front.\n  const pieces = getPieces(formatStr);\n  return {\n    formatStr,\n    pieces,\n    format(temporal: TemporalLike, options: NumberingFormatOptions = {}) {\n      const locale = options.locale ?? DEFAULT_LOCALE;\n      let result = '';\n      for (const piece of pieces) {\n        if (piece.kind === 'literal') {\n          result += piece.value;\n          continue;\n        }\n        const handler = HANDLER_BY_TOKEN.get(piece.value);\n        /* c8 ignore next -- unreachable, see the note in format() above */\n        if (!handler) throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token \"${piece.value}\"` });\n        if (temporal[handler.field] === undefined) {\n          throw new FormatSyntaxError({\n            format: formatStr,\n            token: piece.value,\n            message:\n              `temporal-fmt: token \"${piece.value}\" requires \"${handler.field}\", ` +\n              `which this Temporal object doesn't have. ` +\n              `(e.g. PlainDate has no time fields, PlainTime has no date fields)`,\n          });\n        }\n        result += handler.fn(temporal, locale);\n      }\n      return applyNumbering(result, options);\n    },\n    formatToParts(temporal: TemporalLike, options: NumberingFormatOptions = {}) {\n      const locale = options.locale ?? DEFAULT_LOCALE;\n      const out: FormattedPart[] = [];\n      for (const piece of pieces) {\n        if (piece.kind === 'literal') {\n          const last = out[out.length - 1];\n          /* c8 ignore next -- unreachable, see the note in formatToParts() above */\n          if (last && last.type === 'literal') last.value += piece.value;\n          else out.push({ type: 'literal', value: piece.value });\n          continue;\n        }\n        const handler = HANDLER_BY_TOKEN.get(piece.value);\n        /* c8 ignore next -- unreachable, see the note in format() above */\n        if (!handler) throw new UnknownTokenError({ token: piece.value, format: formatStr, message: `temporal-fmt: unknown token \"${piece.value}\"` });\n        if (temporal[handler.field] === undefined) {\n          throw new FormatSyntaxError({\n            format: formatStr,\n            token: piece.value,\n            message:\n              `temporal-fmt: token \"${piece.value}\" requires \"${handler.field}\", ` +\n              `which this Temporal object doesn't have. ` +\n              `(e.g. PlainDate has no time fields, PlainTime has no date fields)`,\n          });\n        }\n        out.push({ type: 'token', value: applyNumbering(handler.fn(temporal, locale), options), token: piece.value });\n      }\n      return out;\n    },\n  };\n}\n\n// Exported so analyze.ts can reuse the same tokenization cache rather\n// than re-tokenizing when a caller asks for both a format() and an\n// analyzeFormat() on the same string.\nexport function _getPieces(formatStr: string): Piece[] {\n  return getPieces(formatStr);\n}\n\n// Exported for analyze.ts — same reason as above. The handler map is\n// the source of truth for \"what field does this token need\" — analyze\n// consumes it to compute requiredFields and compatibleTypes.\nexport function _handlerFor(token: string): { fn: (t: TemporalLike, locale: string) => string; field: keyof TemporalLike } | undefined {\n  return HANDLER_BY_TOKEN.get(token);\n}"],"mappings":";;;;;;;;;;;;;;;;;AAsBA,IAAM,mBAAmB,IAAI,IAAI,OAAO,IAAI,CAAC,CAAC,KAAK,IAAI,KAAK,MAAM,CAAC,KAAK,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC;AAMvF,IAAM,gBAAgB,oBAAI,IAAqB;AAC/C,IAAM,0BAA0B;AAEhC,SAAS,UAAU,WAA4B;AAC7C,MAAI,SAAS,cAAc,IAAI,SAAS;AACxC,MAAI,OAAQ,QAAO;AACnB,MAAI,cAAc,QAAQ,yBAAyB;AACjD,UAAM,YAAY,cAAc,KAAK,EAAE,KAAK,EAAE;AAC9C,QAAI,cAAc,OAAW,eAAc,OAAO,SAAS;AAAA,EAC7D;AACA,WAAS,SAAS,SAAS;AAQ3B,aAAW,SAAS,OAAQ,QAAO,OAAO,KAAK;AAC/C,SAAO,OAAO,MAAM;AACpB,gBAAc,IAAI,WAAW,MAAM;AACnC,SAAO;AACT;AAaO,SAAS,OAAO,UAAwB,WAAmB,UAAkC,CAAC,GAAW;AAC9G,MAAI,UAAU,SAAS,mBAAmB;AACxC,UAAM,IAAI,kBAAkB;AAAA,MAC1B,QAAQ;AAAA,MACR,SACE,yDAAyD,iBAAiB,oBAClE,UAAU,MAAM;AAAA,IAC5B,CAAC;AAAA,EACH;AAOA,MAAI,aAAa,QAAQ,aAAa,QAAW;AAC/C,UAAM,IAAI,kBAAkB;AAAA,MAC1B,OAAO,OAAO,QAAQ;AAAA,MACtB,QAAQ,yHAAyH,OAAO,QAAQ,CAAC;AAAA,IACnJ,CAAC;AAAA,EACH;AACA,QAAM,OAAO,WAAW,CAAC;AAEzB,QAAM,SAAS,KAAK,UAAU;AAC9B,QAAM,SAAS,UAAU,SAAS;AAClC,MAAI,SAAS;AAEb,aAAW,SAAS,QAAQ;AAC1B,QAAI,MAAM,SAAS,WAAW;AAC5B,gBAAU,MAAM;AAChB;AAAA,IACF;AAEA,UAAM,UAAU,iBAAiB,IAAI,MAAM,KAAK;AAAA,IAChD;AAAA;AAAA;AAAA;AAAA;AAKA,QAAI,CAAC,SAAS;AACZ,YAAM,IAAI,kBAAkB,EAAE,OAAO,MAAM,OAAO,QAAQ,WAAW,SAAS,gCAAgC,MAAM,KAAK,IAAI,CAAC;AAAA,IAChI;AAAA,IACA;AAEA,QAAI,SAAS,QAAQ,KAAK,MAAM,QAAW;AACzC,YAAM,IAAI,kBAAkB;AAAA,QAC1B,QAAQ;AAAA,QACR,OAAO,MAAM;AAAA,QACb,SACE,wBAAwB,MAAM,KAAK,eAAe,QAAQ,KAAK;AAAA,MAGnE,CAAC;AAAA,IACH;AAEA,cAAU,QAAQ,GAAG,UAAU,MAAM;AAAA,EACvC;AAKA,SAAO,eAAe,QAAQ,IAAI;AACpC;AAgBO,SAAS,cAAc,UAAwB,WAAmB,UAAkC,CAAC,GAAoB;AAC9H,MAAI,UAAU,SAAS,mBAAmB;AACxC,UAAM,IAAI,kBAAkB;AAAA,MAC1B,QAAQ;AAAA,MACR,SACE,yDAAyD,iBAAiB,oBAClE,UAAU,MAAM;AAAA,IAC5B,CAAC;AAAA,EACH;AACA,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,SAAS,UAAU,SAAS;AAClC,QAAM,SAA0B,CAAC;AACjC,aAAW,SAAS,QAAQ;AAC1B,QAAI,MAAM,SAAS,WAAW;AAK5B,YAAM,OAAO,OAAO,OAAO,SAAS,CAAC;AAAA,MACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,UAAI,QAAQ,KAAK,SAAS,WAAW;AACnC,aAAK,SAAS,MAAM;AAAA,MACtB,OAAO;AAAA,QACL;AACA,eAAO,KAAK,EAAE,MAAM,WAAW,OAAO,MAAM,MAAM,CAAC;AAAA,MACrD;AACA;AAAA,IACF;AACA,UAAM,UAAU,iBAAiB,IAAI,MAAM,KAAK;AAAA,IAChD;AACA,QAAI,CAAC,SAAS;AACZ,YAAM,IAAI,kBAAkB,EAAE,OAAO,MAAM,OAAO,QAAQ,WAAW,SAAS,gCAAgC,MAAM,KAAK,IAAI,CAAC;AAAA,IAChI;AAAA,IACA;AACA,QAAI,SAAS,QAAQ,KAAK,MAAM,QAAW;AACzC,YAAM,IAAI,kBAAkB;AAAA,QAC1B,QAAQ;AAAA,QACR,OAAO,MAAM;AAAA,QACb,SACE,wBAAwB,MAAM,KAAK,eAAe,QAAQ,KAAK;AAAA,MAGnE,CAAC;AAAA,IACH;AAKA,WAAO,KAAK,EAAE,MAAM,SAAS,OAAO,eAAe,QAAQ,GAAG,UAAU,MAAM,GAAG,OAAO,GAAG,OAAO,MAAM,MAAM,CAAC;AAAA,EACjH;AACA,SAAO;AACT;AAiBO,SAAS,cAAc,WAAmC;AAC/D,MAAI,UAAU,SAAS,mBAAmB;AACxC,UAAM,IAAI,kBAAkB;AAAA,MAC1B,QAAQ;AAAA,MACR,SACE,yDAAyD,iBAAiB,oBAClE,UAAU,MAAM;AAAA,IAC5B,CAAC;AAAA,EACH;AAKA,QAAM,SAAS,UAAU,SAAS;AAClC,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO,UAAwB,UAAkC,CAAC,GAAG;AACnE,YAAM,SAAS,QAAQ,UAAU;AACjC,UAAI,SAAS;AACb,iBAAW,SAAS,QAAQ;AAC1B,YAAI,MAAM,SAAS,WAAW;AAC5B,oBAAU,MAAM;AAChB;AAAA,QACF;AACA,cAAM,UAAU,iBAAiB,IAAI,MAAM,KAAK;AAEhD,YAAI,CAAC,QAAS,OAAM,IAAI,kBAAkB,EAAE,OAAO,MAAM,OAAO,QAAQ,WAAW,SAAS,gCAAgC,MAAM,KAAK,IAAI,CAAC;AAC5I,YAAI,SAAS,QAAQ,KAAK,MAAM,QAAW;AACzC,gBAAM,IAAI,kBAAkB;AAAA,YAC1B,QAAQ;AAAA,YACR,OAAO,MAAM;AAAA,YACb,SACE,wBAAwB,MAAM,KAAK,eAAe,QAAQ,KAAK;AAAA,UAGnE,CAAC;AAAA,QACH;AACA,kBAAU,QAAQ,GAAG,UAAU,MAAM;AAAA,MACvC;AACA,aAAO,eAAe,QAAQ,OAAO;AAAA,IACvC;AAAA,IACA,cAAc,UAAwB,UAAkC,CAAC,GAAG;AAC1E,YAAM,SAAS,QAAQ,UAAU;AACjC,YAAM,MAAuB,CAAC;AAC9B,iBAAW,SAAS,QAAQ;AAC1B,YAAI,MAAM,SAAS,WAAW;AAC5B,gBAAM,OAAO,IAAI,IAAI,SAAS,CAAC;AAE/B,cAAI,QAAQ,KAAK,SAAS,UAAW,MAAK,SAAS,MAAM;AAAA,cACpD,KAAI,KAAK,EAAE,MAAM,WAAW,OAAO,MAAM,MAAM,CAAC;AACrD;AAAA,QACF;AACA,cAAM,UAAU,iBAAiB,IAAI,MAAM,KAAK;AAEhD,YAAI,CAAC,QAAS,OAAM,IAAI,kBAAkB,EAAE,OAAO,MAAM,OAAO,QAAQ,WAAW,SAAS,gCAAgC,MAAM,KAAK,IAAI,CAAC;AAC5I,YAAI,SAAS,QAAQ,KAAK,MAAM,QAAW;AACzC,gBAAM,IAAI,kBAAkB;AAAA,YAC1B,QAAQ;AAAA,YACR,OAAO,MAAM;AAAA,YACb,SACE,wBAAwB,MAAM,KAAK,eAAe,QAAQ,KAAK;AAAA,UAGnE,CAAC;AAAA,QACH;AACA,YAAI,KAAK,EAAE,MAAM,SAAS,OAAO,eAAe,QAAQ,GAAG,UAAU,MAAM,GAAG,OAAO,GAAG,OAAO,MAAM,MAAM,CAAC;AAAA,MAC9G;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACF;AAKO,SAAS,WAAW,WAA4B;AACrD,SAAO,UAAU,SAAS;AAC5B;AAKO,SAAS,YAAY,OAA2G;AACrI,SAAO,iBAAiB,IAAI,KAAK;AACnC;","names":[]}

package/dist/{chunk-3FMUGYE2.js → chunk-KV6GMX4D.js}

@@ -1,153 +1,16 @@
 import {
   add
 } from "./chunk-SC6ENLEB.js";
+import {
+  compare
+} from "./chunk-UGYSEYUQ.js";
 import {
   asDateFieldView
 } from "./chunk-KEPIXQK7.js";
 import {
-  dayOfWeekFromCivil,
   daysFromCivil
 } from "./chunk-BLZDBPSV.js";
 
-// src/comparison.ts
-function toComparableMs(view) {
-  const days = daysFromCivil(view.year, view.month, view.day);
-  const MS_PER_HOUR = 36e5;
-  const MS_PER_MINUTE = 6e4;
-  const MS_PER_SECOND = 1e3;
-  return days * 864e5 + (view.hour ?? 0) * MS_PER_HOUR + (view.minute ?? 0) * MS_PER_MINUTE + (view.second ?? 0) * MS_PER_SECOND + (view.millisecond ?? 0);
-}
-function asDateTimeFieldView(value) {
-  const v = asDateFieldView(value);
-  return v;
-}
-function compare(a, b) {
-  const av = asDateTimeFieldView(a);
-  const bv = asDateTimeFieldView(b);
-  const am = toComparableMs(av);
-  const bm = toComparableMs(bv);
-  if (am < bm) return -1;
-  if (am > bm) return 1;
-  return 0;
-}
-function isEqual(a, b) {
-  return compare(a, b) === 0;
-}
-function isBefore(a, b) {
-  return compare(a, b) < 0;
-}
-function isAfter(a, b) {
-  return compare(a, b) > 0;
-}
-function min(values) {
-  if (!Array.isArray(values) || values.length === 0) {
-    throw new Error("temporal-fmt: min() requires a non-empty array of values.");
-  }
-  let best = values[0];
-  for (let i = 1; i < values.length; i++) {
-    if (compare(values[i], best) < 0) best = values[i];
-  }
-  return best;
-}
-function max(values) {
-  if (!Array.isArray(values) || values.length === 0) {
-    throw new Error("temporal-fmt: max() requires a non-empty array of values.");
-  }
-  let best = values[0];
-  for (let i = 1; i < values.length; i++) {
-    if (compare(values[i], best) > 0) best = values[i];
-  }
-  return best;
-}
-function clamp(value, lo, hi) {
-  if (compare(value, lo) < 0) return lo;
-  if (compare(value, hi) > 0) return hi;
-  return value;
-}
-function isBetween(value, lo, hi) {
-  return compare(value, lo) >= 0 && compare(value, hi) <= 0;
-}
-function readYearMonthDay(value) {
-  const v = asDateFieldView(value);
-  return { year: v.year, month: v.month, day: v.day };
-}
-function todayYearMonthDay() {
-  const now = /* @__PURE__ */ new Date();
-  return { year: now.getFullYear(), month: now.getMonth() + 1, day: now.getDate() };
-}
-function dateEqualYearMonthDay(a, b) {
-  return a.year === b.year && a.month === b.month && a.day === b.day;
-}
-function isSameDay(value, reference) {
-  return dateEqualYearMonthDay(readYearMonthDay(value), readYearMonthDay(reference));
-}
-function isToday(value) {
-  return dateEqualYearMonthDay(readYearMonthDay(value), todayYearMonthDay());
-}
-function tomorrowYearMonthDay() {
-  const d = /* @__PURE__ */ new Date();
-  d.setDate(d.getDate() + 1);
-  return { year: d.getFullYear(), month: d.getMonth() + 1, day: d.getDate() };
-}
-function yesterdayYearMonthDay() {
-  const d = /* @__PURE__ */ new Date();
-  d.setDate(d.getDate() - 1);
-  return { year: d.getFullYear(), month: d.getMonth() + 1, day: d.getDate() };
-}
-function isTomorrow(value) {
-  return dateEqualYearMonthDay(readYearMonthDay(value), tomorrowYearMonthDay());
-}
-function isYesterday(value) {
-  return dateEqualYearMonthDay(readYearMonthDay(value), yesterdayYearMonthDay());
-}
-function sameWeek(yearA, monthA, dayA, yearB, monthB, dayB) {
-  const daysSince = (y, m, d) => {
-    return daysFromCivil(y, m, d);
-  };
-  const a = daysSince(yearA, monthA, dayA);
-  const b = daysSince(yearB, monthB, dayB);
-  if (Math.abs(a - b) >= 7) return false;
-  const weekdayOf2 = (y, m, d) => {
-    return dayOfWeekFromCivil(y, m, d);
-  };
-  const wa = a - (weekdayOf2(yearA, monthA, dayA) - 1);
-  const wb = b - (weekdayOf2(yearB, monthB, dayB) - 1);
-  return wa === wb;
-}
-function isSameWeek(value, reference) {
-  const a = readYearMonthDay(value);
-  const b = readYearMonthDay(reference);
-  return sameWeek(a.year, a.month, a.day, b.year, b.month, b.day);
-}
-function isSameMonth(value, reference) {
-  const a = readYearMonthDay(value);
-  const b = readYearMonthDay(reference);
-  return a.year === b.year && a.month === b.month;
-}
-function isSameQuarter(value, reference) {
-  const a = readYearMonthDay(value);
-  const b = readYearMonthDay(reference);
-  return a.year === b.year && Math.ceil(a.month / 3) === Math.ceil(b.month / 3);
-}
-function isSameYear(value, reference) {
-  return readYearMonthDay(value).year === readYearMonthDay(reference).year;
-}
-function isWeekend(value) {
-  if (typeof value !== "object" || value === null) {
-    throw new Error(`temporal-fmt: isWeekend() expected a Temporal value, got ${String(value)}.`);
-  }
-  const v = value;
-  if (typeof v.dayOfWeek !== "number") {
-    throw new Error(
-      `temporal-fmt: isWeekend() needs a value with a dayOfWeek field (PlainDate / PlainDateTime / ZonedDateTime).`
-    );
-  }
-  return v.dayOfWeek === 6 || v.dayOfWeek === 7;
-}
-function isWeekday(value) {
-  return !isWeekend(value);
-}
-
 // src/recurrence.ts
 function daysInMonthOf(year, month) {
   const LENGTHS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
@@ -535,24 +398,6 @@ function formatRRule(rule) {
 }
 
 export {
-  compare,
-  isEqual,
-  isBefore,
-  isAfter,
-  min,
-  max,
-  clamp,
-  isBetween,
-  isSameDay,
-  isToday,
-  isTomorrow,
-  isYesterday,
-  isSameWeek,
-  isSameMonth,
-  isSameQuarter,
-  isSameYear,
-  isWeekend,
-  isWeekday,
   recurrence,
   take,
   skip,
@@ -560,4 +405,4 @@ export {
   parseRRule,
   formatRRule
 };
-//# sourceMappingURL=chunk-3FMUGYE2.js.map
+//# sourceMappingURL=chunk-KV6GMX4D.js.map