cluaupp 1.0.0 → 1.4.0

package/runtime/FormatNumber/Version.lua

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

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

@@ -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/_impl/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/_impl/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/_impl/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/_impl/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,
-})