cluaupp 0.1.0

package/runtime/FormatNumber/Main/DecimalFormatSymbols.lua

@@ -0,0 +1,43 @@
+local _internal = require(script.Parent.Parent._internal)
+
+local DecimalFormatSymbols = { }
+local DecimalFormatSymbols_methods = { }
+local DecimalFormatSymbols_new = _internal.class.create_init_function(
+	"DecimalFormatSymbols", nil,
+	DecimalFormatSymbols_methods, nil,
+	_internal.class.ImmutabilityType.SYMBOLS
+)
+
+function DecimalFormatSymbols_methods.GetSymbol(self: DecimalFormatSymbols, symbol: number): string
+	local c_self = _internal.class.try_coerce(1, self, "DecimalFormatSymbols")
+	symbol = _internal.class.try_coerce_enum(2, symbol, _internal.enums.ENumberFormatSymbols)
+
+	return c_self[symbol]
+end
+
+function DecimalFormatSymbols_methods.SetSymbol(self: DecimalFormatSymbols, symbol: number, value: string)
+	local c_self = _internal.class.try_coerce(1, self, "DecimalFormatSymbols")
+	symbol = _internal.class.try_coerce_enum(2, symbol, _internal.enums.ENumberFormatSymbols)
+	value = _internal.class.try_coerce(3, value, "string")
+
+	c_self[symbol] = value
+end
+
+
+function DecimalFormatSymbols.createWithLastResortData(): DecimalFormatSymbols
+	return DecimalFormatSymbols_new({
+		[_internal.enums.ENumberFormatSymbols.kDecimalSeparatorSymbol] = ".",
+		[_internal.enums.ENumberFormatSymbols.kGroupingSeparatorSymbol] = "",
+		[_internal.enums.ENumberFormatSymbols.kMinusSignSymbol] = "-",
+		[_internal.enums.ENumberFormatSymbols.kPlusSignSymbol] = "+",
+		[_internal.enums.ENumberFormatSymbols.kExponentialSymbol] = "E",
+		[_internal.enums.ENumberFormatSymbols.kInfinitySymbol] = "∞",
+		[_internal.enums.ENumberFormatSymbols.kNaNSymbol] = "\u{FFFD}",
+	})
+end
+
+export type DecimalFormatSymbols = {
+	GetSymbol: typeof(DecimalFormatSymbols_methods.GetSymbol),
+	SetSymbol: typeof(DecimalFormatSymbols_methods.SetSymbol),
+}
+return table.freeze(DecimalFormatSymbols)

package/runtime/FormatNumber/Main/IntegerWidth.lua

@@ -0,0 +1,41 @@
+local _internal = require(script.Parent.Parent._internal)
+
+local IntegerWidth = { }
+local IntegerWidth_methods = { }
+local IntegerWidth_new = _internal.class.create_init_function(
+	"IntegerWidth",
+	nil,
+	IntegerWidth_methods, nil,
+	_internal.class.ImmutabilityType.DEFAULT
+)
+
+function IntegerWidth_methods.TruncateAt(self: IntegerWidth, maxInt: number): IntegerWidth
+	local c_self = _internal.class.try_coerce(1, self, "IntegerWidth")
+
+	if tonumber(maxInt) and math.ceil(maxInt) == -1 then
+		-- special case
+		maxInt = -1
+	else
+		maxInt = _internal.class.try_coerce_range(1, maxInt, c_self.min, 999)
+	end
+
+	return IntegerWidth_new({
+		min = c_self.min,
+		max = maxInt,
+	})
+end
+
+
+function IntegerWidth.zeroFillTo(minInt: number): IntegerWidth
+	minInt = _internal.class.try_coerce_range(1, minInt, 0, 999)
+
+	return IntegerWidth_new({
+		min = minInt,
+		max = -1,
+	})
+end
+
+export type IntegerWidth = {
+	TruncateAt: typeof(IntegerWidth_methods.TruncateAt),
+}
+return table.freeze(IntegerWidth)

package/runtime/FormatNumber/Main/Notation.lua

@@ -0,0 +1,116 @@
+local _internal = require(script.Parent.Parent._internal)
+
+local Notation = { }
+local Notation_methods = { }
+local Notation_new = _internal.class.create_init_function(
+	"Notation",
+	nil,
+	Notation, nil,
+	_internal.class.ImmutabilityType.DEFAULT
+)
+
+
+local ScientificNotation_methods = { }
+local ScientificNotation_new = _internal.class.create_init_function(
+	"ScientificNotation",
+	"Notation",
+	ScientificNotation_methods, Notation_methods,
+	_internal.class.ImmutabilityType.DEFAULT
+)
+
+function ScientificNotation_methods.WithMinExponentDigits(self: ScientificNotation, minExponentDigits: number): ScientificNotation
+	local c_self = _internal.class.try_coerce(1, self, "ScientificNotation")
+	minExponentDigits = _internal.class.try_coerce_range(2, minExponentDigits, 1, 999)
+
+	c_self = table.clone(c_self)
+	c_self.minExponentDigits = minExponentDigits
+
+	return ScientificNotation_new(c_self)
+end
+
+function ScientificNotation_methods.WithExponentSignDisplay(self: ScientificNotation, exponentSignDisplay: number): ScientificNotation
+	local c_self = _internal.class.try_coerce(1, self, "ScientificNotation")
+	exponentSignDisplay = _internal.class.try_coerce_enum(2, exponentSignDisplay, _internal.enums.SignDisplay)
+
+	c_self = table.clone(c_self)
+	c_self.exponentSignDisplay = exponentSignDisplay
+	c_self.displayExponentSignAt = _internal.formatter_settings.generate_from_sign_enum(exponentSignDisplay)
+
+	return ScientificNotation_new(c_self)
+end
+
+
+-- reserved
+local CompactNotation_methods = { }
+local CompactNotation_new = _internal.class.create_init_function(
+	"CompactNotation", "Notation",
+	CompactNotation_methods, Notation_methods,
+	_internal.class.ImmutabilityType.DEFAULT
+)
+
+
+-- reserved
+local SimpleNotation_methods = { }
+local SimpleNotation_new = _internal.class.create_init_function(
+	"SimpleNotation", "Notation",
+	SimpleNotation_methods, Notation_methods,
+	_internal.class.ImmutabilityType.DEFAULT
+)
+
+
+function Notation.scientific(): ScientificNotation
+	return ScientificNotation_new({
+		type = _internal.enums._Internal.NotationType.SCIENTIFIC,
+		power10Scale = 1,
+		minExponentDigits = 1,
+		exponentSignDisplay = _internal.enums.SignDisplay.AUTO,
+		displayExponentSignAt = _internal.formatter_settings.generate_from_sign_enum(
+			_internal.enums.SignDisplay.AUTO),
+	})
+end
+
+function Notation.engineering(): ScientificNotation
+	return ScientificNotation_new({
+		type = _internal.enums._Internal.NotationType.SCIENTIFIC,
+		power10Scale = 3,
+		minExponentDigits = 1,
+		exponentSignDisplay = _internal.enums.SignDisplay.AUTO,
+		displayExponentSignAt = _internal.formatter_settings.generate_from_sign_enum(
+			_internal.enums.SignDisplay.AUTO),
+	})
+end
+
+function Notation.compactWithSuffixThousands(suffixes: { string }): CompactNotation
+	local empty_string_p
+
+	suffixes = _internal.class.try_coerce(1, suffixes, "{string}")
+
+	empty_string_p = table.find(suffixes, "")
+	if empty_string_p then
+		error(string.format("Index %d is an empty string, please double check the suffixes", empty_string_p), 2)
+	elseif #suffixes == 0 then
+		error("Suffixes is empty", 2)
+	end
+
+	return Notation_new({
+		type = _internal.enums._Internal.NotationType.COMPACT,
+		power10Scale = 3,
+		suffixes = suffixes,
+		suffixesLength = #suffixes,
+	})
+end
+
+function Notation.simple(): SimpleNotation
+	return Notation_new({
+		type = _internal.enums._Internal.NotationType.SIMPLE,
+	})
+end
+
+export type Notation = { }
+export type ScientificNotation = {
+	WithMinExponentDigits: typeof(ScientificNotation_methods.WithMinExponentDigits),
+	WithExponentSignDisplay: typeof(ScientificNotation_methods.WithExponentSignDisplay)
+}
+export type CompactNotation = Notation
+export type SimpleNotation = Notation
+return table.freeze(Notation)

package/runtime/FormatNumber/Main/Precision.lua

@@ -0,0 +1,179 @@
+local _internal = require(script.Parent.Parent._internal)
+
+local Precision = { }
+local Precision_methods = { }
+local Precision_new = _internal.class.create_init_function(
+	"Precision", nil,
+	Precision_methods, nil,
+	_internal.class.ImmutabilityType.DEFAULT
+)
+
+
+local FractionPrecision_methods = { }
+local FractionPrecision_new = _internal.class.create_init_function(
+	"FractionPrecision", "Precision",
+	FractionPrecision_methods, Precision_methods,
+	_internal.class.ImmutabilityType.DEFAULT
+)
+
+function FractionPrecision_methods.WithMinDigits(self: FractionPrecision, minSignificantDigits: number): Precision
+	local c_self = _internal.class.try_coerce(1, self, "FractionPrecision")
+	minSignificantDigits = _internal.class.try_coerce_range(2, minSignificantDigits, 1, 999)
+
+	return Precision_new({
+		type = _internal.enums._Internal.PrecisionType.FRACTION_SIGNIFICANT,
+		minFractionDigits = c_self.min,
+		maxFractionDigits = c_self.max,
+		minSignificantDigits = 1,
+		maxSignificantDigits = minSignificantDigits,
+		roundingPriority = _internal.enums.RoundingPriority.RELAXED,
+		sourcedWithSignificantDigits = false,
+	})
+end
+
+function FractionPrecision_methods.WithMaxDigits(self: FractionPrecision, maxSignificantDigits: number): Precision
+	local c_self = _internal.class.try_coerce(1, self, "FractionPrecision")
+	maxSignificantDigits = _internal.class.try_coerce_range(2, maxSignificantDigits, 1, 999)
+
+	return Precision_new({
+		type = _internal.enums._Internal.PrecisionType.FRACTION_SIGNIFICANT,
+		minFractionDigits = c_self.min,
+		maxFractionDigits = c_self.max,
+		minSignificantDigits = 1,
+		maxSignificantDigits = maxSignificantDigits,
+		roundingPriority = _internal.enums.RoundingPriority.STRICT,
+		sourcedWithSignificantDigits = false,
+	})
+end
+
+function FractionPrecision_methods.WithSignificantDigits(self: FractionPrecision,
+	minSignificantDigits: number, maxSignificantDigits: number, roundingPriority: number): Precision
+	local c_self = _internal.class.try_coerce(1, self, "FractionPrecision")
+	minSignificantDigits = _internal.class.try_coerce_range(2, minSignificantDigits, 1, 999)
+	maxSignificantDigits = _internal.class.try_coerce_range(3, maxSignificantDigits, 1, 999)
+	roundingPriority = _internal.class.try_coerce_enum(4, roundingPriority, _internal.enums.RoundingPriority)
+
+	return Precision_new({
+		type = _internal.enums._Internal.PrecisionType.FRACTION_SIGNIFICANT,
+		minFractionDigits = c_self.min,
+		maxFractionDigits = c_self.max,
+		minSignificantDigits = minSignificantDigits,
+		maxSignificantDigits = maxSignificantDigits,
+		roundingPriority = roundingPriority,
+		sourcedWithSignificantDigits = true,
+	})
+end
+
+-- reserved
+local SignificantDigitsPrecision_methods = { }
+local SignificantDigitsPrecision_new = _internal.class.create_init_function(
+	"SignificantDigitsPrecision", "Precision",
+	SignificantDigitsPrecision_methods, Precision_methods,
+	_internal.class.ImmutabilityType.DEFAULT
+)
+
+
+function Precision.unlimited(): Precision
+	return Precision_new({
+		type = _internal.enums._Internal.PrecisionType.UNLIMITED,
+	})
+end
+
+function Precision.integer(): FractionPrecision
+	return FractionPrecision_new({
+		type = _internal.enums._Internal.PrecisionType.FRACTION,
+		min = 0,
+		max = 0,
+	})
+end
+
+function Precision.fixedFraction(minMaxFractionPlaces: number): FractionPrecision
+	minMaxFractionPlaces = _internal.class.try_coerce_range(1, minMaxFractionPlaces, 0, 999)
+
+	return FractionPrecision_new({
+		type = _internal.enums._Internal.PrecisionType.FRACTION,
+		min = minMaxFractionPlaces,
+		max = minMaxFractionPlaces,
+	})
+end
+
+function Precision.minFraction(minFractionPlaces: number): FractionPrecision
+	minFractionPlaces = _internal.class.try_coerce_range(1, minFractionPlaces, 0, 999)
+
+	return FractionPrecision_new({
+		type = _internal.enums._Internal.PrecisionType.FRACTION,
+		min = minFractionPlaces,
+		max = _internal.formatter_settings.MAX_PRECISION,
+	})
+end
+
+function Precision.maxFraction(maxFractionPlaces: number): FractionPrecision
+	maxFractionPlaces = _internal.class.try_coerce_range(1, maxFractionPlaces, 0, 999)
+
+	return FractionPrecision_new({
+		type = _internal.enums._Internal.PrecisionType.FRACTION,
+		min = 0,
+		max = maxFractionPlaces,
+	})
+end
+
+function Precision.minMaxFraction(minFractionPlaces: number, maxFractionPlaces: number): FractionPrecision
+	minFractionPlaces = _internal.class.try_coerce_range(1, minFractionPlaces, 0, 999)
+	maxFractionPlaces = _internal.class.try_coerce_range(2, maxFractionPlaces, minFractionPlaces, 999)
+
+	return FractionPrecision_new({
+		type = _internal.enums._Internal.PrecisionType.FRACTION,
+		min = minFractionPlaces,
+		max = maxFractionPlaces,
+	})
+end
+
+function Precision.fixedSignificantDigits(minMaxSignificantDigits: number): SignificantDigitsPrecision
+	minMaxSignificantDigits = _internal.class.try_coerce_range(1, minMaxSignificantDigits, 1, 999)
+
+	return SignificantDigitsPrecision_new({
+		type = _internal.enums._Internal.PrecisionType.SIGNFICANT,
+		min = minMaxSignificantDigits,
+		max = minMaxSignificantDigits,
+	})
+end
+
+function Precision.minSignificantDigits(minSignificantDigits: number): SignificantDigitsPrecision
+	minSignificantDigits = _internal.class.try_coerce_range(1, minSignificantDigits, 1, 999)
+
+	return SignificantDigitsPrecision_new({
+		type = _internal.enums._Internal.PrecisionType.SIGNFICANT,
+		min = minSignificantDigits,
+		max = _internal.formatter_settings.MAX_PRECISION,
+	})
+end
+
+function Precision.maxSignificantDigits(maxSignificantDigits: number): SignificantDigitsPrecision
+	maxSignificantDigits = _internal.class.try_coerce_range(1, maxSignificantDigits, 1, 999)
+
+	return SignificantDigitsPrecision_new({
+		type = _internal.enums._Internal.PrecisionType.SIGNFICANT,
+		min = 1,
+		max = maxSignificantDigits,
+	})
+end
+
+function Precision.minMaxSignificantDigits(minSignificantDigits: number, maxSignificantDigits: number): SignificantDigitsPrecision
+	minSignificantDigits = _internal.class.try_coerce_range(1, minSignificantDigits, 1, 999)
+	maxSignificantDigits = _internal.class.try_coerce_range(2, maxSignificantDigits, minSignificantDigits, 999)
+
+	return SignificantDigitsPrecision_new({
+		type = _internal.enums._Internal.PrecisionType.SIGNFICANT,
+		min = minSignificantDigits,
+		max = maxSignificantDigits,
+	})
+end
+
+export type Precision = { }
+export type FractionPrecision = {
+	WithMinDigits: typeof(FractionPrecision_methods.WithMinDigits),
+	WithMaxDigits: typeof(FractionPrecision_methods.WithMaxDigits),
+	WithSignificantDigits: typeof(FractionPrecision_methods.WithSignificantDigits),
+}
+export type SignificantDigitsPrecision = { }
+return table.freeze(Precision)

package/runtime/FormatNumber/Main/init.lua

@@ -0,0 +1,199 @@
+local _internal = require(script.Parent._internal)
+local Notation = require(script.Notation)
+local Precision = require(script.Precision)
+local IntegerWidth = require(script.IntegerWidth)
+local DecimalFormatSymbols = require(script.DecimalFormatSymbols)
+
+local enums = _internal.enums
+
+export type Notation = Notation.Notation
+export type ScientificNotation = Notation.ScientificNotation
+export type Precision = Precision.Precision
+export type FractionPrecision = Precision.FractionPrecision
+export type IntegerWidth = IntegerWidth.IntegerWidth
+export type DecimalFormatSymbols = DecimalFormatSymbols.DecimalFormatSymbols
+
+local NumberFormatter = { }
+local NumberFormatter_methods = { }
+local NumberFormatter_new = _internal.class.create_init_function(
+	"NumberFormatter", nil,
+	NumberFormatter_methods, nil,
+	_internal.class.ImmutabilityType.NUMBER_FORMATTER
+)
+
+function NumberFormatter_methods.Notation(self: NumberFormatter, notation: Notation): NumberFormatter
+	_internal.class.try_coerce(1, self, "NumberFormatter")
+	notation = _internal.class.try_coerce(2, notation, "Notation")
+
+	return NumberFormatter_new({
+		key = "notation",
+		value = notation,
+		parent = _internal.class.get_data(self),
+	})
+end
+function NumberFormatter_methods.Precision(self: NumberFormatter, precision: Precision): NumberFormatter
+	_internal.class.try_coerce(1, self, "NumberFormatter")
+	precision = _internal.class.try_coerce(2, precision, "Precision")
+
+	return NumberFormatter_new({
+		key = "precision",
+		value = precision,
+		parent = _internal.class.get_data(self),
+	})
+end
+function NumberFormatter_methods.RoundingMode(self: NumberFormatter, roundingMode: number): NumberFormatter
+	_internal.class.try_coerce(1, self, "NumberFormatter")
+	roundingMode = _internal.class.try_coerce_enum(2, roundingMode, enums.RoundingMode)
+
+	return NumberFormatter_new({
+		key = "roundingMode",
+		value = roundingMode,
+		parent = _internal.class.get_data(self),
+	})
+end
+function NumberFormatter_methods.Grouping(self: NumberFormatter, strategy: number): NumberFormatter
+	_internal.class.try_coerce(1, self, "NumberFormatter")
+	strategy = _internal.class.try_coerce_enum(2, strategy, enums.GroupingStrategy)
+
+	return NumberFormatter_new({
+		key = "grouping",
+		value = strategy,
+		parent = _internal.class.get_data(self),
+	})
+end
+function NumberFormatter_methods.IntegerWidth(self: NumberFormatter, style: IntegerWidth): NumberFormatter
+	_internal.class.try_coerce(1, self, "NumberFormatter")
+	style = _internal.class.try_coerce(2, style, "IntegerWidth")
+
+	return NumberFormatter_new({
+		key = "integerWidth",
+		value = style,
+		parent = _internal.class.get_data(self),
+	})
+end
+function NumberFormatter_methods.Symbols(self: NumberFormatter, symbols: DecimalFormatSymbols): NumberFormatter
+	_internal.class.try_coerce(1, self, "NumberFormatter")
+	symbols = _internal.class.try_coerce(2, symbols, "DecimalFormatSymbols")
+
+	return NumberFormatter_new({
+		key = "symbols",
+		value = symbols,
+		parent = _internal.class.get_data(self),
+	})
+end
+function NumberFormatter_methods.Sign(self: NumberFormatter, style: number): NumberFormatter
+	_internal.class.try_coerce(1, self, "NumberFormatter")
+	style = _internal.class.try_coerce_enum(2, style, enums.SignDisplay)
+
+	return NumberFormatter_new({
+		key = "sign",
+		value = style,
+		parent = _internal.class.get_data(self),
+	})
+end
+function NumberFormatter_methods.Decimal(self: NumberFormatter, style: number): NumberFormatter
+	_internal.class.try_coerce(1, self, "NumberFormatter")
+	style = _internal.class.try_coerce_enum(2, style, enums.DecimalSeparatorDisplay)
+
+	return NumberFormatter_new({
+		key = "decimal",
+		value = style,
+		parent = _internal.class.get_data(self),
+	})
+end
+
+local function resolve_nf_data(data)
+	return _internal.formatter_settings.resolve_settings(
+		_internal.formatter_settings.linked_list_to_dict(data)
+	)
+end
+
+function NumberFormatter_methods.Format(self: NumberFormatter, value: number): string
+	local result
+	local internal_settings
+	local symbols
+	local is_negt, is_zero
+	local display_sign
+
+	_internal.class.try_coerce(1, self, "NumberFormatter")
+	if type(value) == "string" then
+		error("Argument #2 as a string interpreted as decimal is not currently supported, please cast the argument to a double if you want the string to be interpreted as a double", 2)
+	end
+	value = _internal.class.try_coerce(2, value, "number")
+
+	internal_settings = _internal.class.get_resolved_data(self, resolve_nf_data)
+	symbols = internal_settings.symbols
+
+	-- special values
+	if value ~= value then
+		-- Sign bit detection for NaN
+		-- NaN payload ignored
+		is_negt = string.byte(string.pack(">d", value)) >= 0x80
+		-- intentionally set to true
+		is_zero = true
+		result = symbols[enums.ENumberFormatSymbols.kNaNSymbol]
+	elseif value == math.huge or value == -math.huge then
+		is_negt = value < 0
+		is_zero = false
+		result = symbols[enums.ENumberFormatSymbols.kInfinitySymbol]
+	else
+		local fmt, fmt_n, decimal_marker
+
+		if value == 0 then
+			is_negt = math.atan2(value, -1) < 0
+			fmt, fmt_n, decimal_marker = nil, 0, 1
+		else
+			is_negt = value < 0
+			fmt, fmt_n, decimal_marker =
+				_internal.decimal_conversion.from_double(math.abs(value))
+		end
+
+		result, is_zero = _internal.format.format_unsigned_finite(
+			fmt, fmt_n, decimal_marker, is_negt, internal_settings
+		)
+	end
+
+	result = _internal.format.display_sign(
+		result, is_negt, is_zero,
+		internal_settings.displaySignAt, internal_settings.symbols
+	)
+
+	return result
+end
+
+function NumberFormatter_methods.ToSkeleton(self: NumberFormatter): (boolean, string)
+	local c_self = _internal.class.try_coerce(1, self, "NumberFormatter")
+
+	return _internal.skeleton.settings_to_skeleton(
+		_internal.formatter_settings.linked_list_to_dict(c_self)
+	)
+end
+
+function NumberFormatter.with(): NumberFormatter
+	return NumberFormatter_new(nil)
+end
+
+function NumberFormatter.forSkeleton(skeleton: string): (boolean, string | NumberFormatter)
+	local success, result
+
+	skeleton = _internal.class.try_coerce(1, skeleton, "string")
+
+	success, result = _internal.skeleton.to_option_linked_list(skeleton)
+
+	return success, if success then NumberFormatter_new(result) else result
+end
+
+export type NumberFormatter = typeof(NumberFormatter_methods)
+return table.freeze({
+	NumberFormatter = table.freeze(NumberFormatter),
+	Notation = Notation,
+	Precision = Precision,
+	RoundingPriority = enums.RoundingPriority,
+	RoundingMode = enums.RoundingMode,
+	GroupingStrategy = enums.GroupingStrategy,
+	IntegerWidth = IntegerWidth,
+	DecimalFormatSymbols = DecimalFormatSymbols,
+	ENumberFormatSymbols = enums.ENumberFormatSymbols,
+	SignDisplay = enums.SignDisplay,
+	DecimalSeparatorDisplay = enums.DecimalSeparatorDisplay,
+})

package/runtime/FormatNumber/Simple/init.lua

@@ -0,0 +1,76 @@
+-- Configuration
+-- The suffixes for abbreviation in every power of thousands.
+local COMPACT_SUFFIX = {
+	"K", "M", "B", "T", "Qa", "Qi", "Sx", "Sp", "Oc", "No",
+}
+local CACHED_SKELETON_SETTINGS = true
+--
+
+local MainAPI = require(script.Parent.Main)
+local FormatNumberSimpleAPI = { }
+
+local SKELETON_CACHE = if CACHED_SKELETON_SETTINGS then { } else nil
+local COMPACT_SKELETON_CACHE = if CACHED_SKELETON_SETTINGS then { } else nil
+
+function FormatNumberSimpleAPI.Format(value: number, skeleton: string?): string
+	local success
+	local formatter = nil
+
+	assert(type(value) == "number", "Value provided must be a number")
+
+	if skeleton == nil then
+		skeleton = ""
+	end
+	assert(type(skeleton) == "string", "Skeleton provided must be a string")
+
+	if CACHED_SKELETON_SETTINGS then
+		formatter = SKELETON_CACHE[skeleton]
+	end
+
+	if not formatter then
+		success, formatter =
+			MainAPI.NumberFormatter.forSkeleton(skeleton)
+		assert(success, formatter :: string)
+
+		if CACHED_SKELETON_SETTINGS then
+			SKELETON_CACHE[skeleton] = formatter
+		end
+	end
+
+	return (formatter :: MainAPI.NumberFormatter):Format(value)
+end
+
+function FormatNumberSimpleAPI.FormatCompact(value: number, skeleton: string?): string
+	local success
+	local formatter = nil
+
+	assert(type(value) == "number", "Value provided must be a number")
+
+	if skeleton == nil then
+		skeleton = ""
+	end
+	assert(type(skeleton) == "string", "Skeleton provided must be a string")
+
+	if CACHED_SKELETON_SETTINGS then
+		formatter = COMPACT_SKELETON_CACHE[skeleton]
+	end
+
+	if not formatter then
+		success, formatter =
+			MainAPI.NumberFormatter.forSkeleton(skeleton)
+		assert(success, formatter :: string)
+
+		formatter = (formatter :: MainAPI.NumberFormatter)
+			:Notation(MainAPI.Notation.compactWithSuffixThousands(COMPACT_SUFFIX))
+
+		if CACHED_SKELETON_SETTINGS then
+			COMPACT_SKELETON_CACHE[skeleton] = formatter
+		end
+	end
+
+	assert(#COMPACT_SUFFIX ~= 0, "Please provide the suffix abbreviations for FormatCompact at the top of the Simple ModuleScript")
+
+	return formatter:Format(value)
+end
+
+return table.freeze(FormatNumberSimpleAPI)