@flickfyi/flkr 0.0.140 → 0.0.146

package/node_modules/numeric-quantity/dist/numeric-quantity.legacy-esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-quantity.legacy-esm.js","names":[],"sources":["../src/constants.ts","../src/parseRomanNumerals.ts","../src/numericQuantity.ts","../src/isNumericQuantity.ts"],"sourcesContent":["import type {\n  NumericQuantityOptions,\n  RomanNumeralAscii,\n  RomanNumeralUnicode,\n  SubscriptDigit,\n  SuperscriptDigit,\n  VulgarFraction,\n} from './types';\n\n// #region Decimal_Number Unicode category\n\n/**\n * Unicode decimal digit block start code points.\n * Each block contains 10 contiguous digits (0-9).\n * This list covers all \\p{Nd} (Decimal_Number) blocks through Unicode 17.0.\n * The drift test in index.test.ts validates completeness against the JS engine.\n */\nconst decimalDigitBlockStarts = [\n  0x0030, // ASCII (0-9)\n  0x0660, // Arabic-Indic\n  0x06f0, // Extended Arabic-Indic (Persian/Urdu)\n  0x07c0, // NKo\n  0x0966, // Devanagari\n  0x09e6, // Bengali\n  0x0a66, // Gurmukhi\n  0x0ae6, // Gujarati\n  0x0b66, // Oriya\n  0x0be6, // Tamil\n  0x0c66, // Telugu\n  0x0ce6, // Kannada\n  0x0d66, // Malayalam\n  0x0de6, // Sinhala Lith\n  0x0e50, // Thai\n  0x0ed0, // Lao\n  0x0f20, // Tibetan\n  0x1040, // Myanmar\n  0x1090, // Myanmar Shan\n  0x17e0, // Khmer\n  0x1810, // Mongolian\n  0x1946, // Limbu\n  0x19d0, // New Tai Lue\n  0x1a80, // Tai Tham Hora\n  0x1a90, // Tai Tham Tham\n  0x1b50, // Balinese\n  0x1bb0, // Sundanese\n  0x1c40, // Lepcha\n  0x1c50, // Ol Chiki\n  0xa620, // Vai\n  0xa8d0, // Saurashtra\n  0xa900, // Kayah Li\n  0xa9d0, // Javanese\n  0xa9f0, // Myanmar Tai Laing\n  0xaa50, // Cham\n  0xabf0, // Meetei Mayek\n  0xff10, // Fullwidth\n  0x104a0, // Osmanya\n  0x10d30, // Hanifi Rohingya\n  0x10d40, // Garay\n  0x11066, // Brahmi\n  0x110f0, // Sora Sompeng\n  0x11136, // Chakma\n  0x111d0, // Sharada\n  0x112f0, // Khudawadi\n  0x11450, // Newa\n  0x114d0, // Tirhuta\n  0x11650, // Modi\n  0x116c0, // Takri\n  0x116d0, // Myanmar Pao\n  0x116da, // Myanmar Eastern Pwo Karen\n  0x11730, // Ahom\n  0x118e0, // Warang Citi\n  0x11950, // Dives Akuru\n  0x11bf0, // Sunuwar\n  0x11c50, // Bhaiksuki\n  0x11d50, // Masaram Gondi\n  0x11da0, // Gunjala Gondi\n  0x11de0, // Tolong Siki\n  0x11f50, // Kawi\n  0x16130, // Gurung Khema\n  0x16a60, // Mro\n  0x16ac0, // Tangsa\n  0x16b50, // Pahawh Hmong\n  0x16d70, // Kirat Rai\n  0x1ccf0, // Outlined Digits\n  0x1d7ce, // Mathematical Bold\n  0x1d7d8, // Mathematical Double-Struck\n  0x1d7e2, // Mathematical Sans-Serif\n  0x1d7ec, // Mathematical Sans-Serif Bold\n  0x1d7f6, // Mathematical Monospace\n  0x1e140, // Nyiakeng Puachue Hmong\n  0x1e2f0, // Wancho\n  0x1e4f0, // Nag Mundari\n  0x1e5f1, // Ol Onal\n  0x1e950, // Adlam\n  0x1fbf0, // Segmented Digits\n] as const;\n\n// RegExp ctor (not literal) so old Babel regex transforms (e.g. Expo Snackager) skip `\\p{}`\nconst unicodeDecimalDigitRegex = new RegExp('\\\\p{Nd}', 'gu');\n\n/**\n * Normalizes non-ASCII decimal digits to ASCII digits.\n * Converts characters from Unicode decimal digit blocks (e.g., Arabic-Indic,\n * Devanagari, Bengali) to their ASCII equivalents (0-9).\n *\n * All current Unicode \\p{Nd} blocks are included in decimalDigitBlockStarts.\n */\nexport const normalizeDigits = (str: string): string =>\n  str.replace(unicodeDecimalDigitRegex, ch => {\n    const cp = ch.codePointAt(0)!;\n    // ASCII digits (0x0030-0x0039) don't need conversion\n    if (cp <= 0x39) return ch;\n    // Binary search for the largest block start ≤ cp\n    let lo = 0;\n    let hi = decimalDigitBlockStarts.length - 1;\n    while (lo < hi) {\n      const mid = (lo + hi + 1) >>> 1;\n      if (decimalDigitBlockStarts[mid] <= cp) {\n        lo = mid;\n      } else {\n        hi = mid - 1;\n      }\n    }\n    return String(cp - decimalDigitBlockStarts[lo]!);\n  });\n\n/**\n * Map of Unicode superscript and subscript digit code points to ASCII digits.\n */\nexport const superSubDigitToAsciiMap: Record<SuperscriptDigit | SubscriptDigit, `${number}`> = {\n  '⁰': '0',\n  '¹': '1',\n  '²': '2',\n  '³': '3',\n  '⁴': '4',\n  '⁵': '5',\n  '⁶': '6',\n  '⁷': '7',\n  '⁸': '8',\n  '⁹': '9',\n  '₀': '0',\n  '₁': '1',\n  '₂': '2',\n  '₃': '3',\n  '₄': '4',\n  '₅': '5',\n  '₆': '6',\n  '₇': '7',\n  '₈': '8',\n  '₉': '9',\n} as const;\n\n/**\n * Captures Unicode superscript and subscript digits.\n */\nexport const superSubDigitsRegex: RegExp = /[⁰¹²³⁴⁵⁶⁷⁸⁹₀₁₂₃₄₅₆₇₈₉]/g;\n\n/**\n * Map of Unicode fraction code points to their ASCII equivalents.\n */\nexport const vulgarFractionToAsciiMap: Record<VulgarFraction, `${number}/${number | ''}`> = {\n  '¼': '1/4',\n  '½': '1/2',\n  '¾': '3/4',\n  '⅐': '1/7',\n  '⅑': '1/9',\n  '⅒': '1/10',\n  '⅓': '1/3',\n  '⅔': '2/3',\n  '⅕': '1/5',\n  '⅖': '2/5',\n  '⅗': '3/5',\n  '⅘': '4/5',\n  '⅙': '1/6',\n  '⅚': '5/6',\n  '⅛': '1/8',\n  '⅜': '3/8',\n  '⅝': '5/8',\n  '⅞': '7/8',\n  '⅟': '1/',\n} as const;\n\n/**\n * Captures the individual elements of a numeric string. Commas and underscores are allowed\n * as separators, as long as they appear between digits and are not consecutive.\n *\n * Capture groups:\n *\n * |  #  | Description                                        | Example(s)                                                              |\n * | --- | -------------------------------------------------- | ----------------------------------------------------------------------- |\n * | `0` | entire match                                       | `\"2 1/3\"` from `\"2 1/3\"`                                                |\n * | `1` | sign (`-` or `+`)                                  | `\"-\"` from `\"-2 1/3\"`                                                   |\n * | `2` | whole number or numerator                          | `\"2\"` from `\"2 1/3\"`; `\"1\"` from `\"1/3\"`                                |\n * | `3` | entire tail: fraction, decimal, and/or exponent    | `\" 1/3\"` from `\"2 1/3\"`; `\".23\"` from `\"1.23\"`; `\".5e3\"` from `\"1.5e3\"` |\n * | `4` | exponent, when there is no decimal portion         | `\"e3\"` from `\"1e3\"`                                                     |\n * | `5` | exponent, when there is a decimal portion          | `\"e-3\"` from `\"1.5e-3\"`                                                 |\n * | `6` | numerator of a mixed number (incl. leading space)  | `\" 2\"` from `\"1 2/3\"`                                                   |\n *\n * Groups 4–6 are subgroups of group 3 and are not used directly by\n * {@link numericQuantity}; only groups 1–3 are consumed.\n *\n * _Capture groups 2 and 3 may include comma/underscore separators._\n *\n * @example\n *\n * ```ts\n * numericRegex.exec(\"1\")      // [ \"1\",      null, \"1\",     null,     null, null,  null ]\n * numericRegex.exec(\"1.23\")   // [ \"1.23\",   null, \"1\",     \".23\",    null, null,  null ]\n * numericRegex.exec(\"1 2/3\")  // [ \"1 2/3\",  null, \"1\",     \" 2/3\",   null, null,  \" 2\" ]\n * numericRegex.exec(\"2/3\")    // [ \"2/3\",    null, \"2\",     \"/3\",     null, null,  null ]\n * numericRegex.exec(\"2 / 3\")  // [ \"2 / 3\",  null, \"2\",     \" / 3\",   null, null,  null ]\n * numericRegex.exec(\"-2 1/3\") // [ \"-2 1/3\", \"-\",  \"2\",     \" 1/3\",   null, null,  \" 1\" ]\n * numericRegex.exec(\"1e3\")    // [ \"1e3\",    null, \"1\",     \"e3\",     \"e3\", null,  null ]\n * numericRegex.exec(\"1.5e-3\") // [ \"1.5e-3\", null, \"1\",     \".5e-3\",  null, \"e-3\", null ]\n * numericRegex.exec(\"1,000\")  // [ \"1,000\",  null, \"1,000\", null,     null, null,  null ]\n * ```\n *\n * @remarks\n *\n * This pattern and {@link numericRegexWithTrailingInvalid} are maintained as two separate\n * literals and must be kept in sync. They differ _only_ in the tail: `$` here versus\n * `(\\s*[^.\\d/].*)?` there. `src/index.test.ts` asserts that equality.\n *\n * Group 2 is `((?:\\d(?:[,_]\\d|\\d)*)?)`, deliberately `?` and not `*`. Every string the\n * inner group matches begins and ends with a digit, so concatenating two of them yields\n * another string of the same shape: an outer `*` would add no strings to the language,\n * only exponentially many ways to split one digit run across iterations. That made a\n * failing match catastrophically backtrack — `'1'.repeat(30) + '!'` took ~15s on V8.\n */\nexport const numericRegex: RegExp =\n  /^(?=[-+]?\\s*\\.\\d|[-+]?\\s*\\d)([-+])?\\s*((?:\\d(?:[,_]\\d|\\d)*)?)(([eE][+-]?\\d(?:[,_]\\d|\\d)*)?|\\.\\d(?:[,_]\\d|\\d)*([eE][+-]?\\d(?:[,_]\\d|\\d)*)?|(\\s+\\d(?:[,_]\\d|\\d)*\\s*)?\\s*\\/\\s*\\d(?:[,_]\\d|\\d)*)?$/;\n/**\n * Same as {@link numericRegex}, but allows (and ignores) trailing invalid characters.\n * Capture groups 1–6 are identical to {@link numericRegex}'s; capture group 7 contains the\n * trailing invalid portion.\n *\n * @example\n *\n * ```ts\n * numericRegexWithTrailingInvalid.exec(\"1abc\")\n * // [ \"1abc\",      null, \"1\", null,   null, null, null, \"abc\"  ]\n * numericRegexWithTrailingInvalid.exec(\"1 2/3 xyz\")\n * // [ \"1 2/3 xyz\", null, \"1\", \" 2/3\", null, null, \" 2\", \" xyz\" ]\n * ```\n *\n * @remarks\n *\n * Must be kept in sync with {@link numericRegex} — see that pattern's remarks.\n */\nexport const numericRegexWithTrailingInvalid: RegExp =\n  /^(?=[-+]?\\s*\\.\\d|[-+]?\\s*\\d)([-+])?\\s*((?:\\d(?:[,_]\\d|\\d)*)?)(([eE][+-]?\\d(?:[,_]\\d|\\d)*)?|\\.\\d(?:[,_]\\d|\\d)*([eE][+-]?\\d(?:[,_]\\d|\\d)*)?|(\\s+\\d(?:[,_]\\d|\\d)*\\s*)?\\s*\\/\\s*\\d(?:[,_]\\d|\\d)*)?(\\s*[^.\\d/].*)?/;\n\n/**\n * Captures any Unicode vulgar fractions.\n */\nexport const vulgarFractionsRegex: RegExp = /([¼½¾⅐⅑⅒⅓⅔⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞⅟])/g;\n\n// #endregion\n\n// #region Roman numerals\n\n/**\n * Map of Roman numeral sequences to their decimal equivalents.\n */\nexport const romanNumeralValues: {\n  [\n    k in\n      | `${RomanNumeralAscii}`\n      | `${RomanNumeralAscii}${RomanNumeralAscii}`\n      | `${RomanNumeralAscii}${RomanNumeralAscii}${RomanNumeralAscii}`\n      | `${RomanNumeralAscii}${RomanNumeralAscii}${RomanNumeralAscii}${RomanNumeralAscii}`\n  ]?: number;\n} = {\n  MMM: 3000,\n  MM: 2000,\n  M: 1000,\n  CM: 900,\n  DCCC: 800,\n  DCC: 700,\n  DC: 600,\n  D: 500,\n  CD: 400,\n  CCC: 300,\n  CC: 200,\n  C: 100,\n  XC: 90,\n  LXXX: 80,\n  LXX: 70,\n  LX: 60,\n  L: 50,\n  XL: 40,\n  XXX: 30,\n  XX: 20,\n  // XII/XI are redundant for ASCII input (X + II / X + I), but `romanNumeralUnicodeToAsciiMap`\n  // maps Ⅻ/ⅻ and Ⅺ/ⅺ onto these keys, so they are used in practice.\n  XII: 12,\n  XI: 11,\n  X: 10,\n  IX: 9,\n  VIII: 8,\n  VII: 7,\n  VI: 6,\n  V: 5,\n  IV: 4,\n  III: 3,\n  II: 2,\n  I: 1,\n} as const;\n\n/**\n * Map of Unicode Roman numeral code points to their ASCII equivalents.\n */\nexport const romanNumeralUnicodeToAsciiMap: Record<\n  RomanNumeralUnicode,\n  keyof typeof romanNumeralValues\n> = {\n  // Roman Numeral One (U+2160)\n  Ⅰ: 'I',\n  // Roman Numeral Two (U+2161)\n  Ⅱ: 'II',\n  // Roman Numeral Three (U+2162)\n  Ⅲ: 'III',\n  // Roman Numeral Four (U+2163)\n  Ⅳ: 'IV',\n  // Roman Numeral Five (U+2164)\n  Ⅴ: 'V',\n  // Roman Numeral Six (U+2165)\n  Ⅵ: 'VI',\n  // Roman Numeral Seven (U+2166)\n  Ⅶ: 'VII',\n  // Roman Numeral Eight (U+2167)\n  Ⅷ: 'VIII',\n  // Roman Numeral Nine (U+2168)\n  Ⅸ: 'IX',\n  // Roman Numeral Ten (U+2169)\n  Ⅹ: 'X',\n  // Roman Numeral Eleven (U+216A)\n  Ⅺ: 'XI',\n  // Roman Numeral Twelve (U+216B)\n  Ⅻ: 'XII',\n  // Roman Numeral Fifty (U+216C)\n  Ⅼ: 'L',\n  // Roman Numeral One Hundred (U+216D)\n  Ⅽ: 'C',\n  // Roman Numeral Five Hundred (U+216E)\n  Ⅾ: 'D',\n  // Roman Numeral One Thousand (U+216F)\n  Ⅿ: 'M',\n  // Small Roman Numeral One (U+2170)\n  ⅰ: 'I',\n  // Small Roman Numeral Two (U+2171)\n  ⅱ: 'II',\n  // Small Roman Numeral Three (U+2172)\n  ⅲ: 'III',\n  // Small Roman Numeral Four (U+2173)\n  ⅳ: 'IV',\n  // Small Roman Numeral Five (U+2174)\n  ⅴ: 'V',\n  // Small Roman Numeral Six (U+2175)\n  ⅵ: 'VI',\n  // Small Roman Numeral Seven (U+2176)\n  ⅶ: 'VII',\n  // Small Roman Numeral Eight (U+2177)\n  ⅷ: 'VIII',\n  // Small Roman Numeral Nine (U+2178)\n  ⅸ: 'IX',\n  // Small Roman Numeral Ten (U+2179)\n  ⅹ: 'X',\n  // Small Roman Numeral Eleven (U+217A)\n  ⅺ: 'XI',\n  // Small Roman Numeral Twelve (U+217B)\n  ⅻ: 'XII',\n  // Small Roman Numeral Fifty (U+217C)\n  ⅼ: 'L',\n  // Small Roman Numeral One Hundred (U+217D)\n  ⅽ: 'C',\n  // Small Roman Numeral Five Hundred (U+217E)\n  ⅾ: 'D',\n  // Small Roman Numeral One Thousand (U+217F)\n  ⅿ: 'M',\n} as const;\n\n/**\n * Captures all Unicode Roman numeral code points.\n */\nexport const romanNumeralUnicodeRegex: RegExp = /([ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫⅬⅭⅮⅯⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹⅺⅻⅼⅽⅾⅿ])/gi;\n\n/**\n * Captures a valid Roman numeral sequence.\n *\n * Capture groups:\n *\n * |  #  |  Description    |         Example          |\n * | --- | --------------- | ------------------------ |\n * | `0` |  Entire string  |  \"MCCXIV\" from \"MCCXIV\"  |\n * | `1` |  Thousands      |  \"M\" from \"MCCXIV\"       |\n * | `2` |  Hundreds       |  \"CC\" from \"MCCXIV\"      |\n * | `3` |  Tens           |  \"X\" from \"MCCXIV\"       |\n * | `4` |  Ones           |  \"IV\" from \"MCCXIV\"      |\n *\n * @example\n *\n * ```ts\n * romanNumeralRegex.exec(\"M\")      // [      \"M\", \"M\",   \"\",  \"\",   \"\" ]\n * romanNumeralRegex.exec(\"XII\")    // [    \"XII\",  \"\",   \"\", \"X\", \"II\" ]\n * romanNumeralRegex.exec(\"MCCXIV\") // [ \"MCCXIV\", \"M\", \"CC\", \"X\", \"IV\" ]\n * ```\n */\nexport const romanNumeralRegex: RegExp =\n  /^(?=[MDCLXVI])(M{0,3})(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$/i;\n\n// #endregion\n\n/**\n * Default options for {@link numericQuantity}.\n */\nexport const defaultOptions: Required<NumericQuantityOptions> = {\n  round: 3,\n  allowTrailingInvalid: false,\n  romanNumerals: false,\n  bigIntOnOverflow: false,\n  decimalSeparator: '.',\n  allowCurrency: false,\n  percentage: false,\n  verbose: false,\n} as const;\n","import {\n  romanNumeralRegex,\n  romanNumeralUnicodeRegex,\n  romanNumeralUnicodeToAsciiMap,\n  romanNumeralValues,\n} from './constants';\n\n// Just a shorthand type alias\ntype RomanNumeralKey = keyof typeof romanNumeralValues;\n\n/**\n * Converts a string of Roman numerals to a number, like `parseInt`\n * for Roman numerals. Uses modern, strict rules (only 1 to 3999).\n *\n * The string can include ASCII representations of Roman numerals\n * or Unicode Roman numeral code points (`U+2160` through `U+217F`).\n */\nexport const parseRomanNumerals = (romanNumerals: string): number => {\n  const normalized = romanNumerals\n    // Convert Unicode Roman numerals to ASCII\n    .replace(\n      romanNumeralUnicodeRegex,\n      (_m, rn: keyof typeof romanNumeralUnicodeToAsciiMap) => romanNumeralUnicodeToAsciiMap[rn]\n    )\n    // Normalize to uppercase (more common for Roman numerals)\n    .toUpperCase();\n\n  const regexResult = romanNumeralRegex.exec(normalized);\n\n  if (!regexResult) {\n    return NaN;\n  }\n\n  const [, thousands, hundreds, tens, ones] = regexResult;\n\n  return (\n    (romanNumeralValues[thousands as RomanNumeralKey] ?? 0) +\n    (romanNumeralValues[hundreds as RomanNumeralKey] ?? 0) +\n    (romanNumeralValues[tens as RomanNumeralKey] ?? 0) +\n    (romanNumeralValues[ones as RomanNumeralKey] ?? 0)\n  );\n};\n","import {\n  defaultOptions,\n  normalizeDigits,\n  numericRegexWithTrailingInvalid,\n  superSubDigitToAsciiMap,\n  superSubDigitsRegex,\n  vulgarFractionToAsciiMap,\n  vulgarFractionsRegex,\n} from './constants';\nimport { parseRomanNumerals } from './parseRomanNumerals';\nimport type {\n  NumericQuantityOptions,\n  NumericQuantityReturnType,\n  NumericQuantityVerboseResult,\n} from './types';\n\nconst leadingSlashRegex = /^\\s*\\//;\n// RegExp ctor (not literals) so old Babel regex transforms (e.g. Expo Snackager) skip `\\p{}`\nconst currencyPrefixRegex = new RegExp('^([-+]?)\\\\s*(\\\\p{Sc}+)\\\\s*', 'u');\nconst currencySuffixRegex = new RegExp('\\\\s*(\\\\p{Sc}+)\\\\s*$', 'u');\nconst percentageSuffixRegex = /\\s*%$/;\n\nconst maxSafeBigInt = BigInt(Number.MAX_SAFE_INTEGER);\n/**\n * Upper bound on `10 ** exp` magnitudes evaluated exactly. Anything beyond this\n * overflows/underflows the `number` path to `Infinity`/`0` anyway, so bounding it\n * avoids allocating absurdly large `bigint`s (and `BigInt(Infinity)` throwing).\n */\nconst maxExactExponent = 10_000;\nconst pow10 = (exp: number) => 10n ** BigInt(exp);\n\n/**\n * Evaluates the parsed numeric components as an exact `bigint` rational (magnitude only,\n * sign is applied by the caller) and rounds the result half-up.\n *\n * Returns the rounded `bigint` only if its magnitude exceeds `Number.MAX_SAFE_INTEGER`;\n * otherwise returns `undefined`, meaning \"no overflow, use the `number` path\".\n *\n * @param group1 - Whole number or numerator (separators already stripped).\n * @param group2 - Decimal/exponent/fraction tail, if any.\n * @param divideBy100 - Whether a percentage suffix was stripped.\n */\nconst toRoundedBigInt = (\n  group1: string,\n  group2: string | undefined,\n  divideBy100: boolean\n): bigint | undefined => {\n  let numerator: bigint;\n  let denominator = 1n;\n\n  if (!group2) {\n    // Plain integer\n    numerator = BigInt(group1);\n  } else if (group2.startsWith('.') || group2.startsWith('e') || group2.startsWith('E')) {\n    // Decimal and/or scientific notation\n    const expIndex = group2.search(/[eE]/);\n    const exponent = expIndex === -1 ? 0 : parseInt(group2.slice(expIndex + 1));\n    // Defer to the `number` path for non-finite/absurd exponents, before allocating any\n    // `bigint`s. Fractional digit counts are bounded by the input length, but the exponent\n    // is not, so validate it first.\n    if (!Number.isFinite(exponent) || Math.abs(exponent) > maxExactExponent) return undefined;\n    const fractionDigits = (expIndex === -1 ? group2 : group2.slice(0, expIndex)).slice(1);\n    numerator = BigInt(`${group1}${fractionDigits}`);\n    if (fractionDigits) denominator = pow10(fractionDigits.length);\n    if (exponent > 0) numerator *= pow10(exponent);\n    else if (exponent < 0) denominator *= pow10(-exponent);\n  } else if (leadingSlashRegex.test(group2)) {\n    // Pure fraction, e.g. \"1/2\"\n    numerator = BigInt(group1);\n    denominator = BigInt(group2.replace('/', '').trim());\n  } else {\n    // Mixed number, e.g. \"1 2/3\"\n    const [n, d] = group2.split('/');\n    denominator = BigInt(d.trim());\n    numerator = BigInt(group1) * denominator + BigInt(n.trim());\n  }\n\n  if (divideBy100) denominator *= 100n;\n\n  // Let the `number` path produce `Infinity` for zero denominators\n  if (denominator === 0n) return undefined;\n\n  // Round half-up (BigInt division truncates, i.e. floors for non-negative operands)\n  const rounded = (2n * numerator + denominator) / (2n * denominator);\n\n  return rounded > maxSafeBigInt ? rounded : undefined;\n};\n\n/**\n * Converts a string to a number, like an enhanced version of `parseFloat`.\n *\n * The string can include mixed numbers, vulgar fractions, or Roman numerals.\n * Input is expected to be a `string`, but will be coerced to `string` if necessary.\n */\nfunction numericQuantity(quantity: unknown): number;\nfunction numericQuantity<const T extends NumericQuantityOptions | undefined | null>(\n  quantity: unknown,\n  options: T\n): NumericQuantityReturnType<T>;\nfunction numericQuantity(\n  quantity: unknown,\n  options: NumericQuantityOptions | null = defaultOptions\n): number | bigint | NumericQuantityVerboseResult {\n  const opts: Required<NumericQuantityOptions> = {\n    ...defaultOptions,\n    ...options,\n  };\n\n  // `String` (unlike a template literal) does not throw for `symbol` input, but it does\n  // throw for objects with a null prototype or throwing `toString`/`valueOf` methods.\n  // Coercion failures fall through as an empty string, which parses to `NaN`.\n  let originalInput: string;\n  if (typeof quantity === 'string') {\n    originalInput = quantity;\n  } else {\n    try {\n      originalInput = String(quantity);\n    } catch {\n      originalInput = '';\n    }\n  }\n\n  // Metadata for verbose output\n  let currencyPrefix: string | undefined;\n  let currencySuffix: string | undefined;\n  let percentageSuffix: boolean | undefined;\n  let trailingInvalid: string | undefined;\n  let parsedSign: '-' | '+' | undefined;\n  let parsedWhole: number | undefined;\n  let parsedNumerator: number | undefined;\n  let parsedDenominator: number | undefined;\n\n  const buildVerboseResult = (value: number | bigint): NumericQuantityVerboseResult => {\n    const result: NumericQuantityVerboseResult = {\n      value,\n      input: originalInput,\n    };\n    if (currencyPrefix) result.currencyPrefix = currencyPrefix;\n    if (currencySuffix) result.currencySuffix = currencySuffix;\n    if (percentageSuffix) result.percentageSuffix = percentageSuffix;\n    if (trailingInvalid) result.trailingInvalid = trailingInvalid;\n    if (parsedSign) result.sign = parsedSign;\n    if (parsedWhole !== undefined) result.whole = parsedWhole;\n    if (parsedNumerator !== undefined) result.numerator = parsedNumerator;\n    if (parsedDenominator !== undefined) result.denominator = parsedDenominator;\n    return result;\n  };\n\n  const returnValue = (value: number | bigint) =>\n    opts.verbose ? buildVerboseResult(value) : value;\n\n  /**\n   * Divides by 100 if a percentage suffix was stripped. Exact scaling, no rounding:\n   * `round` applies to the quantity as written, before this division.\n   */\n  const applyPercentage = (value: number) =>\n    percentageSuffix && opts.percentage !== 'number' ? value / 100 : value;\n\n  if (typeof quantity === 'symbol') {\n    // `String(sym)` is e.g. `'Symbol(1)'`; never a valid quantity\n    return returnValue(NaN);\n  }\n\n  if (typeof quantity === 'number' || typeof quantity === 'bigint') {\n    return returnValue(quantity);\n  }\n\n  let finalResult = NaN;\n  let workingString = originalInput;\n\n  // Strip currency/percentage affixes until none match, so the two are order-independent.\n  // At most one `%` is stripped per parse, so `'50%%'` remains invalid.\n  let affixStripped = true;\n  while (affixStripped) {\n    affixStripped = false;\n\n    if (opts.allowCurrency) {\n      const prefixMatch = currencyPrefixRegex.exec(workingString);\n      if (prefixMatch?.[2]) {\n        currencyPrefix = (currencyPrefix ?? '') + prefixMatch[2];\n        // Keep the sign if present, remove currency symbol\n        workingString = (prefixMatch[1] || '') + workingString.slice(prefixMatch[0].length);\n        affixStripped = true;\n      }\n\n      const suffixMatch = currencySuffixRegex.exec(workingString);\n      if (suffixMatch) {\n        currencySuffix = suffixMatch[1] + (currencySuffix ?? '');\n        workingString = workingString.slice(0, -suffixMatch[0].length);\n        affixStripped = true;\n      }\n    }\n\n    if (!percentageSuffix && opts.percentage) {\n      const pctMatch = percentageSuffixRegex.exec(workingString);\n      if (pctMatch) {\n        percentageSuffix = true;\n        workingString = workingString.slice(0, -pctMatch[0].length);\n        affixStripped = true;\n      }\n    }\n  }\n\n  // Coerce to string and normalize\n  const quantityAsString = normalizeDigits(\n    workingString\n      // Convert vulgar fractions to ASCII, with a leading space\n      // to keep the whole number and the fraction separate\n      .replace(\n        vulgarFractionsRegex,\n        (_m, vf: keyof typeof vulgarFractionToAsciiMap) => ` ${vulgarFractionToAsciiMap[vf]}`\n      )\n      // Convert superscript/subscript digits to ASCII\n      .replace(\n        superSubDigitsRegex,\n        ch => superSubDigitToAsciiMap[ch as keyof typeof superSubDigitToAsciiMap]\n      )\n      // Convert fraction slash to standard slash\n      .replace('⁄', '/')\n      .trim()\n  );\n\n  // Bail out if the string was only white space\n  if (quantityAsString.length === 0) {\n    return returnValue(NaN);\n  }\n\n  let normalizedString = quantityAsString;\n\n  if (opts.decimalSeparator === ',') {\n    const commaCount = (quantityAsString.match(/,/g) || []).length;\n    if (commaCount === 1) {\n      // Treat lone comma as decimal separator; remove all \".\" since they represent\n      // thousands/whatever separators\n      normalizedString = quantityAsString.replaceAll('.', '_').replace(',', '.');\n    } else if (commaCount > 1) {\n      // The second comma and everything after is \"trailing invalid\"\n      const firstCommaIndex = quantityAsString.indexOf(',');\n      const secondCommaIndex = quantityAsString.indexOf(',', firstCommaIndex + 1);\n      normalizedString = quantityAsString\n        .substring(0, secondCommaIndex)\n        .replaceAll('.', '_')\n        .replace(',', '.');\n    } else {\n      // No comma as decimal separator, so remove all \".\" since they represent\n      // thousands/whatever separators\n      normalizedString = quantityAsString.replaceAll('.', '_');\n    }\n  }\n\n  const regexResult = numericRegexWithTrailingInvalid.exec(normalizedString);\n\n  // If the Arabic numeral regex fails, try Roman numerals\n  if (!regexResult) {\n    if (!opts.romanNumerals) return returnValue(NaN);\n    return returnValue(applyPercentage(parseRomanNumerals(quantityAsString)));\n  }\n\n  // Capture trailing invalid characters. Group 7 catches chars starting with [^.\\d/], but\n  // the regex (which lacks a $ anchor) may also leave unconsumed input starting with \".\",\n  // \"/\", or digits (e.g. \"0.1.2\" or \"1/\"), and the comma-decimal path above may have\n  // truncated the string. All normalization steps are length-preserving, so the number of\n  // consumed characters maps 1:1 onto `quantityAsString`; slice the remainder from the\n  // original (normalized-digit) input so nothing is dropped and no internal placeholder\n  // (\"_\" for a stripped \".\") leaks into the metadata.\n  const consumedLength = regexResult[0].length - (regexResult[7]?.length ?? 0);\n  const rawTrailing = quantityAsString.slice(consumedLength).trim();\n  if (rawTrailing) {\n    trailingInvalid = rawTrailing;\n    if (!opts.allowTrailingInvalid) {\n      return returnValue(NaN);\n    }\n  }\n\n  const [, sign, rawGroup1, rawGroup2] = regexResult;\n  if (sign === '-' || sign === '+') parsedSign = sign;\n  const numberGroup1 = rawGroup1.replaceAll(',', '').replaceAll('_', '');\n  const numberGroup2 = rawGroup2?.replaceAll(',', '').replaceAll('_', '');\n\n  // Exact overflow evaluation must precede the empty-whole shortcut below, otherwise\n  // leading-decimal scientific values (e.g. \".1e17\") skip the `bigint` path entirely.\n  if (opts.bigIntOnOverflow) {\n    const asBigInt = toRoundedBigInt(\n      numberGroup1,\n      numberGroup2,\n      !!percentageSuffix && opts.percentage !== 'number'\n    );\n    if (asBigInt !== undefined) {\n      return returnValue(sign === '-' ? -asBigInt : asBigInt);\n    }\n  }\n\n  // Numerify capture group 1\n  finalResult =\n    !numberGroup1 && numberGroup2 && numberGroup2.startsWith('.') ? 0 : parseInt(numberGroup1);\n\n  // If capture group 2 is null, then we're dealing with an integer\n  // and there is nothing left to process\n  if (!numberGroup2) {\n    finalResult = sign === '-' ? finalResult * -1 : finalResult;\n    return returnValue(applyPercentage(finalResult));\n  }\n\n  // Non-finite `round` values are treated as `false` (no rounding);\n  // negative values clamp to 0 (round to whole number)\n  const roundTo =\n    typeof opts.round === 'number' && Number.isFinite(opts.round)\n      ? Math.floor(Math.max(0, opts.round))\n      : false;\n  // `10 ** roundTo` (not `parseFloat('1e' + roundTo)`, which mangles exponential notation,\n  // e.g. `1e21` => \"1e1e+21\" => 10). Factors beyond `Number.MAX_VALUE` are `Infinity`, which\n  // would poison the arithmetic below; rounding to >308 decimals is a no-op for a double\n  // anyway, so fall back to no rounding. `NaN` means \"no rounding\".\n  const roundingFactorRaw = roundTo === false ? NaN : 10 ** roundTo;\n  const roundingFactor = Number.isFinite(roundingFactorRaw) ? roundingFactorRaw : NaN;\n\n  /** Rounds to `roundTo` decimal places, falling back to `value` if the scaling overflows. */\n  const round = (value: number, scaled: number) => {\n    const result = Math.round(scaled) / roundingFactor;\n    return Number.isFinite(result) || !Number.isFinite(value) ? result : value;\n  };\n\n  if (\n    numberGroup2.startsWith('.') ||\n    numberGroup2.startsWith('e') ||\n    numberGroup2.startsWith('E')\n  ) {\n    // If first char of `numberGroup2` is \".\" or \"e\"/\"E\", it's a decimal\n    const decimalValue = parseFloat(`${finalResult}${numberGroup2}`);\n    finalResult = isNaN(roundingFactor)\n      ? decimalValue\n      : round(decimalValue, decimalValue * roundingFactor);\n  } else if (leadingSlashRegex.test(numberGroup2)) {\n    // If the first non-space char is \"/\" it's a pure fraction (e.g. \"1/2\")\n    const numerator = parseInt(numberGroup1);\n    const denominator = parseInt(numberGroup2.replace('/', ''));\n    parsedNumerator = numerator;\n    parsedDenominator = denominator;\n    finalResult = isNaN(roundingFactor)\n      ? numerator / denominator\n      : round(numerator / denominator, (numerator * roundingFactor) / denominator);\n  } else {\n    // Otherwise it's a mixed fraction (e.g. \"1 2/3\")\n    const fractionArray = numberGroup2.split('/');\n    const [numerator, denominator] = fractionArray.map(v => parseInt(v));\n    parsedWhole = finalResult;\n    parsedNumerator = numerator;\n    parsedDenominator = denominator;\n    finalResult += isNaN(roundingFactor)\n      ? numerator / denominator\n      : round(numerator / denominator, (numerator * roundingFactor) / denominator);\n  }\n\n  finalResult = sign === '-' ? finalResult * -1 : finalResult;\n\n  return returnValue(applyPercentage(finalResult));\n}\n\nexport { numericQuantity };\n","import { numericQuantity } from './numericQuantity';\nimport type { NumericQuantityOptions } from './types';\n\n/**\n * Checks if a value represents a valid numeric quantity.\n *\n * Returns `true` if the value can be parsed as a number, `false` otherwise.\n * Accepts the same options as `numericQuantity`.\n */\nexport const isNumericQuantity = (quantity: unknown, options?: NumericQuantityOptions): boolean => {\n  const result = numericQuantity(quantity, { ...options, verbose: false });\n  return typeof result === 'bigint' || !isNaN(result);\n};\n"],"mappings":";;;;;;;AAiBA,MAAM,0BAA0B;CAC9B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAGA,MAAM,2BAA2B,IAAI,OAAO,WAAW,IAAI;;;;;;;;AAS3D,MAAa,mBAAmB,QAC9B,IAAI,QAAQ,2BAA0B,OAAM;CAC1C,MAAM,KAAK,GAAG,YAAY,CAAC;CAE3B,IAAI,MAAM,IAAM,OAAO;CAEvB,IAAI,KAAK;CACT,IAAI,KAAK,wBAAwB,SAAS;CAC1C,OAAO,KAAK,IAAI;EACd,MAAM,MAAO,KAAK,KAAK,MAAO;EAC9B,IAAI,wBAAwB,QAAQ,IAClC,KAAK;OAEL,KAAK,MAAM;CAEf;CACA,OAAO,OAAO,KAAK,wBAAwB,GAAI;AACjD,CAAC;;;;AAKH,MAAa,0BAAkF;CAC7F,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;AACP;;;;AAKA,MAAa,sBAA8B;;;;AAK3C,MAAa,2BAA+E;CAC1F,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAA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"}

package/node_modules/numeric-quantity/dist/numeric-quantity.mjs

@@ -0,0 +1,564 @@
+//#region src/constants.ts
+/**
+* Unicode decimal digit block start code points.
+* Each block contains 10 contiguous digits (0-9).
+* This list covers all \p{Nd} (Decimal_Number) blocks through Unicode 17.0.
+* The drift test in index.test.ts validates completeness against the JS engine.
+*/
+const decimalDigitBlockStarts = [
+	48,
+	1632,
+	1776,
+	1984,
+	2406,
+	2534,
+	2662,
+	2790,
+	2918,
+	3046,
+	3174,
+	3302,
+	3430,
+	3558,
+	3664,
+	3792,
+	3872,
+	4160,
+	4240,
+	6112,
+	6160,
+	6470,
+	6608,
+	6784,
+	6800,
+	6992,
+	7088,
+	7232,
+	7248,
+	42528,
+	43216,
+	43264,
+	43472,
+	43504,
+	43600,
+	44016,
+	65296,
+	66720,
+	68912,
+	68928,
+	69734,
+	69872,
+	69942,
+	70096,
+	70384,
+	70736,
+	70864,
+	71248,
+	71360,
+	71376,
+	71386,
+	71472,
+	71904,
+	72016,
+	72688,
+	72784,
+	73040,
+	73120,
+	73184,
+	73552,
+	90416,
+	92768,
+	92864,
+	93008,
+	93552,
+	118e3,
+	120782,
+	120792,
+	120802,
+	120812,
+	120822,
+	123200,
+	123632,
+	124144,
+	124401,
+	125264,
+	130032
+];
+const unicodeDecimalDigitRegex = /* @__PURE__ */ new RegExp("\\p{Nd}", "gu");
+/**
+* Normalizes non-ASCII decimal digits to ASCII digits.
+* Converts characters from Unicode decimal digit blocks (e.g., Arabic-Indic,
+* Devanagari, Bengali) to their ASCII equivalents (0-9).
+*
+* All current Unicode \p{Nd} blocks are included in decimalDigitBlockStarts.
+*/
+const normalizeDigits = (str) => str.replace(unicodeDecimalDigitRegex, (ch) => {
+	const cp = ch.codePointAt(0);
+	if (cp <= 57) return ch;
+	let lo = 0;
+	let hi = decimalDigitBlockStarts.length - 1;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >>> 1;
+		if (decimalDigitBlockStarts[mid] <= cp) lo = mid;
+		else hi = mid - 1;
+	}
+	return String(cp - decimalDigitBlockStarts[lo]);
+});
+/**
+* Map of Unicode superscript and subscript digit code points to ASCII digits.
+*/
+const superSubDigitToAsciiMap = {
+	"⁰": "0",
+	"¹": "1",
+	"²": "2",
+	"³": "3",
+	"⁴": "4",
+	"⁵": "5",
+	"⁶": "6",
+	"⁷": "7",
+	"⁸": "8",
+	"⁹": "9",
+	"₀": "0",
+	"₁": "1",
+	"₂": "2",
+	"₃": "3",
+	"₄": "4",
+	"₅": "5",
+	"₆": "6",
+	"₇": "7",
+	"₈": "8",
+	"₉": "9"
+};
+/**
+* Captures Unicode superscript and subscript digits.
+*/
+const superSubDigitsRegex = /[⁰¹²³⁴⁵⁶⁷⁸⁹₀₁₂₃₄₅₆₇₈₉]/g;
+/**
+* Map of Unicode fraction code points to their ASCII equivalents.
+*/
+const vulgarFractionToAsciiMap = {
+	"¼": "1/4",
+	"½": "1/2",
+	"¾": "3/4",
+	"⅐": "1/7",
+	"⅑": "1/9",
+	"⅒": "1/10",
+	"⅓": "1/3",
+	"⅔": "2/3",
+	"⅕": "1/5",
+	"⅖": "2/5",
+	"⅗": "3/5",
+	"⅘": "4/5",
+	"⅙": "1/6",
+	"⅚": "5/6",
+	"⅛": "1/8",
+	"⅜": "3/8",
+	"⅝": "5/8",
+	"⅞": "7/8",
+	"⅟": "1/"
+};
+/**
+* Captures the individual elements of a numeric string. Commas and underscores are allowed
+* as separators, as long as they appear between digits and are not consecutive.
+*
+* Capture groups:
+*
+* |  #  | Description                                        | Example(s)                                                              |
+* | --- | -------------------------------------------------- | ----------------------------------------------------------------------- |
+* | `0` | entire match                                       | `"2 1/3"` from `"2 1/3"`                                                |
+* | `1` | sign (`-` or `+`)                                  | `"-"` from `"-2 1/3"`                                                   |
+* | `2` | whole number or numerator                          | `"2"` from `"2 1/3"`; `"1"` from `"1/3"`                                |
+* | `3` | entire tail: fraction, decimal, and/or exponent    | `" 1/3"` from `"2 1/3"`; `".23"` from `"1.23"`; `".5e3"` from `"1.5e3"` |
+* | `4` | exponent, when there is no decimal portion         | `"e3"` from `"1e3"`                                                     |
+* | `5` | exponent, when there is a decimal portion          | `"e-3"` from `"1.5e-3"`                                                 |
+* | `6` | numerator of a mixed number (incl. leading space)  | `" 2"` from `"1 2/3"`                                                   |
+*
+* Groups 4–6 are subgroups of group 3 and are not used directly by
+* {@link numericQuantity}; only groups 1–3 are consumed.
+*
+* _Capture groups 2 and 3 may include comma/underscore separators._
+*
+* @example
+*
+* ```ts
+* numericRegex.exec("1")      // [ "1",      null, "1",     null,     null, null,  null ]
+* numericRegex.exec("1.23")   // [ "1.23",   null, "1",     ".23",    null, null,  null ]
+* numericRegex.exec("1 2/3")  // [ "1 2/3",  null, "1",     " 2/3",   null, null,  " 2" ]
+* numericRegex.exec("2/3")    // [ "2/3",    null, "2",     "/3",     null, null,  null ]
+* numericRegex.exec("2 / 3")  // [ "2 / 3",  null, "2",     " / 3",   null, null,  null ]
+* numericRegex.exec("-2 1/3") // [ "-2 1/3", "-",  "2",     " 1/3",   null, null,  " 1" ]
+* numericRegex.exec("1e3")    // [ "1e3",    null, "1",     "e3",     "e3", null,  null ]
+* numericRegex.exec("1.5e-3") // [ "1.5e-3", null, "1",     ".5e-3",  null, "e-3", null ]
+* numericRegex.exec("1,000")  // [ "1,000",  null, "1,000", null,     null, null,  null ]
+* ```
+*
+* @remarks
+*
+* This pattern and {@link numericRegexWithTrailingInvalid} are maintained as two separate
+* literals and must be kept in sync. They differ _only_ in the tail: `$` here versus
+* `(\s*[^.\d/].*)?` there. `src/index.test.ts` asserts that equality.
+*
+* Group 2 is `((?:\d(?:[,_]\d|\d)*)?)`, deliberately `?` and not `*`. Every string the
+* inner group matches begins and ends with a digit, so concatenating two of them yields
+* another string of the same shape: an outer `*` would add no strings to the language,
+* only exponentially many ways to split one digit run across iterations. That made a
+* failing match catastrophically backtrack — `'1'.repeat(30) + '!'` took ~15s on V8.
+*/
+const numericRegex = /^(?=[-+]?\s*\.\d|[-+]?\s*\d)([-+])?\s*((?:\d(?:[,_]\d|\d)*)?)(([eE][+-]?\d(?:[,_]\d|\d)*)?|\.\d(?:[,_]\d|\d)*([eE][+-]?\d(?:[,_]\d|\d)*)?|(\s+\d(?:[,_]\d|\d)*\s*)?\s*\/\s*\d(?:[,_]\d|\d)*)?$/;
+/**
+* Same as {@link numericRegex}, but allows (and ignores) trailing invalid characters.
+* Capture groups 1–6 are identical to {@link numericRegex}'s; capture group 7 contains the
+* trailing invalid portion.
+*
+* @example
+*
+* ```ts
+* numericRegexWithTrailingInvalid.exec("1abc")
+* // [ "1abc",      null, "1", null,   null, null, null, "abc"  ]
+* numericRegexWithTrailingInvalid.exec("1 2/3 xyz")
+* // [ "1 2/3 xyz", null, "1", " 2/3", null, null, " 2", " xyz" ]
+* ```
+*
+* @remarks
+*
+* Must be kept in sync with {@link numericRegex} — see that pattern's remarks.
+*/
+const numericRegexWithTrailingInvalid = /^(?=[-+]?\s*\.\d|[-+]?\s*\d)([-+])?\s*((?:\d(?:[,_]\d|\d)*)?)(([eE][+-]?\d(?:[,_]\d|\d)*)?|\.\d(?:[,_]\d|\d)*([eE][+-]?\d(?:[,_]\d|\d)*)?|(\s+\d(?:[,_]\d|\d)*\s*)?\s*\/\s*\d(?:[,_]\d|\d)*)?(\s*[^.\d/].*)?/;
+/**
+* Captures any Unicode vulgar fractions.
+*/
+const vulgarFractionsRegex = /([¼½¾⅐⅑⅒⅓⅔⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞⅟])/g;
+/**
+* Map of Roman numeral sequences to their decimal equivalents.
+*/
+const romanNumeralValues = {
+	MMM: 3e3,
+	MM: 2e3,
+	M: 1e3,
+	CM: 900,
+	DCCC: 800,
+	DCC: 700,
+	DC: 600,
+	D: 500,
+	CD: 400,
+	CCC: 300,
+	CC: 200,
+	C: 100,
+	XC: 90,
+	LXXX: 80,
+	LXX: 70,
+	LX: 60,
+	L: 50,
+	XL: 40,
+	XXX: 30,
+	XX: 20,
+	XII: 12,
+	XI: 11,
+	X: 10,
+	IX: 9,
+	VIII: 8,
+	VII: 7,
+	VI: 6,
+	V: 5,
+	IV: 4,
+	III: 3,
+	II: 2,
+	I: 1
+};
+/**
+* Map of Unicode Roman numeral code points to their ASCII equivalents.
+*/
+const romanNumeralUnicodeToAsciiMap = {
+	Ⅰ: "I",
+	Ⅱ: "II",
+	Ⅲ: "III",
+	Ⅳ: "IV",
+	Ⅴ: "V",
+	Ⅵ: "VI",
+	Ⅶ: "VII",
+	Ⅷ: "VIII",
+	Ⅸ: "IX",
+	Ⅹ: "X",
+	Ⅺ: "XI",
+	Ⅻ: "XII",
+	Ⅼ: "L",
+	Ⅽ: "C",
+	Ⅾ: "D",
+	Ⅿ: "M",
+	ⅰ: "I",
+	ⅱ: "II",
+	ⅲ: "III",
+	ⅳ: "IV",
+	ⅴ: "V",
+	ⅵ: "VI",
+	ⅶ: "VII",
+	ⅷ: "VIII",
+	ⅸ: "IX",
+	ⅹ: "X",
+	ⅺ: "XI",
+	ⅻ: "XII",
+	ⅼ: "L",
+	ⅽ: "C",
+	ⅾ: "D",
+	ⅿ: "M"
+};
+/**
+* Captures all Unicode Roman numeral code points.
+*/
+const romanNumeralUnicodeRegex = /([ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫⅬⅭⅮⅯⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹⅺⅻⅼⅽⅾⅿ])/gi;
+/**
+* Captures a valid Roman numeral sequence.
+*
+* Capture groups:
+*
+* |  #  |  Description    |         Example          |
+* | --- | --------------- | ------------------------ |
+* | `0` |  Entire string  |  "MCCXIV" from "MCCXIV"  |
+* | `1` |  Thousands      |  "M" from "MCCXIV"       |
+* | `2` |  Hundreds       |  "CC" from "MCCXIV"      |
+* | `3` |  Tens           |  "X" from "MCCXIV"       |
+* | `4` |  Ones           |  "IV" from "MCCXIV"      |
+*
+* @example
+*
+* ```ts
+* romanNumeralRegex.exec("M")      // [      "M", "M",   "",  "",   "" ]
+* romanNumeralRegex.exec("XII")    // [    "XII",  "",   "", "X", "II" ]
+* romanNumeralRegex.exec("MCCXIV") // [ "MCCXIV", "M", "CC", "X", "IV" ]
+* ```
+*/
+const romanNumeralRegex = /^(?=[MDCLXVI])(M{0,3})(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$/i;
+/**
+* Default options for {@link numericQuantity}.
+*/
+const defaultOptions = {
+	round: 3,
+	allowTrailingInvalid: false,
+	romanNumerals: false,
+	bigIntOnOverflow: false,
+	decimalSeparator: ".",
+	allowCurrency: false,
+	percentage: false,
+	verbose: false
+};
+//#endregion
+//#region src/parseRomanNumerals.ts
+/**
+* Converts a string of Roman numerals to a number, like `parseInt`
+* for Roman numerals. Uses modern, strict rules (only 1 to 3999).
+*
+* The string can include ASCII representations of Roman numerals
+* or Unicode Roman numeral code points (`U+2160` through `U+217F`).
+*/
+const parseRomanNumerals = (romanNumerals) => {
+	const normalized = romanNumerals.replace(romanNumeralUnicodeRegex, (_m, rn) => romanNumeralUnicodeToAsciiMap[rn]).toUpperCase();
+	const regexResult = romanNumeralRegex.exec(normalized);
+	if (!regexResult) return NaN;
+	const [, thousands, hundreds, tens, ones] = regexResult;
+	return (romanNumeralValues[thousands] ?? 0) + (romanNumeralValues[hundreds] ?? 0) + (romanNumeralValues[tens] ?? 0) + (romanNumeralValues[ones] ?? 0);
+};
+//#endregion
+//#region src/numericQuantity.ts
+const leadingSlashRegex = /^\s*\//;
+const currencyPrefixRegex = /* @__PURE__ */ new RegExp("^([-+]?)\\s*(\\p{Sc}+)\\s*", "u");
+const currencySuffixRegex = /* @__PURE__ */ new RegExp("\\s*(\\p{Sc}+)\\s*$", "u");
+const percentageSuffixRegex = /\s*%$/;
+const maxSafeBigInt = BigInt(Number.MAX_SAFE_INTEGER);
+/**
+* Upper bound on `10 ** exp` magnitudes evaluated exactly. Anything beyond this
+* overflows/underflows the `number` path to `Infinity`/`0` anyway, so bounding it
+* avoids allocating absurdly large `bigint`s (and `BigInt(Infinity)` throwing).
+*/
+const maxExactExponent = 1e4;
+const pow10 = (exp) => 10n ** BigInt(exp);
+/**
+* Evaluates the parsed numeric components as an exact `bigint` rational (magnitude only,
+* sign is applied by the caller) and rounds the result half-up.
+*
+* Returns the rounded `bigint` only if its magnitude exceeds `Number.MAX_SAFE_INTEGER`;
+* otherwise returns `undefined`, meaning "no overflow, use the `number` path".
+*
+* @param group1 - Whole number or numerator (separators already stripped).
+* @param group2 - Decimal/exponent/fraction tail, if any.
+* @param divideBy100 - Whether a percentage suffix was stripped.
+*/
+const toRoundedBigInt = (group1, group2, divideBy100) => {
+	let numerator;
+	let denominator = 1n;
+	if (!group2) numerator = BigInt(group1);
+	else if (group2.startsWith(".") || group2.startsWith("e") || group2.startsWith("E")) {
+		const expIndex = group2.search(/[eE]/);
+		const exponent = expIndex === -1 ? 0 : parseInt(group2.slice(expIndex + 1));
+		if (!Number.isFinite(exponent) || Math.abs(exponent) > maxExactExponent) return void 0;
+		const fractionDigits = (expIndex === -1 ? group2 : group2.slice(0, expIndex)).slice(1);
+		numerator = BigInt(`${group1}${fractionDigits}`);
+		if (fractionDigits) denominator = pow10(fractionDigits.length);
+		if (exponent > 0) numerator *= pow10(exponent);
+		else if (exponent < 0) denominator *= pow10(-exponent);
+	} else if (leadingSlashRegex.test(group2)) {
+		numerator = BigInt(group1);
+		denominator = BigInt(group2.replace("/", "").trim());
+	} else {
+		const [n, d] = group2.split("/");
+		denominator = BigInt(d.trim());
+		numerator = BigInt(group1) * denominator + BigInt(n.trim());
+	}
+	if (divideBy100) denominator *= 100n;
+	if (denominator === 0n) return void 0;
+	const rounded = (2n * numerator + denominator) / (2n * denominator);
+	return rounded > maxSafeBigInt ? rounded : void 0;
+};
+function numericQuantity(quantity, options = defaultOptions) {
+	var _regexResult$;
+	const opts = {
+		...defaultOptions,
+		...options
+	};
+	let originalInput;
+	if (typeof quantity === "string") originalInput = quantity;
+	else try {
+		originalInput = String(quantity);
+	} catch {
+		originalInput = "";
+	}
+	let currencyPrefix;
+	let currencySuffix;
+	let percentageSuffix;
+	let trailingInvalid;
+	let parsedSign;
+	let parsedWhole;
+	let parsedNumerator;
+	let parsedDenominator;
+	const buildVerboseResult = (value) => {
+		const result = {
+			value,
+			input: originalInput
+		};
+		if (currencyPrefix) result.currencyPrefix = currencyPrefix;
+		if (currencySuffix) result.currencySuffix = currencySuffix;
+		if (percentageSuffix) result.percentageSuffix = percentageSuffix;
+		if (trailingInvalid) result.trailingInvalid = trailingInvalid;
+		if (parsedSign) result.sign = parsedSign;
+		if (parsedWhole !== void 0) result.whole = parsedWhole;
+		if (parsedNumerator !== void 0) result.numerator = parsedNumerator;
+		if (parsedDenominator !== void 0) result.denominator = parsedDenominator;
+		return result;
+	};
+	const returnValue = (value) => opts.verbose ? buildVerboseResult(value) : value;
+	/**
+	* Divides by 100 if a percentage suffix was stripped. Exact scaling, no rounding:
+	* `round` applies to the quantity as written, before this division.
+	*/
+	const applyPercentage = (value) => percentageSuffix && opts.percentage !== "number" ? value / 100 : value;
+	if (typeof quantity === "symbol") return returnValue(NaN);
+	if (typeof quantity === "number" || typeof quantity === "bigint") return returnValue(quantity);
+	let finalResult = NaN;
+	let workingString = originalInput;
+	let affixStripped = true;
+	while (affixStripped) {
+		affixStripped = false;
+		if (opts.allowCurrency) {
+			const prefixMatch = currencyPrefixRegex.exec(workingString);
+			if (prefixMatch === null || prefixMatch === void 0 ? void 0 : prefixMatch[2]) {
+				currencyPrefix = (currencyPrefix ?? "") + prefixMatch[2];
+				workingString = (prefixMatch[1] || "") + workingString.slice(prefixMatch[0].length);
+				affixStripped = true;
+			}
+			const suffixMatch = currencySuffixRegex.exec(workingString);
+			if (suffixMatch) {
+				currencySuffix = suffixMatch[1] + (currencySuffix ?? "");
+				workingString = workingString.slice(0, -suffixMatch[0].length);
+				affixStripped = true;
+			}
+		}
+		if (!percentageSuffix && opts.percentage) {
+			const pctMatch = percentageSuffixRegex.exec(workingString);
+			if (pctMatch) {
+				percentageSuffix = true;
+				workingString = workingString.slice(0, -pctMatch[0].length);
+				affixStripped = true;
+			}
+		}
+	}
+	const quantityAsString = normalizeDigits(workingString.replace(vulgarFractionsRegex, (_m, vf) => ` ${vulgarFractionToAsciiMap[vf]}`).replace(superSubDigitsRegex, (ch) => superSubDigitToAsciiMap[ch]).replace("⁄", "/").trim());
+	if (quantityAsString.length === 0) return returnValue(NaN);
+	let normalizedString = quantityAsString;
+	if (opts.decimalSeparator === ",") {
+		const commaCount = (quantityAsString.match(/,/g) || []).length;
+		if (commaCount === 1) normalizedString = quantityAsString.replaceAll(".", "_").replace(",", ".");
+		else if (commaCount > 1) {
+			const firstCommaIndex = quantityAsString.indexOf(",");
+			const secondCommaIndex = quantityAsString.indexOf(",", firstCommaIndex + 1);
+			normalizedString = quantityAsString.substring(0, secondCommaIndex).replaceAll(".", "_").replace(",", ".");
+		} else normalizedString = quantityAsString.replaceAll(".", "_");
+	}
+	const regexResult = numericRegexWithTrailingInvalid.exec(normalizedString);
+	if (!regexResult) {
+		if (!opts.romanNumerals) return returnValue(NaN);
+		return returnValue(applyPercentage(parseRomanNumerals(quantityAsString)));
+	}
+	const consumedLength = regexResult[0].length - (((_regexResult$ = regexResult[7]) === null || _regexResult$ === void 0 ? void 0 : _regexResult$.length) ?? 0);
+	const rawTrailing = quantityAsString.slice(consumedLength).trim();
+	if (rawTrailing) {
+		trailingInvalid = rawTrailing;
+		if (!opts.allowTrailingInvalid) return returnValue(NaN);
+	}
+	const [, sign, rawGroup1, rawGroup2] = regexResult;
+	if (sign === "-" || sign === "+") parsedSign = sign;
+	const numberGroup1 = rawGroup1.replaceAll(",", "").replaceAll("_", "");
+	const numberGroup2 = rawGroup2 === null || rawGroup2 === void 0 ? void 0 : rawGroup2.replaceAll(",", "").replaceAll("_", "");
+	if (opts.bigIntOnOverflow) {
+		const asBigInt = toRoundedBigInt(numberGroup1, numberGroup2, !!percentageSuffix && opts.percentage !== "number");
+		if (asBigInt !== void 0) return returnValue(sign === "-" ? -asBigInt : asBigInt);
+	}
+	finalResult = !numberGroup1 && numberGroup2 && numberGroup2.startsWith(".") ? 0 : parseInt(numberGroup1);
+	if (!numberGroup2) {
+		finalResult = sign === "-" ? finalResult * -1 : finalResult;
+		return returnValue(applyPercentage(finalResult));
+	}
+	const roundTo = typeof opts.round === "number" && Number.isFinite(opts.round) ? Math.floor(Math.max(0, opts.round)) : false;
+	const roundingFactorRaw = roundTo === false ? NaN : 10 ** roundTo;
+	const roundingFactor = Number.isFinite(roundingFactorRaw) ? roundingFactorRaw : NaN;
+	/** Rounds to `roundTo` decimal places, falling back to `value` if the scaling overflows. */
+	const round = (value, scaled) => {
+		const result = Math.round(scaled) / roundingFactor;
+		return Number.isFinite(result) || !Number.isFinite(value) ? result : value;
+	};
+	if (numberGroup2.startsWith(".") || numberGroup2.startsWith("e") || numberGroup2.startsWith("E")) {
+		const decimalValue = parseFloat(`${finalResult}${numberGroup2}`);
+		finalResult = isNaN(roundingFactor) ? decimalValue : round(decimalValue, decimalValue * roundingFactor);
+	} else if (leadingSlashRegex.test(numberGroup2)) {
+		const numerator = parseInt(numberGroup1);
+		const denominator = parseInt(numberGroup2.replace("/", ""));
+		parsedNumerator = numerator;
+		parsedDenominator = denominator;
+		finalResult = isNaN(roundingFactor) ? numerator / denominator : round(numerator / denominator, numerator * roundingFactor / denominator);
+	} else {
+		const [numerator, denominator] = numberGroup2.split("/").map((v) => parseInt(v));
+		parsedWhole = finalResult;
+		parsedNumerator = numerator;
+		parsedDenominator = denominator;
+		finalResult += isNaN(roundingFactor) ? numerator / denominator : round(numerator / denominator, numerator * roundingFactor / denominator);
+	}
+	finalResult = sign === "-" ? finalResult * -1 : finalResult;
+	return returnValue(applyPercentage(finalResult));
+}
+//#endregion
+//#region src/isNumericQuantity.ts
+/**
+* Checks if a value represents a valid numeric quantity.
+*
+* Returns `true` if the value can be parsed as a number, `false` otherwise.
+* Accepts the same options as `numericQuantity`.
+*/
+const isNumericQuantity = (quantity, options) => {
+	const result = numericQuantity(quantity, {
+		...options,
+		verbose: false
+	});
+	return typeof result === "bigint" || !isNaN(result);
+};
+//#endregion
+export { defaultOptions, isNumericQuantity, normalizeDigits, numericQuantity, numericRegex, numericRegexWithTrailingInvalid, parseRomanNumerals, romanNumeralRegex, romanNumeralUnicodeRegex, romanNumeralUnicodeToAsciiMap, romanNumeralValues, superSubDigitToAsciiMap, superSubDigitsRegex, vulgarFractionToAsciiMap, vulgarFractionsRegex };
+
+//# sourceMappingURL=numeric-quantity.mjs.map