@automattic/number-formatters 1.2.4 → 1.2.6

package/dist/cjs/number-format-currency/index.cjs

@@ -1,376 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCurrencyObject = exports.numberFormatCurrency = void 0;
-const tslib_1 = require("tslib");
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const constants_ts_1 = require("../constants.cjs");
-const get_cached_formatter_ts_1 = require("../get-cached-formatter.cjs");
-const currencies_ts_1 = require("./currencies.cjs");
-const debug = (0, debug_1.default)('number-formatters:number-format-currency');
-/**
- * Retrieves the currency override for a given currency.
- *
- * If the currency is USD and the user is not in the US, it will return `US$`.
- *
- * Per-field merge order is: dynamic overrides (from `currencyOverrides`) → hard-coded defaults.
- * This means a caller can supply a partial map (eg: only `decimal`) without losing the
- * default `symbol`.
- * @param  currency          - The currency to get the override for.
- * @param  geoLocation       - The geo location of the user.
- * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
- * @return {CurrencyOverride | undefined} The currency override.
- */
-function getCurrencyOverride(currency, geoLocation, currencyOverrides) {
-    if (currency === 'USD' && geoLocation && geoLocation !== '' && geoLocation !== 'US') {
-        return { symbol: 'US$', ...currencyOverrides?.USD };
-    }
-    const defaultOverride = currencies_ts_1.defaultCurrencyOverrides[currency];
-    const dynamicOverride = currencyOverrides?.[currency];
-    if (!defaultOverride && !dynamicOverride) {
-        return undefined;
-    }
-    return { ...defaultOverride, ...dynamicOverride };
-}
-/**
- * Returns a valid currency code based on a shortlist of currency codes.
- * Only currencies from the shortlist are allowed. Everything else will fall back to `FALLBACK_CURRENCY`.
- * @param  currency          - The currency to get the valid currency for.
- * @param  geoLocation       - The geo location of the user.
- * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
- * @return {string} The valid currency.
- */
-function getValidCurrency(currency, geoLocation, currencyOverrides) {
-    if (!getCurrencyOverride(currency, geoLocation, currencyOverrides)) {
-        debug(`getValidCurrency was called with a non-existent currency "${currency}"; falling back to ${constants_ts_1.FALLBACK_CURRENCY}`);
-        return constants_ts_1.FALLBACK_CURRENCY;
-    }
-    return currency;
-}
-/**
- * Returns a currency formatter for a given currency.
- * @param  params                   - The parameters for the currency formatter.
- * @param  params.number            - The number to format.
- * @param  params.currency          - The currency to format.
- * @param  params.browserSafeLocale - The browser safe locale.
- * @param  params.forceLatin        - Whether to force the latin locale.
- * @param  params.stripZeros        - Whether to strip zeros.
- * @param  params.signForPositive   - Whether to show the sign for positive numbers.
- * @return {Intl.NumberFormat} The currency formatter.
- */
-function getCurrencyFormatter({ number, currency, browserSafeLocale, forceLatin = true, stripZeros, signForPositive, }) {
-    /**
-     * `numberingSystem` is an option to `Intl.NumberFormat` and is available
-     * in all major browsers according to
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#options
-     * but is not part of the TypeScript types in `es2020`:
-     *
-     * https://github.com/microsoft/TypeScript/blob/cfd472f7aa5a2010a3115263bf457b30c5b489f3/src/lib/es2020.intl.d.ts#L272
-     *
-     * However, it is part of the TypeScript types in `es5`:
-     *
-     * https://github.com/microsoft/TypeScript/blob/cfd472f7aa5a2010a3115263bf457b30c5b489f3/src/lib/es5.d.ts#L4310
-     *
-     * Apparently calypso uses `es2020` so we cannot use that option here right
-     * now. Instead, we will use the unicode extension to the locale, documented
-     * here:
-     *
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/numberingSystem#adding_a_numbering_system_via_the_locale_string
-     */
-    const locale = `${browserSafeLocale}${forceLatin ? '-u-nu-latn' : ''}`;
-    const numberFormatOptions = {
-        style: 'currency',
-        currency,
-        ...(stripZeros &&
-            Number.isInteger(number) && {
-            /**
-             * There's an option called `trailingZeroDisplay` but it does not yet work
-             * in FF so we have to strip zeros manually.
-             */
-            maximumFractionDigits: 0,
-            minimumFractionDigits: 0,
-        }),
-        ...(signForPositive && { signDisplay: 'exceptZero' }),
-    };
-    return (0, get_cached_formatter_ts_1.getCachedFormatter)({
-        locale,
-        options: numberFormatOptions,
-    });
-}
-/**
- * Hard-coded smallest-unit exponent overrides for currencies where browser ICU's
- * `maximumFractionDigits` disagrees with the API's smallest-unit encoding.
- *
- * This list exists as a safety net for callers that have not yet wired up the
- * dynamic `currencyOverrides` path (eg: the WPCOM currencies endpoint). Once a
- * host application provides overrides via `setCurrencyOverrides`, those take
- * precedence on a per-currency basis.
- *
- * Keep this list minimal — the backend is the source of truth for the API's
- * smallest-unit encoding, so adding speculative entries here risks silent
- * drift. Only add a currency once we've verified that browsers report a
- * value the API does not use.
- *
- * - IDR: modern Chrome / Node 24+ ICU reports 0; the API encodes with exponent 2.
- * - HUF: same browser/API divergence as IDR.
- */
-const SMALLEST_UNIT_EXPONENT_OVERRIDES = {
-    IDR: 2,
-    HUF: 2,
-};
-/**
- * Returns the smallest unit exponent for a currency.
- *
- * Lookup order:
- * 1. The dynamic `currencyOverrides[currency].decimal` if a host application has supplied one (typically via `setCurrencyOverrides`).
- * 2. The hard-coded `SMALLEST_UNIT_EXPONENT_OVERRIDES` map.
- * 3. The browser-derived display precision (`fallback`).
- * @param currency          - The currency code (ISO 4217)
- * @param fallback          - The browser-derived precision to use when no override applies
- * @param currencyOverrides - Dynamic per-currency overrides supplied by the host application
- * @return number           - The smallest unit exponent
- */
-function getSmallestUnitExponent(currency, fallback, currencyOverrides) {
-    const dynamicDecimal = currencyOverrides?.[currency]?.decimal;
-    if (typeof dynamicDecimal === 'number') {
-        return dynamicDecimal;
-    }
-    return SMALLEST_UNIT_EXPONENT_OVERRIDES[currency] ?? fallback;
-}
-/**
- * Returns the precision for a given locale and currency.
- * @param  browserSafeLocale - The browser safe locale.
- * @param  currency          - The currency to get the precision for.
- * @param  forceLatin        - Whether to force the latin locale.
- * @return {number | undefined} The precision.
- */
-function getPrecisionForLocaleAndCurrency(browserSafeLocale, currency, forceLatin) {
-    const formatter = getCurrencyFormatter({ number: 0, currency, browserSafeLocale, forceLatin });
-    /**
-     * For regular numbers, the default is 3 if neither `minimumFractionDigits` or `maximumFractionDigits` are set,
-     * otherwise the greatest betweem `minimumFractionDigits` and 3.
-     *
-     * For currencies, the default is dependent on the currency.
-     *
-     * This may also result in undefined, for several reasons:
-     * see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#significantdigitsfractiondigits_default_values
-     */
-    return formatter.resolvedOptions().maximumFractionDigits;
-}
-/**
- * Scales a number to a specified precision and rounds it to that precision.
- * It ensures that all currency values are consistently rounded to the desired precision,
- * avoiding issues with floating-point arithmetic.
- * @param  number            - The number to scale.
- * @param  currencyPrecision - The precision to scale the number to.
- * @return {number} The scaled number.
- */
-function scaleNumberForPrecision(number, currencyPrecision) {
-    const scale = Math.pow(10, currencyPrecision);
-    return Math.round(number * scale) / scale;
-}
-/**
- * Prepares a number for formatting.
- * @param  number            - The number to prepare.
- * @param  currencyPrecision - The display precision (from the browser) to round the result to.
- * @param  currency          - The currency code, used to look up any smallest-unit exponent override.
- * @param  isSmallestUnit    - Whether the number is the smallest unit of a currency.
- * @param  currencyOverrides - Dynamic per-currency overrides supplied by the host application.
- * @return {number} The prepared number.
- */
-function prepareNumberForFormatting(number, currencyPrecision, currency, isSmallestUnit, currencyOverrides) {
-    if (isNaN(number)) {
-        debug('formatCurrency was called with NaN');
-        return 0;
-    }
-    if (isSmallestUnit) {
-        if (!Number.isInteger(number)) {
-            debug('formatCurrency was called with isSmallestUnit and a float which will be rounded', number);
-        }
-        const smallestUnitDivisor = 10 ** getSmallestUnitExponent(currency, currencyPrecision, currencyOverrides);
-        return scaleNumberForPrecision(Math.round(number) / smallestUnitDivisor, currencyPrecision);
-    }
-    return scaleNumberForPrecision(number, currencyPrecision);
-}
-/**
- * Formats money with a given currency code.
- *
- * The currency will define the properties to use for this formatting, but
- * those properties can be overridden using the options. Be careful when doing
- * this.
- *
- * For currencies that include decimals, this will always return the amount
- * with decimals included, even if those decimals are zeros. To exclude the
- * zeros, use the `stripZeros` option. For example, the function will normally
- * format `10.00` in `USD` as `$10.00` but when this option is true, it will
- * return `$10` instead.
- *
- * Since rounding errors are common in floating point math, sometimes a price
- * is provided as an integer in the smallest unit of a currency (eg: cents in
- * USD or yen in JPY). Set the `isSmallestUnit` to change the function to
- * operate on integer numbers instead. If this option is not set or false, the
- * function will format the amount `1025` in `USD` as `$1,025.00`, but when the
- * option is true, it will return `$10.25` instead.
- *
- * If the number is NaN, it will be treated as 0.
- *
- * If the currency code is not known, this will assume a default currency
- * similar to USD.
- *
- * If `isSmallestUnit` is set and the number is not an integer, it will be
- * rounded to an integer.
- *
- * @param  params                   - The parameters for the currency formatter.
- * @param  params.number            - The number to format.
- * @param  params.browserSafeLocale - The browser safe locale.
- * @param  params.currency          - The currency to format.
- * @param  params.stripZeros        - Whether to strip zeros.
- * @param  params.isSmallestUnit    - Whether the number is the smallest unit of a currency.
- * @param  params.signForPositive   - Whether to show the sign for positive numbers.
- * @param  params.geoLocation       - The geo location of the user.
- * @param  params.forceLatin        - Whether to force the latin locale.
- * @param  params.currencyOverrides - Dynamic per-currency overrides supplied by the host application.
- * @return {string} A formatted string.
- */
-const numberFormatCurrency = ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, currencyOverrides, }) => {
-    const validCurrency = getValidCurrency(currency, geoLocation, currencyOverrides);
-    const currencyOverride = getCurrencyOverride(validCurrency, geoLocation, currencyOverrides);
-    const currencyPrecision = getPrecisionForLocaleAndCurrency(browserSafeLocale, validCurrency, forceLatin);
-    if (isSmallestUnit && typeof currencyPrecision === 'undefined') {
-        throw new Error(`Could not determine currency precision for ${validCurrency} in ${browserSafeLocale}`);
-    }
-    const numberAsFloat = prepareNumberForFormatting(number, currencyPrecision ?? 0, validCurrency, isSmallestUnit, currencyOverrides);
-    const formatter = getCurrencyFormatter({
-        number: numberAsFloat,
-        currency: validCurrency,
-        browserSafeLocale,
-        forceLatin,
-        stripZeros,
-        signForPositive,
-    });
-    const parts = formatter.formatToParts(numberAsFloat);
-    return parts.reduce((formatted, part) => {
-        switch (part.type) {
-            case 'currency':
-                if (currencyOverride?.symbol) {
-                    return formatted + currencyOverride.symbol;
-                }
-                return formatted + part.value;
-            default:
-                return formatted + part.value;
-        }
-    }, '');
-};
-exports.numberFormatCurrency = numberFormatCurrency;
-/**
- * Returns a formatted price object which can be used to manually render a
- * formatted currency (eg: if you wanted to render the currency symbol in a
- * different font size).
- *
- * The currency will define the properties to use for this formatting, but
- * those properties can be overridden using the options. Be careful when doing
- * this.
- *
- * For currencies that include decimals, this will always return the amount
- * with decimals included, even if those decimals are zeros. To exclude the
- * zeros, use the `stripZeros` option. For example, the function will normally
- * format `10.00` in `USD` as `$10.00` but when this option is true, it will
- * return `$10` instead.
- *
- * Since rounding errors are common in floating point math, sometimes a price
- * is provided as an integer in the smallest unit of a currency (eg: cents in
- * USD or yen in JPY). Set the `isSmallestUnit` to change the function to
- * operate on integer numbers instead. If this option is not set or false, the
- * function will format the amount `1025` in `USD` as `$1,025.00`, but when the
- * option is true, it will return `$10.25` instead.
- *
- * Note that the `integer` return value of this function is not a number, but a
- * locale-formatted string which may include symbols like spaces, commas, or
- * periods as group separators. Similarly, the `fraction` property is a string
- * that contains the decimal separator.
- *
- * If the number is NaN, it will be treated as 0.
- *
- * If the currency code is not known, this will assume a default currency
- * similar to USD.
- *
- * If `isSmallestUnit` is set and the number is not an integer, it will be
- * rounded to an integer.
- *
- * @param  params                   - The parameters for the currency formatter.
- * @param  params.number            - The number to format.
- * @param  params.browserSafeLocale - The browser safe locale.
- * @param  params.currency          - The currency to format.
- * @param  params.stripZeros        - Whether to strip zeros.
- * @param  params.isSmallestUnit    - Whether the number is the smallest unit of a currency.
- * @param  params.signForPositive   - Whether to show the sign for positive numbers.
- * @param  params.geoLocation       - The geo location of the user.
- * @param  params.forceLatin        - Whether to force the latin locale.
- * @param  params.currencyOverrides - Dynamic per-currency overrides supplied by the host application.
- * @return {CurrencyObject} A formatted string e.g. { symbol:'$', integer: '$99', fraction: '.99', sign: '-' }
- */
-const getCurrencyObject = ({ number, browserSafeLocale, currency, stripZeros, isSmallestUnit, signForPositive, geoLocation, forceLatin, currencyOverrides, }) => {
-    const validCurrency = getValidCurrency(currency, geoLocation, currencyOverrides);
-    const currencyOverride = getCurrencyOverride(validCurrency, geoLocation, currencyOverrides);
-    const currencyPrecision = getPrecisionForLocaleAndCurrency(browserSafeLocale, validCurrency, forceLatin);
-    const numberAsFloat = prepareNumberForFormatting(number, currencyPrecision ?? 0, validCurrency, isSmallestUnit, currencyOverrides);
-    const formatter = getCurrencyFormatter({
-        number: numberAsFloat,
-        currency: validCurrency,
-        browserSafeLocale,
-        forceLatin,
-        stripZeros,
-        signForPositive,
-    });
-    const parts = formatter.formatToParts(numberAsFloat);
-    let sign = '';
-    let symbol = '$';
-    let symbolPosition = 'before';
-    let hasAmountBeenSet = false;
-    let hasDecimalBeenSet = false;
-    let integer = '';
-    let fraction = '';
-    parts.forEach(part => {
-        switch (part.type) {
-            case 'currency':
-                symbol = currencyOverride?.symbol ?? part.value;
-                if (hasAmountBeenSet) {
-                    symbolPosition = 'after';
-                }
-                return;
-            case 'group':
-                integer += part.value;
-                hasAmountBeenSet = true;
-                return;
-            case 'decimal':
-                fraction += part.value;
-                hasAmountBeenSet = true;
-                hasDecimalBeenSet = true;
-                return;
-            case 'integer':
-                integer += part.value;
-                hasAmountBeenSet = true;
-                return;
-            case 'fraction':
-                fraction += part.value;
-                hasAmountBeenSet = true;
-                hasDecimalBeenSet = true;
-                return;
-            case 'minusSign':
-                sign = '-';
-                return;
-            case 'plusSign':
-                sign = '+';
-        }
-    });
-    const hasNonZeroFraction = !Number.isInteger(numberAsFloat) && hasDecimalBeenSet;
-    return {
-        sign,
-        symbol,
-        symbolPosition,
-        integer,
-        fraction,
-        hasNonZeroFraction,
-        floatValue: numberAsFloat,
-    };
-};
-exports.getCurrencyObject = getCurrencyObject;

package/dist/cjs/number-format.cjs

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.numberFormatCompact = exports.numberFormat = void 0;
-const get_cached_formatter_ts_1 = require("./get-cached-formatter.cjs");
-/**
- * Formats numbers using locale settings and/or passed options.
- * @param  params                     - The parameters for the number formatter.
- * @param  params.browserSafeLocale   - The browser safe locale.
- * @param  params.decimals            - The number of decimal places to use.
- * @param  params.forceLatin          - Whether to force the latin locale.
- * @param  params.numberFormatOptions - The options for the number formatter.
- * @return {Intl.NumberFormat} The number formatter.
- */
-const numberFormat = ({ browserSafeLocale, decimals = 0, forceLatin = true, numberFormatOptions = {}, }) => {
-    /**
-     * `numberingSystem` is an option to `Intl.NumberFormat` and is available
-     * in all major browsers according to
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#options
-     * but is not part of the TypeScript types in `es2020`:
-     *
-     * https://github.com/microsoft/TypeScript/blob/cfd472f7aa5a2010a3115263bf457b30c5b489f3/src/lib/es2020.intl.d.ts#L272
-     *
-     * However, it is part of the TypeScript types in `es5`:
-     *
-     * https://github.com/microsoft/TypeScript/blob/cfd472f7aa5a2010a3115263bf457b30c5b489f3/src/lib/es5.d.ts#L4310
-     *
-     * Apparently calypso uses `es2020` so we cannot use that option here right
-     * now. Instead, we will use the unicode extension to the locale, documented
-     * here:
-     *
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/numberingSystem#adding_a_numbering_system_via_the_locale_string
-     */
-    const locale = `${browserSafeLocale}${forceLatin ? '-u-nu-latn' : ''}`;
-    const options = {
-        minimumFractionDigits: decimals, // minimumFractionDigits default is 0
-        maximumFractionDigits: decimals, // maximumFractionDigits default is the greater between minimumFractionDigits and 3
-        ...numberFormatOptions,
-    };
-    return (0, get_cached_formatter_ts_1.getCachedFormatter)({ locale, options });
-};
-exports.numberFormat = numberFormat;
-/**
- * Convenience method for formatting numbers in a compact notation e.g. 1K, 1M, etc.
- * Basically sets `notation: 'compact'` and `maximumFractionDigits: 1` in the options.
- * Everything is overridable by passing the `numberFormatOptions` option.
- * If you want more digits, pass `maximumFractionDigits: 2`.
- * @param  params                     - The parameters for the number formatter.
- * @param  params.numberFormatOptions - The options for the number formatter.
- * @return {Intl.NumberFormat} The number formatter.
- */
-const numberFormatCompact = ({ numberFormatOptions = {}, ...params }) => numberFormat({
-    ...params,
-    numberFormatOptions: {
-        notation: 'compact',
-        maximumFractionDigits: 1,
-        ...numberFormatOptions,
-    },
-});
-exports.numberFormatCompact = numberFormatCompact;

package/dist/cjs/types.cjs

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/constants.js

@@ -1,5 +0,0 @@
-export const FALLBACK_LOCALE = 'en';
-export const FALLBACK_CURRENCY = 'USD';
-// This is just to hint to the dependency extraction tool that this package depends on @wordpress/date
-// See: https://github.com/Automattic/jetpack/pull/47812#issuecomment-4142452829
-export * from '@wordpress/date';

package/dist/esm/create-number-formatters.js

@@ -1,111 +0,0 @@
-import { FALLBACK_LOCALE } from "./constants.js";
-import { numberFormatCurrency, getCurrencyObject as getCurrencyObjectFromCurrencyFormatter, } from "./number-format-currency/index.js";
-import { numberFormat, numberFormatCompact } from "./number-format.js";
-/**
- * Creates a NumberFormatters instance that provides number and currency formatting functionality with locale awareness
- * @return {NumberFormatters} A NumberFormatters instance
- */
-function createNumberFormatters() {
-    let localeState;
-    let geoLocationState;
-    let currencyOverridesState;
-    const setLocale = (locale) => {
-        /**
-         * The `Intl.NumberFormat` constructor fails only when there is a variant, divided by `_`.
-         * These suffixes should be removed. Values like `de-at` or `es-mx`
-         * should all be valid inputs for the constructor.
-         */
-        localeState = locale;
-    };
-    const setCurrencyOverrides = (overrides) => {
-        currencyOverridesState = overrides;
-    };
-    /**
-     * Returns the locale defined on the module instance (through `setLocale`)
-     * or the "fallback locale" if no locale has been set.
-     *
-     * The "fallback locale" is defined as:
-     * - the current WP user locale, if available through `@wordpress/date` settings (assuming this runs in a WordPress context)
-     * - or the browser locale, if available through `window.navigator.language`
-     * - or the fallback locale constant (`FALLBACK_LOCALE`)
-     *
-     * @return {string} The locale to use for formatting.
-     */
-    const getBrowserSafeLocale = () => {
-        // Accessing the user's locale from `@wordpress/date` package.
-        // This is a bit hacky but it's better than importing `@wordpress/date` and using its `getSettings` function,
-        // because it drags moment.js with it even though we don't need it here.
-        const localeFromUserSettings = typeof window !== 'undefined' ? window.wp?.date?.getSettings?.()?.l10n?.locale : undefined;
-        const localeFromNavigator = typeof window !== 'undefined' ? window?.navigator?.language : undefined;
-        return (localeState ??
-            (localeFromUserSettings || localeFromNavigator) ??
-            FALLBACK_LOCALE).split('_')[0];
-    };
-    const setGeoLocation = (geoLocation) => {
-        geoLocationState = geoLocation;
-    };
-    const formatNumber = (number, { decimals = 0, forceLatin = true, numberFormatOptions = {} } = {}) => {
-        try {
-            const formatter = numberFormat({
-                browserSafeLocale: getBrowserSafeLocale(),
-                decimals,
-                forceLatin,
-                numberFormatOptions,
-            });
-            return formatter.format(number);
-        }
-        catch {
-            return String(number);
-        }
-    };
-    const formatNumberCompact = (number, { decimals = 0, forceLatin = true, numberFormatOptions = {} } = {}) => {
-        try {
-            const formatter = numberFormatCompact({
-                browserSafeLocale: getBrowserSafeLocale(),
-                decimals,
-                forceLatin,
-                numberFormatOptions,
-            });
-            return formatter.format(number);
-        }
-        catch {
-            return String(number);
-        }
-    };
-    const formatCurrency = (number, currency, { stripZeros = false, isSmallestUnit = false, signForPositive = false, forceLatin = true } = {}) => {
-        return numberFormatCurrency({
-            number,
-            currency,
-            browserSafeLocale: getBrowserSafeLocale(),
-            stripZeros,
-            isSmallestUnit,
-            signForPositive,
-            geoLocation: geoLocationState,
-            forceLatin,
-            currencyOverrides: currencyOverridesState,
-        });
-    };
-    const getCurrencyObject = (number, currency, { stripZeros = false, isSmallestUnit = false, signForPositive = false, forceLatin = true } = {}) => {
-        return getCurrencyObjectFromCurrencyFormatter({
-            number,
-            currency,
-            browserSafeLocale: getBrowserSafeLocale(),
-            stripZeros,
-            isSmallestUnit,
-            signForPositive,
-            geoLocation: geoLocationState,
-            forceLatin,
-            currencyOverrides: currencyOverridesState,
-        });
-    };
-    return {
-        setLocale,
-        setGeoLocation,
-        setCurrencyOverrides,
-        formatNumber,
-        formatNumberCompact,
-        formatCurrency,
-        getCurrencyObject,
-    };
-}
-export default createNumberFormatters;

package/dist/esm/get-cached-formatter.js

@@ -1,32 +0,0 @@
-import debugFactory from 'debug';
-import { FALLBACK_LOCALE } from "./constants.js";
-const debug = debugFactory('number-formatters:get-cached-formatter');
-const formatterCache = new Map();
-/**
- * Get a cached formatter for a given locale and options.
- * @param  params                - The parameters for the formatter.
- * @param  params.locale         - The locale to format the number in.
- * @param  params.options        - Intl.NumberFormatOptions to pass to the formatter.
- * @param  params.fallbackLocale - The locale to fallback to if the locale is not supported.
- * @param  params.retries        - The number of retries to attempt if the formatter is not created.
- * @return {Intl.NumberFormat} A cached formatter for the given locale and options.
- */
-export function getCachedFormatter({ locale, fallbackLocale = FALLBACK_LOCALE, options, retries = 1, }) {
-    const cacheKey = JSON.stringify([locale, options]);
-    try {
-        return (formatterCache.get(cacheKey) ??
-            formatterCache.set(cacheKey, new Intl.NumberFormat(locale, options)).get(cacheKey));
-    }
-    catch (error) {
-        // If the locale is invalid, creating the NumberFormat will throw.
-        debug(`Intl.NumberFormat was called with a non-existent locale "${locale}"; falling back to ${fallbackLocale}`);
-        if (retries) {
-            return getCachedFormatter({
-                locale: fallbackLocale,
-                options,
-                retries: retries - 1,
-            });
-        }
-        throw error;
-    }
-}

package/dist/esm/index.js

@@ -1,6 +0,0 @@
-import createNumberFormatters from "./create-number-formatters.js";
-const defaultFormatter = createNumberFormatters();
-export const { setLocale, setGeoLocation, setCurrencyOverrides, formatNumber, formatNumberCompact, formatCurrency, getCurrencyObject, } = defaultFormatter;
-export { createNumberFormatters };
-// We can optionally export the formatters individually if we want to use them in a more granular way.
-// export { numberFormat, numberFormatCompact, numberFormatCurrency, getCurrencyObject };