@50arms/ui 0.0.0-stage → 35.1.0

package/dist/lib/use-media-query.js

@@ -0,0 +1,30 @@
+import { useSyncExternalStore as o } from "react";
+function u(e, n = !1) {
+  return o(
+    (i) => {
+      const t = r(e);
+      return t === null ? () => {
+      } : (t.addEventListener("change", i), () => t.removeEventListener("change", i));
+    },
+    () => r(e)?.matches ?? n,
+    () => n
+  );
+}
+function r(e) {
+  return typeof window > "u" || typeof window.matchMedia != "function" ? null : window.matchMedia(e);
+}
+const d = {
+  sm: 640,
+  md: 768,
+  lg: 1024,
+  xl: 1280
+};
+function c(e, n = !1) {
+  return u(`(max-width: ${d[e] - 0.02}px)`, n);
+}
+export {
+  d as BREAKPOINTS,
+  c as useBelow,
+  u as useMediaQuery
+};
+//# sourceMappingURL=use-media-query.js.map

package/dist/lib/use-media-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-media-query.js","sources":["../../src/lib/use-media-query.ts"],"sourcesContent":["import { useSyncExternalStore } from \"react\";\r\n\r\n/**\r\n * Subscribes to a CSS media query and re-renders when it changes.\r\n *\r\n * WHY A HOOK AND NOT A CSS CLASS. Almost everything responsive in this system\r\n * belongs in CSS, where it costs nothing and works before hydration. This\r\n * exists for the case CSS cannot reach: a layout whose measurements are written\r\n * as INLINE STYLE from application state — a resizable panel group being the\r\n * one that matters here. A utility class cannot override `style=\"flex-grow:3\"`,\r\n * so the component has to know the width to write a different value.\r\n *\r\n * Reach for a `lg:` variant first. This is the exception, not the pattern.\r\n *\r\n * `useSyncExternalStore` rather than `useState` + `useEffect`: it reads the\r\n * value during render on the client and returns the server snapshot during SSR,\r\n * so there is no first paint at the wrong breakpoint and no hydration mismatch\r\n * warning. The effect version renders once with a guess and then corrects\r\n * itself, which is a visible layout jump on exactly the devices this is for.\r\n */\r\nexport function useMediaQuery(query: string, serverFallback = false): boolean {\r\n  return useSyncExternalStore(\r\n    (onChange) => {\r\n      const list = queryList(query);\r\n      if (list === null) return () => {};\r\n      list.addEventListener(\"change\", onChange);\r\n      return () => list.removeEventListener(\"change\", onChange);\r\n    },\r\n    () => queryList(query)?.matches ?? serverFallback,\r\n    () => serverFallback,\r\n  );\r\n}\r\n\r\n/** `matchMedia` can be absent (a test DOM such as happy-dom): the hook then answers `serverFallback`, the same answer it gives during SSR, instead of throwing. */\r\nfunction queryList(query: string): MediaQueryList | null {\r\n  return typeof window === \"undefined\" || typeof window.matchMedia !== \"function\" ? null : window.matchMedia(query);\r\n}\r\n\r\n/** Tailwind's own breakpoints, so a JS check and a `lg:` class agree. */\r\nexport const BREAKPOINTS = {\r\n  sm: 640,\r\n  md: 768,\r\n  lg: 1024,\r\n  xl: 1280,\r\n} as const;\r\n\r\nexport type Breakpoint = keyof typeof BREAKPOINTS;\r\n\r\n/** True below the named breakpoint — the JS twin of `max-<bp>:`. */\r\nexport function useBelow(breakpoint: Breakpoint, serverFallback = false): boolean {\r\n  // I18N-ALLOW: CSS media query string\r\n  return useMediaQuery(`(max-width: ${BREAKPOINTS[breakpoint] - 0.02}px)`, serverFallback);\r\n}\r\n"],"names":["useMediaQuery","query","serverFallback","useSyncExternalStore","onChange","list","queryList","BREAKPOINTS","useBelow","breakpoint"],"mappings":";AAoBO,SAASA,EAAcC,GAAeC,IAAiB,IAAgB;AAC5E,SAAOC;AAAA,IACL,CAACC,MAAa;AACZ,YAAMC,IAAOC,EAAUL,CAAK;AAC5B,aAAII,MAAS,OAAa,MAAM;AAAA,MAAC,KACjCA,EAAK,iBAAiB,UAAUD,CAAQ,GACjC,MAAMC,EAAK,oBAAoB,UAAUD,CAAQ;AAAA,IAC1D;AAAA,IACA,MAAME,EAAUL,CAAK,GAAG,WAAWC;AAAA,IACnC,MAAMA;AAAA,EAAA;AAEV;AAGA,SAASI,EAAUL,GAAsC;AACvD,SAAO,OAAO,SAAW,OAAe,OAAO,OAAO,cAAe,aAAa,OAAO,OAAO,WAAWA,CAAK;AAClH;AAGO,MAAMM,IAAc;AAAA,EACzB,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AACN;AAKO,SAASC,EAASC,GAAwBP,IAAiB,IAAgB;AAEhF,SAAOF,EAAc,eAAeO,EAAYE,CAAU,IAAI,IAAI,OAAOP,CAAc;AACzF;"}

package/dist/lib/use-relabel-base-ui-dismiss.js

@@ -0,0 +1,26 @@
+import { useEffect as i, useRef as o, useCallback as a } from "react";
+const l = '[aria-label="Dismiss"], [data-dismiss-relabelled]', c = { childList: !0, subtree: !0 };
+function n(r, s) {
+  for (const t of r.querySelectorAll(l))
+    t.setAttribute("aria-label", s), t.setAttribute("data-dismiss-relabelled", "");
+}
+function d(r, s) {
+  i(() => {
+    const e = s.current;
+    if (!e) return;
+    n(e, r);
+    const u = new MutationObserver(() => n(e, r));
+    return u.observe(e, c), () => u.disconnect();
+  }, [r, s]);
+  const t = o(null);
+  return a(
+    (e) => {
+      t.current?.disconnect(), t.current = null, e && (n(e, r), t.current = new MutationObserver(() => n(e, r)), t.current.observe(e, c));
+    },
+    [r]
+  );
+}
+export {
+  d as useRelabelBaseUiDismiss
+};
+//# sourceMappingURL=use-relabel-base-ui-dismiss.js.map

package/dist/lib/use-relabel-base-ui-dismiss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-relabel-base-ui-dismiss.js","sources":["../../src/lib/use-relabel-base-ui-dismiss.ts"],"sourcesContent":["import { useCallback, useEffect, useRef, type RefObject } from \"react\";\n\n/* ============================================================================\n   BASE UI'S \"DISMISS\" BUTTONS SPEAK ENGLISH, AND NO PROP CHANGES THEM.\n\n   While a Combobox list is open, Base UI (1.7.0) renders two visually hidden\n   buttons for screen readers: one before the input and one beside the popup. Both\n   are built in `combobox/utils/ComboboxInternalDismissButton.mjs` with the literal\n   `aria-label=\"Dismiss\"`; the component takes no props, so the only way to a\n   translated name is to rename the elements after they mount.\n\n   They mount AFTER this component's own render and layout effects (when the list\n   opens by a click, a key or a controlling parent's `open`), so a one-time rename\n   misses them. A MutationObserver on the two places they appear catches them\n   whenever they arrive: the anchor (the start button) and the portaled positioner\n   (the end button). A button this hook has renamed carries `data-dismiss-relabelled`,\n   so a later change of `label` renames it again.\n   ========================================================================= */\n\nconst DISMISS = '[aria-label=\"Dismiss\"], [data-dismiss-relabelled]';\nconst OBSERVE = { childList: true, subtree: true } as const;\n\nfunction relabel(root: Element, label: string): void {\n  for (const button of root.querySelectorAll(DISMISS)) {\n    button.setAttribute(\"aria-label\", label);\n    button.setAttribute(\"data-dismiss-relabelled\", \"\");\n  }\n}\n\n/**\n * Names Base UI's screen-reader dismiss buttons `label`. Pass the element they sit in before the\n * input (`anchorRef`); put the returned ref on the `Positioner`, which holds the other.\n */\nexport function useRelabelBaseUiDismiss(label: string, anchorRef: RefObject<Element | null>) {\n  useEffect(() => {\n    const anchor = anchorRef.current;\n    if (!anchor) return;\n    relabel(anchor, label);\n    const observer = new MutationObserver(() => relabel(anchor, label));\n    observer.observe(anchor, OBSERVE);\n    return () => observer.disconnect();\n  }, [label, anchorRef]);\n\n  const positionerObserver = useRef<MutationObserver | null>(null);\n  return useCallback(\n    (positioner: Element | null) => {\n      positionerObserver.current?.disconnect();\n      positionerObserver.current = null;\n      if (!positioner) return;\n      relabel(positioner, label);\n      positionerObserver.current = new MutationObserver(() => relabel(positioner, label));\n      positionerObserver.current.observe(positioner, OBSERVE);\n    },\n    [label],\n  );\n}\n"],"names":["DISMISS","OBSERVE","relabel","root","label","button","useRelabelBaseUiDismiss","anchorRef","useEffect","anchor","observer","positionerObserver","useRef","useCallback","positioner"],"mappings":";AAmBA,MAAMA,IAAU,qDACVC,IAAU,EAAE,WAAW,IAAM,SAAS,GAAA;AAE5C,SAASC,EAAQC,GAAeC,GAAqB;AACnD,aAAWC,KAAUF,EAAK,iBAAiBH,CAAO;AAChD,IAAAK,EAAO,aAAa,cAAcD,CAAK,GACvCC,EAAO,aAAa,2BAA2B,EAAE;AAErD;AAMO,SAASC,EAAwBF,GAAeG,GAAsC;AAC3F,EAAAC,EAAU,MAAM;AACd,UAAMC,IAASF,EAAU;AACzB,QAAI,CAACE,EAAQ;AACb,IAAAP,EAAQO,GAAQL,CAAK;AACrB,UAAMM,IAAW,IAAI,iBAAiB,MAAMR,EAAQO,GAAQL,CAAK,CAAC;AAClE,WAAAM,EAAS,QAAQD,GAAQR,CAAO,GACzB,MAAMS,EAAS,WAAA;AAAA,EACxB,GAAG,CAACN,GAAOG,CAAS,CAAC;AAErB,QAAMI,IAAqBC,EAAgC,IAAI;AAC/D,SAAOC;AAAA,IACL,CAACC,MAA+B;AAG9B,MAFAH,EAAmB,SAAS,WAAA,GAC5BA,EAAmB,UAAU,MACxBG,MACLZ,EAAQY,GAAYV,CAAK,GACzBO,EAAmB,UAAU,IAAI,iBAAiB,MAAMT,EAAQY,GAAYV,CAAK,CAAC,GAClFO,EAAmB,QAAQ,QAAQG,GAAYb,CAAO;AAAA,IACxD;AAAA,IACA,CAACG,CAAK;AAAA,EAAA;AAEV;"}

package/dist/lib/use-release-snap-drag.js

@@ -0,0 +1,29 @@
+import { useState as v, useRef as P, useEffect as R } from "react";
+const b = 3, S = (i) => Math.min(100, Math.max(0, i));
+function I({ enabled: i, reducedMotion: E }) {
+  const [h, a] = v(null), [w, c] = v(!1), r = P(null);
+  return R(() => () => r.current?.(), []), { dragPercent: h, settling: w, endSettling: () => c(!1), onPointerDown: (o) => {
+    if (!i || o.button !== 0) return;
+    r.current?.(), c(!1);
+    const d = o.currentTarget, e = d.ownerDocument, { pointerId: f, clientX: p, clientY: D } = o, s = o.target.closest("[data-index]")?.getBoundingClientRect(), L = s ? p - (s.left + s.width / 2) : 0;
+    let l = !1;
+    const g = (t) => {
+      if (t.pointerId !== f) return;
+      if (t.buttons === 0) return n(t);
+      if (!l && Math.hypot(t.clientX - p, t.clientY - D) < b) return;
+      const u = d.getBoundingClientRect();
+      u.width !== 0 && (l = !0, a(S((t.clientX - L - u.left) / u.width * 100)));
+    }, n = (t) => {
+      t.pointerId === f && (m(), a(null), l && !E && c(!0));
+    }, m = () => {
+      e.removeEventListener("pointermove", g), e.removeEventListener("pointerup", n), e.removeEventListener("pointercancel", n), r.current = null;
+    };
+    e.addEventListener("pointermove", g), e.addEventListener("pointerup", n), e.addEventListener("pointercancel", n), r.current = m;
+  } };
+}
+export {
+  b as DRAG_THRESHOLD_PX,
+  S as clampPercent,
+  I as useReleaseSnapDrag
+};
+//# sourceMappingURL=use-release-snap-drag.js.map

package/dist/lib/use-release-snap-drag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-release-snap-drag.js","sources":["../../src/lib/use-release-snap-drag.ts"],"sourcesContent":["import { useEffect, useRef, useState } from \"react\";\nimport type { PointerEvent as ReactPointerEvent } from \"react\";\n\n/** A press that has not moved this far (px) is a click, not a drag: a track click never glides from the pointer. */\nexport const DRAG_THRESHOLD_PX = 3;\n\n/** A position along a track, as a percentage held to the track's ends. */\nexport const clampPercent = (percent: number): number => Math.min(100, Math.max(0, percent));\n\n/**\n * DXUI-17 / Slider `snap=\"release\"`. Base UI rounds every pointer position to `step` before it reports it,\n * so it cannot draw a thumb between steps. While a pointer holds the control this tracks where the pointer\n * is along the track (`dragPercent`), which only moves what is DRAWN; the value Base UI reports stays on the\n * steps. `settling` is true from a release that followed a drag until the next press or key, and is the\n * only thing that enables the glide onto the step.\n *\n * Follows the pressing pointer only, ends on its pointerup or pointercancel, and, like Base UI, ends on a\n * move that reports no button down (the pointerup was lost). Assumes a left-to-right track, as Base UI does\n * without a DirectionProvider.\n */\nexport function useReleaseSnapDrag({ enabled, reducedMotion }: { enabled: boolean; reducedMotion: boolean }) {\n  const [dragPercent, setDragPercent] = useState<number | null>(null);\n  const [settling, setSettling] = useState(false);\n  const stopFollowing = useRef<(() => void) | null>(null);\n  useEffect(() => () => stopFollowing.current?.(), []);\n\n  const onPointerDown = (event: ReactPointerEvent<HTMLElement>) => {\n    if (!enabled || event.button !== 0) return;\n    stopFollowing.current?.();\n    setSettling(false);\n    const control = event.currentTarget;\n    const doc = control.ownerDocument;\n    const { pointerId, clientX: startX, clientY: startY } = event;\n    /* Grabbing the thumb off its centre keeps that offset for the whole drag, as Base UI does. */\n    const grabbed = (event.target as Element).closest(\"[data-index]\")?.getBoundingClientRect();\n    const offset = grabbed ? startX - (grabbed.left + grabbed.width / 2) : 0;\n    let dragging = false;\n\n    const move = (e: PointerEvent) => {\n      if (e.pointerId !== pointerId) return;\n      if (e.buttons === 0) return end(e);\n      if (!dragging && Math.hypot(e.clientX - startX, e.clientY - startY) < DRAG_THRESHOLD_PX) return;\n      const box = control.getBoundingClientRect();\n      if (box.width === 0) return;\n      dragging = true;\n      setDragPercent(clampPercent(((e.clientX - offset - box.left) / box.width) * 100));\n    };\n    const end = (e: PointerEvent) => {\n      if (e.pointerId !== pointerId) return;\n      stop();\n      setDragPercent(null);\n      if (dragging && !reducedMotion) setSettling(true);\n    };\n    const stop = () => {\n      doc.removeEventListener(\"pointermove\", move);\n      doc.removeEventListener(\"pointerup\", end);\n      doc.removeEventListener(\"pointercancel\", end);\n      stopFollowing.current = null;\n    };\n    doc.addEventListener(\"pointermove\", move);\n    doc.addEventListener(\"pointerup\", end);\n    doc.addEventListener(\"pointercancel\", end);\n    stopFollowing.current = stop;\n  };\n\n  return { dragPercent, settling, endSettling: () => setSettling(false), onPointerDown };\n}\n"],"names":["DRAG_THRESHOLD_PX","clampPercent","percent","useReleaseSnapDrag","enabled","reducedMotion","dragPercent","setDragPercent","useState","settling","setSettling","stopFollowing","useRef","useEffect","event","control","doc","pointerId","startX","startY","grabbed","offset","dragging","move","e","end","box","stop"],"mappings":";AAIO,MAAMA,IAAoB,GAGpBC,IAAe,CAACC,MAA4B,KAAK,IAAI,KAAK,KAAK,IAAI,GAAGA,CAAO,CAAC;AAapF,SAASC,EAAmB,EAAE,SAAAC,GAAS,eAAAC,KAA+D;AAC3G,QAAM,CAACC,GAAaC,CAAc,IAAIC,EAAwB,IAAI,GAC5D,CAACC,GAAUC,CAAW,IAAIF,EAAS,EAAK,GACxCG,IAAgBC,EAA4B,IAAI;AACtD,SAAAC,EAAU,MAAM,MAAMF,EAAc,UAAA,GAAa,CAAA,CAAE,GAyC5C,EAAE,aAAAL,GAAa,UAAAG,GAAU,aAAa,MAAMC,EAAY,EAAK,GAAG,eAvCjD,CAACI,MAA0C;AAC/D,QAAI,CAACV,KAAWU,EAAM,WAAW,EAAG;AACpC,IAAAH,EAAc,UAAA,GACdD,EAAY,EAAK;AACjB,UAAMK,IAAUD,EAAM,eAChBE,IAAMD,EAAQ,eACd,EAAE,WAAAE,GAAW,SAASC,GAAQ,SAASC,MAAWL,GAElDM,IAAWN,EAAM,OAAmB,QAAQ,cAAc,GAAG,sBAAA,GAC7DO,IAASD,IAAUF,KAAUE,EAAQ,OAAOA,EAAQ,QAAQ,KAAK;AACvE,QAAIE,IAAW;AAEf,UAAMC,IAAO,CAACC,MAAoB;AAChC,UAAIA,EAAE,cAAcP,EAAW;AAC/B,UAAIO,EAAE,YAAY,EAAG,QAAOC,EAAID,CAAC;AACjC,UAAI,CAACF,KAAY,KAAK,MAAME,EAAE,UAAUN,GAAQM,EAAE,UAAUL,CAAM,IAAInB,EAAmB;AACzF,YAAM0B,IAAMX,EAAQ,sBAAA;AACpB,MAAIW,EAAI,UAAU,MAClBJ,IAAW,IACXf,EAAeN,GAAeuB,EAAE,UAAUH,IAASK,EAAI,QAAQA,EAAI,QAAS,GAAG,CAAC;AAAA,IAClF,GACMD,IAAM,CAACD,MAAoB;AAC/B,MAAIA,EAAE,cAAcP,MACpBU,EAAA,GACApB,EAAe,IAAI,GACfe,KAAY,CAACjB,KAAeK,EAAY,EAAI;AAAA,IAClD,GACMiB,IAAO,MAAM;AACjB,MAAAX,EAAI,oBAAoB,eAAeO,CAAI,GAC3CP,EAAI,oBAAoB,aAAaS,CAAG,GACxCT,EAAI,oBAAoB,iBAAiBS,CAAG,GAC5Cd,EAAc,UAAU;AAAA,IAC1B;AACA,IAAAK,EAAI,iBAAiB,eAAeO,CAAI,GACxCP,EAAI,iBAAiB,aAAaS,CAAG,GACrCT,EAAI,iBAAiB,iBAAiBS,CAAG,GACzCd,EAAc,UAAUgB;AAAA,EAC1B,EAEuE;AACzE;"}

package/dist/lib/use-roving-options.js

@@ -0,0 +1,18 @@
+import { useRef as x, useState as l } from "react";
+function h(n, c, u) {
+  const r = x(null), [p, d] = l(null), f = Math.min(p ?? Math.max(c, 0), Math.max(n - 1, 0));
+  function m(t) {
+    const e = t.target.closest("[data-option-index]");
+    if (!e) return;
+    const o = Number(e.dataset.optionIndex), a = Math.max(u, 1), i = t.key === "ArrowRight" ? o + 1 : t.key === "ArrowLeft" ? o - 1 : t.key === "ArrowDown" ? o + a : t.key === "ArrowUp" ? o - a : t.key === "Home" ? 0 : t.key === "End" ? n - 1 : void 0;
+    if (i === void 0) return;
+    t.preventDefault();
+    const s = Math.min(Math.max(i, 0), n - 1);
+    d(s), r.current?.querySelector(`[data-option-index="${s}"]`)?.focus();
+  }
+  return { listRef: r, tabIndexFor: (t) => t === f ? 0 : -1, onKeyDown: m };
+}
+export {
+  h as useRovingOptions
+};
+//# sourceMappingURL=use-roving-options.js.map

package/dist/lib/use-roving-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-roving-options.js","sources":["../../src/lib/use-roving-options.ts"],"sourcesContent":["import { useRef, useState, type KeyboardEvent } from \"react\";\n\n/* ============================================================================\n   ROVING OPTIONS - the keyboard model of `EmojiPicker`'s grid (DXUI-27).\n\n   A picker's choices are ONE Tab stop, not one per option: Tab lands on the\n   chosen option (the first when nothing is chosen), the arrow keys move focus\n   between options, Home and End jump to the ends, and Enter or Space choose\n   (the option is a native button, so the click does that). It is the roving\n   contract of `RadioGroup` / `RatingScale`, with one deliberate difference:\n   arrows move FOCUS only and never choose. A picker closes when something is\n   chosen, so choosing on every arrow press would shut it on the first key.\n   That makes the container a `listbox` of `option`s rather than a radiogroup.\n\n   `columns` is the grid width: Up and Down step a row, Left and Right a cell.\n   Focus clamps at the ends rather than wrapping, as `RatingScale` does.\n   ========================================================================= */\n\nexport interface RovingOptions {\n  /** Attach to the element with `role=\"listbox\"`. */\n  listRef: React.RefObject<HTMLDivElement | null>;\n  /** `0` for the one option that is a Tab stop, `-1` for the rest. */\n  tabIndexFor: (index: number) => 0 | -1;\n  /** Attach to the same element; each option carries `data-option-index`. */\n  onKeyDown: (event: KeyboardEvent<HTMLElement>) => void;\n}\n\nexport function useRovingOptions(count: number, selectedIndex: number, columns: number): RovingOptions {\n  const listRef = useRef<HTMLDivElement | null>(null);\n  const [active, setActive] = useState<number | null>(null);\n  const stop = Math.min(active ?? Math.max(selectedIndex, 0), Math.max(count - 1, 0));\n\n  function onKeyDown(event: KeyboardEvent<HTMLElement>) {\n    const option = (event.target as HTMLElement).closest<HTMLElement>(\"[data-option-index]\");\n    if (!option) return;\n    const current = Number(option.dataset.optionIndex);\n    const step = Math.max(columns, 1);\n    const target =\n      event.key === \"ArrowRight\"\n        ? current + 1\n        : event.key === \"ArrowLeft\"\n          ? current - 1\n          : event.key === \"ArrowDown\"\n            ? current + step\n            : event.key === \"ArrowUp\"\n              ? current - step\n              : event.key === \"Home\"\n                ? 0\n                : event.key === \"End\"\n                  ? count - 1\n                  : undefined;\n    if (target === undefined) return;\n    event.preventDefault();\n    const next = Math.min(Math.max(target, 0), count - 1);\n    setActive(next);\n    listRef.current?.querySelector<HTMLElement>(`[data-option-index=\"${next}\"]`)?.focus();\n  }\n\n  return { listRef, tabIndexFor: (index) => (index === stop ? 0 : -1), onKeyDown };\n}\n"],"names":["useRovingOptions","count","selectedIndex","columns","listRef","useRef","active","setActive","useState","stop","onKeyDown","event","option","current","step","target","next","index"],"mappings":";AA2BO,SAASA,EAAiBC,GAAeC,GAAuBC,GAAgC;AACrG,QAAMC,IAAUC,EAA8B,IAAI,GAC5C,CAACC,GAAQC,CAAS,IAAIC,EAAwB,IAAI,GAClDC,IAAO,KAAK,IAAIH,KAAU,KAAK,IAAIJ,GAAe,CAAC,GAAG,KAAK,IAAID,IAAQ,GAAG,CAAC,CAAC;AAElF,WAASS,EAAUC,GAAmC;AACpD,UAAMC,IAAUD,EAAM,OAAuB,QAAqB,qBAAqB;AACvF,QAAI,CAACC,EAAQ;AACb,UAAMC,IAAU,OAAOD,EAAO,QAAQ,WAAW,GAC3CE,IAAO,KAAK,IAAIX,GAAS,CAAC,GAC1BY,IACJJ,EAAM,QAAQ,eACVE,IAAU,IACVF,EAAM,QAAQ,cACZE,IAAU,IACVF,EAAM,QAAQ,cACZE,IAAUC,IACVH,EAAM,QAAQ,YACZE,IAAUC,IACVH,EAAM,QAAQ,SACZ,IACAA,EAAM,QAAQ,QACZV,IAAQ,IACR;AAChB,QAAIc,MAAW,OAAW;AAC1B,IAAAJ,EAAM,eAAA;AACN,UAAMK,IAAO,KAAK,IAAI,KAAK,IAAID,GAAQ,CAAC,GAAGd,IAAQ,CAAC;AACpD,IAAAM,EAAUS,CAAI,GACdZ,EAAQ,SAAS,cAA2B,uBAAuBY,CAAI,IAAI,GAAG,MAAA;AAAA,EAChF;AAEA,SAAO,EAAE,SAAAZ,GAAS,aAAa,CAACa,MAAWA,MAAUR,IAAO,IAAI,IAAK,WAAAC,EAAA;AACvE;"}

package/dist/lib/values/absent.js

@@ -0,0 +1,5 @@
+const o = "—";
+export {
+  o as ABSENT
+};
+//# sourceMappingURL=absent.js.map

package/dist/lib/values/absent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"absent.js","sources":["../../../src/lib/values/absent.ts"],"sourcesContent":["/** The shared \"no value\" reading for a blank field — a date, a number, a\n *  phone number, a currency amount: nothing recorded. Shared by every\n *  formatter that reads absence this way, so the glyph itself never drifts\n *  between them (DX-3254). `formatBoolean` does NOT use this — see its own\n *  module doc for why a tri-state boolean reads absence as \"Unknown\"\n *  instead. */\nexport const ABSENT = \"—\";\n"],"names":["ABSENT"],"mappings":"AAMO,MAAMA,IAAS;"}

package/dist/lib/values/boolean.js

@@ -0,0 +1,13 @@
+function l(n, e, r = {}) {
+  const { trueLabel: o = e.yes, falseLabel: u = e.no, unknownLabel: t = e.unknown } = r;
+  return n === !0 ? o : n === !1 ? u : t;
+}
+function a(n, e) {
+  const r = n.trim().toLowerCase();
+  return e.trueWords.includes(r) ? !0 : e.falseWords.includes(r) ? !1 : null;
+}
+export {
+  l as formatBoolean,
+  a as parseBoolean
+};
+//# sourceMappingURL=boolean.js.map

package/dist/lib/values/boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.js","sources":["../../../src/lib/values/boolean.ts"],"sourcesContent":["/* ----------------------------------------------------------------------------\n   A TRI-STATE BOOLEAN — `true`, `false`, or nothing recorded.\n\n   `\"Unknown\"`, NOT THE EM DASH, is the default for `null`/`undefined` here —\n   the one deliberate departure from the convention every other formatter in\n   this file follows. The em dash reads correctly as \"no value\" for a date, a\n   number, a phone number: a blank field on a form. A boolean field usually\n   means something was actually ASKED — \"was the patient transported by\n   ambulance,\" \"is there a police report\" — and `null` there means the\n   question has not been answered yet, which is a materially different fact\n   from \"answered no.\" An em dash sits visually closer to \"false-ish\" than\n   \"unanswered\" does; \"Unknown\" does not. `unknownLabel` exists to opt back\n   into the em dash (or anything else) for a dense table where every column\n   already uses it and a differently-worded cell would stand out for the\n   wrong reason — the default is chosen for a single tri-state field read on\n   its own, not for a grid.\n   -------------------------------------------------------------------------- */\n\nimport type { BooleanStrings } from \"../i18n/areas/formats\";\n\nexport interface FormatBooleanOptions {\n  /** Word for `true`. Default `strings.yes`. */\n  trueLabel?: string;\n  /** Word for `false`. Default `strings.no`. */\n  falseLabel?: string;\n  /** Word for `null` / `undefined`. Default `strings.unknown` — see the module doc\n   *  for why this is not the em dash the rest of this package uses for\n   *  absence. */\n  unknownLabel?: string;\n}\n\n/**\n * `true` → `strings.yes`, `false` → `strings.no`, `null` / `undefined` →\n * `strings.unknown` (all three overridable via `options`).\n */\nexport function formatBoolean(\n  value: boolean | null | undefined,\n  strings: BooleanStrings,\n  options: FormatBooleanOptions = {},\n): string {\n  const { trueLabel = strings.yes, falseLabel = strings.no, unknownLabel = strings.unknown } = options;\n  if (value === true) return trueLabel;\n  if (value === false) return falseLabel;\n  return unknownLabel;\n}\n\n/**\n * A human-typed word → `true`, `false`, or `null` for anything else\n * (including an empty string — a caller cannot distinguish \"typed nothing\"\n * from \"typed a real value\" if both return `false`).\n *\n * Matches case-insensitively against the spellings in `strings.trueWords` /\n * `strings.falseWords` (English: `yes`/`y`/`true`/`t`/`1` and `no`/`n`/`false`/\n * `f`/`0`). Deliberately does NOT guess at anything outside that list — a\n * typo like `\"yse\"` returning `null` for a caller to reject is correct;\n * returning `false` for it (or any other unrecognised text) would silently\n * record the opposite of an unreadable answer.\n */\nexport function parseBoolean(input: string, strings: BooleanStrings): boolean | null {\n  const normalized = input.trim().toLowerCase();\n  if (strings.trueWords.includes(normalized)) return true;\n  if (strings.falseWords.includes(normalized)) return false;\n  return null;\n}\n"],"names":["formatBoolean","value","strings","options","trueLabel","falseLabel","unknownLabel","parseBoolean","input","normalized"],"mappings":"AAmCO,SAASA,EACdC,GACAC,GACAC,IAAgC,CAAA,GACxB;AACR,QAAM,EAAE,WAAAC,IAAYF,EAAQ,KAAK,YAAAG,IAAaH,EAAQ,IAAI,cAAAI,IAAeJ,EAAQ,QAAA,IAAYC;AAC7F,SAAIF,MAAU,KAAaG,IACvBH,MAAU,KAAcI,IACrBC;AACT;AAcO,SAASC,EAAaC,GAAeN,GAAyC;AACnF,QAAMO,IAAaD,EAAM,KAAA,EAAO,YAAA;AAChC,SAAIN,EAAQ,UAAU,SAASO,CAAU,IAAU,KAC/CP,EAAQ,WAAW,SAASO,CAAU,IAAU,KAC7C;AACT;"}

package/dist/lib/values/currency.js

@@ -0,0 +1,23 @@
+import { ABSENT as f } from "./absent.js";
+import { numberFormat as o, parseLocalizedNumber as l } from "../intl-cache.js";
+const c = {
+  style: "currency",
+  // I18N-ALLOW: ISO 4217 currency code option
+  currency: "USD",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+};
+function b(r, n) {
+  return r == null || !Number.isFinite(r) ? f : o(n, c).format(r);
+}
+function g(r, n) {
+  const t = r.trim();
+  if (t === "") return null;
+  const e = /^\((.*)\)$/.exec(t), u = e !== null, m = e ? e[1] : t, s = o(n, c).formatToParts(0).find((a) => a.type === "currency").value, i = l(m.replace(/\s/g, ""), n, [s, "$"]);
+  return i === null ? null : u ? -Math.abs(i) : i;
+}
+export {
+  b as formatCurrency,
+  g as parseCurrency
+};
+//# sourceMappingURL=currency.js.map

package/dist/lib/values/currency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"currency.js","sources":["../../../src/lib/values/currency.ts"],"sourcesContent":["/* ----------------------------------------------------------------------------\n   USD MONEY.\n\n   ALWAYS TWO DECIMAL PLACES, regardless of magnitude — the opposite choice\n   from `formatBytes`/`formatTokens`, and deliberately so. Those two round MORE\n   aggressively as a number grows because the tenth of a KB or the exact token\n   count stop being digits anyone acts on at scale. A dollar figure never\n   reaches that point: the gap between $1,234,567.89 and $1,234,568.00 is\n   eighty-nine real cents on an invoice or a settlement figure, not noise, no\n   matter how many digits come before the decimal point. So precision here is\n   fixed, not magnitude-scaled.\n\n   ZERO IS NOT ABSENCE. `formatCurrency(0)` is `\"$0.00\"` — a real, recorded\n   amount, e.g. a fully-waived fee or a $0 deductible. `null`/`undefined` is\n   \"no figure was entered\", rendered as the em dash this package's other\n   formatters use for the same fact. Collapsing the two (rendering 0 as \"—\",\n   or treating \"—\" as 0 in a sum) is the classic spreadsheet bug this\n   distinction exists to prevent.\n   -------------------------------------------------------------------------- */\n\nimport { ABSENT } from \"./absent\";\nimport { numberFormat, parseLocalizedNumber } from \"../intl-cache\";\n\nconst USD: Intl.NumberFormatOptions = {\n  style: \"currency\",\n  // I18N-ALLOW: ISO 4217 currency code option\n  currency: \"USD\",\n  minimumFractionDigits: 2,\n  maximumFractionDigits: 2,\n};\n\n/**\n * `1234.5` → `\"$1,234.50\"` in `en-US`, `\"1.234,50 $\"` in `de-DE`. `null` / `undefined` → `\"—\"`. `0` → `\"$0.00\"`.\n *\n * `NaN` / `Infinity` are not real amounts either and render as the em dash —\n * grouped with absence rather than with a malformed string, because unlike\n * `formatDate`'s malformed-input case, there is no ORIGINAL\n * user-facing string to show back: the caller already has a `number`, and a\n * non-finite one is a computation defect upstream, not a typo to surface.\n */\nexport function formatCurrency(value: number | null | undefined, locale: string): string {\n  if (value == null || !Number.isFinite(value)) return ABSENT;\n  return numberFormat(locale, USD).format(value);\n}\n\n/**\n * A human-typed amount → a `number` in dollars, or `null`.\n *\n * Tolerates the punctuation someone actually types or pastes: the dollar sign\n * (and `locale`'s own symbol for it), `locale`'s thousands separator, surrounding whitespace, and ACCOUNTING-style negatives —\n * `\"($1,234.56)\"` for `-1234.56`, the convention every US invoice and EOB\n * already uses for a credit or a refund. A leading `-` is accepted too.\n * Returns `null` — never `NaN`, never a silent `0` — for anything that is not\n * recognizably a number once that punctuation is stripped, so a caller can\n * reject a bad edit instead of storing garbage.\n */\nexport function parseCurrency(input: string, locale: string): number | null {\n  const trimmed = input.trim();\n  if (trimmed === \"\") return null;\n\n  const accounting = /^\\((.*)\\)$/.exec(trimmed);\n  const negative = accounting !== null;\n  const body = accounting ? accounting[1] : trimmed;\n\n  const symbol = numberFormat(locale, USD).formatToParts(0).find((p) => p.type === \"currency\")!.value;\n  const magnitude = parseLocalizedNumber(body.replace(/\\s/g, \"\"), locale, [symbol, \"$\"]);\n  if (magnitude === null) return null;\n  return negative ? -Math.abs(magnitude) : magnitude;\n}\n"],"names":["USD","formatCurrency","value","locale","ABSENT","numberFormat","parseCurrency","input","trimmed","accounting","negative","body","symbol","p","magnitude","parseLocalizedNumber"],"mappings":";;AAuBA,MAAMA,IAAgC;AAAA,EACpC,OAAO;AAAA;AAAA,EAEP,UAAU;AAAA,EACV,uBAAuB;AAAA,EACvB,uBAAuB;AACzB;AAWO,SAASC,EAAeC,GAAkCC,GAAwB;AACvF,SAAID,KAAS,QAAQ,CAAC,OAAO,SAASA,CAAK,IAAUE,IAC9CC,EAAaF,GAAQH,CAAG,EAAE,OAAOE,CAAK;AAC/C;AAaO,SAASI,EAAcC,GAAeJ,GAA+B;AAC1E,QAAMK,IAAUD,EAAM,KAAA;AACtB,MAAIC,MAAY,GAAI,QAAO;AAE3B,QAAMC,IAAa,aAAa,KAAKD,CAAO,GACtCE,IAAWD,MAAe,MAC1BE,IAAOF,IAAaA,EAAW,CAAC,IAAID,GAEpCI,IAASP,EAAaF,GAAQH,CAAG,EAAE,cAAc,CAAC,EAAE,KAAK,CAACa,MAAMA,EAAE,SAAS,UAAU,EAAG,OACxFC,IAAYC,EAAqBJ,EAAK,QAAQ,OAAO,EAAE,GAAGR,GAAQ,CAACS,GAAQ,GAAG,CAAC;AACrF,SAAIE,MAAc,OAAa,OACxBJ,IAAW,CAAC,KAAK,IAAII,CAAS,IAAIA;AAC3C;"}

package/dist/lib/values/date.js

@@ -0,0 +1,35 @@
+import { parsePlainDate as s, daysInMonth as d } from "../time/plain.js";
+import { dateFormat as l, asUtcDate as c } from "../intl-cache.js";
+import { normalizeDigits as p, datePattern as y, dateFields as D, DATE_OPTIONS as N } from "./locale-date.js";
+import { ABSENT as h } from "./absent.js";
+import { isoDateString as x } from "../time/types.js";
+function E(r, o) {
+  if (r == null || r === "") return h;
+  let t;
+  try {
+    t = s(r);
+  } catch {
+    return r;
+  }
+  return l(o, N).format(c(t.year, t.month, t.day));
+}
+const O = /^(\d{4})-(\d{1,2})-(\d{1,2})$/;
+function F(r, o) {
+  const t = p(r, o).trim();
+  if (t === "") return null;
+  let i, e, n;
+  const m = O.exec(t);
+  if (m)
+    i = Number(m[1]), e = Number(m[2]), n = Number(m[3]);
+  else {
+    const { order: u, source: f } = y(o), a = new RegExp(`^${f}$`).exec(t);
+    if (!a) return null;
+    ({ year: i, month: e, day: n } = D(u, a));
+  }
+  return e < 1 || e > 12 || n < 1 || n > d(i, e) ? null : x({ year: i, month: e, day: n });
+}
+export {
+  E as formatDate,
+  F as parseDate
+};
+//# sourceMappingURL=date.js.map

package/dist/lib/values/date.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.js","sources":["../../../src/lib/values/date.ts"],"sourcesContent":["import { daysInMonth, isoDateString, parsePlainDate } from \"../time/plain\";\nimport type { PlainDate } from \"../time/types\";\nimport { asUtcDate, dateFormat } from \"../intl-cache\";\nimport { DATE_OPTIONS, datePattern, dateFields, normalizeDigits } from \"./locale-date\";\nimport { ABSENT } from \"./absent\";\n\n/* ----------------------------------------------------------------------------\n   A CALENDAR DATE — no time, no zone, just which square on the wall.\n\n   Storage form is `YYYY-MM-DD`, the same ISO shape `lib/time` already parses\n   and prints (`parsePlainDate` / `isoDateString`). That is not a coincidence —\n   an accident date, a policy effective date, a date of birth are all exactly\n   the `PlainDate` the calendar layer already models, and reusing its\n   leap-year-correct arithmetic here is the whole point of `lib/time` existing\n   as a shared layer instead of a calendar-component implementation detail.\n\n   THE BUG THIS FILE CANNOT HAVE, BY CONSTRUCTION. The classic defect —\n   `new Date(\"2026-09-11\")` parsed as UTC midnight, then printed in a reader\n   west of Greenwich, silently showing \"09/10/2026\" — requires a `Date` object\n   and an implicit zone somewhere in the path from string to string. Here the\n   only `Date` is built in UTC from the parsed fields and printed in UTC, and\n   `parseDate` reads typed fields straight into a `PlainDate`. There is no\n   step at which the reader's zone could enter.\n\n   DISPLAY FORMAT: the locale's all-numeric date — `MM/DD/YYYY` in `en-US`,\n   `DD.MM.YYYY` in `de-DE`. Not `Intl`'s long `\"Sep 11, 2026\"`: a 4-digit year\n   with no ambiguity about which field is the day matters more than prose, and\n   an all-numeric form is what a claim file, a police report and an EOB expect.\n   The fields are laid out by `Intl` in the locale's own order and separator,\n   fed a UTC `Date` built from the parsed fields (never a zone-shifted one),\n   so the bug above still cannot happen. It is also the shape `parseDate`\n   accepts back, so a value a person types after seeing this library's own\n   display round-trips without translation.\n   -------------------------------------------------------------------------- */\n\n\n/**\n * `\"2026-09-11\"` → `\"09/11/2026\"` in `en-US`, `\"11.09.2026\"` in `de-DE`.\n *\n * `null` / `undefined` / `\"\"` render as the em dash — no date entered, the\n * convention the rest of this package's formatters share (`formatTokens`,\n * `formatBoolean`'s \"Unknown\" is the one deliberate exception; see its own\n * docblock for why absence needs a different word there).\n *\n * A non-empty value that is NOT a valid `YYYY-MM-DD` date is returned\n * UNCHANGED rather than folded into the same em dash. Absence and corruption\n * are different facts — silently rendering a malformed stored value as \"no\n * date\" hides a data problem behind a blank field; showing the raw string\n * puts it in front of whoever is looking at the row.\n */\nexport function formatDate(value: string | null | undefined, locale: string): string {\n  if (value == null || value === \"\") return ABSENT;\n  let date: PlainDate;\n  try {\n    date = parsePlainDate(value);\n  } catch {\n    return value;\n  }\n  return dateFormat(locale, DATE_OPTIONS).format(asUtcDate(date.year, date.month, date.day));\n}\n\nconst ISO_FORMAT = /^(\\d{4})-(\\d{1,2})-(\\d{1,2})$/;\n\n/**\n * A human-typed date → the stored `YYYY-MM-DD`, or `null` if it is not one.\n *\n * Accepts the numeric date in `locale`'s own order (what `formatDate` prints, and what a person types\n * into a text field) and bare ISO `YYYY-MM-DD` (what a paste from another\n * system, or this library's own storage form, looks like) — nothing looser.\n * `Date`-style leniency (`new Date(\"2026-2-30\")` silently becoming the 2nd of\n * March) is exactly the failure mode `parsePlainDate`'s calendar-length check\n * exists to refuse, so this function refuses it too: `daysInMonth` bounds the\n * day before anything is accepted.\n *\n * Returns `null`, never throws — a form validating a field checks the return\n * value; it should not have to wrap every keystroke in `try`/`catch`.\n */\nexport function parseDate(input: string, locale: string): string | null {\n  const trimmed = normalizeDigits(input, locale).trim();\n  if (trimmed === \"\") return null;\n\n  let year: number;\n  let month: number;\n  let day: number;\n\n  const iso = ISO_FORMAT.exec(trimmed);\n  if (iso) {\n    year = Number(iso[1]);\n    month = Number(iso[2]);\n    day = Number(iso[3]);\n  } else {\n    const { order, source } = datePattern(locale);\n    const typed = new RegExp(`^${source}$`).exec(trimmed);\n    if (!typed) return null;\n    ({ year, month, day } = dateFields(order, typed));\n  }\n\n  if (month < 1 || month > 12) return null;\n  if (day < 1 || day > daysInMonth(year, month)) return null;\n  return isoDateString({ year, month, day });\n}\n"],"names":["formatDate","value","locale","ABSENT","date","parsePlainDate","dateFormat","DATE_OPTIONS","asUtcDate","ISO_FORMAT","parseDate","input","trimmed","normalizeDigits","year","month","day","iso","order","source","datePattern","typed","dateFields","daysInMonth","isoDateString"],"mappings":";;;;;AAkDO,SAASA,EAAWC,GAAkCC,GAAwB;AACnF,MAAID,KAAS,QAAQA,MAAU,GAAI,QAAOE;AAC1C,MAAIC;AACJ,MAAI;AACF,IAAAA,IAAOC,EAAeJ,CAAK;AAAA,EAC7B,QAAQ;AACN,WAAOA;AAAA,EACT;AACA,SAAOK,EAAWJ,GAAQK,CAAY,EAAE,OAAOC,EAAUJ,EAAK,MAAMA,EAAK,OAAOA,EAAK,GAAG,CAAC;AAC3F;AAEA,MAAMK,IAAa;AAgBZ,SAASC,EAAUC,GAAeT,GAA+B;AACtE,QAAMU,IAAUC,EAAgBF,GAAOT,CAAM,EAAE,KAAA;AAC/C,MAAIU,MAAY,GAAI,QAAO;AAE3B,MAAIE,GACAC,GACAC;AAEJ,QAAMC,IAAMR,EAAW,KAAKG,CAAO;AACnC,MAAIK;AACF,IAAAH,IAAO,OAAOG,EAAI,CAAC,CAAC,GACpBF,IAAQ,OAAOE,EAAI,CAAC,CAAC,GACrBD,IAAM,OAAOC,EAAI,CAAC,CAAC;AAAA,OACd;AACL,UAAM,EAAE,OAAAC,GAAO,QAAAC,MAAWC,EAAYlB,CAAM,GACtCmB,IAAQ,IAAI,OAAO,IAAIF,CAAM,GAAG,EAAE,KAAKP,CAAO;AACpD,QAAI,CAACS,EAAO,QAAO;AACnB,KAAC,EAAE,MAAAP,GAAM,OAAAC,GAAO,KAAAC,MAAQM,EAAWJ,GAAOG,CAAK;AAAA,EACjD;AAGA,SADIN,IAAQ,KAAKA,IAAQ,MACrBC,IAAM,KAAKA,IAAMO,EAAYT,GAAMC,CAAK,IAAU,OAC/CS,EAAc,EAAE,MAAAV,GAAM,OAAAC,GAAO,KAAAC,GAAK;AAC3C;"}

package/dist/lib/values/datetime.js

@@ -0,0 +1,54 @@
+import { instantToPlainDateTime as w, plainDateTimeToInstant as z } from "../time/zone.js";
+import { daysInMonth as O } from "../time/plain.js";
+import { dateFormat as b } from "../intl-cache.js";
+import { plainSpaces as g, wallDate as E, normalizeDigits as P, datePattern as $, dateFields as y, TIME_OPTIONS as F, clockPattern as Z, normalizePeriod as _ } from "./locale-date.js";
+import { ABSENT as h } from "./absent.js";
+function D() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function I(t) {
+  if (typeof t == "number") return Number.isFinite(t) ? t : null;
+  const e = t.replace(/(\.\d{3})\d+/, "$1"), i = Date.parse(e);
+  return Number.isNaN(i) ? null : i;
+}
+function R(t, e, i = {}) {
+  if (t == null || t === "") return h;
+  const o = I(t);
+  if (o === null) return String(t);
+  const m = i.zone ?? D(), u = w(m, o);
+  return g(b(e, F).format(E(u)));
+}
+const x = String.raw`(?:,?\s+(\d{1,2}):(\d{2})(?::(\d{2}))?(?:\s*([^\d\s].*?))?)?`, H = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?\s*(Z|[+-]\d{2}:?\d{2})$/;
+function W(t, e, i = {}) {
+  const o = P(t, e).trim();
+  if (o === "") return null;
+  if (H.test(o)) {
+    const n = I(o);
+    return n === null ? null : new Date(n).toISOString();
+  }
+  const { order: m, source: u } = $(e), r = new RegExp(`^${u}${x}$`).exec(o);
+  if (!r) return null;
+  const { year: T, month: l, day: a } = y(m, r);
+  if (l < 1 || l > 12 || a < 1 || a > O(T, l)) return null;
+  let d = 0, c = 0, f = 0;
+  if (r[4] !== void 0) {
+    const n = Number(r[4]);
+    if (c = Number(r[5]), f = r[6] !== void 0 ? Number(r[6]) : 0, c > 59 || f > 59) return null;
+    const s = Z(e);
+    if (s.twelveHour) {
+      const p = r[7] === void 0 ? void 0 : _(r[7]);
+      if (n < 1 || n > 12 || p !== s.am && p !== s.pm) return null;
+      d = p === s.am ? n === 12 ? 0 : n : n === 12 ? 12 : n + 12;
+    } else {
+      if (n > 23 || r[7] !== void 0) return null;
+      d = n;
+    }
+  }
+  const N = { year: T, month: l, day: a, hour: d, minute: c, second: f, millisecond: 0 }, S = i.zone ?? D();
+  return new Date(z(S, N)).toISOString();
+}
+export {
+  R as formatDateTime,
+  W as parseDateTime
+};
+//# sourceMappingURL=datetime.js.map

package/dist/lib/values/datetime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datetime.js","sources":["../../../src/lib/values/datetime.ts"],"sourcesContent":["import { instantToPlainDateTime, plainDateTimeToInstant } from \"../time/zone\";\nimport { daysInMonth } from \"../time/plain\";\nimport type { PlainDateTime } from \"../time/types\";\nimport { dateFormat } from \"../intl-cache\";\nimport { TIME_OPTIONS, clockPattern, dateFields, datePattern, normalizeDigits, normalizePeriod, plainSpaces, wallDate } from \"./locale-date\";\nimport { ABSENT } from \"./absent\";\n\n/* ----------------------------------------------------------------------------\n   AN INSTANT — a fixed point on the timeline, rendered through a zone.\n\n   THE DISTINCTION FROM `date.ts`, AND WHY IT IS A SEPARATE FILE RATHER THAN AN\n   OPTION ON THE SAME ONE. An accident date is a calendar square: everyone who\n   reads a claim file agrees it happened on the 11th, regardless of where they\n   are sitting. \"When this record was created\" is not — it is one instant, and\n   a reader in Los Angeles and a reader in New York see it at different clock\n   times on (near a midnight boundary) potentially different DAYS. Collapsing\n   the two into one formatter with a \"is this a date-time\" flag is how a\n   calendar date ends up accidentally zone-shifted, which is the exact defect\n   `date.ts`'s docblock explains `formatDate` cannot have. Keeping them as two\n   files with two contracts is what keeps that true.\n\n   STORAGE FORM is an ISO instant string (`\"2026-09-11T19:18:43.000Z\"`,\n   `\"...43.000000Z\"` — microsecond precision, as a Laravel/Carbon backend\n   emits, is accepted and truncated to milliseconds, see `toInstant` below) or\n   a raw epoch-millisecond number — `lib/time`'s own `Instant`. Either is\n   accepted so a consumer does not have to convert before handing a value in.\n\n   DISPLAY FORMAT is the locale's all-numeric date and clock — `MM/DD/YYYY,\n   h:mm AM/PM` in `en-US`, `DD.MM.YYYY, HH:mm` in `de-DE` — the SAME numeric\n   date `date.ts` uses, not `Intl`'s long `\"Sep 11, 2026, 1:18 PM\"`. Two\n   reasons, not one: it keeps a date and a date-time reading consistently\n   across a table that shows both, and it means `parseDateTime` can invert\n   exactly what `formatDateTime` prints without parsing a localised month name\n   back out of a string — both read the field order and day-period words from\n   the same `Intl` probe (`locale-date.ts`), so the two functions agree with\n   each other in the locales `date-parse-locales.test.ts` pins (en-US, de-DE,\n   es-AR, hu-HU, bg-BG); `parseDate` is pinned for those plus ko-KR, ar-EG and\n   fa-IR. A locale whose clock puts the day period before the time (ko-KR) is\n   not claimed.\n\n   THE ZONE CONVERSION ITSELF IS NOT REIMPLEMENTED HERE. `instantToPlainDateTime`\n   and `plainDateTimeToInstant` are `lib/time/zone.ts`'s own primitives, proven\n   against a five-zone DST corpus (`time-dst.test.ts`) that includes half-hour\n   offsets, midnight-skipping transitions and hours that happen twice. Writing\n   a second, ad-hoc offset calculation here — the way a naive datetime\n   formatter usually does — is exactly how the bugs that corpus documents get\n   reintroduced a second time in the same codebase.\n   -------------------------------------------------------------------------- */\n\n/** The reader's own zone, per the host `Intl` implementation — the correct\n *  default for an INSTANT, which (unlike a `PlainDate`) has no zone of its\n *  own until someone reads it. */\nfunction localZone(): string {\n  return Intl.DateTimeFormat().resolvedOptions().timeZone;\n}\n\n/**\n * A stored instant (ISO string or epoch ms) → epoch milliseconds, or `null`.\n *\n * Microsecond-precision ISO strings (`.043210Z`, six fractional digits — what\n * Carbon's default JSON cast emits) are truncated to the three digits\n * `Date.parse` is spec-guaranteed to accept; V8 happens to be lenient with\n * more, but nothing requires every engine this bundles into to be.\n */\nfunction toInstant(value: string | number): number | null {\n  if (typeof value === \"number\") return Number.isFinite(value) ? value : null;\n  const normalized = value.replace(/(\\.\\d{3})\\d+/, \"$1\");\n  const ms = Date.parse(normalized);\n  return Number.isNaN(ms) ? null : ms;\n}\n\nexport interface FormatDateTimeOptions {\n  /**\n   * IANA zone to render in, e.g. `\"America/New_York\"`. Omit to use the\n   * reader's own zone — the right default for an instant, and the reason\n   * this is a parameter at all rather than always-local: a report emailed to\n   * someone in a different zone, or a server rendering a PDF, needs to say\n   * WHOSE clock the printed time is on.\n   */\n  zone?: string;\n}\n\n/**\n * A stored instant → `\"09/11/2026, 1:18 PM\"` (`en-US`) in `options.zone` (default: the\n * reader's own).\n *\n * `null` / `undefined` / `\"\"` render as the em dash. A non-empty value that\n * does not parse as an instant is returned UNCHANGED — see `date.ts`'s\n * docblock for why absence and corruption get different treatment.\n */\nexport function formatDateTime(\n  value: string | number | null | undefined,\n  locale: string,\n  options: FormatDateTimeOptions = {},\n): string {\n  if (value == null || value === \"\") return ABSENT;\n  const instant = toInstant(value);\n  if (instant === null) return String(value);\n\n  const zone = options.zone ?? localZone();\n  const wall = instantToPlainDateTime(zone, instant);\n  return plainSpaces(dateFormat(locale, TIME_OPTIONS).format(wallDate(wall)));\n}\n\n/* The time after a typed date: `h:mm[:ss]`, then the locale's day period when its clock has one —\n   what `formatDateTime` prints, plus optional seconds for a value pasted from somewhere more precise. */\n// I18N-ALLOW: regular expression source for a typed time\nconst TYPED_TIME = String.raw`(?:,?\\s+(\\d{1,2}):(\\d{2})(?::(\\d{2}))?(?:\\s*([^\\d\\s].*?))?)?`;\n\n/* An ISO instant carrying its own offset or `Z` — unambiguous on its own, so\n   it never needs a `zone` argument to resolve. */\nconst ISO_WITH_ZONE = /^\\d{4}-\\d{2}-\\d{2}[T ]\\d{2}:\\d{2}(:\\d{2}(\\.\\d+)?)?\\s*(Z|[+-]\\d{2}:?\\d{2})$/;\n\nexport interface ParseDateTimeOptions {\n  /**\n   * The zone a bare (no AM/PM-less midnight, no offset) typed value's\n   * wall-clock reading is IN. Omit to use the reader's own zone — matching\n   * `formatDateTime`'s default, so parsing a value typed against that display\n   * uses the same zone it was rendered in.\n   */\n  zone?: string;\n}\n\n/**\n * A human-typed date-time → the stored ISO instant, or `null`.\n *\n * TWO PATHS, DELIBERATELY NOT ONE. An ISO string carrying its own offset or\n * `Z` is unambiguous — `Date.parse` resolves it correctly regardless of what\n * zone this function is running in, and is used directly. Everything else is\n * a WALL-CLOCK reading with no zone of its own (`\"09/11/2026, 1:18 PM\"`), and\n * `Date.parse`'s native handling of that shape resolves it against the\n * HOST's zone — which is wrong the instant `options.zone` names a different\n * one, e.g. a server in UTC parsing a value entered by a reader in\n * `America/New_York`. So the wall-clock path is hand-parsed into fields and\n * handed to `plainDateTimeToInstant`, which resolves it against the\n * REQUESTED zone rather than whatever zone the code happens to be running in.\n *\n * A wall-clock reading that lands in a DST gap or overlap does not throw —\n * `plainDateTimeToInstant`'s default (`\"compatible\"`) disambiguation applies,\n * matching every other date library's default and `Temporal`'s own. See\n * `time-dst.test.ts` for what that resolves to at a transition.\n */\nexport function parseDateTime(input: string, locale: string, options: ParseDateTimeOptions = {}): string | null {\n  const trimmed = normalizeDigits(input, locale).trim();\n  if (trimmed === \"\") return null;\n\n  if (ISO_WITH_ZONE.test(trimmed)) {\n    const ms = toInstant(trimmed);\n    return ms === null ? null : new Date(ms).toISOString();\n  }\n\n  const { order, source } = datePattern(locale);\n  const m = new RegExp(`^${source}${TYPED_TIME}$`).exec(trimmed);\n  if (!m) return null;\n\n  const { year, month, day } = dateFields(order, m);\n  if (month < 1 || month > 12) return null;\n  if (day < 1 || day > daysInMonth(year, month)) return null;\n\n  let hour = 0;\n  let minute = 0;\n  let second = 0;\n  if (m[4] !== undefined) {\n    const rawHour = Number(m[4]);\n    minute = Number(m[5]);\n    second = m[6] !== undefined ? Number(m[6]) : 0;\n    if (minute > 59 || second > 59) return null;\n    const clock = clockPattern(locale);\n    if (clock.twelveHour) {\n      const period = m[7] === undefined ? undefined : normalizePeriod(m[7]);\n      if (rawHour < 1 || rawHour > 12 || (period !== clock.am && period !== clock.pm)) return null;\n      hour = period === clock.am ? (rawHour === 12 ? 0 : rawHour) : rawHour === 12 ? 12 : rawHour + 12;\n    } else {\n      if (rawHour > 23 || m[7] !== undefined) return null;\n      hour = rawHour;\n    }\n  }\n\n  const wall: PlainDateTime = { year, month, day, hour, minute, second, millisecond: 0 };\n  const zone = options.zone ?? localZone();\n  return new Date(plainDateTimeToInstant(zone, wall)).toISOString();\n}\n"],"names":["localZone","toInstant","value","normalized","ms","formatDateTime","locale","options","ABSENT","instant","zone","wall","instantToPlainDateTime","plainSpaces","dateFormat","TIME_OPTIONS","wallDate","TYPED_TIME","ISO_WITH_ZONE","parseDateTime","input","trimmed","normalizeDigits","order","source","datePattern","m","year","month","day","dateFields","daysInMonth","hour","minute","second","rawHour","clock","clockPattern","period","normalizePeriod","plainDateTimeToInstant"],"mappings":";;;;;AAoDA,SAASA,IAAoB;AAC3B,SAAO,KAAK,iBAAiB,gBAAA,EAAkB;AACjD;AAUA,SAASC,EAAUC,GAAuC;AACxD,MAAI,OAAOA,KAAU,SAAU,QAAO,OAAO,SAASA,CAAK,IAAIA,IAAQ;AACvE,QAAMC,IAAaD,EAAM,QAAQ,gBAAgB,IAAI,GAC/CE,IAAK,KAAK,MAAMD,CAAU;AAChC,SAAO,OAAO,MAAMC,CAAE,IAAI,OAAOA;AACnC;AAqBO,SAASC,EACdH,GACAI,GACAC,IAAiC,CAAA,GACzB;AACR,MAAIL,KAAS,QAAQA,MAAU,GAAI,QAAOM;AAC1C,QAAMC,IAAUR,EAAUC,CAAK;AAC/B,MAAIO,MAAY,KAAM,QAAO,OAAOP,CAAK;AAEzC,QAAMQ,IAAOH,EAAQ,QAAQP,EAAA,GACvBW,IAAOC,EAAuBF,GAAMD,CAAO;AACjD,SAAOI,EAAYC,EAAWR,GAAQS,CAAY,EAAE,OAAOC,EAASL,CAAI,CAAC,CAAC;AAC5E;AAKA,MAAMM,IAAa,OAAO,mEAIpBC,IAAgB;AA+Bf,SAASC,EAAcC,GAAed,GAAgBC,IAAgC,CAAA,GAAmB;AAC9G,QAAMc,IAAUC,EAAgBF,GAAOd,CAAM,EAAE,KAAA;AAC/C,MAAIe,MAAY,GAAI,QAAO;AAE3B,MAAIH,EAAc,KAAKG,CAAO,GAAG;AAC/B,UAAMjB,IAAKH,EAAUoB,CAAO;AAC5B,WAAOjB,MAAO,OAAO,OAAO,IAAI,KAAKA,CAAE,EAAE,YAAA;AAAA,EAC3C;AAEA,QAAM,EAAE,OAAAmB,GAAO,QAAAC,MAAWC,EAAYnB,CAAM,GACtCoB,IAAI,IAAI,OAAO,IAAIF,CAAM,GAAGP,CAAU,GAAG,EAAE,KAAKI,CAAO;AAC7D,MAAI,CAACK,EAAG,QAAO;AAEf,QAAM,EAAE,MAAAC,GAAM,OAAAC,GAAO,KAAAC,MAAQC,EAAWP,GAAOG,CAAC;AAEhD,MADIE,IAAQ,KAAKA,IAAQ,MACrBC,IAAM,KAAKA,IAAME,EAAYJ,GAAMC,CAAK,EAAG,QAAO;AAEtD,MAAII,IAAO,GACPC,IAAS,GACTC,IAAS;AACb,MAAIR,EAAE,CAAC,MAAM,QAAW;AACtB,UAAMS,IAAU,OAAOT,EAAE,CAAC,CAAC;AAG3B,QAFAO,IAAS,OAAOP,EAAE,CAAC,CAAC,GACpBQ,IAASR,EAAE,CAAC,MAAM,SAAY,OAAOA,EAAE,CAAC,CAAC,IAAI,GACzCO,IAAS,MAAMC,IAAS,GAAI,QAAO;AACvC,UAAME,IAAQC,EAAa/B,CAAM;AACjC,QAAI8B,EAAM,YAAY;AACpB,YAAME,IAASZ,EAAE,CAAC,MAAM,SAAY,SAAYa,EAAgBb,EAAE,CAAC,CAAC;AACpE,UAAIS,IAAU,KAAKA,IAAU,MAAOG,MAAWF,EAAM,MAAME,MAAWF,EAAM,GAAK,QAAO;AACxF,MAAAJ,IAAOM,MAAWF,EAAM,KAAMD,MAAY,KAAK,IAAIA,IAAWA,MAAY,KAAK,KAAKA,IAAU;AAAA,IAChG,OAAO;AACL,UAAIA,IAAU,MAAMT,EAAE,CAAC,MAAM,OAAW,QAAO;AAC/C,MAAAM,IAAOG;AAAA,IACT;AAAA,EACF;AAEA,QAAMxB,IAAsB,EAAE,MAAAgB,GAAM,OAAAC,GAAO,KAAAC,GAAK,MAAAG,GAAM,QAAAC,GAAQ,QAAAC,GAAQ,aAAa,EAAA,GAC7ExB,IAAOH,EAAQ,QAAQP,EAAA;AAC7B,SAAO,IAAI,KAAKwC,EAAuB9B,GAAMC,CAAI,CAAC,EAAE,YAAA;AACtD;"}

package/dist/lib/values/locale-date.js

@@ -0,0 +1,60 @@
+import { localeDigits as g, dateFormat as d } from "../intl-cache.js";
+import { wallAsUtcMs as h } from "../time/zone.js";
+const f = { calendar: "gregory", timeZone: "UTC", year: "numeric", month: "2-digit", day: "2-digit" }, S = { ...f, hour: "numeric", minute: "2-digit" };
+function v(t) {
+  return new Date(h(t));
+}
+function I(t) {
+  return t.replace(/[\u202f\u00a0]/g, " ");
+}
+const m = /* @__PURE__ */ new Map(), y = /[‎‏؜]/g, w = (t) => t.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+function M(t, e) {
+  const r = g(e);
+  let n = t.replace(y, "");
+  return r.forEach((o, a) => {
+    o !== String(a) && (n = n.split(o).join(String(a)));
+  }), n;
+}
+function x(t) {
+  let e = m.get(t);
+  if (!e) {
+    const r = d(t, f).formatToParts(/* @__PURE__ */ new Date(0)), n = r.reduce((i, c, s) => c.type === "year" || c.type === "month" || c.type === "day" ? s : i, -1), o = [], a = r.map((i, c) => {
+      if (i.type === "year" || i.type === "month" || i.type === "day")
+        return o.push(i.type), i.type === "year" ? "(\\d{4})" : "(\\d{1,2})";
+      const s = i.value.replace(y, ""), u = `\\s*${w(s.trim())}\\s*`;
+      return c > n ? `(?:${u})?` : u;
+    }).join("");
+    e = { order: o, source: a }, m.set(t, e);
+  }
+  return e;
+}
+function C(t, e, r = 1) {
+  const n = { year: 0, month: 0, day: 0 };
+  return t.forEach((o, a) => {
+    n[o] = Number(e[r + a]);
+  }), n;
+}
+const l = /* @__PURE__ */ new Map();
+function p(t) {
+  return t.toLowerCase().replace(/[\s.\u202f\u00a0]/g, "");
+}
+function E(t) {
+  let e = l.get(t);
+  if (!e) {
+    const r = (o) => d(t, { timeZone: "UTC", hour: "numeric" }).formatToParts(new Date(Date.UTC(2e3, 0, 1, o))).find((a) => a.type === "dayPeriod"), n = r(0);
+    e = { twelveHour: n !== void 0, am: n ? p(n.value) : "", pm: n ? p(r(12).value) : "" }, l.set(t, e);
+  }
+  return e;
+}
+export {
+  f as DATE_OPTIONS,
+  S as TIME_OPTIONS,
+  E as clockPattern,
+  C as dateFields,
+  x as datePattern,
+  M as normalizeDigits,
+  p as normalizePeriod,
+  I as plainSpaces,
+  v as wallDate
+};
+//# sourceMappingURL=locale-date.js.map

package/dist/lib/values/locale-date.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-date.js","sources":["../../../src/lib/values/locale-date.ts"],"sourcesContent":["/* ----------------------------------------------------------------------------\n   DX-4740 — HOW A LOCALE WRITES A CALENDAR DATE AND A CLOCK TIME, LEARNED FROM\n   `Intl` ONCE PER LOCALE SO THE FORMATTERS AND THE PARSERS CANNOT DISAGREE.\n\n   `formatDate` / `formatDateTime` print through `Intl.DateTimeFormat(locale)`;\n   `parseDate` / `parseDateTime` read back exactly that shape. Both derive the\n   field order, the separator and the day-period words from the same probe here,\n   so a value displayed in a locale round-trips through its own parser.\n   -------------------------------------------------------------------------- */\n\nimport { dateFormat, localeDigits } from \"../intl-cache\";\nimport { wallAsUtcMs } from \"../time/zone\";\nimport type { PlainDateTime } from \"../time/types\";\n\ntype DateField = \"year\" | \"month\" | \"day\";\n\n/* `calendar: \"gregory\"`: stored dates are Gregorian, but some locales default to another calendar (fa-IR prints Jalali), which would show a different date than the one stored. */\n// I18N-ALLOW: Intl.DateTimeFormat option values\nexport const DATE_OPTIONS: Intl.DateTimeFormatOptions = { calendar: \"gregory\", timeZone: \"UTC\", year: \"numeric\", month: \"2-digit\", day: \"2-digit\" };\nexport const TIME_OPTIONS: Intl.DateTimeFormatOptions = { ...DATE_OPTIONS, hour: \"numeric\", minute: \"2-digit\" };\n\n/** A wall-clock reading as a `Date` whose UTC fields ARE the reading, so `timeZone: \"UTC\"` prints it untouched. */\nexport function wallDate(wall: PlainDateTime): Date {\n  return new Date(wallAsUtcMs(wall));\n}\n\n/* ICU separates the time from a day period with U+202F in recent versions and a plain\n   space in older ones; one space keeps the output identical across both. */\nexport function plainSpaces(text: string): string {\n  return text.replace(/[\\u202f\\u00a0]/g, \" \");\n}\n\nexport interface DatePattern {\n  order: DateField[];\n  /** Regex source matching one numeric date in the locale's order and separator. */\n  source: string;\n}\n\nconst patterns = new Map<string, DatePattern>();\n\nconst BIDI_MARKS = /[‎‏؜]/g;\nconst escapeRegex = (text: string) => text.replace(/[.*+?^${}()|[\\]\\\\/]/g, \"\\\\$&\");\n\n/**\n * The locale's own digits and bidi marks → plain Latin digits and nothing, so a number typed in\n * Eastern Arabic or Persian digits (ar-EG, fa-IR) reads the same as one typed in Latin.\n */\nexport function normalizeDigits(text: string, locale: string): string {\n  const digits = localeDigits(locale);\n  let out = text.replace(BIDI_MARKS, \"\");\n  digits.forEach((d, i) => {\n    if (d !== String(i)) out = out.split(d).join(String(i));\n  });\n  return out;\n}\n\nexport function datePattern(locale: string): DatePattern {\n  let pattern = patterns.get(locale);\n  if (!pattern) {\n    const parts = dateFormat(locale, DATE_OPTIONS).formatToParts(new Date(0));\n    const lastField = parts.reduce((last, p, i) => (p.type === \"year\" || p.type === \"month\" || p.type === \"day\" ? i : last), -1);\n    const order: DateField[] = [];\n    const source = parts\n      .map((part, i) => {\n        if (part.type === \"year\" || part.type === \"month\" || part.type === \"day\") {\n          order.push(part.type);\n          return part.type === \"year\" ? \"(\\\\d{4})\" : \"(\\\\d{1,2})\";\n        }\n        const literal = part.value.replace(BIDI_MARKS, \"\");\n        /* Whitespace around a literal is optional, so \"2026.09.11\" reads as \"2026. 09. 11.\"; a literal\n           AFTER the last field (\"11.09.2026 г.\", the final \".\" of ko-KR) may be left off. */\n        const text = escapeRegex(literal.trim());\n        const inner = `\\\\s*${text}\\\\s*`;\n        return i > lastField ? `(?:${inner})?` : inner;\n      })\n      .join(\"\");\n    pattern = { order, source };\n    patterns.set(locale, pattern);\n  }\n  return pattern;\n}\n\n/** The three captured numbers of a `datePattern` match, by field. */\nexport function dateFields(order: DateField[], match: RegExpExecArray, offset = 1): { year: number; month: number; day: number } {\n  const out = { year: 0, month: 0, day: 0 };\n  order.forEach((field, i) => {\n    out[field] = Number(match[offset + i]);\n  });\n  return out;\n}\n\nexport interface ClockPattern {\n  /** True when the locale shows 1-12 with a day period (\"AM\"/\"PM\"), false for a 0-23 clock. */\n  twelveHour: boolean;\n  /** Lower-case, space-free forms of the locale's morning and afternoon words (12-hour clocks only). */\n  am: string;\n  pm: string;\n}\n\nconst clocks = new Map<string, ClockPattern>();\n\nexport function normalizePeriod(text: string): string {\n  return text.toLowerCase().replace(/[\\s.\\u202f\\u00a0]/g, \"\");\n}\n\nexport function clockPattern(locale: string): ClockPattern {\n  let clock = clocks.get(locale);\n  if (!clock) {\n    const probe = (hour: number) =>\n      dateFormat(locale, { timeZone: \"UTC\", hour: \"numeric\" }).formatToParts(new Date(Date.UTC(2000, 0, 1, hour))).find((p) => p.type === \"dayPeriod\");\n    const am = probe(0);\n    clock = { twelveHour: am !== undefined, am: am ? normalizePeriod(am.value) : \"\", pm: am ? normalizePeriod(probe(12)!.value) : \"\" };\n    clocks.set(locale, clock);\n  }\n  return clock;\n}\n"],"names":["DATE_OPTIONS","TIME_OPTIONS","wallDate","wall","wallAsUtcMs","plainSpaces","text","patterns","BIDI_MARKS","escapeRegex","normalizeDigits","locale","digits","localeDigits","out","d","i","datePattern","pattern","parts","dateFormat","lastField","last","p","order","source","part","literal","inner","dateFields","match","offset","field","clocks","normalizePeriod","clockPattern","clock","probe","hour","am"],"mappings":";;AAkBO,MAAMA,IAA2C,EAAE,UAAU,WAAW,UAAU,OAAO,MAAM,WAAW,OAAO,WAAW,KAAK,UAAA,GAC3HC,IAA2C,EAAE,GAAGD,GAAc,MAAM,WAAW,QAAQ,UAAA;AAG7F,SAASE,EAASC,GAA2B;AAClD,SAAO,IAAI,KAAKC,EAAYD,CAAI,CAAC;AACnC;AAIO,SAASE,EAAYC,GAAsB;AAChD,SAAOA,EAAK,QAAQ,mBAAmB,GAAG;AAC5C;AAQA,MAAMC,wBAAe,IAAA,GAEfC,IAAa,UACbC,IAAc,CAACH,MAAiBA,EAAK,QAAQ,wBAAwB,MAAM;AAM1E,SAASI,EAAgBJ,GAAcK,GAAwB;AACpE,QAAMC,IAASC,EAAaF,CAAM;AAClC,MAAIG,IAAMR,EAAK,QAAQE,GAAY,EAAE;AACrC,SAAAI,EAAO,QAAQ,CAACG,GAAGC,MAAM;AACvB,IAAID,MAAM,OAAOC,CAAC,MAAGF,IAAMA,EAAI,MAAMC,CAAC,EAAE,KAAK,OAAOC,CAAC,CAAC;AAAA,EACxD,CAAC,GACMF;AACT;AAEO,SAASG,EAAYN,GAA6B;AACvD,MAAIO,IAAUX,EAAS,IAAII,CAAM;AACjC,MAAI,CAACO,GAAS;AACZ,UAAMC,IAAQC,EAAWT,GAAQX,CAAY,EAAE,cAAc,oBAAI,KAAK,CAAC,CAAC,GAClEqB,IAAYF,EAAM,OAAO,CAACG,GAAMC,GAAGP,MAAOO,EAAE,SAAS,UAAUA,EAAE,SAAS,WAAWA,EAAE,SAAS,QAAQP,IAAIM,GAAO,EAAE,GACrHE,IAAqB,CAAA,GACrBC,IAASN,EACZ,IAAI,CAACO,GAAMV,MAAM;AAChB,UAAIU,EAAK,SAAS,UAAUA,EAAK,SAAS,WAAWA,EAAK,SAAS;AACjE,eAAAF,EAAM,KAAKE,EAAK,IAAI,GACbA,EAAK,SAAS,SAAS,aAAa;AAE7C,YAAMC,IAAUD,EAAK,MAAM,QAAQlB,GAAY,EAAE,GAI3CoB,IAAQ,OADDnB,EAAYkB,EAAQ,KAAA,CAAM,CACd;AACzB,aAAOX,IAAIK,IAAY,MAAMO,CAAK,OAAOA;AAAA,IAC3C,CAAC,EACA,KAAK,EAAE;AACV,IAAAV,IAAU,EAAE,OAAAM,GAAO,QAAAC,EAAA,GACnBlB,EAAS,IAAII,GAAQO,CAAO;AAAA,EAC9B;AACA,SAAOA;AACT;AAGO,SAASW,EAAWL,GAAoBM,GAAwBC,IAAS,GAAiD;AAC/H,QAAMjB,IAAM,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,EAAA;AACtC,SAAAU,EAAM,QAAQ,CAACQ,GAAOhB,MAAM;AAC1B,IAAAF,EAAIkB,CAAK,IAAI,OAAOF,EAAMC,IAASf,CAAC,CAAC;AAAA,EACvC,CAAC,GACMF;AACT;AAUA,MAAMmB,wBAAa,IAAA;AAEZ,SAASC,EAAgB5B,GAAsB;AACpD,SAAOA,EAAK,YAAA,EAAc,QAAQ,sBAAsB,EAAE;AAC5D;AAEO,SAAS6B,EAAaxB,GAA8B;AACzD,MAAIyB,IAAQH,EAAO,IAAItB,CAAM;AAC7B,MAAI,CAACyB,GAAO;AACV,UAAMC,IAAQ,CAACC,MACblB,EAAWT,GAAQ,EAAE,UAAU,OAAO,MAAM,WAAW,EAAE,cAAc,IAAI,KAAK,KAAK,IAAI,KAAM,GAAG,GAAG2B,CAAI,CAAC,CAAC,EAAE,KAAK,CAACf,MAAMA,EAAE,SAAS,WAAW,GAC3IgB,IAAKF,EAAM,CAAC;AAClB,IAAAD,IAAQ,EAAE,YAAYG,MAAO,QAAW,IAAIA,IAAKL,EAAgBK,EAAG,KAAK,IAAI,IAAI,IAAIA,IAAKL,EAAgBG,EAAM,EAAE,EAAG,KAAK,IAAI,GAAA,GAC9HJ,EAAO,IAAItB,GAAQyB,CAAK;AAAA,EAC1B;AACA,SAAOA;AACT;"}

package/dist/lib/values/number.js

@@ -0,0 +1,16 @@
+import { ABSENT as n } from "./absent.js";
+import { numberFormat as o, parseLocalizedNumber as e } from "../intl-cache.js";
+function c(i, t, r = {}) {
+  if (i == null || !Number.isFinite(i)) return n;
+  const { decimals: m } = r;
+  return o(t, m === void 0 ? { maximumFractionDigits: 6 } : { minimumFractionDigits: m, maximumFractionDigits: m }).format(i);
+}
+function f(i, t) {
+  const r = i.trim();
+  return r === "" ? null : e(r, t);
+}
+export {
+  c as formatNumber,
+  f as parseNumber
+};
+//# sourceMappingURL=number.js.map

package/dist/lib/values/number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.js","sources":["../../../src/lib/values/number.ts"],"sourcesContent":["/* ----------------------------------------------------------------------------\n   A GENERIC NUMBER — a float or an integer, with thousands separators.\n\n   NO FIXED PRECISION BY DEFAULT, unlike `formatCurrency`'s always-two-decimals\n   rule. Money has a currency-defined minor unit, so \"how many decimals\" is\n   never a real question; a generic number's field might be a whole count\n   of pages, a percentage to one decimal, or a computed rate to four — there is\n   no single right answer, so the caller states it (`decimals`) and the\n   default preserves whatever precision the value actually carries (up to 6\n   fraction digits, trimmed of trailing zeros) rather than inventing digits\n   that were not there or discarding real ones.\n   -------------------------------------------------------------------------- */\n\nimport { ABSENT } from \"./absent\";\nimport { numberFormat, parseLocalizedNumber } from \"../intl-cache\";\n\nexport interface FormatNumberOptions {\n  /**\n   * Fixed fraction digits, e.g. `1` for a percentage rendered as `\"42.0\"`.\n   * Omit to show the value's own precision, up to 6 fraction digits, with no\n   * trailing zeros invented.\n   */\n  decimals?: number;\n}\n\n/**\n * `1234.5` → `\"1,234.5\"` in `en-US`, `\"1.234,5\"` in `de-DE`. `null` / `undefined` → `\"—\"`.\n *\n * `NaN` / `Infinity` render as the em dash too, for the same reason\n * `formatCurrency` groups them with absence rather than showing them back:\n * the caller holds a `number`, not a string a person typed, so there is no\n * original text to preserve.\n */\nexport function formatNumber(value: number | null | undefined, locale: string, options: FormatNumberOptions = {}): string {\n  if (value == null || !Number.isFinite(value)) return ABSENT;\n  const { decimals } = options;\n  const intlOptions: Intl.NumberFormatOptions =\n    decimals === undefined\n      ? { maximumFractionDigits: 6 }\n      : { minimumFractionDigits: decimals, maximumFractionDigits: decimals };\n  return numberFormat(locale, intlOptions).format(value);\n}\n\n/**\n * A human-typed number → a `number`, or `null`.\n *\n * Reads `locale`'s own convention — `\"1,234.5\"` in `en-US` and `\"1.234,5\"` in\n * `de-DE` are both `1234.5` — and accepts a leading `-` for a negative value. Rejects, rather than\n * silently truncating, anything `parseFloat` would otherwise accept a PREFIX\n * of — `\"12abc\"` is not twelve, it is a typo, and `parseFloat` alone would\n * return `12` and hide that.\n */\nexport function parseNumber(input: string, locale: string): number | null {\n  const trimmed = input.trim();\n  if (trimmed === \"\") return null;\n  return parseLocalizedNumber(trimmed, locale);\n}\n"],"names":["formatNumber","value","locale","options","ABSENT","decimals","numberFormat","parseNumber","input","trimmed","parseLocalizedNumber"],"mappings":";;AAiCO,SAASA,EAAaC,GAAkCC,GAAgBC,IAA+B,CAAA,GAAY;AACxH,MAAIF,KAAS,QAAQ,CAAC,OAAO,SAASA,CAAK,EAAG,QAAOG;AACrD,QAAM,EAAE,UAAAC,MAAaF;AAKrB,SAAOG,EAAaJ,GAHlBG,MAAa,SACT,EAAE,uBAAuB,EAAA,IACzB,EAAE,uBAAuBA,GAAU,uBAAuBA,EAAA,CACzB,EAAE,OAAOJ,CAAK;AACvD;AAWO,SAASM,EAAYC,GAAeN,GAA+B;AACxE,QAAMO,IAAUD,EAAM,KAAA;AACtB,SAAIC,MAAY,KAAW,OACpBC,EAAqBD,GAASP,CAAM;AAC7C;"}