n2words 3.0.0 → 4.0.0

package/dist/languages/ta.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ta.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/ta.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 * Tamil language converter - Functional Implementation\n *\n * Self-contained converter for South Asian numbering.\n *\n * Key features:\n * - Indian numbering system (ஆயிரம், லட்சம், கோடி)\n * - Tamil script\n * - 3-2-2 grouping pattern\n * - Complete word forms for 0-99\n * - Special hundred word transformations\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 = 'புள்ளி'\n\nconst BELOW_HUNDRED = [\n  'பூஜ்ஜியம்', 'ஒன்று', 'இரண்டு', 'மூன்று', 'நான்கு', 'ஐந்து', 'ஆறு', 'ஏழு', 'எட்டு', 'ஒன்பது',\n  'பத்து', 'பதினொன்று', 'பன்னிரண்டு', 'பதிமூன்று', 'பதினான்கு', 'பதினைந்து', 'பதினாறு', 'பதினேழு', 'பதினெட்டு', 'பத்தொன்பது',\n  'இருபது', 'இருபத்தொன்று', 'இருபத்திரண்டு', 'இருபத்திமூன்று', 'இருபத்திநான்கு', 'இருபத்தைந்து', 'இருபத்தாறு', 'இருபத்தேழு', 'இருபத்தெட்டு', 'இருபத்தொன்பது',\n  'முப்பது', 'முப்பத்தொன்று', 'முப்பத்திரண்டு', 'முப்பத்திமூன்று', 'முப்பத்திநான்கு', 'முப்பத்தைந்து', 'முப்பத்தாறு', 'முப்பத்தேழு', 'முப்பத்தெட்டு', 'முப்பத்தொன்பது',\n  'நாற்பது', 'நாற்பத்தொன்று', 'நாற்பத்திரண்டு', 'நாற்பத்திமூன்று', 'நாற்பத்திநான்கு', 'நாற்பத்தைந்து', 'நாற்பத்தாறு', 'நாற்பத்தேழு', 'நாற்பத்தெட்டு', 'நாற்பத்தொன்பது',\n  'ஐம்பது', 'ஐம்பத்தொன்று', 'ஐம்பத்திரண்டு', 'ஐம்பத்திமூன்று', 'ஐம்பத்திநான்கு', 'ஐம்பத்தைந்து', 'ஐம்பத்தாறு', 'ஐம்பத்தேழு', 'ஐம்பத்தெட்டு', 'ஐம்பத்தொன்பது',\n  'அறுபது', 'அறுபத்தொன்று', 'அறுபத்திரண்டு', 'அறுபத்திமூன்று', 'அறுபத்திநான்கு', 'அறுபத்தைந்து', 'அறுபத்தாறு', 'அறுபத்தேழு', 'அறுபத்தெட்டு', 'அறுபத்தொன்பது',\n  'எழுபது', 'எழுபத்தொன்று', 'எழுபத்திரண்டு', 'எழுபத்திமூன்று', 'எழுபத்திநான்கு', 'எழுபத்தைந்து', 'எழுபத்தாறு', 'எழுபத்தேழு', 'எழுபத்தெட்டு', 'எழுபத்தொன்பது',\n  'எண்பது', 'எண்பத்தொன்று', 'எண்பத்திரண்டு', 'எண்பத்திமூன்று', 'எண்பத்திநான்கு', 'எண்பத்தைந்து', 'எண்பத்தாறு', 'எண்பத்தேழு', 'எண்பத்தெட்டு', 'எண்பத்தொன்பது',\n  'தொண்ணூறு', 'தொண்ணூற்று ஒன்று', 'தொண்ணூற்று இரண்டு', 'தொண்ணூற்று மூன்று', 'தொண்ணூற்று நான்கு', 'தொண்ணூற்று ஐந்து', 'தொண்ணூற்று ஆறு', 'தொண்ணூற்று ஏழு', 'தொண்ணூற்று எட்டு', 'தொண்ணூற்று ஒன்பது'\n]\n\n// Standalone hundreds (when not followed by remainder)\nconst HUNDREDS = ['', 'நூறு', 'இருநூறு', 'முன்னூறு', 'நானூறு', 'ஐநூறு', 'அறுநூறு', 'எழுநூறு', 'எண்நூறு', 'தொள்ளாயிரம்']\n\n// Connected form of hundreds (when followed by remainder) - precomputed\nconst HUNDREDS_CONNECTED = ['', 'நூற்று', 'இருநூற்று', 'முன்னூற்று', 'நானூற்று', 'ஐநூற்று', 'அறுநூற்று', 'எழுநூற்று', 'எண்நூற்று', 'தொள்ளாயிரத்து']\n\n// Ones for decimal reading\nconst ONES = ['ஒன்று', 'இரண்டு', 'மூன்று', 'நான்கு', 'ஐந்து', 'ஆறு', 'ஏழு', 'எட்டு', 'ஒன்பது']\n\n// Scale words: index 0 = units, 1 = thousand, 2 = lakh, etc.\nconst SCALE_WORDS = ['', 'ஆயிரம்', 'லட்சம்', 'கோடி', 'அரபு', 'கராபு', 'நீல்', 'பத்ம', 'சங்கு']\n\n// ============================================================================\n// Segment Splitting (inlined for performance)\n// ============================================================================\n\nfunction groupByThreeThenTwos (n) {\n  const numStr = n.toString()\n\n  if (numStr.length <= 3) {\n    return [Number(numStr)]\n  }\n\n  const segments = []\n  const last3 = numStr.slice(-3)\n  segments.unshift(Number(last3))\n\n  let remaining = numStr.slice(0, -3)\n  while (remaining.length > 0) {\n    const segment = remaining.slice(-2)\n    segments.unshift(Number(segment))\n    remaining = remaining.slice(0, -2)\n  }\n\n  return segments\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction convertBelowThousand (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 HUNDREDS[hundreds]\n  }\n\n  // Use precomputed connected form\n  return HUNDREDS_CONNECTED[hundreds] + ' ' + BELOW_HUNDRED[remainder]\n}\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  const groups = groupByThreeThenTwos(n)\n  const groupCount = groups.length\n  const words = []\n\n  for (let i = 0; i < groupCount; i++) {\n    const groupValue = groups[i]\n    if (groupValue === 0) continue\n\n    const scaleIndex = groupCount - i - 1\n    const groupWords = (groupValue === 1 && scaleIndex > 0) ? 'ஒரு' : convertBelowThousand(groupValue)\n    words.push(groupWords)\n    if (scaleIndex > 0 && SCALE_WORDS[scaleIndex]) {\n      words.push(SCALE_WORDS[scaleIndex])\n    }\n  }\n\n  return words.join(' ').trim()\n}\n\nfunction decimalPartToWords (decimalPart) {\n  // Per-digit decimal reading\n  const digits = []\n  for (const char of decimalPart) {\n    const d = parseInt(char, 10)\n    digits.push(d === 0 ? ZERO : ONES[d - 1])\n  }\n  return digits.join(' ')\n}\n\n/**\n * Converts a numeric value to Tamil words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Tamil 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","HUNDREDS","HUNDREDS_CONNECTED","ONES","SCALE_WORDS","convertBelowThousand","n","hundreds","Math","trunc","remainder","value","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","groups","numStr","segments","last3","unshift","remaining","segment","groupByThreeThenTwos","groupCount","words","i","groupValue","scaleIndex","groupWords","push","join","integerToWords","char","d","decimalPartToWords"],"mappings":"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"}

package/dist/languages/te.js

@@ -1,3 +0,0 @@
-/*! n2words/te v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const r=e.slice(0,n)||"0",i=e.slice(n+1);return{isNegative:t,integerPart:BigInt(r),decimalPart:i}}function n(e){const[t,n]=e.toLowerCase().split("e"),r=parseInt(n,10),i=t.indexOf("."),o=-1===i?t:t.slice(0,i)+t.slice(i+1),s=(-1===i?t.length:i)+r;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const r="సున్నా",i=["సున్నా","ఒకటి","రెండు","మూడు","నాలుగు","ఐదు","ఆరు","ఏడు","ఎనిమిది","తొమ్మిది","పది","పదకొండు","పన్నెండు","పదమూడు","పద్నాలుగు","పదిహేను","పదహారు","పదిహేడు","పద్దెనిమిది","పంతొమ్మిది","ఇరవై","ఇరవై ఒక్కటి","ఇరవై రెండు","ఇరవై మూడు","ఇరవై నాలుగు","ఇరవై ఐదు","ఇరవై ఆరు","ఇరవై ఏడు","ఇరవై ఎనిమిది","ఇరవై తొమ్మిది","ముప్పై","ముప్పై ఒకటి","ముప్పై రెండు","ముప్పై మూడు","ముప్పై నాలుగు","ముప్పై ఐదు","ముప్పై ఆరు","ముప్పై ఏడు","ముప్పై ఎనిమిది","ముప్పై తొమ్మిది","నలభై","నలభై ఒకటి","నలభై రెండు","నలభై మూడు","నలభై నాలుగు","నలభై ఐదు","నలభై ఆరు","నలభై ఏడు","నలభై ఎనిమిది","నలభై తొమ్మిది","యాభై","యాభై ఒకటి","యాభై రెండు","యాభై మూడు","యాభై నాలుగు","యాభై ఐదు","యాభై ఆరు","యాభై ఏడు","యాభై ఎనిమిది","యాభై తొమ్మిది","అరవై","అరవై ఒకటి","అరవై రెండు","అరవై మూడు","అరవై నాలుగు","అరవై ఐదు","అరవై ఆరు","అరవై ఏడు","అరవై ఎనిమిది","అరవై తొమ్మిది","డెబ్బై","డెబ్బై ఒకటి","డెబ్బై రెండు","డెబ్బై మూడు","డెబ్బై నాలుగు","డెబ్బై ఐదు","డెబ్బై ఆరు","డెబ్బై ఏడు","డెబ్బై ఎనిమిది","డెబ్బై తొమ్మిది","ఎనభై","ఎనభై ఒకటి","ఎనభై రెండు","ఎనభై మూడు","ఎనభై నాలుగు","ఎనభై ఐదు","ఎనభై ఆరు","ఎనభై ఏడు","ఎనభై ఎనిమిది","ఎనభై తొమ్మిది","తొంభై","తొంభై ఒకటి","తొంభై రెండు","తొంభై మూడు","తొంభై నాలుగు","తొంభై ఐదు","తొంభై ఆరు","తొంభై ఏడు","తొంభై ఎనిమిది","తొంభై తొమ్మిది"],o=["","వంద","రెండు వందలు","మూడు వందలు","నాలుగు వందలు","ఐదు వందలు","ఆరు వందలు","ఏడు వందలు","ఎనిమిది వందలు","తొమ్మిది వందలు"],s=["ఒకటి","రెండు","మూడు","నాలుగు","ఐదు","ఆరు","ఏడు","ఎనిమిది","తొమ్మిది"],u=["","వెయ్యి","లక్ష","కోటి","అరబ్","ఖరబ్","నిల్","పడ్మ","శంకు"];function c(e){if(0===e)return"";if(e<100)return i[e];const t=Math.trunc(e/100),n=e%100;return 0===n?o[t]:o[t]+" "+i[n]}function f(e){return 0n===e?r:e<1000n?c(Number(e)):a(e,0)}function a(e,t){if(0n===e)return"";const n=0===t?1000n:100n,r=Number(e%n),o=e/n;let s="";return o>0n&&(s=a(o,t+1)),r>0&&(s&&(s+=" "),s+=0===t?c(r):(1===r?"ఒక":i[r])+" "+u[t]),s}e.te=function(e){const{isNegative:i,integerPart:o,decimalPart:u}=function(e){const r=typeof e;if("bigint"===r)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===r){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===r)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${r}`)}(e);let c="";return i&&(c="మైనస్ "),c+=f(o),u&&(c+=" పాయింట్ "+function(e){const t=[];for(const n of e){const e=parseInt(n,10);t.push(0===e?r:s[e-1])}return t.join(" ")}(u)),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=te.js.map

package/dist/languages/te.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"te.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/te.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 * Telugu language converter - Functional Implementation\n *\n * Self-contained converter for South Asian numbering.\n *\n * Key features:\n * - Indian numbering system (వెయ్యి, లక్ష, కోటి)\n * - Telugu script\n * - 3-2-2 grouping pattern\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 = 'పాయింట్'\n\nconst BELOW_HUNDRED = [\n  'సున్నా', 'ఒకటి', 'రెండు', 'మూడు', 'నాలుగు', 'ఐదు', 'ఆరు', 'ఏడు', 'ఎనిమిది', 'తొమ్మిది',\n  'పది', 'పదకొండు', 'పన్నెండు', 'పదమూడు', 'పద్నాలుగు', 'పదిహేను', 'పదహారు', 'పదిహేడు', 'పద్దెనిమిది', 'పంతొమ్మిది',\n  'ఇరవై', 'ఇరవై ఒక్కటి', 'ఇరవై రెండు', 'ఇరవై మూడు', 'ఇరవై నాలుగు', 'ఇరవై ఐదు', 'ఇరవై ఆరు', 'ఇరవై ఏడు', 'ఇరవై ఎనిమిది', 'ఇరవై తొమ్మిది',\n  'ముప్పై', 'ముప్పై ఒకటి', 'ముప్పై రెండు', 'ముప్పై మూడు', 'ముప్పై నాలుగు', 'ముప్పై ఐదు', 'ముప్పై ఆరు', 'ముప్పై ఏడు', 'ముప్పై ఎనిమిది', 'ముప్పై తొమ్మిది',\n  'నలభై', 'నలభై ఒకటి', 'నలభై రెండు', 'నలభై మూడు', 'నలభై నాలుగు', 'నలభై ఐదు', 'నలభై ఆరు', 'నలభై ఏడు', 'నలభై ఎనిమిది', 'నలభై తొమ్మిది',\n  'యాభై', 'యాభై ఒకటి', 'యాభై రెండు', 'యాభై మూడు', 'యాభై నాలుగు', 'యాభై ఐదు', 'యాభై ఆరు', 'యాభై ఏడు', 'యాభై ఎనిమిది', 'యాభై తొమ్మిది',\n  'అరవై', 'అరవై ఒకటి', 'అరవై రెండు', 'అరవై మూడు', 'అరవై నాలుగు', 'అరవై ఐదు', 'అరవై ఆరు', 'అరవై ఏడు', 'అరవై ఎనిమిది', 'అరవై తొమ్మిది',\n  'డెబ్బై', 'డెబ్బై ఒకటి', 'డెబ్బై రెండు', 'డెబ్బై మూడు', 'డెబ్బై నాలుగు', 'డెబ్బై ఐదు', 'డెబ్బై ఆరు', 'డెబ్బై ఏడు', 'డెబ్బై ఎనిమిది', 'డెబ్బై తొమ్మిది',\n  'ఎనభై', 'ఎనభై ఒకటి', 'ఎనభై రెండు', 'ఎనభై మూడు', 'ఎనభై నాలుగు', 'ఎనభై ఐదు', 'ఎనభై ఆరు', 'ఎనభై ఏడు', 'ఎనభై ఎనిమిది', 'ఎనభై తొమ్మిది',\n  'తొంభై', 'తొంభై ఒకటి', 'తొంభై రెండు', 'తొంభై మూడు', 'తొంభై నాలుగు', 'తొంభై ఐదు', 'తొంభై ఆరు', 'తొంభై ఏడు', 'తొంభై ఎనిమిది', 'తొంభై తొమ్మిది'\n]\n\n// ============================================================================\n// Vocabulary (continued)\n// ============================================================================\n\nconst HUNDREDS = ['', 'వంద', 'రెండు వందలు', 'మూడు వందలు', 'నాలుగు వందలు', 'ఐదు వందలు', 'ఆరు వందలు', 'ఏడు వందలు', 'ఎనిమిది వందలు', 'తొమ్మిది వందలు']\n\n// Ones for decimal reading\nconst ONES = ['ఒకటి', 'రెండు', 'మూడు', 'నాలుగు', 'ఐదు', 'ఆరు', 'ఏడు', 'ఎనిమిది', 'తొమ్మిది']\n\n// Scale words: index 0 = units, 1 = thousand, 2 = lakh, etc.\nconst SCALE_WORDS = ['', 'వెయ్యి', 'లక్ష', 'కోటి', 'అరబ్', 'ఖరబ్', 'నిల్', 'పడ్మ', 'శంకు']\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts 0-999 to Telugu words.\n */\nfunction convertBelowThousand (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 HUNDREDS[hundreds]\n  }\n  return HUNDREDS[hundreds] + ' ' + BELOW_HUNDRED[remainder]\n}\n\n/**\n * Converts a non-negative integer to Telugu words.\n * Uses recursive approach for Indian 3-2-2 grouping pattern.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Telugu 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 convertBelowThousand(Number(n))\n  }\n\n  return buildLargeNumberWords(n, 0)\n}\n\n/**\n * Recursively builds words for numbers >= 1000.\n * Indian grouping: first 3 digits, then 2-digit groups.\n *\n * @param {bigint} n - Number to convert\n * @param {number} scale - Current scale index (0=units, 1=thousands, etc.)\n * @returns {string} Telugu words\n */\nfunction buildLargeNumberWords (n, scale) {\n  if (n === 0n) return ''\n\n  // Determine divisor: 1000 for first split, 100 for rest\n  const divisor = scale === 0 ? 1000n : 100n\n  const segment = Number(n % divisor)\n  const rest = n / divisor\n\n  // Build higher segments first (recursive)\n  let result = ''\n  if (rest > 0n) {\n    result = buildLargeNumberWords(rest, scale + 1)\n  }\n\n  // Add current segment\n  if (segment > 0) {\n    if (result) result += ' '\n\n    if (scale === 0) {\n      // Units segment (0-999)\n      result += convertBelowThousand(segment)\n    } else {\n      // Scale segments (0-99)\n      const groupWords = (segment === 1) ? 'ఒక' : BELOW_HUNDRED[segment]\n      result += groupWords + ' ' + SCALE_WORDS[scale]\n    }\n  }\n\n  return result\n}\n\nfunction decimalPartToWords (decimalPart) {\n  // Per-digit decimal reading\n  const digits = []\n  for (const char of decimalPart) {\n    const d = parseInt(char, 10)\n    digits.push(d === 0 ? ZERO : ONES[d - 1])\n  }\n  return digits.join(' ')\n}\n\n/**\n * Converts a numeric value to Telugu words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Telugu 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","HUNDREDS","ONES","SCALE_WORDS","convertBelowThousand","n","hundreds","Math","trunc","remainder","integerToWords","Number","buildLargeNumberWords","scale","divisor","segment","rest","result","value","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","char","d","push","join","decimalPartToWords"],"mappings":"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"}

package/dist/languages/th.js

@@ -1,3 +0,0 @@
-/*! n2words/th v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const r=e.slice(0,n)||"0",i=e.slice(n+1);return{isNegative:t,integerPart:BigInt(r),decimalPart:i}}function n(e){const[t,n]=e.toLowerCase().split("e"),r=parseInt(n,10),i=t.indexOf("."),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="ศูนย์";function s(e){if(0===e)return"";let t=e;const n=[],i=Math.trunc(t/1e5);t%=1e5;const s=Math.trunc(t/1e4);t%=1e4;const o=Math.trunc(t/1e3);t%=1e3;const u=Math.trunc(t/100);t%=100;const c=Math.trunc(t/10),f=t%10;return i>0&&n.push(r[i-1]+"แสน"),s>0&&n.push(1===s?"หนึ่งหมื่น":r[s-1]+"หมื่น"),o>0&&n.push(r[o-1]+"พัน"),u>0&&n.push(r[u-1]+"ร้อย"),c>0&&n.push(1===c?"สิบ":2===c?"ยี่สิบ":r[c-1]+"สิบ"),f>0&&n.push(1===f&&(c>0||i>0||s>0||o>0||u>0||c>0)?"เอ็ด":r[f-1]),n.join("")}e.th=function(e){const{isNegative:o,integerPart:u,decimalPart:c}=function(e){const r=typeof e;if("bigint"===r)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===r){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===r)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${r}`)}(e);let f="";return o&&(f="ลบ"),f+=function(e){if(0n===e)return i;const t=function(e){const t=[];let n=e;const r=1000000n;for(;n>0n;){const e=Number(n%r);t.unshift(e),n/=r}return t}(e),n=[];for(let e=0;e<t.length;e++){const r=t[e];if(0===r)continue;n.push(s(r));const i=t.length-e-1;i>0&&n.push("ล้าน".repeat(i))}return n.join("")}(u),c&&(f+="จุด"+function(e){const t=[];for(const n of e){const e=parseInt(n,10);t.push(0===e?i:r[e-1])}return t.join("")}(c)),f}},"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=th.js.map

package/dist/languages/th.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"th.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/th.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 * Thai language converter - Functional Implementation\n *\n * Self-contained converter with precomputed lookup tables.\n *\n * Key features:\n * - No word separators (continuous Thai script)\n * - Million-based grouping (ล้าน)\n * - Special handling for 1 as \"เอ็ด\" in compounds\n * - 20 is \"ยี่สิบ\" (not \"สองสิบ\")\n * - Per-digit decimal reading\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES = ['หนึ่ง', 'สอง', 'สาม', 'สี่', 'ห้า', 'หก', 'เจ็ด', 'แปด', 'เก้า']\n\nconst ZERO = 'ศูนย์'\nconst NEGATIVE = 'ลบ'\nconst DECIMAL_SEP = 'จุด'\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction convertBelowMillion (n) {\n  if (n === 0) return ''\n\n  let value = n\n  const parts = []\n\n  const hundredThousands = Math.trunc(value / 100000)\n  value %= 100000\n  const tenThousands = Math.trunc(value / 10000)\n  value %= 10000\n  const thousands = Math.trunc(value / 1000)\n  value %= 1000\n  const hundreds = Math.trunc(value / 100)\n  value %= 100\n  const tens = Math.trunc(value / 10)\n  const ones = value % 10\n\n  if (hundredThousands > 0) {\n    parts.push(ONES[hundredThousands - 1] + 'แสน')\n  }\n\n  if (tenThousands > 0) {\n    if (tenThousands === 1) {\n      parts.push('หนึ่งหมื่น')\n    } else {\n      parts.push(ONES[tenThousands - 1] + 'หมื่น')\n    }\n  }\n\n  if (thousands > 0) {\n    parts.push(ONES[thousands - 1] + 'พัน')\n  }\n\n  if (hundreds > 0) {\n    parts.push(ONES[hundreds - 1] + 'ร้อย')\n  }\n\n  if (tens > 0) {\n    if (tens === 1) {\n      parts.push('สิบ')\n    } else if (tens === 2) {\n      parts.push('ยี่สิบ')\n    } else {\n      parts.push(ONES[tens - 1] + 'สิบ')\n    }\n  }\n\n  if (ones > 0) {\n    const hasHigher = hundredThousands > 0 || tenThousands > 0 || thousands > 0 || hundreds > 0 || tens > 0\n    if (ones === 1 && (tens > 0 || hasHigher)) {\n      parts.push('เอ็ด')\n    } else {\n      parts.push(ONES[ones - 1])\n    }\n  }\n\n  return parts.join('')\n}\n\nfunction splitMillionGroups (n) {\n  const groups = []\n  let remaining = n\n\n  const million = 1_000_000n\n  while (remaining > 0n) {\n    const chunk = Number(remaining % million)\n    groups.unshift(chunk)\n    remaining = remaining / million\n  }\n\n  return groups\n}\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  const groups = splitMillionGroups(n)\n  const parts = []\n\n  for (let i = 0; i < groups.length; i++) {\n    const groupValue = groups[i]\n    if (groupValue === 0) continue\n\n    parts.push(convertBelowMillion(groupValue))\n    const remaining = groups.length - i - 1\n    if (remaining > 0) {\n      parts.push('ล้าน'.repeat(remaining))\n    }\n  }\n\n  return parts.join('')\n}\n\nfunction decimalPartToWords (decimalPart) {\n  // Per-digit decimal reading\n  const digits = []\n  for (const char of decimalPart) {\n    const d = parseInt(char, 10)\n    digits.push(d === 0 ? ZERO : ONES[d - 1])\n  }\n  return digits.join('')\n}\n\n/**\n * Converts a numeric value to Thai words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Thai 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","ZERO","convertBelowMillion","n","value","parts","hundredThousands","Math","trunc","tenThousands","thousands","hundreds","tens","ones","push","join","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","groups","remaining","million","chunk","unshift","splitMillionGroups","i","groupValue","integerToWords","char","d","decimalPartToWords"],"mappings":"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"}

package/dist/languages/tr.js

@@ -1,3 +0,0 @@
-/*! n2words/tr v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const r=e.slice(0,n)||"0",i=e.slice(n+1);return{isNegative:t,integerPart:BigInt(r),decimalPart:i}}function n(e){const[t,n]=e.toLowerCase().split("e"),r=parseInt(n,10),i=t.indexOf("."),o=-1===i?t:t.slice(0,i)+t.slice(i+1),s=(-1===i?t.length:i)+r;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const r=["","bir","iki","üç","dört","beş","altı","yedi","sekiz","dokuz"],i=["on","on bir","on iki","on üç","on dört","on beş","on altı","on yedi","on sekiz","on dokuz"],o=["","","yirmi","otuz","kırk","elli","altmış","yetmiş","seksen","doksan"],s="bin",u="sıfır",c=["milyon","milyar","trilyon","katrilyon","kentilyon"];function l(e,t=" "){if(0===e)return"";const n=e%10,s=Math.floor(e/10)%10,u=Math.floor(e/100),c=[];u>0&&c.push(1===u?"yüz":r[u]+t+"yüz");const l=e%100;return 0===l||c.push(l<10?r[n]:l<20?i[n].replace(" ",t):0===n?o[s]:o[s]+t+r[n]),c.join(t)}const f=new Array(1e3),a=new Array(1e3);for(let e=0;e<1e3;e++)f[e]=l(e," "),a[e]=l(e,"");function p(e,t={}){if(0n===e)return u;const n=t.dropSpaces?"":" ",r=t.dropSpaces?a:f;if(e<1000n)return r[Number(e)];if(e<1000000n){const t=Number(e/1000n),i=Number(e%1000n);let o;return o=1===t?s:r[t]+n+s,i>0&&(o+=n+r[i]),o}return function(e,t){const n=t.dropSpaces?"":" ",r=t.dropSpaces?a:f,i=e.toString(),o=i.length,u=[],l=o%3;let p=0;for(l>0&&(u.push(Number(i.slice(0,l))),p=l);p<o;)u.push(Number(i.slice(p,p+3))),p+=3;const d=[];let g=u.length-1;for(let e=0;e<u.length;e++){const t=u[e];if(0!==t){const e=r[t];d.push(0===g?e:1===g?1===t?s:e+n+s:e+n+c[g-2])}g--}return d.join(n)}(e,t)}e.tr=function(e,r){r=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)}(r);const{isNegative:i,integerPart:o,decimalPart:s}=function(e){const r=typeof e;if("bigint"===r)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===r){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===r)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${r}`)}(e),c=r.dropSpaces?"":" ";let l="";return i&&(l="eksi"+c),l+=p(o,r),s&&(l+=c+"virgül"+c+function(e,t){const n=t.dropSpaces?"":" ";let r="",i=0;for(;i<e.length&&"0"===e[i];)r&&(r+=n),r+=u,i++;const o=e.slice(i);return o&&(r&&(r+=n),r+=p(BigInt(o),t)),r}(s,r)),l}},"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=tr.js.map

package/dist/languages/tr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tr.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/tr.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 * Turkish language converter - Functional Implementation\n *\n * A performance-optimized number-to-words converter using precomputed lookup tables.\n *\n * Key features:\n * - Omits 'bir' (one) before hundreds and thousands\n * - Optional dropSpaces for compound form\n * - Short scale naming\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\nimport { validateOptions } from '../utils/validate-options.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\nconst ONES = ['', 'bir', 'iki', 'üç', 'dört', 'beş', 'altı', 'yedi', 'sekiz', 'dokuz']\n\nconst TEENS = ['on', 'on bir', 'on iki', 'on üç', 'on dört', 'on beş', 'on altı', 'on yedi', 'on sekiz', 'on dokuz']\nconst TENS = ['', '', 'yirmi', 'otuz', 'kırk', 'elli', 'altmış', 'yetmiş', 'seksen', 'doksan']\n\nconst HUNDRED = 'yüz'\nconst THOUSAND = 'bin'\n\nconst ZERO = 'sıfır'\nconst NEGATIVE = 'eksi'\nconst DECIMAL_SEP = 'virgül'\n\n// Short scale\nconst SCALES = ['milyon', 'milyar', 'trilyon', 'katrilyon', 'kentilyon']\n\n// ============================================================================\n// Precomputed Lookup Tables (built once at module load)\n// ============================================================================\n\n/**\n * Builds segment word for 0-999.\n * Omits \"bir\" before \"yüz\" (hundred).\n */\nfunction buildSegment (n, separator = ' ') {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds - omit \"bir\" before yüz\n  if (hundreds > 0) {\n    if (hundreds === 1) {\n      parts.push(HUNDRED)\n    } else {\n      parts.push(ONES[hundreds] + separator + HUNDRED)\n    }\n  }\n\n  // Tens and ones\n  const tensOnes = n % 100\n\n  if (tensOnes === 0) {\n    // Just hundreds\n  } else if (tensOnes < 10) {\n    parts.push(ONES[ones])\n  } else if (tensOnes < 20) {\n    parts.push(TEENS[ones].replace(' ', separator))\n  } else if (ones === 0) {\n    parts.push(TENS[tens])\n  } else {\n    parts.push(TENS[tens] + separator + ONES[ones])\n  }\n\n  return parts.join(separator)\n}\n\n// Precompute all 1000 segment words (0-999) with space separator\nconst SEGMENTS = new Array(1000)\nconst SEGMENTS_NO_SPACE = new Array(1000)\n\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS[i] = buildSegment(i, ' ')\n  SEGMENTS_NO_SPACE[i] = buildSegment(i, '')\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Turkish words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @param {Object} options - Conversion options\n * @returns {string} Turkish words\n */\nfunction integerToWords (n, options = {}) {\n  if (n === 0n) return ZERO\n\n  const sep = options.dropSpaces ? '' : ' '\n  const segments = options.dropSpaces ? SEGMENTS_NO_SPACE : SEGMENTS\n\n  // Fast path: numbers < 1000 (direct lookup)\n  if (n < 1000n) {\n    return segments[Number(n)]\n  }\n\n  // Fast path: numbers < 1,000,000 (thousands)\n  if (n < 1_000_000n) {\n    const thousands = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    // Omit \"bir\" before bin (thousand)\n    let result\n    if (thousands === 1) {\n      result = THOUSAND\n    } else {\n      result = segments[thousands] + sep + THOUSAND\n    }\n\n    if (remainder > 0) {\n      result += sep + segments[remainder]\n    }\n\n    return result\n  }\n\n  // For numbers >= 1,000,000, use scale decomposition\n  return buildLargeNumberWords(n, options)\n}\n\n/**\n * Builds words for numbers >= 1,000,000.\n *\n * @param {bigint} n - Number >= 1,000,000\n * @param {Object} options - Conversion options\n * @returns {string} Turkish words\n */\nfunction buildLargeNumberWords (n, options) {\n  const sep = options.dropSpaces ? '' : ' '\n  const segmentsArr = options.dropSpaces ? SEGMENTS_NO_SPACE : SEGMENTS\n\n  const numStr = n.toString()\n  const len = numStr.length\n\n  // Build segments of 3 digits from right to left\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  // Convert segments to words\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      const segmentWord = segmentsArr[segment]\n\n      if (scaleIndex === 0) {\n        // Units segment\n        parts.push(segmentWord)\n      } else if (scaleIndex === 1) {\n        // Thousands - omit \"bir\" before bin\n        if (segment === 1) {\n          parts.push(THOUSAND)\n        } else {\n          parts.push(segmentWord + sep + THOUSAND)\n        }\n      } else {\n        // Millions+ - \"bir\" is kept before scale words\n        const scaleWord = SCALES[scaleIndex - 2]\n        parts.push(segmentWord + sep + scaleWord)\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(sep)\n}\n\n/**\n * Converts decimal digits to Turkish words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @param {Object} options - Conversion options\n * @returns {string} Turkish words for decimal part\n */\nfunction decimalPartToWords (decimalPart, options) {\n  const sep = options.dropSpaces ? '' : ' '\n  let result = ''\n\n  // Handle leading zeros\n  let i = 0\n  while (i < decimalPart.length && decimalPart[i] === '0') {\n    if (result) result += sep\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 += sep\n    result += integerToWords(BigInt(remainder), options)\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Turkish words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @param {Object} [options] - Conversion options\n * @param {boolean} [options.dropSpaces=false] - Remove spaces for compound form\n * @returns {string} The number in Turkish 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)                        // 'yirmi bir'\n * toWords(21, { dropSpaces: true })  // 'yirmibir'\n * toWords(1000)                      // 'bin'\n */\nfunction toWords (value, options) {\n  options = validateOptions(options)\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  const sep = options.dropSpaces ? '' : ' '\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + sep\n  }\n\n  result += integerToWords(integerPart, options)\n\n  if (decimalPart) {\n    result += sep + DECIMAL_SEP + sep + decimalPartToWords(decimalPart, options)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\nexport { toWords }\n","import { isPlainObject } from './is-plain-object.js'\n\n/**\n * Validates and normalizes the options parameter.\n *\n * @param {*} options The options value to validate\n * @returns {Object} A valid options object (empty object if undefined)\n * @throws {TypeError} If options is not undefined or a plain object\n */\nexport function validateOptions (options) {\n  if (options === undefined) return {}\n  if (isPlainObject(options)) return options\n  throw new TypeError(\n    `Invalid options: expected plain object or undefined, got ${typeof options}`\n  )\n}\n","/**\n * Checks if a value is a plain object (not null, array, or other object types).\n *\n * A plain object is one created by:\n * - Object literal: `{}`\n * - Object.create(null): null-prototype object\n *\n * This excludes arrays, class instances, Map, Set, and other object types.\n *\n * @param {*} value Value to check\n * @returns {boolean} True if value is a plain object\n */\nexport function isPlainObject (value) {\n  if (value === null || typeof value !== 'object') return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === null || proto === Object.prototype\n}\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","TEENS","TENS","THOUSAND","ZERO","SCALES","buildSegment","n","separator","ones","tens","Math","floor","hundreds","parts","push","tensOnes","replace","join","SEGMENTS","Array","SEGMENTS_NO_SPACE","i","integerToWords","options","sep","dropSpaces","segments","Number","thousands","remainder","result","segmentsArr","numStr","toString","len","remainderLen","pos","scaleIndex","segment","segmentWord","buildLargeNumberWords","value","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","decimalPartToWords"],"mappings":"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"}

package/dist/languages/uk.js

@@ -1,3 +0,0 @@
-/*! n2words/uk v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,i;e=this,i=function(e){"use strict";function i(e){const i="-"===e[0];i&&(e=e.slice(1));const t=e.indexOf(".");if(-1===t)return{isNegative:i,integerPart:BigInt(e)};const n=e.slice(0,t)||"0",r=e.slice(t+1);return{isNegative:i,integerPart:BigInt(n),decimalPart:r}}function t(e){const[i,t]=e.toLowerCase().split("e"),n=parseInt(t,10),r=i.indexOf("."),o=-1===r?i:i.slice(0,r)+i.slice(r+1),s=(-1===r?i.length:r)+n;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}function n(e,i){const t="bigint"==typeof e?Number(e):e,n=t%10,r=t%100;return r>=11&&r<=19?i[2]:1===n?i[0]:n>=2&&n<=4?i[1]:i[2]}function r(e,i,t,n,r){if(0===e)return"";const o=e%10,s=Math.floor(e/10)%10,u=Math.floor(e/100),c=[];return u>0&&c.push(r[u]),s>1&&c.push(n[s]),1===s?c.push(t[o]):o>0&&c.push(i[o]),c.join(" ")}const o="нуль",s=[["тисяча","тисячi","тисяч"],["мiльйон","мiльйони","мiльйонiв"],["мiльярд","мiльярди","мiльярдiв"],["трильйон","трильйони","трильйонiв"],["квадрильйон","квадрильйони","квадрильйонiв"],["квiнтильйон","квiнтильйони","квiнтильйонiв"],["секстильйон","секстильйони","секстильйонiв"],["септильйон","септильйони","септильйонiв"],["октильйон","октильйони","октильйонiв"]],{masc:u,fem:c}=function(e,i,t,n,o){const s=new Array(1e3),u=new Array(1e3);for(let c=0;c<1e3;c++)s[c]=r(c,e,t,n,o),u[c]=r(c,i,t,n,o);return{masc:s,fem:u}}(["","один","два","три","чотири","п'ять","шiсть","сiм","вiсiм","дев'ять"],["","одна","двi","три","чотири","п'ять","шiсть","сiм","вiсiм","дев'ять"],["десять","одинадцять","дванадцять","тринадцять","чотирнадцять","п'ятнадцять","шiстнадцять","сiмнадцять","вiсiмнадцять","дев'ятнадцять"],["","","двадцять","тридцять","сорок","п'ятдесят","шiстдесят","сiмдесят","вiсiмдесят","дев'яносто"],["","сто","двiстi","триста","чотириста","п'ятсот","шiстсот","сiмсот","вiсiмсот","дев'ятсот"]);function f(e,i={}){return 0n===e?o:e<1000n?("feminine"===i.gender?c:u)[Number(e)]:function(e,i){const t=e.toString(),r=t.length,o=[],f=r%3;let l=0;for(f>0&&(o.push(Number(t.slice(0,f))),l=f);l<r;)o.push(Number(t.slice(l,l+3))),l+=3;const a=[];let g=o.length-1;for(let e=0;e<o.length;e++){const t=o[e];if(0!==t)if(0===g)a.push(("feminine"===i.gender?c:u)[t]);else{const e=n(t,s[g-1]);a.push((1===g?c:u)[t]+" "+e)}g--}return a.join(" ")}(e,i)}e.uk=function(e,n){n=function(e){if(void 0===e)return{};if(function(e){if(null===e||"object"!=typeof e)return!1;const i=Object.getPrototypeOf(e);return null===i||i===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:u}=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)}:i(function(e){const i=e.toString();return i.includes("e")||i.includes("E")?t(i):i}(e))}if("string"===n)return i(function(e){const i=e.trim();if(0===i.length||Number.isNaN(Number(i)))throw new Error(`Invalid number format: "${e}"`);return i.includes("e")||i.includes("E")?t(i):i}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${n}`)}(e);let c="";return r&&(c="мiнус "),c+=f(s,n),u&&(c+=" кома "+function(e,i){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+=o,n++;const r=e.slice(n);return r&&(t&&(t+=" "),t+=f(BigInt(r),i)),t}(u,n)),c}},"object"==typeof exports&&"undefined"!=typeof module?i(exports):"function"==typeof define&&define.amd?define(["exports"],i):i((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=uk.js.map

package/dist/languages/uk.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"uk.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/uk.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 * Ukrainian language converter - Functional Implementation\n *\n * Self-contained converter using shared Slavic utilities.\n *\n * Key features:\n * - Three-form pluralization (one/few/many)\n * - Gender: thousands are feminine, millions+ are masculine\n * - Irregular hundreds\n * - Long scale naming\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\nimport { validateOptions } from '../utils/validate-options.js'\n\n// ============================================================================\n// Slavic Utilities (inlined for performance)\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 buildAllSegments (onesMasc, onesFem, teens, tens, hundreds) {\n  const masc = new Array(1000)\n  const fem = new Array(1000)\n\n  for (let i = 0; i < 1000; i++) {\n    masc[i] = buildSegment(i, onesMasc, teens, tens, hundreds)\n    fem[i] = buildSegment(i, onesFem, teens, tens, hundreds)\n  }\n\n  return { masc, fem }\n}\n\nfunction buildSegment (n, ones, teens, tens, hundreds) {\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[onesDigit])\n  }\n\n  return parts.join(' ')\n}\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES_MASC = ['', 'один', 'два', 'три', 'чотири', 'п\\'ять', 'шiсть', 'сiм', 'вiсiм', 'дев\\'ять']\nconst ONES_FEM = ['', 'одна', 'двi', 'три', 'чотири', 'п\\'ять', 'шiсть', 'сiм', 'вiсiм', 'дев\\'ять']\n\nconst TEENS = ['десять', 'одинадцять', 'дванадцять', 'тринадцять', 'чотирнадцять', 'п\\'ятнадцять', 'шiстнадцять', 'сiмнадцять', 'вiсiмнадцять', 'дев\\'ятнадцять']\nconst TENS = ['', '', 'двадцять', 'тридцять', 'сорок', 'п\\'ятдесят', 'шiстдесят', 'сiмдесят', 'вiсiмдесят', 'дев\\'яносто']\n\n// Irregular hundreds\nconst HUNDREDS = ['', 'сто', 'двiстi', 'триста', 'чотириста', 'п\\'ятсот', 'шiстсот', 'сiмсот', 'вiсiмсот', 'дев\\'ятсот']\n\nconst ZERO = 'нуль'\nconst NEGATIVE = 'мiнус'\nconst DECIMAL_SEP = 'кома'\n\n// Scale words: [singular, few, many]\n// Thousands (index 0) are feminine, rest are masculine\nconst SCALE_FORMS = [\n  ['тисяча', 'тисячi', 'тисяч'],\n  ['мiльйон', 'мiльйони', 'мiльйонiв'],\n  ['мiльярд', 'мiльярди', 'мiльярдiв'],\n  ['трильйон', 'трильйони', 'трильйонiв'],\n  ['квадрильйон', 'квадрильйони', 'квадрильйонiв'],\n  ['квiнтильйон', 'квiнтильйони', 'квiнтильйонiв'],\n  ['секстильйон', 'секстильйони', 'секстильйонiв'],\n  ['септильйон', 'септильйони', 'септильйонiв'],\n  ['октильйон', 'октильйони', 'октильйонiв']\n]\n\n// ============================================================================\n// Precomputed Lookup Tables\n// ============================================================================\n\nconst { masc: SEGMENTS_MASC, fem: SEGMENTS_FEM } = buildAllSegments(ONES_MASC, ONES_FEM, TEENS, TENS, HUNDREDS)\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n, options = {}) {\n  if (n === 0n) return ZERO\n\n  if (n < 1000n) {\n    const segments = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC\n    return segments[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        const segmentWords = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC\n        parts.push(segmentWords[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 segmentWords = isFeminine ? SEGMENTS_FEM : SEGMENTS_MASC\n        parts.push(segmentWords[segment] + ' ' + 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 Ukrainian 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 Ukrainian 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","pluralize","n","forms","num","Number","lastDigit","lastTwoDigits","buildSegment","ones","teens","tens","hundreds","onesDigit","tensDigit","Math","floor","hundredsDigit","parts","push","join","ZERO","SCALE_FORMS","masc","SEGMENTS_MASC","fem","SEGMENTS_FEM","onesMasc","onesFem","Array","i","buildAllSegments","integerToWords","options","gender","numStr","toString","len","segments","remainderLen","pos","scaleIndex","segment","scaleWord","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/ur.js

@@ -1,3 +0,0 @@
-/*! n2words/ur v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const r=e.slice(0,n)||"0",i=e.slice(n+1);return{isNegative:t,integerPart:BigInt(r),decimalPart:i}}function n(e){const[t,n]=e.toLowerCase().split("e"),r=parseInt(n,10),i=t.indexOf("."),o=-1===i?t:t.slice(0,i)+t.slice(i+1),s=(-1===i?t.length:i)+r;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const r=["صفر","ایک","دو","تین","چار","پانچ","چھ","سات","آٹھ","نو","دس","گیارہ","بارہ","تیرہ","چودہ","پندرہ","سولہ","سترہ","اٹھارہ","انیس","بیس","اکیس","بائیس","تیئیس","چوبیس","پچیس","چھبیس","ستائیس","اٹھائیس","انتیس","تیس","اکتیس","بتیس","تینتیس","چونتیس","پینتیس","چھتیس","سینتیس","اڑتیس","انتالیس","چالیس","اکتالیس","بیالیس","تینتالیس","چوالیس","پینتالیس","چھالیس","سینتالیس","اڑتالیس","انچاس","پچاس","اکاون","باون","ترپن","چون","پچپن","چھپن","ستاون","اٹھاون","انسٹھ","ساٹھ","اکسٹھ","باسٹھ","ترسٹھ","چونسٹھ","پینسٹھ","چھیاسٹھ","سڑسٹھ","اڑسٹھ","انہتر","ستر","اکہتر","بہتر","تہتر","چوہتر","پچھتر","چھہتر","ستتر","اٹھہتر","اناسی","اسی","اکیاسی","بیاسی","تریاسی","چوراسی","پچاسی","چھیاسی","ستاسی","اٹھاسی","نواسی","نوے","اکانوے","بانوے","ترانوے","چورانوے","پچانوے","چھیانوے","ستانوے","اٹھانوے","ننانوے"],i=["","ہزار","لاکھ","کروڑ","ارب","کھرب","نیل","پدم","شنکھ"];function o(e){if(0===e)return"";if(e<100)return r[e];const t=Math.trunc(e/100),n=e%100;return 0===n?r[t]+" سو":r[t]+" سو "+r[n]}function s(e){return 0n===e?"صفر":e<1000n?o(Number(e)):u(e,0)}function u(e,t){if(0n===e)return"";const n=0===t?1000n:100n,s=Number(e%n),c=e/n;let f="";return c>0n&&(f=u(c,t+1)),s>0&&(f&&(f+=" "),f+=0===t?o(s):r[s]+" "+i[t]),f}e.ur=function(e){const{isNegative:r,integerPart:i,decimalPart:o}=function(e){const r=typeof e;if("bigint"===r)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===r){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===r)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${r}`)}(e);let u="";return r&&(u="منفی "),u+=s(i),o&&(u+=" اعشاریہ "+function(e){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+="صفر",n++;const r=e.slice(n);return r&&(t&&(t+=" "),t+=s(BigInt(r))),t}(o)),u}},"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=ur.js.map

package/dist/languages/ur.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ur.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/ur.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 * Urdu language converter - Functional Implementation\n *\n * Self-contained converter for South Asian numbering.\n *\n * Key features:\n * - Indian numbering system (ہزار, لاکھ, کروڑ)\n * - Urdu script (right-to-left)\n * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)\n * - Complete word forms for 0-99\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ZERO = 'صفر'\nconst NEGATIVE = 'منفی'\nconst DECIMAL_SEP = 'اعشاریہ'\nconst HUNDRED = 'سو'\n\nconst BELOW_HUNDRED = [\n  'صفر', 'ایک', 'دو', 'تین', 'چار', 'پانچ', 'چھ', 'سات', 'آٹھ', 'نو',\n  'دس', 'گیارہ', 'بارہ', 'تیرہ', 'چودہ', 'پندرہ', 'سولہ', 'سترہ', 'اٹھارہ', 'انیس',\n  'بیس', 'اکیس', 'بائیس', 'تیئیس', 'چوبیس', 'پچیس', 'چھبیس', 'ستائیس', 'اٹھائیس', 'انتیس',\n  'تیس', 'اکتیس', 'بتیس', 'تینتیس', 'چونتیس', 'پینتیس', 'چھتیس', 'سینتیس', 'اڑتیس', 'انتالیس',\n  'چالیس', 'اکتالیس', 'بیالیس', 'تینتالیس', 'چوالیس', 'پینتالیس', 'چھالیس', 'سینتالیس', 'اڑتالیس', 'انچاس',\n  'پچاس', 'اکاون', 'باون', 'ترپن', 'چون', 'پچپن', 'چھپن', 'ستاون', 'اٹھاون', 'انسٹھ',\n  'ساٹھ', 'اکسٹھ', 'باسٹھ', 'ترسٹھ', 'چونسٹھ', 'پینسٹھ', 'چھیاسٹھ', 'سڑسٹھ', 'اڑسٹھ', 'انہتر',\n  'ستر', 'اکہتر', 'بہتر', 'تہتر', 'چوہتر', 'پچھتر', 'چھہتر', 'ستتر', 'اٹھہتر', 'اناسی',\n  'اسی', 'اکیاسی', 'بیاسی', 'تریاسی', 'چوراسی', 'پچاسی', 'چھیاسی', 'ستاسی', 'اٹھاسی', 'نواسی',\n  'نوے', 'اکانوے', 'بانوے', 'ترانوے', 'چورانوے', 'پچانوے', 'چھیانوے', 'ستانوے', 'اٹھانوے', 'ننانوے'\n]\n\n// Scale words: index 0 = units (empty), 1 = thousand, 2 = lakh, 3 = crore, etc.\nconst SCALE_WORDS = ['', 'ہزار', 'لاکھ', 'کروڑ', 'ارب', 'کھرب', 'نیل', 'پدم', 'شنکھ']\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts 0-999 to Urdu words.\n */\nfunction segmentToWords (n) {\n  if (n === 0) return ''\n  if (n < 100) return BELOW_HUNDRED[n]\n\n  const hundreds = Math.trunc(n / 100)\n  const remainder = n % 100\n\n  if (remainder === 0) {\n    return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED\n  }\n  return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED + ' ' + BELOW_HUNDRED[remainder]\n}\n\n/**\n * Converts a non-negative integer to Urdu words.\n * Uses recursive approach for Indian 3-2-2 grouping pattern.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Urdu 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 segmentToWords(Number(n))\n  }\n\n  return buildLargeNumberWords(n, 0)\n}\n\n/**\n * Recursively builds words for numbers >= 1000.\n * Indian grouping: first 3 digits, then 2-digit groups.\n *\n * @param {bigint} n - Number to convert\n * @param {number} scale - Current scale index (0=units, 1=thousands, etc.)\n * @returns {string} Urdu words\n */\nfunction buildLargeNumberWords (n, scale) {\n  if (n === 0n) return ''\n\n  // Determine divisor: 1000 for first split, 100 for rest\n  const divisor = scale === 0 ? 1000n : 100n\n  const segment = Number(n % divisor)\n  const rest = n / divisor\n\n  // Build higher segments first (recursive)\n  let result = ''\n  if (rest > 0n) {\n    result = buildLargeNumberWords(rest, scale + 1)\n  }\n\n  // Add current segment\n  if (segment > 0) {\n    if (result) result += ' '\n\n    if (scale === 0) {\n      // Units segment (0-999)\n      result += segmentToWords(segment)\n    } else {\n      // Scale segments (0-99)\n      result += BELOW_HUNDRED[segment] + ' ' + SCALE_WORDS[scale]\n    }\n  }\n\n  return result\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 Urdu words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Urdu 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","BELOW_HUNDRED","SCALE_WORDS","segmentToWords","n","hundreds","Math","trunc","remainder","integerToWords","Number","buildLargeNumberWords","scale","divisor","segment","rest","result","value","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","i","decimalPartToWords"],"mappings":"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"}

package/dist/languages/vi.js

@@ -1,3 +0,0 @@
-/*! n2words/vi v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,n;e=this,n=function(e){"use strict";function n(e){const n="-"===e[0];n&&(e=e.slice(1));const t=e.indexOf(".");if(-1===t)return{isNegative:n,integerPart:BigInt(e)};const i=e.slice(0,t)||"0",r=e.slice(t+1);return{isNegative:n,integerPart:BigInt(i),decimalPart:r}}function t(e){const[n,t]=e.toLowerCase().split("e"),i=parseInt(t,10),r=n.indexOf("."),o=-1===r?n:n.slice(0,r)+n.slice(r+1),l=(-1===r?n.length:r)+i;return l>=o.length?o+"0".repeat(l-o.length):l<=0?"0."+"0".repeat(-l)+o:o.slice(0,l)+"."+o.slice(l)}const i=["không","một","hai","ba","bốn","năm","sáu","bảy","tám","chín"],r=["","nghìn","triệu","tỷ","nghìn tỷ","trăm nghìn tỷ","Quintillion","Sextillion","Septillion","Octillion","Nonillion","Decillion","Undecillion","Duodecillion","Tredecillion","Quattuordecillion","Sexdecillion","Septendecillion","Octodecillion","Novemdecillion","Vigintillion"],o="không";function l(e){if(0===e)return i[0];if(e<10)return i[e];if(e<20){const n=e-10;return 0===n?"mười":5===n?"mười lăm":"mười "+i[n]}const n=e%10,t=Math.floor(e/10),r=i[t]+" mươi";return 0===n?r:1===n?r+" mốt":5===n?r+" lăm":r+" "+i[n]}function u(e){if(0===e)return"";const n=Math.floor(e/100),t=e%100;let r="";return n>0&&(r=i[n]+" trăm"),t>0&&(t<10?r?(r+=" lẻ ",r+=5===t?"năm":i[t]):r=i[t]:(r&&(r+=" "),r+=s[t])),r}const s=new Array(100);for(let e=0;e<100;e++)s[e]=l(e);const c=new Array(1e3);for(let e=0;e<1e3;e++)c[e]=u(e);const f=new Array(100);f[0]="";for(let e=1;e<10;e++)f[e]="lẻ "+(5===e?"năm":i[e]);for(let e=10;e<100;e++)f[e]="lẻ "+s[e];function g(e){if(0n===e)return o;if(e<100n)return s[Number(e)];if(e<1000n)return c[Number(e)];if(e<1000000n){const n=Number(e/1000n),t=Number(e%1000n),i=c[n]+" "+r[1];return 0===t?i:t<100?i+" "+f[t]:i+" "+c[t]}return function(e){const n=e.toString(),t=n.length,i=[],l=t%3;let u=0;for(l>0&&(i.push(Number(n.slice(0,l))),u=l);u<t;)i.push(Number(n.slice(u,u+3))),u+=3;const s=[];let g=i.length-1;for(let e=0;e<i.length;e++){const n=i[e];if(0!==n){const e=c[n];e&&s.push(g>0?e+" "+r[g]:e)}g--}const a=s.length;if(0===a)return o;if(1===a)return s[0];const m=i[i.length-1];if(m>0&&m<=99){let e=s[0];for(let n=1;n<a-1;n++)e+=" "+s[n];return e+" "+f[m]}let d=s[0];for(let e=1;e<a;e++)d+=" "+s[e];return d}(e)}e.vi=function(e){const{isNegative:i,integerPart:r,decimalPart:l}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:n(function(e){const n=e.toString();return n.includes("e")||n.includes("E")?t(n):n}(e))}if("string"===i)return n(function(e){const n=e.trim();if(0===n.length||Number.isNaN(Number(n)))throw new Error(`Invalid number format: "${e}"`);return n.includes("e")||n.includes("E")?t(n):n}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(e);let u="";return i&&(u="âm "),u+=g(r),l&&(u+=" phẩy "+function(e){let n="",t=0;for(;t<e.length&&"0"===e[t];)n&&(n+=" "),n+=o,t++;const i=e.slice(t);return i&&(n&&(n+=" "),n+=g(BigInt(i))),n}(l)),u}},"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
-//# sourceMappingURL=vi.js.map

package/dist/languages/vi.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"vi.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/vi.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 * Vietnamese language converter - Functional Implementation v2\n *\n * A performance-optimized number-to-words converter using precomputed lookup tables.\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key optimization: Precompute all segment values (0-999) at module load.\n * This eliminates all per-call string manipulation for segment conversion.\n *\n * Vietnamese-specific rules (handled in precomputation):\n * - Special pronunciation: \"lăm\" for 5 in tens position, \"mốt\" for final 1\n * - \"Lẻ\" (odd/extra) marker when tens place is zero after hundreds/scales\n * - Short scale system with Vietnamese words (nghìn, triệu, tỷ)\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\n// Base vocabulary for building lookup tables\nconst ONES = ['không', 'một', 'hai', 'ba', 'bốn', 'năm', 'sáu', 'bảy', 'tám', 'chín']\n\n// Scale words indexed by scale level (0 = units, 1 = thousands, etc.)\nconst SCALES = [\n  '', 'nghìn', 'triệu', 'tỷ', 'nghìn tỷ', 'trăm nghìn tỷ',\n  'Quintillion', 'Sextillion', 'Septillion', 'Octillion',\n  'Nonillion', 'Decillion', 'Undecillion', 'Duodecillion',\n  'Tredecillion', 'Quattuordecillion', 'Sexdecillion',\n  'Septendecillion', 'Octodecillion', 'Novemdecillion', 'Vigintillion'\n]\n\nconst HUNDRED = 'trăm'\nconst ZERO = 'không'\nconst NEGATIVE = 'âm'\nconst DECIMAL_SEP = 'phẩy'\nconst LE = 'lẻ' // \"odd/extra\" marker for gaps\n\n// Special forms\nconst MOT_FINAL = 'mốt' // 1 in tens position (21, 31, etc.)\nconst LAM = 'lăm' // 5 in tens position (25, 35, etc.)\n\n// ============================================================================\n// Precomputed Lookup Tables (built once at module load)\n// ============================================================================\n\n/**\n * Builds word for 0-99 with special forms (mốt, lăm).\n * Only used during table construction.\n */\nfunction buildBelowHundred (n) {\n  if (n === 0) return ONES[0]\n  if (n < 10) return ONES[n]\n\n  // Teens: 10-19\n  if (n < 20) {\n    const ones = n - 10\n    if (ones === 0) return 'mười'\n    if (ones === 5) return 'mười lăm'\n    return 'mười ' + ONES[ones]\n  }\n\n  // 20-99\n  const ones = n % 10\n  const tens = Math.floor(n / 10)\n  const tensWord = ONES[tens] + ' mươi'\n\n  if (ones === 0) return tensWord\n  if (ones === 1) return tensWord + ' ' + MOT_FINAL\n  if (ones === 5) return tensWord + ' ' + LAM\n  return tensWord + ' ' + ONES[ones]\n}\n\n/**\n * Builds segment word for 0-999.\n * Only used during table construction.\n */\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const hundreds = Math.floor(n / 100)\n  const remainder = n % 100\n\n  let result = ''\n\n  if (hundreds > 0) {\n    result = ONES[hundreds] + ' ' + HUNDRED\n  }\n\n  if (remainder > 0) {\n    if (remainder < 10) {\n      // Single digit after hundreds needs \"lẻ\"\n      if (result) {\n        result += ' ' + LE + ' '\n        // Use \"năm\" not \"lăm\" after lẻ\n        result += remainder === 5 ? 'năm' : ONES[remainder]\n      } else {\n        result = ONES[remainder]\n      }\n    } else {\n      // 10-99 after hundreds\n      if (result) result += ' '\n      result += BELOW_100[remainder]\n    }\n  }\n\n  return result\n}\n\n// Precompute all 100 below-hundred words (0-99)\n// BELOW_100[n] gives the Vietnamese word for n\nconst BELOW_100 = new Array(100)\nfor (let i = 0; i < 100; i++) {\n  BELOW_100[i] = buildBelowHundred(i)\n}\n\n// Precompute all 1000 segment words (0-999)\n// SEGMENTS[n] gives the Vietnamese word for n within a segment\nconst SEGMENTS = new Array(1000)\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS[i] = buildSegment(i)\n}\n\n// Precompute \"lẻ\" prefixed versions for small remainders after scale words\n// LE_SEGMENTS[n] gives \"lẻ X\" for n in range 1-99\nconst LE_SEGMENTS = new Array(100)\nLE_SEGMENTS[0] = ''\nfor (let i = 1; i < 10; i++) {\n  // Use \"năm\" not \"lăm\" after lẻ\n  LE_SEGMENTS[i] = LE + ' ' + (i === 5 ? 'năm' : ONES[i])\n}\nfor (let i = 10; i < 100; i++) {\n  LE_SEGMENTS[i] = LE + ' ' + BELOW_100[i]\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Vietnamese words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Vietnamese words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 100 (direct lookup)\n  if (n < 100n) {\n    return BELOW_100[Number(n)]\n  }\n\n  // Fast path: numbers < 1000 (direct lookup)\n  if (n < 1000n) {\n    return SEGMENTS[Number(n)]\n  }\n\n  // Fast path: numbers < 1,000,000 (thousands)\n  if (n < 1_000_000n) {\n    const thousands = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    const thousandsWords = SEGMENTS[thousands] + ' ' + SCALES[1]\n\n    if (remainder === 0) {\n      return thousandsWords\n    }\n\n    // Check if remainder needs \"lẻ\" marker (< 100)\n    if (remainder < 100) {\n      return thousandsWords + ' ' + LE_SEGMENTS[remainder]\n    }\n\n    return thousandsWords + ' ' + SEGMENTS[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} Vietnamese words\n */\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  // Build segments of 3 digits from right to left\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  // Convert segments to words\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n    if (segment !== 0) {\n      const words = SEGMENTS[segment]\n      if (words) {\n        if (scaleIndex > 0) {\n          parts.push(words + ' ' + SCALES[scaleIndex])\n        } else {\n          parts.push(words)\n        }\n      }\n    }\n    scaleIndex--\n  }\n\n  // Join with \"lẻ\" logic for small remainders\n  const partsLen = parts.length\n  if (partsLen === 0) return ZERO\n  if (partsLen === 1) return parts[0]\n\n  // Check if final segment needs \"lẻ\" marker (remainder <= 99 after scale word)\n  const lastSegment = segments[segments.length - 1]\n  if (lastSegment > 0 && lastSegment <= 99) {\n    // Last segment is small (no hundreds), needs \"lẻ\" after scale word\n    let result = parts[0]\n    for (let i = 1; i < partsLen - 1; i++) {\n      result += ' ' + parts[i]\n    }\n    return result + ' ' + LE_SEGMENTS[lastSegment]\n  }\n\n  // Join with spaces\n  let result = parts[0]\n  for (let i = 1; i < partsLen; i++) {\n    result += ' ' + parts[i]\n  }\n  return result\n}\n\n/**\n * Converts decimal digits to Vietnamese words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Vietnamese 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 Vietnamese 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 Vietnamese 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)           // 'bốn mươi hai'\n * toWords(101)          // 'một trăm lẻ một'\n * toWords(1000000)      // 'một triệu'\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","ZERO","buildBelowHundred","n","ones","tens","Math","floor","tensWord","buildSegment","hundreds","remainder","result","BELOW_100","Array","i","SEGMENTS","LE_SEGMENTS","LE","integerToWords","Number","thousands","thousandsWords","numStr","toString","len","segments","remainderLen","pos","push","parts","scaleIndex","segment","words","partsLen","lastSegment","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/zh-Hans.js

@@ -1,3 +0,0 @@
-/*! n2words/zh-Hans v3.0.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 r=n.slice(0,t)||"0",i=n.slice(t+1);return{isNegative:e,integerPart:BigInt(r),decimalPart:i}}function t(n){const[e,t]=n.toLowerCase().split("e"),r=parseInt(t,10),i=e.indexOf("."),o=-1===i?e:e.slice(0,i)+e.slice(i+1),u=(-1===i?e.length:i)+r;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 r=["零","一","二","三","四","五","六","七","八","九"],i=["零","壹","贰","叁","肆","伍","陆","柒","捌","玖"],o="零";function u(n,e,t,r,i){if(0n===n)return"";let u="",s=!1;const c=n/1000n,f=n%1000n;c>0n&&(u=e[Number(c)]+i,s=f>0n&&f<100n);const l=f/100n,a=f%100n;l>0n?(s&&(u+=o),u+=e[Number(l)]+r,s=a>0n&&a<10n):c>0n&&a>0n&&(s=!0);const g=a/10n,d=a%10n;return g>0n?(s&&(u+=o),u+=e[Number(g)]+t,s=!1):(l>0n||c>0n)&&d>0n&&(s=!0),d>0n&&(s&&(u+=o),u+=e[Number(d)]),u}function s(n,e,t,r,i){if(0n===n)return"";if(n>=10000n){const s=n/10000n,c=n%10000n;let f=u(s,e,t,r,i)+"万";return c>0n&&((s%10n==0n||c<1000n)&&(f+=o),f+=u(c,e,t,r,i)),f}return u(n,e,t,r,i)}n.zhHans=function(n,u){u=function(n){if(void 0===n)return{};if(function(n){if(null===n||"object"!=typeof n)return!1;const e=Object.getPrototypeOf(n);return null===e||e===Object.prototype}(n))return n;throw new TypeError("Invalid options: expected plain object or undefined, got "+typeof n)}(u);const{isNegative:c,integerPart:f,decimalPart:l}=function(n){const r=typeof n;if("bigint"===r)return n<0n?{isNegative:!0,integerPart:-n}:{isNegative:!1,integerPart:n};if("number"===r){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"===r)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 ${r}`)}(n),a=!1!==u.formal;let g=c?"负":"";return g+=function(n,e=!0){if(0n===n)return o;const t=e?i:r,u=e?"拾":"十",c=e?"佰":"百",f=e?"仟":"千";if(n>=100000000n){const e=n%100000000n;let r=s(n/100000000n,t,u,c,f)+"亿";return e>0n&&(e<10000000n&&(r+=o),r+=s(e,t,u,c,f)),r}return s(n,t,u,c,f)}(f,a),l&&(g+="点"+function(n,e){let t="";for(let r=0;r<n.length;r++)t+=e[Number(n[r])];return t}(l,a?i:r)),g}},"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=zh-Hans.js.map

package/dist/languages/zh-Hans.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"zh-Hans.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/zh-Hans.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 * Simplified Chinese language converter - Functional Implementation\n *\n * Self-contained converter for Simplified Chinese.\n *\n * Key features:\n * - Myriad-based (万, 亿) grouping - 4 digits\n * - Formal (financial) vs common numerals\n * - Zero insertion for skipped positions\n * - No word separators (concatenated format)\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\nimport { validateOptions } from '../utils/validate-options.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\n// Common (everyday) numerals\nconst ONES_COMMON = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九']\nconst TEN_COMMON = '十'\nconst HUNDRED_COMMON = '百'\nconst THOUSAND_COMMON = '千'\n\n// Formal (financial) numerals - harder to alter/forge\nconst ONES_FORMAL = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖']\nconst TEN_FORMAL = '拾'\nconst HUNDRED_FORMAL = '佰'\nconst THOUSAND_FORMAL = '仟'\n\n// Scale words\nconst WAN_WORD = '万' // 10,000\nconst YI_WORD = '亿' // 100,000,000\n\nconst ZERO = '零'\nconst NEGATIVE = '负'\nconst DECIMAL_SEP = '点'\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Convert number below 万 (10,000) to words using direct string concatenation.\n */\nfunction convertBelowWan (value, ones, ten, hundred, thousand) {\n  if (value === 0n) return ''\n\n  let result = ''\n  let needsZero = false\n\n  // Thousands (千)\n  const thousandsVal = value / 1000n\n  const thousandsRemainder = value % 1000n\n  if (thousandsVal > 0n) {\n    result = ones[Number(thousandsVal)] + thousand\n    needsZero = thousandsRemainder > 0n && thousandsRemainder < 100n\n  }\n\n  // Hundreds (百)\n  const hundredsVal = thousandsRemainder / 100n\n  const hundredsRemainder = thousandsRemainder % 100n\n  if (hundredsVal > 0n) {\n    if (needsZero) result += ZERO\n    result += ones[Number(hundredsVal)] + hundred\n    needsZero = hundredsRemainder > 0n && hundredsRemainder < 10n\n  } else if (thousandsVal > 0n && hundredsRemainder > 0n) {\n    needsZero = true\n  }\n\n  // Tens (十)\n  const tensVal = hundredsRemainder / 10n\n  const onesVal = hundredsRemainder % 10n\n  if (tensVal > 0n) {\n    if (needsZero) result += ZERO\n    result += ones[Number(tensVal)] + ten\n    needsZero = false\n  } else if ((hundredsVal > 0n || thousandsVal > 0n) && onesVal > 0n) {\n    needsZero = true\n  }\n\n  // Ones\n  if (onesVal > 0n) {\n    if (needsZero) result += ZERO\n    result += ones[Number(onesVal)]\n  }\n\n  return result\n}\n\n/**\n * Convert number below 亿 (100 million) to words.\n */\nfunction convertBelowYi (value, ones, ten, hundred, thousand) {\n  if (value === 0n) return ''\n\n  if (value >= 10_000n) {\n    const wanValue = value / 10_000n\n    const wanRemainder = value % 10_000n\n\n    let result = convertBelowWan(wanValue, ones, ten, hundred, thousand) + WAN_WORD\n\n    if (wanRemainder > 0n) {\n      const needsZero = (wanValue % 10n === 0n) || (wanRemainder < 1000n)\n      if (needsZero) result += ZERO\n      result += convertBelowWan(wanRemainder, ones, ten, hundred, thousand)\n    }\n\n    return result\n  }\n\n  return convertBelowWan(value, ones, ten, hundred, thousand)\n}\n\nfunction integerToWords (n, formal = true) {\n  if (n === 0n) return ZERO\n\n  const ones = formal ? ONES_FORMAL : ONES_COMMON\n  const ten = formal ? TEN_FORMAL : TEN_COMMON\n  const hundred = formal ? HUNDRED_FORMAL : HUNDRED_COMMON\n  const thousand = formal ? THOUSAND_FORMAL : THOUSAND_COMMON\n\n  // Handle numbers >= 亿 (100 million)\n  if (n >= 100_000_000n) {\n    const yiValue = n / 100_000_000n\n    const yiRemainder = n % 100_000_000n\n\n    let result = convertBelowYi(yiValue, ones, ten, hundred, thousand) + YI_WORD\n\n    if (yiRemainder > 0n) {\n      if (yiRemainder < 10_000_000n) result += ZERO\n      result += convertBelowYi(yiRemainder, ones, ten, hundred, thousand)\n    }\n\n    return result\n  }\n\n  return convertBelowYi(n, ones, ten, hundred, thousand)\n}\n\n/**\n * Convert decimal digits to words using direct concatenation.\n */\nfunction decimalDigitsToWords (decimalString, ones) {\n  let result = ''\n  for (let i = 0; i < decimalString.length; i++) {\n    result += ones[Number(decimalString[i])]\n  }\n  return result\n}\n\n/**\n * Converts a numeric value to Simplified Chinese words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @param {Object} [options] - Optional configuration\n * @param {boolean} [options.formal=true] - Use formal/financial numerals\n * @returns {string} The number in Simplified Chinese words\n */\nfunction toWords (value, options) {\n  options = validateOptions(options)\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n  const formal = options.formal !== false // Default to true\n\n  let result = isNegative ? NEGATIVE : ''\n\n  result += integerToWords(integerPart, formal)\n\n  if (decimalPart) {\n    const ones = formal ? ONES_FORMAL : ONES_COMMON\n    result += DECIMAL_SEP + decimalDigitsToWords(decimalPart, ones)\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_COMMON","ONES_FORMAL","ZERO","convertBelowWan","value","ones","ten","hundred","thousand","result","needsZero","thousandsVal","thousandsRemainder","Number","hundredsVal","hundredsRemainder","tensVal","onesVal","convertBelowYi","wanValue","wanRemainder","options","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","formal","n","yiRemainder","integerToWords","decimalString","i","decimalDigitsToWords"],"mappings":"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"}

package/dist/languages/zh-Hant.js

@@ -1,3 +0,0 @@
-/*! n2words/zh-Hant v3.0.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 r=n.slice(0,t)||"0",i=n.slice(t+1);return{isNegative:e,integerPart:BigInt(r),decimalPart:i}}function t(n){const[e,t]=n.toLowerCase().split("e"),r=parseInt(t,10),i=e.indexOf("."),o=-1===i?e:e.slice(0,i)+e.slice(i+1),s=(-1===i?e.length:i)+r;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const r=["零","一","二","三","四","五","六","七","八","九"],i=["零","壹","貳","參","肆","伍","陸","柒","捌","玖"],o="零";n.zhHant=function(n,s){s=function(n){if(void 0===n)return{};if(function(n){if(null===n||"object"!=typeof n)return!1;const e=Object.getPrototypeOf(n);return null===e||e===Object.prototype}(n))return n;throw new TypeError("Invalid options: expected plain object or undefined, got "+typeof n)}(s);const{isNegative:u,integerPart:c,decimalPart:f}=function(n){const r=typeof n;if("bigint"===r)return n<0n?{isNegative:!0,integerPart:-n}:{isNegative:!1,integerPart:n};if("number"===r){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"===r)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 ${r}`)}(n),p=!1!==s.formal;let a="";return u&&(a="負"),a+=function(n,e=!0){if(0n===n)return o;const t=e?i:r,s=e?"拾":"十",u=e?"佰":"百",c=e?"仟":"千";function f(n){if(0n===n)return"";const e=[];let r=!1;const i=n/1000n,f=n%1000n;i>0n&&(e.push(t[Number(i)]+c),r=f>0n&&f<100n);const p=f/100n,a=f%100n;p>0n?(r&&(e.push(o),r=!1),e.push(t[Number(p)]+u),r=a>0n&&a<10n):i>0n&&a>0n&&(r=!0);const l=a/10n,g=a%10n;return l>0n?(r&&(e.push(o),r=!1),e.push(t[Number(l)]+s)):(p>0n||i>0n)&&g>0n&&(r=!0),g>0n&&(r&&e.push(o),e.push(t[Number(g)])),e.join("")}function p(n){if(0n===n)return"";const e=[];if(n>=10000n){const t=n/10000n,r=n%10000n;e.push(f(t)+"萬"),r>0n&&((t%10n==0n||r<1000n)&&e.push(o),e.push(f(r)))}else e.push(f(n));return e.join("")}const a=[];if(n>=100000000n){const e=n%100000000n,t=p(n/100000000n);a.push(t+"億"),e>0n&&(e<10000000n&&a.push(o),a.push(p(e)))}else a.push(p(n));return a.join("")}(c,p),f&&(a+="點"+function(n,e=!0){const t=e?i:r,o=[];for(const e of n)o.push(t[Number(e)]);return o}(f,p).join("")),a}},"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=zh-Hant.js.map

package/dist/languages/zh-Hant.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"zh-Hant.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/zh-Hant.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 * Traditional Chinese language converter - Functional Implementation\n *\n * Self-contained converter for Traditional Chinese.\n *\n * Key features:\n * - Myriad-based (萬, 億) grouping - 4 digits\n * - Formal (financial) vs common numerals\n * - Zero insertion for skipped positions\n * - No word separators (concatenated format)\n *\n * Differences from Simplified:\n * - Different character forms (e.g., 負/负, 點/点, 億/亿, 萬/万)\n * - Some formal numerals differ (參/叁, 貳/贰, 陸/陆)\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\nimport { validateOptions } from '../utils/validate-options.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\n// Common (everyday) numerals - Traditional forms\nconst ONES_COMMON = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九']\nconst TEN_COMMON = '十'\nconst HUNDRED_COMMON = '百'\nconst THOUSAND_COMMON = '千'\n\n// Formal (financial) numerals - Traditional forms\nconst ONES_FORMAL = ['零', '壹', '貳', '參', '肆', '伍', '陸', '柒', '捌', '玖']\nconst TEN_FORMAL = '拾'\nconst HUNDRED_FORMAL = '佰'\nconst THOUSAND_FORMAL = '仟'\n\n// Scale words - Traditional forms\nconst WAN_WORD = '萬' // 10,000\nconst YI_WORD = '億' // 100,000,000\n\nconst ZERO = '零'\nconst NEGATIVE = '負'\nconst DECIMAL_SEP = '點'\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n, formal = true) {\n  if (n === 0n) return ZERO\n\n  const ones = formal ? ONES_FORMAL : ONES_COMMON\n  const ten = formal ? TEN_FORMAL : TEN_COMMON\n  const hundred = formal ? HUNDRED_FORMAL : HUNDRED_COMMON\n  const thousand = formal ? THOUSAND_FORMAL : THOUSAND_COMMON\n\n  // Convert number below 萬 (10,000)\n  function convertBelowWan (value) {\n    if (value === 0n) return ''\n\n    const parts = []\n    let needsZero = false\n\n    // Thousands (千)\n    const thousandsVal = value / 1000n\n    const thousandsRemainder = value % 1000n\n    if (thousandsVal > 0n) {\n      parts.push(ones[Number(thousandsVal)] + thousand)\n      needsZero = thousandsRemainder > 0n && thousandsRemainder < 100n\n    }\n\n    // Hundreds (百)\n    const hundredsVal = thousandsRemainder / 100n\n    const hundredsRemainder = thousandsRemainder % 100n\n    if (hundredsVal > 0n) {\n      if (needsZero) {\n        parts.push(ZERO)\n        needsZero = false\n      }\n      parts.push(ones[Number(hundredsVal)] + hundred)\n      needsZero = hundredsRemainder > 0n && hundredsRemainder < 10n\n    } else if (thousandsVal > 0n && hundredsRemainder > 0n) {\n      needsZero = true\n    }\n\n    // Tens (十)\n    const tensVal = hundredsRemainder / 10n\n    const onesVal = hundredsRemainder % 10n\n    if (tensVal > 0n) {\n      if (needsZero) {\n        parts.push(ZERO)\n        needsZero = false\n      }\n      parts.push(ones[Number(tensVal)] + ten)\n    } else if ((hundredsVal > 0n || thousandsVal > 0n) && onesVal > 0n) {\n      needsZero = true\n    }\n\n    // Ones\n    if (onesVal > 0n) {\n      if (needsZero) {\n        parts.push(ZERO)\n      }\n      parts.push(ones[Number(onesVal)])\n    }\n\n    return parts.join('')\n  }\n\n  // Convert number below 億 (100 million)\n  function convertBelowYi (value) {\n    if (value === 0n) return ''\n\n    const parts = []\n\n    if (value >= 10_000n) {\n      const wanValue = value / 10_000n\n      const wanRemainder = value % 10_000n\n\n      parts.push(convertBelowWan(wanValue) + WAN_WORD)\n\n      if (wanRemainder > 0n) {\n        const wanEndsWithZero = wanValue % 10n === 0n\n        const remainderMissesThousands = wanRemainder < 1000n\n        const needsZero = wanEndsWithZero || remainderMissesThousands\n        if (needsZero) {\n          parts.push(ZERO)\n        }\n        parts.push(convertBelowWan(wanRemainder))\n      }\n    } else {\n      parts.push(convertBelowWan(value))\n    }\n\n    return parts.join('')\n  }\n\n  // Main conversion\n  const parts = []\n\n  if (n >= 100_000_000n) {\n    const yiValue = n / 100_000_000n\n    const yiRemainder = n % 100_000_000n\n\n    const yiWords = convertBelowYi(yiValue)\n    parts.push(yiWords + YI_WORD)\n\n    if (yiRemainder > 0n) {\n      const needsZero = yiRemainder < 10_000_000n\n      if (needsZero) {\n        parts.push(ZERO)\n      }\n      parts.push(convertBelowYi(yiRemainder))\n    }\n  } else {\n    parts.push(convertBelowYi(n))\n  }\n\n  return parts.join('')\n}\n\nfunction decimalDigitsToWords (decimalString, formal = true) {\n  const ones = formal ? ONES_FORMAL : ONES_COMMON\n  const words = []\n  for (const char of decimalString) {\n    words.push(ones[Number(char)])\n  }\n  return words\n}\n\n/**\n * Converts a numeric value to Traditional Chinese words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @param {Object} [options] - Optional configuration\n * @param {boolean} [options.formal=true] - Use formal/financial numerals\n * @returns {string} The number in Traditional Chinese words\n */\nfunction toWords (value, options) {\n  options = validateOptions(options)\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n  const formal = options.formal !== false // Default to true\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE\n  }\n\n  result += integerToWords(integerPart, formal)\n\n  if (decimalPart) {\n    result += DECIMAL_SEP + decimalDigitsToWords(decimalPart, formal).join('')\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_COMMON","ONES_FORMAL","ZERO","value","options","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","formal","result","n","ones","ten","hundred","thousand","convertBelowWan","parts","needsZero","thousandsVal","thousandsRemainder","push","hundredsVal","hundredsRemainder","tensVal","onesVal","join","convertBelowYi","wanValue","wanRemainder","yiRemainder","yiWords","integerToWords","decimalString","words","char","decimalDigitsToWords"],"mappings":"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"}