@stridge/noctis-intl 1.0.0-beta.0

package/dist/number/NumberFormatter.d.ts

@@ -0,0 +1,32 @@
+//#region src/number/NumberFormatter.d.ts
+interface NumberFormatOptions extends Intl.NumberFormatOptions {
+  /** Overrides default numbering system for the current locale. */
+  numberingSystem?: string;
+}
+interface NumberRangeFormatPart extends Intl.NumberFormatPart {
+  source: "startRange" | "endRange" | "shared";
+}
+/**
+ * A wrapper around Intl.NumberFormat providing additional options, polyfills, and caching for
+ * performance.
+ */
+declare class NumberFormatter implements Intl.NumberFormat {
+  private numberFormatter;
+  private options;
+  constructor(locale: string, options?: NumberFormatOptions);
+  /**
+   * Formats a number value as a string, according to the locale and options provided to the
+   * constructor.
+   */
+  format(value: number): string;
+  /** Formats a number to an array of parts such as separators, digits, punctuation, and more. */
+  formatToParts(value: number): Intl.NumberFormatPart[];
+  /** Formats a number range as a string. */
+  formatRange(start: number, end: number): string;
+  /** Formats a number range as an array of parts. */
+  formatRangeToParts(start: number, end: number): NumberRangeFormatPart[];
+  /** Returns the resolved formatting options based on the values passed to the constructor. */
+  resolvedOptions(): Intl.ResolvedNumberFormatOptions;
+}
+//#endregion
+export { NumberFormatOptions, NumberFormatter };

package/dist/number/NumberFormatter.js

@@ -0,0 +1,135 @@
+//#region src/number/NumberFormatter.ts
+let formatterCache = /* @__PURE__ */ new Map();
+let supportsSignDisplay = false;
+try {
+	supportsSignDisplay = new Intl.NumberFormat("de-DE", { signDisplay: "exceptZero" }).resolvedOptions().signDisplay === "exceptZero";
+} catch {}
+let supportsUnit = false;
+try {
+	supportsUnit = new Intl.NumberFormat("de-DE", {
+		style: "unit",
+		unit: "degree"
+	}).resolvedOptions().style === "unit";
+} catch {}
+const UNITS = { degree: { narrow: {
+	default: "°",
+	"ja-JP": " 度",
+	"zh-TW": "度",
+	"sl-SI": " °"
+} } };
+/**
+* A wrapper around Intl.NumberFormat providing additional options, polyfills, and caching for
+* performance.
+*/
+var NumberFormatter = class {
+	numberFormatter;
+	options;
+	constructor(locale, options = {}) {
+		this.numberFormatter = getCachedNumberFormatter(locale, options);
+		this.options = options;
+	}
+	/**
+	* Formats a number value as a string, according to the locale and options provided to the
+	* constructor.
+	*/
+	format(value) {
+		let res = "";
+		if (!supportsSignDisplay && this.options.signDisplay != null) res = numberFormatSignDisplayPolyfill(this.numberFormatter, this.options.signDisplay, value);
+		else res = this.numberFormatter.format(value);
+		if (this.options.style === "unit" && !supportsUnit) {
+			let { unit, unitDisplay = "short", locale } = this.resolvedOptions();
+			if (!unit) return res;
+			let values = UNITS[unit]?.[unitDisplay];
+			res += values[locale] || values.default;
+		}
+		return res;
+	}
+	/** Formats a number to an array of parts such as separators, digits, punctuation, and more. */
+	formatToParts(value) {
+		return this.numberFormatter.formatToParts(value);
+	}
+	/** Formats a number range as a string. */
+	formatRange(start, end) {
+		if (typeof this.numberFormatter.formatRange === "function") return this.numberFormatter.formatRange(start, end);
+		if (end < start) throw new RangeError("End date must be >= start date");
+		return `${this.format(start)} – ${this.format(end)}`;
+	}
+	/** Formats a number range as an array of parts. */
+	formatRangeToParts(start, end) {
+		if (typeof this.numberFormatter.formatRangeToParts === "function") return this.numberFormatter.formatRangeToParts(start, end);
+		if (end < start) throw new RangeError("End date must be >= start date");
+		let startParts = this.numberFormatter.formatToParts(start);
+		let endParts = this.numberFormatter.formatToParts(end);
+		return [
+			...startParts.map((p) => ({
+				...p,
+				source: "startRange"
+			})),
+			{
+				type: "literal",
+				value: " – ",
+				source: "shared"
+			},
+			...endParts.map((p) => ({
+				...p,
+				source: "endRange"
+			}))
+		];
+	}
+	/** Returns the resolved formatting options based on the values passed to the constructor. */
+	resolvedOptions() {
+		let options = this.numberFormatter.resolvedOptions();
+		if (!supportsSignDisplay && this.options.signDisplay != null) options = {
+			...options,
+			signDisplay: this.options.signDisplay
+		};
+		if (!supportsUnit && this.options.style === "unit") options = {
+			...options,
+			style: "unit",
+			unit: this.options.unit,
+			unitDisplay: this.options.unitDisplay
+		};
+		return options;
+	}
+};
+function getCachedNumberFormatter(locale, options = {}) {
+	let { numberingSystem } = options;
+	if (numberingSystem && locale.includes("-nu-")) {
+		if (!locale.includes("-u-")) locale += "-u-";
+		locale += `-nu-${numberingSystem}`;
+	}
+	if (options.style === "unit" && !supportsUnit) {
+		let { unit, unitDisplay = "short" } = options;
+		if (!unit) throw new Error("unit option must be provided with style: \"unit\"");
+		if (!UNITS[unit]?.[unitDisplay]) throw new Error(`Unsupported unit ${unit} with unitDisplay = ${unitDisplay}`);
+		options = {
+			...options,
+			style: "decimal"
+		};
+	}
+	let cacheKey = locale + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : "");
+	if (formatterCache.has(cacheKey)) return formatterCache.get(cacheKey);
+	let numberFormatter = new Intl.NumberFormat(locale, options);
+	formatterCache.set(cacheKey, numberFormatter);
+	return numberFormatter;
+}
+/** @private - Exported for tests */
+function numberFormatSignDisplayPolyfill(numberFormat, signDisplay, num) {
+	if (signDisplay === "auto") return numberFormat.format(num);
+	else if (signDisplay === "never") return numberFormat.format(Math.abs(num));
+	else {
+		let needsPositiveSign = false;
+		if (signDisplay === "always") needsPositiveSign = num > 0 || Object.is(num, 0);
+		else if (signDisplay === "exceptZero") if (Object.is(num, -0) || Object.is(num, 0)) num = Math.abs(num);
+		else needsPositiveSign = num > 0;
+		if (needsPositiveSign) {
+			let negative = numberFormat.format(-num);
+			let noSign = numberFormat.format(num);
+			let minus = negative.replace(noSign, "").replace(/\u200e|\u061C/, "");
+			if ([...minus].length !== 1) console.warn("@react-aria/i18n polyfill for NumberFormat signDisplay: Unsupported case");
+			return negative.replace(noSign, "!!!").replace(minus, "+").replace("!!!", noSign);
+		} else return numberFormat.format(num);
+	}
+}
+//#endregion
+export { NumberFormatter };

package/dist/number/NumberParser.d.ts

@@ -0,0 +1,30 @@
+//#region src/number/NumberParser.d.ts
+/**
+ * A NumberParser can be used to perform locale-aware parsing of numbers from Unicode strings,
+ * as well as validation of partial user input. It automatically detects the numbering system
+ * used in the input, and supports parsing decimals, percentages, currency values, and units
+ * according to the locale.
+ */
+declare class NumberParser {
+  private locale;
+  private options;
+  constructor(locale: string, options?: Intl.NumberFormatOptions);
+  /**
+   * Parses the given string to a number. Returns NaN if a valid number could not be parsed.
+   */
+  parse(value: string): number;
+  /**
+   * Returns whether the given string could potentially be a valid number. This should be used to
+   * validate user input as the user types. If a `minValue` or `maxValue` is provided, the validity
+   * of the minus/plus sign characters can be checked.
+   */
+  isValidPartialNumber(value: string, minValue?: number, maxValue?: number): boolean;
+  /**
+   * Returns a numbering system for which the given string is valid in the current locale.
+   * If no numbering system could be detected, the default numbering system for the current
+   * locale is returned.
+   */
+  getNumberingSystem(value: string): string;
+}
+//#endregion
+export { NumberParser };

package/dist/number/NumberParser.js

@@ -0,0 +1,234 @@
+import { NumberFormatter } from "./NumberFormatter.js";
+//#region src/number/NumberParser.ts
+const CURRENCY_SIGN_REGEX = /* @__PURE__ */ new RegExp("^.*\\(.*\\).*$");
+const NUMBERING_SYSTEMS = [
+	"latn",
+	"arab",
+	"hanidec",
+	"deva",
+	"beng",
+	"fullwide"
+];
+/**
+* A NumberParser can be used to perform locale-aware parsing of numbers from Unicode strings,
+* as well as validation of partial user input. It automatically detects the numbering system
+* used in the input, and supports parsing decimals, percentages, currency values, and units
+* according to the locale.
+*/
+var NumberParser = class {
+	locale;
+	options;
+	constructor(locale, options = {}) {
+		this.locale = locale;
+		this.options = options;
+	}
+	/**
+	* Parses the given string to a number. Returns NaN if a valid number could not be parsed.
+	*/
+	parse(value) {
+		return getNumberParserImpl(this.locale, this.options, value).parse(value);
+	}
+	/**
+	* Returns whether the given string could potentially be a valid number. This should be used to
+	* validate user input as the user types. If a `minValue` or `maxValue` is provided, the validity
+	* of the minus/plus sign characters can be checked.
+	*/
+	isValidPartialNumber(value, minValue, maxValue) {
+		return getNumberParserImpl(this.locale, this.options, value).isValidPartialNumber(value, minValue, maxValue);
+	}
+	/**
+	* Returns a numbering system for which the given string is valid in the current locale.
+	* If no numbering system could be detected, the default numbering system for the current
+	* locale is returned.
+	*/
+	getNumberingSystem(value) {
+		return getNumberParserImpl(this.locale, this.options, value).options.numberingSystem;
+	}
+};
+const numberParserCache = /* @__PURE__ */ new Map();
+function getNumberParserImpl(locale, options, value) {
+	let defaultParser = getCachedNumberParser(locale, options);
+	if (!locale.includes("-nu-") && !defaultParser.isValidPartialNumber(value)) {
+		for (let numberingSystem of NUMBERING_SYSTEMS) if (numberingSystem !== defaultParser.options.numberingSystem) {
+			let parser = getCachedNumberParser(locale + (locale.includes("-u-") ? "-nu-" : "-u-nu-") + numberingSystem, options);
+			if (parser.isValidPartialNumber(value)) return parser;
+		}
+	}
+	return defaultParser;
+}
+function getCachedNumberParser(locale, options) {
+	let cacheKey = locale + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : "");
+	let parser = numberParserCache.get(cacheKey);
+	if (!parser) {
+		parser = new NumberParserImpl(locale, options);
+		numberParserCache.set(cacheKey, parser);
+	}
+	return parser;
+}
+var NumberParserImpl = class {
+	formatter;
+	options;
+	symbols;
+	locale;
+	constructor(locale, options = {}) {
+		this.locale = locale;
+		if (options.roundingIncrement !== 1 && options.roundingIncrement != null) {
+			if (options.maximumFractionDigits == null && options.minimumFractionDigits == null) {
+				options.maximumFractionDigits = 0;
+				options.minimumFractionDigits = 0;
+			} else if (options.maximumFractionDigits == null) options.maximumFractionDigits = options.minimumFractionDigits;
+			else if (options.minimumFractionDigits == null) options.minimumFractionDigits = options.maximumFractionDigits;
+		}
+		this.formatter = new Intl.NumberFormat(locale, options);
+		this.options = this.formatter.resolvedOptions();
+		this.symbols = getSymbols(locale, this.formatter, this.options, options);
+		if (this.options.style === "percent" && ((this.options.minimumFractionDigits ?? 0) > 18 || (this.options.maximumFractionDigits ?? 0) > 18)) console.warn("NumberParser cannot handle percentages with greater than 18 decimal places, please reduce the number in your options.");
+	}
+	parse(value) {
+		let isGroupSymbolAllowed = this.formatter.resolvedOptions().useGrouping;
+		let fullySanitizedValue = this.sanitize(value);
+		if (!isGroupSymbolAllowed && this.symbols.group && fullySanitizedValue.includes(this.symbols.group)) return NaN;
+		else if (this.symbols.group) fullySanitizedValue = fullySanitizedValue.replaceAll(this.symbols.group, "");
+		if (this.symbols.decimal) fullySanitizedValue = fullySanitizedValue.replace(this.symbols.decimal, ".");
+		if (this.symbols.minusSign) fullySanitizedValue = fullySanitizedValue.replace(this.symbols.minusSign, "-");
+		fullySanitizedValue = fullySanitizedValue.replace(this.symbols.numeral, this.symbols.index);
+		if (this.options.style === "percent") {
+			let isNegative = fullySanitizedValue.indexOf("-");
+			fullySanitizedValue = fullySanitizedValue.replace("-", "");
+			fullySanitizedValue = fullySanitizedValue.replace("+", "");
+			let index = fullySanitizedValue.indexOf(".");
+			if (index === -1) index = fullySanitizedValue.length;
+			fullySanitizedValue = fullySanitizedValue.replace(".", "");
+			if (index - 2 === 0) fullySanitizedValue = `0.${fullySanitizedValue}`;
+			else if (index - 2 === -1) fullySanitizedValue = `0.0${fullySanitizedValue}`;
+			else if (index - 2 === -2) fullySanitizedValue = "0.00";
+			else fullySanitizedValue = `${fullySanitizedValue.slice(0, index - 2)}.${fullySanitizedValue.slice(index - 2)}`;
+			if (isNegative > -1) fullySanitizedValue = `-${fullySanitizedValue}`;
+		}
+		let newValue = fullySanitizedValue ? +fullySanitizedValue : NaN;
+		if (isNaN(newValue)) return NaN;
+		if (this.options.style === "percent") {
+			let options = {
+				...this.options,
+				style: "decimal",
+				minimumFractionDigits: Math.min((this.options.minimumFractionDigits ?? 0) + 2, 20),
+				maximumFractionDigits: Math.min((this.options.maximumFractionDigits ?? 0) + 2, 20)
+			};
+			return new NumberParser(this.locale, options).parse(new NumberFormatter(this.locale, options).format(newValue));
+		}
+		if (this.options.currencySign === "accounting" && CURRENCY_SIGN_REGEX.test(value)) newValue = -1 * newValue;
+		return newValue;
+	}
+	sanitize(value) {
+		let isGroupSymbolAllowed = this.formatter.resolvedOptions().useGrouping;
+		if (this.symbols.noNumeralUnits.length > 0 && this.symbols.noNumeralUnits.find((obj) => obj.unit === value)) return this.symbols.noNumeralUnits.find((obj) => obj.unit === value).value.toString();
+		value = value.replace(this.symbols.literals, "");
+		if (this.symbols.minusSign) value = value.replace("-", this.symbols.minusSign);
+		if (this.options.numberingSystem === "arab") {
+			if (this.symbols.decimal) {
+				value = replaceAll(value, ",", this.symbols.decimal);
+				value = replaceAll(value, String.fromCharCode(1548), this.symbols.decimal);
+			}
+			if (this.symbols.group && isGroupSymbolAllowed) value = replaceAll(value, ".", this.symbols.group);
+		}
+		if (this.symbols.group === "’" && value.includes("'") && isGroupSymbolAllowed) value = replaceAll(value, "'", this.symbols.group);
+		if (this.symbols.group === "'" && value.includes("’") && isGroupSymbolAllowed) value = replaceAll(value, "’", this.symbols.group);
+		if (this.options.locale === "fr-FR" && this.symbols.group && isGroupSymbolAllowed) {
+			value = replaceAll(value, " ", this.symbols.group);
+			value = replaceAll(value, /\u00A0/g, this.symbols.group);
+		}
+		return value;
+	}
+	isValidPartialNumber(value, minValue = -Infinity, maxValue = Infinity) {
+		let isGroupSymbolAllowed = this.formatter.resolvedOptions().useGrouping;
+		value = this.sanitize(value);
+		if (this.symbols.minusSign && value.startsWith(this.symbols.minusSign) && minValue < 0) value = value.slice(this.symbols.minusSign.length);
+		else if (this.symbols.plusSign && value.startsWith(this.symbols.plusSign) && maxValue > 0) value = value.slice(this.symbols.plusSign.length);
+		if (this.symbols.decimal && value.indexOf(this.symbols.decimal) > -1 && this.options.maximumFractionDigits === 0) return false;
+		if (this.symbols.group && isGroupSymbolAllowed) value = replaceAll(value, this.symbols.group, "");
+		value = value.replace(this.symbols.numeral, "");
+		if (this.symbols.decimal) value = value.replace(this.symbols.decimal, "");
+		return value.length === 0;
+	}
+};
+const nonLiteralParts = new Set([
+	"decimal",
+	"fraction",
+	"integer",
+	"minusSign",
+	"plusSign",
+	"group"
+]);
+const pluralNumbers = [
+	0,
+	4,
+	2,
+	1,
+	11,
+	20,
+	3,
+	7,
+	100,
+	21,
+	.1,
+	1.1
+];
+function getSymbols(locale, formatter, intlOptions, originalOptions) {
+	let symbolFormatter = new Intl.NumberFormat(locale, {
+		...intlOptions,
+		minimumSignificantDigits: 1,
+		maximumSignificantDigits: 21,
+		roundingIncrement: 1,
+		roundingPriority: "auto",
+		roundingMode: "halfExpand",
+		useGrouping: true
+	});
+	let allParts = symbolFormatter.formatToParts(-10000.111);
+	let posAllParts = symbolFormatter.formatToParts(10000.111);
+	let pluralParts = pluralNumbers.map((n) => symbolFormatter.formatToParts(n));
+	let noNumeralUnits = pluralParts.map((p, i) => {
+		let unit = p.find((p) => p.type === "unit");
+		if (unit && !p.some((p) => p.type === "integer" || p.type === "fraction")) return {
+			unit: unit.value,
+			value: pluralNumbers[i]
+		};
+		return null;
+	}).filter((p) => !!p);
+	let minusSign = allParts.find((p) => p.type === "minusSign")?.value ?? "-";
+	let plusSign = posAllParts.find((p) => p.type === "plusSign")?.value;
+	if (!plusSign && (originalOptions?.signDisplay === "exceptZero" || originalOptions?.signDisplay === "always")) plusSign = "+";
+	let decimal = new Intl.NumberFormat(locale, {
+		...intlOptions,
+		minimumFractionDigits: 2,
+		maximumFractionDigits: 2
+	}).formatToParts(.001).find((p) => p.type === "decimal")?.value;
+	let group = allParts.find((p) => p.type === "group")?.value;
+	let allPartsLiterals = allParts.filter((p) => !nonLiteralParts.has(p.type)).map((p) => escapeRegex(p.value));
+	let pluralPartsLiterals = pluralParts.flatMap((p) => p.filter((p) => !nonLiteralParts.has(p.type)).map((p) => escapeRegex(p.value)));
+	let sortedLiterals = [...new Set([...allPartsLiterals, ...pluralPartsLiterals])].sort((a, b) => b.length - a.length);
+	let literals = sortedLiterals.length === 0 ? /* @__PURE__ */ new RegExp("\\p{White_Space}|\\p{Cf}", "gu") : new RegExp(`${sortedLiterals.join("|")}|\\p{White_Space}|\\p{Cf}`, "gu");
+	let numerals = [...new Intl.NumberFormat(intlOptions.locale, { useGrouping: false }).format(9876543210)].reverse();
+	let indexes = new Map(numerals.map((d, i) => [d, i]));
+	let numeral = new RegExp(`[${numerals.join("")}]`, "g");
+	let index = (d) => String(indexes.get(d));
+	return {
+		minusSign,
+		plusSign,
+		decimal,
+		group,
+		literals,
+		numeral,
+		numerals,
+		index,
+		noNumeralUnits
+	};
+}
+function replaceAll(str, find, replace) {
+	if (str.replaceAll) return str.replaceAll(find, replace);
+	return str.split(find).join(replace);
+}
+function escapeRegex(string) {
+	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+export { NumberParser };

package/dist/number.d.ts

@@ -0,0 +1,3 @@
+import { NumberFormatOptions, NumberFormatter } from "./number/NumberFormatter.js";
+import { NumberParser } from "./number/NumberParser.js";
+export { type NumberFormatOptions, NumberFormatter, NumberParser };

package/dist/number.js

@@ -0,0 +1,3 @@
+import { NumberFormatter } from "./number/NumberFormatter.js";
+import { NumberParser } from "./number/NumberParser.js";
+export { NumberFormatter, NumberParser };

package/dist/react.d.ts

@@ -0,0 +1,17 @@
+import { DateFormatter } from "./date/DateFormatter.js";
+import { useIsSSR } from "./ssr/use-is-ssr.js";
+import { LocalizedStringDictionary, LocalizedStrings } from "./string/LocalizedStringDictionary.js";
+import { LocalizedString, LocalizedStringFormatter, Variables } from "./string/LocalizedStringFormatter.js";
+import { Locale, TextDirection, isRTL } from "./i18n/utils.js";
+import { LocaleContext, LocaleContextValue, useLocaleContext } from "./i18n/context.js";
+import { useCollator } from "./i18n/use-collator.js";
+import { DateFormatterOptions, useDateFormatter } from "./i18n/use-date-formatter.js";
+import { useDeepMemo } from "./i18n/use-deep-memo.js";
+import { Filter, useFilter } from "./i18n/use-filter.js";
+import { useListFormatter } from "./i18n/use-list-formatter.js";
+import { useLocale } from "./i18n/use-locale.js";
+import { useLocalizedStringDictionary, useLocalizedStringFormatter } from "./i18n/use-localized-string-formatter.js";
+import { NumberFormatter } from "./number/NumberFormatter.js";
+import { NumberParser } from "./number/NumberParser.js";
+import { NumberFormatOptions, useNumberFormatter } from "./i18n/use-number-formatter.js";
+export { DateFormatter, type DateFormatterOptions, type Filter, type Locale, LocaleContext, type LocaleContextValue, type LocalizedString, LocalizedStringDictionary, LocalizedStringFormatter, type LocalizedStrings, type NumberFormatOptions, NumberFormatter, NumberParser, type TextDirection, type Variables, isRTL, useCollator, useDateFormatter, useDeepMemo, useFilter, useIsSSR, useListFormatter, useLocale, useLocaleContext, useLocalizedStringDictionary, useLocalizedStringFormatter, useNumberFormatter };

package/dist/react.js

@@ -0,0 +1,17 @@
+import { DateFormatter } from "./date/DateFormatter.js";
+import { NumberFormatter } from "./number/NumberFormatter.js";
+import { NumberParser } from "./number/NumberParser.js";
+import { LocalizedStringDictionary } from "./string/LocalizedStringDictionary.js";
+import { LocalizedStringFormatter } from "./string/LocalizedStringFormatter.js";
+import { isRTL } from "./i18n/utils.js";
+import { useIsSSR } from "./ssr/use-is-ssr.js";
+import { LocaleContext, useLocaleContext } from "./i18n/context.js";
+import { useLocale } from "./i18n/use-locale.js";
+import { useCollator } from "./i18n/use-collator.js";
+import { useDeepMemo } from "./i18n/use-deep-memo.js";
+import { useDateFormatter } from "./i18n/use-date-formatter.js";
+import { useFilter } from "./i18n/use-filter.js";
+import { useListFormatter } from "./i18n/use-list-formatter.js";
+import { useLocalizedStringDictionary, useLocalizedStringFormatter } from "./i18n/use-localized-string-formatter.js";
+import { useNumberFormatter } from "./i18n/use-number-formatter.js";
+export { DateFormatter, LocaleContext, LocalizedStringDictionary, LocalizedStringFormatter, NumberFormatter, NumberParser, isRTL, useCollator, useDateFormatter, useDeepMemo, useFilter, useIsSSR, useListFormatter, useLocale, useLocaleContext, useLocalizedStringDictionary, useLocalizedStringFormatter, useNumberFormatter };

package/dist/ssr/use-is-ssr.d.ts

@@ -0,0 +1,8 @@
+//#region src/ssr/use-is-ssr.d.ts
+/**
+ * Returns whether the component is server-rendering or hydrating, so browser-only rendering can be
+ * deferred until after hydration. Re-implemented from Adobe's react-aria (Apache-2.0; see NOTICE.txt).
+ */
+declare function useIsSSR(): boolean;
+//#endregion
+export { useIsSSR };

package/dist/ssr/use-is-ssr.js

@@ -0,0 +1,15 @@
+"use client";
+import { useSyncExternalStore } from "react";
+//#region src/ssr/use-is-ssr.ts
+const subscribe = () => () => {};
+const getSnapshot = () => false;
+const getServerSnapshot = () => true;
+/**
+* Returns whether the component is server-rendering or hydrating, so browser-only rendering can be
+* deferred until after hydration. Re-implemented from Adobe's react-aria (Apache-2.0; see NOTICE.txt).
+*/
+function useIsSSR() {
+	return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+//#endregion
+export { useIsSSR };

package/dist/string/LocalizedStringDictionary.d.ts

@@ -0,0 +1,22 @@
+import { LocalizedString } from "./LocalizedStringFormatter.js";
+
+//#region src/string/LocalizedStringDictionary.d.ts
+type LocalizedStrings<K extends string, T extends LocalizedString> = {
+  [lang: string]: Record<K, T>;
+};
+/**
+ * Stores a mapping of localized strings. Can be used to find the
+ * closest available string for a given locale.
+ */
+declare class LocalizedStringDictionary<K extends string = string, T extends LocalizedString = string> {
+  private strings;
+  private defaultLocale;
+  constructor(messages: LocalizedStrings<K, T>, defaultLocale?: string);
+  /** Returns a localized string for the given key and locale. */
+  getStringForLocale(key: K, locale: string): T;
+  /** Returns all localized strings for the given locale. */
+  getStringsForLocale(locale: string): Record<K, T>;
+  static getGlobalDictionaryForPackage<K extends string = string, T extends LocalizedString = string>(packageName: string): LocalizedStringDictionary<K, T> | null;
+}
+//#endregion
+export { LocalizedStringDictionary, LocalizedStrings };

package/dist/string/LocalizedStringDictionary.js

@@ -0,0 +1,58 @@
+//#region src/string/LocalizedStringDictionary.ts
+const localeSymbol = Symbol.for("react-aria.i18n.locale");
+const stringsSymbol = Symbol.for("react-aria.i18n.strings");
+let cachedGlobalStrings = void 0;
+/**
+* Stores a mapping of localized strings. Can be used to find the
+* closest available string for a given locale.
+*/
+var LocalizedStringDictionary = class LocalizedStringDictionary {
+	strings;
+	defaultLocale;
+	constructor(messages, defaultLocale = "en-US") {
+		this.strings = Object.fromEntries(Object.entries(messages).filter(([, v]) => v));
+		this.defaultLocale = defaultLocale;
+	}
+	/** Returns a localized string for the given key and locale. */
+	getStringForLocale(key, locale) {
+		let string = this.getStringsForLocale(locale)[key];
+		if (!string) throw new Error(`Could not find intl message ${key} in ${locale} locale`);
+		return string;
+	}
+	/** Returns all localized strings for the given locale. */
+	getStringsForLocale(locale) {
+		let strings = this.strings[locale];
+		if (!strings) {
+			strings = getStringsForLocale(locale, this.strings, this.defaultLocale);
+			this.strings[locale] = strings;
+		}
+		return strings;
+	}
+	static getGlobalDictionaryForPackage(packageName) {
+		if (typeof window === "undefined") return null;
+		let globalWindow = window;
+		let locale = globalWindow[localeSymbol];
+		if (cachedGlobalStrings === void 0) {
+			let globalStrings = globalWindow[stringsSymbol];
+			if (!globalStrings) return null;
+			cachedGlobalStrings = {};
+			for (let pkg in globalStrings) cachedGlobalStrings[pkg] = new LocalizedStringDictionary({ [locale]: globalStrings[pkg] }, locale);
+		}
+		let dictionary = cachedGlobalStrings?.[packageName];
+		if (!dictionary) throw new Error(`Strings for package "${packageName}" were not included by LocalizedStringProvider. Please add it to the list passed to createLocalizedStringDictionary.`);
+		return dictionary;
+	}
+};
+function getStringsForLocale(locale, strings, defaultLocale = "en-US") {
+	if (strings[locale]) return strings[locale];
+	let language = getLanguage(locale);
+	if (strings[language]) return strings[language];
+	for (let key in strings) if (key.startsWith(language + "-")) return strings[key];
+	return strings[defaultLocale];
+}
+function getLanguage(locale) {
+	if (Intl.Locale) return new Intl.Locale(locale).language;
+	return locale.split("-")[0];
+}
+//#endregion
+export { LocalizedStringDictionary };

package/dist/string/LocalizedStringFormatter.d.ts

@@ -0,0 +1,22 @@
+import { LocalizedStringDictionary } from "./LocalizedStringDictionary.js";
+
+//#region src/string/LocalizedStringFormatter.d.ts
+type Variables = Record<string, string | number | boolean> | undefined;
+type LocalizedString = string | ((args: Variables, formatter?: LocalizedStringFormatter<any, any>) => string);
+type InternalString = string | (() => string);
+/**
+ * Formats localized strings from a LocalizedStringDictionary. Supports interpolating variables,
+ * selecting the correct pluralization, and formatting numbers for the locale.
+ */
+declare class LocalizedStringFormatter<K extends string = string, T extends LocalizedString = string> {
+  private locale;
+  private strings;
+  constructor(locale: string, strings: LocalizedStringDictionary<K, T>);
+  /** Formats a localized string for the given key with the provided variables. */
+  format(key: K, variables?: Variables): string;
+  protected plural(count: number, options: Record<string, InternalString>, type?: Intl.PluralRuleType): string;
+  protected number(value: number): string;
+  protected select(options: Record<string, InternalString>, value: string): string;
+}
+//#endregion
+export { LocalizedString, LocalizedStringFormatter, Variables };

package/dist/string/LocalizedStringFormatter.js

@@ -0,0 +1,46 @@
+//#region src/string/LocalizedStringFormatter.ts
+const pluralRulesCache = /* @__PURE__ */ new Map();
+const numberFormatCache = /* @__PURE__ */ new Map();
+/**
+* Formats localized strings from a LocalizedStringDictionary. Supports interpolating variables,
+* selecting the correct pluralization, and formatting numbers for the locale.
+*/
+var LocalizedStringFormatter = class {
+	locale;
+	strings;
+	constructor(locale, strings) {
+		this.locale = locale;
+		this.strings = strings;
+	}
+	/** Formats a localized string for the given key with the provided variables. */
+	format(key, variables) {
+		let message = this.strings.getStringForLocale(key, this.locale);
+		return typeof message === "function" ? message(variables, this) : message;
+	}
+	plural(count, options, type = "cardinal") {
+		let opt = options["=" + count];
+		if (opt) return typeof opt === "function" ? opt() : opt;
+		let key = this.locale + ":" + type;
+		let pluralRules = pluralRulesCache.get(key);
+		if (!pluralRules) {
+			pluralRules = new Intl.PluralRules(this.locale, { type });
+			pluralRulesCache.set(key, pluralRules);
+		}
+		opt = options[pluralRules.select(count)] || options.other;
+		return typeof opt === "function" ? opt() : opt;
+	}
+	number(value) {
+		let numberFormat = numberFormatCache.get(this.locale);
+		if (!numberFormat) {
+			numberFormat = new Intl.NumberFormat(this.locale);
+			numberFormatCache.set(this.locale, numberFormat);
+		}
+		return numberFormat.format(value);
+	}
+	select(options, value) {
+		let opt = options[value] || options.other;
+		return typeof opt === "function" ? opt() : opt;
+	}
+};
+//#endregion
+export { LocalizedStringFormatter };

package/dist/string.d.ts

@@ -0,0 +1,3 @@
+import { LocalizedStringDictionary, LocalizedStrings } from "./string/LocalizedStringDictionary.js";
+import { LocalizedString, LocalizedStringFormatter, Variables } from "./string/LocalizedStringFormatter.js";
+export { type LocalizedString, LocalizedStringDictionary, LocalizedStringFormatter, type LocalizedStrings, type Variables };