numberstring 0.2.0 → 1.0.1

package/languages/pt.js

@@ -0,0 +1,145 @@
+/**
+ * Portuguese number-to-words converter
+ * @module languages/pt
+ */
+
+const PT_ONES = Object.freeze(['', 'um', 'dois', 'três', 'quatro', 'cinco', 'seis', 'sete', 'oito', 'nove']);
+const PT_TENS = Object.freeze(['', '', 'vinte', 'trinta', 'quarenta', 'cinquenta', 'sessenta', 'setenta', 'oitenta', 'noventa']);
+const PT_TEENS = Object.freeze(['dez', 'onze', 'doze', 'treze', 'catorze', 'quinze', 'dezesseis', 'dezessete', 'dezoito', 'dezenove']);
+const PT_HUNDREDS = Object.freeze(['', 'cento', 'duzentos', 'trezentos', 'quatrocentos', 'quinhentos', 'seiscentos', 'setecentos', 'oitocentos', 'novecentos']);
+const PT_ILLIONS = Object.freeze(['', 'mil', 'milhão', 'bilhão', 'trilhão', 'quatrilhão', 'quintilhão', 'sextilhão', 'septilhão', 'octilhão', 'nonilhão', 'decilhão']);
+const PT_ILLIONS_PLURAL = Object.freeze(['', 'mil', 'milhões', 'bilhões', 'trilhões', 'quatrilhões', 'quintilhões', 'sextilhões', 'septilhões', 'octilhões', 'nonilhões', 'decilhões']);
+
+const MAX_VALUE = 10n ** 36n - 1n;
+
+const group = (n) => Math.ceil(n.toString().length / 3) - 1;
+const power = (g) => 10n ** BigInt(g * 3);
+const segment = (n, g) => n % power(g + 1);
+const hundment = (n, g) => Number(segment(n, g) / power(g));
+
+const hundredPt = (n) => {
+  if (n < 100 || n >= 1000) return '';
+  const h = Math.floor(n / 100);
+  const remainder = n % 100;
+  // "cem" when exactly 100, "cento" otherwise
+  if (h === 1 && remainder === 0) return 'cem';
+  return PT_HUNDREDS[h];
+};
+
+const tenPt = (n) => {
+  if (n === 0) return '';
+  if (n < 10) return PT_ONES[n];
+  if (n < 20) return PT_TEENS[n - 10];
+  const onesDigit = n % 10;
+  if (onesDigit) return `${PT_TENS[Math.floor(n / 10)]} e ${PT_ONES[onesDigit]}`;
+  return PT_TENS[Math.floor(n / 10)];
+};
+
+const cap = (str, style) => {
+  switch (style) {
+    case 'title':
+      return str.replace(/\w([^-\s]*)/g, (txt) =>
+        txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase()
+      );
+    case 'upper': return str.toUpperCase();
+    case 'lower': return str.toLowerCase();
+    default: return str;
+  }
+};
+
+/**
+ * Convert a number to Portuguese words
+ * @param {number|bigint} n - The number to convert
+ * @param {Object} [opt] - Options object
+ * @returns {string|false} The Portuguese word representation
+ *
+ * @example
+ * portuguese(42) // 'quarenta e dois'
+ * portuguese(1000) // 'mil'
+ */
+const portuguese = (n, opt) => {
+  let num;
+
+  if (typeof n === 'bigint') {
+    if (n < 0n || n > MAX_VALUE) return false;
+    num = n;
+  } else if (typeof n === 'number') {
+    if (isNaN(n) || n < 0 || !Number.isInteger(n)) return false;
+    if (n > Number.MAX_SAFE_INTEGER) return false;
+    num = BigInt(n);
+  } else {
+    return false;
+  }
+
+  if (num === 0n) return 'zero';
+  if (num === 1n) return 'um';
+
+  const parts = [];
+
+  for (let i = group(num); i >= 0; i--) {
+    const h = hundment(num, i);
+    if (h > 0) {
+      let part = '';
+
+      const hundreds = Math.floor(h / 100);
+      const tens = h % 100;
+
+      if (hundreds > 0) {
+        part += hundredPt(h);
+        if (tens > 0) part += ' e ';
+      }
+
+      if (tens > 0) {
+        part += tenPt(tens);
+      }
+
+      if (i > 0) {
+        // Add scale word (mil, milhão, etc.)
+        if (i === 1) {
+          // "mil" doesn't change for plural and doesn't need "um" before it
+          if (h === 1) {
+            part = 'mil';
+          } else {
+            part += ' mil';
+          }
+        } else {
+          // milhão, bilhão, etc. - use singular for 1, plural for others
+          const scaleWord = h === 1 ? PT_ILLIONS[i] : PT_ILLIONS_PLURAL[i];
+          part += ` ${scaleWord}`;
+        }
+      }
+
+      parts.push(part);
+    }
+  }
+
+  // Join parts with appropriate connectors
+  let result = '';
+  for (let i = 0; i < parts.length; i++) {
+    if (i > 0) {
+      const prevPart = parts[i - 1];
+      const currPart = parts[i];
+
+      // Use "e" (and) for connecting in Portuguese when:
+      // 1. Current part has no scale word (final small numbers)
+      // 2. Previous part has a higher scale (milhão+) and current part has "mil"
+      const prevHasHigherScale = prevPart && (prevPart.includes('ilhão') || prevPart.includes('ilhões'));
+      const currHasMil = currPart && currPart.includes('mil');
+      const currHasNoScale = currPart && !currHasMil && !currPart.includes('ilhão') && !currPart.includes('ilhões');
+
+      if (currHasNoScale || (prevHasHigherScale && currHasMil)) {
+        result += ' e ';
+      } else {
+        result += ' ';
+      }
+    }
+    result += parts[i];
+  }
+
+  result = result.trim();
+  if (opt?.cap) result = cap(result, opt.cap);
+  return result;
+};
+
+export default portuguese;
+export { portuguese };

package/languages/ru.js

@@ -0,0 +1,125 @@
+/**
+ * Russian number-to-words converter
+ * Handles Russian plural forms (1, 2-4, 5-20/0)
+ * @module languages/ru
+ */
+
+const RU_ONES = Object.freeze(['', 'один', 'два', 'три', 'четыре', 'пять', 'шесть', 'семь', 'восемь', 'девять']);
+const RU_ONES_FEM = Object.freeze(['', 'одна', 'две', 'три', 'четыре', 'пять', 'шесть', 'семь', 'восемь', 'девять']);
+const RU_TENS = Object.freeze(['', '', 'двадцать', 'тридцать', 'сорок', 'пятьдесят', 'шестьдесят', 'семьдесят', 'восемьдесят', 'девяносто']);
+const RU_TEENS = Object.freeze(['десять', 'одиннадцать', 'двенадцать', 'тринадцать', 'четырнадцать', 'пятнадцать', 'шестнадцать', 'семнадцать', 'восемнадцать', 'девятнадцать']);
+const RU_HUNDREDS = Object.freeze(['', 'сто', 'двести', 'триста', 'четыреста', 'пятьсот', 'шестьсот', 'семьсот', 'восемьсот', 'девятьсот']);
+const RU_ILLIONS = Object.freeze([
+  ['', '', ''],  // ones
+  ['тысяча', 'тысячи', 'тысяч'],  // thousands (feminine)
+  ['миллион', 'миллиона', 'миллионов'],  // millions
+  ['миллиард', 'миллиарда', 'миллиардов'],  // billions
+  ['триллион', 'триллиона', 'триллионов'],  // trillions
+  ['квадриллион', 'квадриллиона', 'квадриллионов'],  // quadrillions
+  ['квинтиллион', 'квинтиллиона', 'квинтиллионов'],  // quintillions
+  ['секстиллион', 'секстиллиона', 'секстиллионов'],  // sextillions
+  ['септиллион', 'септиллиона', 'септиллионов'],  // septillions
+  ['октиллион', 'октиллиона', 'октиллионов'],  // octillions
+  ['нониллион', 'нониллиона', 'нониллионов'],  // nonillions
+  ['дециллион', 'дециллиона', 'дециллионов']  // decillions
+]);
+
+const MAX_VALUE = 10n ** 36n - 1n;
+
+const group = (n) => Math.ceil(n.toString().length / 3) - 1;
+const power = (g) => 10n ** BigInt(g * 3);
+const segment = (n, g) => n % power(g + 1);
+const hundment = (n, g) => Number(segment(n, g) / power(g));
+const tenment = (n, g) => hundment(n, g) % 100;
+
+/**
+ * Get the correct Russian plural form based on number
+ * Russian has 3 forms: 1, 2-4, 5-20/0
+ */
+const getRuPlural = (n, forms) => {
+  const abs = Math.abs(n);
+  const lastTwo = abs % 100;
+  const lastOne = abs % 10;
+
+  if (lastTwo >= 11 && lastTwo <= 19) {
+    return forms[2];
+  }
+  if (lastOne === 1) {
+    return forms[0];
+  }
+  if (lastOne >= 2 && lastOne <= 4) {
+    return forms[1];
+  }
+  return forms[2];
+};
+
+const tenRu = (n, feminine = false) => {
+  if (n === 0) return '';
+  if (n < 10) return feminine ? RU_ONES_FEM[n] : RU_ONES[n];
+  if (n < 20) return RU_TEENS[n - 10];
+  const onesDigit = n % 10;
+  const tensDigit = Math.floor(n / 10);
+  if (onesDigit === 0) return RU_TENS[tensDigit];
+  const oneWord = feminine ? RU_ONES_FEM[onesDigit] : RU_ONES[onesDigit];
+  return `${RU_TENS[tensDigit]} ${oneWord}`;
+};
+
+const hundredRu = (n) => {
+  if (n < 100 || n >= 1000) return '';
+  return RU_HUNDREDS[Math.floor(n / 100)];
+};
+
+/**
+ * Convert a number to Russian words
+ * @param {number|bigint} n - The number to convert
+ * @returns {string|false} The Russian word representation
+ *
+ * @example
+ * russian(42) // 'сорок два'
+ * russian(1000) // 'одна тысяча'
+ * russian(2000) // 'две тысячи'
+ */
+const russian = (n) => {
+  let num;
+
+  if (typeof n === 'bigint') {
+    if (n < 0n || n > MAX_VALUE) return false;
+    num = n;
+  } else if (typeof n === 'number') {
+    if (isNaN(n) || n < 0 || !Number.isInteger(n)) return false;
+    if (n > Number.MAX_SAFE_INTEGER) return false;
+    num = BigInt(n);
+  } else {
+    return false;
+  }
+
+  if (num === 0n) return 'ноль';
+
+  let s = '';
+  for (let i = group(num); i >= 0; i--) {
+    const h = hundment(num, i);
+    if (h > 0) {
+      const isFeminine = i === 1;
+
+      const hund = hundredRu(h);
+      if (hund) s += hund + ' ';
+
+      const t = tenment(num, i);
+      const tenWord = tenRu(t, isFeminine);
+      if (tenWord) s += tenWord + ' ';
+
+      if (i > 0) {
+        const illionForms = RU_ILLIONS[i];
+        if (illionForms && illionForms[0]) {
+          const illion = getRuPlural(t || h, illionForms);
+          s += illion + ' ';
+        }
+      }
+    }
+  }
+
+  return s.trim().replace(/\s+/g, ' ');
+};
+
+export default russian;
+export { russian };

package/languages/sv.js

@@ -0,0 +1,103 @@
+/**
+ * Swedish number-to-words converter
+ * Swedish uses long scale (miljon, miljard, biljon, etc.)
+ * @module languages/sv
+ */
+
+const SV_ONES = Object.freeze(['', 'en', 'två', 'tre', 'fyra', 'fem', 'sex', 'sju', 'åtta', 'nio']);
+const SV_TENS = Object.freeze(['', '', 'tjugo', 'trettio', 'fyrtio', 'femtio', 'sextio', 'sjuttio', 'åttio', 'nittio']);
+const SV_TEENS = Object.freeze(['tio', 'elva', 'tolv', 'tretton', 'fjorton', 'femton', 'sexton', 'sjutton', 'arton', 'nitton']);
+const SV_ILLIONS = Object.freeze(['', 'tusen', 'miljon', 'miljard', 'biljon', 'biljard', 'triljon', 'triljard', 'kvadriljon', 'kvadriljard', 'kvintiljon', 'kvintiljard']);
+const SV_ILLIONS_PLURAL = Object.freeze(['', 'tusen', 'miljoner', 'miljarder', 'biljoner', 'biljarder', 'triljoner', 'triljarder', 'kvadriljoner', 'kvadriljarder', 'kvintiljoner', 'kvintiljarder']);
+
+const MAX_VALUE = 10n ** 36n - 1n;
+
+const group = (n) => Math.ceil(n.toString().length / 3) - 1;
+const power = (g) => 10n ** BigInt(g * 3);
+const segment = (n, g) => n % power(g + 1);
+const hundment = (n, g) => Number(segment(n, g) / power(g));
+const tenment = (n, g) => hundment(n, g) % 100;
+
+const tenSv = (n) => {
+  if (n === 0) return '';
+  if (n < 10) return SV_ONES[n];
+  if (n < 20) return SV_TEENS[n - 10];
+  const onesDigit = n % 10;
+  const tensDigit = Math.floor(n / 10);
+  if (onesDigit === 0) return SV_TENS[tensDigit];
+  return `${SV_TENS[tensDigit]}${SV_ONES[onesDigit]}`;
+};
+
+const hundredSv = (n) => {
+  if (n < 100 || n >= 1000) return '';
+  const h = Math.floor(n / 100);
+  if (h === 1) return 'etthundra';
+  return `${SV_ONES[h]}hundra`;
+};
+
+/**
+ * Convert a number to Swedish words
+ * @param {number|bigint} n - The number to convert
+ * @returns {string|false} The Swedish word representation
+ *
+ * @example
+ * swedish(42) // 'fyrtiotvå'
+ * swedish(1000) // 'ettusen'
+ */
+const swedish = (n) => {
+  let num;
+
+  if (typeof n === 'bigint') {
+    if (n < 0n || n > MAX_VALUE) return false;
+    num = n;
+  } else if (typeof n === 'number') {
+    if (isNaN(n) || n < 0 || !Number.isInteger(n)) return false;
+    if (n > Number.MAX_SAFE_INTEGER) return false;
+    num = BigInt(n);
+  } else {
+    return false;
+  }
+
+  if (num === 0n) return 'noll';
+  if (num === 1n) return 'en';
+
+  let s = '';
+  for (let i = group(num); i >= 0; i--) {
+    const h = hundment(num, i);
+    if (h > 0) {
+      if (i === 0) {
+        if (h >= 100) s += hundredSv(h) + ' ';
+        const t = tenment(num, i);
+        if (t > 0) s += tenSv(t);
+      } else if (i === 1) {
+        if (h === 1) {
+          s += 'ettusen ';
+        } else {
+          if (h >= 100) s += hundredSv(h) + ' ';
+          const t = tenment(num, i);
+          if (t > 0) s += tenSv(t);
+          s += 'tusen ';
+        }
+      } else {
+        if (h >= 100) s += hundredSv(h) + ' ';
+        const t = tenment(num, i);
+        if (t > 0) {
+          if (t === 1) {
+            s += 'en ';
+          } else {
+            s += tenSv(t) + ' ';
+          }
+        } else if (h < 100 && h >= 1 && h === 1) {
+          s += 'en ';
+        }
+        const illionWord = h === 1 ? SV_ILLIONS[i] : SV_ILLIONS_PLURAL[i];
+        s += `${illionWord} `;
+      }
+    }
+  }
+
+  return s.trim();
+};
+
+export default swedish;
+export { swedish };

package/languages/th.js

@@ -0,0 +1,123 @@
+/**
+ * Thai number-to-words converter
+ * Uses the lan (ล้าน) system for grouping by 1,000,000
+ * @module languages/th
+ */
+
+const TH_ONES = Object.freeze(['', 'หนึ่ง', 'สอง', 'สาม', 'สี่', 'ห้า', 'หก', 'เจ็ด', 'แปด', 'เก้า']);
+const TH_POSITIONS = Object.freeze(['', 'สิบ', 'ร้อย', 'พัน', 'หมื่น', 'แสน']);
+
+/** Maximum supported value (10^36 - 1) */
+const MAX_VALUE = 10n ** 36n - 1n;
+
+
+/**
+ * Convert a group of up to 6 digits (0-999999) to Thai
+ * @param {number} grp - The group value (0-999999)
+ * @returns {string} The Thai representation
+ */
+const groupToTh = (grp) => {
+  if (grp === 0) return '';
+
+  let result = '';
+  const digits = [];
+
+  // Extract digits from right to left (position 0 = ones, 5 = hundred-thousands)
+  let temp = grp;
+  for (let i = 0; i < 6; i++) {
+    digits[i] = temp % 10;
+    temp = Math.floor(temp / 10);
+  }
+
+  // Process from highest position to lowest
+  for (let pos = 5; pos >= 0; pos--) {
+    const d = digits[pos];
+    if (d === 0) continue;
+
+    if (pos === 0) {
+      // Ones place: use เอ็ด when tens digit or higher exists
+      if (d === 1 && grp > 1) {
+        result += 'เอ็ด';
+      } else {
+        result += TH_ONES[d];
+      }
+    } else if (pos === 1) {
+      // Tens place
+      if (d === 1) {
+        // 1 in tens place: just สิบ, not หนึ่งสิบ
+        result += 'สิบ';
+      } else if (d === 2) {
+        // 2 in tens place: ยี่สิบ, not สองสิบ
+        result += 'ยี่สิบ';
+      } else {
+        result += TH_ONES[d] + 'สิบ';
+      }
+    } else {
+      // Hundreds, thousands, ten-thousands, hundred-thousands
+      result += TH_ONES[d] + TH_POSITIONS[pos];
+    }
+  }
+
+  return result;
+};
+
+/**
+ * Convert a number to Thai words
+ * @param {number|bigint} n - The number to convert
+ * @returns {string|false} The Thai word representation
+ *
+ * @example
+ * thai(42) // 'สี่สิบสอง'
+ * thai(11) // 'สิบเอ็ด'
+ * thai(1000000) // 'หนึ่งล้าน'
+ */
+const thai = (n) => {
+  let num;
+
+  if (typeof n === 'bigint') {
+    if (n < 0n || n > MAX_VALUE) return false;
+    num = n;
+  } else if (typeof n === 'number') {
+    if (isNaN(n) || n < 0 || !Number.isInteger(n)) return false;
+    if (n > Number.MAX_SAFE_INTEGER) return false;
+    num = BigInt(n);
+  } else {
+    return false;
+  }
+
+  if (num === 0n) return 'ศูนย์';
+
+  const str = num.toString();
+  const len = str.length;
+
+  // Split into groups of 6 from the right (ล้าน = million grouping)
+  const groups = [];
+  for (let i = len; i > 0; i -= 6) {
+    const start = Math.max(0, i - 6);
+    groups.unshift(str.slice(start, i));
+  }
+
+  let result = '';
+
+  for (let i = 0; i < groups.length; i++) {
+    const grp = parseInt(groups[i], 10);
+    const grpIdx = groups.length - 1 - i;
+
+    if (grp === 0) continue;
+
+    const grpStr = groupToTh(grp);
+    result += grpStr;
+
+    // Append ล้าน scale for each group above the lowest
+    if (grpIdx > 0) {
+      for (let j = 0; j < grpIdx; j++) {
+        result += 'ล้าน';
+      }
+    }
+  }
+
+  return result;
+};
+
+export default thai;
+export { thai, TH_ONES, TH_POSITIONS, MAX_VALUE };

package/languages/tr.js

@@ -0,0 +1,102 @@
+/**
+ * Turkish number-to-words converter
+ * Turkish is very regular with simple concatenation rules
+ * @module languages/tr
+ */
+
+const TR_ONES = Object.freeze(['', 'bir', 'iki', 'üç', 'dört', 'beş', 'altı', 'yedi', 'sekiz', 'dokuz']);
+const TR_TENS = Object.freeze(['', 'on', 'yirmi', 'otuz', 'kırk', 'elli', 'altmış', 'yetmiş', 'seksen', 'doksan']);
+const TR_ILLIONS = Object.freeze(['', 'bin', 'milyon', 'milyar', 'trilyon', 'katrilyon', 'kentilyon', 'sekstilyon', 'septilyon', 'oktilyon', 'nonilyon', 'desilyon']);
+
+/** Maximum supported value (10^36 - 1, up to decillions) */
+const MAX_VALUE = 10n ** 36n - 1n;
+
+const group = (n) => Math.ceil(n.toString().length / 3) - 1;
+const power = (g) => 10n ** BigInt(g * 3);
+const segment = (n, g) => n % power(g + 1);
+const hundment = (n, g) => Number(segment(n, g) / power(g));
+const tenment = (n, g) => hundment(n, g) % 100;
+
+const hundredTr = (n) => {
+  if (n < 100 || n >= 1000) return '';
+  const h = Math.floor(n / 100);
+  // 1 before yüz is omitted: just "yüz", not "bir yüz"
+  if (h === 1) return 'yüz';
+  return `${TR_ONES[h]} yüz`;
+};
+
+const tenTr = (n) => {
+  if (n === 0) return '';
+  if (n < 10) return TR_ONES[n];
+  const onesDigit = n % 10;
+  const tensDigit = Math.floor(n / 10);
+  if (onesDigit === 0) return TR_TENS[tensDigit];
+  return `${TR_TENS[tensDigit]} ${TR_ONES[onesDigit]}`;
+};
+
+/**
+ * Convert a number to Turkish words
+ * @param {number|bigint} n - The number to convert
+ * @returns {string|false} The Turkish word representation
+ *
+ * @example
+ * turkish(42) // 'kırk iki'
+ * turkish(1000) // 'bin'
+ * turkish(1000000) // 'bir milyon'
+ */
+const turkish = (n) => {
+  let num;
+
+  if (typeof n === 'bigint') {
+    if (n < 0n || n > MAX_VALUE) return false;
+    num = n;
+  } else if (typeof n === 'number') {
+    if (isNaN(n) || n < 0 || !Number.isInteger(n)) return false;
+    if (n > Number.MAX_SAFE_INTEGER) return false;
+    num = BigInt(n);
+  } else {
+    return false;
+  }
+
+  if (num === 0n) return 'sıfır';
+
+  let s = '';
+  for (let i = group(num); i >= 0; i--) {
+    const h = hundment(num, i);
+    if (h === 0) continue;
+
+    if (i === 0) {
+      // Ones group: no scale word
+      const hund = hundredTr(h);
+      if (hund) s += hund + ' ';
+      const t = tenment(num, i);
+      const tenWord = tenTr(t);
+      if (tenWord) s += tenWord + ' ';
+    } else if (i === 1) {
+      // Thousands: 1 before bin is omitted
+      if (h === 1) {
+        s += 'bin ';
+      } else {
+        const hund = hundredTr(h);
+        if (hund) s += hund + ' ';
+        const t = tenment(num, i);
+        const tenWord = tenTr(t);
+        if (tenWord) s += tenWord + ' ';
+        s += 'bin ';
+      }
+    } else {
+      // Millions and above: 1 IS included ("bir milyon")
+      const hund = hundredTr(h);
+      if (hund) s += hund + ' ';
+      const t = tenment(num, i);
+      const tenWord = tenTr(t);
+      if (tenWord) s += tenWord + ' ';
+      s += `${TR_ILLIONS[i]} `;
+    }
+  }
+
+  return s.trim();
+};
+
+export default turkish;
+export { turkish, TR_ONES, TR_TENS, TR_ILLIONS, MAX_VALUE };