cluaupp 0.1.0

package/runtime/FormatNumber/Version.lua

@@ -0,0 +1,82 @@
+--[[
+FormatNumber
+Version 31.1
+BSD 2-Clause Licence
+Copyright 2022 - Blockzez (https://devforum.roblox.com/u/Blockzez and https://github.com/Blockzez)
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+]]
+local FormatNumberVersion = { }
+export type FormatNumberVersion = {
+	Major: number,
+	Minor: number,
+}
+
+local function version_tostring(self)
+	return string.format("%d.%d", self.Major, self.Minor)
+end
+
+local function version_lt(lhs, rhs)
+	return if lhs.Major == rhs.Major
+	then lhs.Minor < rhs.Minor
+	else lhs.Major < rhs.Major
+end
+
+local function version_eq(lhs, rhs)
+	return lhs.Major == rhs.Major and lhs.Minor == rhs.Minor
+end
+
+local function double_to_int32(value: number): number
+	-- relying on UDim.new integer conversion semantic
+	-- if you get weird behaviour for values out of the int32 range
+	-- or you put the wrong value in, it's on you.
+	if math.clamp(tonumber(value) or 0, -0x80000000, 0x7FFFFFFF) ~= value then
+		return UDim.new(nil, value).Offset
+	elseif value <= -1 then
+		return math.ceil(value)
+	elseif value >= 1 then
+		return math.floor(value)
+	end
+	return 0
+end
+
+function FormatNumberVersion.new(major: number, minor: number): FormatNumberVersion
+	local object = newproxy(true)
+	local object_meta = getmetatable(object)
+
+	object_meta.__index = {
+		Major = double_to_int32(major),
+		Minor = double_to_int32(minor),
+	}
+	object_meta.__metatable = "The metatable is locked"
+	object_meta.__tostring = version_tostring
+	object_meta.__lt = version_lt
+	object_meta.__eq = version_eq
+	table.freeze(object_meta)
+
+	return object
+end
+
+FormatNumberVersion.current = FormatNumberVersion.new(31, 1)
+
+return table.freeze(FormatNumberVersion)

package/runtime/FormatNumber/_impl/LICENSE.md

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2022, Blockzez
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/runtime/FormatNumber/_impl/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/_impl/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/_impl/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/_impl/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/_impl/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,
+})