cluaupp 1.0.0 → 1.4.0

package/runtime/FormatNumber/Main/DecimalFormatSymbols.lua

@@ -1,43 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

@@ -1,179 +0,0 @@
-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

@@ -1,199 +0,0 @@
-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

@@ -1,76 +0,0 @@
--- 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)