n2words 3.0.0 → 4.0.0

package/{lib/languages/zh-Hant.js → src/zh-Hant-TW.js}

@@ -1,7 +1,7 @@
 /**
- * Traditional Chinese language converter - Functional Implementation
+ * Traditional Chinese (Taiwan) language converter
  *
- * Self-contained converter for Traditional Chinese.
+ * CLDR: zh-Hant-TW | Traditional Chinese as used in Taiwan
  *
  * Key features:
  * - Myriad-based (萬, 億) grouping - 4 digits
@@ -14,8 +14,10 @@
  * - Some formal numerals differ (參/叁, 貳/贰, 陸/陆)
  */
 
-import { parseNumericValue } from '../utils/parse-numeric.js'
-import { validateOptions } from '../utils/validate-options.js'
+import { parseCardinalValue } from './utils/parse-cardinal.js'
+import { parseCurrencyValue } from './utils/parse-currency.js'
+import { parseOrdinalValue } from './utils/parse-ordinal.js'
+import { validateOptions } from './utils/validate-options.js'
 
 // ============================================================================
 // Vocabulary
@@ -41,6 +43,25 @@ const ZERO = '零'
 const NEGATIVE = '負'
 const DECIMAL_SEP = '點'
 
+// ============================================================================
+// Ordinal Vocabulary
+// ============================================================================
+
+const ORDINAL_PREFIX = '第'
+
+// ============================================================================
+// Currency Vocabulary (New Taiwan Dollar)
+// ============================================================================
+
+// Formal currency (default)
+const YUAN_FORMAL = '圓'
+const JIAO_FORMAL = '角'
+const FEN_FORMAL = '分'
+const ZHENG_FORMAL = '整' // "exactly" suffix when whole amount
+
+// Common currency
+const YUAN_COMMON = '元'
+
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -175,10 +196,12 @@ function decimalDigitsToWords (decimalString, formal = true) {
  * @param {boolean} [options.formal=true] - Use formal/financial numerals
  * @returns {string} The number in Traditional Chinese words
  */
-function toWords (value, options) {
+function toCardinal (value, options) {
   options = validateOptions(options)
-  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
-  const formal = options.formal !== false // Default to true
+  const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
+
+  // Apply option defaults
+  const { formal = true } = options
 
   let result = ''
 
@@ -195,8 +218,116 @@ function toWords (value, options) {
   return result
 }
 
+// ============================================================================
+// ORDINAL: toOrdinal(value, options?)
+// ============================================================================
+
+/**
+ * Converts a non-negative integer to Traditional Chinese ordinal words.
+ *
+ * Traditional Chinese ordinals use "第" prefix + cardinal number.
+ *
+ * @param {bigint} n - Positive integer to convert
+ * @param {boolean} formal - Use formal/financial numerals
+ * @returns {string} Traditional Chinese ordinal words
+ */
+function integerToOrdinal (n, formal = true) {
+  return ORDINAL_PREFIX + integerToWords(n, formal)
+}
+
+/**
+ * Converts a numeric value to Traditional Chinese ordinal words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert (positive integer)
+ * @param {Object} [options] - Optional configuration
+ * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @returns {string} The number as ordinal words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {RangeError} If value is negative, zero, or has a decimal part
+ *
+ * @example
+ * toOrdinal(1)                    // '第壹'
+ * toOrdinal(2)                    // '第貳'
+ * toOrdinal(1, { formal: false }) // '第一'
+ */
+function toOrdinal (value, options) {
+  options = validateOptions(options)
+  const integerPart = parseOrdinalValue(value)
+  const { formal = true } = options
+  return integerToOrdinal(integerPart, formal)
+}
+
+// ============================================================================
+// CURRENCY: toCurrency(value, options?)
+// ============================================================================
+
+/**
+ * Converts a numeric value to Traditional Chinese currency words (New Taiwan Dollar).
+ *
+ * Uses 圓 (yuan), 角 (jiao, 1/10), 分 (fen, 1/100).
+ * Formal writing adds 整 (zheng) for whole amounts.
+ *
+ * @param {number | string | bigint} value - The currency amount to convert
+ * @param {Object} [options] - Optional configuration
+ * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @returns {string} The amount in Traditional Chinese currency words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toCurrency(42)                    // '肆拾貳圓整'
+ * toCurrency(1.50)                  // '壹圓伍角整'
+ * toCurrency(42, { formal: false }) // '四十二元整'
+ */
+function toCurrency (value, options) {
+  options = validateOptions(options)
+  const { isNegative, dollars: yuan, cents } = parseCurrencyValue(value)
+  const { formal = true } = options
+
+  const yuanWord = formal ? YUAN_FORMAL : YUAN_COMMON
+
+  // Split cents into jiao (tens) and fen (ones)
+  const jiao = cents / 10n
+  const fen = cents % 10n
+
+  let result = ''
+  if (isNegative) {
+    result = NEGATIVE
+  }
+
+  // Yuan part (always show for zero with no cents)
+  if (yuan > 0n || cents === 0n) {
+    result += integerToWords(yuan, formal)
+    result += yuanWord
+  }
+
+  // Jiao part (tens of cents)
+  if (jiao > 0n) {
+    const ones = formal ? ONES_FORMAL : ONES_COMMON
+    result += ones[Number(jiao)] + JIAO_FORMAL
+  }
+
+  // Fen part (ones of cents)
+  if (fen > 0n) {
+    const ones = formal ? ONES_FORMAL : ONES_COMMON
+    // Need zero if we have yuan but no jiao
+    if (yuan > 0n && jiao === 0n) {
+      result += ZERO
+    }
+    result += ones[Number(fen)] + FEN_FORMAL
+  } else if (jiao > 0n) {
+    // Has jiao but no fen - add 整
+    result += ZHENG_FORMAL
+  } else {
+    // Whole yuan only - add 整
+    result += ZHENG_FORMAL
+  }
+
+  return result
+}
+
 // ============================================================================
 // Exports
 // ============================================================================
 
-export { toWords }
+export { toCardinal, toOrdinal, toCurrency }

package/dist/languages/am-Latn.js

@@ -1,3 +0,0 @@
-/*! n2words/am-Latn v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const i=e.slice(0,n)||"0",r=e.slice(n+1);return{isNegative:t,integerPart:BigInt(i),decimalPart:r}}function n(e){const[t,n]=e.toLowerCase().split("e"),i=parseInt(n,10),r=t.indexOf("."),s=-1===r?t:t.slice(0,r)+t.slice(r+1),a=(-1===r?t.length:r)+i;return a>=s.length?s+"0".repeat(a-s.length):a<=0?"0."+"0".repeat(-a)+s:s.slice(0,a)+"."+s.slice(a)}const i=["","and","hulet","sost","arat","amist","siddist","sebat","siment","zeteny"],r=["asir","asra and","asra hulet","asra sost","asra arat","asra amist","asra siddist","asra sebat","asra siment","asra zeteny"],s=["","","haya","selasa","arba","hamsa","silsa","seba","semanya","zetena"],a="zero",o=["","shi","miliyon","billiyon"];function u(e){if(0===e)return"";const t=e%10,n=Math.floor(e/10)%10,a=Math.floor(e/100),o=[];return a>0&&o.push(i[a]+" meto"),1===n?o.push(r[t]):(n>1&&o.push(s[n]),t>0&&o.push(i[t])),o.join(" ")}const c=new Array(1e3);for(let e=0;e<1e3;e++)c[e]=u(e);e.amLatn=function(e){const{isNegative:r,integerPart:s,decimalPart:u}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===i)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(e);let l="";return r&&(l="asitegna "),l+=0n===(f=s)?a:f<1000n?c[Number(f)]:function(e){const t=e.toString(),n=t.length,i=[],r=n%3;let s=0;for(r>0&&(i.push(Number(t.slice(0,r))),s=r);s<n;)i.push(Number(t.slice(s,s+3))),s+=3;const a=[];let u=i.length-1;for(let e=0;e<i.length;e++){const t=i[e];0!==t&&a.push(0===u?c[t]:c[t]+" "+(o[u]||"")),u--}return a.join(" ")}(f),u&&(l+=" netib "+function(e){const t=[];for(const n of e){const e=parseInt(n,10);t.push(0===e?a:i[e])}return t.join(" ")}(u)),l;var f}},"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=am-Latn.js.map

package/dist/languages/am-Latn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"am-Latn.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/am-Latn.js"],"sourcesContent":["/**\n * Numeric value parsing utility.\n * Transforms user input (number, string, or bigint) into normalized components.\n * @module parse-numeric\n */\n\n/**\n * Parses a numeric value into its components.\n * @param {number|string|bigint} value\n * @returns {{isNegative: boolean, integerPart: bigint, decimalPart?: string}}\n * @throws {TypeError} If value is not number, string, or bigint\n * @throws {Error} If value is not a valid number format\n */\nexport function parseNumericValue (value) {\n  const type = typeof value\n\n  // BigInt: simplest case\n  if (type === 'bigint') {\n    return value < 0n\n      ? { isNegative: true, integerPart: -value }\n      : { isNegative: false, integerPart: value }\n  }\n\n  // Number: fast path for safe integers\n  if (type === 'number') {\n    if (!Number.isFinite(value)) {\n      throw new Error('Number must be finite (NaN and Infinity are not supported)')\n    }\n    if (Number.isSafeInteger(value)) {\n      return value < 0\n        ? { isNegative: true, integerPart: BigInt(-value) }\n        : { isNegative: false, integerPart: BigInt(value) }\n    }\n    return parseNumericString(numberToString(value))\n  }\n\n  // String input\n  if (type === 'string') {\n    return parseNumericString(normalizeString(value))\n  }\n\n  throw new TypeError(\n    `Invalid value type: expected number, string, or bigint, received ${type}`\n  )\n}\n\n/**\n * Converts a number to decimal string, expanding scientific notation if needed.\n */\nfunction numberToString (value) {\n  const str = value.toString()\n  return (str.includes('e') || str.includes('E'))\n    ? expandScientificNotation(str)\n    : str\n}\n\n/**\n * Validates and normalizes a string numeric input.\n */\nfunction normalizeString (value) {\n  const trimmed = value.trim()\n  if (trimmed.length === 0 || Number.isNaN(Number(trimmed))) {\n    throw new Error(`Invalid number format: \"${value}\"`)\n  }\n  return (trimmed.includes('e') || trimmed.includes('E'))\n    ? expandScientificNotation(trimmed)\n    : trimmed\n}\n\n/**\n * Parses a normalized numeric string into components.\n */\nfunction parseNumericString (str) {\n  const isNegative = str[0] === '-'\n  if (isNegative) str = str.slice(1)\n\n  const dotIndex = str.indexOf('.')\n  if (dotIndex === -1) {\n    return { isNegative, integerPart: BigInt(str) }\n  }\n\n  const integerStr = str.slice(0, dotIndex) || '0'\n  const decimalPart = str.slice(dotIndex + 1)\n  return { isNegative, integerPart: BigInt(integerStr), decimalPart }\n}\n\n/**\n * Expands scientific notation to decimal form (e.g., \"1e21\" → \"1000...\").\n */\nfunction expandScientificNotation (str) {\n  const [mantissa, expStr] = str.toLowerCase().split('e')\n  const exp = parseInt(expStr, 10)\n\n  const dotIndex = mantissa.indexOf('.')\n  const digits = dotIndex === -1\n    ? mantissa\n    : mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1)\n  const integerLength = dotIndex === -1 ? mantissa.length : dotIndex\n  const newDotPosition = integerLength + exp\n\n  if (newDotPosition >= digits.length) {\n    return digits + '0'.repeat(newDotPosition - digits.length)\n  }\n  if (newDotPosition <= 0) {\n    return '0.' + '0'.repeat(-newDotPosition) + digits\n  }\n  return digits.slice(0, newDotPosition) + '.' + digits.slice(newDotPosition)\n}\n","/**\n * Amharic Latin language converter - Functional Implementation\n *\n * Self-contained converter with precomputed lookup tables.\n * Latin/ASCII romanization of Amharic numerals.\n *\n * Key features:\n * - Romanized numerals (and, hulet, sost)\n * - Teens formed with \"asra\" prefix\n * - Keeps \"one\" before hundred: \"and meto\" (100)\n * - Short scale naming\n * - Per-digit decimal reading\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES = ['', 'and', 'hulet', 'sost', 'arat', 'amist', 'siddist', 'sebat', 'siment', 'zeteny']\nconst TEENS = ['asir', 'asra and', 'asra hulet', 'asra sost', 'asra arat', 'asra amist', 'asra siddist', 'asra sebat', 'asra siment', 'asra zeteny']\nconst TENS = ['', '', 'haya', 'selasa', 'arba', 'hamsa', 'silsa', 'seba', 'semanya', 'zetena']\n\nconst HUNDRED = 'meto'\nconst THOUSAND = 'shi'\n\nconst ZERO = 'zero'\nconst NEGATIVE = 'asitegna'\nconst DECIMAL_SEP = 'netib'\n\n// Short scale\nconst SCALE_WORDS = ['', THOUSAND, 'miliyon', 'billiyon']\n\n// ============================================================================\n// Precomputed Lookup Table\n// ============================================================================\n\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tensDigit = Math.floor(n / 10) % 10\n  const hundredsDigit = Math.floor(n / 100)\n\n  const parts = []\n\n  // Amharic keeps \"one\" before hundred: \"and meto\" (100)\n  if (hundredsDigit > 0) {\n    parts.push(ONES[hundredsDigit] + ' ' + HUNDRED)\n  }\n\n  if (tensDigit === 1) {\n    parts.push(TEENS[ones])\n  } else {\n    if (tensDigit > 1) {\n      parts.push(TENS[tensDigit])\n    }\n    if (ones > 0) {\n      parts.push(ONES[ones])\n    }\n  }\n\n  return parts.join(' ')\n}\n\nconst SEGMENTS = new Array(1000)\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS[i] = buildSegment(i)\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  if (n < 1000n) {\n    return SEGMENTS[Number(n)]\n  }\n\n  return buildLargeNumberWords(n)\n}\n\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      const scaleWord = SCALE_WORDS[scaleIndex] || ''\n\n      if (scaleIndex === 0) {\n        parts.push(SEGMENTS[segment])\n      } else {\n        parts.push(SEGMENTS[segment] + ' ' + scaleWord)\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\nfunction decimalPartToWords (decimalPart) {\n  // Per-digit decimal reading\n  const digits = []\n  for (const char of decimalPart) {\n    const d = parseInt(char, 10)\n    digits.push(d === 0 ? ZERO : ONES[d])\n  }\n  return digits.join(' ')\n}\n\n/**\n * Converts a numeric value to Amharic (Latin script) words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Amharic Latin words\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Exports\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","TEENS","TENS","ZERO","SCALE_WORDS","buildSegment","n","ones","tensDigit","Math","floor","hundredsDigit","parts","push","join","SEGMENTS","Array","i","value","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","numStr","len","segments","remainderLen","pos","scaleIndex","segment","buildLargeNumberWords","char","d","decimalPartToWords"],"mappings":"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"}

package/dist/languages/am.js

@@ -1,3 +0,0 @@
-/*! n2words/am v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const r=e.slice(0,n)||"0",i=e.slice(n+1);return{isNegative:t,integerPart:BigInt(r),decimalPart:i}}function n(e){const[t,n]=e.toLowerCase().split("e"),r=parseInt(n,10),i=t.indexOf("."),o=-1===i?t:t.slice(0,i)+t.slice(i+1),s=(-1===i?t.length:i)+r;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const r=["","አንድ","ሁለት","ሶስት","አራት","አምስት","ስድስት","ሰባት","ስምንት","ዘጠኝ"],i=["አስር","አስራ አንድ","አስራ ሁለት","አስራ ሶስት","አስራ አራት","አስራ አምስት","አስራ ስድስት","አስራ ሰባት","አስራ ስምንት","አስራ ዘጠኝ"],o=["","","ሃያ","ሰላሳ","አርባ","ሃምሳ","ስልሳ","ሰባ","ሰማንያ","ዘጠና"],s=["","ሺ","ሚሊዮን","ቢሊዮን"];function u(e){if(0===e)return"";const t=e%10,n=Math.floor(e/10)%10,s=Math.floor(e/100),u=[];return s>0&&u.push(r[s]+" መቶ"),1===n?u.push(i[t]):(n>1&&u.push(o[n]),t>0&&u.push(r[t])),u.join(" ")}const c=new Array(1e3);for(let e=0;e<1e3;e++)c[e]=u(e);e.am=function(e){const{isNegative:i,integerPart:o,decimalPart:u}=function(e){const r=typeof e;if("bigint"===r)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===r){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===r)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${r}`)}(e);let f="";return i&&(f="አሉታዊ "),f+=0n===(a=o)?"ዜሮ":a<1000n?c[Number(a)]:function(e){const t=e.toString(),n=t.length,r=[],i=n%3;let o=0;for(i>0&&(r.push(Number(t.slice(0,i))),o=i);o<n;)r.push(Number(t.slice(o,o+3))),o+=3;const u=[];let f=r.length-1;for(let e=0;e<r.length;e++){const t=r[e];0!==t&&u.push(0===f?c[t]:c[t]+" "+(s[f]||"")),f--}return u.join(" ")}(a),u&&(f+=" ነጥብ "+function(e){const t=[];for(const n of e){const e=parseInt(n,10);t.push(0===e?"ዜሮ":r[e])}return t.join(" ")}(u)),f;var a}},"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=am.js.map

package/dist/languages/am.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"am.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/am.js"],"sourcesContent":["/**\n * Numeric value parsing utility.\n * Transforms user input (number, string, or bigint) into normalized components.\n * @module parse-numeric\n */\n\n/**\n * Parses a numeric value into its components.\n * @param {number|string|bigint} value\n * @returns {{isNegative: boolean, integerPart: bigint, decimalPart?: string}}\n * @throws {TypeError} If value is not number, string, or bigint\n * @throws {Error} If value is not a valid number format\n */\nexport function parseNumericValue (value) {\n  const type = typeof value\n\n  // BigInt: simplest case\n  if (type === 'bigint') {\n    return value < 0n\n      ? { isNegative: true, integerPart: -value }\n      : { isNegative: false, integerPart: value }\n  }\n\n  // Number: fast path for safe integers\n  if (type === 'number') {\n    if (!Number.isFinite(value)) {\n      throw new Error('Number must be finite (NaN and Infinity are not supported)')\n    }\n    if (Number.isSafeInteger(value)) {\n      return value < 0\n        ? { isNegative: true, integerPart: BigInt(-value) }\n        : { isNegative: false, integerPart: BigInt(value) }\n    }\n    return parseNumericString(numberToString(value))\n  }\n\n  // String input\n  if (type === 'string') {\n    return parseNumericString(normalizeString(value))\n  }\n\n  throw new TypeError(\n    `Invalid value type: expected number, string, or bigint, received ${type}`\n  )\n}\n\n/**\n * Converts a number to decimal string, expanding scientific notation if needed.\n */\nfunction numberToString (value) {\n  const str = value.toString()\n  return (str.includes('e') || str.includes('E'))\n    ? expandScientificNotation(str)\n    : str\n}\n\n/**\n * Validates and normalizes a string numeric input.\n */\nfunction normalizeString (value) {\n  const trimmed = value.trim()\n  if (trimmed.length === 0 || Number.isNaN(Number(trimmed))) {\n    throw new Error(`Invalid number format: \"${value}\"`)\n  }\n  return (trimmed.includes('e') || trimmed.includes('E'))\n    ? expandScientificNotation(trimmed)\n    : trimmed\n}\n\n/**\n * Parses a normalized numeric string into components.\n */\nfunction parseNumericString (str) {\n  const isNegative = str[0] === '-'\n  if (isNegative) str = str.slice(1)\n\n  const dotIndex = str.indexOf('.')\n  if (dotIndex === -1) {\n    return { isNegative, integerPart: BigInt(str) }\n  }\n\n  const integerStr = str.slice(0, dotIndex) || '0'\n  const decimalPart = str.slice(dotIndex + 1)\n  return { isNegative, integerPart: BigInt(integerStr), decimalPart }\n}\n\n/**\n * Expands scientific notation to decimal form (e.g., \"1e21\" → \"1000...\").\n */\nfunction expandScientificNotation (str) {\n  const [mantissa, expStr] = str.toLowerCase().split('e')\n  const exp = parseInt(expStr, 10)\n\n  const dotIndex = mantissa.indexOf('.')\n  const digits = dotIndex === -1\n    ? mantissa\n    : mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1)\n  const integerLength = dotIndex === -1 ? mantissa.length : dotIndex\n  const newDotPosition = integerLength + exp\n\n  if (newDotPosition >= digits.length) {\n    return digits + '0'.repeat(newDotPosition - digits.length)\n  }\n  if (newDotPosition <= 0) {\n    return '0.' + '0'.repeat(-newDotPosition) + digits\n  }\n  return digits.slice(0, newDotPosition) + '.' + digits.slice(newDotPosition)\n}\n","/**\n * Amharic language converter - Functional Implementation\n *\n * Self-contained converter with precomputed lookup tables.\n * Native Ge'ez script (ግዕዝ) output.\n *\n * Key features:\n * - Ge'ez/Ethiopic script numerals\n * - Teens formed with \"አስራ\" prefix\n * - Keeps \"one\" before hundred: \"አንድ መቶ\" (100)\n * - Short scale naming\n * - Per-digit decimal reading\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES = ['', 'አንድ', 'ሁለት', 'ሶስት', 'አራት', 'አምስት', 'ስድስት', 'ሰባት', 'ስምንት', 'ዘጠኝ']\nconst TEENS = ['አስር', 'አስራ አንድ', 'አስራ ሁለት', 'አስራ ሶስት', 'አስራ አራት', 'አስራ አምስት', 'አስራ ስድስት', 'አስራ ሰባት', 'አስራ ስምንት', 'አስራ ዘጠኝ']\nconst TENS = ['', '', 'ሃያ', 'ሰላሳ', 'አርባ', 'ሃምሳ', 'ስልሳ', 'ሰባ', 'ሰማንያ', 'ዘጠና']\n\nconst HUNDRED = 'መቶ'\nconst THOUSAND = 'ሺ'\n\nconst ZERO = 'ዜሮ'\nconst NEGATIVE = 'አሉታዊ'\nconst DECIMAL_SEP = 'ነጥብ'\n\n// Short scale\nconst SCALE_WORDS = ['', THOUSAND, 'ሚሊዮን', 'ቢሊዮን']\n\n// ============================================================================\n// Precomputed Lookup Table\n// ============================================================================\n\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tensDigit = Math.floor(n / 10) % 10\n  const hundredsDigit = Math.floor(n / 100)\n\n  const parts = []\n\n  // Amharic keeps \"one\" before hundred: \"አንድ መቶ\" (100)\n  if (hundredsDigit > 0) {\n    parts.push(ONES[hundredsDigit] + ' ' + HUNDRED)\n  }\n\n  if (tensDigit === 1) {\n    parts.push(TEENS[ones])\n  } else {\n    if (tensDigit > 1) {\n      parts.push(TENS[tensDigit])\n    }\n    if (ones > 0) {\n      parts.push(ONES[ones])\n    }\n  }\n\n  return parts.join(' ')\n}\n\nconst SEGMENTS = new Array(1000)\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS[i] = buildSegment(i)\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  if (n < 1000n) {\n    return SEGMENTS[Number(n)]\n  }\n\n  return buildLargeNumberWords(n)\n}\n\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      const scaleWord = SCALE_WORDS[scaleIndex] || ''\n\n      if (scaleIndex === 0) {\n        parts.push(SEGMENTS[segment])\n      } else {\n        parts.push(SEGMENTS[segment] + ' ' + scaleWord)\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\nfunction decimalPartToWords (decimalPart) {\n  // Per-digit decimal reading\n  const digits = []\n  for (const char of decimalPart) {\n    const d = parseInt(char, 10)\n    digits.push(d === 0 ? ZERO : ONES[d])\n  }\n  return digits.join(' ')\n}\n\n/**\n * Converts a numeric value to Amharic words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Amharic words\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Exports\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","TEENS","TENS","SCALE_WORDS","buildSegment","n","ones","tensDigit","Math","floor","hundredsDigit","parts","push","join","SEGMENTS","Array","i","value","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","numStr","len","segments","remainderLen","pos","scaleIndex","segment","buildLargeNumberWords","char","d","decimalPartToWords"],"mappings":"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"}

package/dist/languages/ar.js

@@ -1,3 +0,0 @@
-/*! n2words/ar v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const i=e.slice(0,n)||"0",r=e.slice(n+1);return{isNegative:t,integerPart:BigInt(i),decimalPart:r}}function n(e){const[t,n]=e.toLowerCase().split("e"),i=parseInt(n,10),r=t.indexOf("."),o=-1===r?t:t.slice(0,r)+t.slice(r+1),s=(-1===r?t.length:r)+i;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const i=["عشرون","ثلاثون","أربعون","خمسون","ستون","سبعون","ثمانون","تسعون"],r=["","مائة","مئتان","ثلاثمائة","أربعمائة","خمسمائة","ستمائة","سبعمائة","ثمانمائة","تسعمائة"],o=["مائة","ألف","مليون","مليار","تريليون","كوادريليون","كوينتليون","سكستيليون"],s=["","ألفاً","مليوناً","ملياراً","تريليوناً","كوادريليوناً","كوينتليوناً","سكستيليوناً"],u=["","آلاف","ملايين","مليارات","تريليونات","كوادريليونات","كوينتليونات","سكستيليونات"],c=["مئتان","ألفان","مليونان","ملياران","تريليونان","كوادريليونان","كوينتليونان","سكستيليونان"],f=["مئتا","ألفا","مليونا","مليارا","تريليونا","كوادريليونا","كوينتليونا","سكستيليونا"],l=["واحد","اثنان","ثلاثة","أربعة","خمسة","ستة","سبعة","ثمانية","تسعة","عشرة","أحد عشر","اثنا عشر","ثلاثة عشر","أربعة عشر","خمسة عشر","ستة عشر","سبعة عشر","ثمانية عشر","تسعة عشر"],a=["واحدة","اثنتان","ثلاث","أربع","خمس","ست","سبع","ثمان","تسع","عشر","إحدى عشرة","اثنتا عشرة","ثلاث عشرة","أربع عشرة","خمس عشرة","ست عشرة","سبع عشرة","ثماني عشرة","تسع عشرة"];function g(e,t,n,s){const u=e%100,l=Math.trunc(e/100);let a="";if(l>0)if(0===u&&2===l)a=c[0];else{const e=r[l];e&&(a=e,0!==u&&(a+=" و"))}if(u>0)if(u<20)if(2===u&&0===l&&t>0){const i=Number(n),r=Math.trunc(Math.log10(i));r%3==0&&n===BigInt(2*Math.pow(10,r))?a+=2===e?c[t]:f[t]:a+=c[t]}else a+=1===u&&t>0?o[t]:s[u-1];else{const e=u%10,t=Math.trunc(u/10)-2;e>0&&(a+=s[e-1]+" و"),a+=i[t]}return a}function p(e,t){if(0n===e)return"صفر";const n="feminine"===(t.gender||"masculine")?a:l;let i=e,r=0;const c=[];for(;i>0n;){const t=Number(i%1000n);if(i/=1000n,t>0){const i=g(t,r,e,n);if(i){let e=i;r>0&&t>2&&(e+=1==t%100?" "+o[r]:t>=3&&t<=10?" "+u[r]:" "+(c.length>0?s[r]:o[r])),c.unshift(e)}}r++}if(1===c.length)return c[0];let f=c[0];for(let e=1;e<c.length;e++)f+=" و"+c[e];return f}e.ar=function(e,i){i=function(e){if(void 0===e)return{};if(function(e){if(null===e||"object"!=typeof e)return!1;const t=Object.getPrototypeOf(e);return null===t||t===Object.prototype}(e))return e;throw new TypeError("Invalid options: expected plain object or undefined, got "+typeof e)}(i);const{isNegative:r,integerPart:o,decimalPart:s}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===i)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(e),u=[];return r&&u.push(i.negativeWord||"ناقص"),u.push(p(o,i)),s&&(u.push("فاصلة"),u.push(function(e,t){const n=[];let i=0;for(;i<e.length&&"0"===e[i];)n.push("صفر"),i++;const r=e.slice(i);return r&&n.push(p(BigInt(r),t)),n.join(" ")}(s,i))),u.join(" ")}},"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=ar.js.map

package/dist/languages/ar.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ar.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/ar.js","../../lib/utils/validate-options.js","../../lib/utils/is-plain-object.js"],"sourcesContent":["/**\n * Numeric value parsing utility.\n * Transforms user input (number, string, or bigint) into normalized components.\n * @module parse-numeric\n */\n\n/**\n * Parses a numeric value into its components.\n * @param {number|string|bigint} value\n * @returns {{isNegative: boolean, integerPart: bigint, decimalPart?: string}}\n * @throws {TypeError} If value is not number, string, or bigint\n * @throws {Error} If value is not a valid number format\n */\nexport function parseNumericValue (value) {\n  const type = typeof value\n\n  // BigInt: simplest case\n  if (type === 'bigint') {\n    return value < 0n\n      ? { isNegative: true, integerPart: -value }\n      : { isNegative: false, integerPart: value }\n  }\n\n  // Number: fast path for safe integers\n  if (type === 'number') {\n    if (!Number.isFinite(value)) {\n      throw new Error('Number must be finite (NaN and Infinity are not supported)')\n    }\n    if (Number.isSafeInteger(value)) {\n      return value < 0\n        ? { isNegative: true, integerPart: BigInt(-value) }\n        : { isNegative: false, integerPart: BigInt(value) }\n    }\n    return parseNumericString(numberToString(value))\n  }\n\n  // String input\n  if (type === 'string') {\n    return parseNumericString(normalizeString(value))\n  }\n\n  throw new TypeError(\n    `Invalid value type: expected number, string, or bigint, received ${type}`\n  )\n}\n\n/**\n * Converts a number to decimal string, expanding scientific notation if needed.\n */\nfunction numberToString (value) {\n  const str = value.toString()\n  return (str.includes('e') || str.includes('E'))\n    ? expandScientificNotation(str)\n    : str\n}\n\n/**\n * Validates and normalizes a string numeric input.\n */\nfunction normalizeString (value) {\n  const trimmed = value.trim()\n  if (trimmed.length === 0 || Number.isNaN(Number(trimmed))) {\n    throw new Error(`Invalid number format: \"${value}\"`)\n  }\n  return (trimmed.includes('e') || trimmed.includes('E'))\n    ? expandScientificNotation(trimmed)\n    : trimmed\n}\n\n/**\n * Parses a normalized numeric string into components.\n */\nfunction parseNumericString (str) {\n  const isNegative = str[0] === '-'\n  if (isNegative) str = str.slice(1)\n\n  const dotIndex = str.indexOf('.')\n  if (dotIndex === -1) {\n    return { isNegative, integerPart: BigInt(str) }\n  }\n\n  const integerStr = str.slice(0, dotIndex) || '0'\n  const decimalPart = str.slice(dotIndex + 1)\n  return { isNegative, integerPart: BigInt(integerStr), decimalPart }\n}\n\n/**\n * Expands scientific notation to decimal form (e.g., \"1e21\" → \"1000...\").\n */\nfunction expandScientificNotation (str) {\n  const [mantissa, expStr] = str.toLowerCase().split('e')\n  const exp = parseInt(expStr, 10)\n\n  const dotIndex = mantissa.indexOf('.')\n  const digits = dotIndex === -1\n    ? mantissa\n    : mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1)\n  const integerLength = dotIndex === -1 ? mantissa.length : dotIndex\n  const newDotPosition = integerLength + exp\n\n  if (newDotPosition >= digits.length) {\n    return digits + '0'.repeat(newDotPosition - digits.length)\n  }\n  if (newDotPosition <= 0) {\n    return '0.' + '0'.repeat(-newDotPosition) + digits\n  }\n  return digits.slice(0, newDotPosition) + '.' + digits.slice(newDotPosition)\n}\n","/**\n * Arabic language converter - Functional Implementation\n *\n * Self-contained converter with gender agreement and complex pluralization.\n *\n * Key features:\n * - Gender agreement (masculine/feminine forms)\n * - Complex pluralization (singular/dual/plural)\n * - Traditional Arabic number naming conventions\n * - \"و\" (and) conjunction between segments\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\nimport { validateOptions } from '../utils/validate-options.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst TENS = ['عشرون', 'ثلاثون', 'أربعون', 'خمسون', 'ستون', 'سبعون', 'ثمانون', 'تسعون']\nconst HUNDREDS = ['', 'مائة', 'مئتان', 'ثلاثمائة', 'أربعمائة', 'خمسمائة', 'ستمائة', 'سبعمائة', 'ثمانمائة', 'تسعمائة']\n\n// Magnitude words with three forms: singular, appended (tanween), plural\nconst SCALE_WORDS = ['مائة', 'ألف', 'مليون', 'مليار', 'تريليون', 'كوادريليون', 'كوينتليون', 'سكستيليون']\nconst SCALE_APPENDED = ['', 'ألفاً', 'مليوناً', 'ملياراً', 'تريليوناً', 'كوادريليوناً', 'كوينتليوناً', 'سكستيليوناً']\nconst SCALE_PLURAL = ['', 'آلاف', 'ملايين', 'مليارات', 'تريليونات', 'كوادريليونات', 'كوينتليونات', 'سكستيليونات']\n\n// Dual forms\nconst DUAL = ['مئتان', 'ألفان', 'مليونان', 'ملياران', 'تريليونان', 'كوادريليونان', 'كوينتليونان', 'سكستيليونان']\nconst DUAL_APPENDED = ['مئتا', 'ألفا', 'مليونا', 'مليارا', 'تريليونا', 'كوادريليونا', 'كوينتليونا', 'سكستيليونا']\n\n// Gender-specific forms (1-19)\nconst ONES_MASC = ['واحد', 'اثنان', 'ثلاثة', 'أربعة', 'خمسة', 'ستة', 'سبعة', 'ثمانية', 'تسعة', 'عشرة', 'أحد عشر', 'اثنا عشر', 'ثلاثة عشر', 'أربعة عشر', 'خمسة عشر', 'ستة عشر', 'سبعة عشر', 'ثمانية عشر', 'تسعة عشر']\nconst ONES_FEM = ['واحدة', 'اثنتان', 'ثلاث', 'أربع', 'خمس', 'ست', 'سبع', 'ثمان', 'تسع', 'عشر', 'إحدى عشرة', 'اثنتا عشرة', 'ثلاث عشرة', 'أربع عشرة', 'خمس عشرة', 'ست عشرة', 'سبع عشرة', 'ثماني عشرة', 'تسع عشرة']\n\nconst ZERO = 'صفر'\nconst NEGATIVE = 'ناقص'\nconst DECIMAL_SEP = 'فاصلة'\nconst AND = 'و'\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Convert a 3-digit group to words.\n * Returns a clean string with no leading/trailing spaces.\n * Arabic \"و\" (and) is attached to following word: \"مائة وخمسة\" not \"مائة و خمسة\"\n */\nfunction segmentToWords (groupNumber, groupLevel, fullNumber, ones) {\n  const tensValue = groupNumber % 100\n  const hundredsDigit = Math.trunc(groupNumber / 100)\n  let result = ''\n\n  // Process hundreds\n  if (hundredsDigit > 0) {\n    if (tensValue === 0 && hundredsDigit === 2) {\n      result = DUAL[0]\n    } else {\n      const hundredsWord = HUNDREDS[hundredsDigit]\n      if (hundredsWord) {\n        result = hundredsWord\n        if (tensValue !== 0) {\n          result += ' ' + AND // \"مائة و\" - و attaches to next word\n        }\n      }\n    }\n  }\n\n  // Process tens and ones\n  if (tensValue > 0) {\n    if (tensValue < 20) {\n      if (tensValue === 2 && hundredsDigit === 0 && groupLevel > 0) {\n        const numValue = Number(fullNumber)\n        const pow = Math.trunc(Math.log10(numValue))\n        if (pow % 3 === 0 && fullNumber === BigInt(2 * Math.pow(10, pow))) {\n          result += (groupNumber === 2 ? DUAL[groupLevel] : DUAL_APPENDED[groupLevel])\n        } else {\n          result += DUAL[groupLevel]\n        }\n      } else if (tensValue === 1 && groupLevel > 0) {\n        result += SCALE_WORDS[groupLevel]\n      } else {\n        result += ones[tensValue - 1]\n      }\n    } else {\n      const onesDigit = tensValue % 10\n      const tensIndex = Math.trunc(tensValue / 10) - 2\n\n      if (onesDigit > 0) {\n        result += ones[onesDigit - 1] + ' ' + AND // \"ستة و\" attaches to tens\n      }\n      result += TENS[tensIndex]\n    }\n  }\n\n  return result\n}\n\nfunction integerToWords (n, options) {\n  if (n === 0n) return ZERO\n\n  const gender = options.gender || 'masculine'\n  const ones = gender === 'feminine' ? ONES_FEM : ONES_MASC\n\n  let temp = n\n  let group = 0\n  const groups = []\n\n  while (temp > 0n) {\n    const numberToProcess = Number(temp % 1000n)\n    temp = temp / 1000n\n\n    if (numberToProcess > 0) {\n      const groupDescription = segmentToWords(numberToProcess, group, n, ones)\n\n      if (groupDescription) {\n        let groupText = groupDescription\n\n        // Add scale word for groups > 0\n        if (group > 0 && numberToProcess > 2) {\n          const remainder = numberToProcess % 100\n          if (remainder === 1) {\n            groupText += ' ' + SCALE_WORDS[group]\n          } else if (numberToProcess >= 3 && numberToProcess <= 10) {\n            groupText += ' ' + SCALE_PLURAL[group]\n          } else {\n            groupText += ' ' + (groups.length > 0 ? SCALE_APPENDED[group] : SCALE_WORDS[group])\n          }\n        }\n\n        groups.unshift(groupText)\n      }\n    }\n\n    group++\n  }\n\n  // Join groups with و (and) - space before و, attaches to next word\n  // Use simple join since segmentToWords returns clean strings\n  if (groups.length === 1) return groups[0]\n\n  // Build result: \"group1 وgroup2 وgroup3\"\n  let result = groups[0]\n  for (let i = 1; i < groups.length; i++) {\n    result += ' ' + AND + groups[i]\n  }\n  return result\n}\n\nfunction decimalPartToWords (decimalPart, options) {\n  const parts = []\n  let i = 0\n\n  while (i < decimalPart.length && decimalPart[i] === '0') {\n    parts.push(ZERO)\n    i++\n  }\n\n  const remainder = decimalPart.slice(i)\n  if (remainder) {\n    parts.push(integerToWords(BigInt(remainder), options))\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts a numeric value to Arabic words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @param {Object} [options] - Optional configuration\n * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender\n * @param {string} [options.negativeWord] - Custom word for negative numbers\n * @returns {string} The number in Arabic words\n *\n * @example\n * toWords(1)                        // 'واحد'\n * toWords(1, {gender: 'feminine'})  // 'واحدة'\n */\nfunction toWords (value, options) {\n  options = validateOptions(options)\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  const parts = []\n\n  if (isNegative) {\n    parts.push(options.negativeWord || NEGATIVE)\n  }\n\n  parts.push(integerToWords(integerPart, options))\n\n  if (decimalPart) {\n    parts.push(DECIMAL_SEP)\n    parts.push(decimalPartToWords(decimalPart, options))\n  }\n\n  return parts.join(' ')\n}\n\n// ============================================================================\n// Exports\n// ============================================================================\n\nexport { toWords }\n","import { isPlainObject } from './is-plain-object.js'\n\n/**\n * Validates and normalizes the options parameter.\n *\n * @param {*} options The options value to validate\n * @returns {Object} A valid options object (empty object if undefined)\n * @throws {TypeError} If options is not undefined or a plain object\n */\nexport function validateOptions (options) {\n  if (options === undefined) return {}\n  if (isPlainObject(options)) return options\n  throw new TypeError(\n    `Invalid options: expected plain object or undefined, got ${typeof options}`\n  )\n}\n","/**\n * Checks if a value is a plain object (not null, array, or other object types).\n *\n * A plain object is one created by:\n * - Object literal: `{}`\n * - Object.create(null): null-prototype object\n *\n * This excludes arrays, class instances, Map, Set, and other object types.\n *\n * @param {*} value Value to check\n * @returns {boolean} True if value is a plain object\n */\nexport function isPlainObject (value) {\n  if (value === null || typeof value !== 'object') return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === null || proto === Object.prototype\n}\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","TENS","HUNDREDS","SCALE_WORDS","SCALE_APPENDED","SCALE_PLURAL","DUAL","DUAL_APPENDED","ONES_MASC","ONES_FEM","segmentToWords","groupNumber","groupLevel","fullNumber","ones","tensValue","hundredsDigit","Math","trunc","result","hundredsWord","numValue","Number","pow","log10","onesDigit","tensIndex","integerToWords","n","options","gender","temp","group","groups","numberToProcess","groupDescription","groupText","unshift","i","value","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","parts","push","negativeWord","remainder","join","decimalPartToWords"],"mappings":"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"}

package/dist/languages/az.js

@@ -1,3 +0,0 @@
-/*! n2words/az v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,n;e=this,n=function(e){"use strict";function n(e){const n="-"===e[0];n&&(e=e.slice(1));const t=e.indexOf(".");if(-1===t)return{isNegative:n,integerPart:BigInt(e)};const i=e.slice(0,t)||"0",r=e.slice(t+1);return{isNegative:n,integerPart:BigInt(i),decimalPart:r}}function t(e){const[n,t]=e.toLowerCase().split("e"),i=parseInt(t,10),r=n.indexOf("."),o=-1===r?n:n.slice(0,r)+n.slice(r+1),s=(-1===r?n.length:r)+i;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const i=["","bir","iki","üç","dörd","beş","altı","yeddi","səkkiz","doqquz"],r=["on","on bir","on iki","on üç","on dörd","on beş","on altı","on yeddi","on səkkiz","on doqquz"],o=["","","iyirmi","otuz","qırx","əlli","altmış","yetmiş","səksən","doxsan"],s="sıfır",u=["","min","milyon","milyar","trilyon","katrilyon","kentilyon"];function l(e){if(0===e)return"";const n=e%10,t=Math.floor(e/10)%10,s=Math.floor(e/100),u=[];return s>0&&u.push(1===s?"yüz":i[s]+" yüz"),1===t?u.push(r[n]):(t>1&&u.push(o[t]),n>0&&u.push(i[n])),u.join(" ")}const c=new Array(1e3);for(let e=0;e<1e3;e++)c[e]=l(e);function a(e){return 0n===e?s:e<1000n?c[Number(e)]:function(e){const n=e.toString(),t=n.length,i=[],r=t%3;let o=0;for(r>0&&(i.push(Number(n.slice(0,r))),o=r);o<t;)i.push(Number(n.slice(o,o+3))),o+=3;const s=[];let l=i.length-1;for(let e=0;e<i.length;e++){const n=i[e];if(0!==n){const e=u[l]||"";s.push(0===l?c[n]:1===l&&1===n?e:c[n]+" "+e)}l--}return s.join(" ")}(e)}e.az=function(e){const{isNegative:i,integerPart:r,decimalPart:o}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:n(function(e){const n=e.toString();return n.includes("e")||n.includes("E")?t(n):n}(e))}if("string"===i)return n(function(e){const n=e.trim();if(0===n.length||Number.isNaN(Number(n)))throw new Error(`Invalid number format: "${e}"`);return n.includes("e")||n.includes("E")?t(n):n}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(e);let u="";return i&&(u="mənfi "),u+=a(r),o&&(u+=" nöqtə "+function(e){let n="",t=0;for(;t<e.length&&"0"===e[t];)n&&(n+=" "),n+=s,t++;const i=e.slice(t);return i&&(n&&(n+=" "),n+=a(BigInt(i))),n}(o)),u}},"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=az.js.map

package/dist/languages/az.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"az.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/az.js"],"sourcesContent":["/**\n * Numeric value parsing utility.\n * Transforms user input (number, string, or bigint) into normalized components.\n * @module parse-numeric\n */\n\n/**\n * Parses a numeric value into its components.\n * @param {number|string|bigint} value\n * @returns {{isNegative: boolean, integerPart: bigint, decimalPart?: string}}\n * @throws {TypeError} If value is not number, string, or bigint\n * @throws {Error} If value is not a valid number format\n */\nexport function parseNumericValue (value) {\n  const type = typeof value\n\n  // BigInt: simplest case\n  if (type === 'bigint') {\n    return value < 0n\n      ? { isNegative: true, integerPart: -value }\n      : { isNegative: false, integerPart: value }\n  }\n\n  // Number: fast path for safe integers\n  if (type === 'number') {\n    if (!Number.isFinite(value)) {\n      throw new Error('Number must be finite (NaN and Infinity are not supported)')\n    }\n    if (Number.isSafeInteger(value)) {\n      return value < 0\n        ? { isNegative: true, integerPart: BigInt(-value) }\n        : { isNegative: false, integerPart: BigInt(value) }\n    }\n    return parseNumericString(numberToString(value))\n  }\n\n  // String input\n  if (type === 'string') {\n    return parseNumericString(normalizeString(value))\n  }\n\n  throw new TypeError(\n    `Invalid value type: expected number, string, or bigint, received ${type}`\n  )\n}\n\n/**\n * Converts a number to decimal string, expanding scientific notation if needed.\n */\nfunction numberToString (value) {\n  const str = value.toString()\n  return (str.includes('e') || str.includes('E'))\n    ? expandScientificNotation(str)\n    : str\n}\n\n/**\n * Validates and normalizes a string numeric input.\n */\nfunction normalizeString (value) {\n  const trimmed = value.trim()\n  if (trimmed.length === 0 || Number.isNaN(Number(trimmed))) {\n    throw new Error(`Invalid number format: \"${value}\"`)\n  }\n  return (trimmed.includes('e') || trimmed.includes('E'))\n    ? expandScientificNotation(trimmed)\n    : trimmed\n}\n\n/**\n * Parses a normalized numeric string into components.\n */\nfunction parseNumericString (str) {\n  const isNegative = str[0] === '-'\n  if (isNegative) str = str.slice(1)\n\n  const dotIndex = str.indexOf('.')\n  if (dotIndex === -1) {\n    return { isNegative, integerPart: BigInt(str) }\n  }\n\n  const integerStr = str.slice(0, dotIndex) || '0'\n  const decimalPart = str.slice(dotIndex + 1)\n  return { isNegative, integerPart: BigInt(integerStr), decimalPart }\n}\n\n/**\n * Expands scientific notation to decimal form (e.g., \"1e21\" → \"1000...\").\n */\nfunction expandScientificNotation (str) {\n  const [mantissa, expStr] = str.toLowerCase().split('e')\n  const exp = parseInt(expStr, 10)\n\n  const dotIndex = mantissa.indexOf('.')\n  const digits = dotIndex === -1\n    ? mantissa\n    : mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1)\n  const integerLength = dotIndex === -1 ? mantissa.length : dotIndex\n  const newDotPosition = integerLength + exp\n\n  if (newDotPosition >= digits.length) {\n    return digits + '0'.repeat(newDotPosition - digits.length)\n  }\n  if (newDotPosition <= 0) {\n    return '0.' + '0'.repeat(-newDotPosition) + digits\n  }\n  return digits.slice(0, newDotPosition) + '.' + digits.slice(newDotPosition)\n}\n","/**\n * Azerbaijani language converter - Functional Implementation\n *\n * Self-contained converter with precomputed lookup tables.\n *\n * Key features:\n * - Turkic language patterns\n * - Implicit \"bir\" (one) omission before hundreds and thousands\n * - Short scale naming\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES = ['', 'bir', 'iki', 'üç', 'dörd', 'beş', 'altı', 'yeddi', 'səkkiz', 'doqquz']\nconst TEENS = ['on', 'on bir', 'on iki', 'on üç', 'on dörd', 'on beş', 'on altı', 'on yeddi', 'on səkkiz', 'on doqquz']\nconst TENS = ['', '', 'iyirmi', 'otuz', 'qırx', 'əlli', 'altmış', 'yetmiş', 'səksən', 'doxsan']\n\nconst HUNDRED = 'yüz'\nconst THOUSAND = 'min'\n\nconst ZERO = 'sıfır'\nconst NEGATIVE = 'mənfi'\nconst DECIMAL_SEP = 'nöqtə'\n\n// Short scale\nconst SCALE_WORDS = ['', THOUSAND, 'milyon', 'milyar', 'trilyon', 'katrilyon', 'kentilyon']\n\n// ============================================================================\n// Precomputed Lookup Table\n// ============================================================================\n\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tensDigit = Math.floor(n / 10) % 10\n  const hundredsDigit = Math.floor(n / 100)\n\n  const parts = []\n\n  if (hundredsDigit > 0) {\n    if (hundredsDigit === 1) {\n      parts.push(HUNDRED)\n    } else {\n      parts.push(ONES[hundredsDigit] + ' ' + HUNDRED)\n    }\n  }\n\n  if (tensDigit === 1) {\n    parts.push(TEENS[ones])\n  } else {\n    if (tensDigit > 1) {\n      parts.push(TENS[tensDigit])\n    }\n    if (ones > 0) {\n      parts.push(ONES[ones])\n    }\n  }\n\n  return parts.join(' ')\n}\n\nconst SEGMENTS = new Array(1000)\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS[i] = buildSegment(i)\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  if (n < 1000n) {\n    return SEGMENTS[Number(n)]\n  }\n\n  return buildLargeNumberWords(n)\n}\n\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      const scaleWord = SCALE_WORDS[scaleIndex] || ''\n\n      if (scaleIndex === 0) {\n        parts.push(SEGMENTS[segment])\n      } else if (scaleIndex === 1 && segment === 1) {\n        // Omit \"bir\" before thousand\n        parts.push(scaleWord)\n      } else {\n        parts.push(SEGMENTS[segment] + ' ' + scaleWord)\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\nfunction decimalPartToWords (decimalPart) {\n  let result = ''\n  let i = 0\n\n  while (i < decimalPart.length && decimalPart[i] === '0') {\n    if (result) result += ' '\n    result += ZERO\n    i++\n  }\n\n  const remainder = decimalPart.slice(i)\n  if (remainder) {\n    if (result) result += ' '\n    result += integerToWords(BigInt(remainder))\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Azerbaijani words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Azerbaijani words\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Exports\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","TEENS","TENS","ZERO","SCALE_WORDS","buildSegment","n","ones","tensDigit","Math","floor","hundredsDigit","parts","push","join","SEGMENTS","Array","i","integerToWords","Number","numStr","toString","len","segments","remainderLen","pos","scaleIndex","segment","scaleWord","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","remainder","decimalPartToWords"],"mappings":"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"}

package/dist/languages/bn.js

@@ -1,3 +0,0 @@
-/*! n2words/bn v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const i=e.slice(0,n)||"0",r=e.slice(n+1);return{isNegative:t,integerPart:BigInt(i),decimalPart:r}}function n(e){const[t,n]=e.toLowerCase().split("e"),i=parseInt(n,10),r=t.indexOf("."),s=-1===r?t:t.slice(0,r)+t.slice(r+1),o=(-1===r?t.length:r)+i;return o>=s.length?s+"0".repeat(o-s.length):o<=0?"0."+"0".repeat(-o)+s:s.slice(0,o)+"."+s.slice(o)}const i="শূন্য",r=["শূন্য","এক","দুই","তিন","চার","পাঁচ","ছয়","সাত","আট","নয়","দশ","এগারো","বারো","তেরো","চৌদ্দ","পনেরো","ষোল","সতেরো","আঠারো","উনিশ","বিশ","একুশ","বাইশ","তেইশ","চব্বিশ","পঁচিশ","ছাব্বিশ","সাতাশ","আঠাশ","উনত্রিশ","ত্রিশ","একত্রিশ","বত্রিশ","তেত্রিশ","চৌত্রিশ","পঁয়ত্রিশ","ছত্রিশ","সাঁইত্রিশ","আটত্রিশ","উনচল্লিশ","চল্লিশ","একচল্লিশ","বেয়াল্লিশ","তেতাল্লিশ","চুয়াল্লিশ","পঁয়তাল্লিশ","ছেচল্লিশ","সাতচল্লিশ","আটচল্লিশ","উনপঞ্চাশ","পঞ্চাশ","একান্ন","বাহান্ন","তিপ্পান্ন","চুয়ান্ন","পঞ্চান্ন","ছাপ্পান্ন","সাতান্ন","আটান্ন","উনষাট","ষাট","একষট্টি","বাষট্টি","তেষট্টি","চৌষট্টি","পঁয়ষট্টি","ছেষট্টি","সাতষট্টি","আটষট্টি","ঊনসত্তর","সত্তর","একাত্তর","বাহাত্তর","তেহাত্তর","চুয়াত্তর","পঁচাত্তর","ছিয়াত্তর","সাতাত্তর","আটাত্তর","উনআশি","আশি","একাশি","বিরাশি","তিরাশি","চুরাশি","পঁচাশি","ছিয়াশি","সাতাশি","আটাশি","উননব্বই","নব্বই","একানব্বই","বিরানব্বই","তিরানব্বই","চুরানব্বই","পঁচানব্বই","ছিয়ানব্বই","সাতানব্বই","আটানব্বই","নিরানব্বই"],s=["","হাজার","লাখ","কোটি","আরব","খরব","নীল","পদ্ম","শঙ্খ"];function o(e){if(0===e)return"";if(e<100)return r[e];const t=Math.trunc(e/100),n=e%100;return 0===n?r[t]+" শত":r[t]+" শত "+r[n]}function u(e){if(0n===e)return i;const t=function(e){const t=e.toString();if(t.length<=3)return[Number(t)];const n=[];n.unshift(Number(t.slice(-3)));let i=t.slice(0,-3);for(;i.length>0;)n.unshift(Number(i.slice(-2))),i=i.slice(0,-2);return n}(e),n=t.length,r=[];for(let e=0;e<n;e++){const i=t[e];if(0===i)continue;const u=n-e-1;r.push(o(i)),u>0&&s[u]&&r.push(s[u])}return r.join(" ").trim()}e.bn=function(e){const{isNegative:r,integerPart:s,decimalPart:o}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===i)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(e);let c="";return r&&(c="মাইনাস "),c+=u(s),o&&(c+=" দশমিক "+function(e){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+=i,n++;const r=e.slice(n);return r&&(t&&(t+=" "),t+=u(BigInt(r))),t}(o)),c}},"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=bn.js.map

package/dist/languages/bn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bn.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/bn.js"],"sourcesContent":["/**\n * Numeric value parsing utility.\n * Transforms user input (number, string, or bigint) into normalized components.\n * @module parse-numeric\n */\n\n/**\n * Parses a numeric value into its components.\n * @param {number|string|bigint} value\n * @returns {{isNegative: boolean, integerPart: bigint, decimalPart?: string}}\n * @throws {TypeError} If value is not number, string, or bigint\n * @throws {Error} If value is not a valid number format\n */\nexport function parseNumericValue (value) {\n  const type = typeof value\n\n  // BigInt: simplest case\n  if (type === 'bigint') {\n    return value < 0n\n      ? { isNegative: true, integerPart: -value }\n      : { isNegative: false, integerPart: value }\n  }\n\n  // Number: fast path for safe integers\n  if (type === 'number') {\n    if (!Number.isFinite(value)) {\n      throw new Error('Number must be finite (NaN and Infinity are not supported)')\n    }\n    if (Number.isSafeInteger(value)) {\n      return value < 0\n        ? { isNegative: true, integerPart: BigInt(-value) }\n        : { isNegative: false, integerPart: BigInt(value) }\n    }\n    return parseNumericString(numberToString(value))\n  }\n\n  // String input\n  if (type === 'string') {\n    return parseNumericString(normalizeString(value))\n  }\n\n  throw new TypeError(\n    `Invalid value type: expected number, string, or bigint, received ${type}`\n  )\n}\n\n/**\n * Converts a number to decimal string, expanding scientific notation if needed.\n */\nfunction numberToString (value) {\n  const str = value.toString()\n  return (str.includes('e') || str.includes('E'))\n    ? expandScientificNotation(str)\n    : str\n}\n\n/**\n * Validates and normalizes a string numeric input.\n */\nfunction normalizeString (value) {\n  const trimmed = value.trim()\n  if (trimmed.length === 0 || Number.isNaN(Number(trimmed))) {\n    throw new Error(`Invalid number format: \"${value}\"`)\n  }\n  return (trimmed.includes('e') || trimmed.includes('E'))\n    ? expandScientificNotation(trimmed)\n    : trimmed\n}\n\n/**\n * Parses a normalized numeric string into components.\n */\nfunction parseNumericString (str) {\n  const isNegative = str[0] === '-'\n  if (isNegative) str = str.slice(1)\n\n  const dotIndex = str.indexOf('.')\n  if (dotIndex === -1) {\n    return { isNegative, integerPart: BigInt(str) }\n  }\n\n  const integerStr = str.slice(0, dotIndex) || '0'\n  const decimalPart = str.slice(dotIndex + 1)\n  return { isNegative, integerPart: BigInt(integerStr), decimalPart }\n}\n\n/**\n * Expands scientific notation to decimal form (e.g., \"1e21\" → \"1000...\").\n */\nfunction expandScientificNotation (str) {\n  const [mantissa, expStr] = str.toLowerCase().split('e')\n  const exp = parseInt(expStr, 10)\n\n  const dotIndex = mantissa.indexOf('.')\n  const digits = dotIndex === -1\n    ? mantissa\n    : mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1)\n  const integerLength = dotIndex === -1 ? mantissa.length : dotIndex\n  const newDotPosition = integerLength + exp\n\n  if (newDotPosition >= digits.length) {\n    return digits + '0'.repeat(newDotPosition - digits.length)\n  }\n  if (newDotPosition <= 0) {\n    return '0.' + '0'.repeat(-newDotPosition) + digits\n  }\n  return digits.slice(0, newDotPosition) + '.' + digits.slice(newDotPosition)\n}\n","/**\n * Bangla language converter - Functional Implementation\n *\n * Self-contained converter for South Asian numbering.\n *\n * Key features:\n * - Indian numbering system (হাজার, লাখ, কোটি)\n * - Bangla script (Bengali)\n * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)\n * - Complete word forms for 0-99\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ZERO = 'শূন্য'\nconst NEGATIVE = 'মাইনাস'\nconst DECIMAL_SEP = 'দশমিক'\nconst HUNDRED = 'শত'\n\nconst BELOW_HUNDRED = [\n  'শূন্য', 'এক', 'দুই', 'তিন', 'চার', 'পাঁচ', 'ছয়', 'সাত', 'আট', 'নয়',\n  'দশ', 'এগারো', 'বারো', 'তেরো', 'চৌদ্দ', 'পনেরো', 'ষোল', 'সতেরো', 'আঠারো', 'উনিশ',\n  'বিশ', 'একুশ', 'বাইশ', 'তেইশ', 'চব্বিশ', 'পঁচিশ', 'ছাব্বিশ', 'সাতাশ', 'আঠাশ', 'উনত্রিশ',\n  'ত্রিশ', 'একত্রিশ', 'বত্রিশ', 'তেত্রিশ', 'চৌত্রিশ', 'পঁয়ত্রিশ', 'ছত্রিশ', 'সাঁইত্রিশ', 'আটত্রিশ', 'উনচল্লিশ',\n  'চল্লিশ', 'একচল্লিশ', 'বেয়াল্লিশ', 'তেতাল্লিশ', 'চুয়াল্লিশ', 'পঁয়তাল্লিশ', 'ছেচল্লিশ', 'সাতচল্লিশ', 'আটচল্লিশ', 'উনপঞ্চাশ',\n  'পঞ্চাশ', 'একান্ন', 'বাহান্ন', 'তিপ্পান্ন', 'চুয়ান্ন', 'পঞ্চান্ন', 'ছাপ্পান্ন', 'সাতান্ন', 'আটান্ন', 'উনষাট',\n  'ষাট', 'একষট্টি', 'বাষট্টি', 'তেষট্টি', 'চৌষট্টি', 'পঁয়ষট্টি', 'ছেষট্টি', 'সাতষট্টি', 'আটষট্টি', 'ঊনসত্তর',\n  'সত্তর', 'একাত্তর', 'বাহাত্তর', 'তেহাত্তর', 'চুয়াত্তর', 'পঁচাত্তর', 'ছিয়াত্তর', 'সাতাত্তর', 'আটাত্তর', 'উনআশি',\n  'আশি', 'একাশি', 'বিরাশি', 'তিরাশি', 'চুরাশি', 'পঁচাশি', 'ছিয়াশি', 'সাতাশি', 'আটাশি', 'উননব্বই',\n  'নব্বই', 'একানব্বই', 'বিরানব্বই', 'তিরানব্বই', 'চুরানব্বই', 'পঁচানব্বই', 'ছিয়ানব্বই', 'সাতানব্বই', 'আটানব্বই', 'নিরানব্বই'\n]\n\n// Scale words: index 0 = units (empty), 1 = thousand, 2 = lakh, 3 = crore, etc.\nconst SCALE_WORDS = ['', 'হাজার', 'লাখ', 'কোটি', 'আরব', 'খরব', 'নীল', 'পদ্ম', 'শঙ্খ']\n\n// ============================================================================\n// Segment Splitting (inlined for performance)\n// ============================================================================\n\nfunction groupByThreeThenTwos (n) {\n  const numStr = n.toString()\n  if (numStr.length <= 3) return [Number(numStr)]\n\n  const segments = []\n  segments.unshift(Number(numStr.slice(-3)))\n\n  let remaining = numStr.slice(0, -3)\n  while (remaining.length > 0) {\n    segments.unshift(Number(remaining.slice(-2)))\n    remaining = remaining.slice(0, -2)\n  }\n\n  return segments\n}\n\nfunction segmentToWords (n) {\n  if (n === 0) return ''\n  if (n < 100) return BELOW_HUNDRED[n]\n\n  const hundreds = Math.trunc(n / 100)\n  const remainder = n % 100\n\n  if (remainder === 0) {\n    return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED\n  }\n  return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED + ' ' + BELOW_HUNDRED[remainder]\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  const segments = groupByThreeThenTwos(n)\n  const segmentCount = segments.length\n  const words = []\n\n  for (let i = 0; i < segmentCount; i++) {\n    const segmentValue = segments[i]\n    if (segmentValue === 0) continue\n\n    const scaleIndex = segmentCount - i - 1\n    words.push(segmentToWords(segmentValue))\n    if (scaleIndex > 0 && SCALE_WORDS[scaleIndex]) {\n      words.push(SCALE_WORDS[scaleIndex])\n    }\n  }\n\n  return words.join(' ').trim()\n}\n\nfunction decimalPartToWords (decimalPart) {\n  let result = ''\n  let i = 0\n\n  while (i < decimalPart.length && decimalPart[i] === '0') {\n    if (result) result += ' '\n    result += ZERO\n    i++\n  }\n\n  const remainder = decimalPart.slice(i)\n  if (remainder) {\n    if (result) result += ' '\n    result += integerToWords(BigInt(remainder))\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Bengali words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Bengali words\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Exports\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ZERO","BELOW_HUNDRED","SCALE_WORDS","segmentToWords","n","hundreds","Math","trunc","remainder","integerToWords","segments","numStr","toString","Number","unshift","remaining","groupByThreeThenTwos","segmentCount","words","i","segmentValue","scaleIndex","push","join","trim","value","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/cs.js

@@ -1,3 +0,0 @@
-/*! n2words/cs v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var t,e;t=this,e=function(t){"use strict";function e(t){const e="-"===t[0];e&&(t=t.slice(1));const n=t.indexOf(".");if(-1===n)return{isNegative:e,integerPart:BigInt(t)};const i=t.slice(0,n)||"0",r=t.slice(n+1);return{isNegative:e,integerPart:BigInt(i),decimalPart:r}}function n(t){const[e,n]=t.toLowerCase().split("e"),i=parseInt(n,10),r=e.indexOf("."),s=-1===r?e:e.slice(0,r)+e.slice(r+1),o=(-1===r?e.length:r)+i;return o>=s.length?s+"0".repeat(o-s.length):o<=0?"0."+"0".repeat(-o)+s:s.slice(0,o)+"."+s.slice(o)}const i=["","jedna","dva","tři","čtyři","pět","šest","sedm","osm","devět"],r=["deset","jedenáct","dvanáct","třináct","čtrnáct","patnáct","šestnáct","sedmnáct","osmnáct","devatenáct"],s=["","","dvacet","třicet","čtyřicet","padesát","šedesát","sedmdesát","osmdesát","devadesát"],o=["","sto","dvě stě","tři sta","čtyři sta","pět set","šest set","sedm set","osm set","devět set"],u={1:["tisíc","tisíce","tisíc"],2:["milion","miliony","milionů"],3:["miliarda","miliardy","miliard"],4:["bilion","biliony","bilionů"],5:["biliarda","biliardy","biliard"],6:["trilion","triliony","trilionů"],7:["triliarda","triliardy","triliard"],8:["kvadrilion","kvadriliony","kvadrilionů"],9:["kvadriliarda","kvadriliardy","kvadriliard"]},a="nula";function c(t){if(0===t)return"";const e=t%10,n=Math.floor(t/10)%10,u=Math.floor(t/100),a=[];return u>0&&a.push(o[u]),1===n?a.push(r[e]):n>=2?(a.push(s[n]),e>0&&a.push(i[e])):e>0&&a.push(i[e]),a.join(" ")}function l(t){if(0===t)return"";const e=t%10,n=Math.floor(t/10)%10,u=Math.floor(t/100),a=[];return u>0&&a.push(o[u]),1===n?a.push(r[e]):n>=2?(a.push(s[n]),e>0&&a.push(i[e])):e>0&&a.push(i[e]),a.join(" ")}const d=new Array(1e3);for(let t=0;t<1e3;t++)d[t]=c(t);const f=new Array(1e3);for(let t=0;t<1e3;t++)f[t]=l(t);function m(t,e){if(1n===t)return e[0];const n=t%10n,i=t%100n;return n>=2n&&n<=4n&&(i<10n||i>20n)?e[1]:e[2]}function g(t){if(0n===t)return a;if(t<1000n)return d[Number(t)];if(t<1000000n){const e=t/1000n,n=Number(t%1000n),i=m(e,u[1]);let r;return r=1n===e?i:d[Number(e)]+" "+i,n>0&&(r+=" "+f[n]),r}return function(t){const e=[];let n=t;for(;n>0n;)e.push(n%1000n),n/=1000n;let i="";for(let t=e.length-1;t>=0;t--){const n=e[t];if(0n!==n)if(i&&(i+=" "),0===t)i+=f[Number(n)];else{const e=u[t];if(e){const t=m(n,e);i+=1n===n?t:d[Number(n)]+" "+t}else i+=d[Number(n)]}}return i}(t)}t.cs=function(t){const{isNegative:i,integerPart:r,decimalPart:s}=function(t){const i=typeof t;if("bigint"===i)return t<0n?{isNegative:!0,integerPart:-t}:{isNegative:!1,integerPart:t};if("number"===i){if(!Number.isFinite(t))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(t)?t<0?{isNegative:!0,integerPart:BigInt(-t)}:{isNegative:!1,integerPart:BigInt(t)}:e(function(t){const e=t.toString();return e.includes("e")||e.includes("E")?n(e):e}(t))}if("string"===i)return e(function(t){const e=t.trim();if(0===e.length||Number.isNaN(Number(e)))throw new Error(`Invalid number format: "${t}"`);return e.includes("e")||e.includes("E")?n(e):e}(t));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(t);let o="";if(i&&(o="mínus "),o+=g(r),s){const t=function(t){return 0n===t||1n===t?"celá":t>=2n&&t<=4n?"celé":"celých"}(r);o+=" "+t+" "+function(t){let e="",n=0;for(;n<t.length&&"0"===t[n];)e&&(e+=" "),e+=a,n++;const i=t.slice(n);return i&&(e&&(e+=" "),e+=g(BigInt(i))),e}(s)}return o}},"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).n2words=t.n2words||{});
-//# sourceMappingURL=cs.js.map

package/dist/languages/cs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cs.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/cs.js"],"sourcesContent":["/**\n * Numeric value parsing utility.\n * Transforms user input (number, string, or bigint) into normalized components.\n * @module parse-numeric\n */\n\n/**\n * Parses a numeric value into its components.\n * @param {number|string|bigint} value\n * @returns {{isNegative: boolean, integerPart: bigint, decimalPart?: string}}\n * @throws {TypeError} If value is not number, string, or bigint\n * @throws {Error} If value is not a valid number format\n */\nexport function parseNumericValue (value) {\n  const type = typeof value\n\n  // BigInt: simplest case\n  if (type === 'bigint') {\n    return value < 0n\n      ? { isNegative: true, integerPart: -value }\n      : { isNegative: false, integerPart: value }\n  }\n\n  // Number: fast path for safe integers\n  if (type === 'number') {\n    if (!Number.isFinite(value)) {\n      throw new Error('Number must be finite (NaN and Infinity are not supported)')\n    }\n    if (Number.isSafeInteger(value)) {\n      return value < 0\n        ? { isNegative: true, integerPart: BigInt(-value) }\n        : { isNegative: false, integerPart: BigInt(value) }\n    }\n    return parseNumericString(numberToString(value))\n  }\n\n  // String input\n  if (type === 'string') {\n    return parseNumericString(normalizeString(value))\n  }\n\n  throw new TypeError(\n    `Invalid value type: expected number, string, or bigint, received ${type}`\n  )\n}\n\n/**\n * Converts a number to decimal string, expanding scientific notation if needed.\n */\nfunction numberToString (value) {\n  const str = value.toString()\n  return (str.includes('e') || str.includes('E'))\n    ? expandScientificNotation(str)\n    : str\n}\n\n/**\n * Validates and normalizes a string numeric input.\n */\nfunction normalizeString (value) {\n  const trimmed = value.trim()\n  if (trimmed.length === 0 || Number.isNaN(Number(trimmed))) {\n    throw new Error(`Invalid number format: \"${value}\"`)\n  }\n  return (trimmed.includes('e') || trimmed.includes('E'))\n    ? expandScientificNotation(trimmed)\n    : trimmed\n}\n\n/**\n * Parses a normalized numeric string into components.\n */\nfunction parseNumericString (str) {\n  const isNegative = str[0] === '-'\n  if (isNegative) str = str.slice(1)\n\n  const dotIndex = str.indexOf('.')\n  if (dotIndex === -1) {\n    return { isNegative, integerPart: BigInt(str) }\n  }\n\n  const integerStr = str.slice(0, dotIndex) || '0'\n  const decimalPart = str.slice(dotIndex + 1)\n  return { isNegative, integerPart: BigInt(integerStr), decimalPart }\n}\n\n/**\n * Expands scientific notation to decimal form (e.g., \"1e21\" → \"1000...\").\n */\nfunction expandScientificNotation (str) {\n  const [mantissa, expStr] = str.toLowerCase().split('e')\n  const exp = parseInt(expStr, 10)\n\n  const dotIndex = mantissa.indexOf('.')\n  const digits = dotIndex === -1\n    ? mantissa\n    : mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1)\n  const integerLength = dotIndex === -1 ? mantissa.length : dotIndex\n  const newDotPosition = integerLength + exp\n\n  if (newDotPosition >= digits.length) {\n    return digits + '0'.repeat(newDotPosition - digits.length)\n  }\n  if (newDotPosition <= 0) {\n    return '0.' + '0'.repeat(-newDotPosition) + digits\n  }\n  return digits.slice(0, newDotPosition) + '.' + digits.slice(newDotPosition)\n}\n","/**\n * Czech language converter - Functional Implementation\n *\n * A performance-optimized number-to-words converter using precomputed lookup tables.\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key optimization: Precompute all segment values (0-999) at module load.\n * This eliminates all per-call string manipulation for segment conversion.\n *\n * Czech-specific rules (handled in precomputation):\n * - Three-form pluralization: 1 = singular, 2-4 = few, 5+ = many\n * - Irregular hundreds: sto, dvě stě, tři sta, čtyři sta, pět set...\n * - Gender: dva (masc) vs dvě (fem) for 2\n * - Omit \"one\" before scale words: \"tisíc\" not \"jedna tisíc\"\n * - Dynamic decimal separator: celá/celé/celých based on integer\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\n// Ones words (masculine form)\nconst ONES = ['', 'jedna', 'dva', 'tři', 'čtyři', 'pět', 'šest', 'sedm', 'osm', 'devět']\n\n// Teens (10-19)\nconst TEENS = ['deset', 'jedenáct', 'dvanáct', 'třináct', 'čtrnáct', 'patnáct', 'šestnáct', 'sedmnáct', 'osmnáct', 'devatenáct']\n\n// Tens (20-90)\nconst TENS = ['', '', 'dvacet', 'třicet', 'čtyřicet', 'padesát', 'šedesát', 'sedmdesát', 'osmdesát', 'devadesát']\n\n// Irregular hundreds\nconst HUNDREDS = ['', 'sto', 'dvě stě', 'tři sta', 'čtyři sta', 'pět set', 'šest set', 'sedm set', 'osm set', 'devět set']\n\n// Scale plural forms [singular, few (2-4), many (5+)]\nconst PLURAL_FORMS = {\n  1: ['tisíc', 'tisíce', 'tisíc'], // 10^3\n  2: ['milion', 'miliony', 'milionů'], // 10^6\n  3: ['miliarda', 'miliardy', 'miliard'], // 10^9\n  4: ['bilion', 'biliony', 'bilionů'], // 10^12\n  5: ['biliarda', 'biliardy', 'biliard'], // 10^15\n  6: ['trilion', 'triliony', 'trilionů'], // 10^18\n  7: ['triliarda', 'triliardy', 'triliard'], // 10^21\n  8: ['kvadrilion', 'kvadriliony', 'kvadrilionů'], // 10^24\n  9: ['kvadriliarda', 'kvadriliardy', 'kvadriliard'] // 10^27\n}\n\nconst ZERO = 'nula'\nconst NEGATIVE = 'mínus'\n\n// ============================================================================\n// Precomputed Lookup Tables (built once at module load)\n// ============================================================================\n\n/**\n * Builds segment word for 0-999 (masculine, default form).\n * Only used during table construction.\n */\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds (irregular)\n  if (hundreds > 0) {\n    parts.push(HUNDREDS[hundreds])\n  }\n\n  // Tens and ones\n  if (tens === 1) {\n    // Teens\n    parts.push(TEENS[ones])\n  } else if (tens >= 2) {\n    parts.push(TENS[tens])\n    if (ones > 0) {\n      parts.push(ONES[ones])\n    }\n  } else if (ones > 0) {\n    parts.push(ONES[ones])\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Builds segment word for 0-999 with feminine hundreds.\n * Hundreds use irregular forms (dvě stě, tři sta) but ones remain masculine.\n */\nfunction buildSegmentWithHundreds (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds use the irregular HUNDREDS array (already has \"dvě stě\" etc.)\n  if (hundreds > 0) {\n    parts.push(HUNDREDS[hundreds])\n  }\n\n  // Tens and ones use masculine form\n  if (tens === 1) {\n    parts.push(TEENS[ones])\n  } else if (tens >= 2) {\n    parts.push(TENS[tens])\n    if (ones > 0) {\n      parts.push(ONES[ones]) // masculine\n    }\n  } else if (ones > 0) {\n    parts.push(ONES[ones]) // masculine\n  }\n\n  return parts.join(' ')\n}\n\n// Precompute all 1000 segment words (0-999) - masculine form\nconst SEGMENTS = new Array(1000)\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS[i] = buildSegment(i)\n}\n\n// Precompute all 1000 segment words with hundreds (irregular hundreds forms)\nconst SEGMENTS_WITH_HUNDREDS = new Array(1000)\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS_WITH_HUNDREDS[i] = buildSegmentWithHundreds(i)\n}\n\n// ============================================================================\n// Helper Functions\n// ============================================================================\n\n/**\n * Czech pluralization: 1 = singular, 2-4 = few, else = many.\n * Teens (11-19) always use \"many\" form.\n *\n * @param {bigint} n - The number\n * @param {string[]} forms - [singular, few, many]\n * @returns {string} The appropriate form\n */\nfunction pluralize (n, forms) {\n  if (n === 1n) return forms[0]\n\n  const lastDigit = n % 10n\n  const lastTwoDigits = n % 100n\n\n  // 2-4, but not 12-14 (teens use \"many\")\n  if (lastDigit >= 2n && lastDigit <= 4n && (lastTwoDigits < 10n || lastTwoDigits > 20n)) {\n    return forms[1]\n  }\n\n  return forms[2]\n}\n\n/**\n * Gets the decimal separator word based on integer part.\n * celá (0-1), celé (2-4), celých (5+)\n */\nfunction getDecimalSeparator (integerPart) {\n  if (integerPart === 0n || integerPart === 1n) {\n    return 'celá'\n  } else if (integerPart >= 2n && integerPart <= 4n) {\n    return 'celé'\n  } else {\n    return 'celých'\n  }\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Czech words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Czech words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000 (direct lookup)\n  if (n < 1000n) {\n    return SEGMENTS[Number(n)]\n  }\n\n  // Fast path: numbers < 1,000,000 (thousands)\n  if (n < 1_000_000n) {\n    const thousands = n / 1000n\n    const remainder = Number(n % 1000n)\n\n    const scaleWord = pluralize(thousands, PLURAL_FORMS[1])\n\n    let result\n    if (thousands === 1n) {\n      // Omit \"one\" before tisíc\n      result = scaleWord\n    } else {\n      result = SEGMENTS[Number(thousands)] + ' ' + scaleWord\n    }\n\n    if (remainder > 0) {\n      // Use form with irregular hundreds (for \"dvě stě\" etc.)\n      result += ' ' + SEGMENTS_WITH_HUNDREDS[remainder]\n    }\n\n    return result\n  }\n\n  // For numbers >= 1,000,000, use scale decomposition\n  return buildLargeNumberWords(n)\n}\n\n/**\n * Builds words for numbers >= 1,000,000.\n * Uses BigInt division for faster segment extraction.\n *\n * @param {bigint} n - Number >= 1,000,000\n * @returns {string} Czech words\n */\nfunction buildLargeNumberWords (n) {\n  // Extract segments using BigInt division (faster than string slicing)\n  // Segments stored least-significant first (index 0 = ones, 1 = thousands, etc.)\n  const segmentValues = []\n  let temp = n\n  while (temp > 0n) {\n    segmentValues.push(temp % 1000n)\n    temp = temp / 1000n\n  }\n\n  // Build result string directly\n  let result = ''\n\n  for (let i = segmentValues.length - 1; i >= 0; i--) {\n    const segment = segmentValues[i]\n    if (segment === 0n) continue\n\n    if (result) result += ' '\n\n    if (i === 0) {\n      // Units segment (no scale word) - use form with irregular hundreds\n      result += SEGMENTS_WITH_HUNDREDS[Number(segment)]\n    } else {\n      // Scale word needed\n      const forms = PLURAL_FORMS[i]\n      if (forms) {\n        const scaleWord = pluralize(segment, forms)\n\n        if (segment === 1n) {\n          // Omit \"one\" before scale words\n          result += scaleWord\n        } else {\n          // Use masculine form for multiplier before scale words\n          result += SEGMENTS[Number(segment)] + ' ' + scaleWord\n        }\n      } else {\n        // Fallback for very large scales without defined forms\n        result += SEGMENTS[Number(segment)]\n      }\n    }\n  }\n\n  return result\n}\n\n/**\n * Converts decimal digits to Czech words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Czech words for decimal part\n */\nfunction decimalPartToWords (decimalPart) {\n  let result = ''\n\n  // Handle leading zeros\n  let i = 0\n  while (i < decimalPart.length && decimalPart[i] === '0') {\n    if (result) result += ' '\n    result += ZERO\n    i++\n  }\n\n  // Convert remainder as a single number\n  const remainder = decimalPart.slice(i)\n  if (remainder) {\n    if (result) result += ' '\n    result += integerToWords(BigInt(remainder))\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Czech words.\n *\n * This is the main public API. It accepts any valid numeric input\n * (number, string, or bigint) and handles parsing internally.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Czech words\n * @throws {TypeError} If value is not a valid numeric type\n * @throws {Error} If value is not a valid number format\n *\n * @example\n * toWords(21)           // 'dvacet jedna'\n * toWords(1000)         // 'tisíc'\n * toWords(2000)         // 'dva tisíce'\n * toWords(5000)         // 'pět tisíc'\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    const separator = getDecimalSeparator(integerPart)\n    result += ' ' + separator + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","TEENS","TENS","HUNDREDS","PLURAL_FORMS","ZERO","buildSegment","n","ones","tens","Math","floor","hundreds","parts","push","join","buildSegmentWithHundreds","SEGMENTS","Array","i","SEGMENTS_WITH_HUNDREDS","pluralize","forms","lastDigit","lastTwoDigits","integerToWords","Number","thousands","remainder","scaleWord","result","segmentValues","temp","segment","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","separator","getDecimalSeparator","decimalPartToWords"],"mappings":"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"}

package/dist/languages/da.js

@@ -1,3 +0,0 @@
-/*! n2words/da v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const r=e.slice(0,n)||"0",i=e.slice(n+1);return{isNegative:t,integerPart:BigInt(r),decimalPart:i}}function n(e){const[t,n]=e.toLowerCase().split("e"),r=parseInt(n,10),i=t.indexOf("."),o=-1===i?t:t.slice(0,i)+t.slice(i+1),s=(-1===i?t.length:i)+r;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const r=["","et","to","tre","fire","fem","seks","syv","otte","ni"],i=["","en","to","tre","fire","fem","seks","syv","otte","ni"],o=["ti","elleve","tolv","tretten","fjorten","femten","seksten","sytten","atten","nitten"],s=["","","tyve","tredive","fyrre","halvtreds","treds","halvfjerds","firs","halvfems"],l="tusind",u="nul",f=["millioner","millarder","billioner","billarder","trillioner","trillarder","quadrillioner","quadrillarder"];function c(e){if(0===e)return"";const t=e%10,n=Math.floor(e/10)%10,l=Math.floor(e/100),u=[];l>0&&u.push(r[l]+"hundrede");const f=e%100;return 0===f||u.push(f<10?r[t]:f<20?o[t]:0===t?s[n]:i[t]+"og"+s[n]),2===u.length?u[0]+" og "+u[1]:u[0]||""}const a=new Array(1e3);for(let e=0;e<1e3;e++)a[e]=c(e);function d(e){if(0n===e)return u;if(e<1000n)return a[Number(e)];if(e<1000000n){const t=Number(e/1000n),n=Number(e%1000n);let r=a[t]+l;return n>0&&(r+="e og "+a[n]),r}return function(e){const t=e.toString(),n=t.length,r=[],i=n%3;let o=0;for(i>0&&(r.push(Number(t.slice(0,i))),o=i);o<n;)r.push(Number(t.slice(o,o+3))),o+=3;const s=[];let c=r.length-1;for(let e=0;e<r.length;e++){const t=r[e];if(0!==t){const e=a[t];if(0===c)s.push({word:e,type:"units"});else if(1===c)s.push({word:e+l,type:"thousand"});else{let n=e;1===t&&(n="en"),s.push({word:n+" "+f[c-2],type:"million"})}}c--}return function(e){if(0===e.length)return u;if(1===e.length)return e[0].word;const t=[];for(let n=0;n<e.length;n++){const r=e[n],i=e[n+1];"thousand"===r.type&&i&&"units"===i.type?(t.push(r.word+"e og "+i.word),n++):"million"===r.type?(t.length>0&&t.push(" "),t.push(r.word),i&&t.push(" ")):(t.length>0&&!t[t.length-1].endsWith(" ")&&t.push(" "),t.push(r.word))}return t.join("")}(s)}(e)}e.da=function(e){const{isNegative:r,integerPart:i,decimalPart:o}=function(e){const r=typeof e;if("bigint"===r)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===r){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===r)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${r}`)}(e);let s="";return r&&(s="minus "),s+=d(i),o&&(s+=" komma "+function(e){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+=u,n++;const r=e.slice(n);return r&&(t&&(t+=" "),t+=d(BigInt(r))),t}(o)),s}},"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=da.js.map

package/dist/languages/da.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"da.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/da.js"],"sourcesContent":["/**\n * Numeric value parsing utility.\n * Transforms user input (number, string, or bigint) into normalized components.\n * @module parse-numeric\n */\n\n/**\n * Parses a numeric value into its components.\n * @param {number|string|bigint} value\n * @returns {{isNegative: boolean, integerPart: bigint, decimalPart?: string}}\n * @throws {TypeError} If value is not number, string, or bigint\n * @throws {Error} If value is not a valid number format\n */\nexport function parseNumericValue (value) {\n  const type = typeof value\n\n  // BigInt: simplest case\n  if (type === 'bigint') {\n    return value < 0n\n      ? { isNegative: true, integerPart: -value }\n      : { isNegative: false, integerPart: value }\n  }\n\n  // Number: fast path for safe integers\n  if (type === 'number') {\n    if (!Number.isFinite(value)) {\n      throw new Error('Number must be finite (NaN and Infinity are not supported)')\n    }\n    if (Number.isSafeInteger(value)) {\n      return value < 0\n        ? { isNegative: true, integerPart: BigInt(-value) }\n        : { isNegative: false, integerPart: BigInt(value) }\n    }\n    return parseNumericString(numberToString(value))\n  }\n\n  // String input\n  if (type === 'string') {\n    return parseNumericString(normalizeString(value))\n  }\n\n  throw new TypeError(\n    `Invalid value type: expected number, string, or bigint, received ${type}`\n  )\n}\n\n/**\n * Converts a number to decimal string, expanding scientific notation if needed.\n */\nfunction numberToString (value) {\n  const str = value.toString()\n  return (str.includes('e') || str.includes('E'))\n    ? expandScientificNotation(str)\n    : str\n}\n\n/**\n * Validates and normalizes a string numeric input.\n */\nfunction normalizeString (value) {\n  const trimmed = value.trim()\n  if (trimmed.length === 0 || Number.isNaN(Number(trimmed))) {\n    throw new Error(`Invalid number format: \"${value}\"`)\n  }\n  return (trimmed.includes('e') || trimmed.includes('E'))\n    ? expandScientificNotation(trimmed)\n    : trimmed\n}\n\n/**\n * Parses a normalized numeric string into components.\n */\nfunction parseNumericString (str) {\n  const isNegative = str[0] === '-'\n  if (isNegative) str = str.slice(1)\n\n  const dotIndex = str.indexOf('.')\n  if (dotIndex === -1) {\n    return { isNegative, integerPart: BigInt(str) }\n  }\n\n  const integerStr = str.slice(0, dotIndex) || '0'\n  const decimalPart = str.slice(dotIndex + 1)\n  return { isNegative, integerPart: BigInt(integerStr), decimalPart }\n}\n\n/**\n * Expands scientific notation to decimal form (e.g., \"1e21\" → \"1000...\").\n */\nfunction expandScientificNotation (str) {\n  const [mantissa, expStr] = str.toLowerCase().split('e')\n  const exp = parseInt(expStr, 10)\n\n  const dotIndex = mantissa.indexOf('.')\n  const digits = dotIndex === -1\n    ? mantissa\n    : mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1)\n  const integerLength = dotIndex === -1 ? mantissa.length : dotIndex\n  const newDotPosition = integerLength + exp\n\n  if (newDotPosition >= digits.length) {\n    return digits + '0'.repeat(newDotPosition - digits.length)\n  }\n  if (newDotPosition <= 0) {\n    return '0.' + '0'.repeat(-newDotPosition) + digits\n  }\n  return digits.slice(0, newDotPosition) + '.' + digits.slice(newDotPosition)\n}\n","/**\n * Danish language converter - Functional Implementation\n *\n * A performance-optimized number-to-words converter using precomputed lookup tables.\n *\n * Key features:\n * - Vigesimal (base-20) tens naming: halvtreds (50), treds (60), etc.\n * - Units-before-tens: \"enogtyve\" (21) = one-and-twenty\n * - Compound thousands: \"ettusind\", \"firetusinde\"\n * - \"og\" conjunction after hundreds and thousands\n * - Long scale for millions+\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\nconst ONES = ['', 'et', 'to', 'tre', 'fire', 'fem', 'seks', 'syv', 'otte', 'ni']\n// \"en\" form used in vigesimal pattern (X og Y) and before millions\nconst ONES_VIGESIMAL = ['', 'en', 'to', 'tre', 'fire', 'fem', 'seks', 'syv', 'otte', 'ni']\n\nconst TEENS = ['ti', 'elleve', 'tolv', 'tretten', 'fjorten', 'femten', 'seksten', 'sytten', 'atten', 'nitten']\n\n// Danish vigesimal tens (base-20 derived names)\nconst TENS = ['', '', 'tyve', 'tredive', 'fyrre', 'halvtreds', 'treds', 'halvfjerds', 'firs', 'halvfems']\n\nconst HUNDRED = 'hundrede'\nconst THOUSAND = 'tusind'\n\nconst ZERO = 'nul'\nconst NEGATIVE = 'minus'\nconst DECIMAL_SEP = 'komma'\n\n// Long scale: millioner, millarder, billioner, etc.\nconst SCALES = ['millioner', 'millarder', 'billioner', 'billarder', 'trillioner', 'trillarder', 'quadrillioner', 'quadrillarder']\n\n// ============================================================================\n// Precomputed Lookup Tables (built once at module load)\n// ============================================================================\n\n/**\n * Builds segment word for 0-999.\n */\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds: \"ethundrede\", \"tohundrede\" (compound, no space)\n  if (hundreds > 0) {\n    parts.push(ONES[hundreds] + HUNDRED)\n  }\n\n  // Tens and ones\n  const tensOnes = n % 100\n\n  if (tensOnes === 0) {\n    // Just hundreds\n  } else if (tensOnes < 10) {\n    // Single digit\n    parts.push(ONES[ones])\n  } else if (tensOnes < 20) {\n    // Teens\n    parts.push(TEENS[ones])\n  } else if (ones === 0) {\n    // Even tens\n    parts.push(TENS[tens])\n  } else {\n    // Units-before-tens: \"enogtyve\", \"treogfyrre\"\n    parts.push(ONES_VIGESIMAL[ones] + 'og' + TENS[tens])\n  }\n\n  // Combine with \" og \" between hundreds and remainder\n  if (parts.length === 2) {\n    return parts[0] + ' og ' + parts[1]\n  }\n  return parts[0] || ''\n}\n\n// Precompute all 1000 segment words (0-999)\nconst SEGMENTS = new Array(1000)\n\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS[i] = buildSegment(i)\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Danish words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Danish words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000 (direct lookup)\n  if (n < 1000n) {\n    return SEGMENTS[Number(n)]\n  }\n\n  // Fast path: numbers < 1,000,000 (thousands)\n  if (n < 1_000_000n) {\n    const thousands = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    // Compound thousands: \"ettusind\", \"firetusind\"\n    let result = SEGMENTS[thousands] + THOUSAND\n\n    if (remainder > 0) {\n      // Add 'e' suffix and \" og \" for remainder: \"firetusinde og ...\"\n      result += 'e og ' + SEGMENTS[remainder]\n    }\n\n    return result\n  }\n\n  // For numbers >= 1,000,000, use scale decomposition\n  return buildLargeNumberWords(n)\n}\n\n/**\n * Builds words for numbers >= 1,000,000.\n *\n * @param {bigint} n - Number >= 1,000,000\n * @returns {string} Danish words\n */\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  // Build segments of 3 digits from right to left\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  // Convert segments to words with scale tracking\n  // scaleIndex: 0 = units, 1 = thousands, 2 = millions, etc.\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      const segmentWord = SEGMENTS[segment]\n\n      if (scaleIndex === 0) {\n        // Units segment\n        parts.push({ word: segmentWord, type: 'units' })\n      } else if (scaleIndex === 1) {\n        // Thousands - compound form\n        parts.push({ word: segmentWord + THOUSAND, type: 'thousand' })\n      } else {\n        // Millions+ - space-separated, use \"en\" for 1\n        const scaleWord = SCALES[scaleIndex - 2]\n        let numWord = segmentWord\n        // \"et\" → \"en\" before millions+\n        if (segment === 1) {\n          numWord = 'en'\n        }\n        parts.push({ word: numWord + ' ' + scaleWord, type: 'million' })\n      }\n    }\n\n    scaleIndex--\n  }\n\n  // Join parts with Danish rules\n  return joinDanishParts(parts)\n}\n\n/**\n * Joins parts with Danish spacing rules.\n * - After thousands with remainder: \"tusinde og\"\n * - Millions are space-separated\n *\n * @param {Array} parts - Parts with type metadata\n * @returns {string} Joined string\n */\nfunction joinDanishParts (parts) {\n  if (parts.length === 0) return ZERO\n  if (parts.length === 1) return parts[0].word\n\n  const result = []\n\n  for (let i = 0; i < parts.length; i++) {\n    const part = parts[i]\n    const nextPart = parts[i + 1]\n\n    if (part.type === 'thousand' && nextPart && nextPart.type === 'units') {\n      // Thousands followed by units: add \"e og\"\n      result.push(part.word + 'e og ' + nextPart.word)\n      i++ // Skip the units part\n    } else if (part.type === 'million') {\n      if (result.length > 0) {\n        result.push(' ')\n      }\n      result.push(part.word)\n      if (nextPart) {\n        result.push(' ')\n      }\n    } else {\n      if (result.length > 0 && !result[result.length - 1].endsWith(' ')) {\n        result.push(' ')\n      }\n      result.push(part.word)\n    }\n  }\n\n  return result.join('')\n}\n\n/**\n * Converts decimal digits to Danish words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Danish words for decimal part\n */\nfunction decimalPartToWords (decimalPart) {\n  let result = ''\n\n  // Handle leading zeros\n  let i = 0\n  while (i < decimalPart.length && decimalPart[i] === '0') {\n    if (result) result += ' '\n    result += ZERO\n    i++\n  }\n\n  // Convert remainder as a single number\n  const remainder = decimalPart.slice(i)\n  if (remainder) {\n    if (result) result += ' '\n    result += integerToWords(BigInt(remainder))\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Danish words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Danish words\n * @throws {TypeError} If value is not a valid numeric type\n * @throws {Error} If value is not a valid number format\n *\n * @example\n * toWords(21)       // 'enogtyve'\n * toWords(1000)     // 'ettusind'\n * toWords(1000000)  // 'en millioner'\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","ONES_VIGESIMAL","TEENS","TENS","THOUSAND","ZERO","SCALES","buildSegment","n","ones","tens","Math","floor","hundreds","parts","push","tensOnes","SEGMENTS","Array","i","integerToWords","Number","thousands","remainder","result","numStr","toString","len","segments","remainderLen","pos","scaleIndex","segment","segmentWord","word","type","numWord","part","nextPart","endsWith","join","joinDanishParts","buildLargeNumberWords","value","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/de.js

@@ -1,3 +0,0 @@
-/*! n2words/de v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,n;e=this,n=function(e){"use strict";function n(e){const n="-"===e[0];n&&(e=e.slice(1));const i=e.indexOf(".");if(-1===i)return{isNegative:n,integerPart:BigInt(e)};const t=e.slice(0,i)||"0",r=e.slice(i+1);return{isNegative:n,integerPart:BigInt(t),decimalPart:r}}function i(e){const[n,i]=e.toLowerCase().split("e"),t=parseInt(i,10),r=n.indexOf("."),l=-1===r?n:n.slice(0,r)+n.slice(r+1),s=(-1===r?n.length:r)+t;return s>=l.length?l+"0".repeat(s-l.length):s<=0?"0."+"0".repeat(-s)+l:l.slice(0,s)+"."+l.slice(s)}const t=["","eins","zwei","drei","vier","fünf","sechs","sieben","acht","neun"],r="ein",l=["zehn","elf","zwölf","dreizehn","vierzehn","fünfzehn","sechzehn","siebzehn","achtzehn","neunzehn"],s=["","","zwanzig","dreißig","vierzig","fünfzig","sechzig","siebzig","achtzig","neunzig"],o=["tausend","Million","Milliarde","Billion","Billiarde","Trillion","Trilliarde","Quadrillion","Quadrilliarde"],u=["tausend","Millionen","Milliarden","Billionen","Billiarden","Trillionen","Trilliarden","Quadrillionen","Quadrilliarden"],a="hundert",c="null";function f(e){if(0===e)return"";const n=e%10,i=Math.floor(e/10)%10,o=Math.floor(e/100);let u="";return o>0&&(u+=(1===o?r:t[o])+a),1===i?u+=l[n]:i>=2&&n>0?u+=(1===n?r:t[n])+"und"+s[i]:i>=2?u+=s[i]:n>0&&(u+=t[n]),u}function d(e){if(0===e)return"";if(1===e)return r;const n=e%10,i=Math.floor(e/10)%10,o=Math.floor(e/100);let u="";return o>0&&(u+=(1===o?r:t[o])+a),1===i?u+=l[n]:i>=2&&n>0?u+=(1===n?r:t[n])+"und"+s[i]:i>=2?u+=s[i]:(n>0&&o>0||n>0)&&(u+=t[n]),u}const g=new Array(1e3);for(let e=0;e<1e3;e++)g[e]=f(e);const h=new Array(1e3);for(let e=0;e<1e3;e++)h[e]=d(e);function m(e){if(0n===e)return c;if(e<1000n)return g[Number(e)];if(e<1000000n){const n=Number(e/1000n),i=Number(e%1000n);let t=h[n]+o[0];return i>0&&(t+=g[i]),t}return function(e){const n=e.toString(),i=n.length,t=[],r=i%3;let l=0;for(r>0&&(t.push(Number(n.slice(0,r))),l=r);l<i;)t.push(Number(n.slice(l,l+3))),l+=3;const s=[];let a=t.length-1;for(let e=0;e<t.length;e++){const n=t[e];if(0!==n)if(0===a)s.push({words:g[n],isScale:!1,scaleLevel:0});else if(1===a)s.push({words:h[n]+o[0],isScale:!1,scaleLevel:1});else{let e;e=1===n?"eine":g[n];const i=1===n?o[a-1]:u[a-1];s.push({words:e,isScale:!1,scaleLevel:a}),s.push({words:i,isScale:!0,scaleLevel:a})}a--}return function(e){if(0===e.length)return c;let n="";for(let i=0;i<e.length;i++){const t=e[i],r=i>0?e[i-1]:null;i>0&&(t.isScale||r&&r.isScale)&&(n+=" "),n+=t.words}return n}(s)}(e)}e.de=function(e){const{isNegative:t,integerPart:r,decimalPart:l}=function(e){const t=typeof e;if("bigint"===t)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===t){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:n(function(e){const n=e.toString();return n.includes("e")||n.includes("E")?i(n):n}(e))}if("string"===t)return n(function(e){const n=e.trim();if(0===n.length||Number.isNaN(Number(n)))throw new Error(`Invalid number format: "${e}"`);return n.includes("e")||n.includes("E")?i(n):n}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${t}`)}(e);let s="";return t&&(s="minus "),s+=m(r),l&&(s+=" komma "+function(e){let n="",i=0;for(;i<e.length&&"0"===e[i];)n&&(n+=" "),n+=c,i++;const t=e.slice(i);return t&&(n&&(n+=" "),n+=m(BigInt(t))),n}(l)),s}},"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=de.js.map