numora 3.0.2 → 3.2.0

package/README.md

@@ -3,281 +3,70 @@
 [![npm version](https://img.shields.io/npm/v/numora.svg)](https://www.npmjs.com/package/numora)
 [![npm downloads](https://img.shields.io/npm/dm/numora.svg)](https://www.npmjs.com/package/numora)
 
-A lightweight, framework-agnostic numeric input library for handling currency and decimal inputs in **financial/DeFi** applications. Built with TypeScript and designed for modern web applications with:
+A lightweight, framework-agnostic numeric input library. Zero dependencies, TypeScript-first.
 
-- **Zero dependencies** - minimal footprint for your bundle
-- **Type safety** - fully typed API for better developer experience
-- **Framework agnostic** - use with any framework or vanilla JavaScript
-- **Customizable** - extensive options to fit your specific needs
-
-## Demo
-
-Check out the [live demo](https://numora.xyz/) to see Numora in action.
-
-## Features
-
-| Feature | Description |
-|---------|-------------|
-| **⭐️ Zero Dependencies** | No external dependencies, minimal bundle size |
-| **⭐️ Framework Agnostic** | Works with any framework or vanilla JavaScript |
-| **Decimal Precision Control** | Configure minimum and maximum decimal places (`decimalMinLength`, `decimalMaxLength`) |
-| **Minimum Decimal Places** | Automatically pad values with zeros to ensure minimum decimal places (e.g., `"1"` with `decimalMinLength: 2` becomes `"1.00"`) |
-| **Thousand Separators** | Customizable thousand separators with multiple grouping styles (`Thousand`, `Lakh`, `Wan`, `None`) |
-| **Custom Decimal Separator** | Support for different decimal separators (e.g., `.` or `,`) |
-| **Format on Blur/Change** | Choose when to apply formatting: `on blur (clean editing)` or `on change (real-time)` |
-| **Compact Notation Expansion** | When enabled, expands compact notation during paste/setValue (e.g., `"1k"` → `"1000"`, `"1.5m"` → `"1500000"`, `"2B"` → `"2000000000"`) |
-| **Scientific Notation Expansion** | Always automatically expands scientific notation (e.g., `"1.5e-7"` → `"0.00000015"`, `"2e+5"` → `"200000"`) |
-| **Negative Number Support** | Optional support for negative numbers with `enableNegative` |
-| **Leading Zeros Support** | Control leading zero behavior with `enableLeadingZeros` |
-| **Raw Value Mode** | Get unformatted numeric values while displaying formatted values |
-| **Paste Event Handling** | Intelligent paste handling with automatic sanitization, formatting, and cursor positioning |
-| **Cursor Position Preservation** | Smart cursor positioning that works with thousand separators, even during formatting |
-| **Thousand Separator Skipping** | On delete/backspace, cursor automatically skips over thousand separators for better UX |
-| **Mobile Keyboard Optimization** | Automatic `inputmode="decimal"` for mobile numeric keyboards |
-| **Mobile Keyboard Filtering** | Automatically filters non-breaking spaces and Unicode whitespace artifacts from mobile keyboards |
-| **Non-numeric Character Filtering** | Automatic removal of invalid characters |
-| **Comma/Dot Conversion** | When `thousandStyle` is `None`, typing comma or dot automatically converts to the configured `decimalSeparator` |
-| **Character Equivalence** | Automatic conversion of commas to dots (or custom decimal separator) for easier input |
-| **Sanitization** | Comprehensive input sanitization for security and data integrity |
-| **TypeScript Support** | Full TypeScript definitions included |
-
-## Display Formatting Utilities
-
-Numora also exports utility functions for formatting numbers for display (outside of the input component):
-
-| Utility | Description | Example |
-|---------|-------------|---------|
-| `formatPercent` | Format decimal values as percentages | `formatPercent("0.01", 2)` → `"1.00%"` |
-| `formatLargePercent` | Format large percentages with scale notation (k, M, T, etc.) | `formatLargePercent("1000", 2)` → `"100000%"` |
-| `formatLargeNumber` | Format large numbers with scale notation | `formatLargeNumber("1234")` → `"1.23k"` |
-| `condenseDecimalZeros` | Condense leading decimal zeros to subscript notation | `condenseDecimalZeros("0.000001", 8)` → `"0₆1"` |
-
-These utilities use string arithmetic to avoid floating-point precision issues.
-
-## 📊 Comparison
-
-| Feature | Numora | react-number-format | Native Number Input |
-|---------|--------|---------------------|---------------------|
-| **Framework Support** | ✅ All frameworks | ❌ React only | ✅ All frameworks |
-| **Dependencies** | ✅ Zero | ⚠️ React required | ✅ Zero |
-| **Raw Value Mode** | ✅ Yes | ⚠️ Limited | ❌ No |
-| **Comma/Dot Conversion** | ✅ Yes | ⚠️ Limited | ❌ No |
-| **Scientific Notation** | ✅ Auto-expand | ❌ No | ❌ No |
-| **Display Formatting Utils** | ✅ Yes | ❌ No | ❌ No |
-| **Compact Notation** | ✅ Auto-expand | ❌ No | ❌ No |
-| **Mobile Support** | ✅ Yes | ✅ Yes | ⚠️ Limited |
-| **Decimal Precision Control** | ✅ Yes | ✅ Yes | ❌ Limited |
-| **Thousand Separators** | ✅ Customizable | ✅ Yes | ❌ No |
-| **Custom Decimal Separator** | ✅ Yes | ✅ Yes | ❌ No (always `.`) |
-| **Formatting Options** | ✅ Blur/Change modes | ✅ Multiple modes | ❌ No |
-| **Cursor Preservation** | ✅ Advanced | ✅ Basic | ❌ N/A |
-| **TypeScript Support** | ✅ Yes | ✅ Yes | ⚠️ Partial |
-| **Paste Handling** | ✅ Intelligent | ✅ Yes | ⚠️ Basic |
-| **Grouping Styles** | ✅ Thousand/Lakh/Wan | ✅ Thousand/Lakh/Wan | ❌ No |
-| **Leading Zeros Control** | ✅ Yes | ✅ Yes | ❌ No |
-
-## Installation
+## Install
 
 ```bash
 npm install numora
-# or
-bun add numora
-# or
-pnpm add numora
+# or pnpm add numora / bun add numora
 ```
 
 ## Usage
 
-### Basic Example
-
-```typescript
-import { NumoraInput } from 'numora';
-
-// Get the container element where you want to mount the input
-const container = document.querySelector('#my-input-container');
-
-// Create a new NumoraInput instance
-const numoraInput = new NumoraInput(container, {
-  decimalMaxLength: 2,
-  onChange: (value) => {
-    console.log('Value changed:', value);
-  },
-});
-```
-
-### Advanced Example
-
 ```typescript
 import { NumoraInput, FormatOn, ThousandStyle } from 'numora';
 
-const container = document.querySelector('#my-input-container');
-
-const numoraInput = new NumoraInput(container, {
-  // Decimal options
-  decimalMaxLength: 18,
-  decimalMinLength: 2, // Pads with zeros: "1" becomes "1.00"
-  decimalSeparator: '.',
-
-  // Thousand separator options
+const input = new NumoraInput(document.querySelector('#amount'), {
+  decimalMaxLength: 2,
+  decimalMinLength: 2,
   thousandSeparator: ',',
   thousandStyle: ThousandStyle.Thousand,
-  formatOn: FormatOn.Change, // or FormatOn.Blur
-
-  // Additional features
-  enableCompactNotation: true, // Expands "1k" → "1000" on paste/setValue
-  enableNegative: false,
-  enableLeadingZeros: false,
-  rawValueMode: true, // Get unformatted values in onChange
-
-  // Standard input properties
-  placeholder: 'Enter amount',
-  className: 'numora-input',
-
-  // Event handler
-  onChange: (value) => {
-    console.log('Raw value:', value); // Unformatted if rawValueMode is true
-    console.log('Display value:', numoraInput.value); // Formatted display value
-    console.log('As number:', numoraInput.valueAsNumber); // Parsed as number
-  },
-});
-```
-
-### Compact Notation Example
-
-```typescript
-import { NumoraInput } from 'numora';
-
-const container = document.querySelector('#my-input-container');
-
-const numoraInput = new NumoraInput(container, {
-  enableCompactNotation: true,
-  onChange: (value) => {
-    console.log('Value:', value);
-  },
-});
-
-// When user pastes "1.5k" or you call setValue("1.5k")
-// It automatically expands to "1500"
-numoraInput.setValue('1.5k'); // Display: "1,500" (if thousand separator enabled)
-```
-
-### Scientific Notation Example
-
-```typescript
-import { NumoraInput } from 'numora';
-
-const container = document.querySelector('#my-input-container');
-
-const numoraInput = new NumoraInput(container, {
-  decimalMaxLength: 18,
-  onChange: (value) => {
-    console.log('Value:', value);
-  },
-});
-
-// Scientific notation is ALWAYS automatically expanded
-// User can paste "1.5e-7" and it becomes "0.00000015"
-// User can paste "2e+5" and it becomes "200000"
-```
-
-### Comma/Dot Conversion Example
-
-```typescript
-import { NumoraInput, ThousandStyle } from 'numora';
-
-const container = document.querySelector('#my-input-container');
-
-const numoraInput = new NumoraInput(container, {
-  decimalSeparator: ',', // European format
-  thousandStyle: ThousandStyle.None, // Required for comma/dot conversion
-  decimalMaxLength: 2,
+  formatOn: FormatOn.Blur,
+  onChange: (value) => console.log(value),
 });
 
-// When thousandStyle is None:
-// - User types "." → automatically converted to ","
-// - User types "," → automatically converted to ","
-// This makes it easier for users without knowing the exact separator
+// Get / set value
+input.value = '1234.56';
+console.log(input.valueAsNumber); // 1234.56
 ```
 
-### Using Display Formatting Utilities
-
-```typescript
-import { formatPercent, formatLargePercent, formatLargeNumber, condenseDecimalZeros } from 'numora';
-
-// Format as percentage
-const percent = formatPercent('0.01', 2); // "1.00%"
-const largePercent = formatLargePercent('1000', 2); // "100000%"
-
-// Format large numbers with scale notation
-const large = formatLargeNumber('1234567'); // "1.23M"
-const small = formatLargeNumber('1234'); // "1.23k"
-
-// Condense decimal zeros
-const condensed = condenseDecimalZeros('0.000001', 8); // "0₆1"
-const condensed2 = condenseDecimalZeros('0.000123', 8); // "0₃123"
-```
-
-### Programmatic Value Control
-
-```typescript
-// Get the current value
-const currentValue = numoraInput.getValue();
-// or
-const currentValue = numoraInput.value;
-
-// Set a new value
-numoraInput.setValue('1234.56');
-// or
-numoraInput.value = '1234.56';
-
-// Set from a number
-numoraInput.valueAsNumber = 1234.56;
-
-// Get as a number
-const numericValue = numoraInput.valueAsNumber;
-
-// Enable/disable the input
-numoraInput.disable();
-numoraInput.enable();
+## Features
 
-// Access the underlying HTMLInputElement
-const inputElement = numoraInput.getElement();
-inputElement.addEventListener('focus', () => {
-  console.log('Input focused');
-});
-```
+- [Sanitization](https://numora.xyz/docs/numora/features/sanitization) - filters invalid characters and mobile keyboard artifacts
+- [Formatting](https://numora.xyz/docs/numora/features/formatting) - thousand separators (Thousand/Lakh/Wan), format on blur or change
+- [Decimals](https://numora.xyz/docs/numora/features/decimals) - min/max decimal places, custom decimal separator, raw value mode
+- [Compact Notation](https://numora.xyz/docs/numora/features/compact-notation) - expands "1k" → "1000" on paste/setValue (opt-in)
+- [Scientific Notation](https://numora.xyz/docs/numora/features/scientific-notation) - always expands "1.5e-7" → "0.00000015" automatically
+- [Leading Zeros](https://numora.xyz/docs/numora/features/leading-zeros) - configurable leading zero behavior
 
 ## Options
 
-The NumoraInput constructor accepts the following options:
-
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `decimalMaxLength` | `number` | `2` | Maximum number of decimal places allowed |
-| `decimalMinLength` | `number` | `0` | Minimum number of decimal places (pads with zeros) |
-| `decimalSeparator` | `string` | `'.'` | Character used as decimal separator |
-| `thousandSeparator` | `string` | `','` | Character used as thousand separator (set to empty string to disable) |
+| `decimalMaxLength` | `number` | `2` | Maximum decimal places allowed |
+| `decimalMinLength` | `number` | `0` | Minimum decimal places (pads with zeros) |
+| `decimalSeparator` | `string` | `'.'` | Decimal separator character |
+| `thousandSeparator` | `string` | `','` | Thousand separator character |
 | `thousandStyle` | `ThousandStyle` | `ThousandStyle.None` | Grouping style: `Thousand`, `Lakh`, `Wan`, or `None` |
 | `formatOn` | `FormatOn` | `FormatOn.Blur` | When to apply formatting: `Blur` or `Change` |
-| `enableCompactNotation` | `boolean` | `false` | Enable expansion of compact notation (e.g., "1k" → "1000") on paste/setValue |
+| `enableCompactNotation` | `boolean` | `false` | Expand compact notation on paste/setValue |
 | `enableNegative` | `boolean` | `false` | Allow negative numbers |
-| `enableLeadingZeros` | `boolean` | `false` | Allow leading zeros before decimal point |
-| `rawValueMode` | `boolean` | `false` | Return unformatted values in `onChange` callback |
-| `onChange` | `(value: string) => void` | `undefined` | Callback function that runs when the input value changes |
-| `value` | `string` | `undefined` | Initial value (controlled mode) |
-| `defaultValue` | `string` | `undefined` | Initial default value (uncontrolled mode) |
+| `enableLeadingZeros` | `boolean` | `false` | Allow leading zeros |
+| `rawValueMode` | `boolean` | `false` | Return unformatted values in `onChange` |
+| `onChange` | `(value: string) => void` | `undefined` | Called when value changes |
+| `value` | `string` | `undefined` | Initial value (controlled) |
+| `defaultValue` | `string` | `undefined` | Initial value (uncontrolled) |
 
-All standard HTMLInputElement properties are also supported (e.g., `placeholder`, `className`, `disabled`, `id`, etc.).
+All standard `HTMLInputElement` properties are also supported (`placeholder`, `className`, `disabled`, etc.).
 
-**Note:** Scientific notation expansion (e.g., `"1.5e-7"` → `"0.00000015"`) always happens automatically and is not configurable.
+## Documentation
 
-## Framework Adapters
+Full docs and live demo at [numora.xyz/docs/numora](https://numora.xyz/docs/numora).
 
-Numora is also available for popular frameworks:
+## Framework Adapters
 
-- **React**: [`numora-react`](../react/README.md) - React component wrapper
-- **Vue**: Coming soon
-- **Svelte**: Use the core package directly
+- **React**: [`numora-react`](../react/README.md)
 
 ## License
 

package/dist/NumoraInput.d.ts

@@ -16,7 +16,6 @@ export interface NumoraInputOptions extends Partial<Omit<HTMLInputElement, 'valu
 }
 export declare class NumoraInput {
     private element;
-    private options;
     private resolvedOptions;
     private rawValue;
     private caretPositionBeforeChange?;

package/dist/features/compact-notation.d.ts

@@ -1,6 +1,10 @@
 /**
- * Expands compact notation (k, m, b, M, T, Qa, Qi, Sx, Sp, O, N) to full numbers using string manipulation.
- * Handles formats like: 1k, 1.5m, 2B, 1M, 2.5T, 3Qa (case-insensitive)
+ * Static regex patterns for compact notation processing.
+ * Defined at module level to avoid recompilation on each function call.
+ */
+/**
+ * Expands compact notation (k, m, b, t) to full numbers using string manipulation.
+ * Handles formats like: 1k, 1.5m, 2B, 1M, 2.5T (case-insensitive)
  * Uses string arithmetic to avoid precision loss with large numbers.
  *
  * @param value - The string value that may contain compact notation

package/dist/features/formatting/cursor-position.d.ts

@@ -1,6 +1,48 @@
 /**
  * Advanced cursor position calculation for formatted numeric inputs.
  * Handles cursor preservation during formatting changes, insertion, and deletion operations.
+ *
+ * ## Algorithm Overview
+ *
+ * The cursor position calculation uses a "meaningful digit" approach:
+ * 1. Count the number of actual digits (0-9) before the cursor, ignoring separators
+ * 2. After formatting, find the position that has the same number of digits before it
+ * 3. Apply adjustments for separator boundaries and special cases
+ *
+ * ## Processing Flow
+ *
+ * ```
+ * calculateCursorPositionAfterFormatting()
+ *   ├── Guard clauses (empty values, out of bounds)
+ *   ├── Compact notation detection (1k → 1000)
+ *   ├── Character mapping approach (optional, for complex transformations)
+ *   └── Route to handler based on operation type:
+ *       ├── handleDeletion() - for backspace/delete operations
+ *       │   ├── handleSeparatorDeletion() - cursor was on separator
+ *       │   ├── Calculate target digit count
+ *       │   └── Find new position + fine-tune for separators
+ *       └── handleInsertion() - for typing/paste operations
+ *           ├── Handle cursor at end
+ *           └── Find position maintaining digit-relative position
+ * ```
+ *
+ * ## Key Concepts
+ *
+ * - **Meaningful digits**: Numeric characters (0-9) that represent actual value
+ * - **Separators**: Thousand separators that are formatting-only (not part of value)
+ * - **Digit index**: The nth digit from the start (ignoring separators)
+ * - **ChangeRange**: Info about what was typed/deleted to distinguish Delete vs Backspace
+ *
+ * ## Edge Cases Handled
+ *
+ * - Cursor at start/end of input
+ * - Cursor on separator during deletion
+ * - Delete key vs Backspace key (different cursor behavior)
+ * - Compact notation expansion (1k → 1000)
+ * - Integer/decimal part transitions
+ * - Boundary constraints (prefix/suffix)
+ *
+ * @module cursor-position
  */
 import type { ChangeRange } from './constants';
 import { ThousandStyle } from '@/types';
@@ -15,6 +57,7 @@ export type IsCharacterEquivalent = (char1: string, char2: string, context: {
     oldIndex: number;
     newIndex: number;
 }) => boolean;
+export declare const defaultIsCharacterEquivalent: IsCharacterEquivalent;
 /**
  * Options for cursor position calculation.
  */
@@ -36,7 +79,7 @@ export interface CursorPositionOptions {
  * @param newFormattedValue - The formatted value after formatting
  * @param oldCursorPosition - The cursor position in the old formatted value
  * @param separator - The thousand separator character used in formatting
- * @param _groupStyle - The grouping style used (unused but kept for API compatibility)
+ *   Will be removed in a future major version. Pass any value; it is ignored.
  * @param changeRange - Optional change range info to distinguish Delete vs Backspace
  * @param decimalSeparator - The decimal separator character (default: '.')
  * @param options - Additional options for cursor calculation

package/dist/features/formatting/digit-counting.d.ts

@@ -1,23 +1,48 @@
 /**
  * Utilities for counting and locating meaningful digits in formatted numbers.
- * "Meaningful digits" are actual numeric digits, excluding separators and decimal points.
+ *
+ * ## Core Concept
+ *
+ * "Meaningful digits" are the actual numeric characters (0-9) in a formatted string,
+ * excluding formatting characters like thousand separators and decimal points.
+ *
+ * For example, in "1,234.56":
+ * - Meaningful digits: 1, 2, 3, 4, 5, 6 (count = 6)
+ * - Non-meaningful: comma (,) and period (.)
+ *
+ * ## Usage in Cursor Positioning
+ *
+ * These utilities enable cursor preservation during formatting by:
+ * 1. Counting digits before cursor in OLD value
+ * 2. Finding position with same digit count in NEW value
+ *
+ * Example: Typing "0" in "99|" (cursor at end)
+ * - Old value: "99" → 2 digits before cursor
+ * - User types: "0" → becomes "990"
+ * - Formatting: "990" → "990" (no separator yet)
+ * - New cursor: position after 3rd digit = position 3
+ *
+ * Example: Typing "9" in "99|9" → "9,999"
+ * - Old value: "999" → 3 digits before cursor at position 2
+ * - After formatting: "9,999"
+ * - Find position with 3 digits before it → position 4 (after "9,99")
+ *
+ * @module digit-counting
  */
 /**
- * Counts meaningful digits (non-separator, non-decimal) before a position.
+ * Counts meaningful non-thousand-separator characters (digits and decimal separator) before a position.
  * This is the core digit counting logic used throughout cursor positioning.
  *
  * @param value - The formatted string value
  * @param position - The position to count up to
  * @param separator - The thousand separator character
- * @param decimalSeparator - The decimal separator character (default: '.')
  * @returns The count of meaningful digits before the position
  *
  * @example
  * countMeaningfulDigitsBeforePosition("1,234", 3, ",") // Returns: 2 (digits "1" and "2")
- * countMeaningfulDigitsBeforePosition("1,234.56", 8, ",") // Returns: 6
- * countMeaningfulDigitsBeforePosition("1.234,56", 8, ".", ",") // Returns: 6
+ * countMeaningfulDigitsBeforePosition("1,234.56", 8, ",") // Returns: 7
  */
-export declare function countMeaningfulDigitsBeforePosition(value: string, position: number, separator: string, _decimalSeparator?: string): number;
+export declare function countMeaningfulDigitsBeforePosition(value: string, position: number, separator: string): number;
 /**
  * Finds the position in the string for a specific digit index.
  * Returns the position AFTER the digit at targetDigitIndex.
@@ -25,13 +50,12 @@ export declare function countMeaningfulDigitsBeforePosition(value: string, posit
  * @param value - The formatted string value
  * @param targetDigitIndex - The zero-based index of the target digit
  * @param separator - The thousand separator character
- * @param decimalSeparator - The decimal separator character (default: '.')
  * @returns The position after the target digit
  *
  * @example
- * findPositionForDigitIndex("1,234", 2, ",") // Returns: 4 (after digit "3")
+ * findPositionForDigitIndex("1,234", 3, ",") // Returns: 4 (after digit "3")
  */
-export declare function findPositionForDigitIndex(value: string, targetDigitIndex: number, separator: string, _decimalSeparator?: string): number;
+export declare function findPositionForDigitIndex(value: string, targetDigitIndex: number, separator: string): number;
 /**
  * Finds the position in the string where the digit count equals targetDigitCount.
  * Returns the position after reaching the target count.
@@ -39,13 +63,12 @@ export declare function findPositionForDigitIndex(value: string, targetDigitInde
  * @param value - The formatted string value
  * @param targetDigitCount - The target number of digits
  * @param separator - The thousand separator character
- * @param decimalSeparator - The decimal separator character (default: '.')
  * @returns The position where digit count equals target
  *
  * @example
- * findPositionWithMeaningfulDigitCount("1,234", 3, ",") // Returns: 5 (after "2,3")
+ * findPositionWithMeaningfulDigitCount("1,234", 3, ",") // Returns: 4 (after "2,3")
  */
-export declare function findPositionWithMeaningfulDigitCount(value: string, targetDigitCount: number, separator: string, _decimalSeparator?: string): number;
+export declare function findPositionWithMeaningfulDigitCount(value: string, targetDigitCount: number, separator: string): number;
 /**
  * Checks if a position in the string is on a separator character.
  *

package/dist/features/formatting/index.d.ts

@@ -14,7 +14,3 @@ export { findChangedRangeFromCaretPositions, findChangeRange } from './change-de
 export { getCaretBoundary, getCaretPosInBoundary } from './cursor-boundary';
 export { setCaretPosition, setCaretPositionWithRetry, getInputCaretPosition, updateCursorPosition, skipOverThousandSeparatorOnDelete } from './caret-position-utils';
 export { countMeaningfulDigitsBeforePosition, findPositionForDigitIndex, findPositionWithMeaningfulDigitCount, isPositionOnSeparator, } from './digit-counting';
-export { formatPercent, formatLargePercent } from './percent';
-export { condenseDecimalZeros } from './subscript-notation';
-export { formatLargeNumber, type FormatLargeNumberOptions } from './large-number';
-export { applyDecimalPrecision, applyScaleNotation, compareStrings, isVeryLarge } from './numeric-formatting-utils';

package/dist/features/non-numeric-characters.d.ts

@@ -1,5 +1,6 @@
 /**
  * Removes non-numeric characters from a string, preserving the decimal separator.
+ * Uses cached regex for performance optimization.
  *
  * @param value - The string to sanitize
  * @param enableNegative - Whether to allow negative sign

package/dist/features/sanitization.d.ts

@@ -1,7 +1,7 @@
 import type { FormattingOptions, Separators } from '@/types';
 /**
  * Removes all occurrences of thousand separator from a string.
- * Escapes special regex characters in the separator to ensure safe pattern matching.
+ * Uses cached regex for performance optimization.
  *
  * @param value - The string to remove separators from
  * @param thousandSeparator - The thousand separator character to remove

package/dist/features/scientific-notation.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Static regex patterns for scientific notation processing.
+ * Defined at module level to avoid recompilation on each function call.
+ */
 /**
  * Expands scientific notation to decimal notation using string manipulation only.
  * Handles formats like: 1.5e-7, 2e+5, 1.23e-4, etc.

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 export * from './NumoraInput';
 export { ThousandStyle, FormatOn } from './types';
+export { getSeparatorsFromLocale, resolveLocaleOptions } from './utils/locale';
 export { handleOnChangeNumoraInput, handleOnPasteNumoraInput, handleOnKeyDownNumoraInput, } from './utils/event-handlers';
 export { formatValueForDisplay, formatInputValue, } from './utils/format-utils';
 export type { FormattingOptions, CaretPositionInfo } from './types';
-export { formatPercent, formatLargePercent } from './features/formatting/percent';
-export { formatLargeNumber, type FormatLargeNumberOptions } from './features/formatting/large-number';
-export { condenseDecimalZeros } from './features/formatting/subscript-notation';
 export { removeThousandSeparators } from './features/sanitization';
+export { validateNumoraInputOptions } from './validation';
+export { getNumoraPattern } from './utils/input-pattern';