@flickfyi/flkr 0.0.140 → 0.0.146

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

@@ -0,0 +1,622 @@
+//#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 = 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) => {
+	var _romanNumeralValues, _romanNumeralValues2, _romanNumeralValues3, _romanNumeralValues4;
+	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 = romanNumeralValues[thousands]) !== null && _romanNumeralValues !== void 0 ? _romanNumeralValues : 0) + ((_romanNumeralValues2 = romanNumeralValues[hundreds]) !== null && _romanNumeralValues2 !== void 0 ? _romanNumeralValues2 : 0) + ((_romanNumeralValues3 = romanNumeralValues[tens]) !== null && _romanNumeralValues3 !== void 0 ? _romanNumeralValues3 : 0) + ((_romanNumeralValues4 = romanNumeralValues[ones]) !== null && _romanNumeralValues4 !== void 0 ? _romanNumeralValues4 : 0);
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r) {
+			return Object.getOwnPropertyDescriptor(e, r).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+			_defineProperty(e, r, t[r]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+		});
+	}
+	return e;
+}
+//#endregion
+//#region src/numericQuantity.ts
+const leadingSlashRegex = /^\s*\//;
+const currencyPrefixRegex = new RegExp("^([-+]?)\\s*(\\p{Sc}+)\\s*", "u");
+const currencySuffixRegex = 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$7$length, _regexResult$;
+	const opts = _objectSpread2(_objectSpread2({}, defaultOptions), options);
+	let originalInput;
+	if (typeof quantity === "string") originalInput = quantity;
+	else try {
+		originalInput = String(quantity);
+	} catch (_unused) {
+		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]) {
+				var _currencyPrefix;
+				currencyPrefix = ((_currencyPrefix = currencyPrefix) !== null && _currencyPrefix !== void 0 ? _currencyPrefix : "") + prefixMatch[2];
+				workingString = (prefixMatch[1] || "") + workingString.slice(prefixMatch[0].length);
+				affixStripped = true;
+			}
+			const suffixMatch = currencySuffixRegex.exec(workingString);
+			if (suffixMatch) {
+				var _currencySuffix;
+				currencySuffix = suffixMatch[1] + ((_currencySuffix = currencySuffix) !== null && _currencySuffix !== void 0 ? _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$7$length = (_regexResult$ = regexResult[7]) === null || _regexResult$ === void 0 ? void 0 : _regexResult$.length) !== null && _regexResult$7$length !== void 0 ? _regexResult$7$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, _objectSpread2(_objectSpread2({}, 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.legacy-esm.js.map