n2words 2.0.0 → 3.1.0

package/dist/languages/az.js.map

@@ -0,0 +1 @@
+{"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 module with its own input validation, ready for subpath exports.\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\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  if (n < 1000n) {\n    return buildSegment(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(buildSegment(segment))\n      } else if (scaleIndex === 1 && segment === 1) {\n        // Omit \"bir\" before thousand\n        parts.push(scaleWord)\n      } else {\n        parts.push(buildSegment(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","integerToWords","Number","numStr","toString","len","segments","remainderLen","pos","scaleIndex","i","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

@@ -0,0 +1,3 @@
+/*! n2words/bn v3.1.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("."),s=-1===i?t:t.slice(0,i)+t.slice(i+1),o=(-1===i?t.length:i)+r;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 r="শূন্য",i=["শূন্য","এক","দুই","তিন","চার","পাঁচ","ছয়","সাত","আট","নয়","দশ","এগারো","বারো","তেরো","চৌদ্দ","পনেরো","ষোল","সতেরো","আঠারো","উনিশ","বিশ","একুশ","বাইশ","তেইশ","চব্বিশ","পঁচিশ","ছাব্বিশ","সাতাশ","আঠাশ","উনত্রিশ","ত্রিশ","একত্রিশ","বত্রিশ","তেত্রিশ","চৌত্রিশ","পঁয়ত্রিশ","ছত্রিশ","সাঁইত্রিশ","আটত্রিশ","উনচল্লিশ","চল্লিশ","একচল্লিশ","বেয়াল্লিশ","তেতাল্লিশ","চুয়াল্লিশ","পঁয়তাল্লিশ","ছেচল্লিশ","সাতচল্লিশ","আটচল্লিশ","উনপঞ্চাশ","পঞ্চাশ","একান্ন","বাহান্ন","তিপ্পান্ন","চুয়ান্ন","পঞ্চান্ন","ছাপ্পান্ন","সাতান্ন","আটান্ন","উনষাট","ষাট","একষট্টি","বাষট্টি","তেষট্টি","চৌষট্টি","পঁয়ষট্টি","ছেষট্টি","সাতষট্টি","আটষট্টি","ঊনসত্তর","সত্তর","একাত্তর","বাহাত্তর","তেহাত্তর","চুয়াত্তর","পঁচাত্তর","ছিয়াত্তর","সাতাত্তর","আটাত্তর","উনআশি","আশি","একাশি","বিরাশি","তিরাশি","চুরাশি","পঁচাশি","ছিয়াশি","সাতাশি","আটাশি","উননব্বই","নব্বই","একানব্বই","বিরানব্বই","তিরানব্বই","চুরানব্বই","পঁচানব্বই","ছিয়ানব্বই","সাতানব্বই","আটানব্বই","নিরানব্বই"],s=["","হাজার","লাখ","কোটি","আরব","খরব","নীল","পদ্ম","শঙ্খ"];function o(e){if(0===e)return"";if(e<100)return i[e];const t=Math.trunc(e/100),n=e%100;return 0===n?i[t]+" শত":i[t]+" শত "+i[n]}function u(e){if(0n===e)return r;if(e<1000n)return o(Number(e));const t=[];t.push(Number(e%1000n));let n=e/1000n;for(;n>0n;)t.push(Number(n%100n)),n/=100n;const u=[];for(let e=t.length-1;e>=0;e--){const n=t[e];0!==n&&(u.push(0===e?o(n):i[n]),e>0&&s[e]&&u.push(s[e]))}return u.join(" ")}e.bn=function(e){const{isNegative:i,integerPart:s,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 c="";return i&&(c="মাইনাস "),c+=u(s),o&&(c+=" দশমিক "+function(e){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+=r,n++;const i=e.slice(n);return i&&(t&&(t+=" "),t+=u(BigInt(i))),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

@@ -0,0 +1 @@
+{"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 module with its own input validation, ready for subpath exports.\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 Building\n// ============================================================================\n\n/**\n * Builds words for a 0-999 segment.\n */\nfunction buildSegment (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\n/**\n * Converts a non-negative integer to Bengali words.\n *\n * Uses BigInt modulo for segment extraction (faster than string slicing).\n * South Asian 3-2-2 grouping: first 3 digits, then groups of 2.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Bengali 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 buildSegment(Number(n))\n  }\n\n  // Extract segments using BigInt modulo\n  // First segment is 3 digits (thousands), rest are 2 digits (lakhs, crores, etc.)\n  // Segments stored least-significant first\n  const segments = []\n\n  // First segment: last 3 digits\n  segments.push(Number(n % 1000n))\n  let temp = n / 1000n\n\n  // Remaining segments: 2 digits each (lakh = 100k, crore = 10M, etc.)\n  while (temp > 0n) {\n    segments.push(Number(temp % 100n))\n    temp = temp / 100n\n  }\n\n  // Build result string (process from most-significant to least)\n  const words = []\n  for (let i = segments.length - 1; i >= 0; i--) {\n    const segment = segments[i]\n    if (segment === 0) continue\n\n    if (i === 0) {\n      // First segment (units place) can be 0-999\n      words.push(buildSegment(segment))\n    } else {\n      // Other segments are 0-99\n      words.push(BELOW_HUNDRED[segment])\n    }\n\n    // Add scale word if not the units segment\n    if (i > 0 && SCALE_WORDS[i]) {\n      words.push(SCALE_WORDS[i])\n    }\n  }\n\n  return words.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 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","buildSegment","n","hundreds","Math","trunc","remainder","integerToWords","Number","segments","push","temp","words","i","segment","join","value","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/cs.js

@@ -0,0 +1,3 @@
+/*! n2words/cs v3.1.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(" ")}function d(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 f(t){if(0n===t)return a;if(t<1000n)return c(Number(t));if(t<1000000n){const e=t/1000n,n=Number(t%1000n),i=d(e,u[1]);let r;return r=1n===e?i:c(Number(e))+" "+i,n>0&&(r+=" "+l(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+=l(Number(n));else{const e=u[t];if(e){const t=d(n,e);i+=1n===n?t:c(Number(n))+" "+t}else i+=c(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+=f(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+=f(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

@@ -0,0 +1 @@
+{"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 * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Czech-specific rules:\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// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for 0-999 (masculine, default form).\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// ============================================================================\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\n  if (n < 1000n) {\n    return buildSegment(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 = buildSegment(Number(thousands)) + ' ' + scaleWord\n    }\n\n    if (remainder > 0) {\n      // Use form with irregular hundreds (for \"dvě stě\" etc.)\n      result += ' ' + buildSegmentWithHundreds(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 += buildSegmentWithHundreds(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 += buildSegment(Number(segment)) + ' ' + scaleWord\n        }\n      } else {\n        // Fallback for very large scales without defined forms\n        result += buildSegment(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","pluralize","forms","lastDigit","lastTwoDigits","integerToWords","Number","thousands","remainder","scaleWord","result","segmentValues","temp","i","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

@@ -0,0 +1,3 @@
+/*! n2words/da v3.1.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("."),s=-1===i?t:t.slice(0,i)+t.slice(i+1),o=(-1===i?t.length:i)+r;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 r=["","et","to","tre","fire","fem","seks","syv","otte","ni"],i=["","en","to","tre","fire","fem","seks","syv","otte","ni"],s=["ti","elleve","tolv","tretten","fjorten","femten","seksten","sytten","atten","nitten"],o=["","","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?s[t]:0===t?o[n]:i[t]+"og"+o[n]),2===u.length?u[0]+" og "+u[1]:u[0]||""}function a(e){if(0n===e)return u;if(e<1000n)return c(Number(e));if(e<1000000n){const t=Number(e/1000n),n=Number(e%1000n);let r=c(t)+l;return n>0&&(r+="e og "+c(n)),r}return function(e){const t=e.toString(),n=t.length,r=[],i=n%3;let s=0;for(i>0&&(r.push(Number(t.slice(0,i))),s=i);s<n;)r.push(Number(t.slice(s,s+3))),s+=3;const o=[];let a=r.length-1;for(let e=0;e<r.length;e++){const t=r[e];if(0!==t){const e=c(t);if(0===a)o.push({word:e,type:"units"});else if(1===a)o.push({word:e+l,type:"thousand"});else{let n=e;1===t&&(n="en"),o.push({word:n+" "+f[a-2],type:"million"})}}a--}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("")}(o)}(e)}e.da=function(e){const{isNegative:r,integerPart:i,decimalPart:s}=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 o="";return r&&(o="minus "),o+=a(i),s&&(o+=" 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+=a(BigInt(r))),t}(s)),o}},"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

@@ -0,0 +1 @@
+{"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 * Self-contained module with its own input validation, ready for subpath exports.\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// Segment Building\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// ============================================================================\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 buildSegment(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 = buildSegment(thousands) + THOUSAND\n\n    if (remainder > 0) {\n      // Add 'e' suffix and \" og \" for remainder: \"firetusinde og ...\"\n      result += 'e og ' + buildSegment(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 = buildSegment(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","integerToWords","Number","thousands","remainder","result","numStr","toString","len","segments","remainderLen","pos","scaleIndex","i","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

@@ -0,0 +1,3 @@
+/*! n2words/de v3.1.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"],u=["tausend","Million","Milliarde","Billion","Billiarde","Trillion","Trilliarde","Quadrillion","Quadrilliarde"],o=["tausend","Millionen","Milliarden","Billionen","Billiarden","Trillionen","Trilliarden","Quadrillionen","Quadrilliarden"],c="hundert",a="null";function f(e){if(0===e)return"";const n=e%10,i=Math.trunc(e/10)%10,u=Math.trunc(e/100);let o="";return u>0&&(o+=(1===u?r:t[u])+c),1===i?o+=l[n]:i>=2&&n>0?o+=(1===n?r:t[n])+"und"+s[i]:i>=2?o+=s[i]:n>0&&(o+=t[n]),o}function d(e){if(0===e)return"";if(1===e)return r;const n=e%10,i=Math.trunc(e/10)%10,u=Math.trunc(e/100);let o="";return u>0&&(o+=(1===u?r:t[u])+c),1===i?o+=l[n]:i>=2&&n>0?o+=(1===n?r:t[n])+"und"+s[i]:i>=2?o+=s[i]:(n>0&&u>0||n>0)&&(o+=t[n]),o}function g(e){if(0n===e)return a;if(e<1000n)return f(Number(e));if(e<1000000n){const n=Number(e/1000n),i=Number(e%1000n);let t=d(n)+u[0];return i>0&&(t+=f(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 c=t.length-1;for(let e=0;e<t.length;e++){const n=t[e];if(0!==n)if(0===c)s.push({words:f(n),isScale:!1,scaleLevel:0});else if(1===c){const e=d(n);s.push({words:e+u[0],isScale:!1,scaleLevel:1})}else{let e;e=1===n?"eine":f(n);const i=1===n?u[c-1]:o[c-1];s.push({words:e,isScale:!1,scaleLevel:c}),s.push({words:i,isScale:!0,scaleLevel:c})}c--}return function(e){if(0===e.length)return a;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+=g(r),l&&(s+=" komma "+function(e){let n="",i=0;for(;i<e.length&&"0"===e[i];)n&&(n+=" "),n+=a,i++;const t=e.slice(i);return t&&(n&&(n+=" "),n+=g(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

package/dist/languages/de.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"de.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/de.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 * German language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Inverted tens-ones order: \"einundzwanzig\" (one-and-twenty) for 21-99\n * - Compound words without spaces below million level\n * - Three forms of 1: \"eins\" (standalone), \"ein\" (before hundert/tausend), \"eine\" (before Million+)\n * - Scale pluralization: Million → Millionen, Milliarde → Milliarden\n * - Spaces only around million+ scale words\n * - BigInt modulo for efficient segment extraction\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\n// Ones words (1-9), index 0 unused\nconst ONES = ['', 'eins', 'zwei', 'drei', 'vier', 'fünf', 'sechs', 'sieben', 'acht', 'neun']\n\n// \"ein\" form for use before hundert/und\nconst EIN = 'ein'\n\n// Teens (10-19)\nconst TEENS = ['zehn', 'elf', 'zwölf', 'dreizehn', 'vierzehn', 'fünfzehn', 'sechzehn', 'siebzehn', 'achtzehn', 'neunzehn']\n\n// Tens (20-90)\nconst TENS = ['', '', 'zwanzig', 'dreißig', 'vierzig', 'fünfzig', 'sechzig', 'siebzig', 'achtzig', 'neunzig']\n\n// Scale words (index 0 = thousand, 1 = million, etc.)\nconst SCALES = ['tausend', 'Million', 'Milliarde', 'Billion', 'Billiarde', 'Trillion', 'Trilliarde', 'Quadrillion', 'Quadrilliarde']\n\n// Pluralized scale words (million+)\nconst SCALES_PLURAL = ['tausend', 'Millionen', 'Milliarden', 'Billionen', 'Billiarden', 'Trillionen', 'Trilliarden', 'Quadrillionen', 'Quadrilliarden']\n\nconst HUNDRED = 'hundert'\nconst ZERO = 'null'\nconst NEGATIVE = 'minus'\nconst DECIMAL_SEP = 'komma'\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for 0-999 (standalone form, uses \"eins\").\n * German inverts ones and tens: \"einundzwanzig\" = one-and-twenty\n *\n * @param {number} n - Number 0-999\n * @returns {string} German words for the segment\n */\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.trunc(n / 10) % 10\n  const hundreds = Math.trunc(n / 100)\n\n  let result = ''\n\n  // Hundreds: \"ein\" before hundert, not \"eins\"\n  if (hundreds > 0) {\n    result += (hundreds === 1 ? EIN : ONES[hundreds]) + HUNDRED\n  }\n\n  // Tens and ones\n  if (tens === 1) {\n    // Teens\n    result += TEENS[ones]\n  } else if (tens >= 2 && ones > 0) {\n    // Inverted: \"einundzwanzig\" (one-and-twenty)\n    // Use \"ein\" before \"und\", not \"eins\"\n    result += (ones === 1 ? EIN : ONES[ones]) + 'und' + TENS[tens]\n  } else if (tens >= 2) {\n    // Just tens\n    result += TENS[tens]\n  } else if (ones > 0) {\n    // Just ones (no tens, possibly after hundreds)\n    // Use \"eins\" for standalone/after hundreds\n    result += ONES[ones]\n  }\n\n  return result\n}\n\n/**\n * Builds segment word for use before \"tausend\".\n * Uses \"ein\" instead of \"eins\" for 1.\n *\n * @param {number} n - Number 0-999\n * @returns {string} German words for thousand context\n */\nfunction buildSegmentForThousand (n) {\n  if (n === 0) return ''\n  if (n === 1) return EIN // \"eintausend\"\n\n  const ones = n % 10\n  const tens = Math.trunc(n / 10) % 10\n  const hundreds = Math.trunc(n / 100)\n\n  let result = ''\n\n  if (hundreds > 0) {\n    result += (hundreds === 1 ? EIN : ONES[hundreds]) + HUNDRED\n  }\n\n  if (tens === 1) {\n    result += TEENS[ones]\n  } else if (tens >= 2 && ones > 0) {\n    result += (ones === 1 ? EIN : ONES[ones]) + 'und' + TENS[tens]\n  } else if (tens >= 2) {\n    result += TENS[tens]\n  } else if (ones > 0 && hundreds > 0) {\n    result += ONES[ones]\n  } else if (ones > 0) {\n    result += ONES[ones]\n  }\n\n  return result\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to German words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} German words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000\n  if (n < 1000n) {\n    return buildSegment(Number(n))\n  }\n\n  // Fast path: numbers < 1,000,000\n  if (n < 1_000_000n) {\n    const thousands = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    // Compound: \"eintausendzweihundert\" (no spaces)\n    let result = buildSegmentForThousand(thousands) + SCALES[0]\n\n    if (remainder > 0) {\n      result += buildSegment(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} German 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\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      if (scaleIndex === 0) {\n        // Units segment (no scale word)\n        parts.push({ words: buildSegment(segment), isScale: false, scaleLevel: 0 })\n      } else if (scaleIndex === 1) {\n        // Thousands: compound without space\n        const segWords = buildSegmentForThousand(segment)\n        parts.push({ words: segWords + SCALES[0], isScale: false, scaleLevel: 1 })\n      } else {\n        // Million+ : space around scale word\n        let segWords\n        if (segment === 1) {\n          segWords = 'eine' // \"eine Million\"\n        } else {\n          segWords = buildSegment(segment)\n        }\n        const scaleWord = segment === 1 ? SCALES[scaleIndex - 1] : SCALES_PLURAL[scaleIndex - 1]\n        parts.push({ words: segWords, isScale: false, scaleLevel: scaleIndex })\n        parts.push({ words: scaleWord, isScale: true, scaleLevel: scaleIndex })\n      }\n    }\n\n    scaleIndex--\n  }\n\n  // Join with German spacing rules: space around million+ scale words\n  return joinGermanParts(parts)\n}\n\n/**\n * Joins parts with German spacing rules.\n * Spaces only around million+ scale words.\n *\n * @param {Array} parts - Parts with metadata\n * @returns {string} Joined string\n */\nfunction joinGermanParts (parts) {\n  if (parts.length === 0) return ZERO\n\n  let result = ''\n\n  for (let i = 0; i < parts.length; i++) {\n    const part = parts[i]\n    const prevPart = i > 0 ? parts[i - 1] : null\n\n    // Add space before if:\n    // - Current is a million+ scale word\n    // - Previous was a million+ scale word\n    if (i > 0) {\n      const needsSpace = part.isScale || (prevPart && prevPart.isScale)\n      if (needsSpace) {\n        result += ' '\n      }\n    }\n\n    result += part.words\n  }\n\n  return result\n}\n\n/**\n * Converts decimal digits to German words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} German 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 German 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 German 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)           // 'einundzwanzig'\n * toWords(1000)         // 'eintausend'\n * toWords(1000000)      // 'eine Million'\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","EIN","TEENS","TENS","SCALES","SCALES_PLURAL","HUNDRED","ZERO","buildSegment","n","ones","tens","Math","trunc","hundreds","result","buildSegmentForThousand","integerToWords","Number","thousands","remainder","numStr","toString","len","segments","remainderLen","pos","push","parts","scaleIndex","i","segment","words","isScale","scaleLevel","segWords","scaleWord","part","prevPart","joinGermanParts","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/el.js

@@ -0,0 +1,3 @@
+/*! n2words/el v3.1.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("."),s=-1===i?t:t.slice(0,i)+t.slice(i+1),o=(-1===i?t.length:i)+r;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 r=["","ένα","δύο","τρία","τέσσερα","πέντε","έξι","επτά","οκτώ","εννέα"],i=["δέκα","έντεκα","δώδεκα","δεκατρία","δεκατέσσερα","δεκαπέντε","δεκαέξι","δεκαεπτά","δεκαοκτώ","δεκαεννέα"],s=["","","είκοσι","τριάντα","σαράντα","πενήντα","εξήντα","εβδομήντα","ογδόντα","ενενήντα"],o=["","εκατό","διακόσια","τριακόσια","τετρακόσια","πεντακόσια","εξακόσια","επτακόσια","οκτακόσια","εννιακόσια"],u="χίλια",c="μηδέν",f=["εκατομμύριο","δισεκατομμύριο","τρισεκατομμύριο"];function l(e){if(0===e)return"";const t=e%10,n=Math.floor(e/10)%10,u=Math.floor(e/100),c=[];u>0&&c.push(o[u]);const f=e%100;return 0===f||c.push(f<10?r[t]:f<20?i[t]:0===t?s[n]:s[n]+" "+r[t]),c.join(" ")}e.el=function(e){const{isNegative:i,integerPart:s,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 a="";return i&&(a="μείον "),a+=function(e){if(0n===e)return c;if(e<1000n)return l(Number(e));if(e<1000000n){const t=Number(e/1000n),n=Number(e%1000n);let r;return r=1===t?u:l(t)+" "+u,n>0&&(r+=" "+l(n)),r}return function(e){const t=e.toString(),n=t.length,r=[],i=n%3;let s=0;for(i>0&&(r.push(Number(t.slice(0,i))),s=i);s<n;)r.push(Number(t.slice(s,s+3))),s+=3;const o=[];let c=r.length-1;for(let e=0;e<r.length;e++){const t=r[e];if(0!==t){const e=l(t);if(0===c)o.push(e);else if(1===c)o.push(1===t?u:e+" "+u);else{const n=f[c-2];o.push(1===t?n:e+" "+n)}}c--}return o.join(" ")}(e)}(s),o&&(a+=" κόμμα "+function(e){const t=[];for(const n of e){const e=parseInt(n,10);t.push(0===e?c:r[e])}return t.join(" ")}(o)),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=el.js.map

package/dist/languages/el.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"el.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/el.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 * Greek language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Space-separated number composition\n * - Implicit \"one\" (ένα) omission before scale words\n * - Irregular hundreds (διακόσια, τριακόσια, etc.)\n * - Per-digit decimal reading\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\nconst ONES = ['', 'ένα', 'δύο', 'τρία', 'τέσσερα', 'πέντε', 'έξι', 'επτά', 'οκτώ', 'εννέα']\n\nconst TEENS = ['δέκα', 'έντεκα', 'δώδεκα', 'δεκατρία', 'δεκατέσσερα', 'δεκαπέντε', 'δεκαέξι', 'δεκαεπτά', 'δεκαοκτώ', 'δεκαεννέα']\n\nconst TENS = ['', '', 'είκοσι', 'τριάντα', 'σαράντα', 'πενήντα', 'εξήντα', 'εβδομήντα', 'ογδόντα', 'ενενήντα']\n\n// Greek has irregular hundreds\nconst HUNDREDS = ['', 'εκατό', 'διακόσια', 'τριακόσια', 'τετρακόσια', 'πεντακόσια', 'εξακόσια', 'επτακόσια', 'οκτακόσια', 'εννιακόσια']\n\nconst THOUSAND = 'χίλια'\n\nconst ZERO = 'μηδέν'\nconst NEGATIVE = 'μείον'\nconst DECIMAL_SEP = 'κόμμα'\n\n// Short scale\nconst SCALES = ['εκατομμύριο', 'δισεκατομμύριο', 'τρισεκατομμύριο']\n\n// ============================================================================\n// Segment Building\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 (irregular forms)\n  if (hundreds > 0) {\n    parts.push(HUNDREDS[hundreds])\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    parts.push(ONES[ones])\n  } else if (tensOnes < 20) {\n    parts.push(TEENS[ones])\n  } else if (ones === 0) {\n    parts.push(TENS[tens])\n  } else {\n    parts.push(TENS[tens] + ' ' + ONES[ones])\n  }\n\n  return parts.join(' ')\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Greek words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Greek 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 buildSegment(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    // Omit \"ένα\" before χίλια\n    let result\n    if (thousands === 1) {\n      result = THOUSAND\n    } else {\n      result = buildSegment(thousands) + ' ' + THOUSAND\n    }\n\n    if (remainder > 0) {\n      result += ' ' + buildSegment(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} Greek 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\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 = buildSegment(segment)\n\n      if (scaleIndex === 0) {\n        // Units segment\n        parts.push(segmentWord)\n      } else if (scaleIndex === 1) {\n        // Thousands - omit \"ένα\" before χίλια\n        if (segment === 1) {\n          parts.push(THOUSAND)\n        } else {\n          parts.push(segmentWord + ' ' + THOUSAND)\n        }\n      } else {\n        // Millions+ - omit \"ένα\" before scale words\n        const scaleWord = SCALES[scaleIndex - 2]\n        if (segment === 1) {\n          parts.push(scaleWord)\n        } else {\n          parts.push(segmentWord + ' ' + scaleWord)\n        }\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts decimal digits to Greek words (per-digit).\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Greek words for decimal part\n */\nfunction decimalPartToWords (decimalPart) {\n  const parts = []\n\n  for (const digit of decimalPart) {\n    const d = parseInt(digit, 10)\n    if (d === 0) {\n      parts.push(ZERO)\n    } else {\n      parts.push(ONES[d])\n    }\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts a numeric value to Greek words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Greek 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)       // 'είκοσι ένα'\n * toWords(1000)     // 'χίλια'\n * toWords('3.14')   // 'τρία κόμμα ένα τέσσερα'\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","TEENS","TENS","HUNDREDS","THOUSAND","ZERO","SCALES","buildSegment","n","ones","tens","Math","floor","hundreds","parts","push","tensOnes","join","value","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","thousands","remainder","numStr","len","segments","remainderLen","pos","scaleIndex","i","segment","segmentWord","scaleWord","buildLargeNumberWords","integerToWords","digit","d","decimalPartToWords"],"mappings":"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"}

package/dist/languages/en.js

@@ -0,0 +1,3 @@
+/*! n2words/en v3.1.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=["","one","two","three","four","five","six","seven","eight","nine"],r=["ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"],o=["","","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"],s=["thousand","million","billion","trillion","quadrillion","quintillion","sextillion","septillion","octillion"],u="hundred",l="zero",f={word:"",hasHundred:!1};function d(e){if(0===e)return f.word="",f.hasHundred=!1,f;const n=e%10,t=Math.trunc(e/10)%10,s=Math.trunc(e/100);let l="";return 1===t?l=r[n]:t>=2?l=n>0?o[t]+"-"+i[n]:o[t]:n>0&&(l=i[n]),s>0?(f.word=l?i[s]+" "+u+" and "+l:i[s]+" "+u,f.hasHundred=!0):(f.word=l,f.hasHundred=!1),f}function c(e){if(0n===e)return l;if(e<1000n)return d(Number(e)).word;if(e<1000000n){const n=Number(e/1000n),t=Number(e%1000n),{word:i}=d(n);let r=i+" "+s[0];if(t>0){const{word:e,hasHundred:n}=d(t);r+=n?" "+e:" and "+e}return r}return function(e){const n=[];let t=e;for(;t>0n;)n.push(Number(t%1000n)),t/=1000n;let i=-1;for(let e=0;e<n.length;e++)if(0!==n[e]){i=e;break}let r="",o=!1;for(let e=n.length-1;e>=0;e--){const t=n[e];if(0===t)continue;const{word:u,hasHundred:l}=d(t);r&&e===i&&o&&!l&&(r+=" and"),r&&(r+=" "),r+=u,e>0?(r+=" "+s[e-1],o=!0):o=!1}return r}(e)}e.en=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 s="";return i&&(s="minus "),s+=c(r),o&&(s+=" point "+function(e){let n="",t=0;for(;t<e.length&&"0"===e[t];)n&&(n+=" "),n+=l,t++;const i=e.slice(t);return i&&(n&&(n+=" "),n+=c(BigInt(i))),n}(o)),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=en.js.map

package/dist/languages/en.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"en.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/en.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 * English language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Western numbering system (thousand, million, billion)\n * - \"and\" after hundreds: \"one hundred and twenty-three\"\n * - Hyphenated tens-ones: \"twenty-one\", \"forty-two\"\n * - \"and\" before final segment when following scale word\n * - BigInt modulo for efficient segment extraction\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\nconst ONES = ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']\nconst TEENS = ['ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen']\nconst TENS = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety']\n\nconst SCALES = ['thousand', 'million', 'billion', 'trillion', 'quadrillion', 'quintillion', 'sextillion', 'septillion', 'octillion']\n\nconst HUNDRED = 'hundred'\nconst ZERO = 'zero'\nconst NEGATIVE = 'minus'\nconst DECIMAL_SEP = 'point'\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n// Reusable result object to avoid allocation per call\nconst segmentResult = { word: '', hasHundred: false }\n\n/**\n * Builds words for a 0-999 segment.\n *\n * @param {number} n - Number 0-999\n * @returns {{ word: string, hasHundred: boolean }}\n */\nfunction buildSegment (n) {\n  if (n === 0) {\n    segmentResult.word = ''\n    segmentResult.hasHundred = false\n    return segmentResult\n  }\n\n  const ones = n % 10\n  const tens = Math.trunc(n / 10) % 10\n  const hundreds = Math.trunc(n / 100)\n\n  // Build tens-ones part first\n  let tensOnes = ''\n  if (tens === 1) {\n    tensOnes = TEENS[ones]\n  } else if (tens >= 2) {\n    tensOnes = ones > 0 ? TENS[tens] + '-' + ONES[ones] : TENS[tens]\n  } else if (ones > 0) {\n    tensOnes = ONES[ones]\n  }\n\n  // Hundreds place\n  if (hundreds > 0) {\n    if (tensOnes) {\n      segmentResult.word = ONES[hundreds] + ' ' + HUNDRED + ' and ' + tensOnes\n    } else {\n      segmentResult.word = ONES[hundreds] + ' ' + HUNDRED\n    }\n    segmentResult.hasHundred = true\n  } else {\n    segmentResult.word = tensOnes\n    segmentResult.hasHundred = false\n  }\n\n  return segmentResult\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to English words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} English words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000\n  if (n < 1000n) {\n    return buildSegment(Number(n)).word\n  }\n\n  // Fast path: numbers < 1,000,000\n  if (n < 1_000_000n) {\n    const thousands = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    const { word: thousandsWord } = buildSegment(thousands)\n    let result = thousandsWord + ' ' + SCALES[0]\n\n    if (remainder > 0) {\n      const { word: remainderWord, hasHundred } = buildSegment(remainder)\n      result += hasHundred ? ' ' + remainderWord : ' and ' + remainderWord\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} English words\n */\nfunction buildLargeNumberWords (n) {\n  // Extract segments using BigInt division\n  // Segments are stored least-significant first (index 0 = ones, 1 = thousands, etc.)\n  const segments = []\n  let temp = n\n  while (temp > 0n) {\n    segments.push(Number(temp % 1000n))\n    temp = temp / 1000n\n  }\n\n  // Find the first (smallest index) non-zero segment - this is processed last\n  let firstNonZeroIdx = -1\n  for (let i = 0; i < segments.length; i++) {\n    if (segments[i] !== 0) {\n      firstNonZeroIdx = i\n      break\n    }\n  }\n\n  // Build result string (process from most-significant to least)\n  let result = ''\n  let prevWasScale = false\n\n  for (let i = segments.length - 1; i >= 0; i--) {\n    const segment = segments[i]\n    if (segment === 0) continue\n\n    const { word, hasHundred } = buildSegment(segment)\n    const isLastSegment = (i === firstNonZeroIdx)\n\n    // Add \"and\" only before FINAL segment if it follows scale and doesn't have hundred\n    if (result && isLastSegment && prevWasScale && !hasHundred) {\n      result += ' and'\n    }\n\n    // Add segment word\n    if (result) result += ' '\n    result += word\n\n    // Add scale word (i=0 is units, i=1 is thousands, etc.)\n    if (i > 0) {\n      result += ' ' + SCALES[i - 1]\n      prevWasScale = true\n    } else {\n      prevWasScale = false\n    }\n  }\n\n  return result\n}\n\n/**\n * Converts decimal digits to English words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} English 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 English 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 English 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(42)           // 'forty-two'\n * toWords(-3.14)        // 'minus three point one four'\n * toWords('1000000')    // 'one million'\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","TEENS","TENS","SCALES","HUNDRED","ZERO","segmentResult","word","hasHundred","buildSegment","n","ones","tens","Math","trunc","hundreds","tensOnes","integerToWords","Number","thousands","remainder","thousandsWord","result","remainderWord","segments","temp","push","firstNonZeroIdx","i","prevWasScale","segment","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":";0CAwEA,SAASA,EAAoBC,GAC3B,MAAMC,EAAwB,MAAXD,EAAI,GACnBC,IAAYD,EAAMA,EAAIE,MAAM,IAEhC,MAAMC,EAAWH,EAAII,QAAQ,KAC7B,IAAiB,IAAbD,EACF,MAAO,CAAEF,aAAYI,YAAaC,OAAON,IAG3C,MAAMO,EAAaP,EAAIE,MAAM,EAAGC,IAAa,IACvCK,EAAcR,EAAIE,MAAMC,EAAW,GACzC,MAAO,CAAEF,aAAYI,YAAaC,OAAOC,GAAaC,cACxD,CAKA,SAASC,EAA0BT,GACjC,MAAOU,EAAUC,GAAUX,EAAIY,cAAcC,MAAM,KAC7CC,EAAMC,SAASJ,EAAQ,IAEvBR,EAAWO,EAASN,QAAQ,KAC5BY,OAASb,EACXO,EACAA,EAASR,MAAM,EAAGC,GAAYO,EAASR,MAAMC,EAAW,GAEtDc,IAD6B,IAAbd,EAAkBO,EAASQ,OAASf,GACnBW,EAEvC,OAAIG,GAAkBD,EAAOE,OACpBF,EAAS,IAAIG,OAAOF,EAAiBD,EAAOE,QAEjDD,GAAkB,EACb,KAAO,IAAIE,QAAQF,GAAkBD,EAEvCA,EAAOd,MAAM,EAAGe,GAAkB,IAAMD,EAAOd,MAAMe,EAC9D,CCxFA,MAAMG,EAAO,CAAC,GAAI,MAAO,MAAO,QAAS,OAAQ,OAAQ,MAAO,QAAS,QAAS,QAC5EC,EAAQ,CAAC,MAAO,SAAU,SAAU,WAAY,WAAY,UAAW,UAAW,YAAa,WAAY,YAC3GC,EAAO,CAAC,GAAI,GAAI,SAAU,SAAU,QAAS,QAAS,QAAS,UAAW,SAAU,UAEpFC,EAAS,CAAC,WAAY,UAAW,UAAW,WAAY,cAAe,cAAe,aAAc,aAAc,aAElHC,EAAU,UACVC,EAAO,OASPC,EAAgB,CAAEC,KAAM,GAAIC,YAAY,GAQ9C,SAASC,EAAcC,GACrB,GAAU,IAANA,EAGF,OAFAJ,EAAcC,KAAO,GACrBD,EAAcE,YAAa,EACpBF,EAGT,MAAMK,EAAOD,EAAI,GACXE,EAAOC,KAAKC,MAAMJ,EAAI,IAAM,GAC5BK,EAAWF,KAAKC,MAAMJ,EAAI,KAGhC,IAAIM,EAAW,GAsBf,OArBa,IAATJ,EACFI,EAAWf,EAAMU,GACRC,GAAQ,EACjBI,EAAWL,EAAO,EAAIT,EAAKU,GAAQ,IAAMZ,EAAKW,GAAQT,EAAKU,GAClDD,EAAO,IAChBK,EAAWhB,EAAKW,IAIdI,EAAW,GAEXT,EAAcC,KADZS,EACmBhB,EAAKe,GAAY,IAAMX,EAAU,QAAUY,EAE3ChB,EAAKe,GAAY,IAAMX,EAE9CE,EAAcE,YAAa,IAE3BF,EAAcC,KAAOS,EACrBV,EAAcE,YAAa,GAGtBF,CACT,CAYA,SAASW,EAAgBP,GACvB,GAAU,KAANA,EAAU,OAAOL,EAGrB,GAAIK,EAAI,MACN,OAAOD,EAAaS,OAAOR,IAAIH,KAIjC,GAAIG,EAAI,SAAY,CAClB,MAAMS,EAAYD,OAAOR,EAAI,OACvBU,EAAYF,OAAOR,EAAI,QAErBH,KAAMc,GAAkBZ,EAAaU,GAC7C,IAAIG,EAASD,EAAgB,IAAMlB,EAAO,GAE1C,GAAIiB,EAAY,EAAG,CACjB,MAAQb,KAAMgB,EAAaf,WAAEA,GAAeC,EAAaW,GACzDE,GAAUd,EAAa,IAAMe,EAAgB,QAAUA,CACzD,CAEA,OAAOD,CACT,CAGA,OAUF,SAAgCZ,GAG9B,MAAMc,EAAW,GACjB,IAAIC,EAAOf,EACX,KAAOe,EAAO,IACZD,EAASE,KAAKR,OAAOO,EAAO,QAC5BA,GAAc,MAIhB,IAAIE,GAAkB,EACtB,IAAK,IAAIC,EAAI,EAAGA,EAAIJ,EAAS1B,OAAQ8B,IACnC,GAAoB,IAAhBJ,EAASI,GAAU,CACrBD,EAAkBC,EAClB,KACF,CAIF,IAAIN,EAAS,GACTO,GAAe,EAEnB,IAAK,IAAID,EAAIJ,EAAS1B,OAAS,EAAG8B,GAAK,EAAGA,IAAK,CAC7C,MAAME,EAAUN,EAASI,GACzB,GAAgB,IAAZE,EAAe,SAEnB,MAAMvB,KAAEA,EAAIC,WAAEA,GAAeC,EAAaqB,GAItCR,GAHmBM,IAAMD,GAGEE,IAAiBrB,IAC9Cc,GAAU,QAIRA,IAAQA,GAAU,KACtBA,GAAUf,EAGNqB,EAAI,GACNN,GAAU,IAAMnB,EAAOyB,EAAI,GAC3BC,GAAe,GAEfA,GAAe,CAEnB,CAEA,OAAOP,CACT,CA3DSS,CAAsBrB,EAC/B,MAuGA,SAAkBsB,GAChB,MAAMnD,WAAEA,EAAUI,YAAEA,EAAWG,YAAEA,GD/M5B,SAA4B4C,GACjC,MAAMC,SAAcD,EAGpB,GAAa,WAATC,EACF,OAAOD,EAAQ,GACX,CAAEnD,YAAY,EAAMI,aAAc+C,GAClC,CAAEnD,YAAY,EAAOI,YAAa+C,GAIxC,GAAa,WAATC,EAAmB,CACrB,IAAKf,OAAOgB,SAASF,GACnB,MAAM,IAAIG,MAAM,8DAElB,OAAIjB,OAAOkB,cAAcJ,GAChBA,EAAQ,EACX,CAAEnD,YAAY,EAAMI,YAAaC,QAAQ8C,IACzC,CAAEnD,YAAY,EAAOI,YAAaC,OAAO8C,IAExCrD,EAgBX,SAAyBqD,GACvB,MAAMpD,EAAMoD,EAAMK,WAClB,OAAQzD,EAAI0D,SAAS,MAAQ1D,EAAI0D,SAAS,KACtCjD,EAAyBT,GACzBA,CACN,CArB8B2D,CAAeP,GAC3C,CAGA,GAAa,WAATC,EACF,OAAOtD,EAqBX,SAA0BqD,GACxB,MAAMQ,EAAUR,EAAMS,OACtB,GAAuB,IAAnBD,EAAQ1C,QAAgBoB,OAAOwB,MAAMxB,OAAOsB,IAC9C,MAAM,IAAIL,MAAM,2BAA2BH,MAE7C,OAAQQ,EAAQF,SAAS,MAAQE,EAAQF,SAAS,KAC9CjD,EAAyBmD,GACzBA,CACN,CA7B8BG,CAAgBX,IAG5C,MAAM,IAAIY,UACR,oEAAoEX,IAExE,CCgLmDY,CAAkBb,GAEnE,IAAIV,EAAS,GAYb,OAVIzC,IACFyC,EAASwB,UAGXxB,GAAUL,EAAehC,GAErBG,IACFkC,GAAU,UAjDd,SAA6BlC,GAC3B,IAAIkC,EAAS,GAGTM,EAAI,EACR,KAAOA,EAAIxC,EAAYU,QAA6B,MAAnBV,EAAYwC,IACvCN,IAAQA,GAAU,KACtBA,GAAUjB,EACVuB,IAIF,MAAMR,EAAYhC,EAAYN,MAAM8C,GAMpC,OALIR,IACEE,IAAQA,GAAU,KACtBA,GAAUL,EAAe/B,OAAOkC,KAG3BE,CACT,CA8BwCyB,CAAmB3D,IAGlDkC,CACT"}

package/dist/languages/es.js

@@ -0,0 +1,3 @@
+/*! n2words/es v3.1.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=["","uno","dos","tres","cuatro","cinco","seis","siete","ocho","nueve"],r=["","una","dos","tres","cuatro","cinco","seis","siete","ocho","nueve"],o=["diez","once","doce","trece","catorce","quince","dieciseis","diecisiete","dieciocho","diecinueve"],s=["veinte","veintiuno","veintidós","veintitrés","veinticuatro","veinticinco","veintiséis","veintisiete","veintiocho","veintinueve"],c=["veinte","veintiuna","veintidós","veintitrés","veinticuatro","veinticinco","veintiséis","veintisiete","veintiocho","veintinueve"],u=["","","","treinta","cuarenta","cincuenta","sesenta","setenta","ochenta","noventa"],a=["","ciento","doscientos","trescientos","cuatrocientos","quinientos","seiscientos","setecientos","ochocientos","novecientos"],l=["","cienta","doscientas","trescientas","cuatrocientas","quinientas","seiscientas","setecientas","ochocientas","novecientas"],f=["millón","billón","trillón","cuatrillón"],d=["millones","billones","trillones","cuatrillones"],v="mil",g="cero";function p(e,n){if(0===e)return"";if(100===e)return"cien";const t=e%10,f=Math.floor(e/10)%10,d=Math.floor(e/100),v=e%100,g=[];return d>0&&g.push((n?l:a)[d]),0===v||g.push(v<10?(n?r:i)[v]:v<20?o[t]:v<30?(n?c:s)[t]:0===t?u[f]:u[f]+" y "+(n?r:i)[t]),g.join(" ")}function b(e,n){if(1===e)return v;if(e%2==0){const t=e/2-1,i=f[t];return i?n>1n?d[t]:i:""}{const n=d[(e-1)/2-1];return n?v+" "+n:v}}function m(e,n){if(0n===e)return g;if(e<1000n)return p(Number(e),n);if(e<1000000n){const t=Number(e/1000n),i=Number(e%1000n);let r;if(1===t)r=v;else{const e=p(t,!1);r="uno"===e||"una"===e?v:e+" "+v}return i>0&&(r+=" "+p(i,n)),r}return function(e,n){const t=[];let i=e;for(;i>0n;)t.push(i%1000n),i/=1000n;let r="";for(let e=t.length-1;e>=0;e--){const i=t[e];if(0n===i)continue;const o=e>0?b(e,i):"";r&&(r+=" "),r+=0===e?p(Number(i),n):1===e?1n===i?v:p(Number(i),!1)+" "+o:e%2==1?1n===i?o:p(Number(i),!1)+" "+o:1n===i?"un "+o:p(Number(i),!1)+" "+o}return r}(e,n)}e.es=function(e,i){i=function(e){if(void 0===e)return{};if(function(e){if(null===e||"object"!=typeof e)return!1;const n=Object.getPrototypeOf(e);return null===n||n===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)}: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),c="feminine"===i.gender;let u="";return r&&(u="menos "),u+=m(o,c),s&&(u+=" punto "+function(e,n){let t="",i=0;for(;i<e.length&&"0"===e[i];)t&&(t+=" "),t+=g,i++;const r=e.slice(i);return r&&(t&&(t+=" "),t+=m(BigInt(r),n)),t}(s,c)),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=es.js.map

package/dist/languages/es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"es.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/es.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 * Spanish language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Spanish-specific rules:\n * - Gender agreement: uno/una, veintiuno/veintiuna, hundreds\n * - Special twenties: veinte, veintiuno, veintidós, ... veintinueve\n * - \"y\" conjunction: treinta y uno (only 30-99 with ones)\n * - \"cien\" for exact 100, \"ciento/cienta\" otherwise\n * - Irregular hundreds: quinientos, setecientos, novecientos\n * - Compound long scale: millón, mil millones, billón, mil billones\n * - \"un\" before millón (not \"uno\"), omit before mil\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\nimport { validateOptions } from '../utils/validate-options.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\nconst ONES_MASC = ['', 'uno', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve']\nconst ONES_FEM = ['', 'una', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve']\n\nconst TEENS = ['diez', 'once', 'doce', 'trece', 'catorce', 'quince', 'dieciseis', 'diecisiete', 'dieciocho', 'diecinueve']\n\n// 20-29 have special compound forms\nconst TWENTIES_MASC = ['veinte', 'veintiuno', 'veintidós', 'veintitrés', 'veinticuatro', 'veinticinco', 'veintiséis', 'veintisiete', 'veintiocho', 'veintinueve']\nconst TWENTIES_FEM = ['veinte', 'veintiuna', 'veintidós', 'veintitrés', 'veinticuatro', 'veinticinco', 'veintiséis', 'veintisiete', 'veintiocho', 'veintinueve']\n\nconst TENS = ['', '', '', 'treinta', 'cuarenta', 'cincuenta', 'sesenta', 'setenta', 'ochenta', 'noventa']\n\n// Irregular hundreds\nconst HUNDREDS_MASC = ['', 'ciento', 'doscientos', 'trescientos', 'cuatrocientos', 'quinientos', 'seiscientos', 'setecientos', 'ochocientos', 'novecientos']\nconst HUNDREDS_FEM = ['', 'cienta', 'doscientas', 'trescientas', 'cuatrocientas', 'quinientas', 'seiscientas', 'setecientas', 'ochocientas', 'novecientas']\n\n// Scale words (compound long scale)\nconst SCALES = ['millón', 'billón', 'trillón', 'cuatrillón']\nconst SCALES_PLURAL = ['millones', 'billones', 'trillones', 'cuatrillones']\n\nconst THOUSAND = 'mil'\nconst ZERO = 'cero'\nconst NEGATIVE = 'menos'\nconst DECIMAL_SEP = 'punto'\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for 0-999.\n * @param {number} n - Segment value\n * @param {boolean} feminine - Use feminine forms\n * @returns {string} Spanish word\n */\nfunction buildSegment (n, feminine) {\n  if (n === 0) return ''\n\n  // Special case: exact 100 is \"cien\" (no gender)\n  if (n === 100) return 'cien'\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n  const tensOnes = n % 100\n\n  const parts = []\n\n  // Hundreds\n  if (hundreds > 0) {\n    const hundredsArr = feminine ? HUNDREDS_FEM : HUNDREDS_MASC\n    parts.push(hundredsArr[hundreds])\n  }\n\n  // Tens and ones\n  if (tensOnes === 0) {\n    // Just hundreds\n  } else if (tensOnes < 10) {\n    // Single digit\n    const onesArr = feminine ? ONES_FEM : ONES_MASC\n    parts.push(onesArr[tensOnes])\n  } else if (tensOnes < 20) {\n    // 10-19: teens\n    parts.push(TEENS[ones])\n  } else if (tensOnes < 30) {\n    // 20-29: special twenties\n    const twentiesArr = feminine ? TWENTIES_FEM : TWENTIES_MASC\n    parts.push(twentiesArr[ones])\n  } else {\n    // 30-99: tens y ones\n    if (ones === 0) {\n      parts.push(TENS[tens])\n    } else {\n      const onesArr = feminine ? ONES_FEM : ONES_MASC\n      parts.push(TENS[tens] + ' y ' + onesArr[ones])\n    }\n  }\n\n  return parts.join(' ')\n}\n\n// ============================================================================\n// Helper Functions\n// ============================================================================\n\n/**\n * Gets scale word for Spanish compound long scale.\n *\n * @param {number} scaleIndex - Scale level (1 = thousand, 2 = million, etc.)\n * @param {bigint} segment - Segment value for pluralization\n * @returns {string} Scale word\n */\nfunction getScaleWord (scaleIndex, segment) {\n  if (scaleIndex === 1) return THOUSAND\n\n  // Even indices (2, 4, 6, 8): millón, billón, trillón, cuatrillón\n  // Odd indices > 1 (3, 5, 7): mil millones, mil billones, mil trillones\n  if (scaleIndex % 2 === 0) {\n    const arrayIndex = (scaleIndex / 2) - 1\n    const baseWord = SCALES[arrayIndex]\n    if (!baseWord) return ''\n    return segment > 1n ? SCALES_PLURAL[arrayIndex] : baseWord\n  } else {\n    // Compound: \"mil millones\" pattern\n    const arrayIndex = ((scaleIndex - 1) / 2) - 1\n    const pluralWord = SCALES_PLURAL[arrayIndex]\n    if (!pluralWord) return THOUSAND\n    return THOUSAND + ' ' + pluralWord\n  }\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Spanish words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @param {boolean} feminine - Use feminine forms\n * @returns {string} Spanish words\n */\nfunction integerToWords (n, feminine) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000\n  if (n < 1000n) {\n    return buildSegment(Number(n), feminine)\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    let result\n    if (thousands === 1) {\n      // \"mil\" not \"uno mil\"\n      result = THOUSAND\n    } else {\n      // Use masculine for thousands segment, but check for \"uno\" → omit before mil\n      const thousandsWord = buildSegment(thousands, false)\n      // \"uno mil\" → \"mil\" (handled in joinSegments equivalent)\n      if (thousandsWord === 'uno' || thousandsWord === 'una') {\n        result = THOUSAND\n      } else {\n        result = thousandsWord + ' ' + THOUSAND\n      }\n    }\n\n    if (remainder > 0) {\n      result += ' ' + buildSegment(remainder, feminine)\n    }\n\n    return result\n  }\n\n  // For numbers >= 1,000,000, use scale decomposition\n  return buildLargeNumberWords(n, feminine)\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 * @param {boolean} feminine - Use feminine forms\n * @returns {string} Spanish words\n */\nfunction buildLargeNumberWords (n, feminine) {\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    const scaleWord = i > 0 ? getScaleWord(i, segment) : ''\n\n    if (result) result += ' '\n\n    if (i === 0) {\n      // Units segment\n      result += buildSegment(Number(segment), feminine)\n    } else if (i === 1) {\n      // Thousands: omit \"uno\" before mil\n      if (segment === 1n) {\n        result += THOUSAND\n      } else {\n        result += buildSegment(Number(segment), false) + ' ' + scaleWord\n      }\n    } else if (i % 2 === 1) {\n      // Odd scale indices (3, 5, 7): \"mil millones\", \"mil billones\", etc.\n      // Omit \"uno\" before these compound scales\n      if (segment === 1n) {\n        result += scaleWord\n      } else {\n        result += buildSegment(Number(segment), false) + ' ' + scaleWord\n      }\n    } else {\n      // Even scale indices (2, 4, 6): millón, billón, trillón\n      if (segment === 1n) {\n        // \"un millón\" not \"uno millón\"\n        result += 'un ' + scaleWord\n      } else {\n        // Use masculine for scale segment\n        result += buildSegment(Number(segment), false) + ' ' + scaleWord\n      }\n    }\n  }\n\n  return result\n}\n\n/**\n * Converts decimal digits to Spanish words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @param {boolean} feminine - Use feminine forms\n * @returns {string} Spanish words for decimal part\n */\nfunction decimalPartToWords (decimalPart, feminine) {\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), feminine)\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Spanish 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 * @param {Object} [options] - Optional configuration\n * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender\n * @returns {string} The number in Spanish 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)                        // 'veintiuno'\n * toWords(21, {gender: 'feminine'})  // 'veintiuna'\n * toWords(1000000)                   // 'un millón'\n */\nfunction toWords (value, options) {\n  options = validateOptions(options)\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n  const feminine = options.gender === 'feminine'\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart, feminine)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart, feminine)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Public API\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","ONES_MASC","ONES_FEM","TEENS","TWENTIES_MASC","TWENTIES_FEM","TENS","HUNDREDS_MASC","HUNDREDS_FEM","SCALES","SCALES_PLURAL","THOUSAND","ZERO","buildSegment","n","feminine","ones","tens","Math","floor","hundreds","tensOnes","parts","push","join","getScaleWord","scaleIndex","segment","arrayIndex","baseWord","pluralWord","integerToWords","Number","thousands","remainder","result","thousandsWord","segmentValues","temp","i","scaleWord","buildLargeNumberWords","value","options","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","gender","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/fa.js

@@ -0,0 +1,3 @@
+/*! n2words/fa v3.1.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 r=e.slice(0,t)||"0",i=e.slice(t+1);return{isNegative:n,integerPart:BigInt(r),decimalPart:i}}function t(e){const[n,t]=e.toLowerCase().split("e"),r=parseInt(t,10),i=n.indexOf("."),s=-1===i?n:n.slice(0,i)+n.slice(i+1),u=(-1===i?n.length:i)+r;return u>=s.length?s+"0".repeat(u-s.length):u<=0?"0."+"0".repeat(-u)+s:s.slice(0,u)+"."+s.slice(u)}const r={1:"یک",2:"دو",3:"سه",4:"چهار",5:"پنج",6:"شش",7:"هفت",8:"هشت",9:"نه"},i={10:"ده",11:"یازده",12:"دوازده",13:"سیزده",14:"چهارده",15:"پانزده",16:"شانزده",17:"هفده",18:"هجده",19:"نوزده"},s={20:"بیست",30:"سی",40:"چهل",50:"پنجاه",60:"شصت",70:"هفتاد",80:"هشتاد",90:"نود"},u={100:"صد",200:"دویست",300:"سيصد",400:"چهار صد",500:"پانصد",600:"ششصد",700:"هفتصد",800:"هشتصد",900:"نهصد"};function o(e){if(0n===e)return"صفر";if(e<=9n)return r[Number(e)];if(e<=19n)return i[Number(e)];if(e<100n){const n=e%10n,t=e-n;return 0n===n?s[Number(t)]:`${s[Number(t)]} و ${r[Number(n)]}`}if(e<1000n){const n=e/100n*100n,t=e-n;return 0n===t?u[Number(n)]:`${u[Number(n)]} و ${o(t)}`}if(e<1000000n){const n=e/1000n,t=e%1000n;return`${1n===n?"":o(n)+" "}هزار${0n===t?"":" "+o(t)}`}const n=e%1000000n;return`${o(e/1000000n)+" میلیون"}${0n===n?"":" و "+o(n)}`}e.fa=function(e){const{isNegative:r,integerPart:i,decimalPart:s}=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)}:n(function(e){const n=e.toString();return n.includes("e")||n.includes("E")?t(n):n}(e))}if("string"===r)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 ${r}`)}(e);let u="";return r&&(u="منفى "),u+=o(i),s&&(u+=" ممیّز "+function(e){let n="",t=0;for(;t<e.length&&"0"===e[t];)n&&(n+=" "),n+="صفر",t++;const r=e.slice(t);return r&&(n&&(n+=" "),n+=o(BigInt(r))),n}(s)),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=fa.js.map

package/dist/languages/fa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fa.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/fa.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 * Persian language converter - Functional Implementation\n *\n * Self-contained converter using recursive decomposition.\n *\n * Key features:\n * - \"و\" (and) conjunction for compound numbers\n * - Omit \"یک\" (one) before thousand\n * - Pre-composed hundreds (دویست, سيصد, etc.)\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES = { 1: 'یک', 2: 'دو', 3: 'سه', 4: 'چهار', 5: 'پنج', 6: 'شش', 7: 'هفت', 8: 'هشت', 9: 'نه' }\nconst TEENS = { 10: 'ده', 11: 'یازده', 12: 'دوازده', 13: 'سیزده', 14: 'چهارده', 15: 'پانزده', 16: 'شانزده', 17: 'هفده', 18: 'هجده', 19: 'نوزده' }\nconst TENS = { 20: 'بیست', 30: 'سی', 40: 'چهل', 50: 'پنجاه', 60: 'شصت', 70: 'هفتاد', 80: 'هشتاد', 90: 'نود' }\nconst HUNDREDS = { 100: 'صد', 200: 'دویست', 300: 'سيصد', 400: 'چهار صد', 500: 'پانصد', 600: 'ششصد', 700: 'هفتصد', 800: 'هشتصد', 900: 'نهصد' }\n\nconst THOUSAND = 'هزار'\nconst MILLION = 'میلیون'\n\nconst ZERO = 'صفر'\nconst NEGATIVE = 'منفى'\nconst DECIMAL_SEP = 'ممیّز'\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // 1-9\n  if (n <= 9n) {\n    return ONES[Number(n)]\n  }\n\n  // 10-19\n  if (n <= 19n) {\n    return TEENS[Number(n)]\n  }\n\n  // 20-99\n  if (n < 100n) {\n    const ones = n % 10n\n    const tens = n - ones\n    if (ones === 0n) {\n      return TENS[Number(tens)]\n    }\n    return `${TENS[Number(tens)]} و ${ONES[Number(ones)]}`\n  }\n\n  // 100-999\n  if (n < 1000n) {\n    const hundreds = 100n * (n / 100n)\n    const remainder = n - hundreds\n    if (remainder === 0n) {\n      return HUNDREDS[Number(hundreds)]\n    }\n    return `${HUNDREDS[Number(hundreds)]} و ${integerToWords(remainder)}`\n  }\n\n  // 1000-999999\n  if (n < 1_000_000n) {\n    const thousandMultiplier = n / 1000n\n    // Persian omits \"one\" before thousand: 1000 is just \"هزار\", not \"یک هزار\"\n    const thousandPrefix = thousandMultiplier === 1n\n      ? ''\n      : integerToWords(thousandMultiplier) + ' '\n    const remainder = n % 1000n\n    const suffix = remainder === 0n ? '' : ' ' + integerToWords(remainder)\n    return `${thousandPrefix}${THOUSAND}${suffix}`\n  }\n\n  // 1000000+\n  const millionMultiplier = n / 1_000_000n\n  const millionPrefix = integerToWords(millionMultiplier) + ' ' + MILLION\n  const remainder = n % 1_000_000n\n  const suffix = remainder === 0n ? '' : ' و ' + integerToWords(remainder)\n  return `${millionPrefix}${suffix}`\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 Persian words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Persian 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","HUNDREDS","integerToWords","n","Number","ones","tens","hundreds","remainder","thousandMultiplier","value","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","i","decimalPartToWords"],"mappings":"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"}

package/dist/languages/fi.js

@@ -0,0 +1,3 @@
+/*! n2words/fi v3.1.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=["","yksi","kaksi","kolme","neljä","viisi","kuusi","seitsemän","kahdeksan","yhdeksän"],r=["kymmenen","yksitoista","kaksitoista","kolmetoista","neljätoista","viisitoista","kuusitoista","seitsemäntoista","kahdeksantoista","yhdeksäntoista"],s=["","","kaksikymmentä","kolmekymmentä","neljäkymmentä","viisikymmentä","kuusikymmentä","seitsemänkymmentä","kahdeksankymmentä","yhdeksänkymmentä"],o="sata",u="tuhat",a="nolla",l=["miljoona","miljardi","biljoona","triljoona"];function c(e){if(0===e)return"";const t=e%10,n=Math.floor(e/10)%10,u=Math.floor(e/100),a=[];u>0&&a.push(1===u?o:i[u]+" "+o);const l=e%100;return 0===l||a.push(l<10?i[t]:l<20?r[t]:0===t?s[n]:s[n]+i[t]),a.join(" ")}e.fi=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 f="";return r&&(f="miinus "),f+=function(e){if(0n===e)return a;if(e<1000n)return c(Number(e));if(e<1000000n){const t=Number(e/1000n),n=Number(e%1000n);let i;return i=1===t?u:c(t)+" "+u,n>0&&(i+=" "+c(n)),i}return 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 o=[];let a=i.length-1;for(let e=0;e<i.length;e++){const t=i[e];if(0!==t){const e=c(t);o.push(0===a?e:1===a?1===t?u:e+" "+u:e+" "+l[a-2])}a--}return o.join(" ")}(e)}(s),o&&(f+=" pilkku "+function(e){const t=[];for(const n of e){const e=parseInt(n,10);t.push(0===e?a:i[e])}return t.join(" ")}(o)),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=fi.js.map

package/dist/languages/fi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fi.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/fi.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 * Finnish language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Compound tens+ones without spaces: \"kaksikymmentäyksi\" (21)\n * - Teens with \"-toista\" suffix\n * - Omit \"yksi\" before sata/tuhat but keep before miljoona+\n * - Long scale: miljoona, miljardi, biljoona\n * - Per-digit decimal reading\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\nconst ONES = ['', 'yksi', 'kaksi', 'kolme', 'neljä', 'viisi', 'kuusi', 'seitsemän', 'kahdeksan', 'yhdeksän']\n\nconst TEENS = ['kymmenen', 'yksitoista', 'kaksitoista', 'kolmetoista', 'neljätoista', 'viisitoista', 'kuusitoista', 'seitsemäntoista', 'kahdeksantoista', 'yhdeksäntoista']\n\n// Tens use \"kymmentä\" suffix\nconst TENS = ['', '', 'kaksikymmentä', 'kolmekymmentä', 'neljäkymmentä', 'viisikymmentä', 'kuusikymmentä', 'seitsemänkymmentä', 'kahdeksankymmentä', 'yhdeksänkymmentä']\n\nconst HUNDRED = 'sata'\nconst THOUSAND = 'tuhat'\n\nconst ZERO = 'nolla'\nconst NEGATIVE = 'miinus'\nconst DECIMAL_SEP = 'pilkku'\n\n// Long scale\nconst SCALES = ['miljoona', 'miljardi', 'biljoona', 'triljoona']\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for 0-999.\n * Omits \"yksi\" before \"sata\" (hundred).\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 - omit \"yksi\" before sata\n  if (hundreds > 0) {\n    if (hundreds === 1) {\n      parts.push(HUNDRED)\n    } else {\n      parts.push(ONES[hundreds] + ' ' + HUNDRED)\n    }\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    parts.push(ONES[ones])\n  } else if (tensOnes < 20) {\n    parts.push(TEENS[ones])\n  } else if (ones === 0) {\n    parts.push(TENS[tens])\n  } else {\n    // Compound: \"kaksikymmentäyksi\" (no space)\n    parts.push(TENS[tens] + ONES[ones])\n  }\n\n  return parts.join(' ')\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Finnish words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Finnish 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 buildSegment(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    // Omit \"yksi\" before tuhat\n    let result\n    if (thousands === 1) {\n      result = THOUSAND\n    } else {\n      result = buildSegment(thousands) + ' ' + THOUSAND\n    }\n\n    if (remainder > 0) {\n      result += ' ' + buildSegment(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} Finnish 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\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 = buildSegment(segment)\n\n      if (scaleIndex === 0) {\n        // Units segment\n        parts.push(segmentWord)\n      } else if (scaleIndex === 1) {\n        // Thousands - omit \"yksi\" before tuhat\n        if (segment === 1) {\n          parts.push(THOUSAND)\n        } else {\n          parts.push(segmentWord + ' ' + THOUSAND)\n        }\n      } else {\n        // Millions+ - keep \"yksi\" before scale words\n        const scaleWord = SCALES[scaleIndex - 2]\n        parts.push(segmentWord + ' ' + scaleWord)\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts decimal digits to Finnish words (per-digit).\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Finnish words for decimal part\n */\nfunction decimalPartToWords (decimalPart) {\n  const parts = []\n\n  for (const digit of decimalPart) {\n    const d = parseInt(digit, 10)\n    if (d === 0) {\n      parts.push(ZERO)\n    } else {\n      parts.push(ONES[d])\n    }\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts a numeric value to Finnish words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Finnish 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)       // 'kaksikymmentäyksi'\n * toWords(1000)     // 'tuhat'\n * toWords('3.14')   // 'kolme pilkku yksi neljä'\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","TEENS","TENS","HUNDRED","THOUSAND","ZERO","SCALES","buildSegment","n","ones","tens","Math","floor","hundreds","parts","push","tensOnes","join","value","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","thousands","remainder","numStr","len","segments","remainderLen","pos","scaleIndex","i","segment","segmentWord","buildLargeNumberWords","integerToWords","digit","d","decimalPartToWords"],"mappings":"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"}

package/dist/languages/fil.js

@@ -0,0 +1,3 @@
+/*! n2words/fil v3.1.0 | MIT License | github.com/forzagreen/n2words */
+var n,t;n=this,t=function(n){"use strict";function t(n){const t="-"===n[0];t&&(n=n.slice(1));const e=n.indexOf(".");if(-1===e)return{isNegative:t,integerPart:BigInt(n)};const i=n.slice(0,e)||"0",r=n.slice(e+1);return{isNegative:t,integerPart:BigInt(i),decimalPart:r}}function e(n){const[t,e]=n.toLowerCase().split("e"),i=parseInt(e,10),r=t.indexOf("."),a=-1===r?t:t.slice(0,r)+t.slice(r+1),o=(-1===r?t.length:r)+i;return o>=a.length?a+"0".repeat(o-a.length):o<=0?"0."+"0".repeat(-o)+a:a.slice(0,o)+"."+a.slice(o)}const i=["","isa","dalawa","tatlo","apat","lima","anim","pito","walo","siyam"],r=["sampu","labinisa","labindalawa","labintatlo","labinapat","labinlima","labinanum","labimpito","labingwalo","labinsiyam"],a=["","","dalawampu","tatlumpu","apatnapu","limampu","animnapu","pitumpu","walumpu","siyamnapu"],o="zero",s=["","libong","milyong","bilyong","trilyong"],u=["a","e","i","o","u"];function l(n){return u.includes(n[n.length-1])?n+"ng":n+" na"}function c(n){if(0===n)return"";const t=n%10,e=Math.floor(n/10)%10,o=Math.floor(n/100),s=[];if(o>0){const n=l(i[o]);s.push(n+" daang")}const u=n%100;return 0===u||s.push(u<10?i[t]:u<20?r[t]:0===t?a[e]:5===e?a[e]+"ng "+i[t]:a[e]+" "+i[t]),s.join(" ")}function f(n){const t=c(n);if(!t)return"";const e=t.lastIndexOf(" ");if(-1===e)return"g"===t[t.length-1]&&t.endsWith("ng")?t:l(t);const i=t.slice(0,e+1),r=t.slice(e+1);return r.endsWith("ng")?t:i+l(r)}n.fil=function(n){const{isNegative:r,integerPart:a,decimalPart:u}=function(n){const i=typeof n;if("bigint"===i)return n<0n?{isNegative:!0,integerPart:-n}:{isNegative:!1,integerPart:n};if("number"===i){if(!Number.isFinite(n))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(n)?n<0?{isNegative:!0,integerPart:BigInt(-n)}:{isNegative:!1,integerPart:BigInt(n)}:t(function(n){const t=n.toString();return t.includes("e")||t.includes("E")?e(t):t}(n))}if("string"===i)return t(function(n){const t=n.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${n}"`);return t.includes("e")||t.includes("E")?e(t):t}(n));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(n);let l="";return r&&(l="negatibo "),l+=0n===(g=a)?o:g<1000n?c(Number(g)):function(n){const t=[];let e=n;for(;e>0n;)t.push(Number(e%1000n)),e/=1000n;let i="";for(let n=t.length-1;n>=0;n--){const e=t[n];if(0===e)continue;const r=s[n]||"";i&&(i+=" "),i+=0===n?c(e):f(e)+" "+r}return i}(g),u&&(l+=" punto "+function(n){const t=[];for(const e of n){const n=parseInt(e,10);t.push(0===n?o:i[n])}return t.join(" ")}(u)),l;var g}},"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((n="undefined"!=typeof globalThis?globalThis:n||self).n2words=n.n2words||{});
+//# sourceMappingURL=fil.js.map