@c9up/atom 0.1.3 → 0.1.5

package/dist/Decimal.d.ts

@@ -0,0 +1,167 @@
+export type DecimalInput = string | number | bigint | Decimal;
+export type RoundMode = "trunc" | "floor" | "ceil" | "half-up" | "half-even";
+export interface DecimalScaled {
+    value: bigint;
+    scale: number;
+}
+export interface DivOptions {
+    precision?: number;
+}
+export interface PowOptions {
+    precision?: number;
+}
+export interface SqrtOptions {
+    precision?: number;
+    mode?: RoundMode;
+}
+export interface BetweenOptions {
+    inclusive?: boolean;
+}
+export interface QuantizeOptions {
+    mode?: RoundMode;
+    precision?: number;
+}
+export interface MedianOptions {
+    precision?: number;
+}
+export interface StddevOptions {
+    sample?: boolean;
+    precision?: number;
+    mode?: RoundMode;
+}
+export interface ToMinorUnitsOptions {
+    exact?: boolean;
+    mode?: RoundMode;
+}
+export declare class Decimal {
+    #private;
+    constructor(value: DecimalInput);
+    static from(value: DecimalInput): Decimal;
+    static zero(): Decimal;
+    static one(): Decimal;
+    static fromMinorUnits(value: string | number | bigint, scale: number): Decimal;
+    static parseLocale(value: string, localesOrRosetta?: Intl.LocalesArgument | RosettaLike): Decimal;
+    plus(other: DecimalInput): Decimal;
+    minus(other: DecimalInput): Decimal;
+    times(other: DecimalInput): Decimal;
+    div(other: DecimalInput, options?: DivOptions): Decimal;
+    mod(other: DecimalInput): Decimal;
+    pow(exp: number, options?: PowOptions): Decimal;
+    sqrt(options?: SqrtOptions): Decimal;
+    cmp(other: DecimalInput): -1 | 0 | 1;
+    eq(other: DecimalInput): boolean;
+    lt(other: DecimalInput): boolean;
+    lte(other: DecimalInput): boolean;
+    gt(other: DecimalInput): boolean;
+    gte(other: DecimalInput): boolean;
+    min(other: DecimalInput): Decimal;
+    max(other: DecimalInput): Decimal;
+    clamp(min: DecimalInput, max: DecimalInput): Decimal;
+    between(min: DecimalInput, max: DecimalInput, options?: BetweenOptions): boolean;
+    abs(): Decimal;
+    neg(): Decimal;
+    isZero(): boolean;
+    isPositive(): boolean;
+    isNegative(): boolean;
+    isInteger(): boolean;
+    trunc(scale?: number): Decimal;
+    floor(scale?: number): Decimal;
+    ceil(scale?: number): Decimal;
+    round(scale?: number, mode?: RoundMode): Decimal;
+    /**
+     * Snap the value to the nearest multiple of `step`. Useful for rounding
+     * prices to the nearest cent (`.quantize('0.01')`), the nearest 5-cent
+     * increment, or any custom unit. The default rounding mode is `'half-up'`;
+     * pass `{ mode: 'half-even' }` for banker's rounding.
+     *
+     *     new Decimal('1.234').quantize('0.01')  // → Decimal('1.23')
+     *     new Decimal('1.025').quantize('0.05')  // → Decimal('1.05')
+     */
+    quantize(step: DecimalInput, options?: QuantizeOptions): Decimal;
+    toScale(scale?: number, mode?: RoundMode): Decimal;
+    toFixed(scale: number, mode?: RoundMode): string;
+    /**
+     * Convert to a minor-unit `bigint` representation — typically used for
+     * persisting prices to a database as integer cents (`scale: 2`).
+     *
+     * - `exact: true` (default) throws if the conversion would lose precision
+     *   (e.g. `'1.234'.toMinorUnits(2)` errors because `0.004` can't be
+     *   represented at scale 2 without rounding).
+     * - `exact: false` rounds using the requested `mode` (default `'trunc'`).
+     *
+     *     new Decimal('19.99').toMinorUnits(2)  // → 1999n
+     *     new Decimal('1.234').toMinorUnits(2, { exact: false })  // → 123n (truncated)
+     */
+    toMinorUnits(scale: number, options?: ToMinorUnitsOptions): bigint;
+    /**
+     * Compute `this * rate / 100` — the percentage portion of the value.
+     *
+     *     new Decimal('200').percent('15')  // → Decimal('30')
+     */
+    percent(rate: DecimalInput, options?: DivOptions): Decimal;
+    /**
+     * Add a percentage to the value: `this + (this * rate / 100)`. Handy for
+     * tax/markup calculations.
+     *
+     *     new Decimal('100').applyPercent('20')  // → Decimal('120')
+     */
+    applyPercent(rate: DecimalInput, options?: DivOptions): Decimal;
+    /**
+     * Express this value as a percentage of `total`: `this / total * 100`.
+     *
+     *     new Decimal('30').percentageOf('200')  // → Decimal('15')
+     */
+    percentageOf(total: DecimalInput, options?: DivOptions): Decimal;
+    /**
+     * Distribute the value across N buckets according to integer ratios with
+     * **zero rounding loss**: the sum of the returned shares equals the
+     * original value exactly. Used for splitting money: `'10.00'.allocate([1, 1, 1])`
+     * returns `['3.34', '3.33', '3.33']`, not three `'3.33'` (which would
+     * lose a cent).
+     *
+     * The remainder pennies are distributed largest-remainder-first, with
+     * stable input order as the tiebreaker.
+     */
+    allocate(ratios: Array<string | number | bigint>): Decimal[];
+    toParts(): DecimalScaled;
+    toString(): string;
+    toJSON(): string;
+    /**
+     * Convert to a JavaScript `number` — **lossy** for values with more than
+     * 15-16 significant digits. Use `toString()` / `toJSON()` for exact output.
+     * Provided for interop with APIs that expect a primitive number.
+     */
+    toNumber(): number;
+    /**
+     * Format the value as a localized string via `Intl.NumberFormat`.
+     *
+     * Unlike `toNumber()`, this path is **exact** — we route through the
+     * string-accepting overload of `Intl.NumberFormat.format` (ECMA-402
+     * stage-4, supported by every V8 since Node 20). A `Decimal` of
+     * `'9999999999999999.99'` formats correctly instead of rounding to
+     * `10000000000000000`, which is the whole reason Atom exists.
+     *
+     * For pure integers without a decimal point, we hand the value to
+     * `format` as a BigInt (which has been in the type system since ES2020).
+     * For fractional values, we use the runtime's string support via a
+     * typed extension interface — no `any` escape hatch.
+     */
+    toLocale(localesOrRosetta?: Intl.LocalesArgument | RosettaLike, options?: Intl.NumberFormatOptions): string;
+}
+/**
+ * Structural type matching `@c9up/rosetta`'s `Rosetta` and
+ * `RosettaLocale` surfaces. Atom never imports the Rosetta
+ * package directly — duck-typing keeps the integration optional
+ * and avoids a hard cross-package dependency.
+ */
+export interface RosettaNumberFormatData {
+    decimal: string;
+    group: string;
+    minus: string;
+    plusSign: string;
+}
+export interface RosettaLike {
+    getNumberFormatData(): RosettaNumberFormatData;
+    formatNumberString(value: string, options?: Intl.NumberFormatOptions): string;
+}
+//# sourceMappingURL=Decimal.d.ts.map

package/dist/Decimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decimal.d.ts","sourceRoot":"","sources":["../src/Decimal.ts"],"names":[],"mappings":"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"}

package/dist/Decimal.js

@@ -0,0 +1,513 @@
+import { formatDecimal, parseDecimal, pow10BigInt } from "./math.js";
+import { nativeAtom } from "./native.js";
+export class Decimal {
+    #value;
+    constructor(value) {
+        this.#value = normalizeInput(value);
+    }
+    static from(value) {
+        return new Decimal(value);
+    }
+    static zero() {
+        return new Decimal("0");
+    }
+    static one() {
+        return new Decimal("1");
+    }
+    static fromMinorUnits(value, scale) {
+        assertScale(scale);
+        const minor = parseIntegerInput(value);
+        return fromIntScale(minor, scale);
+    }
+    static parseLocale(value, localesOrRosetta) {
+        if (isRosettaLike(localesOrRosetta)) {
+            return new Decimal(normalizeViaRosetta(value, localesOrRosetta));
+        }
+        return new Decimal(normalizeLocaleNumber(value, localesOrRosetta));
+    }
+    plus(other) {
+        const b = normalizeInput(other);
+        const result = nativeAtom().add(this.#value, b);
+        return new Decimal(result);
+    }
+    minus(other) {
+        const b = normalizeInput(other);
+        const result = nativeAtom().sub(this.#value, b);
+        return new Decimal(result);
+    }
+    times(other) {
+        const b = normalizeInput(other);
+        const result = nativeAtom().mul(this.#value, b);
+        return new Decimal(result);
+    }
+    div(other, options = {}) {
+        const b = normalizeInput(other);
+        const precision = options.precision ?? 18;
+        assertScale(precision);
+        const result = nativeAtom().div(this.#value, b, precision);
+        return new Decimal(result);
+    }
+    mod(other) {
+        const b = normalizeInput(other);
+        const result = nativeAtom().rem(this.#value, b);
+        return new Decimal(result);
+    }
+    pow(exp, options = {}) {
+        if (!Number.isInteger(exp)) {
+            throw new Error(`Invalid exponent: ${exp}`);
+        }
+        const precision = options.precision ?? 18;
+        assertScale(precision);
+        const result = nativeAtom().pow(this.#value, exp, precision);
+        return new Decimal(result);
+    }
+    sqrt(options = {}) {
+        const precision = options.precision ?? 18;
+        const mode = options.mode ?? "trunc";
+        assertScale(precision);
+        if (mode === "trunc") {
+            const result = nativeAtom().sqrt(this.#value, precision);
+            return new Decimal(result);
+        }
+        const withExtra = nativeAtom().sqrt(this.#value, precision + 1);
+        const parsed = parseDecimal(withExtra);
+        const rounded = roundIntScale(parsed.int, precision + 1, precision, mode);
+        return fromIntScale(rounded, precision);
+    }
+    cmp(other) {
+        const b = normalizeInput(other);
+        const result = nativeAtom().cmp(this.#value, b);
+        if (result < 0)
+            return -1;
+        if (result > 0)
+            return 1;
+        return 0;
+    }
+    eq(other) {
+        return this.cmp(other) === 0;
+    }
+    lt(other) {
+        return this.cmp(other) < 0;
+    }
+    lte(other) {
+        return this.cmp(other) <= 0;
+    }
+    gt(other) {
+        return this.cmp(other) > 0;
+    }
+    gte(other) {
+        return this.cmp(other) >= 0;
+    }
+    min(other) {
+        return this.lte(other) ? this : new Decimal(other);
+    }
+    max(other) {
+        return this.gte(other) ? this : new Decimal(other);
+    }
+    clamp(min, max) {
+        const minValue = new Decimal(min);
+        const maxValue = new Decimal(max);
+        if (minValue.gt(maxValue)) {
+            throw new Error("Invalid clamp range: min is greater than max");
+        }
+        if (this.lt(minValue))
+            return minValue;
+        if (this.gt(maxValue))
+            return maxValue;
+        return this;
+    }
+    between(min, max, options = {}) {
+        const { inclusive = true } = options;
+        const minValue = new Decimal(min);
+        const maxValue = new Decimal(max);
+        if (minValue.gt(maxValue)) {
+            throw new Error("Invalid between range: min is greater than max");
+        }
+        if (inclusive) {
+            return this.gte(minValue) && this.lte(maxValue);
+        }
+        return this.gt(minValue) && this.lt(maxValue);
+    }
+    abs() {
+        return this.isNegative() ? this.neg() : this;
+    }
+    neg() {
+        return this.isZero()
+            ? this
+            : new Decimal(this.#value.startsWith("-")
+                ? this.#value.slice(1)
+                : `-${this.#value}`);
+    }
+    isZero() {
+        return this.#value === "0";
+    }
+    isPositive() {
+        return this.#value !== "0" && !this.#value.startsWith("-");
+    }
+    isNegative() {
+        return this.#value.startsWith("-");
+    }
+    isInteger() {
+        return parseDecimal(this.#value).scale === 0;
+    }
+    trunc(scale = 0) {
+        return this.toScale(scale, "trunc");
+    }
+    floor(scale = 0) {
+        return this.toScale(scale, "floor");
+    }
+    ceil(scale = 0) {
+        return this.toScale(scale, "ceil");
+    }
+    round(scale = 0, mode = "half-up") {
+        return this.toScale(scale, mode);
+    }
+    /**
+     * Snap the value to the nearest multiple of `step`. Useful for rounding
+     * prices to the nearest cent (`.quantize('0.01')`), the nearest 5-cent
+     * increment, or any custom unit. The default rounding mode is `'half-up'`;
+     * pass `{ mode: 'half-even' }` for banker's rounding.
+     *
+     *     new Decimal('1.234').quantize('0.01')  // → Decimal('1.23')
+     *     new Decimal('1.025').quantize('0.05')  // → Decimal('1.05')
+     */
+    quantize(step, options = {}) {
+        const { mode = "half-up" } = options;
+        const stepValue = new Decimal(step);
+        if (!stepValue.gt(0)) {
+            throw new Error("Quantize step must be greater than zero");
+        }
+        const thisScale = this.toParts().scale;
+        const stepScale = stepValue.toParts().scale;
+        const precision = options.precision ?? Math.max(18, thisScale + stepScale + 6);
+        const units = this.div(stepValue, { precision }).round(0, mode);
+        return units.times(stepValue);
+    }
+    toScale(scale = 0, mode = "trunc") {
+        assertScale(scale);
+        const parsed = parseDecimal(this.#value);
+        return fromIntScale(roundIntScale(parsed.int, parsed.scale, scale, mode), scale);
+    }
+    toFixed(scale, mode = "trunc") {
+        assertScale(scale);
+        const parsed = parseDecimal(this.#value);
+        const roundedInt = roundIntScale(parsed.int, parsed.scale, scale, mode);
+        const negative = roundedInt < 0n;
+        const raw = (negative ? -roundedInt : roundedInt)
+            .toString()
+            .padStart(scale + 1, "0");
+        if (scale === 0)
+            return negative ? `-${raw}` : raw;
+        const whole = raw.slice(0, raw.length - scale);
+        const frac = raw.slice(raw.length - scale);
+        const out = `${whole}.${frac}`;
+        return negative ? `-${out}` : out;
+    }
+    /**
+     * Convert to a minor-unit `bigint` representation — typically used for
+     * persisting prices to a database as integer cents (`scale: 2`).
+     *
+     * - `exact: true` (default) throws if the conversion would lose precision
+     *   (e.g. `'1.234'.toMinorUnits(2)` errors because `0.004` can't be
+     *   represented at scale 2 without rounding).
+     * - `exact: false` rounds using the requested `mode` (default `'trunc'`).
+     *
+     *     new Decimal('19.99').toMinorUnits(2)  // → 1999n
+     *     new Decimal('1.234').toMinorUnits(2, { exact: false })  // → 123n (truncated)
+     */
+    toMinorUnits(scale, options = {}) {
+        assertScale(scale);
+        const { exact = true, mode = "trunc" } = options;
+        const parsed = parseDecimal(this.#value);
+        if (parsed.scale === scale)
+            return parsed.int;
+        if (parsed.scale < scale) {
+            return parsed.int * pow10BigInt(scale - parsed.scale);
+        }
+        const drop = parsed.scale - scale;
+        const factor = pow10BigInt(drop);
+        const remainder = parsed.int % factor;
+        if (exact && remainder !== 0n) {
+            throw new Error(`Cannot convert ${this.#value} to minor units at scale ${scale} without precision loss`);
+        }
+        return roundIntScale(parsed.int, parsed.scale, scale, mode);
+    }
+    /**
+     * Compute `this * rate / 100` — the percentage portion of the value.
+     *
+     *     new Decimal('200').percent('15')  // → Decimal('30')
+     */
+    percent(rate, options = {}) {
+        return this.times(rate).div("100", options);
+    }
+    /**
+     * Add a percentage to the value: `this + (this * rate / 100)`. Handy for
+     * tax/markup calculations.
+     *
+     *     new Decimal('100').applyPercent('20')  // → Decimal('120')
+     */
+    applyPercent(rate, options = {}) {
+        return this.plus(this.percent(rate, options));
+    }
+    /**
+     * Express this value as a percentage of `total`: `this / total * 100`.
+     *
+     *     new Decimal('30').percentageOf('200')  // → Decimal('15')
+     */
+    percentageOf(total, options = {}) {
+        return this.div(total, options).times("100");
+    }
+    /**
+     * Distribute the value across N buckets according to integer ratios with
+     * **zero rounding loss**: the sum of the returned shares equals the
+     * original value exactly. Used for splitting money: `'10.00'.allocate([1, 1, 1])`
+     * returns `['3.34', '3.33', '3.33']`, not three `'3.33'` (which would
+     * lose a cent).
+     *
+     * The remainder pennies are distributed largest-remainder-first, with
+     * stable input order as the tiebreaker.
+     */
+    allocate(ratios) {
+        if (ratios.length === 0) {
+            throw new Error("Allocate requires at least one ratio");
+        }
+        const normalized = ratios.map((ratio) => {
+            const value = parseIntegerInput(ratio);
+            if (value < 0n) {
+                throw new Error(`Allocate ratios must be >= 0, got ${ratio}`);
+            }
+            return value;
+        });
+        const ratioTotal = normalized.reduce((acc, value) => acc + value, 0n);
+        if (ratioTotal <= 0n) {
+            throw new Error("Allocate requires at least one positive ratio");
+        }
+        const parsed = parseDecimal(this.#value);
+        const sign = parsed.int < 0n ? -1n : 1n;
+        const total = parsed.int < 0n ? -parsed.int : parsed.int;
+        const baseShares = [];
+        const remainders = [];
+        let consumed = 0n;
+        for (let index = 0; index < normalized.length; index++) {
+            const ratio = normalized[index];
+            const weighted = total * ratio;
+            const share = weighted / ratioTotal;
+            const remainder = weighted % ratioTotal;
+            baseShares.push(share);
+            remainders.push({ index, remainder });
+            consumed += share;
+        }
+        let left = total - consumed;
+        remainders.sort((a, b) => {
+            if (a.remainder > b.remainder)
+                return -1;
+            if (a.remainder < b.remainder)
+                return 1;
+            return a.index - b.index;
+        });
+        let pointer = 0;
+        while (left > 0n) {
+            baseShares[remainders[pointer].index] += 1n;
+            left -= 1n;
+            pointer++;
+            if (pointer >= remainders.length)
+                pointer = 0;
+        }
+        return baseShares.map((share) => fromIntScale(share * sign, parsed.scale));
+    }
+    toParts() {
+        const parsed = parseDecimal(this.#value);
+        return { value: parsed.int, scale: parsed.scale };
+    }
+    toString() {
+        return this.#value;
+    }
+    toJSON() {
+        return this.#value;
+    }
+    /**
+     * Convert to a JavaScript `number` — **lossy** for values with more than
+     * 15-16 significant digits. Use `toString()` / `toJSON()` for exact output.
+     * Provided for interop with APIs that expect a primitive number.
+     */
+    toNumber() {
+        return Number(this.#value);
+    }
+    /**
+     * Format the value as a localized string via `Intl.NumberFormat`.
+     *
+     * Unlike `toNumber()`, this path is **exact** — we route through the
+     * string-accepting overload of `Intl.NumberFormat.format` (ECMA-402
+     * stage-4, supported by every V8 since Node 20). A `Decimal` of
+     * `'9999999999999999.99'` formats correctly instead of rounding to
+     * `10000000000000000`, which is the whole reason Atom exists.
+     *
+     * For pure integers without a decimal point, we hand the value to
+     * `format` as a BigInt (which has been in the type system since ES2020).
+     * For fractional values, we use the runtime's string support via a
+     * typed extension interface — no `any` escape hatch.
+     */
+    toLocale(localesOrRosetta, options) {
+        if (isRosettaLike(localesOrRosetta)) {
+            return localesOrRosetta.formatNumberString(this.#value, options);
+        }
+        const formatter = new Intl.NumberFormat(localesOrRosetta, options);
+        if (this.isInteger()) {
+            return formatter.format(BigInt(this.#value));
+        }
+        return formatter.format(this.#value);
+    }
+}
+function normalizeInput(value) {
+    if (value instanceof Decimal) {
+        return value.toString();
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error(`Invalid decimal: ${value}`);
+        }
+        return normalizeDecimalString(String(value));
+    }
+    return normalizeDecimalString(value);
+}
+function normalizeDecimalString(input) {
+    const parsed = parseDecimal(input);
+    return formatDecimal(parsed.int, parsed.scale);
+}
+function parseIntegerInput(value) {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isInteger(value)) {
+            throw new Error(`Invalid integer: ${value}`);
+        }
+        return BigInt(value);
+    }
+    const s = value.trim();
+    if (!/^[+-]?\d+$/.test(s)) {
+        throw new Error(`Invalid integer: ${value}`);
+    }
+    return BigInt(s);
+}
+function fromIntScale(int, scale) {
+    return new Decimal(formatDecimal(int, scale));
+}
+function assertScale(scale) {
+    if (!Number.isInteger(scale) || scale < 0) {
+        throw new Error(`Invalid scale: ${scale}`);
+    }
+}
+function roundIntScale(int, sourceScale, targetScale, mode) {
+    if (targetScale >= sourceScale) {
+        return int * pow10BigInt(targetScale - sourceScale);
+    }
+    const drop = sourceScale - targetScale;
+    const factor = pow10BigInt(drop);
+    const q = int / factor;
+    const r = int % factor;
+    if (r === 0n)
+        return q;
+    const absR = r < 0n ? -r : r;
+    const sign = int < 0n ? -1n : 1n;
+    switch (mode) {
+        case "trunc":
+            return q;
+        case "floor":
+            return int < 0n ? q - 1n : q;
+        case "ceil":
+            return int > 0n ? q + 1n : q;
+        case "half-up":
+            return absR * 2n >= factor ? q + sign : q;
+        case "half-even": {
+            const twice = absR * 2n;
+            if (twice < factor)
+                return q;
+            if (twice > factor)
+                return q + sign;
+            const isEven = (q < 0n ? -q : q) % 2n === 0n;
+            return isEven ? q : q + sign;
+        }
+        default:
+            // Defensive guard — the TypeScript type system already restricts `mode`
+            // to the `RoundMode` union, so this branch is unreachable under normal
+            // usage. We throw instead of silently returning the truncated result
+            // because a silent fallback would hide a bug: an upstream cast past the
+            // type system (`as RoundMode`) would lose precision without any signal.
+            throw new Error(`Unknown rounding mode: ${String(mode)}`);
+    }
+}
+function isRosettaLike(arg) {
+    return (typeof arg === "object" &&
+        arg !== null &&
+        "getNumberFormatData" in arg &&
+        typeof arg.getNumberFormatData === "function" &&
+        "formatNumberString" in arg &&
+        typeof arg.formatNumberString === "function");
+}
+function normalizeViaRosetta(input, rosetta) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error("Invalid localized decimal: empty string");
+    }
+    const raw = rosetta.getNumberFormatData();
+    // Guard: a malformed `RosettaLike` returning empty separators
+    // would produce regexes matching every position. Fall back to
+    // ASCII defaults rather than corrupting the input.
+    const data = {
+        decimal: raw.decimal || ".",
+        group: raw.group || ",",
+        minus: raw.minus || "-",
+        plusSign: raw.plusSign || "+",
+    };
+    let normalized = trimmed.replace(/\s| | /g, "");
+    normalized = normalized.replace(new RegExp(escapeRegExp(data.group), "g"), "");
+    normalized = normalized.replace(new RegExp(escapeRegExp(data.decimal), "g"), ".");
+    if (data.minus !== "-") {
+        normalized = normalized.replace(new RegExp(escapeRegExp(data.minus), "g"), "-");
+    }
+    normalized = normalized.replace(/[−﹣－]/g, "-");
+    // Substitute the locale's plus sign (e.g., U+FF0B `＋`,
+    // U+FB29 `﬩`) to ASCII so the strict validator accepts it.
+    if (data.plusSign !== "+") {
+        normalized = normalized.replace(new RegExp(escapeRegExp(data.plusSign), "g"), "+");
+    }
+    if (/^\(.*\)$/.test(normalized)) {
+        normalized = `-${normalized.slice(1, -1)}`;
+    }
+    if (!/^[+-]?\d+(\.\d+)?$/.test(normalized)) {
+        throw new Error(`Invalid localized decimal: ${input}`);
+    }
+    return normalized;
+}
+function normalizeLocaleNumber(input, locales) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        throw new Error("Invalid localized decimal: empty string");
+    }
+    const formatter = new Intl.NumberFormat(locales);
+    const parts = formatter.formatToParts(-12345.6);
+    const group = parts.find((part) => part.type === "group")?.value ?? ",";
+    const decimal = parts.find((part) => part.type === "decimal")?.value ?? ".";
+    const minus = parts.find((part) => part.type === "minusSign")?.value ?? "-";
+    let normalized = trimmed.replace(/\s|\u00A0|\u202F/g, "");
+    normalized = normalized.replace(new RegExp(escapeRegExp(group), "g"), "");
+    normalized = normalized.replace(new RegExp(escapeRegExp(decimal), "g"), ".");
+    if (minus !== "-") {
+        normalized = normalized.replace(new RegExp(escapeRegExp(minus), "g"), "-");
+    }
+    normalized = normalized.replace(/[−﹣－]/g, "-");
+    if (/^\(.*\)$/.test(normalized)) {
+        normalized = `-${normalized.slice(1, -1)}`;
+    }
+    if (!/^[+-]?\d+(\.\d+)?$/.test(normalized)) {
+        throw new Error(`Invalid localized decimal: ${input}`);
+    }
+    return normalized;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=Decimal.js.map