n2words 3.0.0 → 3.1.0

package/dist/languages/lt.js.map

@@ -1 +1 @@
-{"version":3,"file":"lt.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/lt.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 * Lithuanian language converter - Functional Implementation\n *\n * A performance-optimized number-to-words converter using precomputed lookup tables.\n *\n * Key features:\n * - Three-form pluralization (singular/plural/genitive)\n * - Gender agreement (masculine/feminine for numbers < 1000)\n * - Two-form hundreds (šimtas/šimtai)\n * - Long 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_MASC = ['', 'vienas', 'du', 'trys', 'keturi', 'penki', 'šeši', 'septyni', 'aštuoni', 'devyni']\nconst ONES_FEM = ['', 'viena', 'dvi', 'trys', 'keturios', 'penkios', 'šešios', 'septynios', 'aštuonios', 'devynios']\n\nconst TEENS = ['dešimt', 'vienuolika', 'dvylika', 'trylika', 'keturiolika', 'penkiolika', 'šešiolika', 'septyniolika', 'aštuoniolika', 'devyniolika']\nconst TENS = ['', '', 'dvidešimt', 'trisdešimt', 'keturiasdešimt', 'penkiasdešimt', 'šešiasdešimt', 'septyniasdešimt', 'aštuoniasdešimt', 'devyniasdešimt']\n\n// Hundreds: šimtas (singular), šimtai (plural)\nconst HUNDRED_SINGULAR = 'šimtas'\nconst HUNDRED_PLURAL = 'šimtai'\n\nconst ZERO = 'nulis'\nconst NEGATIVE = 'minus'\nconst DECIMAL_SEP = 'kablelis'\n\n// Scale words: [singular, plural, genitive]\nconst SCALE_FORMS = [\n  ['tūkstantis', 'tūkstančiai', 'tūkstančių'],\n  ['milijonas', 'milijonai', 'milijonų'],\n  ['milijardas', 'milijardai', 'milijardų'],\n  ['trilijonas', 'trilijonai', 'trilijonų'],\n  ['kvadrilijonas', 'kvadrilijonai', 'kvadrilijonų'],\n  ['kvintilijonas', 'kvintilijonai', 'kvintilijonų'],\n  ['sikstilijonas', 'sikstilijonai', 'sikstilijonų'],\n  ['septilijonas', 'septilijonai', 'septilijonų'],\n  ['oktilijonas', 'oktilijonai', 'oktilijonų']\n]\n\n// ============================================================================\n// Precomputed Lookup Tables (built once at module load)\n// ============================================================================\n\n/**\n * Builds segment word for 0-999 (masculine form).\n */\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds - Lithuanian always includes the numeral\n  if (hundreds > 0) {\n    parts.push(ONES_MASC[hundreds])\n    parts.push(hundreds === 1 ? HUNDRED_SINGULAR : HUNDRED_PLURAL)\n  }\n\n  // Tens\n  if (tens > 1) {\n    parts.push(TENS[tens])\n  }\n\n  // Teens or ones\n  if (tens === 1) {\n    parts.push(TEENS[ones])\n  } else if (ones > 0) {\n    parts.push(ONES_MASC[ones])\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Builds segment word for 0-999 (feminine form - only differs in ones).\n */\nfunction buildSegmentFeminine (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds - always masculine\n  if (hundreds > 0) {\n    parts.push(ONES_MASC[hundreds])\n    parts.push(hundreds === 1 ? HUNDRED_SINGULAR : HUNDRED_PLURAL)\n  }\n\n  // Tens\n  if (tens > 1) {\n    parts.push(TENS[tens])\n  }\n\n  // Teens or ones - feminine for ones only\n  if (tens === 1) {\n    parts.push(TEENS[ones])\n  } else if (ones > 0) {\n    parts.push(ONES_FEM[ones])\n  }\n\n  return parts.join(' ')\n}\n\n// Precompute all 1000 segment words (0-999)\nconst SEGMENTS_MASC = new Array(1000)\nconst SEGMENTS_FEM = new Array(1000)\n\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS_MASC[i] = buildSegment(i)\n  SEGMENTS_FEM[i] = buildSegmentFeminine(i)\n}\n\n// ============================================================================\n// Pluralization\n// ============================================================================\n\n/**\n * Lithuanian pluralization rules.\n * - Singular: ends in 1 (except 11)\n * - Plural: ends in 2-9 (except 12-19)\n * - Genitive: 0, 10-19, or ends in 0\n *\n * @param {number} n - The segment value\n * @param {string[]} forms - [singular, plural, genitive]\n * @returns {string} The appropriate form\n */\nfunction pluralize (n, forms) {\n  if (n === 0) return forms[2]\n\n  const lastDigit = n % 10\n  const lastTwoDigits = n % 100\n\n  // 10-19 always use genitive\n  if (lastTwoDigits >= 10 && lastTwoDigits <= 19) {\n    return forms[2]\n  }\n\n  // Ends in 0 → genitive\n  if (lastDigit === 0) {\n    return forms[2]\n  }\n\n  // Ends in 1 → singular\n  if (lastDigit === 1) {\n    return forms[0]\n  }\n\n  // Ends in 2-9 → plural\n  return forms[1]\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Lithuanian words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @param {Object} options - Conversion options\n * @returns {string} Lithuanian words\n */\nfunction integerToWords (n, options = {}) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000 (direct lookup)\n  if (n < 1000n) {\n    const segments = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC\n    return segments[Number(n)]\n  }\n\n  // For numbers >= 1000, feminine only applies to final segment if < 1000\n  // But the fixture shows feminine NOT applying for n >= 1000\n  // So we use masculine for all segments when n >= 1000\n  return buildLargeNumberWords(n, options)\n}\n\n/**\n * Builds words for numbers >= 1000.\n *\n * @param {bigint} n - Number >= 1000\n * @param {Object} options - Conversion options\n * @returns {string} Lithuanian words\n */\nfunction buildLargeNumberWords (n, options) {\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 = SEGMENTS_MASC[segment]\n\n      if (scaleIndex === 0) {\n        // Units segment - use masculine (feminine doesn't apply when n >= 1000)\n        parts.push(segmentWord)\n      } else {\n        // Segment with scale word\n        const scaleForms = SCALE_FORMS[scaleIndex - 1]\n        const scaleWord = pluralize(segment, scaleForms)\n        parts.push(segmentWord + ' ' + scaleWord)\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts decimal digits to Lithuanian words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @param {Object} options - Conversion options\n * @returns {string} Lithuanian words for decimal part\n */\nfunction decimalPartToWords (decimalPart, options) {\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), options)\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Lithuanian words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @param {Object} [options] - Conversion options\n * @param {string} [options.gender='masculine'] - Gender for numbers < 1000\n * @returns {string} The number in Lithuanian 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)                          // 'keturiasdešimt du'\n * toWords(1, { gender: 'feminine' })   // 'viena'\n * toWords(1000000)                     // 'vienas milijonas'\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// Public API\n// ============================================================================\n\nexport { toWords }\n","import { isPlainObject } from './is-plain-object.js'\n\n/**\n * Validates and normalizes the options parameter.\n *\n * @param {*} options The options value to validate\n * @returns {Object} A valid options object (empty object if undefined)\n * @throws {TypeError} If options is not undefined or a plain object\n */\nexport function validateOptions (options) {\n  if (options === undefined) return {}\n  if (isPlainObject(options)) return options\n  throw new TypeError(\n    `Invalid options: expected plain object or undefined, got ${typeof options}`\n  )\n}\n","/**\n * Checks if a value is a plain object (not null, array, or other object types).\n *\n * A plain object is one created by:\n * - Object literal: `{}`\n * - Object.create(null): null-prototype object\n *\n * This excludes arrays, class instances, Map, Set, and other object types.\n *\n * @param {*} value Value to check\n * @returns {boolean} True if value is a plain object\n */\nexport function isPlainObject (value) {\n  if (value === null || typeof value !== 'object') return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === null || proto === Object.prototype\n}\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES_MASC","ONES_FEM","TEENS","TENS","HUNDRED_SINGULAR","HUNDRED_PLURAL","ZERO","SCALE_FORMS","buildSegment","n","ones","tens","Math","floor","hundreds","parts","push","join","buildSegmentFeminine","SEGMENTS_MASC","Array","SEGMENTS_FEM","i","pluralize","forms","lastDigit","lastTwoDigits","integerToWords","options","gender","Number","numStr","toString","len","segments","remainderLen","pos","scaleIndex","segment","segmentWord","scaleWord","buildLargeNumberWords","value","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","result","NEGATIVE","remainder","decimalPartToWords"],"mappings":"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"}
+{"version":3,"file":"lt.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/lt.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 * Lithuanian 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 (singular/plural/genitive)\n * - Gender agreement (masculine/feminine for numbers < 1000)\n * - Two-form hundreds (šimtas/šimtai)\n * - Long 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_MASC = ['', 'vienas', 'du', 'trys', 'keturi', 'penki', 'šeši', 'septyni', 'aštuoni', 'devyni']\nconst ONES_FEM = ['', 'viena', 'dvi', 'trys', 'keturios', 'penkios', 'šešios', 'septynios', 'aštuonios', 'devynios']\n\nconst TEENS = ['dešimt', 'vienuolika', 'dvylika', 'trylika', 'keturiolika', 'penkiolika', 'šešiolika', 'septyniolika', 'aštuoniolika', 'devyniolika']\nconst TENS = ['', '', 'dvidešimt', 'trisdešimt', 'keturiasdešimt', 'penkiasdešimt', 'šešiasdešimt', 'septyniasdešimt', 'aštuoniasdešimt', 'devyniasdešimt']\n\n// Hundreds: šimtas (singular), šimtai (plural)\nconst HUNDRED_SINGULAR = 'šimtas'\nconst HUNDRED_PLURAL = 'šimtai'\n\nconst ZERO = 'nulis'\nconst NEGATIVE = 'minus'\nconst DECIMAL_SEP = 'kablelis'\n\n// Scale words: [singular, plural, genitive]\nconst SCALE_FORMS = [\n  ['tūkstantis', 'tūkstančiai', 'tūkstančių'],\n  ['milijonas', 'milijonai', 'milijonų'],\n  ['milijardas', 'milijardai', 'milijardų'],\n  ['trilijonas', 'trilijonai', 'trilijonų'],\n  ['kvadrilijonas', 'kvadrilijonai', 'kvadrilijonų'],\n  ['kvintilijonas', 'kvintilijonai', 'kvintilijonų'],\n  ['sikstilijonas', 'sikstilijonai', 'sikstilijonų'],\n  ['septilijonas', 'septilijonai', 'septilijonų'],\n  ['oktilijonas', 'oktilijonai', 'oktilijonų']\n]\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for 0-999 (masculine form).\n */\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds - Lithuanian always includes the numeral\n  if (hundreds > 0) {\n    parts.push(ONES_MASC[hundreds])\n    parts.push(hundreds === 1 ? HUNDRED_SINGULAR : HUNDRED_PLURAL)\n  }\n\n  // Tens\n  if (tens > 1) {\n    parts.push(TENS[tens])\n  }\n\n  // Teens or ones\n  if (tens === 1) {\n    parts.push(TEENS[ones])\n  } else if (ones > 0) {\n    parts.push(ONES_MASC[ones])\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Builds segment word for 0-999 (feminine form - only differs in ones).\n */\nfunction buildSegmentFeminine (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds - always masculine\n  if (hundreds > 0) {\n    parts.push(ONES_MASC[hundreds])\n    parts.push(hundreds === 1 ? HUNDRED_SINGULAR : HUNDRED_PLURAL)\n  }\n\n  // Tens\n  if (tens > 1) {\n    parts.push(TENS[tens])\n  }\n\n  // Teens or ones - feminine for ones only\n  if (tens === 1) {\n    parts.push(TEENS[ones])\n  } else if (ones > 0) {\n    parts.push(ONES_FEM[ones])\n  }\n\n  return parts.join(' ')\n}\n\n// ============================================================================\n// Pluralization\n// ============================================================================\n\n/**\n * Lithuanian pluralization rules.\n * - Singular: ends in 1 (except 11)\n * - Plural: ends in 2-9 (except 12-19)\n * - Genitive: 0, 10-19, or ends in 0\n *\n * @param {number} n - The segment value\n * @param {string[]} forms - [singular, plural, genitive]\n * @returns {string} The appropriate form\n */\nfunction pluralize (n, forms) {\n  if (n === 0) return forms[2]\n\n  const lastDigit = n % 10\n  const lastTwoDigits = n % 100\n\n  // 10-19 always use genitive\n  if (lastTwoDigits >= 10 && lastTwoDigits <= 19) {\n    return forms[2]\n  }\n\n  // Ends in 0 → genitive\n  if (lastDigit === 0) {\n    return forms[2]\n  }\n\n  // Ends in 1 → singular\n  if (lastDigit === 1) {\n    return forms[0]\n  }\n\n  // Ends in 2-9 → plural\n  return forms[1]\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Lithuanian words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @param {Object} options - Conversion options\n * @returns {string} Lithuanian words\n */\nfunction integerToWords (n, options = {}) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000\n  if (n < 1000n) {\n    const num = Number(n)\n    return options.gender === 'feminine' ? buildSegmentFeminine(num) : buildSegment(num)\n  }\n\n  // For numbers >= 1000, feminine only applies to final segment if < 1000\n  // But the fixture shows feminine NOT applying for n >= 1000\n  // So we use masculine for all segments when n >= 1000\n  return buildLargeNumberWords(n, options)\n}\n\n/**\n * Builds words for numbers >= 1000.\n *\n * @param {bigint} n - Number >= 1000\n * @param {Object} options - Conversion options\n * @returns {string} Lithuanian words\n */\nfunction buildLargeNumberWords (n, options) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  // Build segments of 3 digits from right to left\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  // Convert segments to words\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      const segmentWord = buildSegment(segment)\n\n      if (scaleIndex === 0) {\n        // Units segment - use masculine (feminine doesn't apply when n >= 1000)\n        parts.push(segmentWord)\n      } else {\n        // Segment with scale word\n        const scaleForms = SCALE_FORMS[scaleIndex - 1]\n        const scaleWord = pluralize(segment, scaleForms)\n        parts.push(segmentWord + ' ' + scaleWord)\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts decimal digits to Lithuanian words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @param {Object} options - Conversion options\n * @returns {string} Lithuanian words for decimal part\n */\nfunction decimalPartToWords (decimalPart, options) {\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), options)\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Lithuanian words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @param {Object} [options] - Conversion options\n * @param {string} [options.gender='masculine'] - Gender for numbers < 1000\n * @returns {string} The number in Lithuanian 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)                          // 'keturiasdešimt du'\n * toWords(1, { gender: 'feminine' })   // 'viena'\n * toWords(1000000)                     // 'vienas milijonas'\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// Public API\n// ============================================================================\n\nexport { toWords }\n","import { isPlainObject } from './is-plain-object.js'\n\n/**\n * Validates and normalizes the options parameter.\n *\n * @param {*} options The options value to validate\n * @returns {Object} A valid options object (empty object if undefined)\n * @throws {TypeError} If options is not undefined or a plain object\n */\nexport function validateOptions (options) {\n  if (options === undefined) return {}\n  if (isPlainObject(options)) return options\n  throw new TypeError(\n    `Invalid options: expected plain object or undefined, got ${typeof options}`\n  )\n}\n","/**\n * Checks if a value is a plain object (not null, array, or other object types).\n *\n * A plain object is one created by:\n * - Object literal: `{}`\n * - Object.create(null): null-prototype object\n *\n * This excludes arrays, class instances, Map, Set, and other object types.\n *\n * @param {*} value Value to check\n * @returns {boolean} True if value is a plain object\n */\nexport function isPlainObject (value) {\n  if (value === null || typeof value !== 'object') return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === null || proto === Object.prototype\n}\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES_MASC","ONES_FEM","TEENS","TENS","HUNDRED_SINGULAR","HUNDRED_PLURAL","ZERO","SCALE_FORMS","buildSegment","n","ones","tens","Math","floor","hundreds","parts","push","join","pluralize","forms","lastDigit","lastTwoDigits","integerToWords","options","num","Number","gender","buildSegmentFeminine","numStr","toString","len","segments","remainderLen","pos","scaleIndex","i","segment","segmentWord","scaleWord","buildLargeNumberWords","value","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","result","NEGATIVE","remainder","decimalPartToWords"],"mappings":"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"}

package/dist/languages/lv.js

@@ -1,3 +1,3 @@
-/*! n2words/lv v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var t,e;t=this,e=function(t){"use strict";function e(t){const e="-"===t[0];e&&(t=t.slice(1));const i=t.indexOf(".");if(-1===i)return{isNegative:e,integerPart:BigInt(t)};const n=t.slice(0,i)||"0",s=t.slice(i+1);return{isNegative:e,integerPart:BigInt(n),decimalPart:s}}function i(t){const[e,i]=t.toLowerCase().split("e"),n=parseInt(i,10),s=e.indexOf("."),r=-1===s?e:e.slice(0,s)+e.slice(s+1),o=(-1===s?e.length:s)+n;return o>=r.length?r+"0".repeat(o-r.length):o<=0?"0."+"0".repeat(-o)+r:r.slice(0,o)+"."+r.slice(o)}const n=["","viens","divi","trīs","četri","pieci","seši","septiņi","astoņi","deviņi"],s=["","viena","divas","trīs","četras","piecas","sešas","septiņas","astoņas","deviņas"],r=["desmit","vienpadsmit","divpadsmit","trīspadsmit","četrpadsmit","piecpadsmit","sešpadsmit","septiņpadsmit","astoņpadsmit","deviņpadsmit"],o=["","","divdesmit","trīsdesmit","četrdesmit","piecdesmit","sešdesmit","septiņdesmit","astoņdesmit","deviņdesmit"],u="simts",l="simti",a="simtu",c="nulle",p=[["tūkstotis","tūkstoši","tūkstošu"],["miljons","miljoni","miljonu"],["miljards","miljardi","miljardu"],["triljons","triljoni","triljonu"],["kvadriljons","kvadriljoni","kvadriljonu"],["kvintiljons","kvintiljoni","kvintiljonu"],["sikstiljons","sikstiljoni","sikstiljonu"],["septiljons","septiljoni","septiljonu"],["oktiljons","oktiljoni","oktiljonu"]];function d(t){if(0===t)return"";const e=t%10,i=Math.floor(t/10)%10,s=Math.floor(t/100),c=[];return s>0&&(1===s&&0===i&&e>0?c.push(a):s>1?(c.push(n[s]),c.push(l)):c.push(u)),i>1&&c.push(o[i]),1===i?c.push(r[e]):e>0&&c.push(n[e]),c.join(" ")}function f(t){if(0===t)return"";const e=t%10,i=Math.floor(t/10)%10,c=Math.floor(t/100),p=[];return c>0&&(1===c&&0===i&&e>0?p.push(a):c>1?(p.push(n[c]),p.push(l)):p.push(u)),i>1&&p.push(o[i]),1===i?p.push(r[e]):e>0&&p.push(s[e]),p.join(" ")}const m=new Array(1e3),g=new Array(1e3);for(let t=0;t<1e3;t++)m[t]=d(t),g[t]=f(t);function h(t,e){return 0===t?e[2]:1==t%10&&11!=t%100?e[0]:e[1]}function j(t,e={}){return 0n===t?c:t<1000n?("feminine"===e.gender?g:m)[Number(t)]:function(t){const e=t.toString(),i=e.length,n=[],s=i%3;let r=0;for(s>0&&(n.push(Number(e.slice(0,s))),r=s);r<i;)n.push(Number(e.slice(r,r+3))),r+=3;const o=[];let u=n.length-1;for(let t=0;t<n.length;t++){const e=n[t];if(0!==e){const t=m[e];if(0===u)o.push(t);else{const i=h(e,p[u-1]);o.push(1===e?i:t+" "+i)}}u--}return o.join(" ")}(t)}t.lv=function(t,n){n=function(t){if(void 0===t)return{};if(function(t){if(null===t||"object"!=typeof t)return!1;const e=Object.getPrototypeOf(t);return null===e||e===Object.prototype}(t))return t;throw new TypeError("Invalid options: expected plain object or undefined, got "+typeof t)}(n);const{isNegative:s,integerPart:r,decimalPart:o}=function(t){const n=typeof t;if("bigint"===n)return t<0n?{isNegative:!0,integerPart:-t}:{isNegative:!1,integerPart:t};if("number"===n){if(!Number.isFinite(t))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(t)?t<0?{isNegative:!0,integerPart:BigInt(-t)}:{isNegative:!1,integerPart:BigInt(t)}:e(function(t){const e=t.toString();return e.includes("e")||e.includes("E")?i(e):e}(t))}if("string"===n)return e(function(t){const e=t.trim();if(0===e.length||Number.isNaN(Number(e)))throw new Error(`Invalid number format: "${t}"`);return e.includes("e")||e.includes("E")?i(e):e}(t));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${n}`)}(t);let u="";return s&&(u="mīnus "),u+=j(r,n),o&&(u+=" komats "+function(t,e){let i="",n=0;for(;n<t.length&&"0"===t[n];)i&&(i+=" "),i+=c,n++;const s=t.slice(n);return s&&(i&&(i+=" "),i+=j(BigInt(s),e)),i}(o,n)),u}},"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).n2words=t.n2words||{});
+/*! n2words/lv v3.1.0 | MIT License | github.com/forzagreen/n2words */
+var t,i;t=this,i=function(t){"use strict";function i(t){const i="-"===t[0];i&&(t=t.slice(1));const e=t.indexOf(".");if(-1===e)return{isNegative:i,integerPart:BigInt(t)};const n=t.slice(0,e)||"0",s=t.slice(e+1);return{isNegative:i,integerPart:BigInt(n),decimalPart:s}}function e(t){const[i,e]=t.toLowerCase().split("e"),n=parseInt(e,10),s=i.indexOf("."),r=-1===s?i:i.slice(0,s)+i.slice(s+1),o=(-1===s?i.length:s)+n;return o>=r.length?r+"0".repeat(o-r.length):o<=0?"0."+"0".repeat(-o)+r:r.slice(0,o)+"."+r.slice(o)}const n=["","viens","divi","trīs","četri","pieci","seši","septiņi","astoņi","deviņi"],s=["","viena","divas","trīs","četras","piecas","sešas","septiņas","astoņas","deviņas"],r=["desmit","vienpadsmit","divpadsmit","trīspadsmit","četrpadsmit","piecpadsmit","sešpadsmit","septiņpadsmit","astoņpadsmit","deviņpadsmit"],o=["","","divdesmit","trīsdesmit","četrdesmit","piecdesmit","sešdesmit","septiņdesmit","astoņdesmit","deviņdesmit"],u="simts",l="simti",a="simtu",c="nulle",p=[["tūkstotis","tūkstoši","tūkstošu"],["miljons","miljoni","miljonu"],["miljards","miljardi","miljardu"],["triljons","triljoni","triljonu"],["kvadriljons","kvadriljoni","kvadriljonu"],["kvintiljons","kvintiljoni","kvintiljonu"],["sikstiljons","sikstiljoni","sikstiljonu"],["septiljons","septiljoni","septiljonu"],["oktiljons","oktiljoni","oktiljonu"]];function d(t){if(0===t)return"";const i=t%10,e=Math.floor(t/10)%10,s=Math.floor(t/100),c=[];return s>0&&(1===s&&0===e&&i>0?c.push(a):s>1?(c.push(n[s]),c.push(l)):c.push(u)),e>1&&c.push(o[e]),1===e?c.push(r[i]):i>0&&c.push(n[i]),c.join(" ")}function f(t,i){return 0===t?i[2]:1==t%10&&11!=t%100?i[0]:i[1]}function m(t,i={}){if(0n===t)return c;if(t<1000n){const e=Number(t);return"feminine"===i.gender?function(t){if(0===t)return"";const i=t%10,e=Math.floor(t/10)%10,c=Math.floor(t/100),p=[];return c>0&&(1===c&&0===e&&i>0?p.push(a):c>1?(p.push(n[c]),p.push(l)):p.push(u)),e>1&&p.push(o[e]),1===e?p.push(r[i]):i>0&&p.push(s[i]),p.join(" ")}(e):d(e)}return function(t){const i=t.toString(),e=i.length,n=[],s=e%3;let r=0;for(s>0&&(n.push(Number(i.slice(0,s))),r=s);r<e;)n.push(Number(i.slice(r,r+3))),r+=3;const o=[];let u=n.length-1;for(let t=0;t<n.length;t++){const i=n[t];if(0!==i){const t=d(i);if(0===u)o.push(t);else{const e=f(i,p[u-1]);o.push(1===i?e:t+" "+e)}}u--}return o.join(" ")}(t)}t.lv=function(t,n){n=function(t){if(void 0===t)return{};if(function(t){if(null===t||"object"!=typeof t)return!1;const i=Object.getPrototypeOf(t);return null===i||i===Object.prototype}(t))return t;throw new TypeError("Invalid options: expected plain object or undefined, got "+typeof t)}(n);const{isNegative:s,integerPart:r,decimalPart:o}=function(t){const n=typeof t;if("bigint"===n)return t<0n?{isNegative:!0,integerPart:-t}:{isNegative:!1,integerPart:t};if("number"===n){if(!Number.isFinite(t))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(t)?t<0?{isNegative:!0,integerPart:BigInt(-t)}:{isNegative:!1,integerPart:BigInt(t)}:i(function(t){const i=t.toString();return i.includes("e")||i.includes("E")?e(i):i}(t))}if("string"===n)return i(function(t){const i=t.trim();if(0===i.length||Number.isNaN(Number(i)))throw new Error(`Invalid number format: "${t}"`);return i.includes("e")||i.includes("E")?e(i):i}(t));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${n}`)}(t);let u="";return s&&(u="mīnus "),u+=m(r,n),o&&(u+=" komats "+function(t,i){let e="",n=0;for(;n<t.length&&"0"===t[n];)e&&(e+=" "),e+=c,n++;const s=t.slice(n);return s&&(e&&(e+=" "),e+=m(BigInt(s),i)),e}(o,n)),u}},"object"==typeof exports&&"undefined"!=typeof module?i(exports):"function"==typeof define&&define.amd?define(["exports"],i):i((t="undefined"!=typeof globalThis?globalThis:t||self).n2words=t.n2words||{});
 //# sourceMappingURL=lv.js.map

package/dist/languages/lv.js.map

@@ -1 +1 @@
-{"version":3,"file":"lv.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/lv.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 * Latvian language converter - Functional Implementation\n *\n * A performance-optimized number-to-words converter using precomputed lookup tables.\n *\n * Key features:\n * - Two-form pluralization (singular for 1 except 11, plural otherwise)\n * - Gender agreement (masculine/feminine for numbers < 1000)\n * - Special hundreds forms (simts/simti/simtu)\n * - Omit \"one\" before scale words\n * - Long 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_MASC = ['', 'viens', 'divi', 'trīs', 'četri', 'pieci', 'seši', 'septiņi', 'astoņi', 'deviņi']\nconst ONES_FEM = ['', 'viena', 'divas', 'trīs', 'četras', 'piecas', 'sešas', 'septiņas', 'astoņas', 'deviņas']\n\nconst TEENS = ['desmit', 'vienpadsmit', 'divpadsmit', 'trīspadsmit', 'četrpadsmit', 'piecpadsmit', 'sešpadsmit', 'septiņpadsmit', 'astoņpadsmit', 'deviņpadsmit']\nconst TENS = ['', '', 'divdesmit', 'trīsdesmit', 'četrdesmit', 'piecdesmit', 'sešdesmit', 'septiņdesmit', 'astoņdesmit', 'deviņdesmit']\n\n// Hundreds: simts (100, 110-199), simti (200-999), simtu (101-109)\nconst HUNDRED_SINGULAR = 'simts'\nconst HUNDRED_PLURAL = 'simti'\nconst HUNDRED_GENITIVE = 'simtu'\n\nconst ZERO = 'nulle'\nconst NEGATIVE = 'mīnus'\nconst DECIMAL_SEP = 'komats'\n\n// Scale words: [singular, plural, genitive]\nconst SCALE_FORMS = [\n  ['tūkstotis', 'tūkstoši', 'tūkstošu'],\n  ['miljons', 'miljoni', 'miljonu'],\n  ['miljards', 'miljardi', 'miljardu'],\n  ['triljons', 'triljoni', 'triljonu'],\n  ['kvadriljons', 'kvadriljoni', 'kvadriljonu'],\n  ['kvintiljons', 'kvintiljoni', 'kvintiljonu'],\n  ['sikstiljons', 'sikstiljoni', 'sikstiljonu'],\n  ['septiljons', 'septiljoni', 'septiljonu'],\n  ['oktiljons', 'oktiljoni', 'oktiljonu']\n]\n\n// ============================================================================\n// Precomputed Lookup Tables (built once at module load)\n// ============================================================================\n\n/**\n * Builds segment word for 0-999 (masculine form).\n * Does NOT include special handling for segment=1 (omitOneBeforeScale).\n * That's handled at join time.\n */\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds - Latvian has special forms\n  if (hundreds > 0) {\n    if (hundreds === 1 && tens === 0 && ones > 0) {\n      // 101-109: use genitive form \"simtu\"\n      parts.push(HUNDRED_GENITIVE)\n    } else if (hundreds > 1) {\n      // 200-999: use plural \"simti\"\n      parts.push(ONES_MASC[hundreds])\n      parts.push(HUNDRED_PLURAL)\n    } else {\n      // 100, 110-199: use singular \"simts\"\n      parts.push(HUNDRED_SINGULAR)\n    }\n  }\n\n  // Tens\n  if (tens > 1) {\n    parts.push(TENS[tens])\n  }\n\n  // Teens or ones\n  if (tens === 1) {\n    parts.push(TEENS[ones])\n  } else if (ones > 0) {\n    parts.push(ONES_MASC[ones])\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Builds segment word for 0-999 (feminine form - only differs in ones).\n */\nfunction buildSegmentFeminine (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds - always masculine\n  if (hundreds > 0) {\n    if (hundreds === 1 && tens === 0 && ones > 0) {\n      parts.push(HUNDRED_GENITIVE)\n    } else if (hundreds > 1) {\n      parts.push(ONES_MASC[hundreds])\n      parts.push(HUNDRED_PLURAL)\n    } else {\n      parts.push(HUNDRED_SINGULAR)\n    }\n  }\n\n  // Tens\n  if (tens > 1) {\n    parts.push(TENS[tens])\n  }\n\n  // Teens or ones - feminine for ones only\n  if (tens === 1) {\n    parts.push(TEENS[ones])\n  } else if (ones > 0) {\n    parts.push(ONES_FEM[ones])\n  }\n\n  return parts.join(' ')\n}\n\n// Precompute all 1000 segment words (0-999)\nconst SEGMENTS_MASC = new Array(1000)\nconst SEGMENTS_FEM = new Array(1000)\n\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS_MASC[i] = buildSegment(i)\n  SEGMENTS_FEM[i] = buildSegmentFeminine(i)\n}\n\n// ============================================================================\n// Pluralization\n// ============================================================================\n\n/**\n * Latvian pluralization - simpler than Slavic.\n * Singular: ends in 1 (except 11)\n * Plural: everything else\n *\n * @param {number} n - The segment value\n * @param {string[]} forms - [singular, plural, genitive]\n * @returns {string} The appropriate form\n */\nfunction pluralize (n, forms) {\n  if (n === 0) return forms[2]\n\n  const lastDigit = n % 10\n  const lastTwoDigits = n % 100\n\n  if (lastDigit === 1 && lastTwoDigits !== 11) {\n    return forms[0]\n  }\n\n  return forms[1]\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Latvian words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @param {Object} options - Conversion options\n * @returns {string} Latvian words\n */\nfunction integerToWords (n, options = {}) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000 (direct lookup)\n  if (n < 1000n) {\n    const segments = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC\n    return segments[Number(n)]\n  }\n\n  // For numbers >= 1000, feminine only applies to final segment if < 1000\n  // But we use masculine for all segments when n >= 1000\n  return buildLargeNumberWords(n, options)\n}\n\n/**\n * Builds words for numbers >= 1000.\n *\n * @param {bigint} n - Number >= 1000\n * @param {Object} options - Conversion options\n * @returns {string} Latvian words\n */\nfunction buildLargeNumberWords (n, options) {\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 = SEGMENTS_MASC[segment]\n\n      if (scaleIndex === 0) {\n        // Units segment - use masculine (feminine doesn't apply when n >= 1000)\n        parts.push(segmentWord)\n      } else {\n        // Segment with scale word\n        const scaleForms = SCALE_FORMS[scaleIndex - 1]\n        const scaleWord = pluralize(segment, scaleForms)\n\n        // Latvian omits \"one\" before scale words\n        if (segment === 1) {\n          parts.push(scaleWord)\n        } else {\n          parts.push(segmentWord + ' ' + scaleWord)\n        }\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts decimal digits to Latvian words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @param {Object} options - Conversion options\n * @returns {string} Latvian words for decimal part\n */\nfunction decimalPartToWords (decimalPart, options) {\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), options)\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Latvian words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @param {Object} [options] - Conversion options\n * @param {string} [options.gender='masculine'] - Gender for numbers < 1000\n * @returns {string} The number in Latvian 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)                          // 'četrdesmit divi'\n * toWords(1, { gender: 'feminine' })   // 'viena'\n * toWords(1000)                        // 'tūkstotis'\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// Public API\n// ============================================================================\n\nexport { toWords }\n","import { isPlainObject } from './is-plain-object.js'\n\n/**\n * Validates and normalizes the options parameter.\n *\n * @param {*} options The options value to validate\n * @returns {Object} A valid options object (empty object if undefined)\n * @throws {TypeError} If options is not undefined or a plain object\n */\nexport function validateOptions (options) {\n  if (options === undefined) return {}\n  if (isPlainObject(options)) return options\n  throw new TypeError(\n    `Invalid options: expected plain object or undefined, got ${typeof options}`\n  )\n}\n","/**\n * Checks if a value is a plain object (not null, array, or other object types).\n *\n * A plain object is one created by:\n * - Object literal: `{}`\n * - Object.create(null): null-prototype object\n *\n * This excludes arrays, class instances, Map, Set, and other object types.\n *\n * @param {*} value Value to check\n * @returns {boolean} True if value is a plain object\n */\nexport function isPlainObject (value) {\n  if (value === null || typeof value !== 'object') return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === null || proto === Object.prototype\n}\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES_MASC","ONES_FEM","TEENS","TENS","HUNDRED_SINGULAR","HUNDRED_PLURAL","HUNDRED_GENITIVE","ZERO","SCALE_FORMS","buildSegment","n","ones","tens","Math","floor","hundreds","parts","push","join","buildSegmentFeminine","SEGMENTS_MASC","Array","SEGMENTS_FEM","i","pluralize","forms","integerToWords","options","gender","Number","numStr","toString","len","segments","remainderLen","pos","scaleIndex","segment","segmentWord","scaleWord","buildLargeNumberWords","value","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","result","NEGATIVE","remainder","decimalPartToWords"],"mappings":"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"}
+{"version":3,"file":"lv.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/lv.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 * Latvian language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Two-form pluralization (singular for 1 except 11, plural otherwise)\n * - Gender agreement (masculine/feminine for numbers < 1000)\n * - Special hundreds forms (simts/simti/simtu)\n * - Omit \"one\" before scale words\n * - Long 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_MASC = ['', 'viens', 'divi', 'trīs', 'četri', 'pieci', 'seši', 'septiņi', 'astoņi', 'deviņi']\nconst ONES_FEM = ['', 'viena', 'divas', 'trīs', 'četras', 'piecas', 'sešas', 'septiņas', 'astoņas', 'deviņas']\n\nconst TEENS = ['desmit', 'vienpadsmit', 'divpadsmit', 'trīspadsmit', 'četrpadsmit', 'piecpadsmit', 'sešpadsmit', 'septiņpadsmit', 'astoņpadsmit', 'deviņpadsmit']\nconst TENS = ['', '', 'divdesmit', 'trīsdesmit', 'četrdesmit', 'piecdesmit', 'sešdesmit', 'septiņdesmit', 'astoņdesmit', 'deviņdesmit']\n\n// Hundreds: simts (100, 110-199), simti (200-999), simtu (101-109)\nconst HUNDRED_SINGULAR = 'simts'\nconst HUNDRED_PLURAL = 'simti'\nconst HUNDRED_GENITIVE = 'simtu'\n\nconst ZERO = 'nulle'\nconst NEGATIVE = 'mīnus'\nconst DECIMAL_SEP = 'komats'\n\n// Scale words: [singular, plural, genitive]\nconst SCALE_FORMS = [\n  ['tūkstotis', 'tūkstoši', 'tūkstošu'],\n  ['miljons', 'miljoni', 'miljonu'],\n  ['miljards', 'miljardi', 'miljardu'],\n  ['triljons', 'triljoni', 'triljonu'],\n  ['kvadriljons', 'kvadriljoni', 'kvadriljonu'],\n  ['kvintiljons', 'kvintiljoni', 'kvintiljonu'],\n  ['sikstiljons', 'sikstiljoni', 'sikstiljonu'],\n  ['septiljons', 'septiljoni', 'septiljonu'],\n  ['oktiljons', 'oktiljoni', 'oktiljonu']\n]\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for 0-999 (masculine form).\n * Does NOT include special handling for segment=1 (omitOneBeforeScale).\n * That's handled at join time.\n */\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds - Latvian has special forms\n  if (hundreds > 0) {\n    if (hundreds === 1 && tens === 0 && ones > 0) {\n      // 101-109: use genitive form \"simtu\"\n      parts.push(HUNDRED_GENITIVE)\n    } else if (hundreds > 1) {\n      // 200-999: use plural \"simti\"\n      parts.push(ONES_MASC[hundreds])\n      parts.push(HUNDRED_PLURAL)\n    } else {\n      // 100, 110-199: use singular \"simts\"\n      parts.push(HUNDRED_SINGULAR)\n    }\n  }\n\n  // Tens\n  if (tens > 1) {\n    parts.push(TENS[tens])\n  }\n\n  // Teens or ones\n  if (tens === 1) {\n    parts.push(TEENS[ones])\n  } else if (ones > 0) {\n    parts.push(ONES_MASC[ones])\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Builds segment word for 0-999 (feminine form - only differs in ones).\n */\nfunction buildSegmentFeminine (n) {\n  if (n === 0) return ''\n\n  const ones = n % 10\n  const tens = Math.floor(n / 10) % 10\n  const hundreds = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds - always masculine\n  if (hundreds > 0) {\n    if (hundreds === 1 && tens === 0 && ones > 0) {\n      parts.push(HUNDRED_GENITIVE)\n    } else if (hundreds > 1) {\n      parts.push(ONES_MASC[hundreds])\n      parts.push(HUNDRED_PLURAL)\n    } else {\n      parts.push(HUNDRED_SINGULAR)\n    }\n  }\n\n  // Tens\n  if (tens > 1) {\n    parts.push(TENS[tens])\n  }\n\n  // Teens or ones - feminine for ones only\n  if (tens === 1) {\n    parts.push(TEENS[ones])\n  } else if (ones > 0) {\n    parts.push(ONES_FEM[ones])\n  }\n\n  return parts.join(' ')\n}\n\n// ============================================================================\n// Pluralization\n// ============================================================================\n\n/**\n * Latvian pluralization - simpler than Slavic.\n * Singular: ends in 1 (except 11)\n * Plural: everything else\n *\n * @param {number} n - The segment value\n * @param {string[]} forms - [singular, plural, genitive]\n * @returns {string} The appropriate form\n */\nfunction pluralize (n, forms) {\n  if (n === 0) return forms[2]\n\n  const lastDigit = n % 10\n  const lastTwoDigits = n % 100\n\n  if (lastDigit === 1 && lastTwoDigits !== 11) {\n    return forms[0]\n  }\n\n  return forms[1]\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Latvian words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @param {Object} options - Conversion options\n * @returns {string} Latvian words\n */\nfunction integerToWords (n, options = {}) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000\n  if (n < 1000n) {\n    const num = Number(n)\n    return options.gender === 'feminine' ? buildSegmentFeminine(num) : buildSegment(num)\n  }\n\n  // For numbers >= 1000, feminine only applies to final segment if < 1000\n  // But we use masculine for all segments when n >= 1000\n  return buildLargeNumberWords(n, options)\n}\n\n/**\n * Builds words for numbers >= 1000.\n *\n * @param {bigint} n - Number >= 1000\n * @param {Object} options - Conversion options\n * @returns {string} Latvian words\n */\nfunction buildLargeNumberWords (n, options) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  // Build segments of 3 digits from right to left\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  // Convert segments to words\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      const segmentWord = buildSegment(segment)\n\n      if (scaleIndex === 0) {\n        // Units segment - use masculine (feminine doesn't apply when n >= 1000)\n        parts.push(segmentWord)\n      } else {\n        // Segment with scale word\n        const scaleForms = SCALE_FORMS[scaleIndex - 1]\n        const scaleWord = pluralize(segment, scaleForms)\n\n        // Latvian omits \"one\" before scale words\n        if (segment === 1) {\n          parts.push(scaleWord)\n        } else {\n          parts.push(segmentWord + ' ' + scaleWord)\n        }\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\n/**\n * Converts decimal digits to Latvian words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @param {Object} options - Conversion options\n * @returns {string} Latvian words for decimal part\n */\nfunction decimalPartToWords (decimalPart, options) {\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), options)\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Latvian words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @param {Object} [options] - Conversion options\n * @param {string} [options.gender='masculine'] - Gender for numbers < 1000\n * @returns {string} The number in Latvian 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)                          // 'četrdesmit divi'\n * toWords(1, { gender: 'feminine' })   // 'viena'\n * toWords(1000)                        // 'tūkstotis'\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// Public API\n// ============================================================================\n\nexport { toWords }\n","import { isPlainObject } from './is-plain-object.js'\n\n/**\n * Validates and normalizes the options parameter.\n *\n * @param {*} options The options value to validate\n * @returns {Object} A valid options object (empty object if undefined)\n * @throws {TypeError} If options is not undefined or a plain object\n */\nexport function validateOptions (options) {\n  if (options === undefined) return {}\n  if (isPlainObject(options)) return options\n  throw new TypeError(\n    `Invalid options: expected plain object or undefined, got ${typeof options}`\n  )\n}\n","/**\n * Checks if a value is a plain object (not null, array, or other object types).\n *\n * A plain object is one created by:\n * - Object literal: `{}`\n * - Object.create(null): null-prototype object\n *\n * This excludes arrays, class instances, Map, Set, and other object types.\n *\n * @param {*} value Value to check\n * @returns {boolean} True if value is a plain object\n */\nexport function isPlainObject (value) {\n  if (value === null || typeof value !== 'object') return false\n  const proto = Object.getPrototypeOf(value)\n  return proto === null || proto === Object.prototype\n}\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES_MASC","ONES_FEM","TEENS","TENS","HUNDRED_SINGULAR","HUNDRED_PLURAL","HUNDRED_GENITIVE","ZERO","SCALE_FORMS","buildSegment","n","ones","tens","Math","floor","hundreds","parts","push","join","pluralize","forms","integerToWords","options","num","Number","gender","buildSegmentFeminine","numStr","toString","len","segments","remainderLen","pos","scaleIndex","i","segment","segmentWord","scaleWord","buildLargeNumberWords","value","undefined","proto","Object","getPrototypeOf","prototype","isPlainObject","TypeError","validateOptions","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","parseNumericValue","result","NEGATIVE","remainder","decimalPartToWords"],"mappings":";0CAwEA,SAASA,EAAoBC,GAC3B,MAAMC,EAAwB,MAAXD,EAAI,GACnBC,IAAYD,EAAMA,EAAIE,MAAM,IAEhC,MAAMC,EAAWH,EAAII,QAAQ,KAC7B,IAAiB,IAAbD,EACF,MAAO,CAAEF,aAAYI,YAAaC,OAAON,IAG3C,MAAMO,EAAaP,EAAIE,MAAM,EAAGC,IAAa,IACvCK,EAAcR,EAAIE,MAAMC,EAAW,GACzC,MAAO,CAAEF,aAAYI,YAAaC,OAAOC,GAAaC,cACxD,CAKA,SAASC,EAA0BT,GACjC,MAAOU,EAAUC,GAAUX,EAAIY,cAAcC,MAAM,KAC7CC,EAAMC,SAASJ,EAAQ,IAEvBR,EAAWO,EAASN,QAAQ,KAC5BY,OAASb,EACXO,EACAA,EAASR,MAAM,EAAGC,GAAYO,EAASR,MAAMC,EAAW,GAEtDc,IAD6B,IAAbd,EAAkBO,EAASQ,OAASf,GACnBW,EAEvC,OAAIG,GAAkBD,EAAOE,OACpBF,EAAS,IAAIG,OAAOF,EAAiBD,EAAOE,QAEjDD,GAAkB,EACb,KAAO,IAAIE,QAAQF,GAAkBD,EAEvCA,EAAOd,MAAM,EAAGe,GAAkB,IAAMD,EAAOd,MAAMe,EAC9D,CCvFA,MAAMG,EAAY,CAAC,GAAI,QAAS,OAAQ,OAAQ,QAAS,QAAS,OAAQ,UAAW,SAAU,UACzFC,EAAW,CAAC,GAAI,QAAS,QAAS,OAAQ,SAAU,SAAU,QAAS,WAAY,UAAW,WAE9FC,EAAQ,CAAC,SAAU,cAAe,aAAc,cAAe,cAAe,cAAe,aAAc,gBAAiB,eAAgB,gBAC5IC,EAAO,CAAC,GAAI,GAAI,YAAa,aAAc,aAAc,aAAc,YAAa,eAAgB,cAAe,eAGnHC,EAAmB,QACnBC,EAAiB,QACjBC,EAAmB,QAEnBC,EAAO,QAKPC,EAAc,CAClB,CAAC,YAAa,WAAY,YAC1B,CAAC,UAAW,UAAW,WACvB,CAAC,WAAY,WAAY,YACzB,CAAC,WAAY,WAAY,YACzB,CAAC,cAAe,cAAe,eAC/B,CAAC,cAAe,cAAe,eAC/B,CAAC,cAAe,cAAe,eAC/B,CAAC,aAAc,aAAc,cAC7B,CAAC,YAAa,YAAa,cAY7B,SAASC,EAAcC,GACrB,GAAU,IAANA,EAAS,MAAO,GAEpB,MAAMC,EAAOD,EAAI,GACXE,EAAOC,KAAKC,MAAMJ,EAAI,IAAM,GAC5BK,EAAWF,KAAKC,MAAMJ,EAAI,KAE1BM,EAAQ,GA6Bd,OA1BID,EAAW,IACI,IAAbA,GAA2B,IAATH,GAAcD,EAAO,EAEzCK,EAAMC,KAAKX,GACFS,EAAW,GAEpBC,EAAMC,KAAKjB,EAAUe,IACrBC,EAAMC,KAAKZ,IAGXW,EAAMC,KAAKb,IAKXQ,EAAO,GACTI,EAAMC,KAAKd,EAAKS,IAIL,IAATA,EACFI,EAAMC,KAAKf,EAAMS,IACRA,EAAO,GAChBK,EAAMC,KAAKjB,EAAUW,IAGhBK,EAAME,KAAK,IACpB,CAsDA,SAASC,EAAWT,EAAGU,GACrB,OAAU,IAANV,EAAgBU,EAAM,GAKR,GAHAV,EAAI,IAGmB,IAFnBA,EAAI,IAGjBU,EAAM,GAGRA,EAAM,EACf,CAaA,SAASC,EAAgBX,EAAGY,EAAU,IACpC,GAAU,KAANZ,EAAU,OAAOH,EAGrB,GAAIG,EAAI,MAAO,CACb,MAAMa,EAAMC,OAAOd,GACnB,MAA0B,aAAnBY,EAAQG,OA/EnB,SAA+Bf,GAC7B,GAAU,IAANA,EAAS,MAAO,GAEpB,MAAMC,EAAOD,EAAI,GACXE,EAAOC,KAAKC,MAAMJ,EAAI,IAAM,GAC5BK,EAAWF,KAAKC,MAAMJ,EAAI,KAE1BM,EAAQ,GA0Bd,OAvBID,EAAW,IACI,IAAbA,GAA2B,IAATH,GAAcD,EAAO,EACzCK,EAAMC,KAAKX,GACFS,EAAW,GACpBC,EAAMC,KAAKjB,EAAUe,IACrBC,EAAMC,KAAKZ,IAEXW,EAAMC,KAAKb,IAKXQ,EAAO,GACTI,EAAMC,KAAKd,EAAKS,IAIL,IAATA,EACFI,EAAMC,KAAKf,EAAMS,IACRA,EAAO,GAChBK,EAAMC,KAAKhB,EAASU,IAGfK,EAAME,KAAK,IACpB,CA6C2CQ,CAAqBH,GAAOd,EAAac,EAClF,CAIA,OAUF,SAAgCb,GAC9B,MAAMiB,EAASjB,EAAEkB,WACXC,EAAMF,EAAO7B,OAGbgC,EAAW,GAGXC,EAAeF,EAFD,EAGpB,IAAIG,EAAM,EAKV,IAJID,EAAe,IACjBD,EAASb,KAAKO,OAAOG,EAAO7C,MAAM,EAAGiD,KACrCC,EAAMD,GAEDC,EAAMH,GACXC,EAASb,KAAKO,OAAOG,EAAO7C,MAAMkD,EAAKA,EATrB,KAUlBA,GAVkB,EAcpB,MAAMhB,EAAQ,GACd,IAAIiB,EAAaH,EAAShC,OAAS,EAEnC,IAAK,IAAIoC,EAAI,EAAGA,EAAIJ,EAAShC,OAAQoC,IAAK,CACxC,MAAMC,EAAUL,EAASI,GAEzB,GAAgB,IAAZC,EAAe,CACjB,MAAMC,EAAc3B,EAAa0B,GAEjC,GAAmB,IAAfF,EAEFjB,EAAMC,KAAKmB,OACN,CAEL,MACMC,EAAYlB,EAAUgB,EADT3B,EAAYyB,EAAa,IAK1CjB,EAAMC,KADQ,IAAZkB,EACSE,EAEAD,EAAc,IAAMC,EAEnC,CACF,CAEAJ,GACF,CAEA,OAAOjB,EAAME,KAAK,IACpB,CA5DSoB,CAAsB5B,EAC/B,MAwGA,SAAkB6B,EAAOjB,GACvBA,ECxRK,SAA0BA,GAC/B,QAAgBkB,IAAZlB,EAAuB,MAAO,CAAA,EAClC,GCCK,SAAwBiB,GAC7B,GAAc,OAAVA,GAAmC,iBAAVA,EAAoB,OAAO,EACxD,MAAME,EAAQC,OAAOC,eAAeJ,GACpC,OAAiB,OAAVE,GAAkBA,IAAUC,OAAOE,SAC5C,CDLMC,CAAcvB,GAAU,OAAOA,EACnC,MAAM,IAAIwB,UACR,mEAAmExB,EAEvE,CDkRYyB,CAAgBzB,GAC1B,MAAMzC,WAAEA,EAAUI,YAAEA,EAAWG,YAAEA,GDrR5B,SAA4BmD,GACjC,MAAMS,SAAcT,EAGpB,GAAa,WAATS,EACF,OAAOT,EAAQ,GACX,CAAE1D,YAAY,EAAMI,aAAcsD,GAClC,CAAE1D,YAAY,EAAOI,YAAasD,GAIxC,GAAa,WAATS,EAAmB,CACrB,IAAKxB,OAAOyB,SAASV,GACnB,MAAM,IAAIW,MAAM,8DAElB,OAAI1B,OAAO2B,cAAcZ,GAChBA,EAAQ,EACX,CAAE1D,YAAY,EAAMI,YAAaC,QAAQqD,IACzC,CAAE1D,YAAY,EAAOI,YAAaC,OAAOqD,IAExC5D,EAgBX,SAAyB4D,GACvB,MAAM3D,EAAM2D,EAAMX,WAClB,OAAQhD,EAAIwE,SAAS,MAAQxE,EAAIwE,SAAS,KACtC/D,EAAyBT,GACzBA,CACN,CArB8ByE,CAAed,GAC3C,CAGA,GAAa,WAATS,EACF,OAAOrE,EAqBX,SAA0B4D,GACxB,MAAMe,EAAUf,EAAMgB,OACtB,GAAuB,IAAnBD,EAAQxD,QAAgB0B,OAAOgC,MAAMhC,OAAO8B,IAC9C,MAAM,IAAIJ,MAAM,2BAA2BX,MAE7C,OAAQe,EAAQF,SAAS,MAAQE,EAAQF,SAAS,KAC9C/D,EAAyBiE,GACzBA,CACN,CA7B8BG,CAAgBlB,IAG5C,MAAM,IAAIO,UACR,oEAAoEE,IAExE,CCsPmDU,CAAkBnB,GAEnE,IAAIoB,EAAS,GAYb,OAVI9E,IACF8E,EAASC,UAGXD,GAAUtC,EAAepC,EAAaqC,GAElClC,IACFuE,GAAU,WAjDd,SAA6BvE,EAAakC,GACxC,IAAIqC,EAAS,GAGTzB,EAAI,EACR,KAAOA,EAAI9C,EAAYU,QAA6B,MAAnBV,EAAY8C,IACvCyB,IAAQA,GAAU,KACtBA,GAAUpD,EACV2B,IAIF,MAAM2B,EAAYzE,EAAYN,MAAMoD,GAMpC,OALI2B,IACEF,IAAQA,GAAU,KACtBA,GAAUtC,EAAenC,OAAO2E,GAAYvC,IAGvCqC,CACT,CA8BwCG,CAAmB1E,EAAakC,IAG/DqC,CACT"}

package/dist/languages/mr.js

@@ -1,3 +1,3 @@
-/*! n2words/mr v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const i=e.slice(0,n)||"0",r=e.slice(n+1);return{isNegative:t,integerPart:BigInt(i),decimalPart:r}}function n(e){const[t,n]=e.toLowerCase().split("e"),i=parseInt(n,10),r=t.indexOf("."),s=-1===r?t:t.slice(0,r)+t.slice(r+1),o=(-1===r?t.length:r)+i;return o>=s.length?s+"0".repeat(o-s.length):o<=0?"0."+"0".repeat(-o)+s:s.slice(0,o)+"."+s.slice(o)}const i="शून्य",r="शंभर",s=["शून्य","एक","दोन","तीन","चार","पाच","सहा","सात","आठ","नऊ","दहा","अकरा","बारा","तेरा","चौदा","पंधरा","सोळा","सतरा","अठरा","एकोणीस","वीस","एकवीस","बावीस","तेवीस","चोवीस","पंचवीस","सव्वीस","सत्तावीस","अठ्ठावीस","एकोणतीस","तीस","एकतीस","बत्तीस","तेहेतीस","चौतीस","पस्तीस","छत्तीस","सदतीस","अडतीस","एकोणचाळीस","चाळीस","एकेचाळीस","बेचाळीस","त्रेचाळीस","चव्वेचाळीस","पंचेचाळीस","सेहेचाळीस","सत्तेचाळीस","अठ्ठेचाळीस","एकोणपन्नास","पन्नास","एक्काव्वन","बावन्न","त्रेपन्न","चोपन्न","पंचाव्वन","छप्पन्न","सत्तावन्न","अठ्ठावन्न","एकोणसाठ","साठ","एकसष्ठ","बासष्ठ","त्रेसष्ठ","चौसष्ठ","पासष्ठ","सहासष्ठ","सदुसष्ठ","अडुसष्ठ","एकोणसत्तर","सत्तर","एकाहत्तर","बाहत्तर","त्र्याहत्तर","चौऱ्याहत्तर","पंच्याहत्तर","शहात्तर","सत्याहत्तर","अठ्ठ्याहत्तर","एकोणऐंशी","ऐंशी","एक्याऐंशी","ब्याऐंशी","त्र्याऐंशी","चौऱ्याऐंशी","पंच्याऐंशी","शहाऐंशी","सत्याऐंशी","अठ्ठ्याऐंशी","एकोणनव्वद","नव्वद","एक्याण्णव","ब्याण्णव","त्र्याण्णव","चौऱ्याण्णव","पंच्याण्णव","शहाण्णव","सत्याण्णव","अठ्ठ्याण्णव","नव्याण्णव"],o=["","हजार","लाख","कोटी","अब्ज","खर्व","निखर्व","महापद्म","शंकू"];function u(e){if(0===e)return"";if(e<100)return s[e];const t=Math.trunc(e/100),n=e%100;return 0===n?s[t]+" "+r:s[t]+" "+r+" "+s[n]}e.mr=function(e){const{isNegative:r,integerPart:c,decimalPart:f}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===i)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(e);let a="";return r&&(a="उणे "),a+=function(e){if(0n===e)return i;const t=function(e){const t=e.toString();if(t.length<=3)return[Number(t)];const n=[];n.unshift(Number(t.slice(-3)));let i=t.slice(0,-3);for(;i.length>0;)n.unshift(Number(i.slice(-2))),i=i.slice(0,-2);return n}(e),n=t.length,r=[];for(let e=0;e<n;e++){const i=t[e];if(0===i)continue;const s=n-e-1;r.push(u(i)),s>0&&o[s]&&r.push(o[s])}return r.join(" ").trim()}(c),f&&(a+=" दशांश "+function(e){const t=[];for(const n of e){const e=parseInt(n,10);t.push(0===e?i:s[e])}return t.join(" ")}(f)),a}},"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
+/*! n2words/mr v3.1.0 | MIT License | github.com/forzagreen/n2words */
+var e,n;e=this,n=function(e){"use strict";function n(e){const n="-"===e[0];n&&(e=e.slice(1));const t=e.indexOf(".");if(-1===t)return{isNegative:n,integerPart:BigInt(e)};const r=e.slice(0,t)||"0",i=e.slice(t+1);return{isNegative:n,integerPart:BigInt(r),decimalPart:i}}function t(e){const[n,t]=e.toLowerCase().split("e"),r=parseInt(t,10),i=n.indexOf("."),s=-1===i?n:n.slice(0,i)+n.slice(i+1),o=(-1===i?n.length:i)+r;return o>=s.length?s+"0".repeat(o-s.length):o<=0?"0."+"0".repeat(-o)+s:s.slice(0,o)+"."+s.slice(o)}const r="शून्य",i="शंभर",s=["शून्य","एक","दोन","तीन","चार","पाच","सहा","सात","आठ","नऊ","दहा","अकरा","बारा","तेरा","चौदा","पंधरा","सोळा","सतरा","अठरा","एकोणीस","वीस","एकवीस","बावीस","तेवीस","चोवीस","पंचवीस","सव्वीस","सत्तावीस","अठ्ठावीस","एकोणतीस","तीस","एकतीस","बत्तीस","तेहेतीस","चौतीस","पस्तीस","छत्तीस","सदतीस","अडतीस","एकोणचाळीस","चाळीस","एकेचाळीस","बेचाळीस","त्रेचाळीस","चव्वेचाळीस","पंचेचाळीस","सेहेचाळीस","सत्तेचाळीस","अठ्ठेचाळीस","एकोणपन्नास","पन्नास","एक्काव्वन","बावन्न","त्रेपन्न","चोपन्न","पंचाव्वन","छप्पन्न","सत्तावन्न","अठ्ठावन्न","एकोणसाठ","साठ","एकसष्ठ","बासष्ठ","त्रेसष्ठ","चौसष्ठ","पासष्ठ","सहासष्ठ","सदुसष्ठ","अडुसष्ठ","एकोणसत्तर","सत्तर","एकाहत्तर","बाहत्तर","त्र्याहत्तर","चौऱ्याहत्तर","पंच्याहत्तर","शहात्तर","सत्याहत्तर","अठ्ठ्याहत्तर","एकोणऐंशी","ऐंशी","एक्याऐंशी","ब्याऐंशी","त्र्याऐंशी","चौऱ्याऐंशी","पंच्याऐंशी","शहाऐंशी","सत्याऐंशी","अठ्ठ्याऐंशी","एकोणनव्वद","नव्वद","एक्याण्णव","ब्याण्णव","त्र्याण्णव","चौऱ्याण्णव","पंच्याण्णव","शहाण्णव","सत्याण्णव","अठ्ठ्याण्णव","नव्याण्णव"],o=["","हजार","लाख","कोटी","अब्ज","खर्व","निखर्व","महापद्म","शंकू"];function u(e){if(0===e)return"";if(e<100)return s[e];const n=Math.trunc(e/100),t=e%100;return 0===t?s[n]+" "+i:s[n]+" "+i+" "+s[t]}e.mr=function(e){const{isNegative:i,integerPart:c,decimalPart:f}=function(e){const r=typeof e;if("bigint"===r)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===r){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:n(function(e){const n=e.toString();return n.includes("e")||n.includes("E")?t(n):n}(e))}if("string"===r)return n(function(e){const n=e.trim();if(0===n.length||Number.isNaN(Number(n)))throw new Error(`Invalid number format: "${e}"`);return n.includes("e")||n.includes("E")?t(n):n}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${r}`)}(e);let a="";return i&&(a="उणे "),a+=function(e){if(0n===e)return r;if(e<1000n)return u(Number(e));const n=[];n.push(Number(e%1000n));let t=e/1000n;for(;t>0n;)n.push(Number(t%100n)),t/=100n;const i=[];for(let e=n.length-1;e>=0;e--){const t=n[e];0!==t&&(i.push(0===e?u(t):s[t]),e>0&&o[e]&&i.push(o[e]))}return i.join(" ")}(c),f&&(a+=" दशांश "+function(e){const n=[];for(const t of e){const e=parseInt(t,10);n.push(0===e?r:s[e])}return n.join(" ")}(f)),a}},"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).n2words=e.n2words||{});
 //# sourceMappingURL=mr.js.map

package/dist/languages/mr.js.map

@@ -1 +1 @@
-{"version":3,"file":"mr.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/mr.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 * Marathi language converter - Functional Implementation\n *\n * Self-contained converter for South Asian numbering.\n *\n * Key features:\n * - Indian numbering system (हजार, लाख, कोटी)\n * - Devanagari script\n * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)\n * - Complete word forms for 0-99\n * - Per-digit decimal reading\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ZERO = 'शून्य'\nconst NEGATIVE = 'उणे'\nconst DECIMAL_SEP = 'दशांश'\nconst HUNDRED = 'शंभर'\n\nconst BELOW_HUNDRED = [\n  'शून्य', 'एक', 'दोन', 'तीन', 'चार', 'पाच', 'सहा', 'सात', 'आठ', 'नऊ',\n  'दहा', 'अकरा', 'बारा', 'तेरा', 'चौदा', 'पंधरा', 'सोळा', 'सतरा', 'अठरा', 'एकोणीस',\n  'वीस', 'एकवीस', 'बावीस', 'तेवीस', 'चोवीस', 'पंचवीस', 'सव्वीस', 'सत्तावीस', 'अठ्ठावीस', 'एकोणतीस',\n  'तीस', 'एकतीस', 'बत्तीस', 'तेहेतीस', 'चौतीस', 'पस्तीस', 'छत्तीस', 'सदतीस', 'अडतीस', 'एकोणचाळीस',\n  'चाळीस', 'एकेचाळीस', 'बेचाळीस', 'त्रेचाळीस', 'चव्वेचाळीस', 'पंचेचाळीस', 'सेहेचाळीस', 'सत्तेचाळीस', 'अठ्ठेचाळीस', 'एकोणपन्नास',\n  'पन्नास', 'एक्काव्वन', 'बावन्न', 'त्रेपन्न', 'चोपन्न', 'पंचाव्वन', 'छप्पन्न', 'सत्तावन्न', 'अठ्ठावन्न', 'एकोणसाठ',\n  'साठ', 'एकसष्ठ', 'बासष्ठ', 'त्रेसष्ठ', 'चौसष्ठ', 'पासष्ठ', 'सहासष्ठ', 'सदुसष्ठ', 'अडुसष्ठ', 'एकोणसत्तर',\n  'सत्तर', 'एकाहत्तर', 'बाहत्तर', 'त्र्याहत्तर', 'चौऱ्याहत्तर', 'पंच्याहत्तर', 'शहात्तर', 'सत्याहत्तर', 'अठ्ठ्याहत्तर', 'एकोणऐंशी',\n  'ऐंशी', 'एक्याऐंशी', 'ब्याऐंशी', 'त्र्याऐंशी', 'चौऱ्याऐंशी', 'पंच्याऐंशी', 'शहाऐंशी', 'सत्याऐंशी', 'अठ्ठ्याऐंशी', 'एकोणनव्वद',\n  'नव्वद', 'एक्याण्णव', 'ब्याण्णव', 'त्र्याण्णव', 'चौऱ्याण्णव', 'पंच्याण्णव', 'शहाण्णव', 'सत्याण्णव', 'अठ्ठ्याण्णव', 'नव्याण्णव'\n]\n\n// Scale words: index 0 = units (empty), 1 = thousand, 2 = lakh, 3 = crore, etc.\nconst SCALE_WORDS = ['', 'हजार', 'लाख', 'कोटी', 'अब्ज', 'खर्व', 'निखर्व', 'महापद्म', 'शंकू']\n\n// ============================================================================\n// Segment Splitting (inlined for performance)\n// ============================================================================\n\nfunction groupByThreeThenTwos (n) {\n  const numStr = n.toString()\n  if (numStr.length <= 3) return [Number(numStr)]\n\n  const segments = []\n  segments.unshift(Number(numStr.slice(-3)))\n\n  let remaining = numStr.slice(0, -3)\n  while (remaining.length > 0) {\n    segments.unshift(Number(remaining.slice(-2)))\n    remaining = remaining.slice(0, -2)\n  }\n\n  return segments\n}\n\nfunction segmentToWords (n) {\n  if (n === 0) return ''\n  if (n < 100) return BELOW_HUNDRED[n]\n\n  const hundreds = Math.trunc(n / 100)\n  const remainder = n % 100\n\n  if (remainder === 0) {\n    return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED\n  }\n  return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED + ' ' + BELOW_HUNDRED[remainder]\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  const segments = groupByThreeThenTwos(n)\n  const segmentCount = segments.length\n  const words = []\n\n  for (let i = 0; i < segmentCount; i++) {\n    const segmentValue = segments[i]\n    if (segmentValue === 0) continue\n\n    const scaleIndex = segmentCount - i - 1\n    words.push(segmentToWords(segmentValue))\n    if (scaleIndex > 0 && SCALE_WORDS[scaleIndex]) {\n      words.push(SCALE_WORDS[scaleIndex])\n    }\n  }\n\n  return words.join(' ').trim()\n}\n\nfunction decimalPartToWords (decimalPart) {\n  // Per-digit decimal reading\n  const digits = []\n  for (const char of decimalPart) {\n    const d = parseInt(char, 10)\n    digits.push(d === 0 ? ZERO : BELOW_HUNDRED[d])\n  }\n  return digits.join(' ')\n}\n\n/**\n * Converts a numeric value to Marathi words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Marathi words\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Exports\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ZERO","HUNDRED","BELOW_HUNDRED","SCALE_WORDS","segmentToWords","n","hundreds","Math","trunc","remainder","value","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","segments","numStr","unshift","remaining","groupByThreeThenTwos","segmentCount","words","i","segmentValue","scaleIndex","push","join","integerToWords","char","d","decimalPartToWords"],"mappings":"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"}
+{"version":3,"file":"mr.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/mr.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 * Marathi language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Indian numbering system (हजार, लाख, कोटी)\n * - Devanagari script\n * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)\n * - Complete word forms for 0-99\n * - Per-digit decimal reading\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ZERO = 'शून्य'\nconst NEGATIVE = 'उणे'\nconst DECIMAL_SEP = 'दशांश'\nconst HUNDRED = 'शंभर'\n\nconst BELOW_HUNDRED = [\n  'शून्य', 'एक', 'दोन', 'तीन', 'चार', 'पाच', 'सहा', 'सात', 'आठ', 'नऊ',\n  'दहा', 'अकरा', 'बारा', 'तेरा', 'चौदा', 'पंधरा', 'सोळा', 'सतरा', 'अठरा', 'एकोणीस',\n  'वीस', 'एकवीस', 'बावीस', 'तेवीस', 'चोवीस', 'पंचवीस', 'सव्वीस', 'सत्तावीस', 'अठ्ठावीस', 'एकोणतीस',\n  'तीस', 'एकतीस', 'बत्तीस', 'तेहेतीस', 'चौतीस', 'पस्तीस', 'छत्तीस', 'सदतीस', 'अडतीस', 'एकोणचाळीस',\n  'चाळीस', 'एकेचाळीस', 'बेचाळीस', 'त्रेचाळीस', 'चव्वेचाळीस', 'पंचेचाळीस', 'सेहेचाळीस', 'सत्तेचाळीस', 'अठ्ठेचाळीस', 'एकोणपन्नास',\n  'पन्नास', 'एक्काव्वन', 'बावन्न', 'त्रेपन्न', 'चोपन्न', 'पंचाव्वन', 'छप्पन्न', 'सत्तावन्न', 'अठ्ठावन्न', 'एकोणसाठ',\n  'साठ', 'एकसष्ठ', 'बासष्ठ', 'त्रेसष्ठ', 'चौसष्ठ', 'पासष्ठ', 'सहासष्ठ', 'सदुसष्ठ', 'अडुसष्ठ', 'एकोणसत्तर',\n  'सत्तर', 'एकाहत्तर', 'बाहत्तर', 'त्र्याहत्तर', 'चौऱ्याहत्तर', 'पंच्याहत्तर', 'शहात्तर', 'सत्याहत्तर', 'अठ्ठ्याहत्तर', 'एकोणऐंशी',\n  'ऐंशी', 'एक्याऐंशी', 'ब्याऐंशी', 'त्र्याऐंशी', 'चौऱ्याऐंशी', 'पंच्याऐंशी', 'शहाऐंशी', 'सत्याऐंशी', 'अठ्ठ्याऐंशी', 'एकोणनव्वद',\n  'नव्वद', 'एक्याण्णव', 'ब्याण्णव', 'त्र्याण्णव', 'चौऱ्याण्णव', 'पंच्याण्णव', 'शहाण्णव', 'सत्याण्णव', 'अठ्ठ्याण्णव', 'नव्याण्णव'\n]\n\n// Scale words: index 0 = units (empty), 1 = thousand, 2 = lakh, 3 = crore, etc.\nconst SCALE_WORDS = ['', 'हजार', 'लाख', 'कोटी', 'अब्ज', 'खर्व', 'निखर्व', 'महापद्म', 'शंकू']\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds words for a 0-999 segment.\n */\nfunction buildSegment (n) {\n  if (n === 0) return ''\n  if (n < 100) return BELOW_HUNDRED[n]\n\n  const hundreds = Math.trunc(n / 100)\n  const remainder = n % 100\n\n  if (remainder === 0) {\n    return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED\n  }\n  return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED + ' ' + BELOW_HUNDRED[remainder]\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Marathi 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} Marathi words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000 (direct lookup)\n  if (n < 1000n) {\n    return buildSegment(Number(n))\n  }\n\n  // Extract segments using BigInt modulo\n  const segments = []\n  segments.push(Number(n % 1000n))\n  let temp = n / 1000n\n\n  while (temp > 0n) {\n    segments.push(Number(temp % 100n))\n    temp = temp / 100n\n  }\n\n  // Build result string (process from most-significant to least)\n  const words = []\n  for (let i = segments.length - 1; i >= 0; i--) {\n    const segment = segments[i]\n    if (segment === 0) continue\n\n    if (i === 0) {\n      words.push(buildSegment(segment))\n    } else {\n      words.push(BELOW_HUNDRED[segment])\n    }\n\n    if (i > 0 && SCALE_WORDS[i]) {\n      words.push(SCALE_WORDS[i])\n    }\n  }\n\n  return words.join(' ')\n}\n\nfunction decimalPartToWords (decimalPart) {\n  // Per-digit decimal reading\n  const digits = []\n  for (const char of decimalPart) {\n    const d = parseInt(char, 10)\n    digits.push(d === 0 ? ZERO : BELOW_HUNDRED[d])\n  }\n  return digits.join(' ')\n}\n\n/**\n * Converts a numeric value to Marathi words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Marathi words\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Exports\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ZERO","HUNDRED","BELOW_HUNDRED","SCALE_WORDS","buildSegment","n","hundreds","Math","trunc","remainder","value","type","Number","isFinite","Error","isSafeInteger","toString","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","result","NEGATIVE","segments","push","temp","words","i","segment","join","integerToWords","char","d","decimalPartToWords"],"mappings":"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"}

package/dist/languages/ms.js

@@ -1,3 +1,3 @@
-/*! n2words/ms v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const i=e.slice(0,n)||"0",r=e.slice(n+1);return{isNegative:t,integerPart:BigInt(i),decimalPart:r}}function n(e){const[t,n]=e.toLowerCase().split("e"),i=parseInt(n,10),r=t.indexOf("."),u=-1===r?t:t.slice(0,r)+t.slice(r+1),s=(-1===r?t.length:r)+i;return s>=u.length?u+"0".repeat(s-u.length):s<=0?"0."+"0".repeat(-s)+u:u.slice(0,s)+"."+u.slice(s)}const i=["","satu","dua","tiga","empat","lima","enam","tujuh","lapan","sembilan"],r=["sepuluh","sebelas","dua belas","tiga belas","empat belas","lima belas","enam belas","tujuh belas","lapan belas","sembilan belas"],u=["","","dua puluh","tiga puluh","empat puluh","lima puluh","enam puluh","tujuh puluh","lapan puluh","sembilan puluh"],s="ratus",a="ribu",l=["juta","bilion","trilion"],o="sifar";function c(e){if(0===e)return"";const t=e%10,n=Math.floor(e/10)%10,a=Math.floor(e/100),l=[];a>0&&l.push(1===a?"se"+s:i[a]+" "+s);const o=e%100;return 0===o||l.push(o<10?i[o]:o<20?r[o-10]:0===t?u[n]:u[n]+" "+i[t]),l.join(" ")}const f=new Array(1e3);for(let e=0;e<1e3;e++)f[e]=c(e);function p(e){if(0n===e)return o;if(e<1000n)return f[Number(e)];if(e<1000000n){const t=Number(e/1000n),n=Number(e%1000n);let i;return i=1===t?"se"+a:f[t]+" "+a,n>0&&(i+=" "+f[n]),i}return function(e){const t=e.toString(),n=t.length,i=[],r=n%3;let u=0;for(r>0&&(i.push(Number(t.slice(0,r))),u=r);u<n;)i.push(Number(t.slice(u,u+3))),u+=3;const s=[];let o=i.length-1;for(let e=0;e<i.length;e++){const t=i[e];if(0!==t)if(0===o)s.push(f[t]);else if(1===o)s.push(1===t?"se"+a:f[t]+" "+a);else{const e=l[o-2];s.push(1===t?"se"+e:f[t]+" "+e)}o--}return s.join(" ")}(e)}e.ms=function(e){const{isNegative:i,integerPart:r,decimalPart:u}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===i)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(e);let s="";return i&&(s="minus "),s+=p(r),u&&(s+=" perpuluhan "+function(e){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+=o,n++;const i=e.slice(n);return i&&(t&&(t+=" "),t+=p(BigInt(i))),t}(u)),s}},"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||{});
+/*! n2words/ms v3.1.0 | MIT License | github.com/forzagreen/n2words */
+var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const i=e.slice(0,n)||"0",r=e.slice(n+1);return{isNegative:t,integerPart:BigInt(i),decimalPart:r}}function n(e){const[t,n]=e.toLowerCase().split("e"),i=parseInt(n,10),r=t.indexOf("."),u=-1===r?t:t.slice(0,r)+t.slice(r+1),s=(-1===r?t.length:r)+i;return s>=u.length?u+"0".repeat(s-u.length):s<=0?"0."+"0".repeat(-s)+u:u.slice(0,s)+"."+u.slice(s)}const i=["","satu","dua","tiga","empat","lima","enam","tujuh","lapan","sembilan"],r=["sepuluh","sebelas","dua belas","tiga belas","empat belas","lima belas","enam belas","tujuh belas","lapan belas","sembilan belas"],u=["","","dua puluh","tiga puluh","empat puluh","lima puluh","enam puluh","tujuh puluh","lapan puluh","sembilan puluh"],s="ratus",a="ribu",l=["juta","bilion","trilion"],o="sifar";function c(e){if(0===e)return"";const t=e%10,n=Math.floor(e/10)%10,a=Math.floor(e/100),l=[];a>0&&l.push(1===a?"se"+s:i[a]+" "+s);const o=e%100;return 0===o||l.push(o<10?i[o]:o<20?r[o-10]:0===t?u[n]:u[n]+" "+i[t]),l.join(" ")}function f(e){if(0n===e)return o;if(e<1000n)return c(Number(e));if(e<1000000n){const t=Number(e/1000n),n=Number(e%1000n);let i;return i=1===t?"se"+a:c(t)+" "+a,n>0&&(i+=" "+c(n)),i}return function(e){const t=e.toString(),n=t.length,i=[],r=n%3;let u=0;for(r>0&&(i.push(Number(t.slice(0,r))),u=r);u<n;)i.push(Number(t.slice(u,u+3))),u+=3;const s=[];let o=i.length-1;for(let e=0;e<i.length;e++){const t=i[e];if(0!==t)if(0===o)s.push(c(t));else if(1===o)s.push(1===t?"se"+a:c(t)+" "+a);else{const e=l[o-2];s.push(1===t?"se"+e:c(t)+" "+e)}o--}return s.join(" ")}(e)}e.ms=function(e){const{isNegative:i,integerPart:r,decimalPart:u}=function(e){const i=typeof e;if("bigint"===i)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===i){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===i)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${i}`)}(e);let s="";return i&&(s="minus "),s+=f(r),u&&(s+=" perpuluhan "+function(e){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+=o,n++;const i=e.slice(n);return i&&(t&&(t+=" "),t+=f(BigInt(i))),t}(u)),s}},"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=ms.js.map

package/dist/languages/ms.js.map

@@ -1 +1 @@
-{"version":3,"file":"ms.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/ms.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 * Malay (Bahasa Melayu) language converter - Functional Implementation\n *\n * Self-contained converter with precomputed lookup tables.\n *\n * Key features:\n * - \"Se-\" prefix for ALL singular scale units (seratus, seribu, sejuta, sebilion)\n * - Regular patterns (puluh for tens, ratus for hundreds)\n * - Teens with \"belas\" suffix\n * - Note: \"lapan\" (8) differs from Indonesian \"delapan\"\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES = ['', 'satu', 'dua', 'tiga', 'empat', 'lima', 'enam', 'tujuh', 'lapan', 'sembilan']\nconst TEENS = ['sepuluh', 'sebelas', 'dua belas', 'tiga belas', 'empat belas', 'lima belas', 'enam belas', 'tujuh belas', 'lapan belas', 'sembilan belas']\nconst TENS = ['', '', 'dua puluh', 'tiga puluh', 'empat puluh', 'lima puluh', 'enam puluh', 'tujuh puluh', 'lapan puluh', 'sembilan puluh']\n\nconst HUNDRED_WORD = 'ratus'\nconst THOUSAND_WORD = 'ribu'\nconst SCALE_WORDS = ['juta', 'bilion', 'trilion']\n\nconst ZERO = 'sifar'\nconst NEGATIVE = 'minus'\nconst DECIMAL_SEP = 'perpuluhan'\n\n// ============================================================================\n// Precomputed Lookup Tables\n// ============================================================================\n\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const onesDigit = n % 10\n  const tensDigit = Math.floor(n / 10) % 10\n  const hundredsDigit = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds: seratus (100) or N ratus (200-900)\n  if (hundredsDigit > 0) {\n    if (hundredsDigit === 1) {\n      parts.push('se' + HUNDRED_WORD)\n    } else {\n      parts.push(ONES[hundredsDigit] + ' ' + HUNDRED_WORD)\n    }\n  }\n\n  // Tens and ones\n  const tensOnes = n % 100\n\n  if (tensOnes === 0) {\n    // Just hundreds\n  } else if (tensOnes < 10) {\n    parts.push(ONES[tensOnes])\n  } else if (tensOnes < 20) {\n    parts.push(TEENS[tensOnes - 10])\n  } else if (onesDigit === 0) {\n    parts.push(TENS[tensDigit])\n  } else {\n    parts.push(TENS[tensDigit] + ' ' + ONES[onesDigit])\n  }\n\n  return parts.join(' ')\n}\n\nconst SEGMENTS = new Array(1000)\nfor (let i = 0; i < 1000; i++) {\n  SEGMENTS[i] = buildSegment(i)\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  if (n < 1000n) {\n    return SEGMENTS[Number(n)]\n  }\n\n  if (n < 1_000_000n) {\n    const thousands = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    let result\n    if (thousands === 1) {\n      result = 'se' + THOUSAND_WORD\n    } else {\n      result = SEGMENTS[thousands] + ' ' + THOUSAND_WORD\n    }\n\n    if (remainder > 0) {\n      result += ' ' + SEGMENTS[remainder]\n    }\n\n    return result\n  }\n\n  return buildLargeNumberWords(n)\n}\n\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      if (scaleIndex === 0) {\n        parts.push(SEGMENTS[segment])\n      } else if (scaleIndex === 1) {\n        if (segment === 1) {\n          parts.push('se' + THOUSAND_WORD)\n        } else {\n          parts.push(SEGMENTS[segment] + ' ' + THOUSAND_WORD)\n        }\n      } else {\n        // Malay: \"se-\" prefix for ALL scale words when segment is 1\n        const scaleWord = SCALE_WORDS[scaleIndex - 2]\n        if (segment === 1) {\n          parts.push('se' + scaleWord)\n        } else {\n          parts.push(SEGMENTS[segment] + ' ' + scaleWord)\n        }\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\nfunction decimalPartToWords (decimalPart) {\n  let result = ''\n\n  let i = 0\n  while (i < decimalPart.length && decimalPart[i] === '0') {\n    if (result) result += ' '\n    result += ZERO\n    i++\n  }\n\n  const remainder = decimalPart.slice(i)\n  if (remainder) {\n    if (result) result += ' '\n    result += integerToWords(BigInt(remainder))\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Malay words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Malay words\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Exports\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","TEENS","TENS","HUNDRED_WORD","THOUSAND_WORD","SCALE_WORDS","ZERO","buildSegment","n","onesDigit","tensDigit","Math","floor","hundredsDigit","parts","push","tensOnes","join","SEGMENTS","Array","i","integerToWords","Number","thousands","remainder","result","numStr","toString","len","segments","remainderLen","pos","scaleIndex","segment","scaleWord","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":"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"}
+{"version":3,"file":"ms.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/ms.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 * Malay (Bahasa Melayu) language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - \"Se-\" prefix for ALL singular scale units (seratus, seribu, sejuta, sebilion)\n * - Regular patterns (puluh for tens, ratus for hundreds)\n * - Teens with \"belas\" suffix\n * - Note: \"lapan\" (8) differs from Indonesian \"delapan\"\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary\n// ============================================================================\n\nconst ONES = ['', 'satu', 'dua', 'tiga', 'empat', 'lima', 'enam', 'tujuh', 'lapan', 'sembilan']\nconst TEENS = ['sepuluh', 'sebelas', 'dua belas', 'tiga belas', 'empat belas', 'lima belas', 'enam belas', 'tujuh belas', 'lapan belas', 'sembilan belas']\nconst TENS = ['', '', 'dua puluh', 'tiga puluh', 'empat puluh', 'lima puluh', 'enam puluh', 'tujuh puluh', 'lapan puluh', 'sembilan puluh']\n\nconst HUNDRED_WORD = 'ratus'\nconst THOUSAND_WORD = 'ribu'\nconst SCALE_WORDS = ['juta', 'bilion', 'trilion']\n\nconst ZERO = 'sifar'\nconst NEGATIVE = 'minus'\nconst DECIMAL_SEP = 'perpuluhan'\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\nfunction buildSegment (n) {\n  if (n === 0) return ''\n\n  const onesDigit = n % 10\n  const tensDigit = Math.floor(n / 10) % 10\n  const hundredsDigit = Math.floor(n / 100)\n\n  const parts = []\n\n  // Hundreds: seratus (100) or N ratus (200-900)\n  if (hundredsDigit > 0) {\n    if (hundredsDigit === 1) {\n      parts.push('se' + HUNDRED_WORD)\n    } else {\n      parts.push(ONES[hundredsDigit] + ' ' + HUNDRED_WORD)\n    }\n  }\n\n  // Tens and ones\n  const tensOnes = n % 100\n\n  if (tensOnes === 0) {\n    // Just hundreds\n  } else if (tensOnes < 10) {\n    parts.push(ONES[tensOnes])\n  } else if (tensOnes < 20) {\n    parts.push(TEENS[tensOnes - 10])\n  } else if (onesDigit === 0) {\n    parts.push(TENS[tensDigit])\n  } else {\n    parts.push(TENS[tensDigit] + ' ' + ONES[onesDigit])\n  }\n\n  return parts.join(' ')\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  if (n < 1000n) {\n    return buildSegment(Number(n))\n  }\n\n  if (n < 1_000_000n) {\n    const thousands = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    let result\n    if (thousands === 1) {\n      result = 'se' + THOUSAND_WORD\n    } else {\n      result = buildSegment(thousands) + ' ' + THOUSAND_WORD\n    }\n\n    if (remainder > 0) {\n      result += ' ' + buildSegment(remainder)\n    }\n\n    return result\n  }\n\n  return buildLargeNumberWords(n)\n}\n\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      if (scaleIndex === 0) {\n        parts.push(buildSegment(segment))\n      } else if (scaleIndex === 1) {\n        if (segment === 1) {\n          parts.push('se' + THOUSAND_WORD)\n        } else {\n          parts.push(buildSegment(segment) + ' ' + THOUSAND_WORD)\n        }\n      } else {\n        // Malay: \"se-\" prefix for ALL scale words when segment is 1\n        const scaleWord = SCALE_WORDS[scaleIndex - 2]\n        if (segment === 1) {\n          parts.push('se' + scaleWord)\n        } else {\n          parts.push(buildSegment(segment) + ' ' + scaleWord)\n        }\n      }\n    }\n\n    scaleIndex--\n  }\n\n  return parts.join(' ')\n}\n\nfunction decimalPartToWords (decimalPart) {\n  let result = ''\n\n  let i = 0\n  while (i < decimalPart.length && decimalPart[i] === '0') {\n    if (result) result += ' '\n    result += ZERO\n    i++\n  }\n\n  const remainder = decimalPart.slice(i)\n  if (remainder) {\n    if (result) result += ' '\n    result += integerToWords(BigInt(remainder))\n  }\n\n  return result\n}\n\n/**\n * Converts a numeric value to Malay words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Malay words\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Exports\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","TEENS","TENS","HUNDRED_WORD","THOUSAND_WORD","SCALE_WORDS","ZERO","buildSegment","n","onesDigit","tensDigit","Math","floor","hundredsDigit","parts","push","tensOnes","join","integerToWords","Number","thousands","remainder","result","numStr","toString","len","segments","remainderLen","pos","scaleIndex","i","segment","scaleWord","buildLargeNumberWords","value","type","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":"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"}

package/dist/languages/nb.js

@@ -1,3 +1,3 @@
-/*! n2words/nb v3.0.0 | MIT License | github.com/forzagreen/n2words */
-var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const r=e.slice(0,n)||"0",i=e.slice(n+1);return{isNegative:t,integerPart:BigInt(r),decimalPart:i}}function n(e){const[t,n]=e.toLowerCase().split("e"),r=parseInt(n,10),i=t.indexOf("."),o=-1===i?t:t.slice(0,i)+t.slice(i+1),s=(-1===i?t.length:i)+r;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const r=["","en","to","tre","fire","fem","seks","syv","åtte","ni"],i=["ti","elleve","tolv","tretten","fjorten","femten","seksten","sytten","atten","nitten"],o=["","","tjue","tretti","førti","femti","seksti","sytti","åtti","nitti"],s="tusen",u="null",l=["million","milliard","billion","billiard","kvintillion","sekstillion","septillion","oktillion"];function d(e){if(0===e)return{word:"",hasHundred:!1};const t=e%10,n=Math.floor(e/10)%10,s=Math.floor(e/100),u=[];let l=!1;s>0&&(l=!0,u.push(r[s]+" hundre"));const d=e%100;return 0===d||u.push(d<10?r[t]:d<20?i[t]:0===t?o[n]:o[n]+"-"+r[t]),2===u.length?{word:u[0]+" og "+u[1],hasHundred:!0}:{word:u[0]||"",hasHundred:l}}const f=new Array(1e3),a=new Array(1e3);for(let e=0;e<1e3;e++){const t=d(e);f[e]=t.word,a[e]=t.hasHundred}function c(e){if(0n===e)return u;if(e<1000n)return f[Number(e)];if(e<1000000n){const t=Number(e/1000n),n=Number(e%1000n);let r=f[t]+" "+s;return n>0&&(r+=a[n]?", "+f[n]:" og "+f[n]),r}return function(e){const t=e.toString(),n=t.length,r=[],i=n%3;let o=0;for(i>0&&(r.push(Number(t.slice(0,i))),o=i);o<n;)r.push(Number(t.slice(o,o+3))),o+=3;const d=[];let c=r.length-1;for(let e=0;e<r.length;e++){const t=r[e];if(0!==t){const e=f[t];d.push(0===c?{word:e,hasHundred:a[t],type:"units"}:1===c?{word:e+" "+s,hasHundred:!1,type:"thousand"}:{word:e+" "+l[c-2],hasHundred:!1,type:"million"})}c--}return function(e){if(0===e.length)return u;if(1===e.length)return e[0].word;const t=[];for(let n=0;n<e.length;n++){const r=e[n],i=e[n+1];t.push(r.word),i&&t.push("thousand"===r.type?i.hasHundred?", ":" og ":"million"===r.type?"units"!==i.type||i.hasHundred?" ":" og ":" ")}return t.join("")}(d)}(e)}e.nb=function(e){const{isNegative:r,integerPart:i,decimalPart:o}=function(e){const r=typeof e;if("bigint"===r)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===r){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===r)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${r}`)}(e);let s="";return r&&(s="minus "),s+=c(i),o&&(s+=" komma "+function(e){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+=u,n++;const r=e.slice(n);return r&&(t&&(t+=" "),t+=c(BigInt(r))),t}(o)),s}},"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||{});
+/*! n2words/nb v3.1.0 | MIT License | github.com/forzagreen/n2words */
+var e,t;e=this,t=function(e){"use strict";function t(e){const t="-"===e[0];t&&(e=e.slice(1));const n=e.indexOf(".");if(-1===n)return{isNegative:t,integerPart:BigInt(e)};const r=e.slice(0,n)||"0",i=e.slice(n+1);return{isNegative:t,integerPart:BigInt(r),decimalPart:i}}function n(e){const[t,n]=e.toLowerCase().split("e"),r=parseInt(n,10),i=t.indexOf("."),o=-1===i?t:t.slice(0,i)+t.slice(i+1),s=(-1===i?t.length:i)+r;return s>=o.length?o+"0".repeat(s-o.length):s<=0?"0."+"0".repeat(-s)+o:o.slice(0,s)+"."+o.slice(s)}const r=["","en","to","tre","fire","fem","seks","syv","åtte","ni"],i=["ti","elleve","tolv","tretten","fjorten","femten","seksten","sytten","atten","nitten"],o=["","","tjue","tretti","førti","femti","seksti","sytti","åtti","nitti"],s="tusen",u="null",l=["million","milliard","billion","billiard","kvintillion","sekstillion","septillion","oktillion"];function d(e){if(0===e)return{word:"",hasHundred:!1};const t=e%10,n=Math.floor(e/10)%10,s=Math.floor(e/100),u=[];let l=!1;s>0&&(l=!0,u.push(r[s]+" hundre"));const d=e%100;return 0===d||u.push(d<10?r[t]:d<20?i[t]:0===t?o[n]:o[n]+"-"+r[t]),2===u.length?{word:u[0]+" og "+u[1],hasHundred:!0}:{word:u[0]||"",hasHundred:l}}function f(e){if(0n===e)return u;if(e<1000n)return d(Number(e)).word;if(e<1000000n){const t=Number(e/1000n),n=Number(e%1000n);let r=d(t).word+" "+s;if(n>0){const e=d(n);r+=e.hasHundred?", "+e.word:" og "+e.word}return r}return function(e){const t=e.toString(),n=t.length,r=[],i=n%3;let o=0;for(i>0&&(r.push(Number(t.slice(0,i))),o=i);o<n;)r.push(Number(t.slice(o,o+3))),o+=3;const f=[];let a=r.length-1;for(let e=0;e<r.length;e++){const t=r[e];if(0!==t){const e=d(t);f.push(0===a?{word:e.word,hasHundred:e.hasHundred,type:"units"}:1===a?{word:e.word+" "+s,hasHundred:!1,type:"thousand"}:{word:e.word+" "+l[a-2],hasHundred:!1,type:"million"})}a--}return function(e){if(0===e.length)return u;if(1===e.length)return e[0].word;const t=[];for(let n=0;n<e.length;n++){const r=e[n],i=e[n+1];t.push(r.word),i&&t.push("thousand"===r.type?i.hasHundred?", ":" og ":"million"===r.type?"units"!==i.type||i.hasHundred?" ":" og ":" ")}return t.join("")}(f)}(e)}e.nb=function(e){const{isNegative:r,integerPart:i,decimalPart:o}=function(e){const r=typeof e;if("bigint"===r)return e<0n?{isNegative:!0,integerPart:-e}:{isNegative:!1,integerPart:e};if("number"===r){if(!Number.isFinite(e))throw new Error("Number must be finite (NaN and Infinity are not supported)");return Number.isSafeInteger(e)?e<0?{isNegative:!0,integerPart:BigInt(-e)}:{isNegative:!1,integerPart:BigInt(e)}:t(function(e){const t=e.toString();return t.includes("e")||t.includes("E")?n(t):t}(e))}if("string"===r)return t(function(e){const t=e.trim();if(0===t.length||Number.isNaN(Number(t)))throw new Error(`Invalid number format: "${e}"`);return t.includes("e")||t.includes("E")?n(t):t}(e));throw new TypeError(`Invalid value type: expected number, string, or bigint, received ${r}`)}(e);let s="";return r&&(s="minus "),s+=f(i),o&&(s+=" komma "+function(e){let t="",n=0;for(;n<e.length&&"0"===e[n];)t&&(t+=" "),t+=u,n++;const r=e.slice(n);return r&&(t&&(t+=" "),t+=f(BigInt(r))),t}(o)),s}},"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=nb.js.map

package/dist/languages/nb.js.map

@@ -1 +1 @@
-{"version":3,"file":"nb.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/nb.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 * Norwegian Bokmål language converter - Functional Implementation\n *\n * A performance-optimized number-to-words converter using precomputed lookup tables.\n *\n * Key features:\n * - Hyphenated tens+ones: \"tjue-en\" (21)\n * - \"og\" conjunction after hundreds\n * - Comma separator after thousands before hundreds\n * - Short scale: million, milliard, billion, etc.\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\nconst ONES = ['', 'en', 'to', 'tre', 'fire', 'fem', 'seks', 'syv', 'åtte', 'ni']\n\nconst TEENS = ['ti', 'elleve', 'tolv', 'tretten', 'fjorten', 'femten', 'seksten', 'sytten', 'atten', 'nitten']\nconst TENS = ['', '', 'tjue', 'tretti', 'førti', 'femti', 'seksti', 'sytti', 'åtti', 'nitti']\n\nconst HUNDRED = 'hundre'\nconst THOUSAND = 'tusen'\n\nconst ZERO = 'null'\nconst NEGATIVE = 'minus'\nconst DECIMAL_SEP = 'komma'\n\n// Short scale: million, milliard, billion, etc.\nconst SCALES = ['million', 'milliard', 'billion', 'billiard', 'kvintillion', 'sekstillion', 'septillion', 'oktillion']\n\n// ============================================================================\n// Precomputed Lookup Tables (built once at module load)\n// ============================================================================\n\n/**\n * Builds segment word for 0-999.\n * Returns object with word and hasHundred flag.\n */\nfunction buildSegment (n) {\n  if (n === 0) return { word: '', hasHundred: false }\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  let hasHundred = false\n\n  // Hundreds: \"en hundre\", \"to hundre\"\n  if (hundreds > 0) {\n    hasHundred = true\n    parts.push(ONES[hundreds] + ' ' + HUNDRED)\n  }\n\n  // Tens and ones\n  const tensOnes = n % 100\n\n  if (tensOnes === 0) {\n    // Just hundreds\n  } else if (tensOnes < 10) {\n    // Single digit\n    parts.push(ONES[ones])\n  } else if (tensOnes < 20) {\n    // Teens\n    parts.push(TEENS[ones])\n  } else if (ones === 0) {\n    // Even tens\n    parts.push(TENS[tens])\n  } else {\n    // Hyphenated: \"tjue-en\"\n    parts.push(TENS[tens] + '-' + ONES[ones])\n  }\n\n  // Combine with \" og \" between hundreds and remainder\n  if (parts.length === 2) {\n    return { word: parts[0] + ' og ' + parts[1], hasHundred: true }\n  }\n  return { word: parts[0] || '', hasHundred }\n}\n\n// Precompute all 1000 segment words (0-999)\nconst SEGMENTS = new Array(1000)\nconst SEGMENTS_HAS_HUNDRED = new Array(1000)\n\nfor (let i = 0; i < 1000; i++) {\n  const result = buildSegment(i)\n  SEGMENTS[i] = result.word\n  SEGMENTS_HAS_HUNDRED[i] = result.hasHundred\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Norwegian Bokmål words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Norwegian 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 SEGMENTS[Number(n)]\n  }\n\n  // Fast path: numbers < 1,000,000 (thousands)\n  if (n < 1_000_000n) {\n    const thousands = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    let result = SEGMENTS[thousands] + ' ' + THOUSAND\n\n    if (remainder > 0) {\n      // Comma before hundreds, \" og \" before small numbers\n      if (SEGMENTS_HAS_HUNDRED[remainder]) {\n        result += ', ' + SEGMENTS[remainder]\n      } else {\n        result += ' og ' + SEGMENTS[remainder]\n      }\n    }\n\n    return result\n  }\n\n  // For numbers >= 1,000,000, use scale decomposition\n  return buildLargeNumberWords(n)\n}\n\n/**\n * Builds words for numbers >= 1,000,000.\n *\n * @param {bigint} n - Number >= 1,000,000\n * @returns {string} Norwegian words\n */\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  // Build segments of 3 digits from right to left\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  // Convert segments to words\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      const segmentWord = SEGMENTS[segment]\n      const hasHundred = SEGMENTS_HAS_HUNDRED[segment]\n\n      if (scaleIndex === 0) {\n        // Units segment\n        parts.push({ word: segmentWord, hasHundred, type: 'units' })\n      } else if (scaleIndex === 1) {\n        // Thousands\n        parts.push({ word: segmentWord + ' ' + THOUSAND, hasHundred: false, type: 'thousand' })\n      } else {\n        // Millions+\n        const scaleWord = SCALES[scaleIndex - 2]\n        parts.push({ word: segmentWord + ' ' + scaleWord, hasHundred: false, type: 'million' })\n      }\n    }\n\n    scaleIndex--\n  }\n\n  // Join parts with Norwegian rules\n  return joinNorwegianParts(parts)\n}\n\n/**\n * Joins parts with Norwegian spacing and comma rules.\n *\n * @param {Array} parts - Parts with type metadata\n * @returns {string} Joined string\n */\nfunction joinNorwegianParts (parts) {\n  if (parts.length === 0) return ZERO\n  if (parts.length === 1) return parts[0].word\n\n  const result = []\n\n  for (let i = 0; i < parts.length; i++) {\n    const part = parts[i]\n    const nextPart = parts[i + 1]\n\n    result.push(part.word)\n\n    if (nextPart) {\n      if (part.type === 'thousand') {\n        // After thousands: comma if next has hundred, else \" og \"\n        if (nextPart.hasHundred) {\n          result.push(', ')\n        } else {\n          result.push(' og ')\n        }\n      } else if (part.type === 'million') {\n        // After millions: \" og \" for units without hundred, space otherwise\n        if (nextPart.type === 'units' && !nextPart.hasHundred) {\n          result.push(' og ')\n        } else {\n          result.push(' ')\n        }\n      } else {\n        result.push(' ')\n      }\n    }\n  }\n\n  return result.join('')\n}\n\n/**\n * Converts decimal digits to Norwegian words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Norwegian 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 Norwegian Bokmål words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Norwegian 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)       // 'tjue-en'\n * toWords(101)      // 'en hundre og en'\n * toWords(1000000)  // 'en million'\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","TEENS","TENS","THOUSAND","ZERO","SCALES","buildSegment","n","word","hasHundred","ones","tens","Math","floor","hundreds","parts","push","tensOnes","SEGMENTS","Array","SEGMENTS_HAS_HUNDRED","i","result","integerToWords","Number","thousands","remainder","numStr","toString","len","segments","remainderLen","pos","scaleIndex","segment","segmentWord","type","part","nextPart","join","joinNorwegianParts","buildLargeNumberWords","value","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":"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"}
+{"version":3,"file":"nb.js","sources":["../../lib/utils/parse-numeric.js","../../lib/languages/nb.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 * Norwegian Bokmål language converter - Functional Implementation\n *\n * Self-contained module with its own input validation, ready for subpath exports.\n *\n * Key features:\n * - Hyphenated tens+ones: \"tjue-en\" (21)\n * - \"og\" conjunction after hundreds\n * - Comma separator after thousands before hundreds\n * - Short scale: million, milliard, billion, etc.\n */\n\nimport { parseNumericValue } from '../utils/parse-numeric.js'\n\n// ============================================================================\n// Vocabulary (module-level constants)\n// ============================================================================\n\nconst ONES = ['', 'en', 'to', 'tre', 'fire', 'fem', 'seks', 'syv', 'åtte', 'ni']\n\nconst TEENS = ['ti', 'elleve', 'tolv', 'tretten', 'fjorten', 'femten', 'seksten', 'sytten', 'atten', 'nitten']\nconst TENS = ['', '', 'tjue', 'tretti', 'førti', 'femti', 'seksti', 'sytti', 'åtti', 'nitti']\n\nconst HUNDRED = 'hundre'\nconst THOUSAND = 'tusen'\n\nconst ZERO = 'null'\nconst NEGATIVE = 'minus'\nconst DECIMAL_SEP = 'komma'\n\n// Short scale: million, milliard, billion, etc.\nconst SCALES = ['million', 'milliard', 'billion', 'billiard', 'kvintillion', 'sekstillion', 'septillion', 'oktillion']\n\n// ============================================================================\n// Segment Building\n// ============================================================================\n\n/**\n * Builds segment word for 0-999.\n * Returns object with word and hasHundred flag.\n */\nfunction buildSegment (n) {\n  if (n === 0) return { word: '', hasHundred: false }\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  let hasHundred = false\n\n  // Hundreds: \"en hundre\", \"to hundre\"\n  if (hundreds > 0) {\n    hasHundred = true\n    parts.push(ONES[hundreds] + ' ' + HUNDRED)\n  }\n\n  // Tens and ones\n  const tensOnes = n % 100\n\n  if (tensOnes === 0) {\n    // Just hundreds\n  } else if (tensOnes < 10) {\n    // Single digit\n    parts.push(ONES[ones])\n  } else if (tensOnes < 20) {\n    // Teens\n    parts.push(TEENS[ones])\n  } else if (ones === 0) {\n    // Even tens\n    parts.push(TENS[tens])\n  } else {\n    // Hyphenated: \"tjue-en\"\n    parts.push(TENS[tens] + '-' + ONES[ones])\n  }\n\n  // Combine with \" og \" between hundreds and remainder\n  if (parts.length === 2) {\n    return { word: parts[0] + ' og ' + parts[1], hasHundred: true }\n  }\n  return { word: parts[0] || '', hasHundred }\n}\n\n// ============================================================================\n// Conversion Functions\n// ============================================================================\n\n/**\n * Converts a non-negative integer to Norwegian Bokmål words.\n *\n * @param {bigint} n - Non-negative integer to convert\n * @returns {string} Norwegian words\n */\nfunction integerToWords (n) {\n  if (n === 0n) return ZERO\n\n  // Fast path: numbers < 1000\n  if (n < 1000n) {\n    return buildSegment(Number(n)).word\n  }\n\n  // Fast path: numbers < 1,000,000 (thousands)\n  if (n < 1_000_000n) {\n    const thousands = Number(n / 1000n)\n    const remainder = Number(n % 1000n)\n\n    let result = buildSegment(thousands).word + ' ' + THOUSAND\n\n    if (remainder > 0) {\n      const remainderResult = buildSegment(remainder)\n      // Comma before hundreds, \" og \" before small numbers\n      if (remainderResult.hasHundred) {\n        result += ', ' + remainderResult.word\n      } else {\n        result += ' og ' + remainderResult.word\n      }\n    }\n\n    return result\n  }\n\n  // For numbers >= 1,000,000, use scale decomposition\n  return buildLargeNumberWords(n)\n}\n\n/**\n * Builds words for numbers >= 1,000,000.\n *\n * @param {bigint} n - Number >= 1,000,000\n * @returns {string} Norwegian words\n */\nfunction buildLargeNumberWords (n) {\n  const numStr = n.toString()\n  const len = numStr.length\n\n  // Build segments of 3 digits from right to left\n  const segments = []\n  const segmentSize = 3\n\n  const remainderLen = len % segmentSize\n  let pos = 0\n  if (remainderLen > 0) {\n    segments.push(Number(numStr.slice(0, remainderLen)))\n    pos = remainderLen\n  }\n  while (pos < len) {\n    segments.push(Number(numStr.slice(pos, pos + segmentSize)))\n    pos += segmentSize\n  }\n\n  // Convert segments to words\n  const parts = []\n  let scaleIndex = segments.length - 1\n\n  for (let i = 0; i < segments.length; i++) {\n    const segment = segments[i]\n\n    if (segment !== 0) {\n      const segmentResult = buildSegment(segment)\n\n      if (scaleIndex === 0) {\n        // Units segment\n        parts.push({ word: segmentResult.word, hasHundred: segmentResult.hasHundred, type: 'units' })\n      } else if (scaleIndex === 1) {\n        // Thousands\n        parts.push({ word: segmentResult.word + ' ' + THOUSAND, hasHundred: false, type: 'thousand' })\n      } else {\n        // Millions+\n        const scaleWord = SCALES[scaleIndex - 2]\n        parts.push({ word: segmentResult.word + ' ' + scaleWord, hasHundred: false, type: 'million' })\n      }\n    }\n\n    scaleIndex--\n  }\n\n  // Join parts with Norwegian rules\n  return joinNorwegianParts(parts)\n}\n\n/**\n * Joins parts with Norwegian spacing and comma rules.\n *\n * @param {Array} parts - Parts with type metadata\n * @returns {string} Joined string\n */\nfunction joinNorwegianParts (parts) {\n  if (parts.length === 0) return ZERO\n  if (parts.length === 1) return parts[0].word\n\n  const result = []\n\n  for (let i = 0; i < parts.length; i++) {\n    const part = parts[i]\n    const nextPart = parts[i + 1]\n\n    result.push(part.word)\n\n    if (nextPart) {\n      if (part.type === 'thousand') {\n        // After thousands: comma if next has hundred, else \" og \"\n        if (nextPart.hasHundred) {\n          result.push(', ')\n        } else {\n          result.push(' og ')\n        }\n      } else if (part.type === 'million') {\n        // After millions: \" og \" for units without hundred, space otherwise\n        if (nextPart.type === 'units' && !nextPart.hasHundred) {\n          result.push(' og ')\n        } else {\n          result.push(' ')\n        }\n      } else {\n        result.push(' ')\n      }\n    }\n  }\n\n  return result.join('')\n}\n\n/**\n * Converts decimal digits to Norwegian words.\n *\n * @param {string} decimalPart - Decimal digits (without the point)\n * @returns {string} Norwegian 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 Norwegian Bokmål words.\n *\n * @param {number | string | bigint} value - The numeric value to convert\n * @returns {string} The number in Norwegian 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)       // 'tjue-en'\n * toWords(101)      // 'en hundre og en'\n * toWords(1000000)  // 'en million'\n */\nfunction toWords (value) {\n  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)\n\n  let result = ''\n\n  if (isNegative) {\n    result = NEGATIVE + ' '\n  }\n\n  result += integerToWords(integerPart)\n\n  if (decimalPart) {\n    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)\n  }\n\n  return result\n}\n\n// ============================================================================\n// Public API\n// ============================================================================\n\nexport { toWords }\n"],"names":["parseNumericString","str","isNegative","slice","dotIndex","indexOf","integerPart","BigInt","integerStr","decimalPart","expandScientificNotation","mantissa","expStr","toLowerCase","split","exp","parseInt","digits","newDotPosition","length","repeat","ONES","TEENS","TENS","THOUSAND","ZERO","SCALES","buildSegment","n","word","hasHundred","ones","tens","Math","floor","hundreds","parts","push","tensOnes","integerToWords","Number","thousands","remainder","result","remainderResult","numStr","toString","len","segments","remainderLen","pos","scaleIndex","i","segment","segmentResult","type","part","nextPart","join","joinNorwegianParts","buildLargeNumberWords","value","isFinite","Error","isSafeInteger","includes","numberToString","trimmed","trim","isNaN","normalizeString","TypeError","parseNumericValue","NEGATIVE","decimalPartToWords"],"mappings":"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"}