n2words 3.1.0 → 5.0.0

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 * Self-contained module with its own input validation, ready for subpath exports.\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// Segment Building\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// ============================================================================\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\n  // Fast path: numbers < 1000\n  if (n < 1000n) {\n    return buildSegment(Number(n), sep)\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 = buildSegment(thousands, sep) + sep + THOUSAND\n    }\n\n    if (remainder > 0) {\n      result += sep + buildSegment(remainder, sep)\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\n  const numStr = n.toString()\n  const len = numStr.length\n\n  // Build segments of 3 digits from right to left\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  // Convert segments to words\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      const segmentWord = buildSegment(segment, sep)\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","integerToWords","options","sep","dropSpaces","Number","thousands","remainder","result","numStr","toString","len","segments","remainderLen","pos","scaleIndex","i","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.1.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),u=(-1===r?i.length:r)+n;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 n=["","один","два","три","чотири","п'ять","шiсть","сiм","вiсiм","дев'ять"],r=["","одна","двi","три","чотири","п'ять","шiсть","сiм","вiсiм","дев'ять"],o=["десять","одинадцять","дванадцять","тринадцять","чотирнадцять","п'ятнадцять","шiстнадцять","сiмнадцять","вiсiмнадцять","дев'ятнадцять"],u=["","","двадцять","тридцять","сорок","п'ятдесят","шiстдесят","сiмдесят","вiсiмдесят","дев'яносто"],s=["","сто","двiстi","триста","чотириста","п'ятсот","шiстсот","сiмсот","вiсiмсот","дев'ятсот"],f="нуль",c=[["тисяча","тисячi","тисяч"],["мiльйон","мiльйони","мiльйонiв"],["мiльярд","мiльярди","мiльярдiв"],["трильйон","трильйони","трильйонiв"],["квадрильйон","квадрильйони","квадрильйонiв"],["квiнтильйон","квiнтильйони","квiнтильйонiв"],["секстильйон","секстильйони","секстильйонiв"],["септильйон","септильйони","септильйонiв"],["октильйон","октильйони","октильйонiв"]];function l(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 a(e){if(0===e)return"";const i=e%10,t=Math.floor(e/10)%10,r=Math.floor(e/100),f=[];return r>0&&f.push(s[r]),t>1&&f.push(u[t]),1===t?f.push(o[i]):i>0&&f.push(n[i]),f.join(" ")}function g(e){if(0===e)return"";const i=e%10,t=Math.floor(e/10)%10,n=Math.floor(e/100),f=[];return n>0&&f.push(s[n]),t>1&&f.push(u[t]),1===t?f.push(o[i]):i>0&&f.push(r[i]),f.join(" ")}function p(e,i={}){return 0n===e?f:e<1000n?"feminine"===i.gender?g(Number(e)):a(Number(e)):function(e,i){const t=e.toString(),n=t.length,r=[],o=n%3;let u=0;for(o>0&&(r.push(Number(t.slice(0,o))),u=o);u<n;)r.push(Number(t.slice(u,u+3))),u+=3;const s=[];let f=r.length-1;for(let e=0;e<r.length;e++){const t=r[e];if(0!==t)if(0===f)s.push("feminine"===i.gender?g(t):a(t));else{const e=l(t,c[f-1]),i=1===f?g(t):a(t);s.push(i+" "+e)}f--}return s.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:o,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 s="";return r&&(s="мiнус "),s+=p(o,n),u&&(s+=" кома "+function(e,i){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+=f,n++;const r=e.slice(n);return r&&(t&&(t+=" "),t+=p(BigInt(r),i)),t}(u,n)),s}},"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 module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Three-form pluralization (one/few/many)\n * - Gender: thousands are feminine, millions+ are masculine\n * - Irregular hundreds\n * - Long scale naming\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\nimport { validateOptions } from '../utils/validate-options.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES_MASC = ['', 'один', 'два', 'три', 'чотири', 'п\\'ять', 'ш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// Segment Building\n// ============================================================================\n\nfunction pluralize (n, forms) {\n  const num = typeof n === 'bigint' ? Number(n) : n\n  const lastDigit = num % 10\n  const lastTwoDigits = num % 100\n\n  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {\n    return forms[2]\n  }\n\n  if (lastDigit === 1) return forms[0]\n  if (lastDigit >= 2 && lastDigit <= 4) return forms[1]\n  return forms[2]\n}\n\nfunction buildSegmentMasc (n) {\n  if (n === 0) return ''\n\n  const onesDigit = n % 10\n  const tensDigit = Math.floor(n / 10) % 10\n  const hundredsDigit = Math.floor(n / 100)\n\n  const parts = []\n\n  if (hundredsDigit > 0) {\n    parts.push(HUNDREDS[hundredsDigit])\n  }\n\n  if (tensDigit > 1) {\n    parts.push(TENS[tensDigit])\n  }\n\n  if (tensDigit === 1) {\n    parts.push(TEENS[onesDigit])\n  } else if (onesDigit > 0) {\n    parts.push(ONES_MASC[onesDigit])\n  }\n\n  return parts.join(' ')\n}\n\nfunction buildSegmentFem (n) {\n  if (n === 0) return ''\n\n  const onesDigit = n % 10\n  const tensDigit = Math.floor(n / 10) % 10\n  const hundredsDigit = Math.floor(n / 100)\n\n  const parts = []\n\n  if (hundredsDigit > 0) {\n    parts.push(HUNDREDS[hundredsDigit])\n  }\n\n  if (tensDigit > 1) {\n    parts.push(TENS[tensDigit])\n  }\n\n  if (tensDigit === 1) {\n    parts.push(TEENS[onesDigit])\n  } else if (onesDigit > 0) {\n    parts.push(ONES_FEM[onesDigit])\n  }\n\n  return parts.join(' ')\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n, options = {}) {\n  if (n === 0n) return ZERO\n\n  if (n < 1000n) {\n    return options.gender === 'feminine' ? buildSegmentFem(Number(n)) : buildSegmentMasc(Number(n))\n  }\n\n  return buildLargeNumberWords(n, options)\n}\n\nfunction buildLargeNumberWords (n, options) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      if (scaleIndex === 0) {\n        parts.push(options.gender === 'feminine' ? buildSegmentFem(segment) : buildSegmentMasc(segment))\n      } else {\n        const scaleForms = SCALE_FORMS[scaleIndex - 1]\n        const scaleWord = pluralize(segment, scaleForms)\n        // Thousands (scaleIndex=1) are feminine, others masculine\n        const isFeminine = scaleIndex === 1\n        const segmentWord = isFeminine ? buildSegmentFem(segment) : buildSegmentMasc(segment)\n        parts.push(segmentWord + ' ' + scaleWord)\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\nfunction decimalPartToWords (decimalPart, options) {\n  let result = ''\n  let i = 0\n\n  while (i < decimalPart.length && decimalPart[i] === '0') {\n    if (result) result += ' '\n    result += ZERO\n    i++\n  }\n\n  const remainder = decimalPart.slice(i)\n  if (remainder) {\n    if (result) result += ' '\n    result += integerToWords(BigInt(remainder), options)\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to 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","ONES_MASC","ONES_FEM","TEENS","TENS","HUNDREDS","ZERO","SCALE_FORMS","pluralize","n","forms","num","Number","lastDigit","lastTwoDigits","buildSegmentMasc","onesDigit","tensDigit","Math","floor","hundredsDigit","parts","push","join","buildSegmentFem","integerToWords","options","gender","numStr","toString","len","segments","remainderLen","pos","scaleIndex","i","segment","scaleWord","segmentWord","buildLargeNumberWords","value","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","result","NEGATIVE","remainder","decimalPartToWords"],"mappings":"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"}

package/dist/languages/ur.js

@@ -1,3 +0,0 @@
-/*! n2words/ur v3.1.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const r=e.slice(0,n)||"0",i=e.slice(n+1);return{isNegative:t,integerPart:BigInt(r),decimalPart:i}}function n(e){const[t,n]=e.toLowerCase().split("e"),r=parseInt(n,10),i=t.indexOf("."),s=-1===i?t:t.slice(0,i)+t.slice(i+1),o=(-1===i?t.length:i)+r;return o>=s.length?s+"0".repeat(o-s.length):o<=0?"0."+"0".repeat(-o)+s:s.slice(0,o)+"."+s.slice(o)}const r=["صفر","ایک","دو","تین","چار","پانچ","چھ","سات","آٹھ","نو","دس","گیارہ","بارہ","تیرہ","چودہ","پندرہ","سولہ","سترہ","اٹھارہ","انیس","بیس","اکیس","بائیس","تیئیس","چوبیس","پچیس","چھبیس","ستائیس","اٹھائیس","انتیس","تیس","اکتیس","بتیس","تینتیس","چونتیس","پینتیس","چھتیس","سینتیس","اڑتیس","انتالیس","چالیس","اکتالیس","بیالیس","تینتالیس","چوالیس","پینتالیس","چھالیس","سینتالیس","اڑتالیس","انچاس","پچاس","اکاون","باون","ترپن","چون","پچپن","چھپن","ستاون","اٹھاون","انسٹھ","ساٹھ","اکسٹھ","باسٹھ","ترسٹھ","چونسٹھ","پینسٹھ","چھیاسٹھ","سڑسٹھ","اڑسٹھ","انہتر","ستر","اکہتر","بہتر","تہتر","چوہتر","پچھتر","چھہتر","ستتر","اٹھہتر","اناسی","اسی","اکیاسی","بیاسی","تریاسی","چوراسی","پچاسی","چھیاسی","ستاسی","اٹھاسی","نواسی","نوے","اکانوے","بانوے","ترانوے","چورانوے","پچانوے","چھیانوے","ستانوے","اٹھانوے","ننانوے"],i=["","ہزار","لاکھ","کروڑ","ارب","کھرب","نیل","پدم","شنکھ"];function s(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 o(e){if(0n===e)return"صفر";if(e<1000n)return s(Number(e));const t=[];t.push(Number(e%1000n));let n=e/1000n;for(;n>0n;)t.push(Number(n%100n)),n/=100n;const o=[];for(let e=t.length-1;e>=0;e--){const n=t[e];0!==n&&(o.push(0===e?s(n):r[n]),e>0&&i[e]&&o.push(i[e]))}return o.join(" ")}e.ur=function(e){const{isNegative:r,integerPart:i,decimalPart:s}=function(e){const r=typeof e;if("bigint"===r)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===r){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===r)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${r}`)}(e);let u="";return r&&(u="منفی "),u+=o(i),s&&(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+=o(BigInt(r))),t}(s)),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 module with its own input validation, ready for subpath exports.\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// Segment Building\n// ============================================================================\n\n/**\n * Builds words for a 0-999 segment.\n */\nfunction buildSegment (n) {\n  if (n === 0) return ''\n  if (n < 100) return BELOW_HUNDRED[n]\n\n  const hundreds = Math.trunc(n / 100)\n  const remainder = n % 100\n\n  if (remainder === 0) {\n    return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED\n  }\n  return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED + ' ' + BELOW_HUNDRED[remainder]\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Urdu words.\n *\n * Uses BigInt modulo for segment extraction (faster than string slicing).\n * South Asian 3-2-2 grouping: first 3 digits, then groups of 2.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} 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 buildSegment(Number(n))\n  }\n\n  // Extract segments using BigInt modulo\n  const segments = []\n  segments.push(Number(n % 1000n))\n  let temp = n / 1000n\n\n  while (temp > 0n) {\n    segments.push(Number(temp % 100n))\n    temp = temp / 100n\n  }\n\n  // Build result string (process from most-significant to least)\n  const words = []\n  for (let i = segments.length - 1; i >= 0; i--) {\n    const segment = segments[i]\n    if (segment === 0) continue\n\n    if (i === 0) {\n      words.push(buildSegment(segment))\n    } else {\n      words.push(BELOW_HUNDRED[segment])\n    }\n\n    if (i > 0 && SCALE_WORDS[i]) {\n      words.push(SCALE_WORDS[i])\n    }\n  }\n\n  return words.join(' ')\n}\n\nfunction decimalPartToWords (decimalPart) {\n  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","buildSegment","n","hundreds","Math","trunc","remainder","integerToWords","Number","segments","push","temp","words","i","segment","join","value","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/vi.js

@@ -1,3 +0,0 @@
-/*! n2words/vi v3.1.0 | MIT License | github.com/forzagreen/n2words */
-var e,n;e=this,n=function(e){"use strict";function n(e){const n="-"===e[0];n&&(e=e.slice(1));const t=e.indexOf(".");if(-1===t)return{isNegative:n,integerPart:BigInt(e)};const i=e.slice(0,t)||"0",r=e.slice(t+1);return{isNegative:n,integerPart:BigInt(i),decimalPart:r}}function t(e){const[n,t]=e.toLowerCase().split("e"),i=parseInt(t,10),r=n.indexOf("."),o=-1===r?n:n.slice(0,r)+n.slice(r+1),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+=l(t))),r}function c(e){return 0===e?"":e<10?"lẻ "+(5===e?"năm":i[e]):"lẻ "+l(e)}function s(e){if(0n===e)return o;if(e<100n)return l(Number(e));if(e<1000n)return u(Number(e));if(e<1000000n){const n=Number(e/1000n),t=Number(e%1000n),i=u(n)+" "+r[1];return 0===t?i:t<100?i+" "+c(t):i+" "+u(t)}return function(e){const n=e.toString(),t=n.length,i=[],l=t%3;let s=0;for(l>0&&(i.push(Number(n.slice(0,l))),s=l);s<t;)i.push(Number(n.slice(s,s+3))),s+=3;const f=[];let g=i.length-1;for(let e=0;e<i.length;e++){const n=i[e];if(0!==n){const e=u(n);e&&f.push(g>0?e+" "+r[g]:e)}g--}const a=f.length;if(0===a)return o;if(1===a)return f[0];const m=i[i.length-1];if(m>0&&m<=99){let e=f[0];for(let n=1;n<a-1;n++)e+=" "+f[n];return e+" "+c(m)}let d=f[0];for(let e=1;e<a;e++)d+=" "+f[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+=s(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+=s(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\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Vietnamese-specific rules:\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// Segment Building\n// ============================================================================\n\n/**\n * Builds word for 0-99 with special forms (mốt, lăm).\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 */\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 += buildBelowHundred(remainder)\n    }\n  }\n\n  return result\n}\n\n/**\n * Builds \"lẻ\" prefixed word for small remainders (1-99) after scale words.\n */\nfunction buildLeSegment (n) {\n  if (n === 0) return ''\n  if (n < 10) {\n    // Use \"năm\" not \"lăm\" after lẻ\n    return LE + ' ' + (n === 5 ? 'năm' : ONES[n])\n  }\n  return LE + ' ' + buildBelowHundred(n)\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\n  if (n < 100n) {\n    return buildBelowHundred(Number(n))\n  }\n\n  // Fast path: numbers < 1000\n  if (n < 1000n) {\n    return buildSegment(Number(n))\n  }\n\n  // Fast path: numbers < 1,000,000 (thousands)\n  if (n < 1_000_000n) {\n    const thousands = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    const thousandsWords = buildSegment(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 + ' ' + buildLeSegment(remainder)\n    }\n\n    return thousandsWords + ' ' + buildSegment(remainder)\n  }\n\n  // For numbers >= 1,000,000, use scale decomposition\n  return buildLargeNumberWords(n)\n}\n\n/**\n * Builds words for numbers >= 1,000,000.\n *\n * @param {bigint} n - Number >= 1,000,000\n * @returns {string} 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 = buildSegment(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 + ' ' + buildLeSegment(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","buildLeSegment","LE","integerToWords","Number","thousands","thousandsWords","numStr","toString","len","segments","remainderLen","pos","push","parts","scaleIndex","i","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/yo.js

@@ -1,3 +0,0 @@
-/*! n2words/yo v3.1.0 | MIT License | github.com/forzagreen/n2words */
-var n,e;n=this,e=function(n){"use strict";function e(n){const e="-"===n[0];e&&(n=n.slice(1));const t=n.indexOf(".");if(-1===t)return{isNegative:e,integerPart:BigInt(n)};const 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),l=(-1===i?e.length:i)+r;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 r=["","ọ̀kan","èjì","ẹ̀ta","ẹ̀rin","àrùn","ẹ̀fà","èje","ẹ̀jọ","ẹ̀sán","ẹ̀wá"],i=["","ọ̀kànlá","èjìlá","ẹ̀talá","ẹ̀rinlá"],o=["àrùndínlógún","ẹ̀rìndínlógún","ẹ̀tadínlógún","èjìdínlógún","ọ̀kàndínlógún"],l={20:"ogún",30:"ọgbọ̀n",40:"ogójì",50:"àádọ́ta",60:"ogóta",70:"àádọ́rin",80:"ogórin",90:"àádọ́rùn",100:"ọgọ́rùn"},u={20:"lógún",30:"lọgbọ̀n",40:"lógójì",50:"láàádọ́ta",60:"lógóta",70:"láàádọ́rin",80:"lógórin",90:"láàádọ́rùn",100:"lọ́gọ́rùn"},s={20:"dínlógún",30:"dínlọgbọ̀n",40:"dínlógójì",50:"dínláàádọ́ta",60:"dínlógóta",70:"dínláàádọ́rin",80:"dínlógórin",90:"dínláàádọ́rùn",100:"dínlọ́gọ́rùn"},g="ọgọ́rùn",a="igba",f="irinwó",d="ẹgbẹ̀rún",c="mílíọ̀nù",b="ó lé";function m(n){if(0===n)return"";if(n<=10)return r[n];if(n<=14)return i[n-10];if(n<=19)return o[n-15];if(n%10==0)return l[n];const e=10*Math.floor(n/10),t=n%10;return t<=4?r[t]+" lé "+u[e]:r[10-t]+s[e+10]}function N(n){if(n<100)return m(n);const e=Math.floor(n/100),t=n%100;let i;return 2===e&&0===t?a:4===e&&0===t?f:(i=1===e?g:2===e?a:4===e?f:r[e]+" "+g,t>0&&(i+=" ó lé "+m(t)),i)}function p(n){if(0n===n)return"òdo";if(n<100n)return m(Number(n));if(n<1000n)return N(Number(n));const e=[];let t=n;if(t>=1000000n){const n=t/1000000n;t%=1000000n,e.push(1n===n?c+" kan":c+" "+p(n))}if(t>=1000n){const n=t/1000n;t%=1000n,e.push(1n===n?d+" kan":10n===n?"ẹgbàárùn":20n===n?"ọ̀kẹ́":n<100n?d+" "+m(Number(n)):d+" "+N(Number(n)))}return t>0n&&e.push(t<100n?e.length>0?b+" "+m(Number(t)):m(Number(t)):e.length>0?b+" "+N(Number(t)):N(Number(t))),e.join(", ")}n.yo=function(n){const{isNegative:i,integerPart:o,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);let u="";return i&&(u="àìní "),u+=p(o),l&&(u+=" àmì "+function(n){const e=[];for(const t of n){const n=parseInt(t,10);e.push(0===n?"òdo":r[n])}return e.join(" ")}(l)),u}},"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((n="undefined"!=typeof globalThis?globalThis:n||self).n2words=n.n2words||{});
-//# sourceMappingURL=yo.js.map

package/dist/languages/yo.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"yo.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/yo.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 * Yoruba language converter - Functional Implementation\n *\n * A number-to-words converter for Yoruba (yo), a Niger-Congo language\n * spoken by ~45 million people in Nigeria, Benin, and Togo.\n *\n * Yoruba uses a complex vigesimal (base-20) system with:\n * - Additive patterns: 1-4 added to decade (lé = \"plus\")\n * - Subtractive patterns: 5-9 subtracted from next decade (dín = \"minus\")\n * - Odd decades (30,50,70,90) formed by subtracting 10 from next even decade\n * - Even decades (20,40,60,80,100) are multiples of 20\n *\n * Examples:\n * - 21 = ọ̀kan lé lógún (1 + 20)\n * - 15 = àrùndínlógún (20 - 5)\n * - 50 = àádọ́ta (60 - 10)\n * - 45 = àrùndínláàádọ́ta (50 - 5)\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\n// Basic numbers 1-10\nconst ONES = [\n  '',\n  'ọ̀kan', // 1\n  'èjì', // 2\n  'ẹ̀ta', // 3\n  'ẹ̀rin', // 4\n  'àrùn', // 5\n  'ẹ̀fà', // 6\n  'èje', // 7\n  'ẹ̀jọ', // 8\n  'ẹ̀sán', // 9\n  'ẹ̀wá' // 10\n]\n\n// Numbers 11-14 (additive: X + 10, using \"lá\")\nconst TEENS_ADD = [\n  '',\n  'ọ̀kànlá', // 11 = 1 + 10\n  'èjìlá', // 12 = 2 + 10\n  'ẹ̀talá', // 13 = 3 + 10\n  'ẹ̀rinlá' // 14 = 4 + 10\n]\n\n// Numbers 15-19 (subtractive: 20 - X, using \"dín\")\nconst TEENS_SUB = [\n  'àrùndínlógún', // 15 = 20 - 5\n  'ẹ̀rìndínlógún', // 16 = 20 - 4\n  'ẹ̀tadínlógún', // 17 = 20 - 3\n  'èjìdínlógún', // 18 = 20 - 2\n  'ọ̀kàndínlógún' // 19 = 20 - 1\n]\n\n// Decades (base-20 structure)\n// Even decades are multiples of 20\n// Odd decades subtract 10 from next even decade\nconst DECADES = {\n  20: 'ogún', // 20 = 20 × 1\n  30: 'ọgbọ̀n', // 30 = 20 + 10 (special word)\n  40: 'ogójì', // 40 = 20 × 2\n  50: 'àádọ́ta', // 50 = 60 - 10\n  60: 'ogóta', // 60 = 20 × 3\n  70: 'àádọ́rin', // 70 = 80 - 10\n  80: 'ogórin', // 80 = 20 × 4\n  90: 'àádọ́rùn', // 90 = 100 - 10\n  100: 'ọgọ́rùn' // 100 = 20 × 5\n}\n\n// Prefixes for adding to decades (lé lógún, lé lọgbọ̀n, etc.)\nconst DECADE_ADD_SUFFIX = {\n  20: 'lógún',\n  30: 'lọgbọ̀n',\n  40: 'lógójì',\n  50: 'láàádọ́ta',\n  60: 'lógóta',\n  70: 'láàádọ́rin',\n  80: 'lógórin',\n  90: 'láàádọ́rùn',\n  100: 'lọ́gọ́rùn'\n}\n\n// Prefixes for subtracting from decades (dín lógójì, etc.)\nconst DECADE_SUB_SUFFIX = {\n  20: 'dínlógún',\n  30: 'dínlọgbọ̀n',\n  40: 'dínlógójì',\n  50: 'dínláàádọ́ta',\n  60: 'dínlógóta',\n  70: 'dínláàádọ́rin',\n  80: 'dínlógórin',\n  90: 'dínláàádọ́rùn',\n  100: 'dínlọ́gọ́rùn'\n}\n\n// Scale words\nconst HUNDRED = 'ọgọ́rùn'\nconst TWO_HUNDRED = 'igba' // 200 (special word, historically 200 cowries)\nconst FOUR_HUNDRED = 'irinwó' // 400 (20 × 20)\nconst THOUSAND = 'ẹgbẹ̀rún' // 1000\nconst TEN_THOUSAND = 'ẹgbàárùn' // 10,000 (special)\nconst TWENTY_THOUSAND = 'ọ̀kẹ́' // 20,000 (bag of cowries)\nconst MILLION = 'mílíọ̀nù' // million (loanword)\n\nconst ZERO = 'òdo'\nconst NEGATIVE = 'àìní'\nconst DECIMAL_SEP = 'àmì'\nconst AND = 'ó lé' // \"and\" / \"plus\" connector\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds word for numbers 0-99\n */\nfunction buildUnder100 (n) {\n  if (n === 0) return ''\n  if (n <= 10) return ONES[n]\n\n  // 11-14: additive from 10\n  if (n <= 14) return TEENS_ADD[n - 10]\n\n  // 15-19: subtractive from 20\n  if (n <= 19) return TEENS_SUB[n - 15]\n\n  // Exact decades\n  if (n % 10 === 0) return DECADES[n]\n\n  const decade = Math.floor(n / 10) * 10\n  const unit = n % 10\n\n  // 1-4 are added to current decade (21 = 1 + 20, not 1 + 30)\n  if (unit <= 4) {\n    return ONES[unit] + ' lé ' + DECADE_ADD_SUFFIX[decade]\n  }\n\n  // 5-9 are subtracted from next decade\n  const nextDecade = decade + 10\n  const subtractAmount = 10 - unit\n  return ONES[subtractAmount] + DECADE_SUB_SUFFIX[nextDecade]\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts hundreds (100-999)\n */\nfunction convertHundreds (n) {\n  if (n < 100) return buildUnder100(n)\n\n  const hundreds = Math.floor(n / 100)\n  const remainder = n % 100\n\n  let result\n\n  // Special cases for 200 and 400\n  if (hundreds === 2 && remainder === 0) {\n    return TWO_HUNDRED\n  }\n  if (hundreds === 4 && remainder === 0) {\n    return FOUR_HUNDRED\n  }\n\n  // Build hundreds\n  if (hundreds === 1) {\n    result = HUNDRED\n  } else if (hundreds === 2) {\n    result = TWO_HUNDRED\n  } else if (hundreds === 4) {\n    result = FOUR_HUNDRED\n  } else {\n    // Other hundreds: X ọgọ́rùn\n    result = ONES[hundreds] + ' ' + HUNDRED\n  }\n\n  if (remainder > 0) {\n    result += ' ' + AND + ' ' + buildUnder100(remainder)\n  }\n\n  return result\n}\n\n/**\n * Converts a non-negative integer to Yoruba words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Yoruba words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 100\n  if (n < 100n) {\n    return buildUnder100(Number(n))\n  }\n\n  // Numbers < 1000\n  if (n < 1000n) {\n    return convertHundreds(Number(n))\n  }\n\n  // Build from segments\n  const parts = []\n  let remaining = n\n\n  // Millions\n  if (remaining >= 1_000_000n) {\n    const millions = remaining / 1_000_000n\n    remaining = remaining % 1_000_000n\n    if (millions === 1n) {\n      parts.push(MILLION + ' kan')\n    } else {\n      parts.push(MILLION + ' ' + integerToWords(millions))\n    }\n  }\n\n  // Thousands\n  if (remaining >= 1000n) {\n    const thousands = remaining / 1000n\n    remaining = remaining % 1000n\n\n    if (thousands === 1n) {\n      parts.push(THOUSAND + ' kan')\n    } else if (thousands === 10n) {\n      parts.push(TEN_THOUSAND)\n    } else if (thousands === 20n) {\n      parts.push(TWENTY_THOUSAND)\n    } else if (thousands < 100n) {\n      parts.push(THOUSAND + ' ' + buildUnder100(Number(thousands)))\n    } else {\n      parts.push(THOUSAND + ' ' + convertHundreds(Number(thousands)))\n    }\n  }\n\n  // Hundreds and below\n  if (remaining > 0n) {\n    if (remaining < 100n) {\n      if (parts.length > 0) {\n        parts.push(AND + ' ' + buildUnder100(Number(remaining)))\n      } else {\n        parts.push(buildUnder100(Number(remaining)))\n      }\n    } else {\n      if (parts.length > 0) {\n        parts.push(AND + ' ' + convertHundreds(Number(remaining)))\n      } else {\n        parts.push(convertHundreds(Number(remaining)))\n      }\n    }\n  }\n\n  return parts.join(', ')\n}\n\n/**\n * Converts decimal digits to Yoruba words.\n *\n * @param {string} decimalPart - Decimal digits\n * @returns {string} Yoruba words for decimal\n */\nfunction decimalPartToWords (decimalPart) {\n  const parts = []\n\n  for (const digit of decimalPart) {\n    const d = parseInt(digit, 10)\n    parts.push(d === 0 ? ZERO : ONES[d])\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts a numeric value to Yoruba words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Yoruba 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\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","TEENS_ADD","TEENS_SUB","DECADES","DECADE_ADD_SUFFIX","DECADE_SUB_SUFFIX","HUNDRED","TWO_HUNDRED","FOUR_HUNDRED","THOUSAND","MILLION","AND","buildUnder100","n","decade","Math","floor","unit","convertHundreds","hundreds","remainder","result","integerToWords","Number","parts","remaining","millions","push","thousands","join","value","type","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","digit","d","decimalPartToWords"],"mappings":"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"}

package/dist/languages/zh-Hans.js

@@ -1,3 +0,0 @@
-/*! n2words/zh-Hans v3.1.0 | MIT License | github.com/forzagreen/n2words */
-var n,e;n=this,e=function(n){"use strict";function e(n){const e="-"===n[0];e&&(n=n.slice(1));const t=n.indexOf(".");if(-1===t)return{isNegative:e,integerPart:BigInt(n)};const 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.1.0 | MIT License | github.com/forzagreen/n2words */
-var n,e;n=this,e=function(n){"use strict";function e(n){const e="-"===n[0];e&&(n=n.slice(1));const t=n.indexOf(".");if(-1===t)return{isNegative:e,integerPart:BigInt(n)};const 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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"}