@flickfyi/flkr 0.0.141 → 0.0.146

package/node_modules/numeric-quantity/dist/cjs/numeric-quantity.cjs.production.d.ts

@@ -0,0 +1,293 @@
+//#region src/types.d.ts
+export interface NumericQuantityOptions {
+  /**
+   * Round the result to this many decimal places. Defaults to 3; must
+   * be greater than or equal to zero.
+   *
+   * @default 3
+   */
+  round?: number | false;
+  /**
+   * Allow and ignore trailing invalid characters _à la_ `parseFloat`.
+   *
+   * @default false
+   */
+  allowTrailingInvalid?: boolean;
+  /**
+   * Attempt to parse Roman numerals if Arabic numeral parsing fails.
+   *
+   * @default false
+   */
+  romanNumerals?: boolean;
+  /**
+   * Generates a `bigint` value if the string represents
+   * a valid integer too large for the `number` type.
+   */
+  bigIntOnOverflow?: boolean;
+  /**
+   * Specifies which character ("." or ",") to treat as the decimal separator.
+   *
+   * @default "."
+   */
+  decimalSeparator?: "," | ".";
+  /**
+   * Allow and strip currency symbols (Unicode `\p{Sc}` category) from the
+   * start and/or end of the string.
+   *
+   * @default false
+   */
+  allowCurrency?: boolean;
+  /**
+   * Parse percentage strings by stripping the `%` suffix.
+   * - `'decimal'` or `true`: `"50%"` → `0.5` (divide by 100)
+   * - `'number'`: `"50%"` → `50` (strip `%`, keep value)
+   * - `false` or omitted: `"50%"` → `NaN` (default behavior)
+   *
+   * @default false
+   */
+  percentage?: "decimal" | "number" | boolean;
+  /**
+   * Return a verbose result object with additional parsing metadata.
+   *
+   * @default false
+   */
+  verbose?: boolean;
+}
+/**
+ * Extracts the type of the `verbose` option from an options type, defaulting to `false`.
+ */
+export type VerboseOption<T> = T extends {
+  verbose?: infer V;
+} ? V : false;
+/**
+ * Extracts the type of the `bigIntOnOverflow` option from an options type,
+ * defaulting to `false`.
+ */
+export type BigIntOnOverflowOption<T> = T extends {
+  bigIntOnOverflow?: infer B;
+} ? B : false;
+/**
+ * Resolves the return type of {@link numericQuantity} based on the options provided.
+ *
+ * @remarks
+ * Inference requires the options object to have literal types. An options object
+ * annotated as `const opts: NumericQuantityOptions = { ... }` widens every option to
+ * `boolean | undefined`, so the return type is the full
+ * `number | bigint | NumericQuantityVerboseResult` union. Use
+ * `satisfies NumericQuantityOptions` instead of a `:` annotation to retain literal
+ * inference.
+ */
+export type NumericQuantityReturnType<T extends NumericQuantityOptions | undefined | null = undefined> = boolean extends VerboseOption<T> ? number | bigint | NumericQuantityVerboseResult : true extends VerboseOption<T> ? NumericQuantityVerboseResult : boolean extends BigIntOnOverflowOption<T> ? number | bigint : true extends BigIntOnOverflowOption<T> ? number | bigint : number;
+/**
+ * Verbose result returned when `verbose: true` is set.
+ */
+export interface NumericQuantityVerboseResult {
+  /** The parsed numeric value (NaN if invalid). */
+  value: number | bigint;
+  /** The original input, coerced to a string (`symbol` input becomes e.g. `'Symbol(1)'`). */
+  input: string;
+  /** Currency symbol(s) stripped from the start, if any. */
+  currencyPrefix?: string;
+  /** Currency symbol(s) stripped from the end, if any. */
+  currencySuffix?: string;
+  /** True if a `%` suffix was stripped. */
+  percentageSuffix?: boolean;
+  /** Trailing invalid (usually non-numeric) characters detected in the input, if any. Populated even when `allowTrailingInvalid` is `false`. */
+  trailingInvalid?: string;
+  /** The leading sign character (`'-'` or `'+'`), if present. Omitted when no explicit sign was in the input. */
+  sign?: "-" | "+";
+  /** The whole-number part of a mixed fraction (e.g. `1` from `"1 2/3"`). Omitted for pure fractions, decimals, and integers. */
+  whole?: number;
+  /** The numerator of a fraction (e.g. `2` from `"1 2/3"`, or `1` from `"1/2"`). Always unsigned. */
+  numerator?: number;
+  /** The denominator of a fraction (e.g. `3` from `"1 2/3"`, or `2` from `"1/2"`). Always unsigned. */
+  denominator?: number;
+}
+/**
+ * Unicode vulgar fraction code points.
+ */
+export type VulgarFraction = "¼" | "½" | "¾" | "⅐" | "⅑" | "⅒" | "⅓" | "⅔" | "⅕" | "⅖" | "⅗" | "⅘" | "⅙" | "⅚" | "⅛" | "⅜" | "⅝" | "⅞" | "⅟";
+/**
+ * Unicode superscript digit code points.
+ */
+export type SuperscriptDigit = "⁰" | "¹" | "²" | "³" | "⁴" | "⁵" | "⁶" | "⁷" | "⁸" | "⁹";
+/**
+ * Unicode subscript digit code points.
+ */
+export type SubscriptDigit = "₀" | "₁" | "₂" | "₃" | "₄" | "₅" | "₆" | "₇" | "₈" | "₉";
+/**
+ * Allowable Roman numeral characters (ASCII, uppercase only).
+ */
+export type RomanNumeralAscii = "I" | "V" | "X" | "L" | "C" | "D" | "M";
+/**
+ * Unicode Roman numeral code points (uppercase and lowercase,
+ * representing 1-12, 50, 100, 500, and 1000).
+ */
+export type RomanNumeralUnicode = "Ⅰ" | "Ⅱ" | "Ⅲ" | "Ⅳ" | "Ⅴ" | "Ⅵ" | "Ⅶ" | "Ⅷ" | "Ⅸ" | "Ⅹ" | "Ⅺ" | "Ⅻ" | "Ⅼ" | "Ⅽ" | "Ⅾ" | "Ⅿ" | "ⅰ" | "ⅱ" | "ⅲ" | "ⅳ" | "ⅴ" | "ⅵ" | "ⅶ" | "ⅷ" | "ⅸ" | "ⅹ" | "ⅺ" | "ⅻ" | "ⅼ" | "ⅽ" | "ⅾ" | "ⅿ";
+/**
+ * Union of ASCII and Unicode Roman numeral characters/code points.
+ */
+export type RomanNumeral = RomanNumeralAscii | RomanNumeralUnicode;
+//#endregion
+//#region src/constants.d.ts
+/**
+ * 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.
+ */
+export declare const normalizeDigits: (str: string) => string;
+/**
+ * Map of Unicode superscript and subscript digit code points to ASCII digits.
+ */
+export declare const superSubDigitToAsciiMap: Record<SuperscriptDigit | SubscriptDigit, `${number}`>;
+/**
+ * Captures Unicode superscript and subscript digits.
+ */
+export declare const superSubDigitsRegex: RegExp;
+/**
+ * Map of Unicode fraction code points to their ASCII equivalents.
+ */
+export declare const vulgarFractionToAsciiMap: Record<VulgarFraction, `${number}/${number | ""}`>;
+/**
+ * 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.
+ */
+export declare const numericRegex: RegExp;
+/**
+ * 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.
+ */
+export declare const numericRegexWithTrailingInvalid: RegExp;
+/**
+ * Captures any Unicode vulgar fractions.
+ */
+export declare const vulgarFractionsRegex: RegExp;
+/**
+ * Map of Roman numeral sequences to their decimal equivalents.
+ */
+export declare const romanNumeralValues: { [k in `${RomanNumeralAscii}` | `${RomanNumeralAscii}${RomanNumeralAscii}` | `${RomanNumeralAscii}${RomanNumeralAscii}${RomanNumeralAscii}` | `${RomanNumeralAscii}${RomanNumeralAscii}${RomanNumeralAscii}${RomanNumeralAscii}`]?: number; };
+/**
+ * Map of Unicode Roman numeral code points to their ASCII equivalents.
+ */
+export declare const romanNumeralUnicodeToAsciiMap: Record<RomanNumeralUnicode, keyof typeof romanNumeralValues>;
+/**
+ * Captures all Unicode Roman numeral code points.
+ */
+export declare const romanNumeralUnicodeRegex: RegExp;
+/**
+ * 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" ]
+ * ```
+ */
+export declare const romanNumeralRegex: RegExp;
+/**
+ * Default options for {@link numericQuantity}.
+ */
+export declare const defaultOptions: Required<NumericQuantityOptions>;
+//#endregion
+//#region src/isNumericQuantity.d.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`.
+ */
+export declare const isNumericQuantity: (quantity: unknown, options?: NumericQuantityOptions) => boolean;
+//#endregion
+//#region src/numericQuantity.d.ts
+/**
+ * Converts a string to a number, like an enhanced version of `parseFloat`.
+ *
+ * The string can include mixed numbers, vulgar fractions, or Roman numerals.
+ * Input is expected to be a `string`, but will be coerced to `string` if necessary.
+ */
+declare function numericQuantity(quantity: unknown): number;
+declare function numericQuantity<const T extends NumericQuantityOptions | undefined | null>(quantity: unknown, options: T): NumericQuantityReturnType<T>;
+//#endregion
+//#region src/parseRomanNumerals.d.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`).
+ */
+export declare const parseRomanNumerals: (romanNumerals: string) => number;
+//#endregion
+export { numericQuantity };
+//# sourceMappingURL=numeric-quantity.cjs.production.d.ts.map

package/node_modules/numeric-quantity/dist/cjs/numeric-quantity.cjs.production.js

@@ -0,0 +1,2 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=[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],t=RegExp(`\\p{Nd}`,`gu`),n=n=>n.replace(t,t=>{let n=t.codePointAt(0);if(n<=57)return t;let r=0,i=e.length-1;for(;r<i;){let t=r+i+1>>>1;e[t]<=n?r=t:i=t-1}return String(n-e[r])}),r={"⁰":`0`,"¹":`1`,"²":`2`,"³":`3`,"⁴":`4`,"⁵":`5`,"⁶":`6`,"⁷":`7`,"⁸":`8`,"⁹":`9`,"₀":`0`,"₁":`1`,"₂":`2`,"₃":`3`,"₄":`4`,"₅":`5`,"₆":`6`,"₇":`7`,"₈":`8`,"₉":`9`},i=/[⁰¹²³⁴⁵⁶⁷⁸⁹₀₁₂₃₄₅₆₇₈₉]/g,a={"¼":`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/`},o=/^(?=[-+]?\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=/^(?=[-+]?\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/].*)?/,c=/([¼½¾⅐⅑⅒⅓⅔⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞⅟])/g,l={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},u={Ⅰ:`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`},d=/([ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫⅬⅭⅮⅯⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹⅺⅻⅼⅽⅾⅿ])/gi,f=/^(?=[MDCLXVI])(M{0,3})(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$/i,p={round:3,allowTrailingInvalid:!1,romanNumerals:!1,bigIntOnOverflow:!1,decimalSeparator:`.`,allowCurrency:!1,percentage:!1,verbose:!1},m=e=>{let t=e.replace(d,(e,t)=>u[t]).toUpperCase(),n=f.exec(t);if(!n)return NaN;let[,r,i,a,o]=n;return(l[r]??0)+(l[i]??0)+(l[a]??0)+(l[o]??0)},h=/^\s*\//,g=RegExp(`^([-+]?)\\s*(\\p{Sc}+)\\s*`,`u`),_=RegExp(`\\s*(\\p{Sc}+)\\s*$`,`u`),v=/\s*%$/,y=BigInt(2**53-1),b=e=>10n**BigInt(e),x=(e,t,n)=>{let r,i=1n;if(!t)r=BigInt(e);else if(t.startsWith(`.`)||t.startsWith(`e`)||t.startsWith(`E`)){let n=t.search(/[eE]/),a=n===-1?0:parseInt(t.slice(n+1));if(!Number.isFinite(a)||Math.abs(a)>1e4)return;let o=(n===-1?t:t.slice(0,n)).slice(1);r=BigInt(`${e}${o}`),o&&(i=b(o.length)),a>0?r*=b(a):a<0&&(i*=b(-a))}else if(h.test(t))r=BigInt(e),i=BigInt(t.replace(`/`,``).trim());else{let[n,a]=t.split(`/`);i=BigInt(a.trim()),r=BigInt(e)*i+BigInt(n.trim())}if(n&&(i*=100n),i===0n)return;let a=(2n*r+i)/(2n*i);return a>y?a:void 0};function S(e,t=p){var o;let l={...p,...t},u;if(typeof e==`string`)u=e;else try{u=String(e)}catch{u=``}let d,f,y,b,S,C,w,T,E=e=>{let t={value:e,input:u};return d&&(t.currencyPrefix=d),f&&(t.currencySuffix=f),y&&(t.percentageSuffix=y),b&&(t.trailingInvalid=b),S&&(t.sign=S),C!==void 0&&(t.whole=C),w!==void 0&&(t.numerator=w),T!==void 0&&(t.denominator=T),t},D=e=>l.verbose?E(e):e,O=e=>y&&l.percentage!==`number`?e/100:e;if(typeof e==`symbol`)return D(NaN);if(typeof e==`number`||typeof e==`bigint`)return D(e);let k=NaN,A=u,j=!0;for(;j;){if(j=!1,l.allowCurrency){let e=g.exec(A);e!=null&&e[2]&&(d=(d??``)+e[2],A=(e[1]||``)+A.slice(e[0].length),j=!0);let t=_.exec(A);t&&(f=t[1]+(f??``),A=A.slice(0,-t[0].length),j=!0)}if(!y&&l.percentage){let e=v.exec(A);e&&(y=!0,A=A.slice(0,-e[0].length),j=!0)}}let M=n(A.replace(c,(e,t)=>` ${a[t]}`).replace(i,e=>r[e]).replace(`⁄`,`/`).trim());if(M.length===0)return D(NaN);let N=M;if(l.decimalSeparator===`,`){let e=(M.match(/,/g)||[]).length;if(e===1)N=M.replaceAll(`.`,`_`).replace(`,`,`.`);else if(e>1){let e=M.indexOf(`,`),t=M.indexOf(`,`,e+1);N=M.substring(0,t).replaceAll(`.`,`_`).replace(`,`,`.`)}else N=M.replaceAll(`.`,`_`)}let P=s.exec(N);if(!P)return l.romanNumerals?D(O(m(M))):D(NaN);let F=P[0].length-(((o=P[7])==null?void 0:o.length)??0),I=M.slice(F).trim();if(I&&(b=I,!l.allowTrailingInvalid))return D(NaN);let[,L,R,z]=P;(L===`-`||L===`+`)&&(S=L);let B=R.replaceAll(`,`,``).replaceAll(`_`,``),V=z==null?void 0:z.replaceAll(`,`,``).replaceAll(`_`,``);if(l.bigIntOnOverflow){let e=x(B,V,!!y&&l.percentage!==`number`);if(e!==void 0)return D(L===`-`?-e:e)}if(k=!B&&V&&V.startsWith(`.`)?0:parseInt(B),!V)return k=L===`-`?k*-1:k,D(O(k));let H=typeof l.round==`number`&&Number.isFinite(l.round)?Math.floor(Math.max(0,l.round)):!1,U=H===!1?NaN:10**H,W=Number.isFinite(U)?U:NaN,G=(e,t)=>{let n=Math.round(t)/W;return Number.isFinite(n)||!Number.isFinite(e)?n:e};if(V.startsWith(`.`)||V.startsWith(`e`)||V.startsWith(`E`)){let e=parseFloat(`${k}${V}`);k=isNaN(W)?e:G(e,e*W)}else if(h.test(V)){let e=parseInt(B),t=parseInt(V.replace(`/`,``));w=e,T=t,k=isNaN(W)?e/t:G(e/t,e*W/t)}else{let[e,t]=V.split(`/`).map(e=>parseInt(e));C=k,w=e,T=t,k+=isNaN(W)?e/t:G(e/t,e*W/t)}return k=L===`-`?k*-1:k,D(O(k))}const C=(e,t)=>{let n=S(e,{...t,verbose:!1});return typeof n==`bigint`||!isNaN(n)};exports.defaultOptions=p,exports.isNumericQuantity=C,exports.normalizeDigits=n,exports.numericQuantity=S,exports.numericRegex=o,exports.numericRegexWithTrailingInvalid=s,exports.parseRomanNumerals=m,exports.romanNumeralRegex=f,exports.romanNumeralUnicodeRegex=d,exports.romanNumeralUnicodeToAsciiMap=u,exports.romanNumeralValues=l,exports.superSubDigitToAsciiMap=r,exports.superSubDigitsRegex=i,exports.vulgarFractionToAsciiMap=a,exports.vulgarFractionsRegex=c;
+//# sourceMappingURL=numeric-quantity.cjs.production.js.map

package/node_modules/numeric-quantity/dist/cjs/numeric-quantity.cjs.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-quantity.cjs.production.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":"mEAiBA,MAAM,EAA0B,CAC9B,GACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,OACA,MACF,EAGM,EAA+B,OAAO,UAAW,IAAI,EAS9C,EAAmB,GAC9B,EAAI,QAAQ,EAA0B,GAAM,CAC1C,IAAM,EAAK,EAAG,YAAY,CAAC,EAE3B,GAAI,GAAM,GAAM,OAAO,EAEvB,IAAI,EAAK,EACL,EAAK,EAAwB,OAAS,EAC1C,KAAO,EAAK,GAAI,CACd,IAAM,EAAO,EAAK,EAAK,IAAO,EAC1B,EAAwB,IAAQ,EAClC,EAAK,EAEL,EAAK,EAAM,CAEf,CACA,OAAO,OAAO,EAAK,EAAwB,EAAI,CACjD,CAAC,EAKU,EAAkF,CAC7F,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,GACP,EAKa,EAA8B,0BAK9B,EAA+E,CAC1F,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,OACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,IACP,EAiDa,EACX,iMAmBW,EACX,+MAKW,EAA+B,2BAS/B,EAQT,CACF,IA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"}