n2words 2.0.0 → 3.0.0

package/dist/languages/vi.js.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,3 @@
+/*! 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,3 @@
+/*! 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

@@ -0,0 +1 @@
+{"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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"}