@vamos-ui/react 0.0.0-stage → 0.2.0

package/dist/lib/variants.d.ts

@@ -0,0 +1,131 @@
+import type * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+/**
+ * The shared box look of every text-entry or trigger control: Input, Textarea, Select trigger,
+ * Combobox, date/time picker triggers, Tag input. Works both when the box itself is focusable
+ * (a `<button>` trigger) and when it wraps a focusable child (Input group): focus, invalid and
+ * disabled styles react to the element itself **or** a descendant.
+ *
+ * Heights follow the density axis through `--control-h`: `sm` = control-h − 0.5rem, `md` = control-h,
+ * `lg` = control-h + 0.5rem. Set `data-readonly` on the box for the read-only look.
+ *
+ * ```tsx
+ * <button className={controlVariants({ size: "sm" })}>Status</button>
+ * ```
+ */
+export declare const controlVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    variant?: "nav" | "default" | "ghost" | null | undefined;
+    pill?: boolean | null | undefined;
+    multiline?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ControlVariantProps = VariantProps<typeof controlVariants>;
+/**
+ * One look for every list item: Select / Combobox options, pickers, Dropdown and Context Menu
+ * items, Command items, sidebar flyout links. Highlight works with Radix (`data-highlighted`),
+ * cmdk (`data-selected=true`) and plain `aria-selected`; checked items use `data-state=checked`.
+ *
+ * Compose with `itemSlots` for the inner parts.
+ *
+ * ```tsx
+ * <DropdownMenu.Item className={itemVariants({ tone: "danger" })}>
+ *   <Trash2 className={itemSlots.icon} /> Delete <span className={itemSlots.shortcut}>⌘⌫</span>
+ * </DropdownMenu.Item>
+ * ```
+ */
+export declare const itemVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+    tone?: "nav" | "danger" | "default" | null | undefined;
+    inset?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ItemVariantProps = VariantProps<typeof itemVariants>;
+/** Class names for the inner parts of an item. */
+export declare const itemSlots: {
+    /** Leading icon. */
+    readonly icon: "size-4 shrink-0 text-fg-muted";
+    /** Check / radio indicator in the inset gutter. */
+    readonly indicator: "absolute start-2 flex size-4 items-center justify-center text-fg";
+    /** Main label (truncates). */
+    readonly label: "min-w-0 flex-1 truncate";
+    /** Secondary line under the label. */
+    readonly description: "block text-xs font-normal text-fg-subtle";
+    /** Shortcut / trailing meta at the end. */
+    readonly shortcut: "ms-auto ps-4 font-mono text-[11px] tracking-wide text-fg-subtle";
+    /** Group heading. */
+    readonly groupLabel: "px-2 pt-2 pb-1 text-[11px] font-medium tracking-[0.04em] text-fg-subtle";
+    /** Divider between groups. */
+    readonly separator: "-mx-1 my-1 h-px bg-line";
+};
+interface MenuEntryBase {
+    /** Stable key. */
+    id: string;
+    disabled?: boolean;
+    /** Hidden unless `can(permission)` is true (see `useCan`). Hiding is not security. */
+    permission?: string;
+}
+/** A selectable entry. Exactly one of `onSelect` / `href` is typical. */
+export interface MenuItemEntry extends MenuEntryBase {
+    type?: "item";
+    label: React.ReactNode;
+    /** Plain text for typeahead and search when `label` isn't a string. */
+    textValue?: string;
+    icon?: React.ReactNode;
+    description?: React.ReactNode;
+    /** Shortcut string, e.g. `"mod+shift+p"` (rendered with Kbd / formatShortcut). */
+    shortcut?: string;
+    /** Extra search terms (Command). */
+    keywords?: string[];
+    tone?: "default" | "danger";
+    href?: string;
+    onSelect?: () => void;
+    /** Trailing count or badge. */
+    badge?: React.ReactNode;
+}
+export interface MenuCheckboxEntry extends MenuEntryBase {
+    type: "checkbox";
+    label: React.ReactNode;
+    textValue?: string;
+    checked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+    shortcut?: string;
+}
+export interface MenuRadioEntry extends MenuEntryBase {
+    type: "radio";
+    label?: React.ReactNode;
+    value: string;
+    onValueChange: (value: string) => void;
+    options: Array<{
+        value: string;
+        label: React.ReactNode;
+        textValue?: string;
+        disabled?: boolean;
+    }>;
+}
+export interface MenuSubmenuEntry extends MenuEntryBase {
+    type: "submenu";
+    label: React.ReactNode;
+    textValue?: string;
+    icon?: React.ReactNode;
+    items: MenuEntry[];
+}
+export interface MenuGroupEntry {
+    type: "group";
+    id: string;
+    label?: React.ReactNode;
+    items: MenuEntry[];
+}
+export interface MenuSeparatorEntry {
+    type: "separator";
+    id?: string;
+}
+export interface MenuLabelEntry {
+    type: "label";
+    id?: string;
+    label: React.ReactNode;
+}
+/**
+ * Data-driven menu model shared by Dropdown Menu, Context Menu, Command, Select/Combobox option
+ * lists and sidebar flyouts.
+ */
+export type MenuEntry = MenuItemEntry | MenuCheckboxEntry | MenuRadioEntry | MenuSubmenuEntry | MenuGroupEntry | MenuSeparatorEntry | MenuLabelEntry;
+export {};

package/dist/lib/variants.js

@@ -0,0 +1,109 @@
+import { cva } from "class-variance-authority";
+/**
+ * The shared box look of every text-entry or trigger control: Input, Textarea, Select trigger,
+ * Combobox, date/time picker triggers, Tag input. Works both when the box itself is focusable
+ * (a `<button>` trigger) and when it wraps a focusable child (Input group): focus, invalid and
+ * disabled styles react to the element itself **or** a descendant.
+ *
+ * Heights follow the density axis through `--control-h`: `sm` = control-h − 0.5rem, `md` = control-h,
+ * `lg` = control-h + 0.5rem. Set `data-readonly` on the box for the read-only look.
+ *
+ * ```tsx
+ * <button className={controlVariants({ size: "sm" })}>Status</button>
+ * ```
+ */
+export const controlVariants = cva([
+    "relative flex w-full min-w-0 items-center rounded-ui border text-fg",
+    "transition-[border-color,box-shadow,background-color] duration-150",
+    // focus on self (trigger) or on a child (input group)
+    "focus-visible:outline-none focus-visible:border-ring focus-visible:shadow-[0_0_0_3px_var(--accent-soft)]",
+    "has-[:focus-visible]:border-ring has-[:focus-visible]:shadow-[0_0_0_3px_var(--accent-soft)]",
+    // invalid
+    "aria-invalid:border-danger has-[[aria-invalid=true]]:border-danger",
+    "aria-invalid:focus-visible:shadow-[0_0_0_3px_color-mix(in_srgb,var(--danger)_18%,transparent)]",
+    "has-[[aria-invalid=true]:focus-visible]:shadow-[0_0_0_3px_color-mix(in_srgb,var(--danger)_18%,transparent)]",
+    // disabled
+    // Only a disabled field or trigger dims the wrapper; a disabled helper button inside (a stepper at
+    // its limit, a clear button) must not make the whole control look disabled.
+    "disabled:cursor-not-allowed disabled:opacity-50",
+    "has-[input:disabled,select:disabled,textarea:disabled,[aria-haspopup]:disabled,[role=combobox]:disabled]:cursor-not-allowed",
+    "has-[input:disabled,select:disabled,textarea:disabled,[aria-haspopup]:disabled,[role=combobox]:disabled]:opacity-50",
+    "aria-disabled:cursor-not-allowed aria-disabled:opacity-50",
+    // read-only
+    "data-readonly:border-dashed data-readonly:bg-transparent data-readonly:shadow-none",
+], {
+    variants: {
+        size: {
+            sm: "h-[calc(var(--control-h)-0.5rem)] gap-1.5 px-2.5 text-[13px] [&_svg]:size-3.5",
+            md: "h-(--control-h) gap-2 px-3 text-sm [&_svg]:size-4",
+            lg: "h-[calc(var(--control-h)+0.5rem)] gap-2.5 px-3.5 text-[15px] [&_svg]:size-[18px]",
+        },
+        variant: {
+            /** Field background with a hairline border. */
+            default: "border-field-border bg-field hover:border-field-border-hover",
+            /** Borderless until hover/focus — inline cell editing, toolbar search. */
+            ghost: "border-transparent bg-transparent hover:bg-hover",
+            /** Inside the dark sidebar (`surface-nav`). */
+            nav: "border-nav-line bg-nav-hover text-nav-fg-strong hover:border-[color-mix(in_srgb,var(--nav-fg)_30%,transparent)]",
+        },
+        pill: { true: "rounded-full" },
+        /** Auto height for multi-line content (Textarea, Tag input). */
+        multiline: { true: "h-auto items-start py-2" },
+    },
+    defaultVariants: { size: "md", variant: "default" },
+});
+/**
+ * One look for every list item: Select / Combobox options, pickers, Dropdown and Context Menu
+ * items, Command items, sidebar flyout links. Highlight works with Radix (`data-highlighted`),
+ * cmdk (`data-selected=true`) and plain `aria-selected`; checked items use `data-state=checked`.
+ *
+ * Compose with `itemSlots` for the inner parts.
+ *
+ * ```tsx
+ * <DropdownMenu.Item className={itemVariants({ tone: "danger" })}>
+ *   <Trash2 className={itemSlots.icon} /> Delete <span className={itemSlots.shortcut}>⌘⌫</span>
+ * </DropdownMenu.Item>
+ * ```
+ */
+export const itemVariants = cva([
+    "relative flex w-full cursor-default select-none items-center gap-2 rounded-ui-sm text-start text-fg outline-none",
+    "transition-colors duration-100",
+    "data-highlighted:bg-hover data-[selected=true]:bg-hover aria-selected:bg-hover focus-visible:bg-hover",
+    "data-[state=checked]:font-medium",
+    "[&[data-disabled]:not([data-disabled=false])]:pointer-events-none [&[data-disabled]:not([data-disabled=false])]:opacity-45",
+    "aria-disabled:pointer-events-none aria-disabled:opacity-45",
+    "[&_svg]:size-4 [&_svg]:shrink-0",
+], {
+    variants: {
+        size: {
+            sm: "min-h-7 px-2 py-1 text-[13px]",
+            md: "min-h-8 px-2 py-1.5 text-sm",
+        },
+        tone: {
+            default: "[&_svg]:text-fg-muted",
+            danger: "text-danger [&_svg]:text-danger data-highlighted:bg-[color-mix(in_srgb,var(--danger)_10%,transparent)] data-[selected=true]:bg-[color-mix(in_srgb,var(--danger)_10%,transparent)]",
+            /** Inside the dark sidebar / nav popovers. */
+            nav: "text-nav-fg data-highlighted:bg-nav-hover data-highlighted:text-nav-fg-strong data-[selected=true]:bg-nav-hover aria-selected:bg-nav-hover focus-visible:bg-nav-hover",
+        },
+        /** Reserve the start gutter for a check/radio indicator. */
+        inset: { true: "ps-8" },
+    },
+    defaultVariants: { size: "md", tone: "default" },
+});
+/** Class names for the inner parts of an item. */
+export const itemSlots = {
+    /** Leading icon. */
+    icon: "size-4 shrink-0 text-fg-muted",
+    /** Check / radio indicator in the inset gutter. */
+    indicator: "absolute start-2 flex size-4 items-center justify-center text-fg",
+    /** Main label (truncates). */
+    label: "min-w-0 flex-1 truncate",
+    /** Secondary line under the label. */
+    description: "block text-xs font-normal text-fg-subtle",
+    /** Shortcut / trailing meta at the end. */
+    shortcut: "ms-auto ps-4 font-mono text-[11px] tracking-wide text-fg-subtle",
+    /** Group heading. */
+    groupLabel: "px-2 pt-2 pb-1 text-[11px] font-medium tracking-[0.04em] text-fg-subtle",
+    /** Divider between groups. */
+    separator: "-mx-1 my-1 h-px bg-line",
+};

package/dist/locale-data/core/date.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `YYYY-MM-DD` arithmetic on the proleptic Gregorian calendar, done in UTC so the host time zone
+ * never shifts a day. React-free.
+ */
+import type { IsoDate } from "./types.js";
+/** True for a well-formed, existing calendar date ("2026-02-30" is false). */
+export declare function isIsoDate(value: unknown): value is IsoDate;
+export declare function daysInMonth(year: number, month: number): number;
+/** Days since 1970-01-01 for a `YYYY-MM-DD` string. Throws on malformed input. */
+export declare function toDayNumber(date: IsoDate): number;
+/** Inverse of `toDayNumber`. */
+export declare function fromDayNumber(n: number): IsoDate;
+export declare function addDays(date: IsoDate, n: number): IsoDate;
+/** Whole days from `a` to `b` (`b − a`). */
+export declare function diffDays(a: IsoDate, b: IsoDate): number;
+/** ISO weekday: 1 = Monday … 7 = Sunday (the numbering of `Intl.Locale#getWeekInfo`). */
+export declare function isoWeekday(date: IsoDate): number;
+/** The local calendar date of a `Date` (or now), without going through UTC. */
+export declare function toIsoDate(d?: Date): IsoDate;
+/** `YYYY-MM-DD` of an instant in an IANA time zone. */
+export declare function isoDateInZone(instant: Date | number, timeZone: string): IsoDate;
+export declare function compareIsoDate(a: IsoDate, b: IsoDate): number;
+/** Every date in `[start, end]`, inclusive. */
+export declare function eachDay(start: IsoDate, end: IsoDate): IsoDate[];

package/dist/locale-data/core/date.js

@@ -0,0 +1,68 @@
+const ISO_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const DAY_MS = 86_400_000;
+/** True for a well-formed, existing calendar date ("2026-02-30" is false). */
+export function isIsoDate(value) {
+    if (typeof value !== "string")
+        return false;
+    const m = ISO_RE.exec(value);
+    if (!m)
+        return false;
+    const y = Number(m[1]);
+    const mo = Number(m[2]);
+    const d = Number(m[3]);
+    if (mo < 1 || mo > 12 || d < 1)
+        return false;
+    return d <= daysInMonth(y, mo);
+}
+export function daysInMonth(year, month) {
+    return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+/** Days since 1970-01-01 for a `YYYY-MM-DD` string. Throws on malformed input. */
+export function toDayNumber(date) {
+    const m = ISO_RE.exec(date);
+    if (!m)
+        throw new RangeError(`Expected YYYY-MM-DD, got "${date}"`);
+    return Math.round(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3])) / DAY_MS);
+}
+/** Inverse of `toDayNumber`. */
+export function fromDayNumber(n) {
+    const d = new Date(n * DAY_MS);
+    const y = d.getUTCFullYear();
+    const yy = y < 0 ? "-" + String(-y).padStart(6, "0") : String(y).padStart(4, "0");
+    return `${yy}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`;
+}
+export function addDays(date, n) {
+    return fromDayNumber(toDayNumber(date) + n);
+}
+/** Whole days from `a` to `b` (`b − a`). */
+export function diffDays(a, b) {
+    return toDayNumber(b) - toDayNumber(a);
+}
+/** ISO weekday: 1 = Monday … 7 = Sunday (the numbering of `Intl.Locale#getWeekInfo`). */
+export function isoWeekday(date) {
+    // 1970-01-01 was a Thursday (4).
+    const n = toDayNumber(date);
+    return ((((n + 3) % 7) + 7) % 7) + 1;
+}
+/** The local calendar date of a `Date` (or now), without going through UTC. */
+export function toIsoDate(d = new Date()) {
+    return `${String(d.getFullYear()).padStart(4, "0")}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+/** `YYYY-MM-DD` of an instant in an IANA time zone. */
+export function isoDateInZone(instant, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(instant);
+    const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
+    return `${get("year")}-${get("month")}-${get("day")}`;
+}
+export function compareIsoDate(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/** Every date in `[start, end]`, inclusive. */
+export function eachDay(start, end) {
+    const a = toDayNumber(start);
+    const b = toDayNumber(end);
+    const out = [];
+    for (let n = a; n <= b; n++)
+        out.push(fromDayNumber(n));
+    return out;
+}

package/dist/locale-data/core/decimal.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Exact decimal-string arithmetic for money (BigInt fixed point). Values in and out are decimal
+ * strings ("1234.50"), never floats. Rounding is half-up, away from zero (commercial rounding).
+ */
+/** Parses a decimal string into integer units at `scale` (half-up when it has more digits). */
+export declare function toUnits(value: string | number, scale: number): bigint;
+/** Formats integer units at `scale` as a decimal string with exactly `scale` places. */
+export declare function fromUnits(units: bigint, scale: number): string;
+/** `a × b ÷ c` with half-up rounding (all bigint units). */
+export declare function mulDivRound(a: bigint, b: bigint, c: bigint): bigint;
+/** Rounds a decimal string half-up to `places` ("2.345" → "2.35", "-2.345" → "-2.35"). */
+export declare function roundHalfUp(value: string | number, places?: number): string;
+export declare function addDecimal(...values: (string | number)[]): string;
+export declare function subtractDecimal(a: string | number, b: string | number): string;
+/** `a × b` rounded half-up to `places`. */
+export declare function multiplyDecimal(a: string | number, b: string | number, places?: number): string;
+/** `a ÷ b` rounded half-up to `places`. */
+export declare function divideDecimal(a: string | number, b: string | number, places?: number): string;
+export declare function compareDecimal(a: string | number, b: string | number): -1 | 0 | 1;

package/dist/locale-data/core/decimal.js

@@ -0,0 +1,79 @@
+/**
+ * Exact decimal-string arithmetic for money (BigInt fixed point). Values in and out are decimal
+ * strings ("1234.50"), never floats. Rounding is half-up, away from zero (commercial rounding).
+ */
+const DEC_RE = /^([+-])?(\d*)(?:\.(\d*))?$/;
+/** Parses a decimal string into integer units at `scale` (half-up when it has more digits). */
+export function toUnits(value, scale) {
+    const s = typeof value === "number" ? numberToString(value) : value.trim().replace(/[\s_]/g, "");
+    const m = DEC_RE.exec(s);
+    if (!m || (m[2] === "" && (m[3] ?? "") === ""))
+        throw new RangeError(`Not a decimal: "${value}"`);
+    const neg = m[1] === "-";
+    const int = m[2] || "0";
+    const frac = m[3] ?? "";
+    let units = BigInt(int + frac.slice(0, scale).padEnd(scale, "0"));
+    const next = frac.charCodeAt(scale);
+    if (frac.length > scale && next >= 53 /* "5" */)
+        units += 1n;
+    return neg ? -units : units;
+}
+/** Formats integer units at `scale` as a decimal string with exactly `scale` places. */
+export function fromUnits(units, scale) {
+    const neg = units < 0n;
+    const abs = (neg ? -units : units).toString().padStart(scale + 1, "0");
+    const out = scale ? `${abs.slice(0, -scale)}.${abs.slice(-scale)}` : abs;
+    return neg && units !== 0n ? `-${out}` : out;
+}
+function numberToString(n) {
+    if (!Number.isFinite(n))
+        throw new RangeError(`Not a finite number: ${n}`);
+    const s = String(n);
+    if (!/e/i.test(s))
+        return s;
+    return n.toFixed(20).replace(/0+$/, "").replace(/\.$/, "");
+}
+/** `a × b ÷ c` with half-up rounding (all bigint units). */
+export function mulDivRound(a, b, c) {
+    if (c === 0n)
+        throw new RangeError("Division by zero");
+    const num = a * b;
+    const neg = num < 0n !== c < 0n;
+    const n = num < 0n ? -num : num;
+    const d = c < 0n ? -c : c;
+    const q = (n * 2n + d) / (d * 2n);
+    return neg ? -q : q;
+}
+/** Rounds a decimal string half-up to `places` ("2.345" → "2.35", "-2.345" → "-2.35"). */
+export function roundHalfUp(value, places = 2) {
+    return fromUnits(toUnits(value, places), places);
+}
+export function addDecimal(...values) {
+    const scale = Math.max(2, ...values.map(scaleOf));
+    return fromUnits(values.reduce((s, v) => s + toUnits(v, scale), 0n), scale);
+}
+export function subtractDecimal(a, b) {
+    const scale = Math.max(2, scaleOf(a), scaleOf(b));
+    return fromUnits(toUnits(a, scale) - toUnits(b, scale), scale);
+}
+/** `a × b` rounded half-up to `places`. */
+export function multiplyDecimal(a, b, places = 2) {
+    const sa = scaleOf(a);
+    const sb = scaleOf(b);
+    return fromUnits(mulDivRound(toUnits(a, sa) * toUnits(b, sb), 10n ** BigInt(places), 10n ** BigInt(sa + sb)), places);
+}
+/** `a ÷ b` rounded half-up to `places`. */
+export function divideDecimal(a, b, places = 2) {
+    const s = Math.max(scaleOf(a), scaleOf(b));
+    return fromUnits(mulDivRound(toUnits(a, s), 10n ** BigInt(places), toUnits(b, s)), places);
+}
+export function compareDecimal(a, b) {
+    const s = Math.max(scaleOf(a), scaleOf(b));
+    const d = toUnits(a, s) - toUnits(b, s);
+    return d < 0n ? -1 : d > 0n ? 1 : 0;
+}
+function scaleOf(v) {
+    const s = typeof v === "number" ? numberToString(v) : v.trim();
+    const i = s.indexOf(".");
+    return i === -1 ? 0 : s.length - i - 1;
+}

package/dist/locale-data/core/holidays.d.ts

@@ -0,0 +1,30 @@
+import type { Holiday, HolidayProvider, HolidayRange, IsoDate } from "./types.js";
+export interface CreateHolidayProviderOptions {
+    id: string;
+    /** A static list, or a function returning the holidays of one year. */
+    holidays: Holiday[] | ((year: number) => Holiday[]);
+    coverage?: {
+        from: IsoDate;
+        to: IsoDate;
+    };
+}
+/**
+ * A `HolidayProvider` from plain data. Region-specific entries are returned only when the
+ * caller asks for that region.
+ *
+ * ```ts
+ * const company = createHolidayProvider({
+ *   id: "acme",
+ *   holidays: [{ date: "2026-12-24", name: "Company day off", kind: "bank" }],
+ * });
+ * ```
+ */
+export declare function createHolidayProvider(options: CreateHolidayProviderOptions): HolidayProvider;
+/** Merges providers (e.g. national pack + company days off). Coverage is the intersection. */
+export declare function combineHolidayProviders(...providers: HolidayProvider[]): HolidayProvider;
+/** True when `range` lies inside the provider's declared coverage (or none is declared). */
+export declare function isRangeCovered(provider: HolidayProvider, range: HolidayRange): boolean;
+/** The holidays on one date. */
+export declare function holidaysOn(provider: HolidayProvider | HolidayProvider[] | undefined, date: IsoDate, region?: string): Holiday[];
+/** The holiday's name for `locale`: `localName` when the locale's language matches the pack. */
+export declare function holidayName(holiday: Holiday, locale: string, packLanguage?: string): string;

package/dist/locale-data/core/holidays.js

@@ -0,0 +1,79 @@
+/** Holiday providers: build one from data, combine several, check coverage. React-free. */
+import { compareIsoDate } from "./date.js";
+const inRange = (d, r) => d >= r.start && d <= r.end;
+const regionMatch = (h, region) => !h.region || (region !== undefined && h.region === region);
+/**
+ * A `HolidayProvider` from plain data. Region-specific entries are returned only when the
+ * caller asks for that region.
+ *
+ * ```ts
+ * const company = createHolidayProvider({
+ *   id: "acme",
+ *   holidays: [{ date: "2026-12-24", name: "Company day off", kind: "bank" }],
+ * });
+ * ```
+ */
+export function createHolidayProvider(options) {
+    const { id, holidays, coverage } = options;
+    const byYear = new Map();
+    const yearOf = (year) => {
+        let list = byYear.get(year);
+        if (!list) {
+            list = typeof holidays === "function" ? holidays(year) : holidays.filter((h) => h.date.startsWith(`${year}-`));
+            list = [...list].sort((a, b) => compareIsoDate(a.date, b.date));
+            byYear.set(year, list);
+        }
+        return list;
+    };
+    return {
+        id,
+        coverage,
+        get(range, opts) {
+            if (range.end < range.start)
+                return [];
+            const y0 = Number(range.start.slice(0, 4));
+            const y1 = Number(range.end.slice(0, 4));
+            const out = [];
+            for (let y = y0; y <= y1; y++)
+                for (const h of yearOf(y))
+                    if (inRange(h.date, range) && regionMatch(h, opts?.region))
+                        out.push(h);
+            return out;
+        },
+    };
+}
+/** Merges providers (e.g. national pack + company days off). Coverage is the intersection. */
+export function combineHolidayProviders(...providers) {
+    const covs = providers.map((p) => p.coverage);
+    const coverage = covs.every(Boolean)
+        ? {
+            from: covs.reduce((m, c) => (c.from > m ? c.from : m), covs[0].from),
+            to: covs.reduce((m, c) => (c.to < m ? c.to : m), covs[0].to),
+        }
+        : undefined;
+    return {
+        id: providers.map((p) => p.id).join("+"),
+        coverage,
+        get(range, opts) {
+            return providers.flatMap((p) => p.get(range, opts)).sort((a, b) => compareIsoDate(a.date, b.date));
+        },
+    };
+}
+/** True when `range` lies inside the provider's declared coverage (or none is declared). */
+export function isRangeCovered(provider, range) {
+    const c = provider.coverage;
+    return !c || (range.start >= c.from && range.end <= c.to);
+}
+/** The holidays on one date. */
+export function holidaysOn(provider, date, region) {
+    if (!provider)
+        return [];
+    const list = Array.isArray(provider) ? provider : [provider];
+    return list.flatMap((p) => p.get({ start: date, end: date }, { region }));
+}
+/** The holiday's name for `locale`: `localName` when the locale's language matches the pack. */
+export function holidayName(holiday, locale, packLanguage) {
+    if (holiday.localName && packLanguage && locale.toLowerCase().split(/[-_]/)[0] === packLanguage)
+        return holiday.localName;
+    return holiday.name;
+}

package/dist/locale-data/core/iban.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ISO 13616 IBAN: normalization, mod-97 check, check-digit computation and display grouping.
+ * Chunked mod-97 (no BigInt). Per-country rules are pack data (`IbanCountryRule`).
+ */
+import type { IbanCountryRule, IdResult } from "./types.js";
+/**
+ * IBAN lengths from the SWIFT IBAN registry for common countries. Unknown countries are
+ * checked against the generic 15–34 range only.
+ */
+export declare const IBAN_LENGTHS: Readonly<Record<string, number>>;
+/** Uppercase, separators and whitespace removed ("tr33 0006-1…" → "TR330006…"). */
+export declare function normalizeIban(value: string): string;
+/** The two check digits for a country code and BBAN. */
+export declare function ibanCheckDigits(country: string, bban: string): string;
+/** Builds a valid IBAN from a country code and BBAN. */
+export declare function buildIban(country: string, bban: string): string;
+/**
+ * Validates an IBAN: shape, the country's length (and BBAN pattern when a rule is given), mod 97.
+ *
+ * ```ts
+ * validateIban("TR33 0006 1005 1978 6457 8413 26"); // { valid: true, value: "TR33…", kind: "iban-TR" }
+ * ```
+ */
+export declare function validateIban(value: string, rules?: IbanCountryRule[]): IdResult;
+export declare function isValidIban(value: string, rules?: IbanCountryRule[]): boolean;
+/** Print format: groups of four ("TR33 0006 1005 1978 6457 8413 26"). Works on partial input. */
+export declare function formatIban(value: string): string;
+/** Electronic format (no spaces, uppercase). */
+export declare const electronicIban: typeof normalizeIban;

package/dist/locale-data/core/iban.js

@@ -0,0 +1,74 @@
+/**
+ * IBAN lengths from the SWIFT IBAN registry for common countries. Unknown countries are
+ * checked against the generic 15–34 range only.
+ */
+export const IBAN_LENGTHS = {
+    AD: 24, AE: 23, AL: 28, AT: 20, AZ: 28, BA: 20, BE: 16, BG: 22, BH: 22, BR: 29, CH: 21, CY: 28, CZ: 24,
+    DE: 22, DK: 18, DO: 28, EE: 20, EG: 29, ES: 24, FI: 18, FO: 18, FR: 27, GB: 22, GE: 22, GI: 23, GL: 18,
+    GR: 27, HR: 21, HU: 28, IE: 22, IL: 23, IQ: 23, IS: 26, IT: 27, JO: 30, KW: 30, KZ: 20, LB: 28, LI: 21,
+    LT: 20, LU: 20, LV: 21, MC: 27, MD: 24, ME: 22, MK: 19, MT: 31, MU: 30, NL: 18, NO: 15, PK: 24, PL: 28,
+    PS: 29, PT: 25, QA: 29, RO: 24, RS: 22, SA: 24, SE: 24, SI: 19, SK: 24, SM: 27, TN: 24, TR: 26, UA: 29,
+    VA: 22, XK: 20,
+};
+/** Uppercase, separators and whitespace removed ("tr33 0006-1…" → "TR330006…"). */
+export function normalizeIban(value) {
+    return value.replace(/[\s\-._]/g, "").toUpperCase();
+}
+/** `n mod 97` of a string of decimal digits, in 9-digit chunks. */
+function mod97(digits) {
+    let rem = 0;
+    for (let i = 0; i < digits.length; i += 7)
+        rem = Number(String(rem) + digits.slice(i, i + 7)) % 97;
+    return rem;
+}
+/** Letters → numbers (A = 10 … Z = 35). */
+function toDigits(s) {
+    let out = "";
+    for (const ch of s) {
+        const c = ch.charCodeAt(0);
+        out += c >= 65 && c <= 90 ? String(c - 55) : ch;
+    }
+    return out;
+}
+/** The two check digits for a country code and BBAN. */
+export function ibanCheckDigits(country, bban) {
+    const rem = mod97(toDigits(normalizeIban(bban) + country.toUpperCase() + "00"));
+    return String(98 - rem).padStart(2, "0");
+}
+/** Builds a valid IBAN from a country code and BBAN. */
+export function buildIban(country, bban) {
+    const b = normalizeIban(bban);
+    return country.toUpperCase() + ibanCheckDigits(country, b) + b;
+}
+/**
+ * Validates an IBAN: shape, the country's length (and BBAN pattern when a rule is given), mod 97.
+ *
+ * ```ts
+ * validateIban("TR33 0006 1005 1978 6457 8413 26"); // { valid: true, value: "TR33…", kind: "iban-TR" }
+ * ```
+ */
+export function validateIban(value, rules) {
+    const v = normalizeIban(value);
+    if (!v)
+        return { valid: false, value: v, reason: "empty" };
+    if (!/^[A-Z]{2}\d{2}[A-Z0-9]+$/.test(v))
+        return { valid: false, value: v, reason: "chars" };
+    const country = v.slice(0, 2);
+    const rule = rules?.find((r) => r.country === country);
+    const length = rule?.length ?? IBAN_LENGTHS[country];
+    if (length !== undefined ? v.length !== length : v.length < 15 || v.length > 34)
+        return { valid: false, value: v, kind: `iban-${country}`, reason: "length" };
+    if (rule && !rule.bban.test(v.slice(4)))
+        return { valid: false, value: v, kind: `iban-${country}`, reason: "pattern" };
+    const ok = mod97(toDigits(v.slice(4) + v.slice(0, 4))) === 1;
+    return ok ? { valid: true, value: v, kind: `iban-${country}` } : { valid: false, value: v, kind: `iban-${country}`, reason: "checksum" };
+}
+export function isValidIban(value, rules) {
+    return validateIban(value, rules).valid;
+}
+/** Print format: groups of four ("TR33 0006 1005 1978 6457 8413 26"). Works on partial input. */
+export function formatIban(value) {
+    return normalizeIban(value).replace(/(.{4})(?=.)/g, "$1 ");
+}
+/** Electronic format (no spaces, uppercase). */
+export const electronicIban = normalizeIban;

package/dist/locale-data/core/index.d.ts

@@ -0,0 +1,7 @@
+export type { IsoDate, WeekInfo, Holiday, HolidayKind, HolidayRange, HolidayProvider, BusinessHours, WorkCalendar, IdResult, IdRule, IbanCountryRule, TaxRate, TaxScheme, AddressProvince, AddressDistrict, AddressDataSource, LocaleDataPack, } from "./types.js";
+export { isIsoDate, daysInMonth, toDayNumber, fromDayNumber, addDays, diffDays, isoWeekday, toIsoDate, isoDateInZone, compareIsoDate, eachDay } from "./date.js";
+export { getWeekInfo, weekInfoForRegion, regionOf, defaultWorkDays, weekdayOrder } from "./week-info.js";
+export { createHolidayProvider, combineHolidayProviders, isRangeCovered, holidaysOn, holidayName, type CreateHolidayProviderOptions } from "./holidays.js";
+export { workingValue, isWorkingDay, countWorkingDays, addWorkingDays, nextWorkingDay } from "./working-days.js";
+export { IBAN_LENGTHS, normalizeIban, ibanCheckDigits, buildIban, validateIban, isValidIban, formatIban, electronicIban } from "./iban.js";
+export { toUnits, fromUnits, mulDivRound, roundHalfUp, addDecimal, subtractDecimal, multiplyDecimal, divideDecimal, compareDecimal } from "./decimal.js";