@flickfyi/flkr 0.0.141 → 0.0.153

package/node_modules/intl-messageformat/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "intl-messageformat",
+  "version": "12.1.3",
+  "description": "Formats ICU Message strings with number, date, plural, and select placeholders to create localized messages.",
+  "keywords": [
+    "globalization",
+    "i18n",
+    "icu",
+    "internationalization",
+    "intl",
+    "localization",
+    "messageformat",
+    "parser",
+    "plural"
+  ],
+  "homepage": "https://github.com/formatjs/formatjs",
+  "bugs": "https://github.com/formatjs/formatjs/issues",
+  "license": "BSD-3-Clause",
+  "author": "Eric Ferraiuolo <eferraiuolo@gmail.com>",
+  "contributors": [
+    "Anthony Pipkin <a.pipkin@yahoo.com>",
+    "Caridy Patino <caridy@gmail.com>",
+    "Drew Folta <drew@folta.net>",
+    "Long Ho <holevietlong@gmail.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:formatjs/formatjs.git"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "types": "index.d.ts",
+  "exports": {
+    ".": "./index.js"
+  },
+  "dependencies": {
+    "@formatjs/fast-memoize": "3.1.7",
+    "@formatjs/icu-messageformat-parser": "3.5.21"
+  }
+}

package/node_modules/numeric-quantity/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Jake Boone
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/numeric-quantity/README.md

@@ -0,0 +1,306 @@
+[![npm][badge-npm]](https://www.npmjs.com/package/numeric-quantity)
+![workflow status](https://github.com/jakeboone02/numeric-quantity/actions/workflows/main.yml/badge.svg)
+[![codecov.io](https://codecov.io/github/jakeboone02/numeric-quantity/coverage.svg?branch=main)](https://codecov.io/github/jakeboone02/numeric-quantity?branch=main)
+[![downloads](https://img.shields.io/npm/dm/numeric-quantity.svg)](https://npm-stat.com/charts.html?package=numeric-quantity&from=2015-08-01)
+[![MIT License](https://img.shields.io/npm/l/numeric-quantity.svg)](https://opensource.org/licenses/MIT)
+[![pkg.pr.new](https://pkg.pr.new/badge/jakeboone02/numeric-quantity)](https://pkg.pr.new/~/jakeboone02/numeric-quantity)
+
+Converts a string to a number, like an enhanced version of `parseFloat`. Returns `NaN` if the provided string does not resemble a number.
+
+**[Full documentation](https://jakeboone02.github.io/numeric-quantity/)**
+
+In addition to plain integers and decimals, `numeric-quantity` handles:
+
+- **Fractions and mixed numbers**: `'1 2/3'` → `1.667`, `'1⅖'` → `1.4`, `'1 2⁄3'` → `1.667`
+- **Separators**: `'1,000'` → `1000`, `'1_000_000'` → `1000000`
+- **Roman numerals** (see [option](#roman-numerals-romannumerals) below): `'XIV'` → `14`, `'Ⅻ'` → `12`
+- **Non-ASCII numerals**: Arabic-Indic (`'٣'`), Devanagari (`'३'`), Bengali, Thai, Fullwidth, and 70+ other Unicode digit scripts
+
+> _For the inverse operation—converting a number to an imperial measurement—check out [format-quantity](https://www.npmjs.com/package/format-quantity)._
+
+> _For a more complete solution to parsing recipe ingredients, try [parse-ingredient](https://www.npmjs.com/package/parse-ingredient)._
+
+## Usage
+
+### Installed
+
+```js
+import { numericQuantity } from 'numeric-quantity';
+
+console.log(numericQuantity('1 1/2')); // 1.5
+console.log(numericQuantity('2 2/3')); // 2.667
+```
+
+### CDN
+
+As an ES module:
+
+```html
+<script type="module">
+  import { numericQuantity } from 'https://cdn.jsdelivr.net/npm/numeric-quantity/+esm';
+
+  console.log(numericQuantity('10½')); // 10.5
+</script>
+```
+
+As UMD (all exports are properties of the global object `NumericQuantity`):
+
+```html
+<script src="https://unpkg.com/numeric-quantity"></script>
+<script>
+  console.log(NumericQuantity.numericQuantity('xii', { romanNumerals: true })); // 12
+</script>
+```
+
+## Options
+
+All options are passed as the second argument to `numericQuantity` (and `isNumericQuantity`).
+
+### Rounding (`round`)
+
+Results are rounded to three decimal places by default. Use the `round` option to change this behavior.
+
+```js
+numericQuantity('1/3'); // 0.333 (default: 3 decimal places)
+numericQuantity('1/3', { round: 5 }); // 0.33333
+numericQuantity('1/3', { round: false }); // 0.3333333333333333
+```
+
+Coercion rules:
+
+- Non-finite values (`NaN`, `Infinity`, `-Infinity`) are treated as `false`, i.e. no rounding.
+- Negative values clamp to `0`, i.e. round to a whole number.
+- `round` does not apply to `bigint` results (see [`bigIntOnOverflow`](#large-numbers-bigintonoverflow)).
+- When the `percentage` option divides by 100, `round` applies to the value _as written_, before the division (see [Percentages](#percentages-percentage)).
+
+### Trailing Invalid Characters (`allowTrailingInvalid`)
+
+By default, strings with trailing non-numeric characters return `NaN`. Set `allowTrailingInvalid: true` to ignore trailing invalid characters, similar to `parseFloat`.
+
+```js
+numericQuantity('100abc'); // NaN
+numericQuantity('100abc', { allowTrailingInvalid: true }); // 100
+```
+
+### Roman Numerals (`romanNumerals`)
+
+Parse Roman numerals (ASCII or Unicode) by setting `romanNumerals: true`. You can also use `parseRomanNumerals` directly.
+
+```js
+numericQuantity('MCCXIV', { romanNumerals: true }); // 1214
+numericQuantity('Ⅻ', { romanNumerals: true }); // 12
+numericQuantity('xiv', { romanNumerals: true }); // 14 (case-insensitive)
+```
+
+### Decimal Separator (`decimalSeparator`)
+
+For European-style numbers where comma is the decimal separator, set `decimalSeparator: ','`.
+
+```js
+numericQuantity('1,5'); // 15 (comma treated as thousands separator)
+numericQuantity('1,5', { decimalSeparator: ',' }); // 1.5
+numericQuantity('1.000,50', { decimalSeparator: ',' }); // 1000.5
+```
+
+### Large Numbers (`bigIntOnOverflow`)
+
+When the parsed value exceeds `Number.MAX_SAFE_INTEGER` or is less than `Number.MIN_SAFE_INTEGER`, set `bigIntOnOverflow: true` to return a `bigint` instead.
+
+```js
+numericQuantity('9007199254740993'); // 9007199254740992 (loses precision)
+numericQuantity('9007199254740993', { bigIntOnOverflow: true }); // 9007199254740993n
+```
+
+This applies to _any_ overflowing value, not just integers as written—decimals, fractions, mixed numbers, and exponents all participate. The value is evaluated exactly as a rational number and only rounded at the end.
+
+```js
+const opts = { bigIntOnOverflow: true };
+numericQuantity('9007199254740993.5', opts); // 9007199254740994n (half-up)
+numericQuantity('-9007199254740993.5', opts); // -9007199254740994n (half away from zero)
+numericQuantity('9007199254740993 1/2', opts); // 9007199254740994n
+numericQuantity('9007199254740993e1', opts); // 90071992547409930n (exact, no rounding)
+```
+
+Notes:
+
+- **Fractional tails are unrecoverable anyway.** Past `Number.MAX_SAFE_INTEGER` the gap between adjacent `number` values is 2, so no `number` can carry a fraction at that magnitude. Rounding to a `bigint` loses less than falling back to `number` would.
+- **`round` is not consulted.** `bigint` has no fractional representation, so `round: false` does not disable the half-up rounding.
+- **Rounding can _cause_ overflow.** `numericQuantity('9007199254740991.6', opts)` is `9007199254740992n`, even though the integer part as written is within range.
+- **`percentage` division is folded in exactly**, as a factor of `100n` in the denominator, so it is subject to the same single half-up rounding at the end.
+
+  ```js
+  const opts = { bigIntOnOverflow: true, percentage: true };
+  numericQuantity('900719925474099300%', opts); // 9007199254740993n (exact)
+  numericQuantity('900719925474099399%', opts); // 9007199254740994n (rounded)
+  ```
+
+### Percentages (`percentage`)
+
+Parse percentage strings by setting the `percentage` option. Use `'decimal'` (or `true`) to divide by 100, or `'number'` to just strip the `%` symbol.
+
+```js
+numericQuantity('50%'); // NaN
+numericQuantity('50%', { percentage: true }); // 0.5
+numericQuantity('50%', { percentage: 'decimal' }); // 0.5
+numericQuantity('50%', { percentage: 'number' }); // 50
+numericQuantity('1/2%', { percentage: true }); // 0.005
+```
+
+`round` applies to the value as written, _before_ the division by 100, so the requested number of decimal places is not silently reduced:
+
+```js
+numericQuantity('12.345%', { percentage: true, round: 3 }); // 0.12345, not 0.123
+numericQuantity('1%', { percentage: true, round: 0 }); // 0.01
+numericQuantity('1.0%', { percentage: true, round: 0 }); // 0.01
+numericQuantity('1/1%', { percentage: true, round: 0 }); // 0.01
+```
+
+Roman numerals honor `percentage` as well:
+
+```js
+numericQuantity('L%', { percentage: true, romanNumerals: true }); // 0.5
+```
+
+### Currency Symbols (`allowCurrency`)
+
+Strip currency symbols from the start or end of the string by setting `allowCurrency: true`. Supports all Unicode currency symbols (`$`, `€`, `£`, `¥`, `₹`, `₽`, `₿`, `₩`, etc.).
+
+```js
+numericQuantity('$100'); // NaN
+numericQuantity('$100', { allowCurrency: true }); // 100
+numericQuantity('€1.000,50', { allowCurrency: true, decimalSeparator: ',' }); // 1000.5
+numericQuantity('100€', { allowCurrency: true }); // 100
+numericQuantity('-$50', { allowCurrency: true }); // -50
+```
+
+Currency symbols and the `%` suffix may appear in either order, but at most one `%` is stripped per parse:
+
+```js
+const opts = { allowCurrency: true, percentage: true };
+numericQuantity('50%€', opts); // 0.5
+numericQuantity('100€%', opts); // 1
+numericQuantity('100 € %', opts); // 1
+numericQuantity('50%%', opts); // NaN
+numericQuantity('50%€%', opts); // NaN
+```
+
+### Verbose Output (`verbose`)
+
+Set `verbose: true` to return a detailed result object instead of just the numeric value. This is useful for understanding what was parsed and stripped.
+
+```js
+numericQuantity('$50%', {
+  verbose: true,
+  allowCurrency: true,
+  percentage: true,
+});
+// {
+//   value: 0.5,
+//   input: '$50%',
+//   currencyPrefix: '$',
+//   percentageSuffix: true
+// }
+
+numericQuantity('100abc', {
+  verbose: true,
+  allowTrailingInvalid: true,
+});
+// {
+//   value: 100,
+//   input: '100abc',
+//   trailingInvalid: 'abc'
+// }
+```
+
+For fraction and mixed-number inputs, the result also includes parsed fraction components (always unsigned):
+
+```js
+numericQuantity('1 2/3', { verbose: true });
+// {
+//   value: 1.667,
+//   input: '1 2/3',
+//   whole: 1,
+//   numerator: 2,
+//   denominator: 3
+// }
+
+numericQuantity('½', { verbose: true });
+// {
+//   value: 0.5,
+//   input: '½',
+//   numerator: 1,
+//   denominator: 2
+// }
+```
+
+The verbose result object has the following shape:
+
+```ts
+interface NumericQuantityVerboseResult {
+  value: number | bigint; // The parsed value (NaN if invalid)
+  input: string; // Original input string
+  currencyPrefix?: string; // Currency symbol(s) stripped from start
+  currencySuffix?: string; // Currency symbol(s) stripped from end
+  percentageSuffix?: boolean; // True if "%" was stripped
+  trailingInvalid?: string; // Characters ignored (if allowTrailingInvalid)
+  sign?: '-' | '+'; // Leading sign character, if present
+  whole?: number; // Whole part of a mixed fraction (e.g. 1 from "1 2/3")
+  numerator?: number; // Fraction numerator (e.g. 2 from "1 2/3")
+  denominator?: number; // Fraction denominator (e.g. 3 from "1 2/3")
+}
+```
+
+## `Infinity`
+
+`Infinity` is a valid result, not an error. Division by zero and overflowing exponents both produce it, and `isNumericQuantity` returns `true` for them.
+
+```js
+numericQuantity('1/0'); // Infinity
+numericQuantity('1e400'); // Infinity
+isNumericQuantity('1/0'); // true
+```
+
+## Additional Exports
+
+### `isNumericQuantity(str, options?): boolean`
+
+Returns `true` if the string can be parsed as a valid number, `false` otherwise. Accepts the same options as `numericQuantity`.
+
+```js
+import { isNumericQuantity } from 'numeric-quantity';
+
+isNumericQuantity('1 1/2'); // true
+isNumericQuantity('abc'); // false
+isNumericQuantity('XII', { romanNumerals: true }); // true
+isNumericQuantity('$100', { allowCurrency: true }); // true
+isNumericQuantity('50%', { percentage: true }); // true
+```
+
+### `parseRomanNumerals(str): number`
+
+Parses a string of Roman numerals directly. Returns `NaN` for invalid input.
+
+```js
+import { parseRomanNumerals } from 'numeric-quantity';
+
+parseRomanNumerals('MCMXCIX'); // 1999
+parseRomanNumerals('Ⅻ'); // 12
+parseRomanNumerals('invalid'); // NaN
+```
+
+### Constants and utilities
+
+The internals used by the parser are also part of the public API and are safe to depend on:
+
+| Export                                                       | Description                                                              |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------ |
+| `normalizeDigits(str)`                                       | Converts non-ASCII decimal digits (70+ Unicode scripts) to ASCII `0`–`9` |
+| `numericRegex`                                               | The core pattern matched against a fully normalized string               |
+| `numericRegexWithTrailingInvalid`                            | Same, but with a trailing capture group for `allowTrailingInvalid`       |
+| `vulgarFractionToAsciiMap` / `vulgarFractionsRegex`          | Vulgar fraction characters (`½`, `⅔`, …) and their ASCII equivalents     |
+| `superSubDigitToAsciiMap` / `superSubDigitsRegex`            | Superscript/subscript digits (`¹`, `₂`, …) and their ASCII equivalents   |
+| `romanNumeralValues` / `romanNumeralRegex`                   | Roman numeral values and the validation pattern                          |
+| `romanNumeralUnicodeToAsciiMap` / `romanNumeralUnicodeRegex` | Unicode Roman numeral characters (`Ⅻ`, …) and their ASCII equivalents    |
+| `defaultOptions`                                             | The fully-resolved default option set                                    |
+
+[badge-npm]: https://img.shields.io/npm/v/numeric-quantity.svg?cacheSeconds=3600&logo=npm

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

@@ -0,0 +1 @@
+export * from './numeric-quantity.cjs.development.js';

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

@@ -0,0 +1,6 @@
+'use strict';
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./numeric-quantity.cjs.production.js');
+} else {
+  module.exports = require('./numeric-quantity.cjs.development.js');
+}

package/node_modules/numeric-quantity/dist/cjs/numeric-quantity.cjs.development.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.development.d.ts.map