{"version":3,"sources":["../src/constants/constants.ts","../src/functions/cardinalConverter.ts","../src/functions/ordinalConverter.ts","../src/functions/romanConverter.ts","../src/functions/arabicConverter.ts","../src/functions/italianConverter.ts"],"sourcesContent":["export const zeroNineteen = [\n  'zero',\n  'uno',\n  'due',\n  'tre',\n  'quattro',\n  'cinque',\n  'sei',\n  'sette',\n  'otto',\n  'nove',\n  'dieci',\n  'undici',\n  'dodici',\n  'tredici',\n  'quattordici',\n  'quindici',\n  'sedici',\n  'diciassette',\n  'diciotto',\n  'diciannove',\n];\n\nexport const zeroTenOrdinals = [\n  'zeresimo',\n  'primo',\n  'secondo',\n  'terzo',\n  'quarto',\n  'quinto',\n  'sesto',\n  'settimo',\n  'ottavo',\n  'nono',\n  'decimo',\n];\n\nexport const tens = [\n  'venti',\n  'trenta',\n  'quaranta',\n  'cinquanta',\n  'sessanta',\n  'settanta',\n  'ottanta',\n  'novanta',\n];\n\nexport const hundred = 'cento';\nexport const thousands = ['mille', 'mila'];\nexport const millions = ['un milione', ' milioni'];\nexport const billions = ['un miliardo', ' miliardi'];\n\nexport const and = ' e ';\n\nexport const romanNumerals: { [key: string]: number } = {\n  I: 1,\n  V: 5,\n  X: 10,\n  L: 50,\n  C: 100,\n  D: 500,\n  M: 1000,\n};\n\nexport const romanUnits = [\n  '',\n  'I',\n  'II',\n  'III',\n  'IV',\n  'V',\n  'VI',\n  'VII',\n  'VIII',\n  'IX',\n];\n\nexport const romanTens = [\n  '',\n  'X',\n  'XX',\n  'XXX',\n  'XL',\n  'L',\n  'LX',\n  'LXX',\n  'LXXX',\n  'XC',\n];\n\nexport const romanHundreds = [\n  '',\n  'C',\n  'CC',\n  'CCC',\n  'CD',\n  'D',\n  'DC',\n  'DCC',\n  'DCCC',\n  'CM',\n];\n\nexport const romanThousands = [\n  '',\n  'M',\n  'MM',\n  'MMM',\n];\n\nexport const unitsDict : { [unit: string] : number } = {\n  un: 1,\n  uno: 1,\n  due: 2,\n  tre: 3,\n  tré: 3,\n  quattro: 4,\n  cinque: 5,\n  sei: 6,\n  sette: 7,\n  otto: 8,\n  nove: 9,\n  dieci: 10,\n  undici: 11,\n  dodici: 12,\n  tredici: 13,\n  quattordici: 14,\n  quindici: 15,\n  sedici: 16,\n  diciassette: 17,\n  diciotto: 18,\n  diciannove: 19,\n};\n\nexport const tensDict : { [ten: string] : number } = {\n  venti: 20,\n  trenta: 30,\n  quaranta: 40,\n  cinquanta: 50,\n  sessanta: 60,\n  settanta: 70,\n  ottanta: 80,\n  novanta: 90,\n};\n","import {\n  zeroNineteen,\n  tens,\n  hundred,\n  thousands,\n  millions,\n  billions,\n  and,\n} from '../constants/constants';\n\nexport type CardinalConverterOptions = {\n  includeDecimals?: boolean;\n}\n\nconst tensConverter = (n: number): string => {\n  if (n < 20) {\n    return zeroNineteen[n];\n  }\n\n  const firstDigit = Math.floor(n / 10) - 2;\n  const secondDigit = n % 10;\n  const word = tens[firstDigit];\n\n  if (secondDigit === 0) {\n    return word;\n  }\n\n  if (secondDigit === 1 || secondDigit === 8) {\n    return word.slice(0, word.length - 1) + zeroNineteen[secondDigit];\n  }\n\n  return word + zeroNineteen[secondDigit];\n};\n\nconst hundredsConverter = (n: number): string => {\n  const firstDigit = Math.floor(n / 100);\n  if (firstDigit === 1) {\n    return hundred;\n  }\n\n  return zeroNineteen[firstDigit] + hundred;\n};\n\nconst wordCalculator = (n: number): string => {\n  const digitsNumber = n === 0 ? 1 : Math.floor(Math.log10(n)) + 1;\n\n  if (digitsNumber < 3) {\n    return tensConverter(n);\n  }\n  if (digitsNumber < 4) {\n    if (n % 100 === 0) {\n      return hundredsConverter(n);\n    }\n\n    if (n % 100 > 79 && n % 100 < 90) {\n      const word = hundredsConverter(n);\n      return word.slice(0, word.length - 1) + wordCalculator(n % 100);\n    }\n\n    return hundredsConverter(n) + wordCalculator(n % 100);\n  }\n  // thousands\n  if (digitsNumber < 7) {\n    const firstDigits = Math.floor(n / 1000);\n    if (firstDigits === 1) {\n      if (n % 1000 === 0) {\n        return thousands[0];\n      }\n      return thousands[0] + wordCalculator(n % 1000);\n    }\n    if (n % 1000 === 0) {\n      return wordCalculator(firstDigits) + thousands[1];\n    }\n    return (\n      wordCalculator(firstDigits) + thousands[1] + wordCalculator(n % 1000)\n    );\n  }\n  // millions\n  if (digitsNumber < 10) {\n    const firstDigits = Math.floor(n / 1000000);\n    if (firstDigits === 1) {\n      if (n % 1000000 === 0) {\n        return millions[0];\n      }\n      return millions[0] + and + wordCalculator(n % 1000000);\n    }\n    if (n % 1000000 === 0) {\n      return wordCalculator(firstDigits) + millions[1];\n    }\n    return (\n      wordCalculator(firstDigits) + millions[1] + and + wordCalculator(n % 1000000)\n    );\n  }\n  // billions\n  const firstDigits = Math.floor(n / 1000000000);\n  if (firstDigits === 1) {\n    if (n % 1000000000 === 0) {\n      return billions[0];\n    }\n    return billions[0] + and + wordCalculator(n % 1000000000);\n  }\n  if (n % 1000000000 === 0) {\n    return wordCalculator(firstDigits) + billions[1];\n  }\n  return (\n    wordCalculator(firstDigits) + billions[1] + and + wordCalculator(n % 1000000000)\n  );\n};\n\n/**\n * Converts a numeric value into its Italian cardinal word representation.\n *\n * This function accepts a number and returns its Italian word representation\n * as a cardinal number. Optionally, it can include the decimal part in the result.\n * The valid range for the input number is -999999999999 to 999999999999.\n *\n * @param {number} number - The numeric value to convert. Must be a valid finite number.\n * @param {CardinalConverterOptions} options - Configuration options.\n * Default is `{ includeDecimals: false }`.\n * @param {boolean} [options.includeDecimals=false]\n * - Whether to include the decimal part in the result.\n *\n * @returns {string} The Italian cardinal word representation of the input number.\n *\n * @throws {Error}\n * Throws an error if the input is not a valid number.\n * @throws {Error}\n * Throws an error if the input is greater than 999999999999 or lower than -999999999999.\n *\n * @example\n * cardinalConverter(1); // 'uno'\n * cardinalConverter(90); // 'novanta'\n * cardinalConverter(709); // 'settecentonove'\n * cardinalConverter(1000.05, { includeDecimals: true }); // 'mille/05'\n * cardinalConverter(9, { includeDecimals: true }); // 'nove/00'\n * cardinalConverter(-1); // 'meno uno'\n * cardinalConverter(Infinity); // 'infinito'\n * cardinalConverter(NaN); // Throws Error: \"not a number\"\n */\nconst cardinalConverter = (\n  number: number,\n  options: CardinalConverterOptions = { includeDecimals: false },\n): string => {\n  if (Number.isNaN(number)) {\n    throw new Error('not a number');\n  }\n  if (number === Infinity) {\n    return 'infinito';\n  }\n  if (number === -Infinity) {\n    return 'meno infinito';\n  }\n\n  if (number > 999999999999) {\n    throw new Error('greater than 999999999999');\n  }\n  if (number < -999999999999) {\n    throw new Error('lower than -999999999999');\n  }\n\n  let prepend = '';\n  if (number < 0) {\n    prepend = 'meno ';\n  }\n  const n = Math.trunc(Math.abs(number));\n\n  let result = prepend + wordCalculator(n);\n  if (result.endsWith('tre') && result !== 'tre') {\n    result = result.replace(/.$/, 'é');\n  }\n\n  if (result.includes('tre ')) {\n    result = result.replace(/(?<=\\w+)tre\\s/g, 'tré ');\n  }\n\n  if (options.includeDecimals) {\n    const absStr = Math.abs(number).toString();\n    const dotIndex = absStr.indexOf('.');\n    const decimalStr = dotIndex === -1 ? '00' : absStr.slice(dotIndex + 1, dotIndex + 3).padEnd(2, '0');\n    result = `${result}/${decimalStr}`;\n  }\n\n  return result;\n};\n\nexport default cardinalConverter;\n","import { zeroTenOrdinals } from '../constants/constants';\nimport cardinalConverter from './cardinalConverter';\n\nexport type OrdinalConverterOptions = {\n  female?: boolean;\n  plural?: boolean;\n}\n\nconst converter = (n: number): string => {\n  if (n < 11) {\n    return zeroTenOrdinals[n];\n  }\n\n  let word = cardinalConverter(n);\n\n  word = word.replaceAll(' e ', ' ');\n  word = word.replace(/([io])\\s([ou])/g, (_match, p1, p2) => {\n    if (p2 === 'o') {\n      return p1;\n    }\n    return p2;\n  });\n  word = word.replace(/un\\s/g, '');\n  word = word.replace(/ouno$/g, 'uno');\n  word = word.replace(/ootto$/g, 'otto');\n  word = word.replaceAll(' ', '');\n\n  const lastDigit = n % 10;\n\n  if (n % 100 !== 13 && lastDigit === 3) {\n    return `${word.replace(/.$/, 'e')}esimo`;\n  }\n  if (n % 100 !== 16 && lastDigit === 6) {\n    return `${word}esimo`;\n  }\n  if (n % 100 === 10) {\n    return word.replace(/dieci$/g, 'decimo');\n  }\n  if (word.endsWith('mila')) {\n    return word.replace(/mila/, 'millesimo');\n  }\n\n  return `${word.replace(/.$/, '')}esimo`;\n};\n\n/**\n * Converts a number into its Italian word representation in ordinal form.\n *\n * @param {number} number\n * A positive integer or Infinity. Must be a valid number (not NaN), less than\n * or equal to 999,999,999,999.\n * Infinity is represented as \"infinitesimo\".\n * @param {OrdinalConverterOptions} options\n * Configuration options for the conversion.\n * - `options.female` (optional): If `true`, returns the representation in feminine form.\n * - `options.plural` (optional): If `true`, returns the representation in plural form.\n *\n * Both `female` and `plural` can be used together.\n *\n * @returns {string}\n * The Italian word representing the ordinal number.\n * Example:\n *  - 1 -> \"primo\",\n *  - 10 -> \"decimo\",\n *  - Infinity -> \"infinitesimo\".\n *\n * @throws {Error} Throws an error if:\n *  - The number is NaN.\n *  - The number is greater than 999,999,999,999.\n *  - The number is negative.\n *\n * @example\n * // Basic usage:\n * ordinalConverter(1); // 'primo'\n * ordinalConverter(10); // 'decimo'\n * ordinalConverter(63); // 'sessantatreesimo'\n *\n * // Special case:\n * ordinalConverter(Infinity); // 'infinitesimo'\n *\n * // Feminine form:\n * ordinalConverter(1, { female: true }); // 'prima'\n * ordinalConverter(15, { female: true }); // 'quindicesima'\n * ordinalConverter(109, { female: true }); // 'centonovesima'\n *\n * // Plural form:\n * ordinalConverter(1, { plural: true }); // 'primi'\n * ordinalConverter(18, { plural: true }); // 'diciottesimi'\n * ordinalConverter(89, { plural: true }); // 'ottantanovesimi'\n *\n * // Feminine plural form:\n * ordinalConverter(1, { plural: true, female: true }); // 'prime'\n * ordinalConverter(70, { plural: true, female: true }); // 'settantesime'\n * ordinalConverter(110, { plural: true, female: true }); // 'centodecime'\n *\n * @description\n * This function converts numbers into their ordinal form in Italian, handling:\n * - Standard ordinal forms.\n * - Feminine and/or plural variations.\n * - Special case for Infinity.\n * - Error handling for invalid inputs.\n *\n * Note:\n * - The `female` and `plural` options modify only the suffix of the word\n * (e.g., \"a\" for feminine or \"i/e\" for plural forms).\n * - For large numbers or unexpected inputs, ensure proper validation before usage.\n */\nconst ordinalConverter = (\n  number: number,\n  options: OrdinalConverterOptions = { female: false, plural: false },\n): string => {\n  if (number < 0) {\n    throw new Error('negative number not allowed');\n  }\n\n  const n = Math.trunc(number);\n  const result = converter(n);\n\n  const { female, plural } = options;\n\n  if (female && plural) {\n    return result.replace(/.$/, 'e');\n  }\n\n  if (female) {\n    return result.replace(/.$/, 'a');\n  }\n\n  if (plural) {\n    return result.replace(/.$/, 'i');\n  }\n\n  return result;\n};\n\nexport default ordinalConverter;\n","import {\n  romanHundreds,\n  romanTens,\n  romanThousands,\n  romanUnits,\n} from '../constants/constants';\n\n/**\n * Converts an Arabic numeral into its Roman numeral representation.\n *\n * This function converts a given Arabic number (integer) into its equivalent\n * Roman numeral format. It supports numbers within the range of 1 to 3999,\n * inclusive.\n *\n * @param {number} number - The Arabic numeral to convert. Must be an integer between 1 and 3999.\n * @returns {string} The Roman numeral representation of the input number.\n * @throws {Error} Throws an error if the input is not a valid number.\n * @throws {Error} Throws an error if the number is less than 1 or greater than 3999.\n *\n * @example\n * romanConverter(1); // 'I'\n * romanConverter(79); // 'LXXIX'\n * romanConverter(2317); // 'MMCCCXVII'\n * romanConverter(NaN); // Throws Error: \"not a number\"\n * romanConverter(0); // Throws Error: \"lower than 1\"\n * romanConverter(4000); // Throws Error: \"greater than 3999\"\n * romanConverter(Infinity); // 'infinitum'\n */\nconst romanConverter = (number: number): string => {\n  if (Number.isNaN(number)) {\n    throw new Error('not a number');\n  }\n  if (number === Infinity) {\n    return 'infinitum';\n  }\n\n  if (!Number.isInteger(number)) {\n    throw new Error('not an integer');\n  }\n\n  if (number > 3999) {\n    throw new Error('greater than 3999');\n  }\n\n  if (number < 1) {\n    throw new Error('lower than 1');\n  }\n\n  const unit = number % 10;\n  const ten = Math.floor(number / 10) % 10;\n  const hundred = Math.floor(number / 100) % 10;\n  const thousand = Math.floor(number / 1000) % 10;\n\n  const result = `${romanThousands[thousand]}${romanHundreds[hundred]}${romanTens[ten]}${romanUnits[unit]}`;\n  return result;\n};\n\nexport default romanConverter;\n","import { romanNumerals } from '../constants/constants';\n\nconst validRomanPattern = /^M{0,3}(CM|CD|D?C{0,3})(XC|XL|L?X{0,3})(IX|IV|V?I{0,3})$/;\n\n/**\n * Converts a Roman numeral into its Arabic numeral representation.\n *\n * This function takes a valid Roman numeral string and converts it into its\n * equivalent Arabic number (integer). It supports standard Roman numeral notation.\n * Invalid inputs, including unsupported characters or improper formatting, will\n * trigger an error.\n *\n * @param {string} romanNumber - The Roman numeral to convert. Must be a valid Roman numeral.\n * @returns {number} The Arabic numeral representation of the input Roman numeral.\n * @throws {Error} - Throws an error if the input string is not a valid Roman numeral.\n *\n * @example\n * arabicConverter('MD'); // 1500\n * arabicConverter('CDXC'); // 490\n * arabicConverter('MCMXC'); // 1990\n * arabicConverter('infinitum'); // Infinity\n * arabicConverter('ABC'); // Throws Error: \"invalid roman number\"\n * arabicConverter(''); // Throws Error: \"invalid roman number\"\n */\nexport const arabicConverter = (romanNumber: string): number => {\n  if (romanNumber === 'infinitum') {\n    return Infinity;\n  }\n\n  if (!romanNumber || !validRomanPattern.test(romanNumber)) {\n    throw new Error('invalid roman number');\n  }\n\n  let number = 0;\n\n  for (let i = 0; i < romanNumber.length; i++) {\n    let arabicNumber = romanNumerals[romanNumber.charAt(i)];\n\n    if (i + 1 < romanNumber.length) {\n      const nextArabicNumber = romanNumerals[romanNumber.charAt(i + 1)];\n      if (arabicNumber < nextArabicNumber) {\n        arabicNumber *= -1;\n      }\n    }\n\n    number += arabicNumber;\n  }\n\n  return number;\n};\n\nexport default arabicConverter;\n","import { unitsDict, tensDict, zeroTenOrdinals } from '../constants/constants';\n\nconst tensPrefixes = Object.keys(tensDict).map((w) => ({\n  prefix: w.slice(0, -1),\n  full: w,\n}));\n\nconst tensConverter = (word: string): number => {\n  if (unitsDict[word]) {\n    return unitsDict[word];\n  }\n\n  const entry = tensPrefixes.find(({ prefix }) => word.startsWith(prefix));\n  const ten = entry?.full;\n  if (!ten) {\n    return NaN;\n  }\n\n  const result = tensDict[ten];\n  if (word === ten) {\n    return result;\n  }\n\n  let [, unit] = word.split(ten);\n  if (!unit) {\n    [, unit] = word.split(ten.slice(0, -1));\n  }\n  if (!unitsDict[unit]) {\n    return NaN;\n  }\n  return result + unitsDict[unit];\n};\n\nconst hundredsConverter = (word: string): number => {\n  const [hundred, ten] = word.split('cento');\n  if (ten === undefined) {\n    return tensConverter(hundred);\n  }\n  let result = -1;\n  if (hundred === '') {\n    result = 100;\n  } else {\n    if (!unitsDict[hundred]) {\n      return NaN;\n    }\n    result = unitsDict[hundred] * 100;\n  }\n  if (ten !== '') {\n    const tensWord = ten.startsWith('tt') ? `o${ten}` : ten;\n    result += tensConverter(tensWord);\n  }\n\n  return result;\n};\n\nconst numberCalculator = (word: string): number => {\n  // billions\n  let index = word.indexOf('miliard');\n  if (index > -1) {\n    const sub = word.slice(index + 8);\n    let rest = 0;\n    if (sub) {\n      rest = numberCalculator(sub);\n    }\n    return hundredsConverter(word.slice(0, index)) * 1000000000 + rest;\n  }\n\n  // millions\n  index = word.indexOf('milion');\n  if (index > -1) {\n    const sub = word.slice(index + 7);\n    let rest = 0;\n    if (sub) {\n      rest = numberCalculator(sub);\n    }\n    return hundredsConverter(word.slice(0, index)) * 1000000 + rest;\n  }\n\n  // thousands\n  index = word.indexOf('mila');\n  if (index > -1) {\n    const sub = word.slice(index + 4);\n    let rest = 0;\n    if (sub) {\n      rest = numberCalculator(sub);\n    }\n    return hundredsConverter(word.slice(0, index)) * 1000 + rest;\n  }\n\n  index = word.indexOf('mille');\n  if (index > -1) {\n    const sub = word.slice(index + 5);\n    if (!sub) {\n      return 1000;\n    }\n    return 1000 + hundredsConverter(sub);\n  }\n\n  return hundredsConverter(word);\n};\n\nconst ordinalRules: [RegExp, string][] = [\n  [/decim\\w$/, 'dieci'],\n  [/centesim\\w$/, 'cento'],\n  [/^millesim\\w$/, 'mille'],\n  [/millesim\\w$/, 'mila'],\n  [/^milionesim\\w$/, 'unmilione'],\n  [/milionesim\\w$/, 'milioni'],\n  [/^miliardesim\\w$/, 'unmiliardo'],\n  [/miliardesim\\w$/, 'miliardi'],\n  [/ventesim\\w$/, 'venti'],\n  [/ntesim\\w$/, 'nta'],\n  [/unesim\\w$/, 'uno'],\n  [/quattresim\\w$/, 'quattro'],\n  [/ottesim\\w$/, 'otto'],\n  [/duesim\\w$/, 'due'],\n  [/cinquesim\\w$/, 'cinque'],\n  [/settesim\\w$/, 'sette'],\n  [/novesim\\w$/, 'nove'],\n  [/undicesim\\w$/, 'undici'],\n  [/dodicesim\\w$/, 'dodici'],\n  [/tredicesim\\w$/, 'tredici'],\n  [/quattordicesim\\w$/, 'quattordici'],\n  [/quindicesim\\w$/, 'quindici'],\n  [/sedicesim\\w$/, 'sedici'],\n  [/esim\\w$/, ''],\n];\n\nconst postOrdinalRules: [RegExp, string][] = [\n  [/^milione/, 'unmilione'],\n  [/^miliard/, 'unmiliardo'],\n  [/centuno/, 'centouno'],\n  [/centotto/, 'centootto'],\n  [/miliarduno/, 'miliardouno'],\n  [/miliardotto/, 'miliardootto'],\n];\n\nconst getNumberFromOrdinal = (ordinal: string): string => {\n  let cardinal = ordinal;\n  ordinalRules.forEach(([pattern, replacement]) => {\n    cardinal = cardinal.replace(pattern, replacement);\n  });\n  postOrdinalRules.forEach(([pattern, replacement]) => {\n    cardinal = cardinal.replace(pattern, replacement);\n  });\n  return cardinal;\n};\n\n/**\n * Converts an Italian word representation of a number into its numeric value.\n *\n * @param {string} word\n * The Italian word representing a number, which may include ordinals, decimals, or negative values.\n * Special values like \"infinito\" (Infinity) are also supported.\n *\n * @returns {number}\n * The numeric value corresponding to the word, or NaN if the input cannot be converted.\n * Returns Infinity for words like \"infinito\".\n *\n * @example\n * italianConverter('uno'); // 1\n * italianConverter('novantasette'); // 97\n * italianConverter('un milione tredicimila'); // 1013000\n * italianConverter('zeresimo'); // 0\n * italianConverter('prima'); // 1\n * italianConverter('quattrocentotredicesime'); // 413\n * italianConverter('venti/40'); // 20.40\n * italianConverter('infinitesimi'); // Infinity\n *\n * @description\n * This function processes an Italian word representing a number, handling cases like:\n * - Removing spaces and conjunctions (e.g., \"un milione e cento\").\n * - Supporting negative numbers (e.g., \"meno due\").\n * - Parsing decimal numbers in formats like \"venti/40\".\n * - Handling ordinal forms like \"prima\" or \"quindicesimo\".\n * - Recognizing \"infinito\" and related words as Infinity.\n *\n * Note:\n * - Case sensitivity is handled (input is converted to lowercase internally).\n * - The function expects well-formed input; unexpected input may yield NaN.\n */\nconst italianConverter = (word: string): number => {\n  let escapedWord = word.toLowerCase();\n  escapedWord = escapedWord.replaceAll(' e ', '');\n  escapedWord = escapedWord.replaceAll(' ', '');\n\n  let multiplier = 1;\n  if (escapedWord.startsWith('meno')) {\n    multiplier = -1;\n    escapedWord = escapedWord.replace('meno', '');\n  }\n\n  if (escapedWord === 'infinito') {\n    return multiplier * Infinity;\n  }\n\n  if (escapedWord === 'zero') {\n    return 0;\n  }\n\n  let decimals = 0;\n  if (escapedWord.match(/\\/\\d\\d$/)) {\n    let stringDecimals: string;\n    [escapedWord, stringDecimals] = escapedWord.split('/');\n    decimals = parseInt(stringDecimals, 10) / 100;\n  }\n\n  if (escapedWord.match(/\\w*(a|o|e|i)$/)) {\n    const index = zeroTenOrdinals.findIndex((ord) => escapedWord.startsWith(ord.slice(0, -1)));\n    if (index !== -1) {\n      return index;\n    }\n    if (escapedWord.match(/infinitesim(a|o|e|i)$/)) {\n      return Infinity;\n    }\n    if (escapedWord.match(/\\w*(esim|decim)(a|o|e|i)$/)) {\n      escapedWord = getNumberFromOrdinal(escapedWord);\n    }\n  }\n\n  const result = numberCalculator(escapedWord) * multiplier + decimals;\n  return result;\n};\n\nexport default italianConverter;\n"],"mappings":"AAAO,IAAMA,EAAe,CAC1B,OACA,MACA,MACA,MACA,UACA,SACA,MACA,QACA,OACA,OACA,QACA,SACA,SACA,UACA,cACA,WACA,SACA,cACA,WACA,YACF,EAEaC,EAAkB,CAC7B,WACA,QACA,UACA,QACA,SACA,SACA,QACA,UACA,SACA,OACA,QACF,EAEaC,EAAO,CAClB,QACA,SACA,WACA,YACA,WACA,WACA,UACA,SACF,EAEaC,EAAU,QACVC,EAAY,CAAC,QAAS,MAAM,EAC5BC,EAAW,CAAC,aAAc,UAAU,EACpCC,EAAW,CAAC,cAAe,WAAW,EAEtCC,EAAM,MAENC,EAA2C,CACtD,EAAG,EACH,EAAG,EACH,EAAG,GACH,EAAG,GACH,EAAG,IACH,EAAG,IACH,EAAG,GACL,EAEaC,EAAa,CACxB,GACA,IACA,KACA,MACA,KACA,IACA,KACA,MACA,OACA,IACF,EAEaC,EAAY,CACvB,GACA,IACA,KACA,MACA,KACA,IACA,KACA,MACA,OACA,IACF,EAEaC,EAAgB,CAC3B,GACA,IACA,KACA,MACA,KACA,IACA,KACA,MACA,OACA,IACF,EAEaC,EAAiB,CAC5B,GACA,IACA,KACA,KACF,EAEaC,EAA0C,CACrD,GAAI,EACJ,IAAK,EACL,IAAK,EACL,IAAK,EACL,SAAK,EACL,QAAS,EACT,OAAQ,EACR,IAAK,EACL,MAAO,EACP,KAAM,EACN,KAAM,EACN,MAAO,GACP,OAAQ,GACR,OAAQ,GACR,QAAS,GACT,YAAa,GACb,SAAU,GACV,OAAQ,GACR,YAAa,GACb,SAAU,GACV,WAAY,EACd,EAEaC,EAAwC,CACnD,MAAO,GACP,OAAQ,GACR,SAAU,GACV,UAAW,GACX,SAAU,GACV,SAAU,GACV,QAAS,GACT,QAAS,EACX,EClIA,IAAMC,EAAiBC,GAAsB,CAC3C,GAAIA,EAAI,GACN,OAAOC,EAAaD,CAAC,EAGvB,IAAME,EAAa,KAAK,MAAMF,EAAI,EAAE,EAAI,EAClCG,EAAcH,EAAI,GAClBI,EAAOC,EAAKH,CAAU,EAE5B,OAAIC,IAAgB,EACXC,EAGLD,IAAgB,GAAKA,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","names":["zeroNineteen","zeroTenOrdinals","tens","hundred","thousands","millions","billions","and","romanNumerals","romanUnits","romanTens","romanHundreds","romanThousands","unitsDict","tensDict","tensConverter","n","zeroNineteen","firstDigit","secondDigit","word","tens","hundredsConverter","hundred","wordCalculator","digitsNumber","firstDigits","thousands","millions","and","billions","cardinalConverter","number","options","prepend","result","absStr","dotIndex","decimalStr","cardinalConverter_default","converter","n","zeroTenOrdinals","word","cardinalConverter_default","_match","p1","p2","lastDigit","ordinalConverter","number","options","result","female","plural","ordinalConverter_default","romanConverter","number","unit","ten","hundred","thousand","romanThousands","romanHundreds","romanTens","romanUnits","romanConverter_default","validRomanPattern","arabicConverter","romanNumber","number","arabicNumber","romanNumerals","nextArabicNumber","arabicConverter_default","tensPrefixes","tensDict","w","tensConverter","word","unitsDict","ten","prefix","result","unit","hundredsConverter","hundred","tensWord","numberCalculator","index","sub","rest","ordinalRules","postOrdinalRules","getNumberFromOrdinal","ordinal","cardinal","pattern","replacement","italianConverter","escapedWord","multiplier","decimals","stringDecimals","zeroTenOrdinals","ord","italianConverter_default"]}