numeric-quantity 3.0.0 → 3.2.0

package/dist/numeric-quantity.legacy-esm.d.ts

@@ -0,0 +1,225 @@
+//#region src/types.d.ts
+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;
+}
+/**
+* Resolves the return type of {@link numericQuantity} based on the options provided.
+*/
+type NumericQuantityReturnType<T extends NumericQuantityOptions | undefined = undefined> = T extends {
+  verbose: true;
+} ? NumericQuantityVerboseResult : T extends {
+  bigIntOnOverflow: true;
+} ? number | bigint : number;
+/**
+* Verbose result returned when `verbose: true` is set.
+*/
+interface NumericQuantityVerboseResult {
+  /** The parsed numeric value (NaN if invalid). */
+  value: number | bigint;
+  /** The original input string. */
+  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.
+*/
+type VulgarFraction = "¼" | "½" | "¾" | "⅐" | "⅑" | "⅒" | "⅓" | "⅔" | "⅕" | "⅖" | "⅗" | "⅘" | "⅙" | "⅚" | "⅛" | "⅜" | "⅝" | "⅞" | "⅟";
+/**
+* Allowable Roman numeral characters (ASCII, uppercase only).
+*/
+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).
+*/
+type RomanNumeralUnicode = "Ⅰ" | "Ⅱ" | "Ⅲ" | "Ⅳ" | "Ⅴ" | "Ⅵ" | "Ⅶ" | "Ⅷ" | "Ⅸ" | "Ⅹ" | "Ⅺ" | "Ⅻ" | "Ⅼ" | "Ⅽ" | "Ⅾ" | "Ⅿ" | "ⅰ" | "ⅱ" | "ⅲ" | "ⅳ" | "ⅴ" | "ⅵ" | "ⅶ" | "ⅷ" | "ⅸ" | "ⅹ" | "ⅺ" | "ⅻ" | "ⅼ" | "ⅽ" | "ⅾ" | "ⅿ";
+/**
+* Union of ASCII and Unicode Roman numeral characters/code points.
+*/
+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.
+*/
+declare const normalizeDigits: (str: string) => string;
+/**
+* Map of Unicode fraction code points to their ASCII equivalents.
+*/
+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 string                                    | `"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 fraction, decimal portion, or denominator | `" 1/3"` from `"2 1/3"`; `".33"` from `"2.33"`; `"/3"` from `"1/3"` |
+*
+* _Capture group 2 may include comma/underscore separators._
+*
+* @example
+*
+* ```ts
+* numericRegex.exec("1")     // [ "1",     "1", null,   null ]
+* numericRegex.exec("1.23")  // [ "1.23",  "1", ".23",  null ]
+* numericRegex.exec("1 2/3") // [ "1 2/3", "1", " 2/3", " 2" ]
+* numericRegex.exec("2/3")   // [ "2/3",   "2", "/3",   null ]
+* numericRegex.exec("2 / 3") // [ "2 / 3", "2", "/ 3",  null ]
+* ```
+*/
+declare const numericRegex: RegExp;
+/**
+* Same as {@link numericRegex}, but allows (and ignores) trailing invalid characters.
+* Capture group 7 contains the trailing invalid portion.
+*/
+declare const numericRegexWithTrailingInvalid: RegExp;
+/**
+* Captures any Unicode vulgar fractions.
+*/
+declare const vulgarFractionsRegex: RegExp;
+type RomanNumeralSequenceFragment = `${RomanNumeralAscii}` | `${RomanNumeralAscii}${RomanNumeralAscii}` | `${RomanNumeralAscii}${RomanNumeralAscii}${RomanNumeralAscii}` | `${RomanNumeralAscii}${RomanNumeralAscii}${RomanNumeralAscii}${RomanNumeralAscii}`;
+/**
+* Map of Roman numeral sequences to their decimal equivalents.
+*/
+declare const romanNumeralValues: { [k in RomanNumeralSequenceFragment]?: number };
+/**
+* Map of Unicode Roman numeral code points to their ASCII equivalents.
+*/
+declare const romanNumeralUnicodeToAsciiMap: Record<RomanNumeralUnicode, keyof typeof romanNumeralValues>;
+/**
+* Captures all Unicode Roman numeral code points.
+*/
+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" ]
+* ```
+*/
+declare const romanNumeralRegex: RegExp;
+/**
+* Default options for {@link numericQuantity}.
+*/
+declare const defaultOptions: Required<NumericQuantityOptions>;
+//#endregion
+//#region src/isNumericQuantity.d.ts
+/**
+* Checks if a string represents a valid numeric quantity.
+*
+* Returns `true` if the string can be parsed as a number, `false` otherwise.
+* Accepts the same options as `numericQuantity`.
+*/
+declare const isNumericQuantity: (quantity: string | number, 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.
+*/
+declare function numericQuantity(quantity: string | number): number;
+declare function numericQuantity<T extends NumericQuantityOptions>(quantity: string | number, options: T): NumericQuantityReturnType<T>;
+declare function numericQuantity(quantity: string | number, options?: NumericQuantityOptions): number;
+//#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`).
+*/
+declare const parseRomanNumerals: (romanNumerals: string) => number;
+//#endregion
+export { NumericQuantityOptions, NumericQuantityReturnType, NumericQuantityVerboseResult, RomanNumeral, RomanNumeralAscii, RomanNumeralUnicode, VulgarFraction, defaultOptions, isNumericQuantity, normalizeDigits, numericQuantity, numericRegex, numericRegexWithTrailingInvalid, parseRomanNumerals, romanNumeralRegex, romanNumeralUnicodeRegex, romanNumeralUnicodeToAsciiMap, romanNumeralValues, vulgarFractionToAsciiMap, vulgarFractionsRegex };
+//# sourceMappingURL=numeric-quantity.legacy-esm.d.ts.map

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

@@ -1,5 +1,109 @@
 //#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
+];
+/**
+* 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(/* @__PURE__ */ new RegExp("\\p{Nd}", "gu"), (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 fraction code points to their ASCII equivalents.
 */
 const vulgarFractionToAsciiMap = {
@@ -32,7 +136,7 @@ const vulgarFractionToAsciiMap = {
 * |  #  |    Description                                   |        Example(s)                                                   |
 * | --- | ------------------------------------------------ | ------------------------------------------------------------------- |
 * | `0` | entire string                                    | `"2 1/3"` from `"2 1/3"`                                            |
-* | `1` | "negative" dash                                  | `"-"` 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 fraction, decimal portion, or denominator | `" 1/3"` from `"2 1/3"`; `".33"` from `"2.33"`; `"/3"` from `"1/3"` |
 *
@@ -48,15 +152,16 @@ const vulgarFractionToAsciiMap = {
 * numericRegex.exec("2 / 3") // [ "2 / 3", "2", "/ 3",  null ]
 * ```
 */
-const numericRegex = new RegExp("^(?=-?\\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)*)?$", "");
+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 group 7 contains the trailing invalid portion.
 */
-const numericRegexWithTrailingInvalid = new RegExp("^(?=-?\\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/].*)?", "");
+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 = new RegExp("([¼½¾⅐⅑⅒⅓⅔⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞⅟}])", "g");
+const vulgarFractionsRegex = /([¼½¾⅐⅑⅒⅓⅔⅕⅖⅗⅘⅙⅚⅛⅜⅝⅞⅟}])/g;
 /**
 * Map of Roman numeral sequences to their decimal equivalents.
 */
@@ -134,7 +239,7 @@ const romanNumeralUnicodeToAsciiMap = {
 /**
 * Captures all Unicode Roman numeral code points.
 */
-const romanNumeralUnicodeRegex = new RegExp("([ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫⅬⅭⅮⅯⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹⅺⅻⅼⅽⅾⅿ])", "gi");
+const romanNumeralUnicodeRegex = /([ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫⅬⅭⅮⅯⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹⅺⅻⅼⅽⅾⅿ])/gi;
 /**
 * Captures a valid Roman numeral sequence.
 *
@@ -156,7 +261,7 @@ const romanNumeralUnicodeRegex = new RegExp("([ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪ
 * romanNumeralRegex.exec("MCCXIV") // [ "MCCXIV", "M", "CC", "X", "IV" ]
 * ```
 */
-const romanNumeralRegex = new RegExp("^(?=[MDCLXVI])(M{0,3})(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$", "i");
+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}.
 */
@@ -165,7 +270,10 @@ const defaultOptions = {
 	allowTrailingInvalid: false,
 	romanNumerals: false,
 	bigIntOnOverflow: false,
-	decimalSeparator: "."
+	decimalSeparator: ".",
+	allowCurrency: false,
+	percentage: false,
+	verbose: false
 };
 
 //#endregion
@@ -187,18 +295,18 @@ const parseRomanNumerals = (romanNumerals) => {
 };
 
 //#endregion
-//#region node_modules/@oxc-project/runtime/src/helpers/esm/typeof.js
+//#region \0@oxc-project+runtime@0.112.0/helpers/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
-	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
-		return typeof o$1;
-	} : function(o$1) {
-		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	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 node_modules/@oxc-project/runtime/src/helpers/esm/toPrimitive.js
+//#region \0@oxc-project+runtime@0.112.0/helpers/toPrimitive.js
 function toPrimitive(t, r) {
 	if ("object" != _typeof(t) || !t) return t;
 	var e = t[Symbol.toPrimitive];
@@ -211,14 +319,14 @@ function toPrimitive(t, r) {
 }
 
 //#endregion
-//#region node_modules/@oxc-project/runtime/src/helpers/esm/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.112.0/helpers/toPropertyKey.js
 function toPropertyKey(t) {
 	var i = toPrimitive(t, "string");
 	return "symbol" == _typeof(i) ? i : i + "";
 }
 
 //#endregion
-//#region node_modules/@oxc-project/runtime/src/helpers/esm/defineProperty.js
+//#region \0@oxc-project+runtime@0.112.0/helpers/defineProperty.js
 function _defineProperty(e, r, t) {
 	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 		value: t,
@@ -229,13 +337,13 @@ function _defineProperty(e, r, t) {
 }
 
 //#endregion
-//#region node_modules/@oxc-project/runtime/src/helpers/esm/objectSpread2.js
+//#region \0@oxc-project+runtime@0.112.0/helpers/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$1) {
-			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		r && (o = o.filter(function(r) {
+			return Object.getOwnPropertyDescriptor(e, r).enumerable;
 		})), t.push.apply(t, o);
 	}
 	return t;
@@ -243,10 +351,10 @@ function ownKeys(e, r) {
 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$1) {
-			_defineProperty(e, r$1, t[r$1]);
-		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
-			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+		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;
@@ -255,18 +363,65 @@ function _objectSpread2(e) {
 //#endregion
 //#region src/numericQuantity.ts
 const spaceThenSlashRegex = /^\s*\//;
+const currencyPrefixRegex = /* @__PURE__ */ new RegExp("^([-+]?)\\s*(\\p{Sc}+)\\s*", "u");
+const currencySuffixRegex = /* @__PURE__ */ new RegExp("\\s*(\\p{Sc}+)$", "u");
+const percentageSuffixRegex = /%$/;
 function numericQuantity(quantity, options = defaultOptions) {
-	if (typeof quantity === "number" || typeof quantity === "bigint") return quantity;
-	let finalResult = NaN;
-	const quantityAsString = `${quantity}`.replace(vulgarFractionsRegex, (_m, vf) => ` ${vulgarFractionToAsciiMap[vf]}`).replace("⁄", "/").trim();
-	if (quantityAsString.length === 0) return NaN;
 	const opts = _objectSpread2(_objectSpread2({}, defaultOptions), options);
+	const originalInput = typeof quantity === "string" ? quantity : `${quantity}`;
+	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;
+	if (typeof quantity === "number" || typeof quantity === "bigint") return returnValue(quantity);
+	let finalResult = NaN;
+	let workingString = `${quantity}`;
+	if (opts.allowCurrency) {
+		const prefixMatch = currencyPrefixRegex.exec(workingString);
+		if (prefixMatch && prefixMatch[2]) {
+			currencyPrefix = prefixMatch[2];
+			workingString = (prefixMatch[1] || "") + workingString.slice(prefixMatch[0].length);
+		}
+	}
+	if (opts.allowCurrency) {
+		const suffixMatch = currencySuffixRegex.exec(workingString);
+		if (suffixMatch) {
+			currencySuffix = suffixMatch[1];
+			workingString = workingString.slice(0, -suffixMatch[0].length);
+		}
+	}
+	if (opts.percentage && percentageSuffixRegex.test(workingString)) {
+		percentageSuffix = true;
+		workingString = workingString.slice(0, -1);
+	}
+	const quantityAsString = normalizeDigits(workingString.replace(vulgarFractionsRegex, (_m, vf) => ` ${vulgarFractionToAsciiMap[vf]}`).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) {
-			if (!opts.allowTrailingInvalid) return NaN;
+			if (!opts.allowTrailingInvalid) return returnValue(NaN);
 			const firstCommaIndex = quantityAsString.indexOf(",");
 			const secondCommaIndex = quantityAsString.indexOf(",", firstCommaIndex + 1);
 			const beforeSecondComma = quantityAsString.substring(0, secondCommaIndex).replaceAll(".", "_").replace(",", ".");
@@ -274,20 +429,30 @@ function numericQuantity(quantity, options = defaultOptions) {
 			normalizedString = opts.allowTrailingInvalid ? beforeSecondComma + "&" + afterSecondComma : beforeSecondComma;
 		} else normalizedString = quantityAsString.replaceAll(".", "_");
 	}
-	const regexResult = (opts.allowTrailingInvalid ? numericRegexWithTrailingInvalid : numericRegex).exec(normalizedString);
-	if (!regexResult) return opts.romanNumerals ? parseRomanNumerals(quantityAsString) : NaN;
-	const [, dash, ng1temp, ng2temp] = regexResult;
+	const regexResult = numericRegexWithTrailingInvalid.exec(normalizedString);
+	if (!regexResult) return returnValue(opts.romanNumerals ? parseRomanNumerals(quantityAsString) : NaN);
+	const rawTrailing = (regexResult[7] || normalizedString.slice(regexResult[0].length)).trim();
+	if (rawTrailing) {
+		trailingInvalid = rawTrailing;
+		if (!opts.allowTrailingInvalid) return returnValue(NaN);
+	}
+	const [, sign, ng1temp, ng2temp] = regexResult;
+	if (sign === "-" || sign === "+") parsedSign = sign;
 	const numberGroup1 = ng1temp.replaceAll(",", "").replaceAll("_", "");
 	const numberGroup2 = ng2temp === null || ng2temp === void 0 ? void 0 : ng2temp.replaceAll(",", "").replaceAll("_", "");
 	if (!numberGroup1 && numberGroup2 && numberGroup2.startsWith(".")) finalResult = 0;
 	else {
 		if (opts.bigIntOnOverflow) {
-			const asBigInt = dash ? BigInt(`-${numberGroup1}`) : BigInt(numberGroup1);
-			if (asBigInt > BigInt(Number.MAX_SAFE_INTEGER) || asBigInt < BigInt(Number.MIN_SAFE_INTEGER)) return asBigInt;
+			const asBigInt = sign === "-" ? BigInt(`-${numberGroup1}`) : BigInt(numberGroup1);
+			if (asBigInt > BigInt(Number.MAX_SAFE_INTEGER) || asBigInt < BigInt(Number.MIN_SAFE_INTEGER)) return returnValue(asBigInt);
 		}
 		finalResult = parseInt(numberGroup1);
 	}
-	if (!numberGroup2) return dash ? finalResult * -1 : finalResult;
+	if (!numberGroup2) {
+		finalResult = sign === "-" ? finalResult * -1 : finalResult;
+		if (percentageSuffix && opts.percentage !== "number") finalResult = finalResult / 100;
+		return returnValue(finalResult);
+	}
 	const roundingFactor = opts.round === false ? NaN : parseFloat(`1e${Math.floor(Math.max(0, opts.round))}`);
 	if (numberGroup2.startsWith(".") || numberGroup2.startsWith("e") || numberGroup2.startsWith("E")) {
 		const decimalValue = parseFloat(`${finalResult}${numberGroup2}`);
@@ -295,15 +460,34 @@ function numericQuantity(quantity, options = defaultOptions) {
 	} else if (spaceThenSlashRegex.test(numberGroup2)) {
 		const numerator = parseInt(numberGroup1);
 		const denominator = parseInt(numberGroup2.replace("/", ""));
+		parsedNumerator = numerator;
+		parsedDenominator = denominator;
 		finalResult = isNaN(roundingFactor) ? numerator / denominator : Math.round(numerator * roundingFactor / denominator) / roundingFactor;
 	} else {
-		const fractionArray = numberGroup2.split("/");
-		const [numerator, denominator] = fractionArray.map((v) => parseInt(v));
+		const [numerator, denominator] = numberGroup2.split("/").map((v) => parseInt(v));
+		parsedWhole = finalResult;
+		parsedNumerator = numerator;
+		parsedDenominator = denominator;
 		finalResult += isNaN(roundingFactor) ? numerator / denominator : Math.round(numerator * roundingFactor / denominator) / roundingFactor;
 	}
-	return dash ? finalResult * -1 : finalResult;
+	finalResult = sign === "-" ? finalResult * -1 : finalResult;
+	if (percentageSuffix && opts.percentage !== "number") finalResult = isNaN(roundingFactor) ? finalResult / 100 : Math.round(finalResult / 100 * roundingFactor) / roundingFactor;
+	return returnValue(finalResult);
 }
 
 //#endregion
-export { defaultOptions, numericQuantity, numericRegex, numericRegexWithTrailingInvalid, parseRomanNumerals, romanNumeralRegex, romanNumeralUnicodeRegex, romanNumeralUnicodeToAsciiMap, romanNumeralValues, vulgarFractionToAsciiMap, vulgarFractionsRegex };
+//#region src/isNumericQuantity.ts
+/**
+* Checks if a string represents a valid numeric quantity.
+*
+* Returns `true` if the string 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, vulgarFractionToAsciiMap, vulgarFractionsRegex };
 //# sourceMappingURL=numeric-quantity.legacy-esm.js.map