@automattic/number-formatters 1.2.5 → 1.2.6

package/dist/esm/number-format-currency/index.js

@@ -1,371 +0,0 @@
-import debugFactory from 'debug';
-import { FALLBACK_CURRENCY } from "../constants.js";
-import { getCachedFormatter } from "../get-cached-formatter.js";
-import { defaultCurrencyOverrides } from "./currencies.js";
-const debug = debugFactory('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 = 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 ${FALLBACK_CURRENCY}`);
-        return 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 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;
-        }
-    }, '');
-};
-/**
- * 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,
-    };
-};
-export { numberFormatCurrency, getCurrencyObject };

package/dist/esm/number-format.js

@@ -1,55 +0,0 @@
-import { getCachedFormatter } from "./get-cached-formatter.js";
-/**
- * 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 getCachedFormatter({ locale, options });
-};
-/**
- * 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,
-    },
-});
-export { numberFormat, numberFormatCompact };

package/dist/esm/types.js

@@ -1 +0,0 @@
-export {};

package/dist/types/constants.d.ts

@@ -1,3 +0,0 @@
-export declare const FALLBACK_LOCALE = "en";
-export declare const FALLBACK_CURRENCY = "USD";
-export * from '@wordpress/date';

package/dist/types/create-number-formatters.d.ts

@@ -1,154 +0,0 @@
-import type { CurrencyOverride, FormatCurrency, FormatNumber, GetCurrencyObject } from './types.ts';
-declare global {
-    interface Window {
-        wp?: {
-            date?: {
-                getSettings?: () => {
-                    l10n?: {
-                        locale?: string;
-                    };
-                };
-            };
-        };
-    }
-}
-export interface NumberFormatters {
-    /**
-     * Sets the locale for number formatting
-     * @param locale - The locale to use for formatting
-     */
-    setLocale(locale: string): void;
-    /**
-     * Sets the user's geo location for currency formatting if available
-     * @param geoLocation - The geo location to use for formatting
-     */
-    setGeoLocation(geoLocation: string): void;
-    /**
-     * Sets a dynamic map of per-currency overrides used by currency formatting.
-     *
-     * Typical use: load `{ "IDR": { "decimal": 0 } }` from the WPCOM currencies
-     * endpoint at app boot and pass the parsed object here. Each entry can carry
-     * a `symbol` and/or `decimal` (the smallest-unit exponent), and additional
-     * fields may be added to `CurrencyOverride` in the future.
-     *
-     * If this setter is never called, the package falls back to the hard-coded
-     * defaults shipped with the package, preserving previous behavior.
-     *
-     * When called with a partial map, missing currencies or fields fall back to
-     * the hard-coded defaults — passing `{ IDR: { decimal: 0 } }` does not clear
-     * the default IDR symbol, for example.
-     * @param overrides - Map of currency code to override settings
-     */
-    setCurrencyOverrides(overrides: Record<string, CurrencyOverride>): void;
-    /**
-     * Formats numbers using locale settings and/or passed options.
-     * @param  number                     - The number to format.
-     * @param  params                     - The parameters for the formatter.
-     * @param  params.decimals            - The number of decimal places to display.
-     * @param  params.forceLatin          - Whether to force the Latin script.
-     * @param  params.numberFormatOptions - Additional options to pass to the formatter.
-     * @return {string} Formatted number as string, or original number as string if formatting fails.
-     */
-    formatNumber: FormatNumber;
-    /**
-     * Formats numbers using locale settings and/or passed options, with a compact notation.
-     * 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  number                     - The number to format.
-     * @param  params                     - The parameters for the formatter.
-     * @param  params.decimals            - The number of decimal places to display.
-     * @param  params.forceLatin          - Whether to force the Latin script.
-     * @param  params.numberFormatOptions - Additional options to pass to the formatter.
-     * @return {string} Formatted number as string, or original number as string if formatting fails.
-     */
-    formatNumberCompact: FormatNumber;
-    /**
-     * 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  number                  - The number to format.
-     * @param  currency                - The currency to format.
-     * @param  options                 - The options for the formatter.
-     * @param  options.stripZeros      - Whether to strip zeros.
-     * @param  options.isSmallestUnit  - Whether the number is the smallest unit of a currency.
-     * @param  options.signForPositive - Whether to show the sign for positive numbers.
-     * @param  options.forceLatin      - Whether to force the latin locale.
-     * @return {string} A formatted string.
-     */
-    formatCurrency: FormatCurrency;
-    /**
-     * 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  number                  - The number to format.
-     * @param  currency                - The currency to format.
-     * @param  options                 - The options for the formatter.
-     * @param  options.stripZeros      - Whether to strip zeros.
-     * @param  options.isSmallestUnit  - Whether the number is the smallest unit of a currency.
-     * @param  options.signForPositive - Whether to show the sign for positive numbers.
-     * @param  options.forceLatin      - Whether to force the latin locale.
-     * @return {CurrencyObject} A formatted price object.
-     */
-    getCurrencyObject: GetCurrencyObject;
-}
-/**
- * Creates a NumberFormatters instance that provides number and currency formatting functionality with locale awareness
- * @return {NumberFormatters} A NumberFormatters instance
- */
-declare function createNumberFormatters(): NumberFormatters;
-export default createNumberFormatters;

package/dist/types/get-cached-formatter.d.ts

@@ -1,17 +0,0 @@
-interface Params {
-    locale: string;
-    options?: Intl.NumberFormatOptions;
-    fallbackLocale?: string;
-    retries?: number;
-}
-/**
- * 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 declare function getCachedFormatter({ locale, fallbackLocale, options, retries, }: Params): Intl.NumberFormat;
-export {};

package/dist/types/index.d.ts

@@ -1,4 +0,0 @@
-import createNumberFormatters from './create-number-formatters.ts';
-export declare const setLocale: (locale: string) => void, setGeoLocation: (geoLocation: string) => void, setCurrencyOverrides: (overrides: Record<string, import("./types.ts").CurrencyOverride>) => void, formatNumber: import("./types.ts").FormatNumber, formatNumberCompact: import("./types.ts").FormatNumber, formatCurrency: import("./types.ts").FormatCurrency, getCurrencyObject: import("./types.ts").GetCurrencyObject;
-export { createNumberFormatters };
-export type * from './types.ts';

package/dist/types/number-format-currency/currencies.d.ts

@@ -1,2 +0,0 @@
-import type { CurrencyOverride } from '../types.ts';
-export declare const defaultCurrencyOverrides: Record<string, CurrencyOverride>;