@eternl/formats 0.9.14 → 0.9.16

package/dist/index.cjs

@@ -0,0 +1,810 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let big_js = require("big.js");
+big_js = __toESM(big_js);
+
+//#region src/types.ts
+const NUMBER_STYLES = {
+	decimal: "decimal",
+	currency: "currency",
+	percent: "percent"
+};
+const SIGN_DISPLAYS = {
+	auto: "auto",
+	always: "always",
+	exceptZero: "exceptZero",
+	never: "never",
+	negative: "negative"
+};
+const COMPACT_UNITS = [
+	"K",
+	"M",
+	"B",
+	"T"
+];
+
+//#endregion
+//#region src/constants.ts
+const STYLE_DECIMAL = NUMBER_STYLES.decimal;
+const STYLE_CURRENCY = NUMBER_STYLES.currency;
+const STYLE_PERCENT = NUMBER_STYLES.percent;
+const DEFAULT_LOCALE = "en-US";
+const DISPLAY_SIGNS = {
+	minus: "minus",
+	plus: "plus",
+	none: "none"
+};
+const DISPLAY_SIGN_MINUS = DISPLAY_SIGNS.minus;
+const DISPLAY_SIGN_PLUS = DISPLAY_SIGNS.plus;
+const DISPLAY_SIGN_NONE = DISPLAY_SIGNS.none;
+const COMPACT_ORDER = [...COMPACT_UNITS].reverse();
+const DEFAULT_SIGN_MINUS = "-";
+const DEFAULT_SIGN_PLUS = "+";
+const DECIMAL_ZERO = "0";
+const DECIMAL_EMPTY = "";
+const DECIMAL_DOT = ".";
+
+//#endregion
+//#region src/errors.ts
+let FormatError = /* @__PURE__ */ function(FormatError) {
+	FormatError["NonNegativeIntegerRequired"] = "nonNegativeIntegerRequired";
+	FormatError["PositiveIntegerRequired"] = "positiveIntegerRequired";
+	FormatError["NumericValueNonFinite"] = "numericValueNonFinite";
+	FormatError["NumericStringEmpty"] = "numericStringEmpty";
+	FormatError["UnsupportedNumericInput"] = "unsupportedNumericInput";
+	FormatError["MaxDecimalsLessThanMinimum"] = "maxDecimalsLessThanMinimum";
+	FormatError["MissingLocale"] = "missingLocale";
+	FormatError["MissingCurrencyCode"] = "missingCurrencyCode";
+	FormatError["DateValueInvalid"] = "dateValueInvalid";
+	FormatError["DateStringEmpty"] = "dateStringEmpty";
+	FormatError["DateNumberNonFinite"] = "dateNumberNonFinite";
+	FormatError["InvalidDateString"] = "invalidDateString";
+	FormatError["UnsupportedDateInput"] = "unsupportedDateInput";
+	return FormatError;
+}({});
+const FORMAT_ERROR_MESSAGES = {
+	[FormatError.NonNegativeIntegerRequired]: "%label% must be a non-negative integer",
+	[FormatError.PositiveIntegerRequired]: "%label% must be a positive integer",
+	[FormatError.NumericValueNonFinite]: "Numeric value must be a finite number",
+	[FormatError.NumericStringEmpty]: "Numeric string cannot be empty",
+	[FormatError.UnsupportedNumericInput]: "Unsupported numeric input type",
+	[FormatError.MaxDecimalsLessThanMinimum]: "maxDecimals cannot be less than minDecimals",
+	[FormatError.MissingLocale]: "Display formatting requires a locale",
+	[FormatError.MissingCurrencyCode]: "Currency formatting requires a currencyCode",
+	[FormatError.DateValueInvalid]: "Invalid date value",
+	[FormatError.DateStringEmpty]: "Date string cannot be empty",
+	[FormatError.DateNumberNonFinite]: "Date number must be finite",
+	[FormatError.InvalidDateString]: "Invalid date string",
+	[FormatError.UnsupportedDateInput]: "Unsupported date input type"
+};
+const applyDetails = (template, details) => {
+	if (!details) return template;
+	return Object.keys(details).reduce((message, key) => message.replace(new RegExp(`%${key}%`, "g"), details[key]), template);
+};
+const getFormatErrorMessage = (code, details) => applyDetails(FORMAT_ERROR_MESSAGES[code], details);
+const toRangeError = (code, details) => new RangeError(getFormatErrorMessage(code, details));
+const toTypeError = (code, details) => new TypeError(getFormatErrorMessage(code, details));
+const toError = (code, details) => new Error(getFormatErrorMessage(code, details));
+
+//#endregion
+//#region src/internal/numeric.ts
+const BIG_ZERO = new big_js.default(0);
+const ROUNDING_MODE_MAP = {
+	roundDown: big_js.default.roundDown,
+	roundHalfUp: big_js.default.roundHalfUp,
+	roundHalfEven: big_js.default.roundHalfEven,
+	roundUp: big_js.default.roundUp
+};
+const assertNonNegativeInteger = (value, label) => {
+	if (value === void 0) return;
+	if (!Number.isInteger(value) || value < 0) throw toRangeError(FormatError.NonNegativeIntegerRequired, { label });
+	return value;
+};
+const assertPositiveInteger = (value, label) => {
+	if (value === void 0) return;
+	if (!Number.isInteger(value) || value <= 0) throw toRangeError(FormatError.PositiveIntegerRequired, { label });
+	return value;
+};
+const isZeroString = (input) => {
+	return /^[-+]?0+(?:\.0+)?$/.test(input);
+};
+const normalizeNumeric = (value, clone = false) => {
+	if (value instanceof big_js.default) return clone ? new big_js.default(value) : value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw toRangeError(FormatError.NumericValueNonFinite);
+		return value === 0 ? BIG_ZERO : new big_js.default(value);
+	}
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed) throw toRangeError(FormatError.NumericStringEmpty);
+		if (isZeroString(trimmed)) return BIG_ZERO;
+		return new big_js.default(trimmed);
+	}
+	throw toTypeError(FormatError.UnsupportedNumericInput);
+};
+const mapRoundingMode = (mode) => {
+	if (!mode) return big_js.default.roundHalfUp;
+	return ROUNDING_MODE_MAP[mode];
+};
+const computeNumericParts = (value, options = {}) => {
+	const minDecimals = assertNonNegativeInteger(options.minDecimals, "minDecimals") ?? 0;
+	const maxDecimals = assertNonNegativeInteger(options.maxDecimals, "maxDecimals");
+	const precision = assertPositiveInteger(options.precision, "precision");
+	const roundingMode = mapRoundingMode(options.roundingMode);
+	if (maxDecimals !== void 0 && maxDecimals < minDecimals) throw toRangeError(FormatError.MaxDecimalsLessThanMinimum);
+	let bigValue = normalizeNumeric(value);
+	if (precision !== void 0) bigValue = bigValue.prec(precision, roundingMode);
+	if (maxDecimals !== void 0) bigValue = bigValue.round(maxDecimals, roundingMode);
+	const isZero = bigValue.eq(0);
+	const isNegative = !isZero && bigValue.s < 0;
+	let [integerPart, fractionPart = DECIMAL_EMPTY] = bigToDecimalString(bigValue.abs()).split(DECIMAL_DOT);
+	integerPart = integerPart.replace(/^(0+)(\d)/, "$2");
+	if (!integerPart) integerPart = DECIMAL_ZERO;
+	if (!options.trimTrailingZeros && fractionPart.length < minDecimals) fractionPart = fractionPart.padEnd(minDecimals, DECIMAL_ZERO);
+	if (maxDecimals !== void 0 && fractionPart.length > maxDecimals) fractionPart = fractionPart.slice(0, maxDecimals);
+	if (options.trimTrailingZeros) {
+		const minKeep = minDecimals;
+		while (fractionPart.length > minKeep && fractionPart.endsWith(DECIMAL_ZERO)) fractionPart = fractionPart.slice(0, -1);
+	}
+	return {
+		big: bigValue,
+		integer: integerPart,
+		fraction: fractionPart,
+		isNegative,
+		isZero
+	};
+};
+const bigToDecimalString = (value) => {
+	const coefficient = value.c ?? [0];
+	const exponent = value.e ?? 0;
+	const sign = value.s < 0 ? DEFAULT_SIGN_MINUS : DECIMAL_EMPTY;
+	if (coefficient.every((digit) => digit === 0)) return DECIMAL_ZERO;
+	const digits = coefficient.join("");
+	const decimalIndex = exponent + 1;
+	if (decimalIndex <= 0) return `${sign}${DECIMAL_ZERO}${DECIMAL_DOT}${DECIMAL_ZERO.repeat(Math.abs(decimalIndex))}${digits}`.replace(/\.$/, DECIMAL_EMPTY);
+	if (decimalIndex >= digits.length) return `${sign}${digits}${DECIMAL_ZERO.repeat(decimalIndex - digits.length)}`;
+	return `${sign}${digits.slice(0, decimalIndex)}${DECIMAL_DOT}${digits.slice(decimalIndex)}`;
+};
+const applyGrouping = (integer, grouping, enableGrouping) => {
+	if (!enableGrouping || grouping.primary === 0 || integer.length <= grouping.primary) return integer;
+	const groups = [];
+	const primary = grouping.primary;
+	const secondary = grouping.secondary ?? primary;
+	let index = integer.length;
+	let usePrimary = true;
+	while (index > 0) {
+		const size = usePrimary ? primary : secondary;
+		if (size <= 0) {
+			groups.unshift(integer.slice(0, index));
+			break;
+		}
+		const start = Math.max(index - size, 0);
+		groups.unshift(integer.slice(start, index));
+		index = start;
+		if (index <= 0) break;
+		usePrimary = false;
+	}
+	return groups.join(grouping.separator);
+};
+
+//#endregion
+//#region src/internal/locale.ts
+const resolveLocale = (value) => {
+	const candidate = value?.trim();
+	return candidate && candidate.length > 0 ? candidate : DEFAULT_LOCALE;
+};
+
+//#endregion
+//#region src/internal/intl-cache.ts
+const numberFormatCache = /* @__PURE__ */ new Map();
+const numberFormatMetaCache = /* @__PURE__ */ new Map();
+const dateFormatCache = /* @__PURE__ */ new Map();
+const serializeOptions = (options) => {
+	return Object.entries(options).filter(([, value]) => value !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, value]) => {
+		if (value && typeof value === "object" && !Array.isArray(value)) return `${key}:{${serializeOptions(value)}}`;
+		if (Array.isArray(value)) return `${key}:[${value.join("|")}]`;
+		return `${key}:${String(value)}`;
+	}).join(",");
+};
+const buildNumberFormatKey = (locale, options) => `${locale}|${serializeOptions(options)}`;
+const buildDateFormatKey = (locale, options) => `${locale}|${options ? serializeOptions(options) : ""}`;
+const getNumberFormat = (locale, options) => {
+	const key = buildNumberFormatKey(locale, options);
+	const cached = numberFormatCache.get(key);
+	if (cached) return cached;
+	const nf = new Intl.NumberFormat(locale, options);
+	numberFormatCache.set(key, nf);
+	return nf;
+};
+const deriveGrouping = (parts) => {
+	const integerParts = parts.filter((part) => part.type === "integer");
+	if (integerParts.length <= 1) return { primary: 0 };
+	const lengths = integerParts.map((part) => part.value.length);
+	const primary = lengths[lengths.length - 1];
+	const secondary = lengths.length > 1 ? lengths[lengths.length - 2] : void 0;
+	if (secondary === primary) return { primary };
+	return {
+		primary,
+		secondary
+	};
+};
+const analyzePattern = (nf) => {
+	const sampleValue = 1234567.89123456;
+	const positiveParts = nf.formatToParts(sampleValue);
+	const negativeParts = nf.formatToParts(-sampleValue);
+	const plusProbe = nf.formatToParts(1);
+	return {
+		positive: positiveParts,
+		negative: negativeParts,
+		groupSeparator: positiveParts.find((part) => part.type === "group")?.value ?? "",
+		decimalSeparator: positiveParts.find((part) => part.type === "decimal")?.value ?? ".",
+		grouping: deriveGrouping(positiveParts),
+		minusSign: negativeParts.find((part) => part.type === "minusSign")?.value,
+		plusSign: plusProbe.find((part) => part.type === "plusSign")?.value
+	};
+};
+const getNumberFormatPattern = (locale, options) => {
+	const key = buildNumberFormatKey(locale, options);
+	const cached = numberFormatMetaCache.get(key);
+	if (cached) return cached;
+	const pattern = analyzePattern(getNumberFormat(locale, options));
+	numberFormatMetaCache.set(key, pattern);
+	return pattern;
+};
+const getDateFormat = (locale, options) => {
+	const key = buildDateFormatKey(locale, options);
+	const cached = dateFormatCache.get(key);
+	if (cached) return cached;
+	const df = new Intl.DateTimeFormat(locale, options);
+	dateFormatCache.set(key, df);
+	return df;
+};
+
+//#endregion
+//#region src/display.ts
+const defaultCompactThresholds = {
+	K: new big_js.default(1e3),
+	M: new big_js.default(1e6),
+	B: new big_js.default(1e9),
+	T: new big_js.default(0xe8d4a51000)
+};
+const defaultCompactSuffixes = {
+	K: "K",
+	M: "M",
+	B: "B",
+	T: "T"
+};
+const compactThresholdCache = /* @__PURE__ */ new WeakMap();
+const COMPACT_DECIMAL_BUFFER = 12;
+const SUBSCRIPT_DIGITS = [
+	"₀",
+	"₁",
+	"₂",
+	"₃",
+	"₄",
+	"₅",
+	"₆",
+	"₇",
+	"₈",
+	"₉"
+];
+const SUBSCRIPT_TO_DIGIT = SUBSCRIPT_DIGITS.reduce((acc, digit, index) => {
+	acc[digit] = index.toString();
+	return acc;
+}, {});
+const toSubscriptNumber = (value) => value.toString().split("").map((digit) => SUBSCRIPT_DIGITS[digit.charCodeAt(0) - 48]).join("");
+const expandSubscriptDigits = (value) => {
+	let result = "";
+	for (let index = 0; index < value.length; index += 1) {
+		const char = value[index];
+		const mapped = SUBSCRIPT_TO_DIGIT[char];
+		if (mapped === void 0) {
+			result += char;
+			continue;
+		}
+		let subscriptBuffer = mapped;
+		while (index + 1 < value.length) {
+			const nextMapped = SUBSCRIPT_TO_DIGIT[value[index + 1]];
+			if (nextMapped === void 0) break;
+			subscriptBuffer += nextMapped;
+			index += 1;
+		}
+		const zeroCount = Number(subscriptBuffer);
+		if (Number.isNaN(zeroCount) || zeroCount <= 0) continue;
+		result += "0".repeat(zeroCount);
+	}
+	return result;
+};
+const compactFractionLeadingZeros = (fraction) => {
+	const match = /^(0{2,})(.+)$/.exec(fraction);
+	if (!match) return fraction;
+	const [, zeros, remainder] = match;
+	if (!remainder || /^0+$/.test(remainder)) return fraction;
+	const annotation = toSubscriptNumber(zeros.length - 1);
+	return `${zeros[0]}${annotation}${remainder}`;
+};
+const resolveSignKind = (isNegative, isZero, signDisplay, forceSign) => {
+	switch (signDisplay ?? (forceSign ? SIGN_DISPLAYS.always : SIGN_DISPLAYS.auto)) {
+		case SIGN_DISPLAYS.always: return isNegative ? DISPLAY_SIGN_MINUS : DISPLAY_SIGN_PLUS;
+		case SIGN_DISPLAYS.exceptZero: return isNegative ? DISPLAY_SIGN_MINUS : isZero ? DISPLAY_SIGN_NONE : DISPLAY_SIGN_PLUS;
+		case SIGN_DISPLAYS.never: return DISPLAY_SIGN_NONE;
+		case SIGN_DISPLAYS.negative: return isNegative ? DISPLAY_SIGN_MINUS : DISPLAY_SIGN_NONE;
+		case SIGN_DISPLAYS.auto:
+		default: return isNegative ? DISPLAY_SIGN_MINUS : DISPLAY_SIGN_NONE;
+	}
+};
+const resolveCurrencyToken = (template, options) => {
+	const code = options.currencyCode?.toUpperCase() ?? "";
+	if (options.useSymbol === false) return {
+		value: code,
+		fromCustom: false
+	};
+	const custom = code ? options.customSymbols?.[code] : void 0;
+	if (custom) return {
+		value: custom,
+		fromCustom: true
+	};
+	if (template && template !== code) return {
+		value: template,
+		fromCustom: false
+	};
+	return {
+		value: code,
+		fromCustom: false
+	};
+};
+const getNormalizedThreshold = (options, unit) => {
+	const overrides = options.compactThresholds;
+	if (!overrides || overrides[unit] === void 0) return;
+	let cache = compactThresholdCache.get(options);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		compactThresholdCache.set(options, cache);
+	}
+	let normalized = cache.get(unit);
+	if (!normalized) {
+		normalized = normalizeNumeric(overrides[unit], true);
+		cache.set(unit, normalized);
+	}
+	return normalized;
+};
+const resolveCompact = (value, options, enabled) => {
+	if (!enabled) return { value };
+	const abs = value.abs();
+	for (const unit of COMPACT_ORDER) {
+		const threshold = getNormalizedThreshold(options, unit) ?? getDefaultCompactThreshold(unit);
+		if (abs.gte(threshold)) {
+			const suffix = options.compactSuffixes?.[unit] ?? getDefaultCompactSuffix(unit);
+			return {
+				value: threshold.eq(0) ? value : value.div(threshold),
+				suffix
+			};
+		}
+	}
+	return { value };
+};
+const getDefaultCompactThreshold = (unit) => {
+	return defaultCompactThresholds[unit];
+};
+const getDefaultCompactSuffix = (unit) => {
+	return defaultCompactSuffixes[unit];
+};
+const buildNumberFormatOptions = (options, style) => {
+	const nfOptions = {
+		style,
+		useGrouping: options.useGrouping !== false
+	};
+	if (options.signDisplay && options.signDisplay !== SIGN_DISPLAYS.negative) nfOptions.signDisplay = options.signDisplay;
+	else if (!options.signDisplay && options.forceSign) nfOptions.signDisplay = SIGN_DISPLAYS.always;
+	if (options.minDecimals !== void 0) nfOptions.minimumFractionDigits = options.minDecimals;
+	if (options.maxDecimals !== void 0) nfOptions.maximumFractionDigits = options.maxDecimals;
+	if (style === STYLE_CURRENCY && options.currencyCode) {
+		nfOptions.currency = options.currencyCode;
+		nfOptions.currencyDisplay = options.useSymbol === false ? "code" : "symbol";
+	}
+	return nfOptions;
+};
+const formatFromPattern = (options, style, integerPart, fractionPart, sign, pattern, suffix, currencyOverride, currencyOverrideIsCustom) => {
+	const parts = sign === DISPLAY_SIGN_MINUS ? pattern.negative : pattern.positive;
+	const useGrouping = options.useGrouping !== false;
+	const groupedInteger = applyGrouping(integerPart, {
+		separator: pattern.groupSeparator,
+		primary: pattern.grouping.primary,
+		secondary: pattern.grouping.secondary
+	}, useGrouping);
+	const hasFraction = fractionPart.length > 0;
+	let result = "";
+	let integerInjected = false;
+	let currencyMeta;
+	let previousType;
+	let suffixInjected = false;
+	const appendSuffix = () => {
+		if (!suffix || suffixInjected) return;
+		result += suffix;
+		suffixInjected = true;
+	};
+	const stripTrailingWhitespace = () => {
+		if (!result) return;
+		const trimmed = result.replace(/\s+$/gu, "");
+		if (trimmed !== result) result = trimmed;
+	};
+	for (const part of parts) {
+		switch (part.type) {
+			case "integer":
+				if (!integerInjected) {
+					result += groupedInteger;
+					integerInjected = true;
+					if (!hasFraction) appendSuffix();
+				}
+				break;
+			case "group": break;
+			case "decimal":
+				if (hasFraction) result += pattern.decimalSeparator;
+				break;
+			case "fraction":
+				if (hasFraction) {
+					result += fractionPart;
+					appendSuffix();
+				}
+				break;
+			case "minusSign":
+				if (sign === DISPLAY_SIGN_MINUS) result += pattern.minusSign ?? part.value ?? DEFAULT_SIGN_MINUS;
+				break;
+			case "plusSign":
+				if (sign === DISPLAY_SIGN_PLUS) result += pattern.plusSign ?? part.value ?? DEFAULT_SIGN_PLUS;
+				break;
+			case "currency":
+				if (integerInjected) appendSuffix();
+				if (currencyOverride !== void 0) currencyMeta = {
+					value: currencyOverride,
+					fromCustom: currencyOverrideIsCustom ?? false
+				};
+				else currencyMeta = currencyMeta ?? resolveCurrencyToken(part.value, options);
+				result += currencyMeta.value;
+				break;
+			case "percentSign":
+				stripTrailingWhitespace();
+				result += part.value;
+				break;
+			case "literal":
+				if (previousType === "currency" && currencyMeta?.fromCustom && /^\s+$/.test(part.value)) break;
+				result += part.value;
+				break;
+			default:
+				result += part.value;
+				break;
+		}
+		previousType = part.type;
+	}
+	appendSuffix();
+	return result;
+};
+const resolveDisplayStyle = (options, overrideStyle) => {
+	const style = overrideStyle ?? options.style ?? STYLE_DECIMAL;
+	if (style === STYLE_CURRENCY && !options.currencyCode) throw toError(FormatError.MissingCurrencyCode);
+	return style;
+};
+const formatDisplayInternal = (value, options, styleOverride, forceCompact) => {
+	const style = resolveDisplayStyle(options, styleOverride);
+	const base = normalizeNumeric(value);
+	const { value: scaled, suffix } = resolveCompact(style === STYLE_PERCENT ? base.times(100) : base, options, forceCompact ?? options.compact === true);
+	const numericParts = computeNumericParts(scaled, options);
+	const sign = resolveSignKind(numericParts.isNegative, numericParts.isZero, options.signDisplay, options.forceSign);
+	let integerPart = numericParts.integer;
+	let fractionPart = numericParts.fraction;
+	const locale = resolveLocale(options.locale);
+	let pattern;
+	let currencyOverride;
+	let currencyOverrideIsCustom = false;
+	if (options.compactDecimalZeros && !options.isHidden) {
+		const baseMatch = /^(0{2,})(.+)$/.exec(fractionPart);
+		const baseRemainder = baseMatch?.[2];
+		if (baseMatch && baseRemainder && !/^0+$/.test(baseRemainder)) fractionPart = compactFractionLeadingZeros(fractionPart);
+		else {
+			const extendedMax = options.maxDecimals !== void 0 ? options.maxDecimals + COMPACT_DECIMAL_BUFFER : void 0;
+			const extendedParts = computeNumericParts(scaled, {
+				...options,
+				maxDecimals: extendedMax,
+				trimTrailingZeros: false
+			});
+			const extendedFraction = extendedParts.fraction;
+			const match = /^(0{2,})(.+)$/.exec(extendedFraction);
+			if (match) {
+				const zerosPortion = match[1];
+				let remainder = match[2];
+				if (!/^0+$/.test(remainder)) {
+					const targetMax = options.maxDecimals;
+					const targetMin = options.minDecimals ?? 0;
+					if (targetMax === 0) fractionPart = "";
+					else {
+						let digits = zerosPortion;
+						const remainderNeeded = targetMax !== void 0 ? Math.max(targetMax - 1, 0) : remainder.length;
+						if (remainderNeeded > 0) {
+							if (remainder.length < remainderNeeded) remainder = remainder.padEnd(remainderNeeded, "0");
+							digits += remainder.slice(0, remainderNeeded);
+						}
+						if (targetMax === void 0 && digits.length < targetMin) {
+							const extraNeeded = targetMin - digits.length;
+							let extraSource = remainder.slice(remainderNeeded);
+							if (extraSource.length < extraNeeded) extraSource = extraSource.padEnd(extraNeeded, "0");
+							digits += extraSource.slice(0, extraNeeded);
+						}
+						if (targetMax !== void 0 && digits.length < targetMin) digits = digits.padEnd(targetMin, "0");
+						if (options.trimTrailingZeros) {
+							const minKeep = Math.max(targetMin, zerosPortion ? 1 : 0);
+							while (digits.length > Math.max(minKeep, zerosPortion.length) && digits.endsWith("0")) digits = digits.slice(0, -1);
+						}
+						fractionPart = compactFractionLeadingZeros(digits);
+						integerPart = extendedParts.integer;
+					}
+				}
+			}
+		}
+	}
+	if (options.isHidden) {
+		const maskChar = options.hiddenCharacter && options.hiddenCharacter.length > 0 ? options.hiddenCharacter[0] : "*";
+		integerPart = maskChar;
+		fractionPart = fractionPart.length > 0 ? maskChar.repeat(fractionPart.length) : fractionPart;
+	}
+	try {
+		pattern = getNumberFormatPattern(locale, buildNumberFormatOptions(options, style));
+	} catch (error) {
+		if (!(error instanceof RangeError) || style !== STYLE_CURRENCY || !options.currencyCode) throw error;
+		pattern = getNumberFormatPattern(locale, buildNumberFormatOptions({
+			...options,
+			currencyCode: "USD"
+		}, STYLE_CURRENCY));
+		const rawCode = options.currencyCode;
+		const code = rawCode.toUpperCase();
+		if (options.useSymbol === false) currencyOverride = rawCode;
+		else {
+			const customSymbol = options.customSymbols?.[code] ?? options.customSymbols?.[rawCode];
+			if (customSymbol) {
+				currencyOverride = customSymbol;
+				currencyOverrideIsCustom = true;
+			} else currencyOverride = rawCode;
+		}
+	}
+	return formatFromPattern(options, style, integerPart, fractionPart, sign, pattern, suffix, currencyOverride, currencyOverrideIsCustom);
+};
+const formatDisplayNumber = (value, options) => formatDisplayInternal(value, options);
+const formatDisplayCurrency = (value, options) => formatDisplayInternal(value, options, STYLE_CURRENCY);
+const formatDisplayPercent = (value, options) => formatDisplayInternal(value, options, STYLE_PERCENT);
+const formatDisplayCompact = (value, options) => formatDisplayInternal(value, options, void 0, true);
+const stripGroupSeparators = (value, separator) => {
+	if (!separator) return value;
+	return value.split(separator).join("");
+};
+const normalizeNumericCore = (core, pattern) => {
+	let normalized = expandSubscriptDigits(core);
+	if (pattern.groupSeparator) normalized = stripGroupSeparators(normalized, pattern.groupSeparator);
+	normalized = normalized.replace(/\s+/gu, "");
+	if (pattern.decimalSeparator && pattern.decimalSeparator !== ".") normalized = normalized.replace(pattern.decimalSeparator, ".");
+	if (pattern.minusSign && pattern.minusSign !== DEFAULT_SIGN_MINUS) normalized = normalized.split(pattern.minusSign).join(DEFAULT_SIGN_MINUS);
+	if (pattern.plusSign && pattern.plusSign !== DEFAULT_SIGN_PLUS) normalized = normalized.split(pattern.plusSign).join(DEFAULT_SIGN_PLUS);
+	return normalized;
+};
+const parseDisplayInternal = (formatted, options) => {
+	const numericCore = extractNumberCore(formatted);
+	if (!numericCore) return NaN;
+	const locale = options?.locale;
+	if (locale) {
+		const normalizedCore = normalizeNumericCore(numericCore, getNumberFormatPattern(resolveLocale(locale), buildNumberFormatOptions(options ?? {}, STYLE_DECIMAL)));
+		if (!normalizedCore || normalizedCore === DEFAULT_SIGN_MINUS || normalizedCore === DEFAULT_SIGN_PLUS) return NaN;
+		try {
+			return (0, big_js.default)(normalizedCore).toNumber();
+		} catch (error) {}
+	}
+	let normalized = expandSubscriptDigits(numericCore);
+	normalized = normalized.replace(/['’`_\s\u00A0]/gu, "");
+	const lastDot = normalized.lastIndexOf(".");
+	const lastComma = normalized.lastIndexOf(",");
+	if (lastDot !== -1 || lastComma !== -1) {
+		let decimalIndex = Math.max(lastDot, lastComma);
+		let decimalChar = decimalIndex === lastDot ? "." : ",";
+		if (lastDot !== -1 && lastComma !== -1) {
+			decimalChar = decimalIndex === lastDot ? "." : ",";
+			const thousandsChar = decimalChar === "." ? "," : ".";
+			normalized = normalized.split(thousandsChar).join("");
+		} else if (lastComma !== -1) if (normalized.slice(lastComma + 1).length === 3 && normalized.slice(0, lastComma).replace(/[^0-9]/g, "").length > 3) {
+			normalized = normalized.replace(/,/g, "");
+			decimalChar = ".";
+		} else decimalChar = ",";
+		else if (lastDot !== -1) if (normalized.slice(lastDot + 1).length === 3 && normalized.slice(0, lastDot).replace(/[^0-9]/g, "").length > 3) {
+			decimalChar = ",";
+			normalized = normalized.replace(/\./g, "");
+		} else decimalChar = ".";
+		if (decimalChar !== ".") normalized = normalized.split(decimalChar).join(".");
+	}
+	normalized = normalized.replace(/,/g, "");
+	if (!normalized || normalized === DEFAULT_SIGN_MINUS || normalized === DEFAULT_SIGN_PLUS) return NaN;
+	try {
+		return (0, big_js.default)(normalized).toNumber();
+	} catch (error) {
+		return NaN;
+	}
+};
+const parseDisplayValue = (formatted, options) => parseDisplayInternal(formatted, options);
+const NUMERIC_OR_SUBSCRIPT = /[0-9₀-₉]/;
+const MINUS_SIGNS = new Set([
+	"-",
+	"−",
+	"﹣",
+	"－"
+]);
+const isWhitespace = (char) => /\s/.test(char);
+const extractNumberCore = (formatted) => {
+	let startIndex = -1;
+	let endIndex = -1;
+	for (let i = 0; i < formatted.length; i += 1) if (NUMERIC_OR_SUBSCRIPT.test(formatted[i])) {
+		startIndex = i;
+		break;
+	}
+	if (startIndex === -1) return "";
+	for (let i = formatted.length - 1; i >= startIndex; i -= 1) if (NUMERIC_OR_SUBSCRIPT.test(formatted[i])) {
+		endIndex = i;
+		break;
+	}
+	if (endIndex === -1) return "";
+	let signPrefix = "";
+	for (let idx = startIndex - 1; idx >= 0; idx -= 1) {
+		const candidate = formatted[idx];
+		if (isWhitespace(candidate)) continue;
+		if (MINUS_SIGNS.has(candidate)) {
+			signPrefix = candidate;
+			break;
+		}
+		if (NUMERIC_OR_SUBSCRIPT.test(candidate)) break;
+	}
+	if (!signPrefix) for (let idx = endIndex + 1; idx < formatted.length; idx += 1) {
+		const candidate = formatted[idx];
+		if (isWhitespace(candidate)) continue;
+		if (MINUS_SIGNS.has(candidate)) {
+			signPrefix = candidate;
+			break;
+		}
+		if (NUMERIC_OR_SUBSCRIPT.test(candidate)) break;
+	}
+	return `${signPrefix}${formatted.slice(startIndex, endIndex + 1)}`;
+};
+
+//#endregion
+//#region src/date.ts
+const toDate = (value) => {
+	if (value instanceof Date) {
+		const timestamp = value.getTime();
+		if (Number.isNaN(timestamp)) throw toRangeError(FormatError.DateValueInvalid);
+		return new Date(timestamp);
+	}
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw toRangeError(FormatError.DateNumberNonFinite);
+		const date = new Date(value);
+		if (Number.isNaN(date.getTime())) throw toRangeError(FormatError.DateValueInvalid);
+		return date;
+	}
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed) throw toRangeError(FormatError.DateStringEmpty);
+		const date = new Date(trimmed);
+		if (Number.isNaN(date.getTime())) throw toRangeError(FormatError.InvalidDateString);
+		return date;
+	}
+	throw toTypeError(FormatError.UnsupportedDateInput);
+};
+const formatDisplayDate = (date, locale, options) => {
+	const resolvedLocale = resolveLocale(locale);
+	const parsed = toDate(date);
+	return getDateFormat(resolvedLocale, options).format(parsed);
+};
+const formatCsvDate = (date, options) => {
+	const parsed = toDate(date);
+	if ((options?.format ?? "iso") === "utc-datetime") return `${parsed.getUTCFullYear()}-${String(parsed.getUTCMonth() + 1).padStart(2, "0")}-${String(parsed.getUTCDate()).padStart(2, "0")} ${String(parsed.getUTCHours()).padStart(2, "0")}:${String(parsed.getUTCMinutes()).padStart(2, "0")}:${String(parsed.getUTCSeconds()).padStart(2, "0")}`;
+	const iso = parsed.toISOString();
+	const datePart = iso.slice(0, 10);
+	if (!(parsed.getUTCHours() !== 0 || parsed.getUTCMinutes() !== 0 || parsed.getUTCSeconds() !== 0 || parsed.getUTCMilliseconds() !== 0)) return datePart;
+	return `${datePart}T${iso.slice(11).replace(/\.\d+Z$/, "Z")}`;
+};
+
+//#endregion
+//#region src/csv.ts
+const resolveDecimalDelimiter = (options) => {
+	if (options.decimalDelimiter !== void 0) return options.decimalDelimiter;
+	if (options.locale) return getNumberFormatPattern(resolveLocale(options.locale), { style: STYLE_DECIMAL }).decimalSeparator;
+	return DECIMAL_DOT;
+};
+const stringifyNumericParts = (parts, decimalDelimiter = DECIMAL_DOT) => {
+	const fraction = parts.fraction.length > 0 ? `${decimalDelimiter}${parts.fraction}` : DECIMAL_EMPTY;
+	const integer = parts.integer || DECIMAL_ZERO;
+	return `${parts.isNegative ? DEFAULT_SIGN_MINUS : DECIMAL_EMPTY}${integer}${fraction}`;
+};
+const formatCsvNumber = (value, options = {}) => {
+	return stringifyNumericParts(computeNumericParts(value, options), resolveDecimalDelimiter(options));
+};
+const formatCsvPercent = (value, options = {}) => {
+	return stringifyNumericParts(computeNumericParts(normalizeNumeric(value).times(100), options), resolveDecimalDelimiter(options));
+};
+const csvCurrencyCode = (code, customSymbols, useSymbol) => {
+	const trimmed = code.trim();
+	if (!trimmed) return DECIMAL_EMPTY;
+	const normalized = trimmed.toUpperCase();
+	if (useSymbol) {
+		const symbol = customSymbols?.[normalized];
+		if (symbol) return symbol;
+	}
+	return normalized;
+};
+const escapeCsvField = (value, delimiter) => {
+	if (!(value.includes(delimiter) || value.includes("\n") || value.includes("\r") || value.includes("\""))) return value;
+	return `"${value.replace(/"/g, "\"\"")}"`;
+};
+const defaultFormatter = (value) => {
+	if (value === null || value === void 0) return DECIMAL_EMPTY;
+	if (value instanceof Date) return formatCsvDate(value);
+	if (typeof value === "number") return formatCsvNumber(value);
+	if (typeof value === "string") return value;
+	if (typeof value === "boolean") return value ? "true" : "false";
+	return String(value);
+};
+const buildCsv = (rows, columns, delimiter = ",", lineEnding = "\n") => {
+	const lines = [columns.map((col) => escapeCsvField(col.header, delimiter)).join(delimiter)];
+	for (const row of rows) {
+		const fields = columns.map((col) => {
+			const raw = col.accessor(row);
+			return escapeCsvField((col.formatter ? col.formatter(raw) : defaultFormatter(raw)) ?? DECIMAL_EMPTY, delimiter);
+		});
+		lines.push(fields.join(delimiter));
+	}
+	return `${lines.join(lineEnding)}${lineEnding}`;
+};
+
+//#endregion
+exports.DECIMAL_DOT = DECIMAL_DOT;
+exports.DECIMAL_EMPTY = DECIMAL_EMPTY;
+exports.DECIMAL_ZERO = DECIMAL_ZERO;
+exports.DEFAULT_SIGN_MINUS = DEFAULT_SIGN_MINUS;
+exports.DEFAULT_SIGN_PLUS = DEFAULT_SIGN_PLUS;
+exports.DISPLAY_SIGNS = DISPLAY_SIGNS;
+exports.FormatError = FormatError;
+exports.buildCsv = buildCsv;
+exports.csvCurrencyCode = csvCurrencyCode;
+exports.extractNumberCore = extractNumberCore;
+exports.formatCsvDate = formatCsvDate;
+exports.formatCsvNumber = formatCsvNumber;
+exports.formatCsvPercent = formatCsvPercent;
+exports.formatDisplayCompact = formatDisplayCompact;
+exports.formatDisplayCurrency = formatDisplayCurrency;
+exports.formatDisplayDate = formatDisplayDate;
+exports.formatDisplayNumber = formatDisplayNumber;
+exports.formatDisplayPercent = formatDisplayPercent;
+exports.getFormatErrorMessage = getFormatErrorMessage;
+exports.parseDisplayValue = parseDisplayValue;
+exports.toError = toError;
+exports.toRangeError = toRangeError;
+exports.toTypeError = toTypeError;
+//# sourceMappingURL=index.cjs.map