raqam 0.2.0

package/dist/core.d.ts

@@ -0,0 +1,351 @@
+interface LocaleInfo {
+    /** Decimal separator for this locale (e.g. "." en-US, "," de-DE, "٫" fa-IR) */
+    decimalSeparator: string;
+    /** Grouping (thousands) separator (e.g. "," en-US, "." de-DE, "٬" fa-IR) */
+    groupingSeparator: string;
+    /** Minus sign character (usually "-" but can differ) */
+    minusSign: string;
+    /** Locale's representation of "0" (e.g. "0" for Latin, "۰" for Persian) */
+    zero: string;
+    /** Whether this is an RTL locale */
+    isRTL: boolean;
+}
+interface FormatResult {
+    formatted: string;
+    parts: Intl.NumberFormatPart[];
+}
+interface ParseResult {
+    /** The parsed number, or null if empty / un-parseable */
+    value: number | null;
+    /** True for valid numbers */
+    isValid: boolean;
+    /**
+     * True for valid-but-incomplete input that must not be reformatted yet:
+     * "-", "1.", "1.0", "1.00", etc.
+     */
+    isIntermediate: boolean;
+}
+/**
+ * boolean[] of length formattedValue.length + 1.
+ * true  → cursor may rest at this index
+ * false → cursor must not rest here (e.g. inside a thousands separator)
+ */
+type CaretBoundary = boolean[];
+/** Unicode codepoint range [start, end] inclusive representing a digit block */
+type DigitBlock = readonly [number, number];
+interface UseNumberFieldStateOptions {
+    /** Controlled numeric value */
+    value?: number | null;
+    /** Uncontrolled default value */
+    defaultValue?: number | null;
+    /** Fires on every meaningful value change */
+    onChange?: (value: number | null) => void;
+    /** BCP 47 locale tag (default: browser locale) */
+    locale?: string;
+    /** Full Intl.NumberFormatOptions — currency, percent, decimal, etc. */
+    formatOptions?: Intl.NumberFormatOptions;
+    /** Minimum allowed value */
+    minValue?: number;
+    /** Maximum allowed value */
+    maxValue?: number;
+    /** Step amount for increment/decrement (default: 1) */
+    step?: number;
+    /** Large step — Shift+Arrow / PageUp/Down (default: step * 10) */
+    largeStep?: number;
+    /** Small step — Meta/Ctrl+Arrow (default: step * 0.1) */
+    smallStep?: number;
+    /** Allow negative values (default: true) */
+    allowNegative?: boolean;
+    /** Allow decimal values (default: true) */
+    allowDecimal?: boolean;
+    /** Override maximumFractionDigits from formatOptions */
+    maximumFractionDigits?: number;
+    /** Override minimumFractionDigits from formatOptions */
+    minimumFractionDigits?: number;
+    /** Always show exactly maximumFractionDigits decimal places */
+    fixedDecimalScale?: boolean;
+    /** When clamping happens (default: "blur") */
+    clampBehavior?: "blur" | "strict" | "none";
+    /** Apply live formatting while typing (default: true) */
+    liveFormat?: boolean;
+    /** Arbitrary prefix string (e.g. "$") */
+    prefix?: string;
+    /** Arbitrary suffix string (e.g. " تومان") */
+    suffix?: string;
+    /** Disable the field */
+    disabled?: boolean;
+    /** Make the field read-only */
+    readOnly?: boolean;
+    /** Mark the field as required */
+    required?: boolean;
+    /**
+     * Allow values outside min/max to be typed and committed without clamping.
+     * Useful when server-side validation handles clamping.
+     * When true, aria-invalid is set when value is out of range.
+     * default: false
+     */
+    allowOutOfRange?: boolean;
+    /**
+     * Custom validation function. Called on every value change.
+     * - Return `true` or `null`/`undefined` → valid
+     * - Return `false` → invalid (aria-invalid set, no error message)
+     * - Return a `string` → invalid with that string as the error message
+     */
+    validate?: (value: number | null) => boolean | string | null | undefined;
+    /**
+     * Fires with the raw unformatted string the user typed, preserving full
+     * decimal precision before JS float conversion. Useful for financial apps
+     * that need arbitrary-precision string arithmetic.
+     * Fires alongside `onChange`.
+     */
+    onRawChange?: (rawValue: string | null) => void;
+    /**
+     * Custom format function. When provided, replaces the built-in Intl.NumberFormat
+     * formatter for display purposes. Also used for initial display value.
+     */
+    formatValue?: (value: number) => string;
+    /**
+     * Custom parse function. When provided, replaces the built-in locale-aware parser.
+     * Must return `{ value: number | null, isIntermediate: boolean }`.
+     */
+    parseValue?: (input: string) => {
+        value: number | null;
+        isIntermediate: boolean;
+    };
+}
+interface NumberFieldState {
+    /** The display string shown in the input */
+    inputValue: string;
+    /** The parsed numeric value (null for empty/invalid) */
+    numberValue: number | null;
+    /**
+     * The raw string value exactly as the user typed it (before formatting).
+     * Preserves full decimal precision — useful for financial arbitrary-precision math.
+     */
+    rawValue: string | null;
+    /** Whether increment is currently possible */
+    canIncrement: boolean;
+    /** Whether decrement is currently possible */
+    canDecrement: boolean;
+    /** Whether the ScrubArea is currently being dragged */
+    isScrubbing: boolean;
+    /** Update the isScrubbing state (called by useScrubArea) */
+    setIsScrubbing: (val: boolean) => void;
+    /** Whether the input is currently focused */
+    isFocused: boolean;
+    /** Update the isFocused state (called by useNumberField) */
+    setIsFocused: (val: boolean) => void;
+    /** Current validation state — 'valid' if no validate prop, or based on validate result */
+    validationState: "valid" | "invalid";
+    /** Error message from validate() if it returned a string, otherwise null */
+    validationError: string | null;
+    /** Internal: set the reason for the next onChange call (used by useNumberField) */
+    _setLastChangeReason: (reason: ChangeReason) => void;
+    /** Internal: read the current change reason (used by NumberField.Root) */
+    _getLastChangeReason: () => ChangeReason;
+    /** Update display string (triggers parse + onChange) */
+    setInputValue: (val: string) => void;
+    /** Directly set the numeric value (triggers format + onChange) */
+    setNumberValue: (val: number | null) => void;
+    /** Format + clamp on blur — call from onBlur */
+    commit: () => void;
+    /** Increment by step */
+    increment: (amount?: number) => void;
+    /** Decrement by step */
+    decrement: (amount?: number) => void;
+    /** Jump to maxValue */
+    incrementToMax: () => void;
+    /** Jump to minValue */
+    decrementToMin: () => void;
+    /** Raw options (for hooks that need them) */
+    options: UseNumberFieldStateOptions;
+}
+/** Reason for a value change — propagated through onValueChange details */
+type ChangeReason = "input" | "clear" | "blur" | "paste" | "keyboard" | "increment" | "decrement" | "wheel" | "scrub";
+interface UseNumberFieldProps extends UseNumberFieldStateOptions {
+    /** Visible label text (used for aria-label fallback) */
+    label?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
+    /** Form field name — renders a hidden input */
+    name?: string;
+    /** id for the input element */
+    id?: string;
+    /** Enable mouse-wheel increment/decrement */
+    allowMouseWheel?: boolean;
+    /**
+     * Controls what is placed in the clipboard on copy/cut.
+     * - 'formatted' (default): browser-native copy of display string
+     * - 'raw': numberValue as a plain JS number string (e.g. "1234.56")
+     * - 'number': alias for 'raw'
+     */
+    copyBehavior?: "formatted" | "raw" | "number";
+    /** Milliseconds before press-and-hold repeat starts (default: 400) */
+    stepHoldDelay?: number;
+    /** Initial milliseconds between repeats during press-and-hold (default: 200) */
+    stepHoldInterval?: number;
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;
+}
+interface NumberFieldAria {
+    labelProps: React.LabelHTMLAttributes<HTMLLabelElement>;
+    groupProps: React.HTMLAttributes<HTMLDivElement>;
+    inputProps: React.InputHTMLAttributes<HTMLInputElement>;
+    hiddenInputProps: React.InputHTMLAttributes<HTMLInputElement> | null;
+    incrementButtonProps: React.ButtonHTMLAttributes<HTMLButtonElement>;
+    decrementButtonProps: React.ButtonHTMLAttributes<HTMLButtonElement>;
+    descriptionProps: React.HTMLAttributes<HTMLElement>;
+    errorMessageProps: React.HTMLAttributes<HTMLElement>;
+}
+type StateRenderFn = (props: Record<string, unknown>, state: NumberFieldState) => React.ReactElement;
+type RenderProp = React.ReactElement | StateRenderFn;
+interface NumberFieldRootProps extends UseNumberFieldProps {
+    children?: React.ReactNode;
+    /** CSS class for the root wrapper div */
+    className?: string;
+    /** Inline style for the root wrapper div */
+    style?: React.CSSProperties;
+    /** Fires on every meaningful value change */
+    onValueChange?: (value: number | null, details: {
+        reason: ChangeReason;
+        formattedValue: string;
+        event?: React.SyntheticEvent;
+    }) => void;
+    /** Fires only on commit (blur, Enter) */
+    onValueCommitted?: (value: number | null, details: {
+        reason: "blur" | "keyboard";
+    }) => void;
+}
+
+/**
+ * Format presets — named Intl.NumberFormatOptions configurations for common
+ * number input patterns. Use these as the `formatOptions` prop value.
+ *
+ * @example
+ * import { presets } from 'raqam'
+ * <NumberField.Root formatOptions={presets.currency('USD')} />
+ * <NumberField.Root formatOptions={presets.percent} />
+ * <NumberField.Root formatOptions={presets.compact} />
+ */
+declare const presets: {
+    /** Currency with standard sign display. Shorthand for `{ style:'currency', currency:code }`. */
+    readonly currency: (code: string) => Intl.NumberFormatOptions;
+    /**
+     * Accounting currency — negatives shown as `(1,234.56)` instead of `-$1,234.56`.
+     * Requires the accounting format parser fix (built-in to raqam).
+     */
+    readonly accounting: (code: string) => Intl.NumberFormatOptions;
+    /** Percentage — formats 0.42 as "42%" */
+    readonly percent: Intl.NumberFormatOptions;
+    /** Compact short — "1.2K", "3.4M" */
+    readonly compact: Intl.NumberFormatOptions;
+    /** Compact long — "1.2 thousand", "3.4 million" */
+    readonly compactLong: Intl.NumberFormatOptions;
+    /** Scientific notation — "1.234E3" */
+    readonly scientific: Intl.NumberFormatOptions;
+    /** Engineering notation — exponents always multiples of 3 */
+    readonly engineering: Intl.NumberFormatOptions;
+    /** Integer — no decimal places */
+    readonly integer: Intl.NumberFormatOptions;
+    /**
+     * Financial — always exactly 2 decimal places (fixed scale).
+     * Combine with `fixedDecimalScale` prop for strict display.
+     */
+    readonly financial: Intl.NumberFormatOptions;
+    /**
+     * Unit — shorthand for `{ style:'unit', unit:unitCode }`.
+     * @example presets.unit('kilometer-per-hour') → { style:'unit', unit:'kilometer-per-hour' }
+     */
+    readonly unit: (unit: string) => Intl.NumberFormatOptions;
+};
+
+interface LocaleConfig {
+    /** Extra digit block ranges to register */
+    digitBlocks?: DigitBlock[];
+}
+/**
+ * Register additional digit blocks (called by locale plugins as a side effect).
+ * Duplicate ranges are silently ignored.
+ */
+declare function registerLocale(config: LocaleConfig): void;
+/**
+ * Normalise any Unicode decimal digit in `input` to its ASCII equivalent (0–9).
+ * Non-digit characters pass through unchanged.
+ */
+declare function normalizeDigits(input: string): string;
+
+interface FormatterOptions {
+    locale?: string;
+    formatOptions?: Intl.NumberFormatOptions;
+    prefix?: string;
+    suffix?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    fixedDecimalScale?: boolean;
+}
+interface Formatter {
+    format(value: number): string;
+    formatToParts(value: number): Intl.NumberFormatPart[];
+    getLocaleInfo(): LocaleInfo;
+    formatResult(value: number): FormatResult;
+}
+/**
+ * Create a formatter instance. Intl.NumberFormat is cached — safe to call
+ * on every render.
+ */
+declare function createFormatter(opts: FormatterOptions): Formatter;
+
+interface ParserOptions {
+    locale?: string;
+    formatOptions?: Intl.NumberFormatOptions;
+    allowNegative?: boolean;
+    allowDecimal?: boolean;
+    prefix?: string;
+    suffix?: string;
+}
+interface Parser {
+    parse(input: string): ParseResult;
+    isIntermediate(input: string): boolean;
+    getLocaleInfo(): LocaleInfo;
+}
+/**
+ * Create a locale-aware parser. Separator characters are extracted from
+ * Intl.NumberFormat — never hardcoded.
+ */
+declare function createParser(opts?: ParserOptions): Parser;
+
+/**
+ * Build a boolean array of length `formattedValue.length + 1`.
+ * `true`  → cursor may rest at this position.
+ * `false` → cursor must snap away (sits inside a formatting-only character
+ *            such as a grouping separator or a currency prefix).
+ *
+ * Rules:
+ *  - Start and end positions are always valid.
+ *  - A position immediately AFTER a grouping separator is invalid (the
+ *    cursor would look like it's between two digits but moving left would
+ *    skip the comma).
+ *  - A position immediately BEFORE a grouping separator is valid.
+ */
+declare function getCaretBoundary(formattedValue: string, info: LocaleInfo): CaretBoundary;
+/**
+ * Compute the new cursor position in `newFormatted` that corresponds
+ * semantically to `oldCursor` in `oldInput`.
+ *
+ * Algorithm (3 stages from the spec):
+ *
+ * 1. Count accepted characters before `oldCursor` in `oldInput`.
+ * 2. Adjust for backspace-over-separator edge case.
+ * 3. Walk `newFormatted` to find the position where the same count of
+ *    accepted chars precede it; snap to the nearest valid boundary.
+ *
+ * @param oldInput     The raw string the user just typed into (pre-format)
+ * @param oldCursor    selectionStart captured from the native event
+ * @param newFormatted The formatted string we're about to display
+ * @param info         Locale separators
+ * @param inputType    e.nativeEvent.inputType (optional — for backspace detection)
+ */
+declare function computeNewCursorPosition(oldInput: string, oldCursor: number, newFormatted: string, info: LocaleInfo, inputType?: string): number;
+
+export { type CaretBoundary, type ChangeReason, type DigitBlock, type FormatResult, type Formatter, type FormatterOptions, type LocaleConfig, type LocaleInfo, type NumberFieldAria, type NumberFieldRootProps, type NumberFieldState, type ParseResult, type Parser, type ParserOptions, type RenderProp, type StateRenderFn, type UseNumberFieldProps, type UseNumberFieldStateOptions, computeNewCursorPosition, createFormatter, createParser, getCaretBoundary, normalizeDigits, presets, registerLocale };

package/dist/core.js

@@ -0,0 +1,2 @@
+var L={currency:e=>({style:"currency",currency:e}),accounting:e=>({style:"currency",currency:e,currencySign:"accounting"}),percent:{style:"percent"},compact:{notation:"compact"},compactLong:{notation:"compact",compactDisplay:"long"},scientific:{notation:"scientific"},engineering:{notation:"engineering"},integer:{maximumFractionDigits:0},financial:{minimumFractionDigits:2,maximumFractionDigits:2},unit:e=>({style:"unit",unit:e})};var O=[[1632,1641],[1776,1785],[2406,2415],[2534,2543],[3664,3673]],p=[...O];function D(e){if(e.digitBlocks)for(let t of e.digitBlocks)p.some(([i])=>i===t[0])||p.push(t);}function g(e){return /[^\u0020-\u007e]/.test(e)?e.replace(/\p{Nd}/gu,t=>{let r=t.codePointAt(0);for(let[o,s]of p)if(r>=o&&r<=s)return String(r-o);let i=Number.parseInt(t,10);return Number.isNaN(i)?t:String(i)}):e}var x=new Map;function F(e,t){let r=`${e??""}::${JSON.stringify(t??{})}`,i=x.get(r);return i||(i=new Intl.NumberFormat(e,t),x.set(r,i)),i}function P(e,t){let r=F(e,t),i=r.formatToParts(12345.6),o=".",s=",",f="-",c="0";for(let m of i)m.type==="decimal"&&(o=m.value),m.type==="group"&&(s=m.value),m.type==="minusSign"&&(f=m.value);let u=r.formatToParts(0);for(let m of u)if(m.type==="integer"){c=m.value;break}let a=/^(ar|he|fa|ur|syc|nqo|ug|yi)/i,n=r.resolvedOptions().locale,l=a.test(n);return {decimalSeparator:o,groupingSeparator:s,minusSign:f,zero:c,isRTL:l}}function d(e){let t={...e.formatOptions};e.minimumFractionDigits!==void 0&&(t.minimumFractionDigits=e.minimumFractionDigits),e.maximumFractionDigits!==void 0&&(t.maximumFractionDigits=e.maximumFractionDigits),e.fixedDecimalScale&&e.maximumFractionDigits!==void 0&&(t.minimumFractionDigits=e.maximumFractionDigits,t.maximumFractionDigits=e.maximumFractionDigits);let r=F(e.locale,t),i=null;function o(){return i||(i=P(e.locale,t)),i}function s(u){let a=r.formatToParts(u);if(!e.prefix&&!e.suffix)return a;let n=[];return e.prefix&&n.push({type:"literal",value:e.prefix}),n.push(...a),e.suffix&&n.push({type:"literal",value:e.suffix}),n}function f(u){if(!Number.isFinite(u))return "";let a=r.format(u);return (e.prefix??"")+a+(e.suffix??"")}function c(u){let a=s(u);return {formatted:a.map(l=>l.value).join(""),parts:a}}return {format:f,formatToParts:s,getLocaleInfo:o,formatResult:c}}function I(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function b(e,t,r,i){let o=I(t.decimalSeparator),s=I(t.minusSign);return !!(r&&(e==="-"||e===t.minusSign)||i&&new RegExp(`^${s}?\\d+${o}$`).test(e)||i&&new RegExp(`^${s}?\\d+${o}\\d*0+$`).test(e))}function S(e={}){let t=e.allowNegative??true,r=e.allowDecimal??true,i=d({locale:e.locale,formatOptions:e.formatOptions,prefix:e.prefix,suffix:e.suffix});function o(){return i.getLocaleInfo()}function s(u){let a=o(),n=g(u),l=n.match(/^\((.+)\)$/);return l&&(n=`-${l[1]}`),e.prefix&&n.startsWith(e.prefix)&&(n=n.slice(e.prefix.length)),e.suffix&&n.endsWith(e.suffix)&&(n=n.slice(0,-e.suffix.length)),a.groupingSeparator&&(n=n.split(a.groupingSeparator).join("")),a.decimalSeparator!=="."&&(n=n.split(a.decimalSeparator).join(".")),a.minusSign!=="-"&&(n=n.split(a.minusSign).join("-")),n=n.replace(/[^\d.\-]/g,"").trim(),n}function f(u){if(!u||u.trim()==="")return {value:null,isValid:false,isIntermediate:false};let a=o();if(b(u,a,t,r))return {value:null,isValid:false,isIntermediate:true};let n=s(u);if(n==="")return {value:null,isValid:false,isIntermediate:false};if(n==="-")return {value:null,isValid:false,isIntermediate:t};if(!/^-?\d+\.?\d*$/.test(n))return {value:null,isValid:false,isIntermediate:false};if(!t&&n.startsWith("-"))return {value:null,isValid:false,isIntermediate:false};if(!r&&n.includes("."))return {value:null,isValid:false,isIntermediate:false};let l=Number.parseFloat(n);return Number.isFinite(l)?{value:l,isValid:true,isIntermediate:false}:{value:null,isValid:false,isIntermediate:false}}function c(u){let a=o();return b(u,a,t,r)}return {parse:f,isIntermediate:c,getLocaleInfo:o}}function y(e,t){return e>="0"&&e<="9"||e===t.decimalSeparator||e===t.minusSign||e==="-"}function v(e,t,r){let i=g(e),o=0;for(let s=0;s<t&&s<i.length;s++)y(i[s],r)&&o++;return o}function N(e,t){let r=e.length,i=new Array(r+1).fill(true);for(let o=0;o<r;o++)e[o]===t.groupingSeparator&&(i[o+1]=false);return i[0]=true,i[r]=true,i}function B(e,t,r,i,o){let s=g(e),f=v(s,t,i);o==="deleteContentBackward"&&t>0&&e[t-1]===i.groupingSeparator&&(f=Math.max(0,f-1));let c=N(r,i),u=g(r),a=0,n=0;for(let l=0;l<u.length;l++){if(a===f){n=l;break}y(u[l],i)&&a++,n=l+1;}return f>0&&a<f&&(n=r.length),n=R(n,c),n}function R(e,t){if(t[e])return e;for(let r=e+1;r<t.length;r++)if(t[r])return r;for(let r=e-1;r>=0;r--)if(t[r])return r;return 0}export{B as computeNewCursorPosition,d as createFormatter,S as createParser,N as getCaretBoundary,g as normalizeDigits,L as presets,D as registerLocale};//# sourceMappingURL=core.js.map
+//# sourceMappingURL=core.js.map

package/dist/core.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/presets.ts","../src/core/normalizer.ts","../src/core/formatter.ts","../src/core/parser.ts","../src/core/cursor.ts"],"names":["presets","code","unit","BUILTIN_DIGIT_BLOCKS","registeredBlocks","registerLocale","config","block","s","normalizeDigits","input","ch","start","end","digit","formatterCache","getFormatter","locale","options","key","fmt","extractLocaleInfo","parts","decimalSeparator","groupingSeparator","minusSign","zero","part","zeroParts","rtlLocales","resolvedLocale","isRTL","createFormatter","opts","intlOptions","intlFmt","cachedLocaleInfo","getLocaleInfo","formatToParts","value","result","format","formatted","formatResult","p","escapeRegex","checkIntermediate","normalized","info","allowNegative","allowDecimal","dec","minus","createParser","stripAffordances","raw","accountingMatch","parse","stripped","n","isIntermediate","isAccepted","countAcceptedBefore","str","cursor","normalised","count","i","getCaretBoundary","formattedValue","len","boundary","computeNewCursorPosition","oldInput","oldCursor","newFormatted","inputType","acceptedCount","normNew","pos","snapToBoundary"],"mappings":"AAWO,IAAMA,CAAAA,CAAU,CAErB,QAAA,CAAWC,CAAAA,GAA4C,CACrD,KAAA,CAAO,UAAA,CACP,QAAA,CAAUA,CACZ,CAAA,CAAA,CAMA,UAAA,CAAaA,CAAAA,GAA4C,CACvD,KAAA,CAAO,UAAA,CACP,QAAA,CAAUA,CAAAA,CACV,YAAA,CAAc,YAChB,CAAA,CAAA,CAGA,OAAA,CAAS,CAAE,KAAA,CAAO,SAAU,CAAA,CAG5B,OAAA,CAAS,CAAE,QAAA,CAAU,SAAU,EAG/B,WAAA,CAAa,CACX,QAAA,CAAU,SAAA,CACV,cAAA,CAAgB,MAClB,CAAA,CAGA,UAAA,CAAY,CAAE,QAAA,CAAU,YAAa,CAAA,CAGrC,WAAA,CAAa,CAAE,QAAA,CAAU,aAAc,EAGvC,OAAA,CAAS,CAAE,qBAAA,CAAuB,CAAE,CAAA,CAMpC,SAAA,CAAW,CACT,qBAAA,CAAuB,CAAA,CACvB,qBAAA,CAAuB,CACzB,CAAA,CAMA,IAAA,CAAOC,CAAAA,GAA4C,CACjD,KAAA,CAAO,OACP,IAAA,CAAAA,CACF,CAAA,CACF,EC5DA,IAAMC,CAAAA,CAAqC,CACzC,CAAC,IAAA,CAAQ,IAAM,CAAA,CACf,CAAC,IAAA,CAAQ,IAAM,CAAA,CACf,CAAC,KAAQ,IAAM,CAAA,CACf,CAAC,IAAA,CAAQ,IAAM,CAAA,CACf,CAAC,IAAA,CAAQ,IAAM,CACjB,CAAA,CAGMC,CAAAA,CAAiC,CAAC,GAAGD,CAAoB,CAAA,CAaxD,SAASE,CAAAA,CAAeC,CAAAA,CAA4B,CACzD,GAAKA,CAAAA,CAAO,WAAA,CACZ,IAAA,IAAWC,CAAAA,IAASD,CAAAA,CAAO,WAAA,CACTF,CAAAA,CAAiB,IAAA,CAAK,CAAC,CAACI,CAAC,CAAA,GAAMA,IAAMD,CAAAA,CAAM,CAAC,CAAC,CAAA,EAC/CH,CAAAA,CAAiB,IAAA,CAAKG,CAAK,EAE7C,CAMO,SAASE,CAAAA,CAAgBC,CAAAA,CAAuB,CAErD,OAAK,kBAAA,CAAmB,IAAA,CAAKA,CAAK,EAE3BA,CAAAA,CAAM,OAAA,CAAQ,UAAA,CAAaC,CAAAA,EAAO,CACvC,IAAMV,CAAAA,CAAOU,CAAAA,CAAG,WAAA,CAAY,CAAC,CAAA,CAC7B,IAAA,GAAW,CAACC,CAAAA,CAAOC,CAAG,CAAA,GAAKT,EACzB,GAAIH,CAAAA,EAAQW,CAAAA,EAASX,CAAAA,EAAQY,CAAAA,CAC3B,OAAO,MAAA,CAAOZ,CAAAA,CAAOW,CAAK,CAAA,CAI9B,IAAME,CAAAA,CAAQ,MAAA,CAAO,QAAA,CAASH,CAAAA,CAAI,EAAE,EACpC,OAAO,MAAA,CAAO,KAAA,CAAMG,CAAK,CAAA,CAAIH,CAAAA,CAAK,MAAA,CAAOG,CAAK,CAChD,CAAC,CAAA,CAZ2CJ,CAa9C,CC/CA,IAAMK,CAAAA,CAAiB,IAAI,IAE3B,SAASC,CAAAA,CACPC,CAAAA,CACAC,CAAAA,CACmB,CACnB,IAAMC,CAAAA,CAAM,CAAA,EAAGF,CAAAA,EAAU,EAAE,CAAA,EAAA,EAAK,IAAA,CAAK,SAAA,CAAUC,CAAAA,EAAW,EAAE,CAAC,CAAA,CAAA,CACzDE,CAAAA,CAAML,CAAAA,CAAe,GAAA,CAAII,CAAG,CAAA,CAChC,OAAKC,CAAAA,GACHA,CAAAA,CAAM,IAAI,IAAA,CAAK,YAAA,CAAaH,CAAAA,CAAQC,CAAO,CAAA,CAC3CH,CAAAA,CAAe,IAAII,CAAAA,CAAKC,CAAG,CAAA,CAAA,CAEtBA,CACT,CAGA,SAASC,CAAAA,CACPJ,CAAAA,CACAC,CAAAA,CACY,CACZ,IAAME,CAAAA,CAAMJ,CAAAA,CAAaC,CAAAA,CAAQC,CAAO,CAAA,CAElCI,EAAQF,CAAAA,CAAI,aAAA,CAAc,OAAW,CAAA,CAEvCG,CAAAA,CAAmB,GAAA,CACnBC,CAAAA,CAAoB,GAAA,CACpBC,CAAAA,CAAY,GAAA,CACZC,CAAAA,CAAO,GAAA,CAEX,IAAA,IAAWC,CAAAA,IAAQL,CAAAA,CACbK,CAAAA,CAAK,OAAS,SAAA,GAAWJ,CAAAA,CAAmBI,CAAAA,CAAK,KAAA,CAAA,CACjDA,CAAAA,CAAK,IAAA,GAAS,OAAA,GAASH,CAAAA,CAAoBG,EAAK,KAAA,CAAA,CAChDA,CAAAA,CAAK,IAAA,GAAS,WAAA,GAAaF,CAAAA,CAAYE,CAAAA,CAAK,KAAA,CAAA,CAIlD,IAAMC,EAAYR,CAAAA,CAAI,aAAA,CAAc,CAAC,CAAA,CACrC,IAAA,IAAWO,CAAAA,IAAQC,CAAAA,CACjB,GAAID,CAAAA,CAAK,IAAA,GAAS,SAAA,CAAW,CAC3BD,CAAAA,CAAOC,CAAAA,CAAK,KAAA,CACZ,KACF,CAIF,IAAME,CAAAA,CAAa,+BAAA,CACbC,CAAAA,CAAiBV,CAAAA,CAAI,eAAA,EAAgB,CAAE,MAAA,CACvCW,CAAAA,CAAQF,CAAAA,CAAW,IAAA,CAAKC,CAAc,CAAA,CAE5C,OAAO,CAAE,gBAAA,CAAAP,EAAkB,iBAAA,CAAAC,CAAAA,CAAmB,SAAA,CAAAC,CAAAA,CAAW,IAAA,CAAAC,CAAAA,CAAM,KAAA,CAAAK,CAAM,CACvE,CAyBO,SAASC,CAAAA,CAAgBC,CAAAA,CAAmC,CAEjE,IAAMC,CAAAA,CAAwC,CAAE,GAAGD,CAAAA,CAAK,aAAc,CAAA,CAElEA,CAAAA,CAAK,qBAAA,GAA0B,MAAA,GACjCC,CAAAA,CAAY,qBAAA,CAAwBD,CAAAA,CAAK,qBAAA,CAAA,CAEvCA,CAAAA,CAAK,qBAAA,GAA0B,MAAA,GACjCC,CAAAA,CAAY,qBAAA,CAAwBD,EAAK,qBAAA,CAAA,CAEvCA,CAAAA,CAAK,iBAAA,EAAqBA,CAAAA,CAAK,qBAAA,GAA0B,MAAA,GAC3DC,CAAAA,CAAY,qBAAA,CAAwBD,CAAAA,CAAK,qBAAA,CACzCC,CAAAA,CAAY,qBAAA,CAAwBD,CAAAA,CAAK,qBAAA,CAAA,CAG3C,IAAME,CAAAA,CAAUnB,EAAaiB,CAAAA,CAAK,MAAA,CAAQC,CAAW,CAAA,CAEjDE,CAAAA,CAAsC,IAAA,CAE1C,SAASC,CAAAA,EAA4B,CACnC,OAAKD,CAAAA,GACHA,CAAAA,CAAmBf,CAAAA,CAAkBY,CAAAA,CAAK,MAAA,CAAQC,CAAW,GAExDE,CACT,CAEA,SAASE,CAAAA,CAAcC,CAAAA,CAAwC,CAC7D,IAAMjB,CAAAA,CAAQa,CAAAA,CAAQ,aAAA,CAAcI,CAAK,CAAA,CACzC,GAAI,CAACN,CAAAA,CAAK,MAAA,EAAU,CAACA,CAAAA,CAAK,MAAA,CAAQ,OAAOX,CAAAA,CAEzC,IAAMkB,CAAAA,CAAkC,EAAC,CACzC,OAAIP,CAAAA,CAAK,MAAA,EAAQO,CAAAA,CAAO,IAAA,CAAK,CAAE,IAAA,CAAM,SAAA,CAAW,KAAA,CAAOP,EAAK,MAAO,CAAC,CAAA,CACpEO,CAAAA,CAAO,IAAA,CAAK,GAAGlB,CAAK,CAAA,CAChBW,CAAAA,CAAK,MAAA,EAAQO,CAAAA,CAAO,IAAA,CAAK,CAAE,IAAA,CAAM,SAAA,CAAW,KAAA,CAAOP,EAAK,MAAO,CAAC,CAAA,CAC7DO,CACT,CAEA,SAASC,CAAAA,CAAOF,CAAAA,CAAuB,CACrC,GAAI,CAAC,MAAA,CAAO,QAAA,CAASA,CAAK,CAAA,CAAG,OAAO,GACpC,IAAMG,CAAAA,CAAYP,CAAAA,CAAQ,MAAA,CAAOI,CAAK,CAAA,CACtC,OAAA,CAAQN,CAAAA,CAAK,MAAA,EAAU,EAAA,EAAMS,CAAAA,EAAaT,CAAAA,CAAK,MAAA,EAAU,EAAA,CAC3D,CAEA,SAASU,EAAaJ,CAAAA,CAA6B,CACjD,IAAMjB,CAAAA,CAAQgB,CAAAA,CAAcC,CAAK,CAAA,CAEjC,OAAO,CAAE,SAAA,CADSjB,CAAAA,CAAM,GAAA,CAAKsB,CAAAA,EAAMA,CAAAA,CAAE,KAAK,CAAA,CAAE,KAAK,EAAE,CAAA,CAC/B,KAAA,CAAAtB,CAAM,CAC5B,CAEA,OAAO,CAAE,MAAA,CAAAmB,CAAAA,CAAQ,aAAA,CAAAH,CAAAA,CAAe,aAAA,CAAAD,CAAAA,CAAe,YAAA,CAAAM,CAAa,CAC9D,CC5HA,SAASE,CAAAA,CAAYrC,CAAAA,CAAmB,CACtC,OAAOA,CAAAA,CAAE,OAAA,CAAQ,qBAAA,CAAuB,MAAM,CAChD,CAWA,SAASsC,CAAAA,CACPC,CAAAA,CACAC,CAAAA,CACAC,EACAC,CAAAA,CACS,CACT,IAAMC,CAAAA,CAAMN,CAAAA,CAAYG,CAAAA,CAAK,gBAAgB,CAAA,CACvCI,CAAAA,CAAQP,CAAAA,CAAYG,CAAAA,CAAK,SAAS,CAAA,CAWxC,OARI,CAAA,EAAAC,CAAAA,GAAkBF,IAAe,GAAA,EAAOA,CAAAA,GAAeC,CAAAA,CAAK,SAAA,CAAA,EAI5DE,CAAAA,EAAgB,IAAI,MAAA,CAAO,CAAA,CAAA,EAAIE,CAAK,CAAA,KAAA,EAAQD,CAAG,CAAA,CAAA,CAAG,CAAA,CAAE,IAAA,CAAKJ,CAAU,CAAA,EAInEG,CAAAA,EAAgB,IAAI,MAAA,CAAO,CAAA,CAAA,EAAIE,CAAK,CAAA,KAAA,EAAQD,CAAG,CAAA,OAAA,CAAS,CAAA,CAAE,IAAA,CAAKJ,CAAU,CAAA,CAI/E,CAuBO,SAASM,CAAAA,CAAapB,CAAAA,CAAsB,EAAC,CAAW,CAC7D,IAAMgB,CAAAA,CAAgBhB,CAAAA,CAAK,aAAA,EAAiB,IAAA,CACtCiB,CAAAA,CAAejB,CAAAA,CAAK,YAAA,EAAgB,IAAA,CAGpCb,CAAAA,CAAMY,CAAAA,CAAgB,CAC1B,MAAA,CAAQC,CAAAA,CAAK,MAAA,CACb,aAAA,CAAeA,EAAK,aAAA,CACpB,MAAA,CAAQA,CAAAA,CAAK,MAAA,CACb,MAAA,CAAQA,CAAAA,CAAK,MACf,CAAC,CAAA,CAED,SAASI,CAAAA,EAA4B,CACnC,OAAOjB,CAAAA,CAAI,aAAA,EACb,CAEA,SAASkC,CAAAA,CAAiBC,CAAAA,CAAqB,CAC7C,IAAMP,CAAAA,CAAOX,CAAAA,EAAc,CAGvB7B,CAAAA,CAAIC,CAAAA,CAAgB8C,CAAG,CAAA,CAIrBC,CAAAA,CAAkBhD,CAAAA,CAAE,KAAA,CAAM,YAAY,EAC5C,OAAIgD,CAAAA,GACFhD,CAAAA,CAAI,CAAA,CAAA,EAAIgD,CAAAA,CAAgB,CAAC,CAAC,CAAA,CAAA,CAAA,CAIxBvB,CAAAA,CAAK,MAAA,EAAUzB,CAAAA,CAAE,UAAA,CAAWyB,CAAAA,CAAK,MAAM,CAAA,GACzCzB,CAAAA,CAAIA,EAAE,KAAA,CAAMyB,CAAAA,CAAK,MAAA,CAAO,MAAM,CAAA,CAAA,CAE5BA,CAAAA,CAAK,MAAA,EAAUzB,CAAAA,CAAE,QAAA,CAASyB,CAAAA,CAAK,MAAM,CAAA,GACvCzB,CAAAA,CAAIA,CAAAA,CAAE,KAAA,CAAM,CAAA,CAAG,CAACyB,CAAAA,CAAK,MAAA,CAAO,MAAM,CAAA,CAAA,CAIhCe,CAAAA,CAAK,iBAAA,GACPxC,CAAAA,CAAIA,CAAAA,CAAE,KAAA,CAAMwC,CAAAA,CAAK,iBAAiB,CAAA,CAAE,IAAA,CAAK,EAAE,CAAA,CAAA,CAIzCA,CAAAA,CAAK,mBAAqB,GAAA,GAC5BxC,CAAAA,CAAIA,CAAAA,CAAE,KAAA,CAAMwC,CAAAA,CAAK,gBAAgB,CAAA,CAAE,IAAA,CAAK,GAAG,CAAA,CAAA,CAIzCA,CAAAA,CAAK,SAAA,GAAc,GAAA,GACrBxC,CAAAA,CAAIA,CAAAA,CAAE,KAAA,CAAMwC,CAAAA,CAAK,SAAS,CAAA,CAAE,IAAA,CAAK,GAAG,CAAA,CAAA,CAMtCxC,CAAAA,CAAIA,CAAAA,CAAE,OAAA,CAAQ,WAAA,CAAa,EAAE,CAAA,CAAE,IAAA,EAAK,CAE7BA,CACT,CAEA,SAASiD,CAAAA,CAAM/C,EAA4B,CACzC,GAAI,CAACA,CAAAA,EAASA,CAAAA,CAAM,IAAA,EAAK,GAAM,EAAA,CAC7B,OAAO,CAAE,KAAA,CAAO,IAAA,CAAM,OAAA,CAAS,KAAA,CAAO,cAAA,CAAgB,KAAM,EAG9D,IAAMsC,CAAAA,CAAOX,CAAAA,EAAc,CAG3B,GAAIS,CAAAA,CAAkBpC,CAAAA,CAAOsC,CAAAA,CAAMC,CAAAA,CAAeC,CAAY,CAAA,CAC5D,OAAO,CAAE,KAAA,CAAO,IAAA,CAAM,OAAA,CAAS,MAAO,cAAA,CAAgB,IAAK,CAAA,CAG7D,IAAMQ,CAAAA,CAAWJ,CAAAA,CAAiB5C,CAAK,CAAA,CAEvC,GAAIgD,CAAAA,GAAa,EAAA,CACf,OAAO,CAAE,KAAA,CAAO,IAAA,CAAM,OAAA,CAAS,MAAO,cAAA,CAAgB,KAAM,CAAA,CAG9D,GAAIA,CAAAA,GAAa,GAAA,CAEf,OAAO,CAAE,KAAA,CAAO,IAAA,CAAM,OAAA,CAAS,KAAA,CAAO,cAAA,CAAgBT,CAAc,CAAA,CAItE,GAAI,CAAC,eAAA,CAAgB,IAAA,CAAKS,CAAQ,CAAA,CAChC,OAAO,CAAE,KAAA,CAAO,IAAA,CAAM,OAAA,CAAS,KAAA,CAAO,cAAA,CAAgB,KAAM,CAAA,CAG9D,GAAI,CAACT,CAAAA,EAAiBS,EAAS,UAAA,CAAW,GAAG,CAAA,CAC3C,OAAO,CAAE,KAAA,CAAO,IAAA,CAAM,OAAA,CAAS,KAAA,CAAO,cAAA,CAAgB,KAAM,CAAA,CAG9D,GAAI,CAACR,CAAAA,EAAgBQ,CAAAA,CAAS,SAAS,GAAG,CAAA,CACxC,OAAO,CAAE,KAAA,CAAO,IAAA,CAAM,OAAA,CAAS,KAAA,CAAO,eAAgB,KAAM,CAAA,CAG9D,IAAMC,CAAAA,CAAI,MAAA,CAAO,UAAA,CAAWD,CAAQ,CAAA,CACpC,OAAK,MAAA,CAAO,QAAA,CAASC,CAAC,CAAA,CAIf,CAAE,KAAA,CAAOA,CAAAA,CAAG,OAAA,CAAS,IAAA,CAAM,cAAA,CAAgB,KAAM,CAAA,CAH/C,CAAE,KAAA,CAAO,IAAA,CAAM,OAAA,CAAS,MAAO,cAAA,CAAgB,KAAM,CAIhE,CAEA,SAASC,CAAAA,CAAelD,CAAAA,CAAwB,CAC9C,IAAMsC,CAAAA,CAAOX,CAAAA,EAAc,CAC3B,OAAOS,CAAAA,CAAkBpC,CAAAA,CAAOsC,CAAAA,CAAMC,EAAeC,CAAY,CACnE,CAEA,OAAO,CAAE,KAAA,CAAAO,CAAAA,CAAO,cAAA,CAAAG,CAAAA,CAAgB,aAAA,CAAAvB,CAAc,CAChD,CCrKA,SAASwB,CAAAA,CAAWlD,CAAAA,CAAYqC,EAA2B,CAGzD,OAFIrC,CAAAA,EAAM,GAAA,EAAOA,CAAAA,EAAM,GAAA,EACnBA,CAAAA,GAAOqC,CAAAA,CAAK,gBAAA,EACZrC,CAAAA,GAAOqC,CAAAA,CAAK,SAAA,EAAarC,CAAAA,GAAO,GAEtC,CAMA,SAASmD,EAAoBC,CAAAA,CAAaC,CAAAA,CAAgBhB,CAAAA,CAA0B,CAClF,IAAMiB,CAAAA,CAAaxD,CAAAA,CAAgBsD,CAAG,CAAA,CAClCG,CAAAA,CAAQ,CAAA,CACZ,IAAA,IAASC,CAAAA,CAAI,CAAA,CAAGA,CAAAA,CAAIH,CAAAA,EAAUG,EAAIF,CAAAA,CAAW,MAAA,CAAQE,CAAAA,EAAAA,CAC/CN,CAAAA,CAAWI,CAAAA,CAAWE,CAAC,CAAA,CAAInB,CAAI,CAAA,EAAGkB,CAAAA,EAAAA,CAExC,OAAOA,CACT,CAiBO,SAASE,CAAAA,CAAiBC,CAAAA,CAAwBrB,EAAiC,CACxF,IAAMsB,CAAAA,CAAMD,CAAAA,CAAe,MAAA,CACrBE,CAAAA,CAA0B,IAAI,KAAA,CAAMD,CAAAA,CAAM,CAAC,CAAA,CAAE,IAAA,CAAK,IAAI,CAAA,CAE5D,IAAA,IAASH,CAAAA,CAAI,EAAGA,CAAAA,CAAIG,CAAAA,CAAKH,CAAAA,EAAAA,CACZE,CAAAA,CAAeF,CAAC,CAAA,GAChBnB,CAAAA,CAAK,iBAAA,GAEduB,EAASJ,CAAAA,CAAI,CAAC,CAAA,CAAI,KAAA,CAAA,CAKtB,OAAAI,CAAAA,CAAS,CAAC,CAAA,CAAI,KACdA,CAAAA,CAASD,CAAG,CAAA,CAAI,IAAA,CAETC,CACT,CAqBO,SAASC,CAAAA,CACdC,CAAAA,CACAC,CAAAA,CACAC,CAAAA,CACA3B,CAAAA,CACA4B,CAAAA,CACQ,CACR,IAAMX,CAAAA,CAAaxD,EAAgBgE,CAAQ,CAAA,CAGvCI,CAAAA,CAAgBf,CAAAA,CAAoBG,CAAAA,CAAYS,CAAAA,CAAW1B,CAAI,CAAA,CAIjE4B,CAAAA,GAAc,uBAAA,EACdF,CAAAA,CAAY,CAAA,EACZD,CAAAA,CAASC,CAAAA,CAAY,CAAC,CAAA,GAAM1B,EAAK,iBAAA,GAGjC6B,CAAAA,CAAgB,IAAA,CAAK,GAAA,CAAI,CAAA,CAAGA,CAAAA,CAAgB,CAAC,CAAA,CAAA,CAI/C,IAAMN,CAAAA,CAAWH,CAAAA,CAAiBO,CAAAA,CAAc3B,CAAI,CAAA,CAC9C8B,CAAAA,CAAUrE,CAAAA,CAAgBkE,CAAY,CAAA,CACxCT,CAAAA,CAAQ,CAAA,CACRa,CAAAA,CAAM,CAAA,CAEV,IAAA,IAASZ,CAAAA,CAAI,CAAA,CAAGA,CAAAA,CAAIW,CAAAA,CAAQ,MAAA,CAAQX,CAAAA,EAAAA,CAAK,CACvC,GAAID,CAAAA,GAAUW,CAAAA,CAAe,CAC3BE,CAAAA,CAAMZ,CAAAA,CACN,KACF,CACIN,CAAAA,CAAWiB,CAAAA,CAAQX,CAAC,CAAA,CAAInB,CAAI,CAAA,EAAGkB,CAAAA,EAAAA,CACnCa,CAAAA,CAAMZ,CAAAA,CAAI,EACZ,CAKA,OAAIU,EAAgB,CAAA,EAAKX,CAAAA,CAAQW,CAAAA,GAC/BE,CAAAA,CAAMJ,CAAAA,CAAa,MAAA,CAAA,CAIrBI,CAAAA,CAAMC,CAAAA,CAAeD,CAAAA,CAAKR,CAAQ,CAAA,CAE3BQ,CACT,CAMA,SAASC,CAAAA,CAAeD,CAAAA,CAAaR,EAAiC,CACpE,GAAIA,CAAAA,CAASQ,CAAG,CAAA,CAAG,OAAOA,CAAAA,CAG1B,IAAA,IAASZ,CAAAA,CAAIY,CAAAA,CAAM,CAAA,CAAGZ,CAAAA,CAAII,CAAAA,CAAS,MAAA,CAAQJ,CAAAA,EAAAA,CACzC,GAAII,EAASJ,CAAC,CAAA,CAAG,OAAOA,CAAAA,CAG1B,IAAA,IAASA,CAAAA,CAAIY,CAAAA,CAAM,CAAA,CAAGZ,GAAK,CAAA,CAAGA,CAAAA,EAAAA,CAC5B,GAAII,CAAAA,CAASJ,CAAC,CAAA,CAAG,OAAOA,CAAAA,CAE1B,OAAO,CACT","file":"core.js","sourcesContent":["/**\n * Format presets — named Intl.NumberFormatOptions configurations for common\n * number input patterns. Use these as the `formatOptions` prop value.\n *\n * @example\n * import { presets } from 'raqam'\n * <NumberField.Root formatOptions={presets.currency('USD')} />\n * <NumberField.Root formatOptions={presets.percent} />\n * <NumberField.Root formatOptions={presets.compact} />\n */\n\nexport const presets = {\n  /** Currency with standard sign display. Shorthand for `{ style:'currency', currency:code }`. */\n  currency: (code: string): Intl.NumberFormatOptions => ({\n    style: \"currency\",\n    currency: code,\n  }),\n\n  /**\n   * Accounting currency — negatives shown as `(1,234.56)` instead of `-$1,234.56`.\n   * Requires the accounting format parser fix (built-in to raqam).\n   */\n  accounting: (code: string): Intl.NumberFormatOptions => ({\n    style: \"currency\",\n    currency: code,\n    currencySign: \"accounting\",\n  }),\n\n  /** Percentage — formats 0.42 as \"42%\" */\n  percent: { style: \"percent\" } as Intl.NumberFormatOptions,\n\n  /** Compact short — \"1.2K\", \"3.4M\" */\n  compact: { notation: \"compact\" } as Intl.NumberFormatOptions,\n\n  /** Compact long — \"1.2 thousand\", \"3.4 million\" */\n  compactLong: {\n    notation: \"compact\",\n    compactDisplay: \"long\",\n  } as Intl.NumberFormatOptions,\n\n  /** Scientific notation — \"1.234E3\" */\n  scientific: { notation: \"scientific\" } as Intl.NumberFormatOptions,\n\n  /** Engineering notation — exponents always multiples of 3 */\n  engineering: { notation: \"engineering\" } as Intl.NumberFormatOptions,\n\n  /** Integer — no decimal places */\n  integer: { maximumFractionDigits: 0 } as Intl.NumberFormatOptions,\n\n  /**\n   * Financial — always exactly 2 decimal places (fixed scale).\n   * Combine with `fixedDecimalScale` prop for strict display.\n   */\n  financial: {\n    minimumFractionDigits: 2,\n    maximumFractionDigits: 2,\n  } as Intl.NumberFormatOptions,\n\n  /**\n   * Unit — shorthand for `{ style:'unit', unit:unitCode }`.\n   * @example presets.unit('kilometer-per-hour') → { style:'unit', unit:'kilometer-per-hour' }\n   */\n  unit: (unit: string): Intl.NumberFormatOptions => ({\n    style: \"unit\",\n    unit,\n  }),\n} as const;\n","import type { DigitBlock } from \"./types.js\";\n\n// ── Built-in digit blocks ────────────────────────────────────────────────────\n// These cover the digit systems required by the spec.\n// Additional blocks can be registered via registerLocale().\n\nconst BUILTIN_DIGIT_BLOCKS: DigitBlock[] = [\n  [0x0660, 0x0669], // Arabic-Indic (arab)\n  [0x06f0, 0x06f9], // Extended Arabic-Indic / Persian (arabext)\n  [0x0966, 0x096f], // Devanagari / Hindi (deva)\n  [0x09e6, 0x09ef], // Bengali (beng)\n  [0x0e50, 0x0e59], // Thai (thai)\n];\n\n// Mutable registry — locale plugins can add blocks here\nconst registeredBlocks: DigitBlock[] = [...BUILTIN_DIGIT_BLOCKS];\n\n// ── Public API ────────────────────────────────────────────────────────────────\n\nexport interface LocaleConfig {\n  /** Extra digit block ranges to register */\n  digitBlocks?: DigitBlock[];\n}\n\n/**\n * Register additional digit blocks (called by locale plugins as a side effect).\n * Duplicate ranges are silently ignored.\n */\nexport function registerLocale(config: LocaleConfig): void {\n  if (!config.digitBlocks) return;\n  for (const block of config.digitBlocks) {\n    const already = registeredBlocks.some(([s]) => s === block[0]);\n    if (!already) registeredBlocks.push(block);\n  }\n}\n\n/**\n * Normalise any Unicode decimal digit in `input` to its ASCII equivalent (0–9).\n * Non-digit characters pass through unchanged.\n */\nexport function normalizeDigits(input: string): string {\n  // Fast path: if there are no non-ASCII chars, return as-is\n  if (!/[^\\u0020-\\u007e]/.test(input)) return input;\n\n  return input.replace(/\\p{Nd}/gu, (ch) => {\n    const code = ch.codePointAt(0)!;\n    for (const [start, end] of registeredBlocks) {\n      if (code >= start && code <= end) {\n        return String(code - start);\n      }\n    }\n    // Fallback: let JS try to parse it as a decimal digit\n    const digit = Number.parseInt(ch, 10);\n    return Number.isNaN(digit) ? ch : String(digit);\n  });\n}\n\n/**\n * Returns true if the character is a non-Latin Unicode decimal digit\n * (i.e. would need normalization).\n */\nexport function isNonLatinDigit(ch: string): boolean {\n  const code = ch.codePointAt(0);\n  if (code === undefined) return false;\n  if (code >= 0x30 && code <= 0x39) return false; // ASCII 0-9\n  for (const [start, end] of registeredBlocks) {\n    if (code >= start && code <= end) return true;\n  }\n  return false;\n}\n","import type { FormatResult, LocaleInfo } from \"./types.js\";\n\n// ── Internal ──────────────────────────────────────────────────────────────────\n\n/** Probe value that will surface decimal AND grouping parts */\nconst PROBE_VALUE = 12345.6;\n\n/** Cache key = locale + JSON.stringify(options) */\nconst formatterCache = new Map<string, Intl.NumberFormat>();\n\nfunction getFormatter(\n  locale: string | undefined,\n  options: Intl.NumberFormatOptions | undefined\n): Intl.NumberFormat {\n  const key = `${locale ?? \"\"}::${JSON.stringify(options ?? {})}`;\n  let fmt = formatterCache.get(key);\n  if (!fmt) {\n    fmt = new Intl.NumberFormat(locale, options);\n    formatterCache.set(key, fmt);\n  }\n  return fmt;\n}\n\n/** Extract locale meta from formatToParts — never hardcoded. */\nfunction extractLocaleInfo(\n  locale: string | undefined,\n  options: Intl.NumberFormatOptions | undefined\n): LocaleInfo {\n  const fmt = getFormatter(locale, options);\n  // Use a simple decimal number — we only need the separators\n  const parts = fmt.formatToParts(PROBE_VALUE);\n\n  let decimalSeparator = \".\";\n  let groupingSeparator = \",\";\n  let minusSign = \"-\";\n  let zero = \"0\";\n\n  for (const part of parts) {\n    if (part.type === \"decimal\") decimalSeparator = part.value;\n    if (part.type === \"group\") groupingSeparator = part.value;\n    if (part.type === \"minusSign\") minusSign = part.value;\n  }\n\n  // Detect locale zero digit\n  const zeroParts = fmt.formatToParts(0);\n  for (const part of zeroParts) {\n    if (part.type === \"integer\") {\n      zero = part.value;\n      break;\n    }\n  }\n\n  // RTL locales: Arabic / Hebrew / Persian / Urdu / Syriac etc.\n  const rtlLocales = /^(ar|he|fa|ur|syc|nqo|ug|yi)/i;\n  const resolvedLocale = fmt.resolvedOptions().locale;\n  const isRTL = rtlLocales.test(resolvedLocale);\n\n  return { decimalSeparator, groupingSeparator, minusSign, zero, isRTL };\n}\n\n// ── Factory ───────────────────────────────────────────────────────────────────\n\nexport interface FormatterOptions {\n  locale?: string;\n  formatOptions?: Intl.NumberFormatOptions;\n  prefix?: string;\n  suffix?: string;\n  minimumFractionDigits?: number;\n  maximumFractionDigits?: number;\n  fixedDecimalScale?: boolean;\n}\n\nexport interface Formatter {\n  format(value: number): string;\n  formatToParts(value: number): Intl.NumberFormatPart[];\n  getLocaleInfo(): LocaleInfo;\n  formatResult(value: number): FormatResult;\n}\n\n/**\n * Create a formatter instance. Intl.NumberFormat is cached — safe to call\n * on every render.\n */\nexport function createFormatter(opts: FormatterOptions): Formatter {\n  // Merge fraction digit overrides into formatOptions\n  const intlOptions: Intl.NumberFormatOptions = { ...opts.formatOptions };\n\n  if (opts.minimumFractionDigits !== undefined) {\n    intlOptions.minimumFractionDigits = opts.minimumFractionDigits;\n  }\n  if (opts.maximumFractionDigits !== undefined) {\n    intlOptions.maximumFractionDigits = opts.maximumFractionDigits;\n  }\n  if (opts.fixedDecimalScale && opts.maximumFractionDigits !== undefined) {\n    intlOptions.minimumFractionDigits = opts.maximumFractionDigits;\n    intlOptions.maximumFractionDigits = opts.maximumFractionDigits;\n  }\n\n  const intlFmt = getFormatter(opts.locale, intlOptions);\n  // Lazy — computed once on first call\n  let cachedLocaleInfo: LocaleInfo | null = null;\n\n  function getLocaleInfo(): LocaleInfo {\n    if (!cachedLocaleInfo) {\n      cachedLocaleInfo = extractLocaleInfo(opts.locale, intlOptions);\n    }\n    return cachedLocaleInfo;\n  }\n\n  function formatToParts(value: number): Intl.NumberFormatPart[] {\n    const parts = intlFmt.formatToParts(value);\n    if (!opts.prefix && !opts.suffix) return parts;\n\n    const result: Intl.NumberFormatPart[] = [];\n    if (opts.prefix) result.push({ type: \"literal\", value: opts.prefix });\n    result.push(...parts);\n    if (opts.suffix) result.push({ type: \"literal\", value: opts.suffix });\n    return result;\n  }\n\n  function format(value: number): string {\n    if (!Number.isFinite(value)) return \"\";\n    const formatted = intlFmt.format(value);\n    return (opts.prefix ?? \"\") + formatted + (opts.suffix ?? \"\");\n  }\n\n  function formatResult(value: number): FormatResult {\n    const parts = formatToParts(value);\n    const formatted = parts.map((p) => p.value).join(\"\");\n    return { formatted, parts };\n  }\n\n  return { format, formatToParts, getLocaleInfo, formatResult };\n}\n","import { createFormatter } from \"./formatter.js\";\nimport { normalizeDigits } from \"./normalizer.js\";\nimport type { LocaleInfo, ParseResult } from \"./types.js\";\n\n// ── Helpers ───────────────────────────────────────────────────────────────────\n\n/**\n * Escape a string so it can be used literally inside a RegExp.\n */\nfunction escapeRegex(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Returns true if `s` represents a valid-but-incomplete number:\n *   \"-\"       lone minus\n *   \"1.\"      trailing decimal separator (any locale)\n *   \"1.0\"     trailing zero after decimal\n *   \"1.00\"    etc.\n *\n * These should NOT be reformatted while the user is still typing.\n */\nfunction checkIntermediate(\n  normalized: string,\n  info: LocaleInfo,\n  allowNegative: boolean,\n  allowDecimal: boolean\n): boolean {\n  const dec = escapeRegex(info.decimalSeparator);\n  const minus = escapeRegex(info.minusSign);\n\n  // Lone minus sign\n  if (allowNegative && (normalized === \"-\" || normalized === info.minusSign)) {\n    return true;\n  }\n  // Trailing decimal separator\n  if (allowDecimal && new RegExp(`^${minus}?\\\\d+${dec}$`).test(normalized)) {\n    return true;\n  }\n  // Trailing zeros after decimal  (e.g. \"1.0\", \"1.00\", \"-1.0\")\n  if (allowDecimal && new RegExp(`^${minus}?\\\\d+${dec}\\\\d*0+$`).test(normalized)) {\n    return true;\n  }\n  return false;\n}\n\n// ── Factory ───────────────────────────────────────────────────────────────────\n\nexport interface ParserOptions {\n  locale?: string;\n  formatOptions?: Intl.NumberFormatOptions;\n  allowNegative?: boolean;\n  allowDecimal?: boolean;\n  prefix?: string;\n  suffix?: string;\n}\n\nexport interface Parser {\n  parse(input: string): ParseResult;\n  isIntermediate(input: string): boolean;\n  getLocaleInfo(): LocaleInfo;\n}\n\n/**\n * Create a locale-aware parser. Separator characters are extracted from\n * Intl.NumberFormat — never hardcoded.\n */\nexport function createParser(opts: ParserOptions = {}): Parser {\n  const allowNegative = opts.allowNegative ?? true;\n  const allowDecimal = opts.allowDecimal ?? true;\n\n  // Re-use the formatter to get locale info\n  const fmt = createFormatter({\n    locale: opts.locale,\n    formatOptions: opts.formatOptions,\n    prefix: opts.prefix,\n    suffix: opts.suffix,\n  });\n\n  function getLocaleInfo(): LocaleInfo {\n    return fmt.getLocaleInfo();\n  }\n\n  function stripAffordances(raw: string): string {\n    const info = getLocaleInfo();\n\n    // 1. Normalise non-Latin digits to ASCII\n    let s = normalizeDigits(raw);\n\n    // 2. Accounting format: \"(1,234.56)\" or \"($1,234.56)\" → negative\n    // Intl.NumberFormat with currencySign:\"accounting\" wraps negatives in parens\n    const accountingMatch = s.match(/^\\((.+)\\)$/);\n    if (accountingMatch) {\n      s = `-${accountingMatch[1]}`;\n    }\n\n    // 3. Strip prefix / suffix\n    if (opts.prefix && s.startsWith(opts.prefix)) {\n      s = s.slice(opts.prefix.length);\n    }\n    if (opts.suffix && s.endsWith(opts.suffix)) {\n      s = s.slice(0, -opts.suffix.length);\n    }\n\n    // 4. Strip grouping separators  (escape special chars)\n    if (info.groupingSeparator) {\n      s = s.split(info.groupingSeparator).join(\"\");\n    }\n\n    // 5. Replace locale decimal separator with ASCII \".\"\n    if (info.decimalSeparator !== \".\") {\n      s = s.split(info.decimalSeparator).join(\".\");\n    }\n\n    // 6. Replace locale minus sign with ASCII \"-\"\n    if (info.minusSign !== \"-\") {\n      s = s.split(info.minusSign).join(\"-\");\n    }\n\n    // 7. Strip currency symbol, percent sign, spaces that Intl might prepend/append\n    // Strip any remaining non-numeric chars except digits, \".\", \"-\"\n    // (handles currency prefixes/suffixes from Intl)\n    s = s.replace(/[^\\d.\\-]/g, \"\").trim();\n\n    return s;\n  }\n\n  function parse(input: string): ParseResult {\n    if (!input || input.trim() === \"\") {\n      return { value: null, isValid: false, isIntermediate: false };\n    }\n\n    const info = getLocaleInfo();\n\n    // Check for intermediate state before stripping\n    if (checkIntermediate(input, info, allowNegative, allowDecimal)) {\n      return { value: null, isValid: false, isIntermediate: true };\n    }\n\n    const stripped = stripAffordances(input);\n\n    if (stripped === \"\") {\n      return { value: null, isValid: false, isIntermediate: false };\n    }\n\n    if (stripped === \"-\") {\n      // Lone minus after stripping — only intermediate if negatives are allowed\n      return { value: null, isValid: false, isIntermediate: allowNegative };\n    }\n\n    // Reject if not a valid numeric string\n    if (!/^-?\\d+\\.?\\d*$/.test(stripped)) {\n      return { value: null, isValid: false, isIntermediate: false };\n    }\n\n    if (!allowNegative && stripped.startsWith(\"-\")) {\n      return { value: null, isValid: false, isIntermediate: false };\n    }\n\n    if (!allowDecimal && stripped.includes(\".\")) {\n      return { value: null, isValid: false, isIntermediate: false };\n    }\n\n    const n = Number.parseFloat(stripped);\n    if (!Number.isFinite(n)) {\n      return { value: null, isValid: false, isIntermediate: false };\n    }\n\n    return { value: n, isValid: true, isIntermediate: false };\n  }\n\n  function isIntermediate(input: string): boolean {\n    const info = getLocaleInfo();\n    return checkIntermediate(input, info, allowNegative, allowDecimal);\n  }\n\n  return { parse, isIntermediate, getLocaleInfo };\n}\n","import { normalizeDigits } from \"./normalizer.js\";\nimport type { CaretBoundary, LocaleInfo } from \"./types.js\";\n\n// ── Accepted-character helpers ────────────────────────────────────────────────\n\n/**\n * Returns true if `ch` is an \"accepted\" character — one that the user typed\n * intentionally and that contributes to the numeric value:\n *   - ASCII digit 0-9\n *   - The locale decimal separator\n *   - The locale minus sign\n */\nfunction isAccepted(ch: string, info: LocaleInfo): boolean {\n  if (ch >= \"0\" && ch <= \"9\") return true;\n  if (ch === info.decimalSeparator) return true;\n  if (ch === info.minusSign || ch === \"-\") return true;\n  return false;\n}\n\n/**\n * Count how many \"accepted\" characters appear before position `cursor`\n * in `str` (after normalising non-Latin digits to ASCII).\n */\nfunction countAcceptedBefore(str: string, cursor: number, info: LocaleInfo): number {\n  const normalised = normalizeDigits(str);\n  let count = 0;\n  for (let i = 0; i < cursor && i < normalised.length; i++) {\n    if (isAccepted(normalised[i]!, info)) count++;\n  }\n  return count;\n}\n\n// ── Caret boundary ────────────────────────────────────────────────────────────\n\n/**\n * Build a boolean array of length `formattedValue.length + 1`.\n * `true`  → cursor may rest at this position.\n * `false` → cursor must snap away (sits inside a formatting-only character\n *            such as a grouping separator or a currency prefix).\n *\n * Rules:\n *  - Start and end positions are always valid.\n *  - A position immediately AFTER a grouping separator is invalid (the\n *    cursor would look like it's between two digits but moving left would\n *    skip the comma).\n *  - A position immediately BEFORE a grouping separator is valid.\n */\nexport function getCaretBoundary(formattedValue: string, info: LocaleInfo): CaretBoundary {\n  const len = formattedValue.length;\n  const boundary: CaretBoundary = new Array(len + 1).fill(true) as boolean[];\n\n  for (let i = 0; i < len; i++) {\n    const ch = formattedValue[i]!;\n    if (ch === info.groupingSeparator) {\n      // Position immediately after the grouping separator is invalid\n      boundary[i + 1] = false;\n    }\n  }\n\n  // First and last are always valid\n  boundary[0] = true;\n  boundary[len] = true;\n\n  return boundary;\n}\n\n// ── Cursor computation ────────────────────────────────────────────────────────\n\n/**\n * Compute the new cursor position in `newFormatted` that corresponds\n * semantically to `oldCursor` in `oldInput`.\n *\n * Algorithm (3 stages from the spec):\n *\n * 1. Count accepted characters before `oldCursor` in `oldInput`.\n * 2. Adjust for backspace-over-separator edge case.\n * 3. Walk `newFormatted` to find the position where the same count of\n *    accepted chars precede it; snap to the nearest valid boundary.\n *\n * @param oldInput     The raw string the user just typed into (pre-format)\n * @param oldCursor    selectionStart captured from the native event\n * @param newFormatted The formatted string we're about to display\n * @param info         Locale separators\n * @param inputType    e.nativeEvent.inputType (optional — for backspace detection)\n */\nexport function computeNewCursorPosition(\n  oldInput: string,\n  oldCursor: number,\n  newFormatted: string,\n  info: LocaleInfo,\n  inputType?: string\n): number {\n  const normalised = normalizeDigits(oldInput);\n\n  // Stage 1: count accepted chars before cursor in old input\n  let acceptedCount = countAcceptedBefore(normalised, oldCursor, info);\n\n  // Stage 2: backspace on grouping separator — also delete the preceding digit\n  if (\n    inputType === \"deleteContentBackward\" &&\n    oldCursor > 0 &&\n    oldInput[oldCursor - 1] === info.groupingSeparator\n  ) {\n    // The separator was deleted but we want to remove the preceding digit too\n    acceptedCount = Math.max(0, acceptedCount - 1);\n  }\n\n  // Stage 3: build boundary and walk new formatted string\n  const boundary = getCaretBoundary(newFormatted, info);\n  const normNew = normalizeDigits(newFormatted);\n  let count = 0;\n  let pos = 0;\n\n  for (let i = 0; i < normNew.length; i++) {\n    if (count === acceptedCount) {\n      pos = i;\n      break;\n    }\n    if (isAccepted(normNew[i]!, info)) count++;\n    pos = i + 1;\n  }\n\n  // If we ran through the entire string without reaching the target count,\n  // place the cursor at the end. Note: acceptedCount === 0 means we correctly\n  // want pos = 0 (set in the loop), so we must NOT override that case.\n  if (acceptedCount > 0 && count < acceptedCount) {\n    pos = newFormatted.length;\n  }\n\n  // Snap to nearest valid boundary\n  pos = snapToBoundary(pos, boundary);\n\n  return pos;\n}\n\n/**\n * If `pos` is at a false (invalid) boundary position, find the nearest\n * true position. Prefers moving forward; falls back to backward.\n */\nfunction snapToBoundary(pos: number, boundary: CaretBoundary): number {\n  if (boundary[pos]) return pos;\n\n  // Try forward first\n  for (let i = pos + 1; i < boundary.length; i++) {\n    if (boundary[i]) return i;\n  }\n  // Fall back to backward\n  for (let i = pos - 1; i >= 0; i--) {\n    if (boundary[i]) return i;\n  }\n  return 0;\n}\n"]}