number-flow-react-native 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Antonín Wingender
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+<p align="center">
+  <img src="https://github.com/Rednegniw/number-flow-react-native/raw/main/.github/assets/demo.gif" alt="number-flow-react-native demo" width="300" />
+</p>
+
+<h1 align="center">number-flow-react-native</h1>
+
+<p align="center">
+  An animated number component for React Native.
+  <br />
+  Inspired by <a href="https://number-flow.barvian.me/">NumberFlow</a>.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/number-flow-react-native"><img src="https://img.shields.io/npm/v/number-flow-react-native" alt="npm version" /></a>
+  <a href="https://github.com/Rednegniw/number-flow-react-native/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/number-flow-react-native" alt="license" /></a>
+</p>
+
+---
+
+For full documentation, visit **[DOCS_URL](DOCS_URL)**.
+
+## Quick start
+
+```bash
+npm install number-flow-react-native react-native-reanimated
+```
+
+```tsx
+import { NumberFlow } from "number-flow-react-native/native";
+
+<NumberFlow
+  value={1234.56}
+  format={{ style: "currency", currency: "USD" }}
+  style={{ fontSize: 32, color: "#000" }}
+/>;
+```
+
+## Attribution
+
+This library is a React Native reimplementation inspired by [NumberFlow](https://number-flow.barvian.me/) by [Maxwell Barvian](https://github.com/barvian). The animation patterns, easing curves, and digit-rolling approach are adapted from the original web implementation. All code is original — no source code is shared.
+
+## License
+
+MIT

package/lib/module/core/constants.js

@@ -0,0 +1,21 @@
+"use strict";
+
+export const MAX_SLOTS = 20;
+export const DIGIT_COUNT = 10;
+
+// Fallback character set for glyph measurement when the actual format characters are unknown
+export const MEASURABLE_CHARS = "0123456789.,%+-$/:! €£¥₩abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ~°";
+
+/**
+ * Horizontal mask fade width as a ratio of lineHeight.
+ * Matches web NumberFlow's --number-flow-mask-width: 0.5em
+ */
+export const MASK_WIDTH_RATIO = 0.5;
+
+/**
+ * Superscript exponent rendering scale derived from OpenType font metrics.
+ * Inter font OS/2 table: ySuperscriptYSize = 1229/2048 ≈ 0.60.
+ * Consistent with TeX (\defaultscriptratio=0.7) and general typography convention (60-70%).
+ */
+export const SUPERSCRIPT_SCALE = 0.6;
+//# sourceMappingURL=constants.js.map

package/lib/module/core/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MAX_SLOTS","DIGIT_COUNT","MEASURABLE_CHARS","MASK_WIDTH_RATIO","SUPERSCRIPT_SCALE"],"sourceRoot":"../../../src","sources":["core/constants.ts"],"mappings":";;AAAA,OAAO,MAAMA,SAAS,GAAG,EAAE;AAE3B,OAAO,MAAMC,WAAW,GAAG,EAAE;;AAE7B;AACA,OAAO,MAAMC,gBAAgB,GAC3B,gFAAgF;;AAElF;AACA;AACA;AACA;AACA,OAAO,MAAMC,gBAAgB,GAAG,GAAG;;AAEnC;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,iBAAiB,GAAG,GAAG","ignoreList":[]}

package/lib/module/core/intlHelpers.js

@@ -0,0 +1,310 @@
+"use strict";
+
+import { MEASURABLE_CHARS } from "./constants.js";
+import { detectNumberingSystem, detectOutputZeroCodePoint, getDigitStrings, getZeroCodePoint, isLocaleDigit } from "./numerals/index.js";
+
+/**
+ * Avoids expensive new Intl.NumberFormat() on every render when callers pass
+ * inline format objects (which create new references each render).
+ */
+const formatterCache = new Map();
+export function getOrCreateFormatter(locales, format) {
+  const key = JSON.stringify([locales, format]);
+  let cached = formatterCache.get(key);
+  if (!cached) {
+    cached = new Intl.NumberFormat(locales, format);
+    formatterCache.set(key, cached);
+  }
+  return cached;
+}
+
+/**
+ * Probes the formatter with a sample number that exercises group separators,
+ * decimal separator, and currency/percent symbols. Returns only characters NOT
+ * already in MEASURABLE_CHARS — this keeps the result stable across different
+ * prefix/suffix combinations and prevents native measurement cache invalidation.
+ */
+const formatCharsCache = new Map();
+export function getFormatCharacters(locales, format, prefix = "", suffix = "") {
+  const key = JSON.stringify([locales, format, prefix, suffix]);
+  const cached = formatCharsCache.get(key);
+  if (cached !== undefined) return cached;
+  const formatter = getOrCreateFormatter(locales, format);
+  const numberingSystem = detectNumberingSystem(locales, format);
+  const zeroCP = getZeroCodePoint(numberingSystem);
+
+  // Sample that exercises: group separators, decimal, sign, large integers
+  const probes = [1234567.89, -1234567.89];
+  const chars = new Set();
+  for (const probe of probes) {
+    for (const ch of formatter.format(probe)) {
+      const code = ch.charCodeAt(0);
+      // Skip digits in both Latin and the locale's numbering system
+      const isLatinDigit = code >= 48 && code <= 57;
+      const isLocale = isLocaleDigit(code, zeroCP);
+      if (!isLatinDigit && !isLocale) chars.add(ch);
+    }
+  }
+  // Scientific/engineering notation replaces E with ×10 in our display
+  if (format?.notation === "scientific" || format?.notation === "engineering") {
+    chars.add("\u00D7"); // × (multiplication sign)
+  }
+
+  // Add locale digit strings so they get measured
+  const digitStrings = getDigitStrings(numberingSystem);
+  for (const ds of digitStrings) chars.add(ds);
+
+  // Also include prefix/suffix chars.
+  for (const ch of prefix) chars.add(ch);
+  for (const ch of suffix) chars.add(ch);
+
+  /**
+   * Only return chars NOT already in MEASURABLE_CHARS — this keeps the result
+   * stable across prefix/suffix changes and avoids native measurement cache misses.
+   */
+  const result = Array.from(chars).filter(c => !MEASURABLE_CHARS.includes(c)).join("");
+  formatCharsCache.set(key, result);
+  return result;
+}
+const decimalSepCache = new Map();
+function detectDecimalSeparator(locales) {
+  const key = JSON.stringify(locales);
+  const cached = decimalSepCache.get(key);
+  if (cached) return cached;
+  let sep = ".";
+  try {
+    const fmt = new Intl.NumberFormat(locales, {
+      minimumFractionDigits: 1,
+      maximumFractionDigits: 1,
+      useGrouping: false
+    });
+    const str = fmt.format(1.5);
+    const zeroCP = detectOutputZeroCodePoint(str);
+    for (const ch of str) {
+      const code = ch.charCodeAt(0);
+      if (!isLocaleDigit(code, zeroCP) && !(code >= 48 && code <= 57)) {
+        sep = ch;
+        break;
+      }
+    }
+  } catch {}
+  decimalSepCache.set(key, sep);
+  return sep;
+}
+
+/**
+ * Parses the mantissa portion of a formatted number string into typed parts.
+ * Handles integer digits, fraction digits, decimal separators, signs, and group separators.
+ */
+function parseMantissa(mantissa, decimalSep, parts, zeroCodePoint = 48) {
+  /**
+   * Search from right — in some locales the decimal sep char is also
+   * used as a group separator, so leftmost match could be wrong.
+   */
+  let decimalPos = -1;
+  for (let i = mantissa.length - 1; i >= 0; i--) {
+    if (mantissa[i] === decimalSep) {
+      let hasDigitAfter = false;
+      for (let j = i + 1; j < mantissa.length; j++) {
+        if (isLocaleDigit(mantissa[j].charCodeAt(0), zeroCodePoint)) {
+          hasDigitAfter = true;
+          break;
+        }
+      }
+      if (hasDigitAfter) {
+        decimalPos = i;
+        break;
+      }
+    }
+  }
+  let buf = "";
+  let inFraction = false;
+  const flush = () => {
+    if (buf) {
+      parts.push({
+        type: inFraction ? "fraction" : "integer",
+        value: buf
+      });
+      buf = "";
+    }
+  };
+  for (let i = 0; i < mantissa.length; i++) {
+    const ch = mantissa[i];
+    if (i === decimalPos) {
+      flush();
+      parts.push({
+        type: "decimal",
+        value: ch
+      });
+      inFraction = true;
+      continue;
+    }
+    if (isLocaleDigit(ch.charCodeAt(0), zeroCodePoint)) {
+      buf += ch;
+    } else if (ch === "-") {
+      flush();
+      parts.push({
+        type: "minusSign",
+        value: ch
+      });
+    } else if (ch === "+") {
+      flush();
+      parts.push({
+        type: "plusSign",
+        value: ch
+      });
+    } else if (!inFraction) {
+      flush();
+      const prevDigit = i > 0 && isLocaleDigit(mantissa[i - 1].charCodeAt(0), zeroCodePoint);
+      const nextDigit = i < mantissa.length - 1 && isLocaleDigit(mantissa[i + 1].charCodeAt(0), zeroCodePoint);
+      parts.push({
+        type: prevDigit && nextDigit ? "group" : "literal",
+        value: ch
+      });
+    } else {
+      flush();
+      parts.push({
+        type: "literal",
+        value: ch
+      });
+    }
+  }
+  flush();
+}
+
+/**
+ * Parses a formatted number string (with optional E exponent) into typed parts.
+ * Separated from fallbackFormatToParts so it can be reused for polyfill strings.
+ */
+function parseNumberString(formatted, decimalSep, zeroCodePoint = 48) {
+  // Detect exponent separator (E or e) — split into mantissa + exponent
+  let exponentPos = -1;
+  for (let i = 0; i < formatted.length; i++) {
+    if (formatted[i] === "E" || formatted[i] === "e") {
+      exponentPos = i;
+      break;
+    }
+  }
+  const mantissa = exponentPos >= 0 ? formatted.slice(0, exponentPos) : formatted;
+  const parts = [];
+  parseMantissa(mantissa, decimalSep, parts, zeroCodePoint);
+  if (exponentPos >= 0) {
+    parts.push({
+      type: "exponentSeparator",
+      value: formatted[exponentPos]
+    });
+    let expBuf = "";
+    for (let i = exponentPos + 1; i < formatted.length; i++) {
+      const ch = formatted[i];
+      if (ch === "-") {
+        parts.push({
+          type: "exponentMinusSign",
+          value: ch
+        });
+      } else if (ch === "+") {
+        parts.push({
+          type: "exponentPlusSign",
+          value: ch
+        });
+      } else if (isLocaleDigit(ch.charCodeAt(0), zeroCodePoint)) {
+        expBuf += ch;
+      }
+    }
+    if (expBuf) {
+      parts.push({
+        type: "exponentInteger",
+        value: expBuf
+      });
+    }
+  }
+  return parts;
+}
+
+/**
+ * Hermes has Intl.NumberFormat but may lack formatToParts(). This fallback
+ * uses format() and parses the resulting string into typed parts.
+ */
+function fallbackFormatToParts(formatter, value, locales) {
+  const formatted = formatter.format(value);
+  const zeroCp = detectOutputZeroCodePoint(formatted);
+  return parseNumberString(formatted, detectDecimalSeparator(locales), zeroCp);
+}
+
+/**
+ * Manually computes an engineering notation string for values where the
+ * platform's Intl.NumberFormat doesn't support notation: "engineering"
+ * (notably iOS Hermes, which uses NSNumberFormatter under the hood).
+ *
+ * Engineering notation: exponent is always a multiple of 3, mantissa has 1-3 integer digits.
+ */
+function computeEngineeringString(value, resolved) {
+  if (value === 0) return "0E0";
+  const negative = value < 0;
+  const abs = Math.abs(value);
+  const logFloor = Math.floor(Math.log10(abs));
+  const exp = 3 * Math.floor(logFloor / 3);
+  const mantissa = abs / 10 ** exp;
+  const maxFrac = resolved.maximumFractionDigits ?? 0;
+  const minFrac = resolved.minimumFractionDigits ?? 0;
+  let mantissaStr = mantissa.toFixed(maxFrac);
+
+  // Trim trailing zeros beyond minFrac
+  const dotIdx = mantissaStr.indexOf(".");
+  if (dotIdx >= 0) {
+    let end = mantissaStr.length;
+    const minEnd = dotIdx + 1 + minFrac;
+    while (end > minEnd && mantissaStr[end - 1] === "0") {
+      end--;
+    }
+
+    // Remove the dot if no fraction digits remain
+    if (end <= dotIdx + 1 && minFrac === 0) {
+      end = dotIdx;
+    }
+    mantissaStr = mantissaStr.slice(0, end);
+  }
+  const sign = negative ? "-" : "";
+  return `${sign}${mantissaStr}E${exp}`;
+}
+
+/**
+ * Safe wrapper around formatToParts that handles:
+ * 1. Missing formatToParts (Hermes fallback)
+ * 2. Broken formatToParts that returns all "literal" parts (non-Latin locales on Hermes)
+ * 3. Missing engineering notation support (iOS Hermes)
+ */
+export function safeFormatToParts(formatter, value, locales) {
+  let parts;
+  if (typeof formatter.formatToParts === "function") {
+    parts = formatter.formatToParts(value);
+
+    /**
+     * Hermes may return formatToParts with all parts as "literal" for
+     * non-Latin locales, or misclassify digit characters. Validate that
+     * at least one "integer" or "fraction" part exists for non-zero values.
+     * If not, fall back to our manual parser which detects digits by codepoint.
+     */
+    if (value !== 0) {
+      const hasDigitParts = parts.some(p => p.type === "integer" || p.type === "fraction");
+      if (!hasDigitParts) {
+        parts = fallbackFormatToParts(formatter, value, locales);
+      }
+    }
+  } else {
+    parts = fallbackFormatToParts(formatter, value, locales);
+  }
+
+  // iOS Hermes uses NSNumberFormatter which doesn't support engineering notation.
+  // It silently falls back to decimal formatting, producing no exponent parts.
+  // Detect this and manually compute the engineering representation.
+  const hasExponent = parts.some(p => p.type === "exponentSeparator");
+  if (!hasExponent && Number.isFinite(value)) {
+    const notation = formatter.resolvedOptions().notation;
+    if (notation === "engineering") {
+      const str = computeEngineeringString(value, formatter.resolvedOptions());
+      return parseNumberString(str, ".");
+    }
+  }
+  return parts;
+}
+//# sourceMappingURL=intlHelpers.js.map

package/lib/module/core/intlHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MEASURABLE_CHARS","detectNumberingSystem","detectOutputZeroCodePoint","getDigitStrings","getZeroCodePoint","isLocaleDigit","formatterCache","Map","getOrCreateFormatter","locales","format","key","JSON","stringify","cached","get","Intl","NumberFormat","set","formatCharsCache","getFormatCharacters","prefix","suffix","undefined","formatter","numberingSystem","zeroCP","probes","chars","Set","probe","ch","code","charCodeAt","isLatinDigit","isLocale","add","notation","digitStrings","ds","result","Array","from","filter","c","includes","join","decimalSepCache","detectDecimalSeparator","sep","fmt","minimumFractionDigits","maximumFractionDigits","useGrouping","str","parseMantissa","mantissa","decimalSep","parts","zeroCodePoint","decimalPos","i","length","hasDigitAfter","j","buf","inFraction","flush","push","type","value","prevDigit","nextDigit","parseNumberString","formatted","exponentPos","slice","expBuf","fallbackFormatToParts","zeroCp","computeEngineeringString","resolved","negative","abs","Math","logFloor","floor","log10","exp","maxFrac","minFrac","mantissaStr","toFixed","dotIdx","indexOf","end","minEnd","sign","safeFormatToParts","formatToParts","hasDigitParts","some","p","hasExponent","Number","isFinite","resolvedOptions"],"sourceRoot":"../../../src","sources":["core/intlHelpers.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/core/layout.js

@@ -0,0 +1,71 @@
+"use strict";
+
+import { SUPERSCRIPT_SCALE } from "./constants.js";
+import { isDigitChar, localeDigitValue } from "./numerals/index.js";
+
+/**
+ * Assigns x positions to each entry based on text alignment.
+ * Mutates the `x` field of each entry in place.
+ * Worklet-safe. When `precomputedContentWidth` is provided, skips the sum loop.
+ */
+export function assignXPositions(chars, totalWidth, textAlign, precomputedContentWidth) {
+  "worklet";
+
+  let contentWidth = precomputedContentWidth ?? 0;
+  if (precomputedContentWidth === undefined) {
+    for (const entry of chars) contentWidth += entry.width;
+  }
+  let startX = 0;
+  if (textAlign === "right") startX = totalWidth - contentWidth;else if (textAlign === "center") startX = (totalWidth - contentWidth) / 2;
+  let currentX = startX;
+  for (const entry of chars) {
+    entry.x = currentX;
+    currentX += entry.width;
+  }
+}
+export function computeKeyedLayout(parts, metrics, totalWidth, textAlign, localeDigitStrings) {
+  const chars = [];
+  for (const part of parts) {
+    const isSuperscript = part.key.startsWith("exponentInteger:") || part.key.startsWith("exponentSign:");
+
+    // For digit parts, look up the width of the locale digit character
+    // (what DigitSlot actually renders) rather than the format output character.
+    // On Hermes, format() may output Latin "4" but DigitSlot renders e.g. "四".
+    let displayChar = part.char;
+    if (part.type === "digit" && localeDigitStrings && part.digitValue >= 0) {
+      displayChar = localeDigitStrings[part.digitValue];
+    }
+    const rawWidth = metrics.charWidths[displayChar] ?? metrics.maxDigitWidth;
+    const width = isSuperscript ? rawWidth * SUPERSCRIPT_SCALE : rawWidth;
+    chars.push({
+      key: part.key,
+      char: part.char,
+      isDigit: part.type === "digit",
+      digitValue: part.digitValue,
+      x: 0,
+      width,
+      superscript: isSuperscript
+    });
+  }
+  assignXPositions(chars, totalWidth, textAlign);
+  return chars;
+}
+export function computeStringLayout(text, metrics, totalWidth, textAlign, zeroCodePoint = 48) {
+  const chars = [];
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const digit = isDigitChar(char, zeroCodePoint);
+    const width = metrics.charWidths[char] ?? metrics.maxDigitWidth;
+    chars.push({
+      key: `pos:${i}`,
+      char,
+      isDigit: digit,
+      digitValue: digit ? localeDigitValue(char.charCodeAt(0), zeroCodePoint) : -1,
+      x: 0,
+      width
+    });
+  }
+  assignXPositions(chars, totalWidth, textAlign);
+  return chars;
+}
+//# sourceMappingURL=layout.js.map

package/lib/module/core/layout.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SUPERSCRIPT_SCALE","isDigitChar","localeDigitValue","assignXPositions","chars","totalWidth","textAlign","precomputedContentWidth","contentWidth","undefined","entry","width","startX","currentX","x","computeKeyedLayout","parts","metrics","localeDigitStrings","part","isSuperscript","key","startsWith","displayChar","char","type","digitValue","rawWidth","charWidths","maxDigitWidth","push","isDigit","superscript","computeStringLayout","text","zeroCodePoint","i","length","digit","charCodeAt"],"sourceRoot":"../../../src","sources":["core/layout.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/core/mask.js

@@ -0,0 +1,50 @@
+"use strict";
+
+// Target gradient size as a ratio of lineHeight.
+// The gradient will be at least this tall, expanding the container if needed.
+const TARGET_GRADIENT_RATIO = 0.2;
+
+// Small inset so the gradient doesn't start right at the glyph boundary.
+const PADDING_PX = 2;
+/**
+ * Computes adaptive vertical mask heights based on the actual characters
+ * currently displayed.
+ *
+ * The gradient starts at the edge of the visible glyph content and extends
+ * outward. If the "dead zone" inside lineHeight is smaller than the target
+ * gradient size, the container expands beyond lineHeight.
+ */
+export function computeAdaptiveMaskHeights(layout, exitingEntries, metrics) {
+  let maxAscent = 0;
+  let maxDescent = 0;
+  const processChar = char => {
+    const bounds = metrics.charBounds[char];
+    if (!bounds) return;
+    if (bounds.top < maxAscent) maxAscent = bounds.top;
+    if (bounds.bottom > maxDescent) maxDescent = bounds.bottom;
+  };
+  for (const entry of layout) {
+    if (entry.superscript) continue;
+    processChar(entry.char);
+  }
+  for (const [, entry] of exitingEntries) {
+    if (entry.superscript) continue;
+    processChar(entry.char);
+  }
+  const targetGradient = TARGET_GRADIENT_RATIO * metrics.lineHeight;
+
+  // Dead zone: space within lineHeight not occupied by glyph content.
+  const deadZoneTop = Math.max(0, -metrics.ascent - -maxAscent - PADDING_PX);
+  const deadZoneBottom = Math.max(0, metrics.descent - maxDescent - PADDING_PX);
+
+  // If the dead zone is smaller than the target, expand the container.
+  const expansionTop = Math.max(0, targetGradient - deadZoneTop);
+  const expansionBottom = Math.max(0, targetGradient - deadZoneBottom);
+  return {
+    top: deadZoneTop + expansionTop,
+    bottom: deadZoneBottom + expansionBottom,
+    expansionTop,
+    expansionBottom
+  };
+}
+//# sourceMappingURL=mask.js.map

package/lib/module/core/mask.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TARGET_GRADIENT_RATIO","PADDING_PX","computeAdaptiveMaskHeights","layout","exitingEntries","metrics","maxAscent","maxDescent","processChar","char","bounds","charBounds","top","bottom","entry","superscript","targetGradient","lineHeight","deadZoneTop","Math","max","ascent","deadZoneBottom","descent","expansionTop","expansionBottom"],"sourceRoot":"../../../src","sources":["core/mask.ts"],"mappings":";;AAGA;AACA;AACA,MAAMA,qBAAqB,GAAG,GAAG;;AAEjC;AACA,MAAMC,UAAU,GAAG,CAAC;AAapB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,0BAA0BA,CACxCC,MAAoB,EACpBC,cAAuC,EACvCC,OAAqB,EACR;EACb,IAAIC,SAAS,GAAG,CAAC;EACjB,IAAIC,UAAU,GAAG,CAAC;EAElB,MAAMC,WAAW,GAAIC,IAAY,IAAK;IACpC,MAAMC,MAAM,GAAGL,OAAO,CAACM,UAAU,CAACF,IAAI,CAAC;IACvC,IAAI,CAACC,MAAM,EAAE;IAEb,IAAIA,MAAM,CAACE,GAAG,GAAGN,SAAS,EAAEA,SAAS,GAAGI,MAAM,CAACE,GAAG;IAClD,IAAIF,MAAM,CAACG,MAAM,GAAGN,UAAU,EAAEA,UAAU,GAAGG,MAAM,CAACG,MAAM;EAC5D,CAAC;EAED,KAAK,MAAMC,KAAK,IAAIX,MAAM,EAAE;IAC1B,IAAIW,KAAK,CAACC,WAAW,EAAE;IACvBP,WAAW,CAACM,KAAK,CAACL,IAAI,CAAC;EACzB;EAEA,KAAK,MAAM,GAAGK,KAAK,CAAC,IAAIV,cAAc,EAAE;IACtC,IAAIU,KAAK,CAACC,WAAW,EAAE;IACvBP,WAAW,CAACM,KAAK,CAACL,IAAI,CAAC;EACzB;EAEA,MAAMO,cAAc,GAAGhB,qBAAqB,GAAGK,OAAO,CAACY,UAAU;;EAEjE;EACA,MAAMC,WAAW,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAE,CAACf,OAAO,CAACgB,MAAM,GAAG,CAACf,SAAS,GAAGL,UAAU,CAAC;EAC1E,MAAMqB,cAAc,GAAGH,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEf,OAAO,CAACkB,OAAO,GAAGhB,UAAU,GAAGN,UAAU,CAAC;;EAE7E;EACA,MAAMuB,YAAY,GAAGL,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEJ,cAAc,GAAGE,WAAW,CAAC;EAC9D,MAAMO,eAAe,GAAGN,IAAI,CAACC,GAAG,CAAC,CAAC,EAAEJ,cAAc,GAAGM,cAAc,CAAC;EAEpE,OAAO;IACLV,GAAG,EAAEM,WAAW,GAAGM,YAAY;IAC/BX,MAAM,EAAES,cAAc,GAAGG,eAAe;IACxCD,YAAY;IACZC;EACF,CAAC;AACH","ignoreList":[]}

package/lib/module/core/numerals/detection.js

@@ -0,0 +1,105 @@
+"use strict";
+
+import { hanidecDigitValue } from "./digits.js";
+import { CLDR_DEFAULT_NUMBERING, HANIDEC_ZERO, LATIN_ZERO, ZERO_CODEPOINTS } from "./tables.js";
+const numberingSystemCache = new Map();
+
+/**
+ * Looks up the CLDR-expected numbering system for a locale.
+ * Checks explicit -u-nu- extension, then exact match (e.g. "ar-EG"),
+ * then language subtag (e.g. "ar").
+ * Returns undefined if the locale defaults to "latn".
+ */
+function getExpectedNumberingSystem(locales) {
+  if (!locales) return undefined;
+  const tag = String(locales);
+
+  // Parse explicit Unicode extension: "th-TH-u-nu-thai" → "thai"
+  const nuMatch = tag.match(/-u-nu-([a-z]+)/);
+  if (nuMatch) {
+    return nuMatch[1] === "latn" ? undefined : nuMatch[1];
+  }
+  const exact = CLDR_DEFAULT_NUMBERING[tag];
+  if (exact) return exact;
+
+  // Try language subtag only (strip region): "ar-EG" → "ar"
+  const dashIdx = tag.indexOf("-");
+  if (dashIdx > 0) {
+    return CLDR_DEFAULT_NUMBERING[tag.slice(0, dashIdx)];
+  }
+  return undefined;
+}
+
+/**
+ * Scans a formatted number string and detects which numbering system's
+ * digits are actually present. Returns the zero codepoint of the detected
+ * system, or LATIN_ZERO if only Latin digits (or no digits) are found.
+ *
+ * Handles hanidec (non-contiguous ideographs) separately from contiguous systems.
+ */
+export function detectOutputZeroCodePoint(formattedStr) {
+  for (let i = 0; i < formattedStr.length; i++) {
+    const code = formattedStr.charCodeAt(i);
+
+    // Skip Latin digits — we want to detect non-Latin systems
+    if (code >= LATIN_ZERO && code <= LATIN_ZERO + 9) continue;
+
+    // Check hanidec (non-contiguous codepoints)
+    if (hanidecDigitValue(code) >= 0) return HANIDEC_ZERO;
+
+    // Check all contiguous systems (skip latn and hanidec)
+    for (const system in ZERO_CODEPOINTS) {
+      if (system === "latn" || system === "hanidec") continue;
+      const zeroCp = ZERO_CODEPOINTS[system];
+      if (code >= zeroCp && code <= zeroCp + 9) return zeroCp;
+    }
+  }
+  return LATIN_ZERO;
+}
+
+/**
+ * Detects the numbering system for a locale/format combination.
+ *
+ * Strategy: query the platform first (resolvedOptions), then verify by
+ * formatting a probe. If the platform reports "latn" but the CLDR table
+ * says otherwise (common on Hermes), use the CLDR value.
+ */
+export function detectNumberingSystem(locales, format) {
+  const key = JSON.stringify([locales, format]);
+  const cached = numberingSystemCache.get(key);
+  if (cached) return cached;
+  const formatter = new Intl.NumberFormat(locales ?? undefined, format);
+  const platformSystem = formatter.resolvedOptions().numberingSystem;
+
+  // If the platform reports a known non-latn system, trust it
+  if (platformSystem && platformSystem !== "latn") {
+    numberingSystemCache.set(key, platformSystem);
+    return platformSystem;
+  }
+
+  // Platform says "latn" or undefined — check if the locale expects something else
+  const expected = getExpectedNumberingSystem(locales);
+  if (!expected) {
+    numberingSystemCache.set(key, "latn");
+    return "latn";
+  }
+
+  // Verify by checking the actual formatted output
+  const probe = formatter.format(1234567890);
+  const outputZeroCp = detectOutputZeroCodePoint(probe);
+  if (outputZeroCp !== LATIN_ZERO) {
+    // Platform does output non-Latin digits; find the matching system name
+    for (const system in ZERO_CODEPOINTS) {
+      if (ZERO_CODEPOINTS[system] === outputZeroCp) {
+        numberingSystemCache.set(key, system);
+        return system;
+      }
+    }
+  }
+
+  // Platform truly outputs Latin digits — use the CLDR expected system
+  // so digitStrings render the correct locale characters on the wheel
+  numberingSystemCache.set(key, expected);
+  return expected;
+}
+//# sourceMappingURL=detection.js.map