n2words 1.24.0 → 2.0.0

package/lib/classes/slavic-language.js

@@ -1,196 +1,228 @@
-import AbstractLanguage from './abstract-language.js'
-
-/**
- * @typedef {string[]} SlavicPluralForms
- * Array of three plural forms for Slavic languages:
- * - [0]: Singular form (for numbers ending in 1, except 11)
- * - [1]: Few form (for numbers ending in 2-4, except 12-14)
- * - [2]: Many form (for all other numbers: 0, 5-20, and numbers ending in 0, 5-9, 11-19)
- */
-
-/**
- * @typedef {Object.<string, SlavicPluralForms>} SlavicThousandsMap
- * Mapping from power indices to their plural forms.
- * Example: { '0': ['тысяча', 'тысячи', 'тысяч'], '1': ['миллион', 'миллиона', 'миллионов'] }
- */
+import { AbstractLanguage } from './abstract-language.js'
 
 /**
  * Base class for Slavic and related languages with complex pluralization.
  *
  * This class provides a reusable implementation for languages that share:
  * - Three-form pluralization (singular/few/many)
- * - Gender-aware number forms (masculine/feminine for 1, 2)
- * - Hundreds, tens, ones decomposition
- * - Chunk-based large number handling (thousands, millions, etc.)
+ * - Gender-aware number forms (masculine/feminine for 1-9)
+ * - Hundreds, tens, ones decomposition pattern
+ * - Segment-based large number handling (thousands, millions, etc.)
  * - Inherits decimal handling from AbstractLanguage (supports both grouped and
- *   per-digit modes via the `convertDecimalsPerDigit` class property).
+ *   per-digit modes via the `usePerDigitDecimals` class property).
  *
- * Used by: Russian, Czech, Polish, Ukrainian, Serbian, Croatian,
- * as well as Baltic (Lithuanian, Latvian) and Hebrew languages.
+ * Used by: Russian (ru), Czech (cs), Polish (pl), Ukrainian (uk), Serbian (sr-Latn),
+ * Croatian (hr), Lithuanian (lt), Latvian (lv), Hebrew (he), and Biblical Hebrew (hbo).
  *
  * Subclasses MUST define these properties with language-specific vocabulary:
- * - `ones` - Object mapping 1-9 to masculine forms
- * - `onesFeminine` - Object mapping 1-9 to feminine forms
- * - `tens` - Object mapping 0-9 to teen numbers (10-19)
- * - `twenties` - Object mapping 2-9 to tens (20-90)
- * - `hundreds` - Object mapping 1-9 to hundreds (100-900)
- * - `thousands` - Object mapping power indices to [singular, few, many] forms
- * - `feminine` - Boolean indicating if feminine forms should be used (optional)
+ * - `onesWords` - Object mapping 1-9 to masculine forms (or default forms)
+ * - `onesFeminineWords` - Object mapping 1-9 to feminine forms (if gender distinction exists)
+ * - `teensWords` - Object mapping 0-9 to teen numbers (10-19)
+ * - `twentiesWords` - Object mapping 2-9 to tens (20-90)
+ * - `hundredsWords` - Object mapping 1-9 to hundreds (100-900) or special hundreds handling
+ * - `pluralForms` - Object mapping segment indices to [singular, few, many] plural forms
+ *
+ * Optional properties:
+ * - `scaleGenders` - Object mapping segment indices to boolean (true = feminine scale word)
+ *   If not defined, defaults to thousands (index 1) being feminine, others masculine.
  *
  * @abstract
  * @extends AbstractLanguage
  */
-class SlavicLanguage extends AbstractLanguage {
+export class SlavicLanguage extends AbstractLanguage {
+  // ============================================================================
+  // Required Properties (subclasses must define)
+  // ============================================================================
+
   /**
-   * Masculine forms for digits 1-9.
+   * Masculine forms for digits 1-9 (or default forms if no gender distinction).
    *
-   * @type {object}
+   * @type {Object.<number, string>}
    */
-  ones = {}
+  onesWords = {}
 
   /**
-   * Feminine forms for digits 1-9.
+   * Feminine forms for digits 1-9 (if language has gender distinction).
    *
-   * @type {object}
+   * @type {Object.<number, string>}
    */
-  onesFeminine = {}
+  onesFeminineWords = {}
 
   /**
-   * Words for tens (10, 20, 30, etc.).
+   * Words for teen numbers (10-19).
    *
-   * @type {object}
+   * @type {Object.<number, string>}
    */
-  tens = {}
+  teensWords = {}
 
   /**
-   * Special forms for 21-29 in some languages.
+   * Words for multiples of ten (20, 30, 40, etc.).
    *
-   * @type {object}
+   * @type {Object.<number, string>}
    */
-  twenties = {}
+  twentiesWords = {}
 
   /**
-   * Words for hundreds (100, 200, 300, etc.).
+   * Words for hundreds (100, 200, 300, etc.) or special hundreds handling.
    *
-   * @type {object}
+   * @type {Object.<number, string>}
    */
-  hundreds = {}
+  hundredsWords = {}
 
   /**
-   * Scale words for thousands, millions, etc.
+   * Plural forms for scale words (thousands, millions, billions, etc.).
+   * Maps segment indices to [singular, few, many] forms.
    *
-   * @type {object}
+   * @type {Object.<number, string[]>}
    */
-  thousands = {}
+  pluralForms = {}
+
+  // ============================================================================
+  // Optional Properties (subclasses may override)
+  // ============================================================================
 
   /**
-   * Use feminine forms for numbers (affects 1-9).
+   * Gender of each scale word.
+   * Maps segment indices to boolean: true = feminine, false = masculine.
+   * Default is empty (all masculine). Languages with feminine thousands
+   * (Russian, Ukrainian, Serbian, Croatian) should set `{ 1: true }`.
+   *
+   * @type {Object.<number, boolean>}
+   */
+  scaleGenders = {}
+
+  /**
+   * Whether to omit "one" before scale words (e.g., "thousand" instead of "one thousand").
+   * When true, 1000 becomes "tysiąc" (Polish) instead of "jeden tysiąc".
+   * Used by Polish, Czech, and similar languages.
    *
    * @type {boolean}
    */
-  feminine
+  omitOneBeforeScale = false
+
+  // ============================================================================
+  // Constructor
+  // ============================================================================
 
   /**
-   * Initializes the Slavic language converter with language-specific options.
+   * Constructs a SlavicLanguage instance with optional configuration.
    *
-   * @param {Object} [options={}] Configuration options.
-   * @param {boolean} [options.feminine=false] Use feminine forms for numbers (affects gender agreement).
+   * @param {Object} [options] Configuration options.
+   * @param {('masculine'|'feminine')} [options.gender='masculine'] Grammatical gender for number forms.
    */
-  constructor ({ feminine = false } = {}) {
+  constructor (options = {}) {
     super()
 
-    this.feminine = feminine
+    this.setOptions({
+      gender: 'masculine'
+    }, options)
   }
 
+  // ============================================================================
+  // Public Methods
+  // ============================================================================
+
   /**
-   * Converts a whole number to its word representation.
+   * Converts an integer to its word representation.
    *
    * This method implements the Slavic number construction algorithm:
-   * 1. Split number into 3-digit chunks (right to left)
-   * 2. For each chunk: convert hundreds, tens, ones
-   * 3. Apply gender rules for ones (feminine for thousands, or when feminine=true)
-   * 4. Add pluralized power word (thousand/million/billion/etc.)
+   * 1. Split number into 3-digit segments from right to left (567, 234, 1 for 1,234,567)
+   * 2. For each segment (processing left to right): convert hundreds, tens, ones
+   * 3. Apply gender rules: feminine forms for thousands segment or when feminine=true
+   * 4. Add appropriate pluralized scale word (thousand/million/billion/etc.)
    * 5. Join all parts with spaces
    *
-   * @param {bigint} number The whole number to convert (non-negative).
+   * @param {bigint} integerPart The integer to convert (non-negative).
    * @returns {string} The number in words.
    */
-  convertWholePart (number) {
-    if (number === 0n) {
+  integerToWords (integerPart) {
+    if (integerPart === 0n) {
       return this.zeroWord
     }
 
     const words = []
-    const chunks = this.splitByX(number.toString(), 3)
-    let chunkIndex = chunks.length
+    const segments = this.splitToSegments(integerPart.toString(), 3)
+    let segmentIndex = segments.length
 
-    for (const chunkValue of chunks) {
-      chunkIndex = chunkIndex - 1
+    for (const segmentValue of segments) {
+      segmentIndex = segmentIndex - 1
 
-      if (chunkValue === 0n) {
+      if (segmentValue === 0n) {
         continue
       }
 
-      const [onesDigit, tensDigit, hundredsDigit] = this.getDigits(chunkValue)
+      const [onesDigit, tensDigit, hundredsDigit] = this.extractDigits(segmentValue)
 
       if (hundredsDigit > 0n) {
-        words.push(this.hundreds[hundredsDigit])
+        words.push(this.hundredsWords[hundredsDigit])
       }
 
       if (tensDigit > 1n) {
-        words.push(this.twenties[tensDigit])
+        words.push(this.twentiesWords[tensDigit])
       }
 
       // Handle teens (10-19) or ones (1-9)
       if (tensDigit === 1n) {
-        // Teens: use tens array directly
-        words.push(this.tens[onesDigit])
+        // Teens: use teensWords array directly
+        words.push(this.teensWords[onesDigit])
       } else if (onesDigit > 0n) {
-        // Ones: use feminine form for thousands (chunkIndex 1) or when feminine=true (chunkIndex 0)
-        const onesArray =
-          chunkIndex === 1 || (this.feminine && chunkIndex === 0)
-            ? this.onesFeminine
-            : this.ones
-        words.push(onesArray[onesDigit])
+        // Skip "one" before scale words if omitOneBeforeScale is set
+        // e.g., Polish says "tysiąc" not "jeden tysiąc" for 1000
+        const shouldOmitOne = this.omitOneBeforeScale && segmentIndex > 0 && segmentValue === 1n
+
+        if (!shouldOmitOne) {
+          // Determine if feminine forms should be used:
+          // 1. Check scaleGenders for this segment index (e.g., thousands = index 1)
+          // 2. Also use feminine if user requested gender='feminine' for the ones segment
+          const isScaleFeminine = this.scaleGenders[segmentIndex] === true
+          const isFeminine = isScaleFeminine || (this.options.gender === 'feminine' && segmentIndex === 0)
+          const onesArray = isFeminine ? this.onesFeminineWords : this.onesWords
+          words.push(onesArray[onesDigit])
+        }
       }
 
       // Add power word (thousand, million, etc.) with proper pluralization
-      if (chunkIndex > 0) {
-        words.push(this.pluralize(chunkValue, this.thousands[chunkIndex]))
+      if (segmentIndex > 0) {
+        words.push(this.pluralize(segmentValue, this.pluralForms[segmentIndex]))
       }
     }
 
     return words.join(' ')
   }
 
+  // ============================================================================
+  // Protected Methods (subclasses may call or override)
+  // ============================================================================
+
   /**
-   * Splits a number string into chunks of X digits.
+   * Splits a number string into segments of specified size from right to left.
    *
-   * Example: splitByX('1234567', 3) => [1n, 234n, 567n]
+   * Example: splitToSegments('1234567', 3) => [1n, 234n, 567n]
+   * This represents: 1 million + 234 thousand + 567 ones
    *
    * @param {string} numberString The number as a string.
-   * @param {number} chunkSize Chunk size (typically 3 for thousands grouping).
-   * @returns {bigint[]} Array of BigInt chunks.
+   * @param {number} segmentSize Segment size (typically 3 for thousands grouping).
+   * @returns {bigint[]} Array of BigInt segments from highest to lowest scale.
    */
-  splitByX (numberString, chunkSize) {
-    const chunks = []
+  splitToSegments (numberString, segmentSize) {
+    const segments = []
     const stringLength = numberString.length
 
-    if (stringLength > chunkSize) {
-      const remainderLength = stringLength % chunkSize
+    if (stringLength > segmentSize) {
+      const remainderLength = stringLength % segmentSize
 
       if (remainderLength > 0) {
-        chunks.push(BigInt(numberString.slice(0, remainderLength)))
+        segments.push(BigInt(numberString.slice(0, remainderLength)))
       }
 
-      for (let i = remainderLength; i < stringLength; i += chunkSize) {
-        chunks.push(BigInt(numberString.slice(i, i + chunkSize)))
+      for (let i = remainderLength; i < stringLength; i += segmentSize) {
+        segments.push(BigInt(numberString.slice(i, i + segmentSize)))
       }
     } else {
-      chunks.push(BigInt(numberString))
+      segments.push(BigInt(numberString))
     }
 
-    return chunks
+    return segments
   }
 
   /**
@@ -202,7 +234,7 @@ class SlavicLanguage extends AbstractLanguage {
    * @param {bigint} value The number to extract digits from (0-999).
    * @returns {bigint[]} Array of [ones, tens, hundreds] as BigInts.
    */
-  getDigits (value) {
+  extractDigits (value) {
     // Direct BigInt arithmetic is faster than string manipulation
     const onesPlace = value % 10n
     const tensPlace = (value / 10n) % 10n
@@ -213,18 +245,18 @@ class SlavicLanguage extends AbstractLanguage {
   /**
    * Selects the correct plural form based on Slavic pluralization rules.
    *
-   * Slavic languages use three forms:
-   * - Form 0 (singular): numbers ending in 1 (but not 11)
-   * - Form 1 (few): numbers ending in 2-4 (but not 12-14)
-   * - Form 2 (many): all other numbers (0, 5-20, 25-30, etc.)
+   * Slavic languages typically use three forms:
+   * - Form 0 (singular): numbers ending in 1, except 11 (1, 21, 31, 101...)
+   * - Form 1 (few): numbers ending in 2-4, except 12-14 (2-4, 22-24, 32-34...)
+   * - Form 2 (many): all other numbers (0, 5-20, 25-30, 100, 111-119...)
    *
-   * Examples (Russian):
-   * - 1, 21, 31... => тысяча (form 0)
-   * - 2-4, 22-24, 32-34... => тысячи (form 1)
-   * - 0, 5-20, 25-30... => тысяч (form 2)
+   * Examples using Russian тысяча (thousand):
+   * - 1, 21, 31... ⇒ тысяча (form 0, singular)
+   * - 2-4, 22-24, 32-34... ⇒ тысячи (form 1, few)
+   * - 0, 5-20, 25-30, 100... ⇒ тысяч (form 2, many)
    *
-   * @param {bigint} n The number to check.
-   * @param {string[]} forms Array of [singular, few, many] forms.
+   * @param {bigint} number The number to check.
+   * @param {string[]} pluralForms Array of [singular, few, many] forms.
    * @returns {string} The appropriate form for the number.
    */
   pluralize (number, pluralForms) {
@@ -247,5 +279,3 @@ class SlavicLanguage extends AbstractLanguage {
     return pluralForms[2] // Many
   }
 }
-
-export default SlavicLanguage

package/lib/classes/south-asian-language.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Base class for South Asian languages with shared grouping patterns.
+ *
+ * This class provides a reusable implementation for South Asian languages that share:
+ * - Indian-style number grouping: last 3 digits, then 2-2 (1,23,45,67,89)
+ * - Lakh (100,000), Crore (10,000,000), Arab (1,000,000,000) scale words
+ * - Standard negative and decimal handling (inherits AbstractLanguage decimal logic,
+ *   including `usePerDigitDecimals` support when set by subclasses)
+ *
+ * Used by: Hindi (hi), Bengali (bn), Urdu (ur), Punjabi (pa), Marathi (mr), Gujarati (gu), Kannada (kn)
+ *
+ * Subclasses MUST define language-specific vocabulary via class properties:
+ * - `belowHundredWords` array with digit and teen words (0-99)
+ * - `hundredWord` string used inside `segmentToWords`
+ * - `scaleWords` array with grouping words (hazaar, lakh, crore, etc.) indexed by grouping level
+ * - `negativeWord`, `decimalSeparatorWord`, `zeroWord`, `wordSeparator`
+ *
+ * @abstract
+ * @extends AbstractLanguage
+ */
+export class SouthAsianLanguage extends AbstractLanguage {
+    /**
+     * Array of words for numbers 0-99 (digits and teens).
+     * Index directly: belowHundredWords[0] through belowHundredWords[99].
+     * @type {Array<string>}
+     */
+    belowHundredWords: Array<string>;
+    /**
+     * Word for "hundred" in the language (e.g., 'सौ' in Hindi, 'শত' in Bengali).
+     * Used to construct hundreds (e.g., "1 hundred", "2 hundred").
+     * @type {string}
+     */
+    hundredWord: string;
+    /**
+     * Array of scale words for Indian-style grouping (hazaar, lakh, crore, arab, etc.).
+     * Index 0 contains empty string (ones place has no scale word).
+     * Index 1 is for thousands, Index 2 for lakhs, Index 3 for crores, etc.
+     * @type {Array<string>}
+     */
+    scaleWords: Array<string>;
+    /**
+     * Splits a number into Indian numbering system segments.
+     *
+     * The Indian system segments differently than Western (3-3-3) systems:
+     * - First segment (rightmost): Up to 3 digits (ones, tens, hundreds)
+     * - Subsequent segments: Exactly 2 digits each (thousands, lakhs, crores, etc.)
+     *
+     * This creates the familiar Indian comma pattern: 1,23,45,67,890
+     *
+     * @protected
+     * @param {bigint} integerPart The integer to split into segments.
+     * @returns {Array<number>} Array of segments from most significant to least significant.
+     *
+     * @example
+     * // splitToSegments(1234567n) → [12, 34, 567]
+     * // Reads as: 12 lakhs, 34 thousands, 567 units
+     * // splitToSegments(98765432n) → [9, 87, 65, 432]
+     * // Reads as: 9 crores, 87 lakhs, 65 thousands, 432 units
+     */
+    protected splitToSegments(integerPart: bigint): Array<number>;
+    /**
+     * Converts a segment (0-999) to words.
+     *
+     * @protected
+     * @param {number} segmentValue Value between 0 and 999.
+     * @returns {string} Language-specific word representation.
+     */
+    protected segmentToWords(segmentValue: number): string;
+}
+import { AbstractLanguage } from './abstract-language.js';

package/lib/classes/south-asian-language.js

@@ -1,21 +1,4 @@
-import AbstractLanguage from './abstract-language.js'
-
-/**
- * @typedef {Array<string>} SouthAsianScaleWords
- * Array of scale words for the Indian numbering system, in ascending order.
- * - Index 0: Usually empty/unused (ones place)
- * - Index 1: Thousands (hazaar/হাজার/हजार)
- * - Index 2: Lakhs (lakh/লাখ/लाख)
- * - Index 3: Crores (crore/কোটি/करोड़)
- * - Index 4: Arabs (arab/আরব/अरब)
- * Each index i represents the scale word for groups at position i in the Indian system.
- */
-
-/**
- * @typedef {Array<string>} SouthAsianBelowHundred
- * Array of words for numbers 0-99, indexed directly.
- * belowHundred[0] = word for 0, belowHundred[42] = word for 42, etc.
- */
+import { AbstractLanguage } from './abstract-language.js'
 
 /**
  * Base class for South Asian languages with shared grouping patterns.
@@ -24,26 +7,30 @@ import AbstractLanguage from './abstract-language.js'
  * - Indian-style number grouping: last 3 digits, then 2-2 (1,23,45,67,89)
  * - Lakh (100,000), Crore (10,000,000), Arab (1,000,000,000) scale words
  * - Standard negative and decimal handling (inherits AbstractLanguage decimal logic,
- *   including `convertDecimalsPerDigit` support when set by subclasses)
+ *   including `usePerDigitDecimals` support when set by subclasses)
  *
  * Used by: Hindi (hi), Bengali (bn), Urdu (ur), Punjabi (pa), Marathi (mr), Gujarati (gu), Kannada (kn)
  *
  * Subclasses MUST define language-specific vocabulary via class properties:
- * - `belowHundred` array with digit and teen words (0-99)
- * - `hundredWord` string used inside `convertBelowThousand`
+ * - `belowHundredWords` array with digit and teen words (0-99)
+ * - `hundredWord` string used inside `segmentToWords`
  * - `scaleWords` array with grouping words (hazaar, lakh, crore, etc.) indexed by grouping level
  * - `negativeWord`, `decimalSeparatorWord`, `zeroWord`, `wordSeparator`
  *
  * @abstract
  * @extends AbstractLanguage
  */
-class SouthAsianLanguage extends AbstractLanguage {
+export class SouthAsianLanguage extends AbstractLanguage {
+  // ============================================================================
+  // Required Properties (subclasses must define)
+  // ============================================================================
+
   /**
    * Array of words for numbers 0-99 (digits and teens).
-   * Index directly: belowHundred[0] through belowHundred[99].
+   * Index directly: belowHundredWords[0] through belowHundredWords[99].
    * @type {Array<string>}
    */
-  belowHundred
+  belowHundredWords
 
   /**
    * Word for "hundred" in the language (e.g., 'सौ' in Hindi, 'শত' in Bengali).
@@ -54,101 +41,109 @@ class SouthAsianLanguage extends AbstractLanguage {
 
   /**
    * Array of scale words for Indian-style grouping (hazaar, lakh, crore, arab, etc.).
-   * Index 0 is typically unused (ones place, no scale word).
+   * Index 0 contains empty string (ones place has no scale word).
    * Index 1 is for thousands, Index 2 for lakhs, Index 3 for crores, etc.
    * @type {Array<string>}
    */
   scaleWords
 
+  // ============================================================================
+  // Protected Methods (subclasses may call or override)
+  // ============================================================================
+
   /**
-   * Split a number into Indian numbering system groups.
+   * Splits a number into Indian numbering system segments.
    *
-   * The Indian system groups differently than Western (3-3-3) systems:
-   * - First group (rightmost): Up to 3 digits (ones, tens, hundreds)
-   * - Subsequent groups: Exactly 2 digits each (thousands, lakhs, crores, etc.)
+   * The Indian system segments differently than Western (3-3-3) systems:
+   * - First segment (rightmost): Up to 3 digits (ones, tens, hundreds)
+   * - Subsequent segments: Exactly 2 digits each (thousands, lakhs, crores, etc.)
    *
    * This creates the familiar Indian comma pattern: 1,23,45,67,890
    *
    * @protected
-   * @param {bigint} number The number to split into groups
-   * @returns {Array<number>} Array of groups from most significant to least significant
+   * @param {bigint} integerPart The integer to split into segments.
+   * @returns {Array<number>} Array of segments from most significant to least significant.
    *
    * @example
-   * // splitToGroups(1234567n) → [12, 34, 567]
+   * // splitToSegments(1234567n) → [12, 34, 567]
    * // Reads as: 12 lakhs, 34 thousands, 567 units
-   * // splitToGroups(98765432n) → [9, 87, 65, 432]
+   * // splitToSegments(98765432n) → [9, 87, 65, 432]
    * // Reads as: 9 crores, 87 lakhs, 65 thousands, 432 units
    */
-  splitToGroups (number) {
-    const numStr = number.toString()
+  splitToSegments (integerPart) {
+    const numStr = integerPart.toString()
 
     if (numStr.length <= 3) {
       return [Number(numStr)]
     }
 
-    const groups = []
+    const segments = []
     const last3 = numStr.slice(-3)
-    groups.unshift(Number(last3))
+    segments.unshift(Number(last3))
 
     let remaining = numStr.slice(0, -3)
     while (remaining.length > 0) {
-      const group = remaining.slice(-2)
-      groups.unshift(Number(group))
+      const segment = remaining.slice(-2)
+      segments.unshift(Number(segment))
       remaining = remaining.slice(0, -2)
     }
 
-    return groups
+    return segments
   }
 
   /**
-   * Convert a number below 1000 to words (0-999).
+   * Converts a segment (0-999) to words.
    *
    * @protected
-   * @param {number} number Value between 0 and 999
-   * @returns {string} Language-specific word representation
+   * @param {number} segmentValue Value between 0 and 999.
+   * @returns {string} Language-specific word representation.
    */
-  convertBelowThousand (number) {
-    if (number === 0) return ''
-    if (number < 100) return this.belowHundred[number]
+  segmentToWords (segmentValue) {
+    if (segmentValue === 0) return ''
+    if (segmentValue < 100) return this.belowHundredWords[segmentValue]
 
-    const hundreds = Math.trunc(number / 100)
-    const remainder = number % 100
+    const hundreds = Math.trunc(segmentValue / 100)
+    const remainder = segmentValue % 100
     const parts = []
 
     if (hundreds === 1) {
-      parts.push(this.belowHundred[1] + ' ' + this.hundredWord)
+      parts.push(this.belowHundredWords[1] + ' ' + this.hundredWord)
     } else {
-      parts.push(this.belowHundred[hundreds] + ' ' + this.hundredWord)
+      parts.push(this.belowHundredWords[hundreds] + ' ' + this.hundredWord)
     }
 
     if (remainder > 0) {
-      parts.push(this.belowHundred[remainder])
+      parts.push(this.belowHundredWords[remainder])
     }
 
     return parts.join(' ')
   }
 
+  // ============================================================================
+  // Public Methods
+  // ============================================================================
+
   /**
-   * Convert whole number to cardinal words using South Asian grouping.
+   * Converts integer to cardinal words using South Asian grouping.
    *
-   * @param {bigint} number Number to convert
-   * @returns {string} Cardinal representation
+   * @param {bigint} integerPart Number to convert.
+   * @returns {string} Cardinal representation.
    */
-  convertWholePart (number) {
-    if (number === 0n) {
+  integerToWords (integerPart) {
+    if (integerPart === 0n) {
       return this.zeroWord
     }
 
-    const groups = this.splitToGroups(number)
-    const groupCount = groups.length
+    const segments = this.splitToSegments(integerPart)
+    const segmentCount = segments.length
     const words = []
 
-    for (let i = 0; i < groupCount; i++) {
-      const groupValue = groups[i]
-      if (groupValue === 0) continue
+    for (let i = 0; i < segmentCount; i++) {
+      const segmentValue = segments[i]
+      if (segmentValue === 0) continue
 
-      const scaleIndex = groupCount - i - 1
-      words.push(this.convertBelowThousand(groupValue))
+      const scaleIndex = segmentCount - i - 1
+      words.push(this.segmentToWords(segmentValue))
       if (scaleIndex > 0 && this.scaleWords[scaleIndex]) {
         words.push(this.scaleWords[scaleIndex])
       }
@@ -157,5 +152,3 @@ class SouthAsianLanguage extends AbstractLanguage {
     return words.join(' ').trim()
   }
 }
-
-export default SouthAsianLanguage