@canutin/svelte-currency-input 0.12.0 → 1.0.0-next.7

package/dist/currency-input.svelte

@@ -0,0 +1,361 @@
+<script lang="ts">
+	import type { HTMLInputAttributes } from 'svelte/elements';
+	import type {
+		IntlConfig,
+		CurrencyInputValues,
+		CleanValueOptions,
+		FormatValueOptions
+	} from './types';
+	import {
+		isNumber,
+		cleanValue,
+		fixedDecimalValue,
+		formatValue,
+		getLocaleConfig,
+		padTrimValue,
+		getSuffix,
+		repositionCursor
+	} from './utils/index';
+
+	type Props = Omit<HTMLInputAttributes, 'value'> & {
+		value?: string;
+		intlConfig?: IntlConfig;
+		prefix?: string;
+		suffix?: string;
+		decimalSeparator?: string;
+		groupSeparator?: string;
+		allowDecimals?: boolean;
+		decimalsLimit?: number;
+		decimalScale?: number;
+		fixedDecimalLength?: number;
+		allowNegativeValue?: boolean;
+		min?: number;
+		max?: number;
+		maxLength?: number;
+		step?: number;
+		disableGroupSeparators?: boolean;
+		disableAbbreviations?: boolean;
+		formatValueOnBlur?: boolean;
+		transformRawValue?: (rawValue: string) => string;
+		oninputvalue?: (values: CurrencyInputValues) => void;
+		onchangevalue?: (values: CurrencyInputValues) => void;
+		ref?: HTMLInputElement | null;
+	};
+
+	let {
+		value = $bindable(''),
+		intlConfig,
+		prefix: userPrefix,
+		suffix: userSuffix,
+		decimalSeparator: _decimalSeparator,
+		groupSeparator: _groupSeparator,
+		allowDecimals = true,
+		decimalsLimit,
+		decimalScale,
+		fixedDecimalLength,
+		allowNegativeValue = true,
+		min,
+		max,
+		maxLength: userMaxLength,
+		step,
+		disableGroupSeparators = false,
+		disableAbbreviations = false,
+		formatValueOnBlur = true,
+		transformRawValue,
+		oninputvalue,
+		onchangevalue,
+		ref = $bindable(null),
+		...restProps
+	}: Props = $props();
+
+	$effect(() => {
+		if (_decimalSeparator && isNumber(_decimalSeparator)) {
+			throw new Error('decimalSeparator cannot be a number');
+		}
+
+		if (_groupSeparator && isNumber(_groupSeparator)) {
+			throw new Error('groupSeparator cannot be a number');
+		}
+	});
+
+	let localeConfig = $derived(getLocaleConfig(intlConfig));
+	let decimalSeparator = $derived(_decimalSeparator || localeConfig.decimalSeparator || '');
+	let groupSeparator = $derived(_groupSeparator || localeConfig.groupSeparator || '');
+	let prefix = $derived(userPrefix ?? localeConfig.prefix);
+	let suffix = $derived(userSuffix ?? '');
+
+	$effect(() => {
+		if (
+			decimalSeparator &&
+			groupSeparator &&
+			decimalSeparator === groupSeparator &&
+			disableGroupSeparators === false
+		) {
+			throw new Error('decimalSeparator cannot be the same as groupSeparator');
+		}
+	});
+
+	let formatValueOptions = $derived<Partial<FormatValueOptions>>({
+		decimalSeparator,
+		groupSeparator,
+		disableGroupSeparators,
+		intlConfig,
+		prefix,
+		suffix
+	});
+
+	let cleanValueOptions = $derived<Partial<CleanValueOptions>>({
+		decimalSeparator,
+		groupSeparator,
+		allowDecimals,
+		decimalsLimit: decimalsLimit ?? fixedDecimalLength ?? 2,
+		allowNegativeValue,
+		disableAbbreviations,
+		prefix,
+		transformRawValue
+	});
+
+	let stateValue = $state('');
+	let dirty = $state(false);
+	let cursor = $state(0);
+	let changeCount = $state(0);
+	let lastKeyStroke = $state<string | null>(null);
+
+	$effect(() => {
+		if (stateValue === '-' || (decimalSeparator && stateValue === decimalSeparator)) {
+			return;
+		}
+		if (value !== undefined && value !== null && value !== '') {
+			const formatted = formatValue({
+				...formatValueOptions,
+				decimalScale: dirty ? undefined : decimalScale,
+				value: String(value)
+			});
+			if (!dirty) {
+				stateValue = formatted;
+			}
+		} else if (!dirty) {
+			stateValue = '';
+		}
+	});
+
+	$effect(() => {
+		if (dirty && stateValue !== '-' && ref && document.activeElement === ref) {
+			ref.setSelectionRange(cursor, cursor);
+		}
+	});
+
+	function processChange(inputValue: string, selectionStart?: number | null): void {
+		dirty = true;
+
+		const { modifiedValue, cursorPosition } = repositionCursor({
+			selectionStart,
+			value: inputValue,
+			lastKeyStroke,
+			stateValue,
+			groupSeparator
+		});
+
+		const stringValue = cleanValue({ value: modifiedValue, ...cleanValueOptions });
+
+		if (userMaxLength && stringValue.replace(/-/g, '').length > userMaxLength) {
+			if (ref) {
+				ref.value = stateValue;
+				const cursorPos = Math.min(selectionStart ?? 0, stateValue.length);
+				ref.setSelectionRange(cursorPos, cursorPos);
+			}
+			return;
+		}
+
+		if (stringValue === '' || stringValue === '-' || stringValue === decimalSeparator) {
+			value = '';
+			stateValue = stringValue;
+			cursor = 1;
+
+			if (ref) {
+				ref.value = stringValue;
+				ref.setSelectionRange(cursor, cursor);
+			}
+
+			const values: CurrencyInputValues = { float: null, formatted: '', value: '' };
+			oninputvalue?.(values);
+			return;
+		}
+
+		const stringValueWithoutSeparator = decimalSeparator
+			? stringValue.replace(decimalSeparator, '.')
+			: stringValue;
+
+		const numberValue = parseFloat(stringValueWithoutSeparator);
+
+		const formattedValue = formatValue({
+			value: stringValue,
+			...formatValueOptions
+		});
+
+		let newCursor = cursorPosition ?? formattedValue.length;
+		if (cursorPosition != null) {
+			newCursor = cursorPosition + (formattedValue.length - inputValue.length);
+			newCursor = newCursor <= 0 ? (prefix ? prefix.length : 0) : newCursor;
+		}
+
+		cursor = newCursor;
+		changeCount = changeCount + 1;
+		stateValue = formattedValue;
+		value = stringValue;
+
+		if (ref) {
+			ref.value = formattedValue;
+			ref.setSelectionRange(cursor, cursor);
+		}
+
+		const values: CurrencyInputValues = {
+			float: numberValue,
+			formatted: formattedValue,
+			value: stringValue
+		};
+		oninputvalue?.(values);
+	}
+
+	function handleInput(event: Event): void {
+		const target = event.target as HTMLInputElement;
+		const { value: inputValue, selectionStart } = target;
+
+		processChange(inputValue, selectionStart);
+	}
+
+	function handleBlur(event: FocusEvent): void {
+		const target = event.target as HTMLInputElement;
+		const { value: inputValue } = target;
+
+		const valueOnly = cleanValue({ value: inputValue, ...cleanValueOptions });
+
+		if (valueOnly === '-' || valueOnly === decimalSeparator || !valueOnly) {
+			stateValue = '';
+			value = '';
+			dirty = false;
+			return;
+		}
+
+		const fixedDecimals = fixedDecimalValue(valueOnly, decimalSeparator, fixedDecimalLength);
+
+		const newValue = padTrimValue(
+			fixedDecimals,
+			decimalSeparator,
+			decimalScale !== undefined ? decimalScale : fixedDecimalLength
+		);
+
+		const stringValueWithoutSeparator = decimalSeparator
+			? newValue.replace(decimalSeparator, '.')
+			: newValue;
+
+		const numberValue = parseFloat(stringValueWithoutSeparator);
+
+		const formattedValue = formatValue({
+			...formatValueOptions,
+			value: newValue
+		});
+
+		if (formatValueOnBlur) {
+			stateValue = formattedValue;
+			value = newValue;
+
+			const values: CurrencyInputValues = {
+				float: numberValue,
+				formatted: formattedValue,
+				value: newValue
+			};
+			onchangevalue?.(values);
+		}
+
+		dirty = false;
+	}
+
+	function handleKeyDown(event: KeyboardEvent): void {
+		const { key } = event;
+
+		lastKeyStroke = key;
+
+		if (step && (key === 'ArrowUp' || key === 'ArrowDown')) {
+			event.preventDefault();
+			cursor = stateValue.length;
+
+			const stringValueWithoutSeparator =
+				decimalSeparator && value ? value.replace(decimalSeparator, '.') : value;
+
+			const currentValue =
+				parseFloat(
+					stringValueWithoutSeparator != null && stringValueWithoutSeparator !== ''
+						? stringValueWithoutSeparator
+						: cleanValue({ value: stateValue, ...cleanValueOptions })
+				) || 0;
+			const newValue = key === 'ArrowUp' ? currentValue + step : currentValue - step;
+
+			if ((min !== undefined && newValue < min) || (!allowNegativeValue && newValue < 0)) {
+				return;
+			}
+
+			if (max !== undefined && newValue > max) {
+				return;
+			}
+
+			const fixedLength = String(step).includes('.')
+				? Number(String(step).split('.')[1].length)
+				: undefined;
+
+			processChange(
+				String(fixedLength ? newValue.toFixed(fixedLength) : newValue).replace(
+					'.',
+					decimalSeparator
+				)
+			);
+		}
+	}
+
+	function handleKeyUp(event: KeyboardEvent): void {
+		const { key } = event;
+		const target = event.currentTarget as HTMLInputElement;
+		const { selectionStart } = target;
+
+		if (key !== 'ArrowUp' && key !== 'ArrowDown' && stateValue !== '-') {
+			const suffixValue = getSuffix(stateValue, { groupSeparator, decimalSeparator });
+
+			if (
+				suffixValue &&
+				selectionStart &&
+				selectionStart > stateValue.length - suffixValue.length
+			) {
+				if (ref) {
+					const newCursor = stateValue.length - suffixValue.length;
+					ref.setSelectionRange(newCursor, newCursor);
+				}
+			}
+		}
+	}
+
+	let displayValue = $derived.by(() => {
+		if (stateValue === '-' || stateValue === decimalSeparator) {
+			return stateValue;
+		}
+		if (value !== undefined && value !== null && value !== '') {
+			return formatValue({
+				...formatValueOptions,
+				decimalScale: dirty ? undefined : decimalScale,
+				value: String(value)
+			});
+		}
+		return stateValue;
+	});
+</script>
+
+<input
+	bind:this={ref}
+	type="text"
+	inputmode="decimal"
+	value={displayValue}
+	oninput={handleInput}
+	onblur={handleBlur}
+	onkeydown={handleKeyDown}
+	onkeyup={handleKeyUp}
+	{...restProps}
+/>

package/dist/currency-input.svelte.d.ts

@@ -0,0 +1,29 @@
+import type { HTMLInputAttributes } from 'svelte/elements';
+import type { IntlConfig, CurrencyInputValues } from './types';
+type Props = Omit<HTMLInputAttributes, 'value'> & {
+    value?: string;
+    intlConfig?: IntlConfig;
+    prefix?: string;
+    suffix?: string;
+    decimalSeparator?: string;
+    groupSeparator?: string;
+    allowDecimals?: boolean;
+    decimalsLimit?: number;
+    decimalScale?: number;
+    fixedDecimalLength?: number;
+    allowNegativeValue?: boolean;
+    min?: number;
+    max?: number;
+    maxLength?: number;
+    step?: number;
+    disableGroupSeparators?: boolean;
+    disableAbbreviations?: boolean;
+    formatValueOnBlur?: boolean;
+    transformRawValue?: (rawValue: string) => string;
+    oninputvalue?: (values: CurrencyInputValues) => void;
+    onchangevalue?: (values: CurrencyInputValues) => void;
+    ref?: HTMLInputElement | null;
+};
+declare const CurrencyInput: import("svelte").Component<Props, {}, "value" | "ref">;
+type CurrencyInput = ReturnType<typeof CurrencyInput>;
+export default CurrencyInput;

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-import CurrencyInput from './CurrencyInput.svelte';
-export default CurrencyInput;
+export { default as CurrencyInput } from './currency-input.svelte';
+export type { IntlConfig, CurrencyInputValues, LocaleConfig, FormatValueOptions, CleanValueOptions } from './types';
+export { addSeparators, cleanValue, escapeRegExp, fixedDecimalValue, formatValue, getLocaleConfig, getSuffix, isNumber, padTrimValue, parseAbbrValue, abbrValue, removeInvalidChars, removeSeparators, repositionCursor } from './utils/index';

package/dist/index.js

@@ -1,2 +1,4 @@
-import CurrencyInput from './CurrencyInput.svelte';
-export default CurrencyInput;
+// Component
+export { default as CurrencyInput } from './currency-input.svelte';
+// Utilities
+export { addSeparators, cleanValue, escapeRegExp, fixedDecimalValue, formatValue, getLocaleConfig, getSuffix, isNumber, padTrimValue, parseAbbrValue, abbrValue, removeInvalidChars, removeSeparators, repositionCursor } from './utils/index';

package/dist/types.d.ts

@@ -1,9 +1,36 @@
-export interface InputClasses {
-    wrapper?: string;
-    unformatted?: string;
-    formatted?: string;
-    formattedPositive?: string;
-    formattedNegative?: string;
-    formattedZero?: string;
-}
-export type Callback = (value: number) => any;
+export type IntlConfig = {
+    locale: string;
+} & Intl.NumberFormatOptions;
+export type CurrencyInputValues = {
+    float: number | null;
+    formatted: string;
+    value: string;
+};
+export type LocaleConfig = {
+    currencySymbol: string;
+    groupSeparator: string;
+    decimalSeparator: string;
+    prefix: string;
+    suffix: string;
+};
+export type FormatValueOptions = {
+    value: string | undefined;
+    decimalSeparator?: string;
+    groupSeparator?: string;
+    disableGroupSeparators?: boolean;
+    intlConfig?: IntlConfig;
+    decimalScale?: number;
+    prefix?: string;
+    suffix?: string;
+};
+export type CleanValueOptions = {
+    value: string;
+    decimalSeparator?: string;
+    groupSeparator?: string;
+    allowDecimals?: boolean;
+    decimalsLimit?: number;
+    allowNegativeValue?: boolean;
+    disableAbbreviations?: boolean;
+    prefix?: string;
+    transformRawValue?: (rawValue: string) => string;
+};

package/dist/utils/addSeparators.d.ts

@@ -0,0 +1 @@
+export declare const addSeparators: (value: string, separator?: string) => string;

package/dist/utils/addSeparators.js

@@ -0,0 +1,3 @@
+export const addSeparators = (value, separator = ',') => {
+    return value.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+};

package/dist/utils/cleanValue.d.ts

@@ -0,0 +1,2 @@
+import type { CleanValueOptions } from '../types';
+export declare const cleanValue: ({ value, groupSeparator, decimalSeparator, allowDecimals, decimalsLimit, allowNegativeValue, disableAbbreviations, prefix, transformRawValue }: CleanValueOptions) => string;

package/dist/utils/cleanValue.js

@@ -0,0 +1,43 @@
+import { escapeRegExp } from './escapeRegExp';
+import { parseAbbrValue } from './parseAbbrValue';
+import { removeInvalidChars } from './removeInvalidChars';
+import { removeSeparators } from './removeSeparators';
+export const cleanValue = ({ value, groupSeparator = ',', decimalSeparator = '.', allowDecimals = true, decimalsLimit = 2, allowNegativeValue = true, disableAbbreviations = false, prefix = '', transformRawValue = (rawValue) => rawValue }) => {
+    const transformedValue = transformRawValue(value);
+    if (transformedValue === '-') {
+        return transformedValue;
+    }
+    const abbreviations = disableAbbreviations ? [] : ['k', 'm', 'b'];
+    const reg = new RegExp(`((^|\\D)-\\d)|(-${escapeRegExp(prefix)})`);
+    const isNegative = reg.test(transformedValue);
+    const [prefixWithValue, preValue] = RegExp(`(\\d+)-?${escapeRegExp(prefix)}`).exec(value) || [];
+    const withoutPrefix = prefix
+        ? prefixWithValue
+            ? transformedValue.replace(prefixWithValue, '').concat(preValue)
+            : transformedValue.replace(prefix, '')
+        : transformedValue;
+    const withoutSeparators = removeSeparators(withoutPrefix, groupSeparator);
+    const withoutInvalidChars = removeInvalidChars(withoutSeparators, [
+        groupSeparator,
+        decimalSeparator,
+        ...abbreviations
+    ]);
+    let valueOnly = withoutInvalidChars;
+    if (!disableAbbreviations) {
+        if (abbreviations.some((letter) => letter === withoutInvalidChars.toLowerCase().replace(decimalSeparator, ''))) {
+            return '';
+        }
+        const parsed = parseAbbrValue(withoutInvalidChars, decimalSeparator);
+        if (parsed) {
+            valueOnly = String(parsed);
+        }
+    }
+    const includeNegative = isNegative && allowNegativeValue ? '-' : '';
+    if (decimalSeparator && valueOnly.includes(decimalSeparator)) {
+        const [int, decimals] = withoutInvalidChars.split(decimalSeparator);
+        const trimmedDecimals = decimalsLimit && decimals ? decimals.slice(0, decimalsLimit) : decimals;
+        const includeDecimals = allowDecimals ? `${decimalSeparator}${trimmedDecimals}` : '';
+        return `${includeNegative}${int}${includeDecimals}`;
+    }
+    return `${includeNegative}${valueOnly}`;
+};

package/dist/utils/escapeRegExp.d.ts

@@ -0,0 +1 @@
+export declare const escapeRegExp: (stringToGoIntoTheRegex: string) => string;

package/dist/utils/escapeRegExp.js

@@ -0,0 +1,3 @@
+export const escapeRegExp = (stringToGoIntoTheRegex) => {
+    return stringToGoIntoTheRegex.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+};

package/dist/utils/fixedDecimalValue.d.ts

@@ -0,0 +1 @@
+export declare const fixedDecimalValue: (value: string, decimalSeparator: string, fixedDecimalLength?: number) => string;

package/dist/utils/fixedDecimalValue.js

@@ -0,0 +1,25 @@
+export const fixedDecimalValue = (value, decimalSeparator, fixedDecimalLength) => {
+    if (fixedDecimalLength !== undefined && value.length > 1) {
+        if (fixedDecimalLength === 0) {
+            return value.replace(decimalSeparator, '');
+        }
+        if (value.includes(decimalSeparator)) {
+            const [int, decimals] = value.split(decimalSeparator);
+            if (decimals.length === fixedDecimalLength) {
+                return value;
+            }
+            if (decimals.length > fixedDecimalLength) {
+                return `${int}${decimalSeparator}${decimals.slice(0, fixedDecimalLength)}`;
+            }
+        }
+        const reg = value.length > fixedDecimalLength
+            ? new RegExp(`(\\d+)(\\d{${fixedDecimalLength}})`)
+            : new RegExp(`(\\d)(\\d+)`);
+        const match = value.match(reg);
+        if (match) {
+            const [, int, decimals] = match;
+            return `${int}${decimalSeparator}${decimals}`;
+        }
+    }
+    return value;
+};

package/dist/utils/formatValue.d.ts

@@ -0,0 +1,2 @@
+import type { FormatValueOptions } from '../types';
+export declare const formatValue: (options: FormatValueOptions) => string;

package/dist/utils/formatValue.js

@@ -0,0 +1,101 @@
+import { escapeRegExp } from './escapeRegExp';
+import { getSuffix } from './getSuffix';
+export const formatValue = (options) => {
+    const { value: _value, decimalSeparator, intlConfig, decimalScale, prefix = '', suffix = '' } = options;
+    if (_value === '' || _value === undefined) {
+        return '';
+    }
+    if (_value === '-') {
+        return '-';
+    }
+    const isNegative = new RegExp(`^\\d?-${prefix ? `${escapeRegExp(prefix)}?` : ''}\\d`).test(_value);
+    let value = decimalSeparator !== '.'
+        ? replaceDecimalSeparator(_value, decimalSeparator, isNegative)
+        : _value;
+    if (decimalSeparator && decimalSeparator !== '-' && value.startsWith(decimalSeparator)) {
+        value = '0' + value;
+    }
+    const { locale, currency, ...formatOptions } = intlConfig || {};
+    const defaultNumberFormatOptions = {
+        ...formatOptions,
+        minimumFractionDigits: decimalScale || 0,
+        maximumFractionDigits: 20
+    };
+    const numberFormatter = intlConfig
+        ? new Intl.NumberFormat(locale, {
+            ...defaultNumberFormatOptions,
+            ...(currency && { style: 'currency', currency })
+        })
+        : new Intl.NumberFormat(undefined, defaultNumberFormatOptions);
+    const parts = numberFormatter.formatToParts(Number(value));
+    let formatted = replaceParts(parts, options);
+    const intlSuffix = getSuffix(formatted, { ...options });
+    const includeDecimalSeparator = _value.slice(-1) === decimalSeparator ? decimalSeparator : '';
+    const [, decimals] = value.match(RegExp('\\d+\\.(\\d+)')) || [];
+    if (decimalScale === undefined && decimals && decimalSeparator) {
+        if (formatted.includes(decimalSeparator)) {
+            formatted = formatted.replace(RegExp(`(\\d+)(${escapeRegExp(decimalSeparator)})(\\d+)`, 'g'), `$1$2${decimals}`);
+        }
+        else {
+            if (intlSuffix && !suffix) {
+                formatted = formatted.replace(intlSuffix, `${decimalSeparator}${decimals}${intlSuffix}`);
+            }
+            else {
+                formatted = `${formatted}${decimalSeparator}${decimals}`;
+            }
+        }
+    }
+    if (suffix && includeDecimalSeparator) {
+        return `${formatted}${includeDecimalSeparator}${suffix}`;
+    }
+    if (intlSuffix && includeDecimalSeparator) {
+        return formatted.replace(intlSuffix, `${includeDecimalSeparator}${intlSuffix}`);
+    }
+    if (intlSuffix && suffix) {
+        return formatted.replace(intlSuffix, `${includeDecimalSeparator}${suffix}`);
+    }
+    return [formatted, includeDecimalSeparator, suffix].join('');
+};
+const replaceDecimalSeparator = (value, decimalSeparator, isNegative) => {
+    let newValue = value;
+    if (decimalSeparator && decimalSeparator !== '.') {
+        newValue = newValue.replace(RegExp(escapeRegExp(decimalSeparator), 'g'), '.');
+        if (isNegative && decimalSeparator === '-') {
+            newValue = `-${newValue.slice(1)}`;
+        }
+    }
+    return newValue;
+};
+const replaceParts = (parts, { prefix, groupSeparator, decimalSeparator, decimalScale, disableGroupSeparators = false }) => {
+    return parts
+        .reduce((prev, { type, value }, i) => {
+        if (i === 0 && prefix) {
+            if (type === 'minusSign') {
+                return [value, prefix];
+            }
+            if (type === 'currency') {
+                return [...prev, prefix];
+            }
+            return [prefix, value];
+        }
+        if (type === 'currency') {
+            return prefix ? prev : [...prev, value];
+        }
+        if (type === 'group') {
+            return !disableGroupSeparators
+                ? [...prev, groupSeparator !== undefined ? groupSeparator : value]
+                : prev;
+        }
+        if (type === 'decimal') {
+            if (decimalScale !== undefined && decimalScale === 0) {
+                return prev;
+            }
+            return [...prev, decimalSeparator !== undefined ? decimalSeparator : value];
+        }
+        if (type === 'fraction') {
+            return [...prev, decimalScale !== undefined ? value.slice(0, decimalScale) : value];
+        }
+        return [...prev, value];
+    }, [''])
+        .join('');
+};

package/dist/utils/getLocaleConfig.d.ts

@@ -0,0 +1,2 @@
+import type { IntlConfig, LocaleConfig } from '../types';
+export declare const getLocaleConfig: (intlConfig?: IntlConfig) => LocaleConfig;

package/dist/utils/getLocaleConfig.js

@@ -0,0 +1,33 @@
+const defaultConfig = {
+    currencySymbol: '',
+    groupSeparator: '',
+    decimalSeparator: '',
+    prefix: '',
+    suffix: ''
+};
+export const getLocaleConfig = (intlConfig) => {
+    const { locale, currency, ...formatOptions } = intlConfig || {};
+    const numberFormatter = locale
+        ? new Intl.NumberFormat(locale, {
+            ...formatOptions,
+            ...(currency && { currency, style: 'currency' })
+        })
+        : new Intl.NumberFormat();
+    return numberFormatter.formatToParts(1000.1).reduce((prev, curr, i) => {
+        if (curr.type === 'currency') {
+            if (i === 0) {
+                return { ...prev, currencySymbol: curr.value, prefix: curr.value };
+            }
+            else {
+                return { ...prev, currencySymbol: curr.value, suffix: curr.value };
+            }
+        }
+        if (curr.type === 'group') {
+            return { ...prev, groupSeparator: curr.value };
+        }
+        if (curr.type === 'decimal') {
+            return { ...prev, decimalSeparator: curr.value };
+        }
+        return prev;
+    }, defaultConfig);
+};