numberstring 0.1.0 → 1.0.1

package/languages/ja.js

@@ -0,0 +1,122 @@
+/**
+ * Japanese number-to-words converter
+ * Uses the man (万) system for grouping by 10,000
+ * @module languages/ja
+ */
+
+const JA_DIGITS = Object.freeze(['', '一', '二', '三', '四', '五', '六', '七', '八', '九']);
+const JA_SCALES = Object.freeze(['', '万', '億', '兆', '京', '垓', '𥝱', '穣', '溝']);
+
+/** Maximum supported value (10^36 - 1, up to 溝) */
+const MAX_VALUE = 10n ** 36n - 1n;
+
+
+/**
+ * Convert a 4-digit group (0-9999) to Japanese
+ * @param {number} grp - The group value (0-9999)
+ * @returns {string} The Japanese representation
+ */
+const groupToJa = (grp) => {
+  if (grp === 0) return '';
+
+  const thousands = Math.floor(grp / 1000);
+  const hundreds = Math.floor((grp % 1000) / 100);
+  const tens = Math.floor((grp % 100) / 10);
+  const ones = grp % 10;
+
+  let result = '';
+
+  // Thousands: 1 before 千 is omitted
+  if (thousands > 0) {
+    if (thousands === 1) {
+      result += '千';
+    } else {
+      result += JA_DIGITS[thousands] + '千';
+    }
+  }
+
+  // Hundreds: 1 before 百 is omitted
+  if (hundreds > 0) {
+    if (hundreds === 1) {
+      result += '百';
+    } else {
+      result += JA_DIGITS[hundreds] + '百';
+    }
+  }
+
+  // Tens: 1 before 十 is omitted
+  if (tens > 0) {
+    if (tens === 1) {
+      result += '十';
+    } else {
+      result += JA_DIGITS[tens] + '十';
+    }
+  }
+
+  // Ones
+  if (ones > 0) {
+    result += JA_DIGITS[ones];
+  }
+
+  return result;
+};
+
+/**
+ * Convert a number to Japanese words
+ * @param {number|bigint} n - The number to convert
+ * @returns {string|false} The Japanese word representation
+ *
+ * @example
+ * japanese(42) // '四十二'
+ * japanese(1000) // '千'
+ * japanese(10000) // '一万'
+ */
+const japanese = (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 4 from the right
+  const groups = [];
+  for (let i = len; i > 0; i -= 4) {
+    const start = Math.max(0, i - 4);
+    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 = groupToJa(grp);
+
+    // 1 before 万 and above IS included (handled naturally by groupToJa
+    // since grp=1 produces '一' for the ones digit in the group)
+    result += grpStr;
+    if (grpIdx > 0) {
+      result += JA_SCALES[grpIdx];
+    }
+  }
+
+  return result;
+};
+
+export default japanese;
+export { japanese, JA_DIGITS, JA_SCALES, MAX_VALUE };

package/languages/ko.js

@@ -0,0 +1,122 @@
+/**
+ * Korean number-to-words converter (Sino-Korean)
+ * Uses the man (만) system for grouping by 10,000
+ * @module languages/ko
+ */
+
+const KO_DIGITS = Object.freeze(['', '일', '이', '삼', '사', '오', '육', '칠', '팔', '구']);
+const KO_SCALES = Object.freeze(['', '만', '억', '조', '경', '해', '자', '양', '구']);
+
+/** Maximum supported value (10^36 - 1) */
+const MAX_VALUE = 10n ** 36n - 1n;
+
+
+/**
+ * Convert a 4-digit group (0-9999) to Sino-Korean
+ * @param {number} grp - The group value (0-9999)
+ * @returns {string} The Korean representation
+ */
+const groupToKo = (grp) => {
+  if (grp === 0) return '';
+
+  const thousands = Math.floor(grp / 1000);
+  const hundreds = Math.floor((grp % 1000) / 100);
+  const tens = Math.floor((grp % 100) / 10);
+  const ones = grp % 10;
+
+  let result = '';
+
+  // Thousands: 1 before 천 is omitted
+  if (thousands > 0) {
+    if (thousands === 1) {
+      result += '천';
+    } else {
+      result += KO_DIGITS[thousands] + '천';
+    }
+  }
+
+  // Hundreds: 1 before 백 is omitted
+  if (hundreds > 0) {
+    if (hundreds === 1) {
+      result += '백';
+    } else {
+      result += KO_DIGITS[hundreds] + '백';
+    }
+  }
+
+  // Tens: 1 before 십 is omitted
+  if (tens > 0) {
+    if (tens === 1) {
+      result += '십';
+    } else {
+      result += KO_DIGITS[tens] + '십';
+    }
+  }
+
+  // Ones
+  if (ones > 0) {
+    result += KO_DIGITS[ones];
+  }
+
+  return result;
+};
+
+/**
+ * Convert a number to Korean words (Sino-Korean system)
+ * @param {number|bigint} n - The number to convert
+ * @returns {string|false} The Korean word representation
+ *
+ * @example
+ * korean(42) // '사십이'
+ * korean(1000) // '천'
+ * korean(10000) // '일만'
+ */
+const korean = (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 4 from the right
+  const groups = [];
+  for (let i = len; i > 0; i -= 4) {
+    const start = Math.max(0, i - 4);
+    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 = groupToKo(grp);
+
+    // 1 before 만 and above IS included (handled naturally by groupToKo
+    // since grp=1 produces '일' for the ones digit in the group)
+    result += grpStr;
+    if (grpIdx > 0) {
+      result += KO_SCALES[grpIdx];
+    }
+  }
+
+  return result;
+};
+
+export default korean;
+export { korean, KO_DIGITS, KO_SCALES, MAX_VALUE };

package/languages/nl.js

@@ -0,0 +1,112 @@
+/**
+ * Dutch number-to-words converter
+ * Dutch reverses ones and tens (eenentwintig = one-and-twenty)
+ * @module languages/nl
+ */
+
+const NL_ONES = Object.freeze(['', 'een', 'twee', 'drie', 'vier', 'vijf', 'zes', 'zeven', 'acht', 'negen']);
+const NL_TENS = Object.freeze(['', '', 'twintig', 'dertig', 'veertig', 'vijftig', 'zestig', 'zeventig', 'tachtig', 'negentig']);
+const NL_TEENS = Object.freeze(['tien', 'elf', 'twaalf', 'dertien', 'veertien', 'vijftien', 'zestien', 'zeventien', 'achttien', 'negentien']);
+const NL_ILLIONS = Object.freeze(['', 'duizend', 'miljoen', 'miljard', 'biljoen', 'biljard', 'triljoen', 'triljard', 'quadriljoen', 'quadriljard', 'quintiljoen', 'quintiljard']);
+const NL_ILLIONS_PLURAL = Object.freeze(['', 'duizend', 'miljoen', 'miljard', 'biljoen', 'biljard', 'triljoen', 'triljard', 'quadriljoen', 'quadriljard', 'quintiljoen', 'quintiljard']);
+
+/** 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 tenNl = (n) => {
+  if (n === 0) return '';
+  if (n < 10) return NL_ONES[n];
+  if (n < 20) return NL_TEENS[n - 10];
+  const onesDigit = n % 10;
+  const tensDigit = Math.floor(n / 10);
+  if (onesDigit === 0) return NL_TENS[tensDigit];
+  // Use "en" connector between ones and tens
+  // Use "ën" after words ending in vowel-e (twee, drie)
+  const connector = (onesDigit === 2 || onesDigit === 3) ? 'ën' : 'en';
+  return `${NL_ONES[onesDigit]}${connector}${NL_TENS[tensDigit]}`;
+};
+
+const hundredNl = (n) => {
+  if (n < 100 || n >= 1000) return '';
+  const h = Math.floor(n / 100);
+  // 100 = "honderd" (not "eenhonderd")
+  if (h === 1) return 'honderd';
+  return `${NL_ONES[h]}honderd`;
+};
+
+/**
+ * Convert a number to Dutch words
+ * @param {number|bigint} n - The number to convert
+ * @returns {string|false} The Dutch word representation
+ *
+ * @example
+ * dutch(42) // 'tweeënveertig'
+ * dutch(1000) // 'duizend'
+ * dutch(21) // 'eenentwintig'
+ */
+const dutch = (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 'nul';
+
+  let s = '';
+  for (let i = group(num); i >= 0; i--) {
+    const h = hundment(num, i);
+    if (h > 0) {
+      if (i === 0) {
+        // Units group
+        if (h >= 100) s += hundredNl(h);
+        const t = tenment(num, i);
+        if (t > 0) s += tenNl(t);
+      } else if (i === 1) {
+        // Thousands: 1000 = "duizend" (not "eenduizend")
+        if (h === 1) {
+          s += 'duizend';
+        } else {
+          if (h >= 100) s += hundredNl(h);
+          const t = tenment(num, i);
+          if (t > 0) s += tenNl(t);
+          s += 'duizend';
+        }
+      } else {
+        // Millions and above: separated by spaces
+        // 1 million = "een miljoen", 2 million = "twee miljoen"
+        if (h >= 100) s += hundredNl(h);
+        const t = tenment(num, i);
+        if (t > 0) {
+          if (t === 1) {
+            s += 'een ';
+          } else {
+            s += tenNl(t) + ' ';
+          }
+        } else if (h < 100 && h === 1) {
+          s += 'een ';
+        }
+        const illionWord = h === 1 ? NL_ILLIONS[i] : NL_ILLIONS_PLURAL[i];
+        s += `${illionWord} `;
+      }
+    }
+  }
+
+  return s.trim();
+};
+
+export default dutch;
+export { dutch };

package/languages/no.js

@@ -0,0 +1,103 @@
+/**
+ * Norwegian (Bokmål) number-to-words converter
+ * Norwegian uses long scale like Danish but with simpler tens
+ * @module languages/no
+ */
+
+const NO_ONES = Object.freeze(['', 'en', 'to', 'tre', 'fire', 'fem', 'seks', 'sju', 'åtte', 'ni']);
+const NO_TENS = Object.freeze(['', '', 'tjue', 'tretti', 'førti', 'femti', 'seksti', 'sytti', 'åtti', 'nitti']);
+const NO_TEENS = Object.freeze(['ti', 'elleve', 'tolv', 'tretten', 'fjorten', 'femten', 'seksten', 'sytten', 'atten', 'nitten']);
+const NO_ILLIONS = Object.freeze(['', 'tusen', 'million', 'milliard', 'billion', 'billiard', 'trillion', 'trilliard', 'kvadrillion', 'kvadrilliard', 'kvintillion', 'kvintilliard']);
+const NO_ILLIONS_PLURAL = Object.freeze(['', 'tusen', 'millioner', 'milliarder', 'billioner', 'billiarder', 'trillioner', 'trilliarder', 'kvadrillioner', 'kvadrilliarder', 'kvintillioner', 'kvintilliarder']);
+
+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 tenNo = (n) => {
+  if (n === 0) return '';
+  if (n < 10) return NO_ONES[n];
+  if (n < 20) return NO_TEENS[n - 10];
+  const onesDigit = n % 10;
+  const tensDigit = Math.floor(n / 10);
+  if (onesDigit === 0) return NO_TENS[tensDigit];
+  return `${NO_TENS[tensDigit]}${NO_ONES[onesDigit]}`;
+};
+
+const hundredNo = (n) => {
+  if (n < 100 || n >= 1000) return '';
+  const h = Math.floor(n / 100);
+  if (h === 1) return 'etthundre';
+  return `${NO_ONES[h]}hundre`;
+};
+
+/**
+ * Convert a number to Norwegian words
+ * @param {number|bigint} n - The number to convert
+ * @returns {string|false} The Norwegian word representation
+ *
+ * @example
+ * norwegian(42) // 'førtito'
+ * norwegian(1000) // 'ettusen'
+ */
+const norwegian = (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 'null';
+  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 += hundredNo(h) + ' ';
+        const t = tenment(num, i);
+        if (t > 0) s += tenNo(t);
+      } else if (i === 1) {
+        if (h === 1) {
+          s += 'ettusen ';
+        } else {
+          if (h >= 100) s += hundredNo(h) + ' ';
+          const t = tenment(num, i);
+          if (t > 0) s += tenNo(t);
+          s += 'tusen ';
+        }
+      } else {
+        if (h >= 100) s += hundredNo(h) + ' ';
+        const t = tenment(num, i);
+        if (t > 0) {
+          if (t === 1) {
+            s += 'en ';
+          } else {
+            s += tenNo(t) + ' ';
+          }
+        } else if (h < 100 && h >= 1 && h === 1) {
+          s += 'en ';
+        }
+        const illionWord = h === 1 ? NO_ILLIONS[i] : NO_ILLIONS_PLURAL[i];
+        s += `${illionWord} `;
+      }
+    }
+  }
+
+  return s.trim();
+};
+
+export default norwegian;
+export { norwegian };

package/languages/pl.js

@@ -0,0 +1,146 @@
+/**
+ * Polish number-to-words converter
+ * Handles Polish plural forms (singular, 2-4, 5+)
+ * @module languages/pl
+ */
+
+const PL_ONES = Object.freeze(['', 'jeden', 'dwa', 'trzy', 'cztery', 'pięć', 'sześć', 'siedem', 'osiem', 'dziewięć']);
+const PL_TENS = Object.freeze(['', '', 'dwadzieścia', 'trzydzieści', 'czterdzieści', 'pięćdziesiąt', 'sześćdziesiąt', 'siedemdziesiąt', 'osiemdziesiąt', 'dziewięćdziesiąt']);
+const PL_TEENS = Object.freeze(['dziesięć', 'jedenaście', 'dwanaście', 'trzynaście', 'czternaście', 'piętnaście', 'szesnaście', 'siedemnaście', 'osiemnaście', 'dziewiętnaście']);
+const PL_HUNDREDS = Object.freeze(['', 'sto', 'dwieście', 'trzysta', 'czterysta', 'pięćset', 'sześćset', 'siedemset', 'osiemset', 'dziewięćset']);
+const PL_ILLIONS = Object.freeze([
+  ['', '', ''],                          // ones
+  ['tysiąc', 'tysiące', 'tysięcy'],      // thousands
+  ['milion', 'miliony', 'milionów'],     // millions
+  ['miliard', 'miliardy', 'miliardów'], // billions
+  ['bilion', 'biliony', 'bilionów'],     // trillions
+  ['biliard', 'biliardy', 'biliardów'], // quadrillions
+  ['trylion', 'tryliony', 'trylionów'], // quintillions
+  ['tryliard', 'tryliardy', 'tryliardów'], // sextillions
+  ['kwadrylion', 'kwadryliony', 'kwadrylionów'], // septillions
+  ['kwadryliard', 'kwadryliardy', 'kwadryliardów'], // octillions
+  ['kwintylion', 'kwintyliony', 'kwintylionów'], // nonillions
+  ['kwintyliard', 'kwintyliardy', 'kwintyliardów']  // decillions
+]);
+
+/** 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;
+
+/**
+ * Get the correct Polish plural form based on number
+ * Polish has 3 forms: singular (1), plural 2-4, plural 5+
+ * @param {number} n - The number to check
+ * @param {string[]} forms - [singular, plural2_4, plural5_plus]
+ * @returns {string} The correct plural form
+ */
+const getPlPlural = (n, forms) => {
+  if (n === 1) return forms[0];
+  const lastTwo = n % 100;
+  const lastOne = n % 10;
+  if (lastTwo >= 12 && lastTwo <= 14) return forms[2];
+  if (lastOne >= 2 && lastOne <= 4) return forms[1];
+  return forms[2];
+};
+
+const hundredPl = (n) => {
+  if (n < 100 || n >= 1000) return '';
+  return PL_HUNDREDS[Math.floor(n / 100)];
+};
+
+const tenPl = (n) => {
+  if (n === 0) return '';
+  if (n < 10) return PL_ONES[n];
+  if (n < 20) return PL_TEENS[n - 10];
+  const onesDigit = n % 10;
+  const tensDigit = Math.floor(n / 10);
+  if (onesDigit === 0) return PL_TENS[tensDigit];
+  return `${PL_TENS[tensDigit]} ${PL_ONES[onesDigit]}`;
+};
+
+/**
+ * Convert a number to Polish words
+ * @param {number|bigint} n - The number to convert
+ * @returns {string|false} The Polish word representation
+ *
+ * @example
+ * polish(42) // 'czterdzieści dwa'
+ * polish(1000) // 'tysiąc'
+ * polish(2000) // 'dwa tysiące'
+ * polish(5000) // 'pięć tysięcy'
+ */
+const polish = (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 'zero';
+
+  let s = '';
+  for (let i = group(num); i >= 0; i--) {
+    const h = hundment(num, i);
+    if (h > 0) {
+      const hund = hundredPl(h);
+      if (hund) s += hund + ' ';
+
+      const t = tenment(num, i);
+
+      if (i === 0) {
+        // Units group: just tens
+        const tenWord = tenPl(t);
+        if (tenWord) s += tenWord + ' ';
+      } else if (i === 1) {
+        // Thousands
+        if (h === 1 && t === 0) {
+          // Just "tysiąc" for exactly 1 thousand (with possible hundreds)
+          s += 'tysiąc ';
+        } else {
+          if (t > 0) {
+            // Skip "jeden" before "tysiąc" when it's just 1
+            if (t === 1) {
+              s += 'tysiąc ';
+            } else {
+              s += tenPl(t) + ' ';
+              s += getPlPlural(t, PL_ILLIONS[i]) + ' ';
+            }
+          } else {
+            // h >= 100 with no tens portion, use h for plural
+            s += getPlPlural(h, PL_ILLIONS[i]) + ' ';
+          }
+        }
+      } else {
+        // Millions and above
+        if (t > 0) {
+          if (t === 1) {
+            s += 'jeden ';
+          } else {
+            s += tenPl(t) + ' ';
+          }
+        } else if (h < 100 && h === 1) {
+          s += 'jeden ';
+        }
+        const illionWord = getPlPlural(t || h, PL_ILLIONS[i]);
+        s += illionWord + ' ';
+      }
+    }
+  }
+
+  return s.trim().replace(/\s+/g, ' ');
+};
+
+export default polish;
+export { polish };