n2words 3.1.0 → 5.0.0

package/dist/languages/he.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"he.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/he.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 * Modern Hebrew language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Feminine grammatical forms (default in Modern Hebrew)\n * - Dual forms for 2, 200, 2000\n * - Special 1-9 thousands construct state\n * - \"ו\" (ve) conjunction rules vary by position\n * - Per-digit decimal reading\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\nimport { validateOptions } from '../utils/validate-options.js'\n\n// ============================================================================\n// Vocabulary (arrays for indexed access - faster than object property lookup)\n// ============================================================================\n\n// Feminine forms (default in Modern Hebrew) - index 0 unused\nconst ONES = ['', 'אחת', 'שתים', 'שלש', 'ארבע', 'חמש', 'שש', 'שבע', 'שמונה', 'תשע']\nconst TEENS = ['עשר', 'אחת עשרה', 'שתים עשרה', 'שלש עשרה', 'ארבע עשרה', 'חמש עשרה', 'שש עשרה', 'שבע עשרה', 'שמונה עשרה', 'תשע עשרה']\nconst TENS = ['', '', 'עשרים', 'שלשים', 'ארבעים', 'חמישים', 'ששים', 'שבעים', 'שמונים', 'תשעים']\nconst HUNDREDS = ['', 'מאה', 'מאתיים', 'שלש מאות', 'ארבע מאות', 'חמש מאות', 'שש מאות', 'שבע מאות', 'שמונה מאות', 'תשע מאות']\n\n// Special forms for 1-9 thousand (index 0 unused)\nconst THOUSANDS_SPECIAL = ['', 'אלף', 'אלפיים', 'שלשת אלפים', 'ארבעת אלפים', 'חמשת אלפים', 'ששת אלפים', 'שבעת אלפים', 'שמונת אלפים', 'תשעת אלפים']\n\n// Scale words (index 1 = thousands, 2 = millions, etc.)\nconst SCALE = ['', 'אלף', 'מיליון', 'מיליארד', 'טריליון', 'קוודרליון', 'קווינטיליון']\nconst SCALE_PLURAL = ['', 'אלפים', 'מיליונים', 'מיליארדים', 'טריליונים', 'קוודרליונים', 'קווינטיליונים']\n\nconst ZERO = 'אפס'\nconst NEGATIVE = 'מינוס'\nconst DECIMAL_SEP = 'נקודה'\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for scale segments (thousands, millions, etc.).\n * \"ו\" is added before tens and ones when following hundreds.\n */\nfunction buildScaleSegment (n, andWord) {\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  let result = ''\n\n  // Hundreds\n  if (hundreds > 0) {\n    result = HUNDREDS[hundreds]\n  }\n\n  // Tens and ones\n  if (tens === 1) {\n    // Teens (10-19)\n    const teenWord = TEENS[ones]\n    if (result) {\n      result += ' ' + andWord + teenWord\n    } else {\n      result = teenWord\n    }\n  } else {\n    // Tens (20-90)\n    if (tens >= 2) {\n      if (result) {\n        result += ' ' + andWord + TENS[tens]\n      } else {\n        result = TENS[tens]\n      }\n    }\n\n    // Ones\n    if (ones > 0) {\n      if (result) {\n        result += ' ' + andWord + ONES[ones]\n      } else {\n        result = ONES[ones]\n      }\n    }\n  }\n\n  return result\n}\n\n/**\n * Builds segment word for units segment (no scale word).\n * \"ו\" is only added before the final ones digit.\n */\nfunction buildUnitsSegment (n, andWord) {\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  let result = ''\n\n  // Hundreds\n  if (hundreds > 0) {\n    result = HUNDREDS[hundreds]\n  }\n\n  // Tens (no conjunction)\n  if (tens === 1) {\n    // Teens (10-19)\n    if (result) {\n      result += ' ' + TEENS[ones]\n    } else {\n      result = TEENS[ones]\n    }\n  } else {\n    if (tens >= 2) {\n      if (result) {\n        result += ' ' + TENS[tens]\n      } else {\n        result = TENS[tens]\n      }\n    }\n\n    // Ones - conjunction only here\n    if (ones > 0) {\n      if (result) {\n        result += ' ' + andWord + ONES[ones]\n      } else {\n        result = ONES[ones]\n      }\n    }\n  }\n\n  return result\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Hebrew words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @param {Object} options - Conversion options\n * @returns {string} Hebrew words\n */\nfunction integerToWords (n, options) {\n  if (n === 0n) return ZERO\n\n  const andWord = options.andWord ?? 'ו'\n\n  // Fast path: numbers < 1000\n  if (n < 1000n) {\n    return buildUnitsSegment(Number(n), andWord)\n  }\n\n  // Extract segments using BigInt modulo\n  const segments = []\n  let temp = n\n  while (temp > 0n) {\n    segments.push(Number(temp % 1000n))\n    temp = temp / 1000n\n  }\n\n  // Build result string directly\n  let result = ''\n\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      // Units segment (no scale word)\n      const segmentWord = buildUnitsSegment(segment, andWord)\n      if (result) {\n        // Add \"ו\" before single-digit units when following scale words\n        if (segment <= 9) {\n          result += ' ' + andWord + segmentWord\n        } else {\n          result += ' ' + segmentWord\n        }\n      } else {\n        result = segmentWord\n      }\n    } else if (i === 1) {\n      // Thousands - special handling for 1-9\n      if (segment <= 9) {\n        if (result) result += ' '\n        result += THOUSANDS_SPECIAL[segment]\n      } else {\n        const segmentWord = buildScaleSegment(segment, andWord)\n        if (result) result += ' '\n        result += segmentWord + ' ' + SCALE[1]\n      }\n    } else {\n      // Millions and above\n      if (segment === 1) {\n        if (result) result += ' '\n        result += SCALE[i]\n      } else {\n        const segmentWord = buildScaleSegment(segment, andWord)\n        if (result) result += ' '\n        result += segmentWord + ' ' + SCALE_PLURAL[i]\n      }\n    }\n  }\n\n  return result\n}\n\n/**\n * Converts decimal digits to Hebrew words (digit by digit).\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Hebrew words for decimal part\n */\nfunction decimalPartToWords (decimalPart) {\n  let result = ''\n\n  for (let i = 0; i < decimalPart.length; i++) {\n    const d = parseInt(decimalPart[i], 10)\n    if (result) result += ' '\n    result += d === 0 ? ZERO : ONES[d]\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Modern Hebrew words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @param {Object} [options] - Optional configuration\n * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender\n * @param {string} [options.andWord] - Custom conjunction word\n * @returns {string} The number in Modern Hebrew words\n */\nfunction toWords (value, options) {\n  options = validateOptions(options)\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart, options)\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","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","TEENS","TENS","HUNDREDS","THOUSANDS_SPECIAL","SCALE","SCALE_PLURAL","buildScaleSegment","n","andWord","ones","tens","Math","floor","hundreds","result","teenWord","buildUnitsSegment","value","options","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","NEGATIVE","segments","temp","push","i","segment","segmentWord","integerToWords","d","decimalPartToWords"],"mappings":"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"}

package/dist/languages/hi.js

@@ -1,3 +0,0 @@
-/*! n2words/hi 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.hi=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=hi.js.map

package/dist/languages/hi.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hi.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/hi.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 * Hindi 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 * - Devanagari script\n * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)\n * - Complete word forms for 0-99\n * - BigInt modulo for efficient segment extraction\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 *\n * @param {number} n - Number 0-999\n * @returns {string} Hindi words for the 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 Hindi 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} Hindi 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  // 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 Hindi words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Hindi 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":";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,QAKPC,EAAgB,CACpB,QAAS,KAAM,KAAM,MAAO,MAAO,OAAQ,KAAM,MAAO,KAAM,KAC9D,KAAM,SAAU,OAAQ,OAAQ,OAAQ,SAAU,OAAQ,QAAS,QAAS,SAC5E,MAAO,SAAU,OAAQ,OAAQ,QAAS,SAAU,SAAU,UAAW,UAAW,QACpF,MAAO,QAAS,SAAU,SAAU,SAAU,SAAU,SAAU,SAAU,SAAU,UACtF,QAAS,UAAW,SAAU,UAAW,SAAU,WAAY,UAAW,WAAY,WAAY,QAClG,OAAQ,UAAW,OAAQ,QAAS,OAAQ,OAAQ,QAAS,UAAW,UAAW,OACnF,MAAO,OAAQ,OAAQ,QAAS,QAAS,QAAS,SAAU,QAAS,QAAS,UAC9E,QAAS,UAAW,SAAU,UAAW,UAAW,UAAW,UAAW,UAAW,UAAW,UAChG,QAAS,UAAW,QAAS,SAAU,SAAU,QAAS,SAAU,UAAW,UAAW,QAC1F,QAAS,WAAY,QAAS,UAAW,UAAW,SAAU,UAAW,WAAY,WAAY,aAI7FC,EAAc,CAAC,GAAI,QAAS,MAAO,QAAS,MAAO,MAAO,MAAO,OAAQ,OAY/E,SAASC,EAAcC,GACrB,GAAU,IAANA,EAAS,MAAO,GACpB,GAAIA,EAAI,IAAK,OAAOH,EAAcG,GAElC,MAAMC,EAAWC,KAAKC,MAAMH,EAAI,KAC1BI,EAAYJ,EAAI,IAEtB,OAAkB,IAAdI,EACKP,EAAcI,GAAdJ,MAEFA,EAAcI,GAAdJ,OAAgDA,EAAcO,EACvE,CAeA,SAASC,EAAgBL,GACvB,GAAU,KAANA,EAAU,OAAOJ,EAGrB,GAAII,EAAI,MACN,OAAOD,EAAaO,OAAON,IAM7B,MAAMO,EAAW,GAGjBA,EAASC,KAAKF,OAAON,EAAI,QACzB,IAAIS,EAAOT,EAAI,MAGf,KAAOS,EAAO,IACZF,EAASC,KAAKF,OAAOG,EAAO,OAC5BA,GAAc,KAIhB,MAAMC,EAAQ,GACd,IAAK,IAAIC,EAAIJ,EAASb,OAAS,EAAGiB,GAAK,EAAGA,IAAK,CAC7C,MAAMC,EAAUL,EAASI,GACT,IAAZC,IAIFF,EAAMF,KAFE,IAANG,EAESZ,EAAaa,GAGbf,EAAce,IAIvBD,EAAI,GAAKb,EAAYa,IACvBD,EAAMF,KAAKV,EAAYa,IAE3B,CAEA,OAAOD,EAAMG,KAAK,IACpB,MA2BA,SAAkBC,GAChB,MAAMrC,WAAEA,EAAUI,YAAEA,EAAWG,YAAEA,GDvI5B,SAA4B8B,GACjC,MAAMC,SAAcD,EAGpB,GAAa,WAATC,EACF,OAAOD,EAAQ,GACX,CAAErC,YAAY,EAAMI,aAAciC,GAClC,CAAErC,YAAY,EAAOI,YAAaiC,GAIxC,GAAa,WAATC,EAAmB,CACrB,IAAKT,OAAOU,SAASF,GACnB,MAAM,IAAIG,MAAM,8DAElB,OAAIX,OAAOY,cAAcJ,GAChBA,EAAQ,EACX,CAAErC,YAAY,EAAMI,YAAaC,QAAQgC,IACzC,CAAErC,YAAY,EAAOI,YAAaC,OAAOgC,IAExCvC,EAgBX,SAAyBuC,GACvB,MAAMtC,EAAMsC,EAAMK,WAClB,OAAQ3C,EAAI4C,SAAS,MAAQ5C,EAAI4C,SAAS,KACtCnC,EAAyBT,GACzBA,CACN,CArB8B6C,CAAeP,GAC3C,CAGA,GAAa,WAATC,EACF,OAAOxC,EAqBX,SAA0BuC,GACxB,MAAMQ,EAAUR,EAAMS,OACtB,GAAuB,IAAnBD,EAAQ5B,QAAgBY,OAAOkB,MAAMlB,OAAOgB,IAC9C,MAAM,IAAIL,MAAM,2BAA2BH,MAE7C,OAAQQ,EAAQF,SAAS,MAAQE,EAAQF,SAAS,KAC9CnC,EAAyBqC,GACzBA,CACN,CA7B8BG,CAAgBX,IAG5C,MAAM,IAAIY,UACR,oEAAoEX,IAExE,CCwGmDY,CAAkBb,GAEnE,IAAIc,EAAS,GAYb,OAVInD,IACFmD,EAASC,UAGXD,GAAUvB,EAAexB,GAErBG,IACF4C,GAAU,UArCd,SAA6B5C,GAC3B,IAAI4C,EAAS,GACTjB,EAAI,EAER,KAAOA,EAAI3B,EAAYU,QAA6B,MAAnBV,EAAY2B,IACvCiB,IAAQA,GAAU,KACtBA,GAAUhC,EACVe,IAGF,MAAMP,EAAYpB,EAAYN,MAAMiC,GAMpC,OALIP,IACEwB,IAAQA,GAAU,KACtBA,GAAUvB,EAAevB,OAAOsB,KAG3BwB,CACT,CAoBwCE,CAAmB9C,IAGlD4C,CACT"}

package/dist/languages/hr.js

@@ -1,3 +0,0 @@
-/*! n2words/hr 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 i=e.indexOf(".");if(-1===i)return{isNegative:t,integerPart:BigInt(e)};const n=e.slice(0,i)||"0",r=e.slice(i+1);return{isNegative:t,integerPart:BigInt(n),decimalPart:r}}function i(e){const[t,i]=e.toLowerCase().split("e"),n=parseInt(i,10),r=t.indexOf("."),s=-1===r?t:t.slice(0,r)+t.slice(r+1),o=(-1===r?t.length:r)+n;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 n=["","jedan","dva","tri","četiri","pet","šest","sedam","osam","devet"],r=["","jedna","dvije","tri","četiri","pet","šest","sedam","osam","devet"],s=["deset","jedanaest","dvanaest","trinaest","četrnaest","petnaest","šesnaest","sedamnaest","osamnaest","devetnaest"],o=["","","dvadeset","trideset","četrdeset","pedeset","šezdeset","sedamdeset","osamdeset","devedeset"],a=["","sto","dvjesto","tristo","četiristo","petsto","šesto","sedamsto","osamsto","devetsto"],u="nula",d=[["tisuća","tisuće","tisuća"],["milijun","milijuna","milijuna"],["milijarda","milijarde","milijarda"],["bilijun","bilijuna","bilijuna"],["bilijarda","bilijarde","bilijarda"],["trilijun","trilijuna","trilijuna"],["trilijarda","trilijarde","trilijarda"],["kvadrilijun","kvadrilijuna","kvadrilijuna"],["kvadrilijarda","kvadrilijarde","kvadrilijarda"]];function l(e,t){const i="bigint"==typeof e?Number(e):e,n=i%10,r=i%100;return r>=11&&r<=19?t[2]:1===n?t[0]:n>=2&&n<=4?t[1]:t[2]}function f(e){if(0===e)return"";const t=e%10,i=Math.floor(e/10)%10,r=Math.floor(e/100),u=[];return r>0&&u.push(a[r]),i>1&&u.push(o[i]),1===i?u.push(s[t]):t>0&&u.push(n[t]),u.join(" ")}function c(e){if(0===e)return"";const t=e%10,i=Math.floor(e/10)%10,n=Math.floor(e/100),u=[];return n>0&&u.push(a[n]),i>1&&u.push(o[i]),1===i?u.push(s[t]):t>0&&u.push(r[t]),u.join(" ")}function p(e,t={}){return 0n===e?u:e<1000n?"feminine"===t.gender?c(Number(e)):f(Number(e)):function(e,t){const i=e.toString(),n=i.length,r=[],s=n%3;let o=0;for(s>0&&(r.push(Number(i.slice(0,s))),o=s);o<n;)r.push(Number(i.slice(o,o+3))),o+=3;const a=[];let u=r.length-1;for(let e=0;e<r.length;e++){const i=r[e];if(0!==i)if(0===u)a.push("feminine"===t.gender?c(i):f(i));else{const e=l(i,d[u-1]),t=1===u?c(i):f(i);a.push(t+" "+e)}u--}return a.join(" ")}(e,t)}e.hr=function(e,n){n=function(e){if(void 0===e)return{};if(function(e){if(null===e||"object"!=typeof e)return!1;const t=Object.getPrototypeOf(e);return null===t||t===Object.prototype}(e))return e;throw new TypeError("Invalid options: expected plain object or undefined, got "+typeof e)}(n);const{isNegative:r,integerPart:s,decimalPart:o}=function(e){const n=typeof e;if("bigint"===n)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===n){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")?i(t):t}(e))}if("string"===n)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")?i(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${n}`)}(e);let a="";return r&&(a="minus "),a+=p(s,n),o&&(a+=" zarez "+function(e,t){let i="",n=0;for(;n<e.length&&"0"===e[n];)i&&(i+=" "),i+=u,n++;const r=e.slice(n);return r&&(i&&(i+=" "),i+=p(BigInt(r),t)),i}(o,n)),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=hr.js.map

package/dist/languages/hr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hr.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/hr.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 * Croatian language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Three-form pluralization (one/few/many)\n * - Gender: thousands are feminine, millions+ are masculine\n * - Irregular hundreds (dvjesto, tristo, etc.)\n * - Long scale naming with -ard forms\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\nimport { validateOptions } from '../utils/validate-options.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES_MASC = ['', 'jedan', 'dva', 'tri', 'četiri', 'pet', 'šest', 'sedam', 'osam', 'devet']\nconst ONES_FEM = ['', 'jedna', 'dvije', 'tri', 'četiri', 'pet', 'šest', 'sedam', 'osam', 'devet']\n\nconst TEENS = ['deset', 'jedanaest', 'dvanaest', 'trinaest', 'četrnaest', 'petnaest', 'šesnaest', 'sedamnaest', 'osamnaest', 'devetnaest']\nconst TENS = ['', '', 'dvadeset', 'trideset', 'četrdeset', 'pedeset', 'šezdeset', 'sedamdeset', 'osamdeset', 'devedeset']\n\n// Croatian has irregular hundreds\nconst HUNDREDS = ['', 'sto', 'dvjesto', 'tristo', 'četiristo', 'petsto', 'šesto', 'sedamsto', 'osamsto', 'devetsto']\n\nconst ZERO = 'nula'\nconst NEGATIVE = 'minus'\nconst DECIMAL_SEP = 'zarez'\n\n// Scale words: [singular, few, many]\n// Thousands (index 0) are feminine, rest are masculine\nconst SCALE_FORMS = [\n  ['tisuća', 'tisuće', 'tisuća'],\n  ['milijun', 'milijuna', 'milijuna'],\n  ['milijarda', 'milijarde', 'milijarda'],\n  ['bilijun', 'bilijuna', 'bilijuna'],\n  ['bilijarda', 'bilijarde', 'bilijarda'],\n  ['trilijun', 'trilijuna', 'trilijuna'],\n  ['trilijarda', 'trilijarde', 'trilijarda'],\n  ['kvadrilijun', 'kvadrilijuna', 'kvadrilijuna'],\n  ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda']\n]\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\nfunction pluralize (n, forms) {\n  const num = typeof n === 'bigint' ? Number(n) : n\n  const lastDigit = num % 10\n  const lastTwoDigits = num % 100\n\n  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {\n    return forms[2]\n  }\n\n  if (lastDigit === 1) return forms[0]\n  if (lastDigit >= 2 && lastDigit <= 4) return forms[1]\n  return forms[2]\n}\n\nfunction buildSegmentMasc (n) {\n  if (n === 0) return ''\n\n  const onesDigit = 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    parts.push(HUNDREDS[hundredsDigit])\n  }\n\n  if (tensDigit > 1) {\n    parts.push(TENS[tensDigit])\n  }\n\n  if (tensDigit === 1) {\n    parts.push(TEENS[onesDigit])\n  } else if (onesDigit > 0) {\n    parts.push(ONES_MASC[onesDigit])\n  }\n\n  return parts.join(' ')\n}\n\nfunction buildSegmentFem (n) {\n  if (n === 0) return ''\n\n  const onesDigit = 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    parts.push(HUNDREDS[hundredsDigit])\n  }\n\n  if (tensDigit > 1) {\n    parts.push(TENS[tensDigit])\n  }\n\n  if (tensDigit === 1) {\n    parts.push(TEENS[onesDigit])\n  } else if (onesDigit > 0) {\n    parts.push(ONES_FEM[onesDigit])\n  }\n\n  return parts.join(' ')\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n, options = {}) {\n  if (n === 0n) return ZERO\n\n  if (n < 1000n) {\n    return options.gender === 'feminine' ? buildSegmentFem(Number(n)) : buildSegmentMasc(Number(n))\n  }\n\n  return buildLargeNumberWords(n, options)\n}\n\nfunction buildLargeNumberWords (n, options) {\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      if (scaleIndex === 0) {\n        parts.push(options.gender === 'feminine' ? buildSegmentFem(segment) : buildSegmentMasc(segment))\n      } else {\n        const scaleForms = SCALE_FORMS[scaleIndex - 1]\n        const scaleWord = pluralize(segment, scaleForms)\n        // Thousands (scaleIndex=1) are feminine, others masculine\n        const isFeminine = scaleIndex === 1\n        const segmentWord = isFeminine ? buildSegmentFem(segment) : buildSegmentMasc(segment)\n        parts.push(segmentWord + ' ' + scaleWord)\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\nfunction decimalPartToWords (decimalPart, options) {\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), options)\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Croatian words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @param {Object} [options] - Optional configuration\n * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender\n * @returns {string} The number in Croatian words\n */\nfunction toWords (value, options) {\n  options = validateOptions(options)\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart, options)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart, options)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Exports\n// ============================================================================\n\nexport { toWords }\n","import { isPlainObject } from './is-plain-object.js'\n\n/**\n * Validates and normalizes the options parameter.\n *\n * @param {*} options The options value to validate\n * @returns {Object} A valid options object (empty object if undefined)\n * @throws {TypeError} If options is not undefined or a plain object\n */\nexport function validateOptions (options) {\n  if (options === undefined) return {}\n  if (isPlainObject(options)) return options\n  throw new TypeError(\n    `Invalid options: expected plain object or undefined, got ${typeof options}`\n  )\n}\n","/**\n * Checks if a value is a plain object (not null, array, or other object types).\n *\n * A plain object is one created by:\n * - Object literal: `{}`\n * - Object.create(null): null-prototype object\n *\n * This excludes arrays, class instances, Map, Set, and other object types.\n *\n * @param {*} value Value to check\n * @returns {boolean} True if value is a plain object\n */\nexport function isPlainObject (value) {\n  if (value === null || typeof value !== 'object') return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === null || proto === Object.prototype\n}\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES_MASC","ONES_FEM","TEENS","TENS","HUNDREDS","ZERO","SCALE_FORMS","pluralize","n","forms","num","Number","lastDigit","lastTwoDigits","buildSegmentMasc","onesDigit","tensDigit","Math","floor","hundredsDigit","parts","push","join","buildSegmentFem","integerToWords","options","gender","numStr","toString","len","segments","remainderLen","pos","scaleIndex","i","segment","scaleWord","segmentWord","buildLargeNumberWords","value","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","result","NEGATIVE","remainder","decimalPartToWords"],"mappings":"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"}

package/dist/languages/hu.js

@@ -1,3 +0,0 @@
-/*! n2words/hu v3.1.0 | MIT License | github.com/forzagreen/n2words */
-var n,e;n=this,e=function(n){"use strict";function e(n){const e="-"===n[0];e&&(n=n.slice(1));const t=n.indexOf(".");if(-1===t)return{isNegative:e,integerPart:BigInt(n)};const i=n.slice(0,t)||"0",r=n.slice(t+1);return{isNegative:e,integerPart:BigInt(i),decimalPart:r}}function t(n){const[e,t]=n.toLowerCase().split("e"),i=parseInt(t,10),r=e.indexOf("."),o=-1===r?e:e.slice(0,r)+e.slice(r+1),s=(-1===r?e.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=new Map([[1000000000000000000000000000n,"quadrilliárd"],[1000000000000000000000000n,"quadrillió"],[1000000000000000000000n,"trilliárd"],[1000000000000000000n,"trillió"],[1000000000000000n,"billiárd"],[1000000000000n,"billió"],[1000000000n,"milliárd"],[1000000n,"millió"],[1000n,"ezer"],[100n,"száz"],[90n,"kilencven"],[80n,"nyolcvan"],[70n,"hetven"],[60n,"hatvan"],[50n,"ötven"],[40n,"negyven"],[30n,"harminc"],[29n,"huszonkilenc"],[28n,"huszonnyolc"],[27n,"huszonhét"],[26n,"huszonhat"],[25n,"huszonöt"],[24n,"huszonnégy"],[23n,"huszonhárom"],[22n,"huszonkettő"],[21n,"huszonegy"],[20n,"húsz"],[19n,"tizenkilenc"],[18n,"tizennyolc"],[17n,"tizenhét"],[16n,"tizenhat"],[15n,"tizenöt"],[14n,"tizennégy"],[13n,"tizenhárom"],[12n,"tizenkettő"],[11n,"tizenegy"],[10n,"tíz"],[9n,"kilenc"],[8n,"nyolc"],[7n,"hét"],[6n,"hat"],[5n,"öt"],[4n,"négy"],[3n,"három"],[2n,"kettő"],[1n,"egy"],[0n,"nulla"]]),r="nulla";function o(n){return i.get(n)}const s=[1000000000000000000000000000n,1000000000000000000000000n,1000000000000000000000n,1000000000000000000n,1000000000000000n,1000000000000n,1000000000n,1000000n];function u(n,e=r){return"bigint"!=typeof n&&(n=BigInt(n)),0n===n?e:""===e&&2n===n?"két":n<30n?o(n):n<100n?function(n){if(i.has(n))return i.get(n);const e=n%10n;return o(n/10n*10n)+u(e)}(n):n<1000n?function(n){const e=n/100n;let t="száz";return 1n!==e&&(t=u(e,"")+t),t+u(n%100n,"")}(n):n<1000000n?function(n){const e=n/1000n;let t="ezer";1n!==e&&(t=u(e,"")+t);const i=u(n%1000n,"");return t+(n<=2000n||""===i?"":"-")+i}(n):function(n){let e=1000000n;for(const t of s)if(n>=t){e=t;break}const t=u(n/e,""),i=u(n%e,""),r=""===i?"":"-"+i;return t+o(e)+r}(n)}function l(n){return u(n,r)}n.hu=function(n){const{isNegative:i,integerPart:o,decimalPart:s}=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)}:e(function(n){const e=n.toString();return e.includes("e")||e.includes("E")?t(e):e}(n))}if("string"===i)return e(function(n){const e=n.trim();if(0===e.length||Number.isNaN(Number(e)))throw new Error(`Invalid number format: "${n}"`);return e.includes("e")||e.includes("E")?t(e):e}(n));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(n);let u="";return i&&(u="mínusz "),u+=l(o),s&&(u+=" egész "+function(n){let e="",t=0;for(;t<n.length&&"0"===n[t];)e&&(e+=" "),e+=r,t++;const i=n.slice(t);return i&&(e&&(e+=" "),e+=l(BigInt(i))),e}(s)),u}},"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((n="undefined"!=typeof globalThis?globalThis:n||self).n2words=n.n2words||{});
-//# sourceMappingURL=hu.js.map

package/dist/languages/hu.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hu.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/hu.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 * Hungarian language converter - Functional Implementation\n *\n * Self-contained converter with agglutinative word formation.\n *\n * Key features:\n * - Agglutinative structure (no spaces between compound parts)\n * - Special handling for \"egy\" (one) omission\n * - Pre-composed twenties (huszonegy through huszonkilenc)\n * - \"két\" instead of \"kettő\" in compound forms\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\n// Word map using BigInt keys for scale values\nconst WORDS = new Map([\n  [1_000_000_000_000_000_000_000_000_000n, 'quadrilliárd'],\n  [1_000_000_000_000_000_000_000_000n, 'quadrillió'],\n  [1_000_000_000_000_000_000_000n, 'trilliárd'],\n  [1_000_000_000_000_000_000n, 'trillió'],\n  [1_000_000_000_000_000n, 'billiárd'],\n  [1_000_000_000_000n, 'billió'],\n  [1_000_000_000n, 'milliárd'],\n  [1_000_000n, 'millió'],\n  [1000n, 'ezer'],\n  [100n, 'száz'],\n  [90n, 'kilencven'],\n  [80n, 'nyolcvan'],\n  [70n, 'hetven'],\n  [60n, 'hatvan'],\n  [50n, 'ötven'],\n  [40n, 'negyven'],\n  [30n, 'harminc'],\n  [29n, 'huszonkilenc'],\n  [28n, 'huszonnyolc'],\n  [27n, 'huszonhét'],\n  [26n, 'huszonhat'],\n  [25n, 'huszonöt'],\n  [24n, 'huszonnégy'],\n  [23n, 'huszonhárom'],\n  [22n, 'huszonkettő'],\n  [21n, 'huszonegy'],\n  [20n, 'húsz'],\n  [19n, 'tizenkilenc'],\n  [18n, 'tizennyolc'],\n  [17n, 'tizenhét'],\n  [16n, 'tizenhat'],\n  [15n, 'tizenöt'],\n  [14n, 'tizennégy'],\n  [13n, 'tizenhárom'],\n  [12n, 'tizenkettő'],\n  [11n, 'tizenegy'],\n  [10n, 'tíz'],\n  [9n, 'kilenc'],\n  [8n, 'nyolc'],\n  [7n, 'hét'],\n  [6n, 'hat'],\n  [5n, 'öt'],\n  [4n, 'négy'],\n  [3n, 'három'],\n  [2n, 'kettő'],\n  [1n, 'egy'],\n  [0n, 'nulla']\n])\n\nconst ZERO = 'nulla'\nconst NEGATIVE = 'mínusz'\nconst DECIMAL_SEP = 'egész'\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction wordForScale (value) {\n  return WORDS.get(value)\n}\n\nfunction tensToCardinal (n) {\n  if (WORDS.has(n)) {\n    return WORDS.get(n)\n  }\n  const tens = n / 10n\n  const units = n % 10n\n  return wordForScale(tens * 10n) + integerToWordsInner(units)\n}\n\nfunction hundredsToCardinal (n) {\n  const hundreds = n / 100n\n  let prefix = 'száz'\n  if (hundreds !== 1n) {\n    prefix = integerToWordsInner(hundreds, '') + prefix\n  }\n  const postfix = integerToWordsInner(n % 100n, '')\n  return prefix + postfix\n}\n\nfunction thousandsToCardinal (n) {\n  const thousands = n / 1000n\n  let prefix = 'ezer'\n  if (thousands !== 1n) {\n    prefix = integerToWordsInner(thousands, '') + prefix\n  }\n  const postfix = integerToWordsInner(n % 1000n, '')\n  const middle = (n <= 2000n || postfix === '') ? '' : '-'\n  return prefix + middle + postfix\n}\n\n// Scale values for finding appropriate scale (avoids toString)\nconst SCALES = [\n  1_000_000_000_000_000_000_000_000_000n,\n  1_000_000_000_000_000_000_000_000n,\n  1_000_000_000_000_000_000_000n,\n  1_000_000_000_000_000_000n,\n  1_000_000_000_000_000n,\n  1_000_000_000_000n,\n  1_000_000_000n,\n  1_000_000n\n]\n\nfunction bigNumberToCardinal (n) {\n  // Find appropriate scale using BigInt comparison (avoids toString)\n  let exp = 1_000_000n\n  for (const scale of SCALES) {\n    if (n >= scale) {\n      exp = scale\n      break\n    }\n  }\n\n  const prefix = integerToWordsInner(n / exp, '')\n  const rest = integerToWordsInner(n % exp, '')\n  const postfix = (rest === '') ? '' : ('-' + rest)\n  return prefix + wordForScale(exp) + postfix\n}\n\nfunction integerToWordsInner (n, zeroWord = ZERO) {\n  // Normalize to BigInt for consistent comparisons\n  if (typeof n !== 'bigint') n = BigInt(n)\n\n  if (n === 0n) {\n    return zeroWord\n  }\n  if (zeroWord === '' && n === 2n) {\n    return 'két'\n  }\n  if (n < 30n) {\n    return wordForScale(n)\n  }\n  if (n < 100n) {\n    return tensToCardinal(n)\n  }\n  if (n < 1000n) {\n    return hundredsToCardinal(n)\n  }\n  if (n < 1_000_000n) {\n    return thousandsToCardinal(n)\n  }\n  return bigNumberToCardinal(n)\n}\n\nfunction integerToWords (n) {\n  return integerToWordsInner(n, ZERO)\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 Hungarian words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Hungarian 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","WORDS","Map","ZERO","wordForScale","value","get","SCALES","integerToWordsInner","n","zeroWord","has","units","tensToCardinal","hundreds","prefix","hundredsToCardinal","thousands","postfix","thousandsToCardinal","scale","rest","bigNumberToCardinal","integerToWords","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","i","remainder","decimalPartToWords"],"mappings":"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"}

package/dist/languages/id.js

@@ -1,3 +0,0 @@
-/*! n2words/id 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("."),u=-1===r?n:n.slice(0,r)+n.slice(r+1),s=(-1===r?n.length:r)+i;return s>=u.length?u+"0".repeat(s-u.length):s<=0?"0."+"0".repeat(-s)+u:u.slice(0,s)+"."+u.slice(s)}const i=["","satu","dua","tiga","empat","lima","enam","tujuh","delapan","sembilan"],r=["sepuluh","sebelas","dua belas","tiga belas","empat belas","lima belas","enam belas","tujuh belas","delapan belas","sembilan belas"],u=["","","dua puluh","tiga puluh","empat puluh","lima puluh","enam puluh","tujuh puluh","delapan puluh","sembilan puluh"],s="ratus",l="ribu",a=["juta","miliar","triliun","kuadriliun","kuantiliun","sekstiliun","septiliun","oktiliun","noniliun","desiliun"];function o(e){if(0===e)return"";const n=e%10,t=Math.floor(e/10)%10,l=Math.floor(e/100),a=[];l>0&&a.push(1===l?"se"+s:i[l]+" "+s);const o=e%100;return 0===o||a.push(o<10?i[o]:o<20?r[o-10]:0===n?u[t]:u[t]+" "+i[n]),a.join(" ")}function c(e){if(0n===e)return"nol";if(e<1000n)return o(Number(e));if(e<1000000n){const n=Number(e/1000n),t=Number(e%1000n);let i;return i=1===n?"se"+l:o(n)+" "+l,t>0&&(i+=" "+o(t)),i}return function(e){const n=e.toString(),t=n.length,i=[],r=t%3;let u=0;for(r>0&&(i.push(Number(n.slice(0,r))),u=r);u<t;)i.push(Number(n.slice(u,u+3))),u+=3;const s=[];let c=i.length-1;for(let e=0;e<i.length;e++){const n=i[e];if(0!==n)if(0===c)s.push(o(n));else if(1===c)s.push(1===n?"se"+l:o(n)+" "+l);else{const e=a[c-2];s.push(o(n)+" "+e)}c--}return s.join(" ")}(e)}e.id=function(e){const{isNegative:i,integerPart:r,decimalPart:u}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}: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="min "),s+=c(r),u&&(s+=" koma "+function(e){let n="",t=0;for(;t<e.length&&"0"===e[t];)n&&(n+=" "),n+="nol",t++;const i=e.slice(t);return i&&(n&&(n+=" "),n+=c(BigInt(i))),n}(u)),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=id.js.map

package/dist/languages/id.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"id.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/id.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 * Indonesian language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - \"Se-\" prefix for 100 (seratus) and 1000 (seribu)\n * - Regular patterns (puluh for tens, ratus for hundreds)\n * - Teens with \"belas\" suffix\n * - Indonesian uses \"satu juta\" (not \"sejuta\") for millions+\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES = ['', 'satu', 'dua', 'tiga', 'empat', 'lima', 'enam', 'tujuh', 'delapan', 'sembilan']\nconst TEENS = ['sepuluh', 'sebelas', 'dua belas', 'tiga belas', 'empat belas', 'lima belas', 'enam belas', 'tujuh belas', 'delapan belas', 'sembilan belas']\nconst TENS = ['', '', 'dua puluh', 'tiga puluh', 'empat puluh', 'lima puluh', 'enam puluh', 'tujuh puluh', 'delapan puluh', 'sembilan puluh']\n\nconst HUNDRED_WORD = 'ratus'\nconst THOUSAND_WORD = 'ribu'\nconst SCALE_WORDS = ['juta', 'miliar', 'triliun', 'kuadriliun', 'kuantiliun', 'sekstiliun', 'septiliun', 'oktiliun', 'noniliun', 'desiliun']\n\nconst ZERO = 'nol'\nconst NEGATIVE = 'min'\nconst DECIMAL_SEP = 'koma'\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const onesDigit = n % 10\n  const tensDigit = Math.floor(n / 10) % 10\n  const hundredsDigit = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds: seratus (100) or N ratus (200-900)\n  if (hundredsDigit > 0) {\n    if (hundredsDigit === 1) {\n      parts.push('se' + HUNDRED_WORD)\n    } else {\n      parts.push(ONES[hundredsDigit] + ' ' + HUNDRED_WORD)\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[tensOnes])\n  } else if (tensOnes < 20) {\n    parts.push(TEENS[tensOnes - 10])\n  } else if (onesDigit === 0) {\n    parts.push(TENS[tensDigit])\n  } else {\n    parts.push(TENS[tensDigit] + ' ' + ONES[onesDigit])\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  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      result = 'se' + THOUSAND_WORD\n    } else {\n      result = buildSegment(thousands) + ' ' + THOUSAND_WORD\n    }\n\n    if (remainder > 0) {\n      result += ' ' + buildSegment(remainder)\n    }\n\n    return result\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      if (scaleIndex === 0) {\n        parts.push(buildSegment(segment))\n      } else if (scaleIndex === 1) {\n        if (segment === 1) {\n          parts.push('se' + THOUSAND_WORD)\n        } else {\n          parts.push(buildSegment(segment) + ' ' + THOUSAND_WORD)\n        }\n      } else {\n        // Indonesian: \"satu juta\" not \"sejuta\"\n        const scaleWord = SCALE_WORDS[scaleIndex - 2]\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\n  let i = 0\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 Indonesian words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Indonesian 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","HUNDRED_WORD","THOUSAND_WORD","SCALE_WORDS","buildSegment","n","onesDigit","tensDigit","Math","floor","hundredsDigit","parts","push","tensOnes","join","integerToWords","Number","thousands","remainder","result","numStr","toString","len","segments","remainderLen","pos","scaleIndex","i","segment","scaleWord","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/it.js

@@ -1,3 +0,0 @@
-/*! n2words/it 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("."),o=-1===r?e:e.slice(0,r)+e.slice(r+1),u=(-1===r?e.length:r)+i;return u>=o.length?o+"0".repeat(u-o.length):u<=0?"0."+"0".repeat(-u)+o:o.slice(0,u)+"."+o.slice(u)}const i=["","uno","due","tre","quattro","cinque","sei","sette","otto","nove"],r=["dieci","undici","dodici","tredici","quattordici","quindici","sedici","diciassette","diciotto","diciannove"],o=["","","venti","trenta","quaranta","cinquanta","sessanta","settanta","ottanta","novanta"],u=["","cento","duecento","trecento","quattrocento","cinquecento","seicento","settecento","ottocento","novecento"],s=["","","vent","trent","quarant","cinquant","sessant","settant","ottant","novant"],c="zero",a=["m","b","tr","quadr","quint","sest","sett","ott","nov","dec"];function f(t){if(0===t)return"";const e=t%10,n=Math.floor(t/10)%10,c=Math.floor(t/100);let a="";return c>0&&(a=8===n||0===n&&8===e?u[c].slice(0,-1):u[c]),0===n&&0===e||(1===n?a+=r[e]:n>=2?a+=1===e||8===e?s[n]+i[e]:3===e?o[n]+"tré":e>0?o[n]+i[e]:o[n]:e>0&&(a+=3===e&&c>0?"tré":i[e])),a}function l(t){return 0===t?"":1===t?"un":f(t)}function d(t){return 0===t?"":1===t?"mille":f(t)+"mila"}function g(t){if(t<2)return"";const e=Math.floor((t-2)/2),n=a[e];return n?n+((t-2)%2==1?"iliardo":"ilione"):""}function m(t){if(t<2)return"";const e=Math.floor((t-2)/2),n=a[e];return n?n+((t-2)%2==1?"iliardi":"ilioni"):""}function v(t){if(0n===t)return c;if(t<1000n)return f(Number(t));if(t<1000000n){const e=Number(t/1000n),n=Number(t%1000n);return 0===n?d(e):d(e)+f(n)}return function(t){const e=[];let n=t,i=2,r=1000000n;for(;1000n*r<=n;)r*=1000n,i++;for(let t=i;t>=0;t--){const i=1000n**BigInt(t),r=n/i;if(n%=i,0n===r)continue;const o=Number(r);if(t>=2){const n=l(o),i=1n===r?g(t):m(t);e.push(n+" "+i)}else e.push(1===t?d(o):f(o))}return function(t){const e=t.length;if(0===e)return"";if(1===e)return t[0];const n=t[e-1];if(-1===n.indexOf(" ")){let i=t[0];for(let n=1;n<e-1;n++)i+=" "+t[n];return i+" e "+n}let i=t[0];for(let n=1;n<e;n++)i+=" "+t[n];return i}(e)}(t)}t.it=function(t){const{isNegative:i,integerPart:r,decimalPart:o}=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 u="";return i&&(u="meno "),u+=v(r),o&&(u+=" virgola "+function(t){let e="",n=0;for(;n<t.length&&"0"===t[n];)e&&(e+=" "),e+=c,n++;const i=t.slice(n);return i&&(e&&(e+=" "),e+=v(BigInt(i))),e}(o)),u}},"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=it.js.map

package/dist/languages/it.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"it.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/it.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 * Italian language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Italian-specific rules:\n * - Concatenation without spaces within segments (\"ventotto\" not \"venti otto\")\n * - Phonetic vowel elision: \"venti\" + \"otto\" → \"ventotto\"\n * - Accent on final \"tre\" in compounds: \"ventitré\"\n * - mille/mila alternation for thousands\n * - Scale words: milione/milioni, miliardo/miliardi, etc.\n * - \"e\" connector before simple final remainder\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\n// Base vocabulary\nconst ONES = ['', 'uno', 'due', 'tre', 'quattro', 'cinque', 'sei', 'sette', 'otto', 'nove']\nconst TEENS = ['dieci', 'undici', 'dodici', 'tredici', 'quattordici', 'quindici', 'sedici', 'diciassette', 'diciotto', 'diciannove']\nconst TENS = ['', '', 'venti', 'trenta', 'quaranta', 'cinquanta', 'sessanta', 'settanta', 'ottanta', 'novanta']\nconst HUNDREDS = ['', 'cento', 'duecento', 'trecento', 'quattrocento', 'cinquecento', 'seicento', 'settecento', 'ottocento', 'novecento']\n\n// Pre-elided tens stems (drop final vowel before 'uno'/'otto')\n// vent- (from venti), trent- (from trenta), etc.\nconst TENS_STEM = ['', '', 'vent', 'trent', 'quarant', 'cinquant', 'sessant', 'settant', 'ottant', 'novant']\n\nconst ZERO = 'zero'\nconst NEGATIVE = 'meno'\nconst DECIMAL_SEP = 'virgola'\n\n// Thousands\nconst THOUSAND_SINGULAR = 'mille'\nconst THOUSAND_PLURAL_SUFFIX = 'mila'\n\n// Scale word generation\nconst SCALE_PREFIXES = ['m', 'b', 'tr', 'quadr', 'quint', 'sest', 'sett', 'ott', 'nov', 'dec']\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds the segment word for a number 0-999.\n * Handles Italian phonetic elision inline (no regex).\n *\n * Elision rules:\n * - Tens ending in vowel + uno/otto → drop tens vowel: ventuno, ventotto\n * - Hundreds cento + otto/ottanta → centotto, centottanta (drop 'o')\n * - Final 'tre' in compounds becomes 'tré': ventitré, trentatré\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  let result = ''\n\n  // Hundreds\n  if (hundreds > 0) {\n    // Elision: *cento + otto/ottanta → *centotto/centottanta (drop final 'o')\n    // Only applies when tens = 8 (ottanta) or tens = 0 and ones = 8 (otto)\n    if (tens === 8 || (tens === 0 && ones === 8)) {\n      // Remove final 'o' from hundreds: cento→cent, duecento→duecent, etc.\n      result = HUNDREDS[hundreds].slice(0, -1)\n    } else {\n      result = HUNDREDS[hundreds]\n    }\n  }\n\n  // Tens and ones\n  if (tens === 0 && ones === 0) {\n    // Nothing more (just hundreds)\n  } else if (tens === 1) {\n    // Teens: 10-19\n    result += TEENS[ones]\n  } else if (tens >= 2) {\n    // 20-99: handle elision for uno (1) and otto (8)\n    if (ones === 1 || ones === 8) {\n      // Use stem form: vent + uno = ventuno, vent + otto = ventotto\n      result += TENS_STEM[tens] + ONES[ones]\n    } else if (ones === 3) {\n      // Final tre becomes tré\n      result += TENS[tens] + 'tré'\n    } else if (ones > 0) {\n      result += TENS[tens] + ONES[ones]\n    } else {\n      result += TENS[tens]\n    }\n  } else if (ones > 0) {\n    // 1-9 (tens === 0)\n    if (ones === 3 && hundreds > 0) {\n      // centotré, duecentotré, etc.\n      result += 'tré'\n    } else {\n      result += ONES[ones]\n    }\n  }\n\n  return result\n}\n\n/**\n * Builds segment word with \"un\" for scale context (millions, billions).\n * Same as buildSegment but returns \"un\" for 1 instead of \"uno\".\n */\nfunction buildSegmentForScale (n) {\n  if (n === 0) return ''\n  if (n === 1) return 'un' // \"un milione\" not \"uno milione\"\n  return buildSegment(n)\n}\n\n/**\n * Builds thousands word for 1-999 thousand.\n * Handles elision: tre + mila = tremila (no accent), otto + mila = ottomila\n */\nfunction buildThousands (n) {\n  if (n === 0) return ''\n  if (n === 1) return THOUSAND_SINGULAR // \"mille\"\n\n  // Build segment and append \"mila\"\n  // Note: elision of segment ending vowel + 'mila' not needed (mila starts with 'm')\n  // But we need to handle cases like \"ottomila\" (no double-o issue since we build directly)\n  return buildSegment(n) + THOUSAND_PLURAL_SUFFIX\n}\n\n// ============================================================================\n// Scale Word Functions\n// ============================================================================\n\n/**\n * Gets singular scale word for index.\n * @param {number} scaleIndex - 2=million, 3=billion, etc.\n */\nfunction getScaleWordSingular (scaleIndex) {\n  if (scaleIndex < 2) return ''\n  const prefixIndex = Math.floor((scaleIndex - 2) / 2)\n  const isIardo = (scaleIndex - 2) % 2 === 1\n  const prefix = SCALE_PREFIXES[prefixIndex]\n  if (!prefix) return ''\n  return prefix + (isIardo ? 'iliardo' : 'ilione')\n}\n\n/**\n * Gets plural scale word for index.\n * @param {number} scaleIndex - 2=million, 3=billion, etc.\n */\nfunction getScaleWordPlural (scaleIndex) {\n  if (scaleIndex < 2) return ''\n  const prefixIndex = Math.floor((scaleIndex - 2) / 2)\n  const isIardo = (scaleIndex - 2) % 2 === 1\n  const prefix = SCALE_PREFIXES[prefixIndex]\n  if (!prefix) return ''\n  return prefix + (isIardo ? 'iliardi' : 'ilioni')\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Italian words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Italian 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 = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    if (remainder === 0) {\n      return buildThousands(thousands)\n    }\n\n    // Concatenate thousands + remainder\n    return buildThousands(thousands) + buildSegment(remainder)\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} Italian words\n */\nfunction buildLargeNumberWords (n) {\n  const parts = []\n  let remaining = n\n\n  // Find the highest scale\n  let maxScale = 2\n  let testValue = 1_000_000n\n  while (testValue * 1000n <= remaining) {\n    testValue *= 1000n\n    maxScale++\n  }\n\n  // Process from highest scale down\n  for (let scaleIndex = maxScale; scaleIndex >= 0; scaleIndex--) {\n    const divisor = 1000n ** BigInt(scaleIndex)\n    const segment = remaining / divisor\n    remaining = remaining % divisor\n\n    if (segment === 0n) continue\n\n    const segNum = Number(segment)\n\n    if (scaleIndex >= 2) {\n      // Millions and above: \"segment scaleWord\"\n      const segmentWords = buildSegmentForScale(segNum)\n      const scaleWord = segment === 1n\n        ? getScaleWordSingular(scaleIndex)\n        : getScaleWordPlural(scaleIndex)\n      parts.push(segmentWords + ' ' + scaleWord)\n    } else if (scaleIndex === 1) {\n      // Thousands\n      parts.push(buildThousands(segNum))\n    } else {\n      // Units (scaleIndex === 0): just the segment\n      parts.push(buildSegment(segNum))\n    }\n  }\n\n  return joinPartsWithConnector(parts)\n}\n\n/**\n * Joins parts with Italian connector rules.\n * Uses \"e\" before simple (non-compound) final segment.\n *\n * @param {string[]} parts - Parts to join\n * @returns {string} Joined string\n */\nfunction joinPartsWithConnector (parts) {\n  const len = parts.length\n  if (len === 0) return ''\n  if (len === 1) return parts[0]\n\n  // Check if last part is \"simple\" (no space = no scale word)\n  const lastPart = parts[len - 1]\n  if (lastPart.indexOf(' ') === -1) {\n    // Join all but last with space, then add \"e\" connector\n    let result = parts[0]\n    for (let i = 1; i < len - 1; i++) {\n      result += ' ' + parts[i]\n    }\n    return result + ' e ' + lastPart\n  }\n\n  // Join with spaces\n  let result = parts[0]\n  for (let i = 1; i < len; i++) {\n    result += ' ' + parts[i]\n  }\n  return result\n}\n\n/**\n * Converts decimal digits to Italian words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Italian 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 Italian 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 Italian 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(28)           // 'ventotto'\n * toWords(23)           // 'ventitré'\n * toWords(1000)         // 'mille'\n * toWords(2000)         // 'duemila'\n * toWords(1000000)      // 'un milione'\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","TENS_STEM","ZERO","SCALE_PREFIXES","buildSegment","n","ones","tens","Math","floor","hundreds","result","buildSegmentForScale","buildThousands","getScaleWordSingular","scaleIndex","prefixIndex","prefix","getScaleWordPlural","integerToWords","Number","thousands","remainder","parts","remaining","maxScale","testValue","divisor","segment","segNum","segmentWords","scaleWord","push","len","lastPart","i","joinPartsWithConnector","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/ja.js

@@ -1,3 +0,0 @@
-/*! n2words/ja 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("."),o=-1===i?t:t.slice(0,i)+t.slice(i+1),s=(-1===i?t.length:i)+r;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const r=["","一","二","三","四","五","六","七","八","九"],i=["万","億","兆","京","垓","秭","穣","溝","澗","正","載","極","恒河沙","阿僧祇","那由他","不可思議","無量大数"];function o(e){if(0===e)return"";const t=e%10,n=Math.floor(e/10)%10,i=Math.floor(e/100)%10,o=Math.floor(e/1e3);let s="";return o>0&&(s+=1===o?"千":r[o]+"千"),i>0&&(s+=1===i?"百":r[i]+"百"),n>0&&(s+=1===n?"十":r[n]+"十"),t>0&&(s+=r[t]),s}e.ja=function(e){const{isNegative:s,integerPart:u,decimalPart:f}=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 s&&(c="マイナス"),c+=function(e){if(0n===e)return"零";if(e<10000n)return o(Number(e));if(e<100000000n){const t=Number(e/10000n),n=Number(e%10000n);let r;return r=1===t?"一"+i[0]:o(t)+i[0],n>0&&(r+=o(n)),r}return function(e){const t=[];let n=e;for(;n>0n;)t.push(Number(n%10000n)),n/=10000n;let r="";for(let e=t.length-1;e>=0;e--){const n=t[e];0!==n&&(r+=e>0?1===n?"一"+i[e-1]:o(n)+i[e-1]:o(n))}return r||"零"}(e)}(u),f&&(c+="点"+function(e){let t="";for(let n=0;n<e.length;n++){const i=parseInt(e[n],10);t+=0===i?"零":r[i]}return t}(f)),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=ja.js.map

package/dist/languages/ja.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ja.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/ja.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 * Japanese language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Japanese-specific rules:\n * - Myriad (万-based) grouping: 4 digits per segment instead of 3\n * - 一 omission: Omit \"一\" before 十, 百, 千 but NOT before 万 and higher scales\n * - Kanji numerals: 零一二三四五六七八九\n * - No spaces between characters\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 = ['', '一', '二', '三', '四', '五', '六', '七', '八', '九']\n\n// Scale words for powers of 10,000 (万-based system)\n// Index 0 = 万 (10^4), 1 = 億 (10^8), 2 = 兆 (10^12), etc.\nconst SCALES = [\n  '万', // 10^4 (man)\n  '億', // 10^8 (oku)\n  '兆', // 10^12 (chō)\n  '京', // 10^16 (kei)\n  '垓', // 10^20 (gai)\n  '秭', // 10^24 (jo/shi)\n  '穣', // 10^28 (jō)\n  '溝', // 10^32 (kō)\n  '澗', // 10^36 (kan)\n  '正', // 10^40 (sei)\n  '載', // 10^44 (sai)\n  '極', // 10^48 (goku)\n  '恒河沙', // 10^52 (gōgasha)\n  '阿僧祇', // 10^56 (asōgi)\n  '那由他', // 10^60 (nayuta)\n  '不可思議', // 10^64 (fukashigi)\n  '無量大数' // 10^68 (muryōtaisū)\n]\n\nconst ZERO = '零'\nconst NEGATIVE = 'マイナス'\nconst DECIMAL_SEP = '点'\n\n// Internal scale words (within 4-digit segments)\nconst TEN = '十'\nconst HUNDRED = '百'\nconst THOUSAND = '千'\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for 0-9999 with 一 omission rules.\n * - Omit 一 before 十, 百, 千\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) % 10\n  const thousands = Math.floor(n / 1000)\n\n  let result = ''\n\n  // Thousands (千) - omit 一 when 1\n  if (thousands > 0) {\n    if (thousands === 1) {\n      result += THOUSAND\n    } else {\n      result += ONES[thousands] + THOUSAND\n    }\n  }\n\n  // Hundreds (百) - omit 一 when 1\n  if (hundreds > 0) {\n    if (hundreds === 1) {\n      result += HUNDRED\n    } else {\n      result += ONES[hundreds] + HUNDRED\n    }\n  }\n\n  // Tens (十) - omit 一 when 1\n  if (tens > 0) {\n    if (tens === 1) {\n      result += TEN\n    } else {\n      result += ONES[tens] + TEN\n    }\n  }\n\n  // Ones\n  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 Japanese words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Japanese kanji words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 10000\n  if (n < 10000n) {\n    return buildSegment(Number(n))\n  }\n\n  // Fast path: numbers < 100,000,000 (万 range)\n  if (n < 100_000_000n) {\n    const man = Number(n / 10000n)\n    const remainder = Number(n % 10000n)\n\n    // For 万 and above, we need 一 before the scale word when segment is 1\n    let result\n    if (man === 1) {\n      result = '一' + SCALES[0] // 一万\n    } else {\n      result = buildSegment(man) + SCALES[0]\n    }\n\n    if (remainder > 0) {\n      result += buildSegment(remainder)\n    }\n\n    return result\n  }\n\n  // For numbers >= 100,000,000, use scale decomposition\n  return buildLargeNumberWords(n)\n}\n\n/**\n * Builds words for numbers >= 100,000,000.\n * Uses BigInt modulo for 4-digit (myriad) segment extraction.\n *\n * @param {bigint} n - Number >= 100,000,000\n * @returns {string} Japanese kanji words\n */\nfunction buildLargeNumberWords (n) {\n  // Extract segments using BigInt modulo (faster than string slicing)\n  // Segments stored least-significant first (index 0 = units, 1 = 万, etc.)\n  const segments = []\n  let temp = n\n  while (temp > 0n) {\n    segments.push(Number(temp % 10000n))\n    temp = temp / 10000n\n  }\n\n  // Build result string directly (process from most-significant to least)\n  let result = ''\n\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      // For scales >= 万, we need 一 before scale word when segment is 1\n      if (segment === 1) {\n        result += '一' + SCALES[i - 1]\n      } else {\n        result += buildSegment(segment) + SCALES[i - 1]\n      }\n    } else {\n      // Units segment (no scale word)\n      result += buildSegment(segment)\n    }\n  }\n\n  return result || ZERO\n}\n\n/**\n * Converts decimal digits to Japanese words (digit by digit).\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Japanese kanji words for decimal part\n */\nfunction decimalPartToWords (decimalPart) {\n  let result = ''\n\n  for (let i = 0; i < decimalPart.length; i++) {\n    const digit = parseInt(decimalPart[i], 10)\n    if (digit === 0) {\n      result += ZERO\n    } else {\n      result += ONES[digit]\n    }\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Japanese 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 Japanese kanji 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)           // '四十二'\n * toWords(10000)        // '一万'\n * toWords(100000000)    // '一億'\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","SCALES","buildSegment","n","ones","tens","Math","floor","hundreds","thousands","result","value","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","man","remainder","segments","temp","push","i","segment","buildLargeNumberWords","integerToWords","digit","decimalPartToWords"],"mappings":"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"}

package/dist/languages/ka.js

@@ -1,3 +0,0 @@
-/*! n2words/ka 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=["ნული","ერთი","ორი","სამი","ოთხი","ხუთი","ექვსი","შვიდი","რვა","ცხრა"],r=["ათი","თერთმეტი","თორმეტი","ცამეტი","თოთხმეტი","თხუთმეტი","თექვსმეტი","ჩვიდმეტი","თვრამეტი","ცხრამეტი"],s=["","ოცი","ორმოცი","სამოცი","ოთხმოცი"],o=["","ოცდა","ორმოცდა","სამოცდა","ოთხმოცდა"],u=["","","ორ","სამ","ოთხ","ხუთ","ექვს","შვიდ","რვა","ცხრა"],l="ათასი",c="ათას",f=["","","მილიონი","მილიარდი","ტრილიონი","კვადრილიონი","კვინტილიონი","სექსტილიონი"],a="ნული";function g(e){if(e<10)return i[e];if(e<20)return r[e-10];const t=Math.floor(e/20),n=e%20;if(0===n)return s[t];const u=o[t];return n<10?u+i[n]:u+r[n-10]}function m(e){if(0===e)return{full:"",stem:""};if(e<100){const t=g(e),n=t.slice(-1),i="ი"===n||"ა"===n?t.slice(0,-1):t;return{full:t,stem:i}}const t=Math.floor(e/100),n=e%100;let i;if(i=1===t?n>0?"ას":"ასი":u[t]+(n>0?"ას":"ასი"),n>0){const e=g(n),t=i+" "+e,r=e.slice(-1);return{full:t,stem:i+" "+("ი"===r||"ა"===r?e.slice(0,-1):e)}}return{full:i,stem:i.slice(0,-1)}}function d(e){if(0n===e)return a;if(e<1000n){const{full:t}=m(Number(e));return t}if(e<1000000n){const t=Number(e/1000n),n=Number(e%1000n);let i;if(1===t)i=n>0?c:l;else{const{stem:e}=m(t);i=e+" "+(n>0?c:l)}if(n>0){const{full:e}=m(n);i+=" "+e}return 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 u=i.length-1;for(let e=0;e<i.length;e++){const t=i[e];if(0!==t)if(0===u){const{full:e}=m(t);o.push(e)}else if(1===u){const n=i.slice(e+1).some(e=>0!==e)?c:l;if(1===t)o.push(n);else{const{stem:e}=m(t);o.push(e+" "+n)}}else{const e=f[u]||f[f.length-1];if(1===t)o.push("ერთი "+e);else{const{full:n}=m(t);o.push(n+" "+e)}}u--}return o.join(" ")}(e)}e.ka=function(e){const{isNegative:i,integerPart:r,decimalPart:s}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===i)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(e);let o="";return i&&(o="მინუს "),o+=d(r),s&&(o+=" მთელი "+function(e){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+=a,n++;const i=e.slice(n);return i&&(t&&(t+=" "),t+=d(BigInt(i))),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=ka.js.map

package/dist/languages/ka.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ka.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/ka.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 * Georgian language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Georgian-specific rules:\n * - Vigesimal (base-20) system for 20-99\n * - 40 = ორმოცი (2×20), 60 = სამოცი (3×20), 80 = ოთხმოცი (4×20)\n * - 30/50/70/90 use \"და\" + \"ათი\": ოცდაათი (20+10), ორმოცდაათი (40+10)\n * - Compound numbers use \"და\" (da = \"and\") connector\n * - Hundreds: unit prefix + ას (ორასი = 200)\n * - Short scale for large numbers (მილიონი, მილიარდი, ტრილიონი)\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\n// Numbers 0-9 (primitives)\nconst ONES = ['ნული', 'ერთი', 'ორი', 'სამი', 'ოთხი', 'ხუთი', 'ექვსი', 'შვიდი', 'რვა', 'ცხრა']\n\n// Numbers 10-19\nconst TEENS = ['ათი', 'თერთმეტი', 'თორმეტი', 'ცამეტი', 'თოთხმეტი', 'თხუთმეტი', 'თექვსმეტი', 'ჩვიდმეტი', 'თვრამეტი', 'ცხრამეტი']\n\n// Vigesimal bases: 20, 40, 60, 80 (with და connector forms)\nconst VIGESIMAL = ['', 'ოცი', 'ორმოცი', 'სამოცი', 'ოთხმოცი']\nconst VIGESIMAL_DA = ['', 'ოცდა', 'ორმოცდა', 'სამოცდა', 'ოთხმოცდა']\n\n// Prefixes for hundreds (unit forms without final vowel)\nconst HUNDRED_PREFIXES = ['', '', 'ორ', 'სამ', 'ოთხ', 'ხუთ', 'ექვს', 'შვიდ', 'რვა', 'ცხრა']\n\nconst HUNDRED = 'ასი'\nconst HUNDRED_STEM = 'ას' // Without final vowel\nconst THOUSAND = 'ათასი'\nconst THOUSAND_STEM = 'ათას' // Without final vowel\n\n// Scale words (short scale) - indexed by segment position\nconst SCALES = ['', '', 'მილიონი', 'მილიარდი', 'ტრილიონი', 'კვადრილიონი', 'კვინტილიონი', 'სექსტილიონი']\n\nconst ZERO = 'ნული'\nconst NEGATIVE = 'მინუს'\nconst DECIMAL_SEP = 'მთელი'\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for 0-99 using vigesimal system.\n * @param {number} n - Number 0-99\n * @returns {string} Georgian word\n */\nfunction buildTens (n) {\n  if (n < 10) return ONES[n]\n  if (n < 20) return TEENS[n - 10]\n\n  const vigesimalGroup = Math.floor(n / 20)\n  const remainder = n % 20\n\n  if (remainder === 0) {\n    return VIGESIMAL[vigesimalGroup]\n  }\n\n  // Use და connector: ოცდა + remainder\n  const base = VIGESIMAL_DA[vigesimalGroup]\n  if (remainder < 10) {\n    return base + ONES[remainder]\n  }\n  return base + TEENS[remainder - 10]\n}\n\n/**\n * Builds segment word for 0-999.\n * Returns object with full form and stem form (without final vowel).\n * @param {number} n - Number 0-999\n * @returns {{full: string, stem: string}} Georgian words\n */\nfunction buildSegment (n) {\n  if (n === 0) return { full: '', stem: '' }\n  if (n < 100) {\n    const word = buildTens(n)\n    // Remove final vowel for stem\n    const lastChar = word.slice(-1)\n    const stem = (lastChar === 'ი' || lastChar === 'ა') ? word.slice(0, -1) : word\n    return { full: word, stem }\n  }\n\n  const hundreds = Math.floor(n / 100)\n  const remainder = n % 100\n\n  // Build hundreds: ასი (100), ორასი (200), etc.\n  let hundredWord\n  if (hundreds === 1) {\n    hundredWord = remainder > 0 ? HUNDRED_STEM : HUNDRED\n  } else {\n    hundredWord = HUNDRED_PREFIXES[hundreds] + (remainder > 0 ? HUNDRED_STEM : HUNDRED)\n  }\n\n  if (remainder > 0) {\n    const remainderWord = buildTens(remainder)\n    const full = hundredWord + ' ' + remainderWord\n    // Stem removes final vowel from remainder\n    const lastChar = remainderWord.slice(-1)\n    const remainderStem = (lastChar === 'ი' || lastChar === 'ა') ? remainderWord.slice(0, -1) : remainderWord\n    return { full, stem: hundredWord + ' ' + remainderStem }\n  }\n\n  // Hundreds only - stem removes final ი\n  return { full: hundredWord, stem: hundredWord.slice(0, -1) }\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Georgian words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Georgian words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000\n  if (n < 1000n) {\n    const { full } = buildSegment(Number(n))\n    return full\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      // \"ათასი\" not \"ერთი ათასი\"\n      result = remainder > 0 ? THOUSAND_STEM : THOUSAND\n    } else {\n      // Use stem form before ათასი\n      const { stem: thousandsPart } = buildSegment(thousands)\n      result = thousandsPart + ' ' + (remainder > 0 ? THOUSAND_STEM : THOUSAND)\n    }\n\n    if (remainder > 0) {\n      const { full: remainderWord } = buildSegment(remainder)\n      result += ' ' + 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 *\n * @param {bigint} n - Number >= 1,000,000\n * @returns {string} Georgian words\n */\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  // Build segments of 3 digits from left to right\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 (no scale)\n        const { full } = buildSegment(segment)\n        parts.push(full)\n      } else if (scaleIndex === 1) {\n        // Thousands - check if there's a remainder\n        const hasRemainder = segments.slice(i + 1).some(s => s !== 0)\n        const thousandWord = hasRemainder ? THOUSAND_STEM : THOUSAND\n\n        if (segment === 1) {\n          parts.push(thousandWord)\n        } else {\n          const { stem } = buildSegment(segment)\n          parts.push(stem + ' ' + thousandWord)\n        }\n      } else {\n        // Million and above\n        const scaleWord = SCALES[scaleIndex] || SCALES[SCALES.length - 1]\n        if (segment === 1) {\n          parts.push('ერთი ' + scaleWord)\n        } else {\n          const { full } = buildSegment(segment)\n          parts.push(full + ' ' + scaleWord)\n        }\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts decimal digits to Georgian words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Georgian 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 Georgian 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 Georgian 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(100)          // 'ასი'\n * toWords(1000)         // 'ათასი'\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","VIGESIMAL","VIGESIMAL_DA","HUNDRED_PREFIXES","THOUSAND","THOUSAND_STEM","SCALES","ZERO","buildTens","n","vigesimalGroup","Math","floor","remainder","base","buildSegment","full","stem","word","lastChar","hundreds","hundredWord","remainderWord","integerToWords","Number","thousands","result","thousandsPart","numStr","toString","len","segments","remainderLen","pos","push","parts","scaleIndex","i","segment","thousandWord","some","s","scaleWord","join","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/kn.js

@@ -1,3 +0,0 @@
-/*! n2words/kn 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),o=(-1===i?n.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=["","ಸಾವಿರ","ಲಕ್ಷ","ಕೋಟಿ","ಅಬ್ಜ","ಖರ್ವ","ನೀಲ","ಪದ್ಮ","ಶಂಖ"];function u(e){if(0===e)return"";if(e<100)return s[e];const n=Math.trunc(e/100),t=e%100;return 0===t?s[n]+" "+i:s[n]+" "+i+" "+s[t]}e.kn=function(e){const{isNegative:i,integerPart:c,decimalPart:f}=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 a="";return i&&(a="ಋಣಾತ್ಮಕ "),a+=function(e){if(0n===e)return r;if(e<1000n)return u(Number(e));const n=[];n.push(Number(e%1000n));let t=e/1000n;for(;t>0n;)n.push(Number(t%100n)),t/=100n;const i=[];for(let e=n.length-1;e>=0;e--){const t=n[e];0!==t&&(i.push(0===e?u(t):s[t]),e>0&&o[e]&&i.push(o[e]))}return i.join(" ")}(c),f&&(a+=" ದಶಮಾಂಶ "+function(e){const n=[];for(const t of e){const e=parseInt(t,10);n.push(0===e?r:s[e])}return n.join(" ")}(f)),a}},"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=kn.js.map

package/dist/languages/kn.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"kn.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/kn.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 * Kannada 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 * - Kannada script\n * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)\n * - Complete word forms for 0-99\n * - Per-digit decimal reading\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 Kannada 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} Kannada 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  const segments = []\n  segments.push(Number(n % 1000n))\n  let temp = n / 1000n\n\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      words.push(buildSegment(segment))\n    } else {\n      words.push(BELOW_HUNDRED[segment])\n    }\n\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  // Per-digit decimal reading\n  const digits = []\n  for (const char of decimalPart) {\n    const d = parseInt(char, 10)\n    digits.push(d === 0 ? ZERO : BELOW_HUNDRED[d])\n  }\n  return digits.join(' ')\n}\n\n/**\n * Converts a numeric value to Kannada words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Kannada 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","HUNDRED","BELOW_HUNDRED","SCALE_WORDS","buildSegment","n","hundreds","Math","trunc","remainder","value","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","segments","push","temp","words","i","segment","join","integerToWords","char","d","decimalPartToWords"],"mappings":"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"}

package/dist/languages/ko.js

@@ -1,3 +0,0 @@
-/*! n2words/ko 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=["","일","이","삼","사","오","육","칠","팔","구"],r=["만","억","조","경","해","자","양"];function s(e){if(0===e)return"";const t=e%10,n=Math.floor(e/10)%10,r=Math.floor(e/100)%10,s=Math.floor(e/1e3);let o="";return s>0&&(o+=1===s?"천":i[s]+"천"),r>0&&(o+=1===r?"백":i[r]+"백"),n>0&&(o+=1===n?"십":i[n]+"십"),t>0&&(o+=i[t]),o}function o(e){return 0n===e?"영":e<10000n?s(Number(e)):function(e){const t=e.toString(),n=t.length,i=[],o=n%4;let u=0;for(o>0&&(i.push(Number(t.slice(0,o))),u=o);u<n;)i.push(Number(t.slice(u,u+4))),u+=4;const c=[];let l=i.length-1;for(let e=0;e<i.length;e++){const t=i[e];if(0!==t)if(0===l)c.push({word:s(t),isScale:!1});else{const e=r[l-1];1===t||c.push({word:s(t),isScale:!1}),c.push({word:e,isScale:!0})}l--}return function(e){if(0===e.length)return"영";if(1===e.length)return e[0].word;const t=[];for(let n=0;n<e.length;n++){const i=e[n],r=n>0?e[n-1]:null;r&&r.isScale&&!i.isScale&&t.push(" "),t.push(i.word)}return t.join("")}(c)}(e)}e.ko=function(e){const{isNegative:i,integerPart:r,decimalPart:s}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===i)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(e),u=[];return i&&u.push("마이너스"),u.push(o(r)),s&&(u.push("점"),u.push(function(e){const t=[];let n=0;for(;n<e.length&&"0"===e[n];)t.push("영"),n++;const i=e.slice(n);return i&&t.push(o(BigInt(i))),t.join(" ")}(s))),u.join(" ")}},"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=ko.js.map

package/dist/languages/ko.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ko.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/ko.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 * Korean language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Myriad-based (만) grouping - 4 digits\n * - Implicit '일' (one) omission before scale words\n * - Space separation after 만+ scales\n * - Hangul numerals\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\nconst ONES = ['', '일', '이', '삼', '사', '오', '육', '칠', '팔', '구']\n\nconst TEN = '십'\nconst HUNDRED = '백'\nconst THOUSAND = '천'\n\nconst ZERO = '영'\nconst NEGATIVE = '마이너스'\nconst DECIMAL_SEP = '점'\n\n// Myriad scale words (powers of 10,000)\n// 만 (10^4), 억 (10^8), 조 (10^12), 경 (10^16), etc.\nconst SCALES = ['만', '억', '조', '경', '해', '자', '양']\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for 0-9999 (4-digit myriad segment).\n * Korean omits \"일\" before 십, 백, 천.\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) % 10\n  const thousands = Math.floor(n / 1000)\n\n  let result = ''\n\n  // Thousands\n  if (thousands > 0) {\n    if (thousands === 1) {\n      result += THOUSAND\n    } else {\n      result += ONES[thousands] + THOUSAND\n    }\n  }\n\n  // Hundreds\n  if (hundreds > 0) {\n    if (hundreds === 1) {\n      result += HUNDRED\n    } else {\n      result += ONES[hundreds] + HUNDRED\n    }\n  }\n\n  // Tens\n  if (tens > 0) {\n    if (tens === 1) {\n      result += TEN\n    } else {\n      result += ONES[tens] + TEN\n    }\n  }\n\n  // Ones\n  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 Korean words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Korean words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 10000\n  if (n < 10000n) {\n    return buildSegment(Number(n))\n  }\n\n  // For numbers >= 10000, use myriad decomposition\n  return buildLargeNumberWords(n)\n}\n\n/**\n * Builds words for numbers >= 10000.\n * Uses myriad (만) grouping - 4 digits per segment.\n *\n * @param {bigint} n - Number >= 10000\n * @returns {string} Korean words\n */\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  // Build segments of 4 digits from right to left\n  const segments = []\n  const segmentSize = 4\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({ word: buildSegment(segment), isScale: false })\n      } else {\n        // Segment with scale word\n        const scaleWord = SCALES[scaleIndex - 1]\n\n        // Korean omits segment when it's 1 before scale words\n        if (segment === 1) {\n          parts.push({ word: scaleWord, isScale: true })\n        } else {\n          parts.push({ word: buildSegment(segment), isScale: false })\n          parts.push({ word: scaleWord, isScale: true })\n        }\n      }\n    }\n\n    scaleIndex--\n  }\n\n  // Join with Korean spacing rules\n  return joinKoreanParts(parts)\n}\n\n/**\n * Joins parts with Korean spacing rules.\n * - Concatenate without spaces within segments\n * - Space after scale words before next number\n *\n * @param {Array} parts - Parts with isScale metadata\n * @returns {string} Joined string\n */\nfunction joinKoreanParts (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 prevPart = i > 0 ? parts[i - 1] : null\n\n    // Add space after scale words before next number\n    if (prevPart && prevPart.isScale && !part.isScale) {\n      result.push(' ')\n    }\n\n    result.push(part.word)\n  }\n\n  return result.join('')\n}\n\n/**\n * Converts decimal digits to Korean words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Korean words for decimal part (space-separated)\n */\nfunction decimalPartToWords (decimalPart) {\n  const parts = []\n\n  // Handle leading zeros\n  let i = 0\n  while (i < decimalPart.length && decimalPart[i] === '0') {\n    parts.push(ZERO)\n    i++\n  }\n\n  // Convert remainder as a single number\n  const remainder = decimalPart.slice(i)\n  if (remainder) {\n    parts.push(integerToWords(BigInt(remainder)))\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts a numeric value to Korean words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Korean 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(10000)      // '만'\n * toWords(1000000)    // '백만'\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  const parts = []\n\n  if (isNegative) {\n    parts.push(NEGATIVE)\n  }\n\n  parts.push(integerToWords(integerPart))\n\n  if (decimalPart) {\n    parts.push(DECIMAL_SEP)\n    parts.push(decimalPartToWords(decimalPart))\n  }\n\n  return parts.join(' ')\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","SCALES","buildSegment","n","ones","tens","Math","floor","hundreds","thousands","result","integerToWords","Number","numStr","toString","len","segments","remainderLen","pos","push","parts","scaleIndex","i","segment","word","isScale","scaleWord","part","prevPart","join","joinKoreanParts","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","remainder","decimalPartToWords"],"mappings":"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"}