NumberFormat.cpp 72 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610
  1. /*
  2. * Copyright (c) 2021, Tim Flynn <trflynn89@pm.me>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Array.h>
  7. #include <AK/Utf8View.h>
  8. #include <LibJS/Runtime/Array.h>
  9. #include <LibJS/Runtime/GlobalObject.h>
  10. #include <LibJS/Runtime/Intl/NumberFormat.h>
  11. #include <LibJS/Runtime/Intl/NumberFormatFunction.h>
  12. #include <LibUnicode/CurrencyCode.h>
  13. #include <LibUnicode/Locale.h>
  14. #include <math.h>
  15. #include <stdlib.h>
  16. namespace JS::Intl {
  17. Vector<StringView> const& NumberFormat::relevant_extension_keys()
  18. {
  19. // 15.3.3 Internal slots, https://tc39.es/ecma402/#sec-intl.numberformat-internal-slots
  20. // The value of the [[RelevantExtensionKeys]] internal slot is « "nu" ».
  21. static Vector<StringView> relevant_extension_keys { "nu"sv };
  22. return relevant_extension_keys;
  23. }
  24. // 15 NumberFormat Objects, https://tc39.es/ecma402/#numberformat-objects
  25. NumberFormat::NumberFormat(Object& prototype)
  26. : Object(prototype)
  27. {
  28. }
  29. void NumberFormat::visit_edges(Cell::Visitor& visitor)
  30. {
  31. Base::visit_edges(visitor);
  32. if (m_bound_format)
  33. visitor.visit(m_bound_format);
  34. }
  35. void NumberFormat::set_style(StringView style)
  36. {
  37. if (style == "decimal"sv)
  38. m_style = Style::Decimal;
  39. else if (style == "percent"sv)
  40. m_style = Style::Percent;
  41. else if (style == "currency"sv)
  42. m_style = Style::Currency;
  43. else if (style == "unit"sv)
  44. m_style = Style::Unit;
  45. else
  46. VERIFY_NOT_REACHED();
  47. }
  48. StringView NumberFormat::style_string() const
  49. {
  50. switch (m_style) {
  51. case Style::Decimal:
  52. return "decimal"sv;
  53. case Style::Percent:
  54. return "percent"sv;
  55. case Style::Currency:
  56. return "currency"sv;
  57. case Style::Unit:
  58. return "unit"sv;
  59. default:
  60. VERIFY_NOT_REACHED();
  61. }
  62. }
  63. void NumberFormat::set_currency_display(StringView currency_display)
  64. {
  65. m_resolved_currency_display.clear();
  66. if (currency_display == "code"sv)
  67. m_currency_display = CurrencyDisplay::Code;
  68. else if (currency_display == "symbol"sv)
  69. m_currency_display = CurrencyDisplay::Symbol;
  70. else if (currency_display == "narrowSymbol"sv)
  71. m_currency_display = CurrencyDisplay::NarrowSymbol;
  72. else if (currency_display == "name"sv)
  73. m_currency_display = CurrencyDisplay::Name;
  74. else
  75. VERIFY_NOT_REACHED();
  76. }
  77. StringView NumberFormat::resolve_currency_display()
  78. {
  79. if (m_resolved_currency_display.has_value())
  80. return *m_resolved_currency_display;
  81. switch (currency_display()) {
  82. case NumberFormat::CurrencyDisplay::Code:
  83. m_resolved_currency_display = currency();
  84. break;
  85. case NumberFormat::CurrencyDisplay::Symbol:
  86. m_resolved_currency_display = Unicode::get_locale_currency_mapping(data_locale(), currency(), Unicode::Style::Short);
  87. break;
  88. case NumberFormat::CurrencyDisplay::NarrowSymbol:
  89. m_resolved_currency_display = Unicode::get_locale_currency_mapping(data_locale(), currency(), Unicode::Style::Narrow);
  90. break;
  91. case NumberFormat::CurrencyDisplay::Name:
  92. m_resolved_currency_display = Unicode::get_locale_currency_mapping(data_locale(), currency(), Unicode::Style::Numeric);
  93. break;
  94. default:
  95. VERIFY_NOT_REACHED();
  96. }
  97. if (!m_resolved_currency_display.has_value())
  98. m_resolved_currency_display = currency();
  99. return *m_resolved_currency_display;
  100. }
  101. StringView NumberFormat::currency_display_string() const
  102. {
  103. VERIFY(m_currency_display.has_value());
  104. switch (*m_currency_display) {
  105. case CurrencyDisplay::Code:
  106. return "code"sv;
  107. case CurrencyDisplay::Symbol:
  108. return "symbol"sv;
  109. case CurrencyDisplay::NarrowSymbol:
  110. return "narrowSymbol"sv;
  111. case CurrencyDisplay::Name:
  112. return "name"sv;
  113. default:
  114. VERIFY_NOT_REACHED();
  115. }
  116. }
  117. void NumberFormat::set_currency_sign(StringView currency_sign)
  118. {
  119. if (currency_sign == "standard"sv)
  120. m_currency_sign = CurrencySign::Standard;
  121. else if (currency_sign == "accounting"sv)
  122. m_currency_sign = CurrencySign::Accounting;
  123. else
  124. VERIFY_NOT_REACHED();
  125. }
  126. StringView NumberFormat::currency_sign_string() const
  127. {
  128. VERIFY(m_currency_sign.has_value());
  129. switch (*m_currency_sign) {
  130. case CurrencySign::Standard:
  131. return "standard"sv;
  132. case CurrencySign::Accounting:
  133. return "accounting"sv;
  134. default:
  135. VERIFY_NOT_REACHED();
  136. }
  137. }
  138. void NumberFormat::set_unit_display(StringView unit_display)
  139. {
  140. if (unit_display == "short"sv)
  141. m_unit_display = UnitDisplay::Short;
  142. else if (unit_display == "narrow"sv)
  143. m_unit_display = UnitDisplay::Narrow;
  144. else if (unit_display == "long"sv)
  145. m_unit_display = UnitDisplay::Long;
  146. else
  147. VERIFY_NOT_REACHED();
  148. }
  149. StringView NumberFormat::unit_display_string() const
  150. {
  151. VERIFY(m_unit_display.has_value());
  152. switch (*m_unit_display) {
  153. case UnitDisplay::Short:
  154. return "short"sv;
  155. case UnitDisplay::Narrow:
  156. return "narrow"sv;
  157. case UnitDisplay::Long:
  158. return "long"sv;
  159. default:
  160. VERIFY_NOT_REACHED();
  161. }
  162. }
  163. StringView NumberFormat::rounding_type_string() const
  164. {
  165. switch (m_rounding_type) {
  166. case RoundingType::SignificantDigits:
  167. return "significantDigits"sv;
  168. case RoundingType::FractionDigits:
  169. return "fractionDigits"sv;
  170. case RoundingType::CompactRounding:
  171. return "compactRounding"sv;
  172. default:
  173. VERIFY_NOT_REACHED();
  174. }
  175. }
  176. void NumberFormat::set_notation(StringView notation)
  177. {
  178. if (notation == "standard"sv)
  179. m_notation = Notation::Standard;
  180. else if (notation == "scientific"sv)
  181. m_notation = Notation::Scientific;
  182. else if (notation == "engineering"sv)
  183. m_notation = Notation::Engineering;
  184. else if (notation == "compact"sv)
  185. m_notation = Notation::Compact;
  186. else
  187. VERIFY_NOT_REACHED();
  188. }
  189. StringView NumberFormat::notation_string() const
  190. {
  191. switch (m_notation) {
  192. case Notation::Standard:
  193. return "standard"sv;
  194. case Notation::Scientific:
  195. return "scientific"sv;
  196. case Notation::Engineering:
  197. return "engineering"sv;
  198. case Notation::Compact:
  199. return "compact"sv;
  200. default:
  201. VERIFY_NOT_REACHED();
  202. }
  203. }
  204. void NumberFormat::set_compact_display(StringView compact_display)
  205. {
  206. if (compact_display == "short"sv)
  207. m_compact_display = CompactDisplay::Short;
  208. else if (compact_display == "long"sv)
  209. m_compact_display = CompactDisplay::Long;
  210. else
  211. VERIFY_NOT_REACHED();
  212. }
  213. StringView NumberFormat::compact_display_string() const
  214. {
  215. VERIFY(m_compact_display.has_value());
  216. switch (*m_compact_display) {
  217. case CompactDisplay::Short:
  218. return "short"sv;
  219. case CompactDisplay::Long:
  220. return "long"sv;
  221. default:
  222. VERIFY_NOT_REACHED();
  223. }
  224. }
  225. void NumberFormat::set_sign_display(StringView sign_display)
  226. {
  227. if (sign_display == "auto"sv)
  228. m_sign_display = SignDisplay::Auto;
  229. else if (sign_display == "never"sv)
  230. m_sign_display = SignDisplay::Never;
  231. else if (sign_display == "always"sv)
  232. m_sign_display = SignDisplay::Always;
  233. else if (sign_display == "exceptZero"sv)
  234. m_sign_display = SignDisplay::ExceptZero;
  235. else
  236. VERIFY_NOT_REACHED();
  237. }
  238. StringView NumberFormat::sign_display_string() const
  239. {
  240. switch (m_sign_display) {
  241. case SignDisplay::Auto:
  242. return "auto"sv;
  243. case SignDisplay::Never:
  244. return "never"sv;
  245. case SignDisplay::Always:
  246. return "always"sv;
  247. case SignDisplay::ExceptZero:
  248. return "exceptZero"sv;
  249. default:
  250. VERIFY_NOT_REACHED();
  251. }
  252. }
  253. static ALWAYS_INLINE int log10floor(double value)
  254. {
  255. return static_cast<int>(floor(log10(value)));
  256. }
  257. // 15.1.1 SetNumberFormatDigitOptions ( intlObj, options, mnfdDefault, mxfdDefault, notation ), https://tc39.es/ecma402/#sec-setnfdigitoptions
  258. ThrowCompletionOr<void> set_number_format_digit_options(GlobalObject& global_object, NumberFormat& intl_object, Object const& options, int default_min_fraction_digits, int default_max_fraction_digits, NumberFormat::Notation notation)
  259. {
  260. auto& vm = global_object.vm();
  261. // 1. Assert: Type(intlObj) is Object.
  262. // 2. Assert: Type(options) is Object.
  263. // 3. Assert: Type(mnfdDefault) is Number.
  264. // 4. Assert: Type(mxfdDefault) is Number.
  265. // 5. Let mnid be ? GetNumberOption(options, "minimumIntegerDigits,", 1, 21, 1).
  266. auto min_integer_digits = TRY(get_number_option(global_object, options, vm.names.minimumIntegerDigits, 1, 21, 1));
  267. // 6. Let mnfd be ? Get(options, "minimumFractionDigits").
  268. auto min_fraction_digits = TRY(options.get(vm.names.minimumFractionDigits));
  269. // 7. Let mxfd be ? Get(options, "maximumFractionDigits").
  270. auto max_fraction_digits = TRY(options.get(vm.names.maximumFractionDigits));
  271. // 8. Let mnsd be ? Get(options, "minimumSignificantDigits").
  272. auto min_significant_digits = TRY(options.get(vm.names.minimumSignificantDigits));
  273. // 9. Let mxsd be ? Get(options, "maximumSignificantDigits").
  274. auto max_significant_digits = TRY(options.get(vm.names.maximumSignificantDigits));
  275. // 10. Set intlObj.[[MinimumIntegerDigits]] to mnid.
  276. intl_object.set_min_integer_digits(*min_integer_digits);
  277. // 11. If mnsd is not undefined or mxsd is not undefined, then
  278. if (!min_significant_digits.is_undefined() || !max_significant_digits.is_undefined()) {
  279. // a. Set intlObj.[[RoundingType]] to significantDigits.
  280. intl_object.set_rounding_type(NumberFormat::RoundingType::SignificantDigits);
  281. // b. Let mnsd be ? DefaultNumberOption(mnsd, 1, 21, 1).
  282. auto min_digits = TRY(default_number_option(global_object, min_significant_digits, 1, 21, 1));
  283. // c. Let mxsd be ? DefaultNumberOption(mxsd, mnsd, 21, 21).
  284. auto max_digits = TRY(default_number_option(global_object, max_significant_digits, *min_digits, 21, 21));
  285. // d. Set intlObj.[[MinimumSignificantDigits]] to mnsd.
  286. intl_object.set_min_significant_digits(*min_digits);
  287. // e. Set intlObj.[[MaximumSignificantDigits]] to mxsd.
  288. intl_object.set_max_significant_digits(*max_digits);
  289. }
  290. // 12. Else if mnfd is not undefined or mxfd is not undefined, then
  291. else if (!min_fraction_digits.is_undefined() || !max_fraction_digits.is_undefined()) {
  292. // a. Set intlObj.[[RoundingType]] to fractionDigits.
  293. intl_object.set_rounding_type(NumberFormat::RoundingType::FractionDigits);
  294. // b. Let mnfd be ? DefaultNumberOption(mnfd, 0, 20, undefined).
  295. auto min_digits = TRY(default_number_option(global_object, min_fraction_digits, 0, 20, {}));
  296. // c. Let mxfd be ? DefaultNumberOption(mxfd, 0, 20, undefined).
  297. auto max_digits = TRY(default_number_option(global_object, max_fraction_digits, 0, 20, {}));
  298. // d. If mnfd is undefined, set mnfd to min(mnfdDefault, mxfd).
  299. if (!min_digits.has_value())
  300. min_digits = min(default_min_fraction_digits, *max_digits);
  301. // e. Else if mxfd is undefined, set mxfd to max(mxfdDefault, mnfd).
  302. else if (!max_digits.has_value())
  303. max_digits = max(default_max_fraction_digits, *min_digits);
  304. // f. Else if mnfd is greater than mxfd, throw a RangeError exception.
  305. else if (*min_digits > *max_digits)
  306. return vm.throw_completion<RangeError>(global_object, ErrorType::IntlMinimumExceedsMaximum, *min_digits, *max_digits);
  307. // g. Set intlObj.[[MinimumFractionDigits]] to mnfd.
  308. intl_object.set_min_fraction_digits(*min_digits);
  309. // h. Set intlObj.[[MaximumFractionDigits]] to mxfd.
  310. intl_object.set_max_fraction_digits(*max_digits);
  311. }
  312. // 13. Else if notation is "compact", then
  313. else if (notation == NumberFormat::Notation::Compact) {
  314. // a. Set intlObj.[[RoundingType]] to compactRounding.
  315. intl_object.set_rounding_type(NumberFormat::RoundingType::CompactRounding);
  316. }
  317. // 14. Else,
  318. else {
  319. // a. Set intlObj.[[RoundingType]] to fractionDigits.
  320. intl_object.set_rounding_type(NumberFormat::RoundingType::FractionDigits);
  321. // b. Set intlObj.[[MinimumFractionDigits]] to mnfdDefault.
  322. intl_object.set_min_fraction_digits(default_min_fraction_digits);
  323. // c. Set intlObj.[[MaximumFractionDigits]] to mxfdDefault.
  324. intl_object.set_max_fraction_digits(default_max_fraction_digits);
  325. }
  326. return {};
  327. }
  328. // 15.1.2 InitializeNumberFormat ( numberFormat, locales, options ), https://tc39.es/ecma402/#sec-initializenumberformat
  329. ThrowCompletionOr<NumberFormat*> initialize_number_format(GlobalObject& global_object, NumberFormat& number_format, Value locales_value, Value options_value)
  330. {
  331. auto& vm = global_object.vm();
  332. // 1. Let requestedLocales be ? CanonicalizeLocaleList(locales).
  333. auto requested_locales = TRY(canonicalize_locale_list(global_object, locales_value));
  334. // 2. Set options to ? CoerceOptionsToObject(options).
  335. auto* options = TRY(coerce_options_to_object(global_object, options_value));
  336. // 3. Let opt be a new Record.
  337. LocaleOptions opt {};
  338. // 4. Let matcher be ? GetOption(options, "localeMatcher", "string", « "lookup", "best fit" », "best fit").
  339. auto matcher = TRY(get_option(global_object, *options, vm.names.localeMatcher, Value::Type::String, { "lookup"sv, "best fit"sv }, "best fit"sv));
  340. // 5. Set opt.[[localeMatcher]] to matcher.
  341. opt.locale_matcher = matcher;
  342. // 6. Let numberingSystem be ? GetOption(options, "numberingSystem", "string", undefined, undefined).
  343. auto numbering_system = TRY(get_option(global_object, *options, vm.names.numberingSystem, Value::Type::String, {}, Empty {}));
  344. // 7. If numberingSystem is not undefined, then
  345. if (!numbering_system.is_undefined()) {
  346. // a. If numberingSystem does not match the Unicode Locale Identifier type nonterminal, throw a RangeError exception.
  347. if (!Unicode::is_type_identifier(numbering_system.as_string().string()))
  348. return vm.throw_completion<RangeError>(global_object, ErrorType::OptionIsNotValidValue, numbering_system, "numberingSystem"sv);
  349. // 8. Set opt.[[nu]] to numberingSystem.
  350. opt.nu = numbering_system.as_string().string();
  351. }
  352. // 9. Let localeData be %NumberFormat%.[[LocaleData]].
  353. // 10. Let r be ResolveLocale(%NumberFormat%.[[AvailableLocales]], requestedLocales, opt, %NumberFormat%.[[RelevantExtensionKeys]], localeData).
  354. auto result = resolve_locale(requested_locales, opt, NumberFormat::relevant_extension_keys());
  355. // 11. Set numberFormat.[[Locale]] to r.[[locale]].
  356. number_format.set_locale(move(result.locale));
  357. // 12. Set numberFormat.[[DataLocale]] to r.[[dataLocale]].
  358. number_format.set_data_locale(move(result.data_locale));
  359. // 13. Set numberFormat.[[NumberingSystem]] to r.[[nu]].
  360. number_format.set_numbering_system(result.nu.release_value());
  361. // 14. Perform ? SetNumberFormatUnitOptions(numberFormat, options).
  362. TRY(set_number_format_unit_options(global_object, number_format, *options));
  363. // 15. Let style be numberFormat.[[Style]].
  364. auto style = number_format.style();
  365. int default_min_fraction_digits = 0;
  366. int default_max_fraction_digits = 0;
  367. // 16. If style is "currency", then
  368. if (style == NumberFormat::Style::Currency) {
  369. // a. Let currency be numberFormat.[[Currency]].
  370. auto const& currency = number_format.currency();
  371. // b. Let cDigits be CurrencyDigits(currency).
  372. int digits = currency_digits(currency);
  373. // c. Let mnfdDefault be cDigits.
  374. default_min_fraction_digits = digits;
  375. // d. Let mxfdDefault be cDigits.
  376. default_max_fraction_digits = digits;
  377. }
  378. // 17. Else,
  379. else {
  380. // a. Let mnfdDefault be 0.
  381. default_min_fraction_digits = 0;
  382. // b. If style is "percent", then
  383. // i. Let mxfdDefault be 0.
  384. // c. Else,
  385. // i. Let mxfdDefault be 3.
  386. default_max_fraction_digits = style == NumberFormat::Style::Percent ? 0 : 3;
  387. }
  388. // 18. Let notation be ? GetOption(options, "notation", "string", « "standard", "scientific", "engineering", "compact" », "standard").
  389. auto notation = TRY(get_option(global_object, *options, vm.names.notation, Value::Type::String, { "standard"sv, "scientific"sv, "engineering"sv, "compact"sv }, "standard"sv));
  390. // 19. Set numberFormat.[[Notation]] to notation.
  391. number_format.set_notation(notation.as_string().string());
  392. // 20. Perform ? SetNumberFormatDigitOptions(numberFormat, options, mnfdDefault, mxfdDefault, notation).
  393. TRY(set_number_format_digit_options(global_object, number_format, *options, default_min_fraction_digits, default_max_fraction_digits, number_format.notation()));
  394. // 21. Let compactDisplay be ? GetOption(options, "compactDisplay", "string", « "short", "long" », "short").
  395. auto compact_display = TRY(get_option(global_object, *options, vm.names.compactDisplay, Value::Type::String, { "short"sv, "long"sv }, "short"sv));
  396. // 22. If notation is "compact", then
  397. if (number_format.notation() == NumberFormat::Notation::Compact) {
  398. // a. Set numberFormat.[[CompactDisplay]] to compactDisplay.
  399. number_format.set_compact_display(compact_display.as_string().string());
  400. }
  401. // 23. Let useGrouping be ? GetOption(options, "useGrouping", "boolean", undefined, true).
  402. auto use_grouping = TRY(get_option(global_object, *options, vm.names.useGrouping, Value::Type::Boolean, {}, true));
  403. // 24. Set numberFormat.[[UseGrouping]] to useGrouping.
  404. number_format.set_use_grouping(use_grouping.as_bool());
  405. // 25. Let signDisplay be ? GetOption(options, "signDisplay", "string", « "auto", "never", "always", "exceptZero" », "auto").
  406. auto sign_display = TRY(get_option(global_object, *options, vm.names.signDisplay, Value::Type::String, { "auto"sv, "never"sv, "always"sv, "exceptZero"sv }, "auto"sv));
  407. // 26. Set numberFormat.[[SignDisplay]] to signDisplay.
  408. number_format.set_sign_display(sign_display.as_string().string());
  409. // 27. Return numberFormat.
  410. return &number_format;
  411. }
  412. // 15.1.3 CurrencyDigits ( currency ), https://tc39.es/ecma402/#sec-currencydigits
  413. int currency_digits(StringView currency)
  414. {
  415. // 1. If the ISO 4217 currency and funds code list contains currency as an alphabetic code, return the minor
  416. // unit value corresponding to the currency from the list; otherwise, return 2.
  417. if (auto currency_code = Unicode::get_currency_code(currency); currency_code.has_value())
  418. return currency_code->minor_unit.value_or(2);
  419. return 2;
  420. }
  421. // 15.1.5 FormatNumericToString ( intlObject, x ), https://tc39.es/ecma402/#sec-formatnumberstring
  422. FormatResult format_numeric_to_string(NumberFormat& number_format, double number)
  423. {
  424. // 1. If x < 0 or x is -0𝔽, let isNegative be true; else let isNegative be false.
  425. bool is_negative = (number < 0.0) || Value(number).is_negative_zero();
  426. // 2. If isNegative, then
  427. if (is_negative) {
  428. // a. Let x be -x.
  429. number *= -1;
  430. }
  431. RawFormatResult result {};
  432. switch (number_format.rounding_type()) {
  433. // 3. If intlObject.[[RoundingType]] is significantDigits, then
  434. case NumberFormat::RoundingType::SignificantDigits:
  435. // a. Let result be ToRawPrecision(x, intlObject.[[MinimumSignificantDigits]], intlObject.[[MaximumSignificantDigits]]).
  436. result = to_raw_precision(number, number_format.min_significant_digits(), number_format.max_significant_digits());
  437. break;
  438. // 4. Else if intlObject.[[RoundingType]] is fractionDigits, then
  439. case NumberFormat::RoundingType::FractionDigits:
  440. // a. Let result be ToRawFixed(x, intlObject.[[MinimumFractionDigits]], intlObject.[[MaximumFractionDigits]]).
  441. result = to_raw_fixed(number, number_format.min_fraction_digits(), number_format.max_fraction_digits());
  442. break;
  443. // 5. Else,
  444. case NumberFormat::RoundingType::CompactRounding:
  445. // a. Assert: intlObject.[[RoundingType]] is compactRounding.
  446. // b. Let result be ToRawPrecision(x, 1, 2).
  447. result = to_raw_precision(number, 1, 2);
  448. // c. If result.[[IntegerDigitsCount]] > 1, then
  449. if (result.digits > 1) {
  450. // i. Let result be ToRawFixed(x, 0, 0).
  451. result = to_raw_fixed(number, 0, 0);
  452. }
  453. break;
  454. default:
  455. VERIFY_NOT_REACHED();
  456. }
  457. // 6. Let x be result.[[RoundedNumber]].
  458. number = result.rounded_number;
  459. // 7. Let string be result.[[FormattedString]].
  460. auto string = move(result.formatted_string);
  461. // 8. Let int be result.[[IntegerDigitsCount]].
  462. int digits = result.digits;
  463. // 9. Let minInteger be intlObject.[[MinimumIntegerDigits]].
  464. int min_integer = number_format.min_integer_digits();
  465. // 10. If int < minInteger, then
  466. if (digits < min_integer) {
  467. // a. Let forwardZeros be the String consisting of minInteger–int occurrences of the character "0".
  468. auto forward_zeros = String::repeated('0', min_integer - digits);
  469. // b. Set string to the string-concatenation of forwardZeros and string.
  470. string = String::formatted("{}{}", forward_zeros, string);
  471. }
  472. // 11. If isNegative, then
  473. if (is_negative) {
  474. // a. Let x be -x.
  475. number *= -1;
  476. }
  477. // 12. Return the Record { [[RoundedNumber]]: x, [[FormattedString]]: string }.
  478. return { move(string), number };
  479. }
  480. // 15.1.6 PartitionNumberPattern ( numberFormat, x ), https://tc39.es/ecma402/#sec-partitionnumberpattern
  481. Vector<PatternPartition> partition_number_pattern(NumberFormat& number_format, double number)
  482. {
  483. // 1. Let exponent be 0.
  484. int exponent = 0;
  485. String formatted_string;
  486. // 2. If x is NaN, then
  487. if (Value(number).is_nan()) {
  488. // a. Let n be an implementation- and locale-dependent (ILD) String value indicating the NaN value.
  489. formatted_string = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), "nan"sv).value_or("NaN"sv);
  490. }
  491. // 3. Else if x is a non-finite Number, then
  492. else if (!Value(number).is_finite_number()) {
  493. // a. Let n be an ILD String value indicating infinity.
  494. formatted_string = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), "infinity"sv).value_or("infinity"sv);
  495. }
  496. // 4. Else,
  497. else {
  498. // a. If numberFormat.[[Style]] is "percent", let x be 100 × x.
  499. if (number_format.style() == NumberFormat::Style::Percent)
  500. number = number * 100;
  501. // b. Let exponent be ComputeExponent(numberFormat, x).
  502. exponent = compute_exponent(number_format, number);
  503. // c. Let x be x × 10^(-exponent).
  504. number *= pow(10, -exponent);
  505. // d. Let formatNumberResult be FormatNumericToString(numberFormat, x).
  506. auto format_number_result = format_numeric_to_string(number_format, number);
  507. // e. Let n be formatNumberResult.[[FormattedString]].
  508. formatted_string = move(format_number_result.formatted_string);
  509. // f. Let x be formatNumberResult.[[RoundedNumber]].
  510. number = format_number_result.rounded_number;
  511. }
  512. // 5. Let pattern be GetNumberFormatPattern(numberFormat, x).
  513. auto pattern = get_number_format_pattern(number_format, number);
  514. if (!pattern.has_value())
  515. return {};
  516. // 6. Let result be a new empty List.
  517. Vector<PatternPartition> result;
  518. // 7. Let patternParts be PartitionPattern(pattern).
  519. auto pattern_parts = pattern->visit([](auto const& p) { return partition_pattern(p); });
  520. // 8. For each Record { [[Type]], [[Value]] } patternPart of patternParts, do
  521. for (auto& pattern_part : pattern_parts) {
  522. // a. Let p be patternPart.[[Type]].
  523. auto part = pattern_part.type;
  524. // b. If p is "literal", then
  525. if (part == "literal"sv) {
  526. // i. Append a new Record { [[Type]]: "literal", [[Value]]: patternPart.[[Value]] } as the last element of result.
  527. result.append({ "literal"sv, move(pattern_part.value) });
  528. }
  529. // c. Else if p is equal to "number", then
  530. else if (part == "number"sv) {
  531. // i. Let notationSubParts be PartitionNotationSubPattern(numberFormat, x, n, exponent).
  532. auto notation_sub_parts = partition_notation_sub_pattern(number_format, number, formatted_string, exponent);
  533. // ii. Append all elements of notationSubParts to result.
  534. result.extend(move(notation_sub_parts));
  535. }
  536. // d. Else if p is equal to "plusSign", then
  537. else if (part == "plusSign"sv) {
  538. // i. Let plusSignSymbol be the ILND String representing the plus sign.
  539. auto plus_sign_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), "plusSign"sv).value_or("+"sv);
  540. // ii. Append a new Record { [[Type]]: "plusSign", [[Value]]: plusSignSymbol } as the last element of result.
  541. result.append({ "plusSign"sv, plus_sign_symbol });
  542. }
  543. // e. Else if p is equal to "minusSign", then
  544. else if (part == "minusSign"sv) {
  545. // i. Let minusSignSymbol be the ILND String representing the minus sign.
  546. auto minus_sign_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), "minusSign"sv).value_or("-"sv);
  547. // ii. Append a new Record { [[Type]]: "minusSign", [[Value]]: minusSignSymbol } as the last element of result.
  548. result.append({ "minusSign"sv, minus_sign_symbol });
  549. }
  550. // f. Else if p is equal to "percentSign" and numberFormat.[[Style]] is "percent", then
  551. else if ((part == "percentSign"sv) && (number_format.style() == NumberFormat::Style::Percent)) {
  552. // i. Let percentSignSymbol be the ILND String representing the percent sign.
  553. auto percent_sign_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), "percentSign"sv).value_or("%"sv);
  554. // ii. Append a new Record { [[Type]]: "percentSign", [[Value]]: percentSignSymbol } as the last element of result.
  555. result.append({ "percentSign"sv, percent_sign_symbol });
  556. }
  557. // g. Else if p is equal to "unitPrefix" and numberFormat.[[Style]] is "unit", then
  558. else if ((part == "unitPrefix"sv) && (number_format.style() == NumberFormat::Style::Unit)) {
  559. // i. Let unit be numberFormat.[[Unit]].
  560. // ii. Let unitDisplay be numberFormat.[[UnitDisplay]].
  561. // iii. Let mu be an ILD String value representing unit before x in unitDisplay form, which may depend on x in languages having different plural forms.
  562. // iv. Append a new Record { [[Type]]: "unit", [[Value]]: mu } as the last element of result.
  563. // FIXME: LibUnicode will need to parse the cldr-units package.
  564. }
  565. // h. Else if p is equal to "unitSuffix" and numberFormat.[[Style]] is "unit", then
  566. else if ((part == "unitSuffix"sv) && (number_format.style() == NumberFormat::Style::Unit)) {
  567. // i. Let unit be numberFormat.[[Unit]].
  568. // ii. Let unitDisplay be numberFormat.[[UnitDisplay]].
  569. // iii. Let mu be an ILD String value representing unit after x in unitDisplay form, which may depend on x in languages having different plural forms.
  570. // iv. Append a new Record { [[Type]]: "unit", [[Value]]: mu } as the last element of result.
  571. // FIXME: LibUnicode will need to parse the cldr-units package.
  572. }
  573. // i. Else if p is equal to "currencyCode" and numberFormat.[[Style]] is "currency", then
  574. // j. Else if p is equal to "currencyPrefix" and numberFormat.[[Style]] is "currency", then
  575. // k. Else if p is equal to "currencySuffix" and numberFormat.[[Style]] is "currency", then
  576. //
  577. // Note: Our implementation manipulates the format string to inject/remove spacing around the
  578. // currency code during GetNumberFormatPattern so that we do not have to do currency
  579. // display / plurality lookups more than once.
  580. else if ((part == "currency"sv) && (number_format.style() == NumberFormat::Style::Currency)) {
  581. result.append({ "currency"sv, number_format.resolve_currency_display() });
  582. }
  583. // l. Else,
  584. else {
  585. // i. Let unknown be an ILND String based on x and p.
  586. // ii. Append a new Record { [[Type]]: "unknown", [[Value]]: unknown } as the last element of result.
  587. // LibUnicode doesn't generate any "unknown" patterns.
  588. VERIFY_NOT_REACHED();
  589. }
  590. }
  591. // 9. Return result.
  592. return result;
  593. }
  594. static String replace_digits_for_number_format(NumberFormat& number_format, String formatted_string)
  595. {
  596. // https://tc39.es/ecma402/#table-numbering-system-digits
  597. static HashMap<StringView, AK::Array<u32, 10>> s_numbering_system_digits = {
  598. { "adlm"sv, { 0x1e950, 0x1e951, 0x1e952, 0x1e953, 0x1e954, 0x1e955, 0x1e956, 0x1e957, 0x1e958, 0x1e959 } },
  599. { "ahom"sv, { 0x11730, 0x11731, 0x11732, 0x11733, 0x11734, 0x11735, 0x11736, 0x11737, 0x11738, 0x11739 } },
  600. { "arab"sv, { 0x660, 0x661, 0x662, 0x663, 0x664, 0x665, 0x666, 0x667, 0x668, 0x669 } },
  601. { "arabext"sv, { 0x6f0, 0x6f1, 0x6f2, 0x6f3, 0x6f4, 0x6f5, 0x6f6, 0x6f7, 0x6f8, 0x6f9 } },
  602. { "bali"sv, { 0x1b50, 0x1b51, 0x1b52, 0x1b53, 0x1b54, 0x1b55, 0x1b56, 0x1b57, 0x1b58, 0x1b59 } },
  603. { "beng"sv, { 0x9e6, 0x9e7, 0x9e8, 0x9e9, 0x9ea, 0x9eb, 0x9ec, 0x9ed, 0x9ee, 0x9ef } },
  604. { "bhks"sv, { 0x11c50, 0x11c51, 0x11c52, 0x11c53, 0x11c54, 0x11c55, 0x11c56, 0x11c57, 0x11c58, 0x11c59 } },
  605. { "brah"sv, { 0x11066, 0x11067, 0x11068, 0x11069, 0x1106a, 0x1106b, 0x1106c, 0x1106d, 0x1106e, 0x1106f } },
  606. { "cakm"sv, { 0x11136, 0x11137, 0x11138, 0x11139, 0x1113a, 0x1113b, 0x1113c, 0x1113d, 0x1113e, 0x1113f } },
  607. { "cham"sv, { 0xaa50, 0xaa51, 0xaa52, 0xaa53, 0xaa54, 0xaa55, 0xaa56, 0xaa57, 0xaa58, 0xaa59 } },
  608. { "deva"sv, { 0x966, 0x967, 0x968, 0x969, 0x96a, 0x96b, 0x96c, 0x96d, 0x96e, 0x96f } },
  609. { "diak"sv, { 0x11950, 0x11951, 0x11952, 0x11953, 0x11954, 0x11955, 0x11956, 0x11957, 0x11958, 0x11959 } },
  610. { "fullwide"sv, { 0xff10, 0xff11, 0xff12, 0xff13, 0xff14, 0xff15, 0xff16, 0xff17, 0xff18, 0xff19 } },
  611. { "gong"sv, { 0x11da0, 0x11da1, 0x11da2, 0x11da3, 0x11da4, 0x11da5, 0x11da6, 0x11da7, 0x11da8, 0x11da9 } },
  612. { "gonm"sv, { 0x11d50, 0x11d51, 0x11d52, 0x11d53, 0x11d54, 0x11d55, 0x11d56, 0x11d57, 0x11d58, 0x11d59 } },
  613. { "gujr"sv, { 0xae6, 0xae7, 0xae8, 0xae9, 0xaea, 0xaeb, 0xaec, 0xaed, 0xaee, 0xaef } },
  614. { "guru"sv, { 0xa66, 0xa67, 0xa68, 0xa69, 0xa6a, 0xa6b, 0xa6c, 0xa6d, 0xa6e, 0xa6f } },
  615. { "hanidec"sv, { 0x3007, 0x4e00, 0x4e8c, 0x4e09, 0x56db, 0x4e94, 0x516d, 0x4e03, 0x516b, 0x4e5d } },
  616. { "hmng"sv, { 0x16b50, 0x16b51, 0x16b52, 0x16b53, 0x16b54, 0x16b55, 0x16b56, 0x16b57, 0x16b58, 0x16b59 } },
  617. { "hmnp"sv, { 0x1e140, 0x1e141, 0x1e142, 0x1e143, 0x1e144, 0x1e145, 0x1e146, 0x1e147, 0x1e148, 0x1e149 } },
  618. { "java"sv, { 0xa9d0, 0xa9d1, 0xa9d2, 0xa9d3, 0xa9d4, 0xa9d5, 0xa9d6, 0xa9d7, 0xa9d8, 0xa9d9 } },
  619. { "kali"sv, { 0xa900, 0xa901, 0xa902, 0xa903, 0xa904, 0xa905, 0xa906, 0xa907, 0xa908, 0xa909 } },
  620. { "khmr"sv, { 0x17e0, 0x17e1, 0x17e2, 0x17e3, 0x17e4, 0x17e5, 0x17e6, 0x17e7, 0x17e8, 0x17e9 } },
  621. { "knda"sv, { 0xce6, 0xce7, 0xce8, 0xce9, 0xcea, 0xceb, 0xcec, 0xced, 0xcee, 0xcef } },
  622. { "lana"sv, { 0x1a80, 0x1a81, 0x1a82, 0x1a83, 0x1a84, 0x1a85, 0x1a86, 0x1a87, 0x1a88, 0x1a89 } },
  623. { "lanatham"sv, { 0x1a90, 0x1a91, 0x1a92, 0x1a93, 0x1a94, 0x1a95, 0x1a96, 0x1a97, 0x1a98, 0x1a99 } },
  624. { "laoo"sv, { 0xed0, 0xed1, 0xed2, 0xed3, 0xed4, 0xed5, 0xed6, 0xed7, 0xed8, 0xed9 } },
  625. { "latn"sv, { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39 } },
  626. { "lepc"sv, { 0x1c40, 0x1c41, 0x1c42, 0x1c43, 0x1c44, 0x1c45, 0x1c46, 0x1c47, 0x1c48, 0x1c49 } },
  627. { "limb"sv, { 0x1946, 0x1947, 0x1948, 0x1949, 0x194a, 0x194b, 0x194c, 0x194d, 0x194e, 0x194f } },
  628. { "mathbold"sv, { 0x1d7ce, 0x1d7cf, 0x1d7d0, 0x1d7d1, 0x1d7d2, 0x1d7d3, 0x1d7d4, 0x1d7d5, 0x1d7d6, 0x1d7d7 } },
  629. { "mathdbl"sv, { 0x1d7d8, 0x1d7d9, 0x1d7da, 0x1d7db, 0x1d7dc, 0x1d7dd, 0x1d7de, 0x1d7df, 0x1d7e0, 0x1d7e1 } },
  630. { "mathmono"sv, { 0x1d7f6, 0x1d7f7, 0x1d7f8, 0x1d7f9, 0x1d7fa, 0x1d7fb, 0x1d7fc, 0x1d7fd, 0x1d7fe, 0x1d7ff } },
  631. { "mathsanb"sv, { 0x1d7ec, 0x1d7ed, 0x1d7ee, 0x1d7ef, 0x1d7f0, 0x1d7f1, 0x1d7f2, 0x1d7f3, 0x1d7f4, 0x1d7f5 } },
  632. { "mathsans"sv, { 0x1d7e2, 0x1d7e3, 0x1d7e4, 0x1d7e5, 0x1d7e6, 0x1d7e7, 0x1d7e8, 0x1d7e9, 0x1d7ea, 0x1d7eb } },
  633. { "mlym"sv, { 0xd66, 0xd67, 0xd68, 0xd69, 0xd6a, 0xd6b, 0xd6c, 0xd6d, 0xd6e, 0xd6f } },
  634. { "modi"sv, { 0x11650, 0x11651, 0x11652, 0x11653, 0x11654, 0x11655, 0x11656, 0x11657, 0x11658, 0x11659 } },
  635. { "mong"sv, { 0x1810, 0x1811, 0x1812, 0x1813, 0x1814, 0x1815, 0x1816, 0x1817, 0x1818, 0x1819 } },
  636. { "mroo"sv, { 0x16a60, 0x16a61, 0x16a62, 0x16a63, 0x16a64, 0x16a65, 0x16a66, 0x16a67, 0x16a68, 0x16a69 } },
  637. { "mtei"sv, { 0xabf0, 0xabf1, 0xabf2, 0xabf3, 0xabf4, 0xabf5, 0xabf6, 0xabf7, 0xabf8, 0xabf9 } },
  638. { "mymr"sv, { 0x1040, 0x1041, 0x1042, 0x1043, 0x1044, 0x1045, 0x1046, 0x1047, 0x1048, 0x1049 } },
  639. { "mymrshan"sv, { 0x1090, 0x1091, 0x1092, 0x1093, 0x1094, 0x1095, 0x1096, 0x1097, 0x1098, 0x1099 } },
  640. { "mymrtlng"sv, { 0xa9f0, 0xa9f1, 0xa9f2, 0xa9f3, 0xa9f4, 0xa9f5, 0xa9f6, 0xa9f7, 0xa9f8, 0xa9f9 } },
  641. { "newa"sv, { 0x11450, 0x11451, 0x11452, 0x11453, 0x11454, 0x11455, 0x11456, 0x11457, 0x11458, 0x11459 } },
  642. { "nkoo"sv, { 0x7c0, 0x7c1, 0x7c2, 0x7c3, 0x7c4, 0x7c5, 0x7c6, 0x7c7, 0x7c8, 0x7c9 } },
  643. { "olck"sv, { 0x1c50, 0x1c51, 0x1c52, 0x1c53, 0x1c54, 0x1c55, 0x1c56, 0x1c57, 0x1c58, 0x1c59 } },
  644. { "orya"sv, { 0xb66, 0xb67, 0xb68, 0xb69, 0xb6a, 0xb6b, 0xb6c, 0xb6d, 0xb6e, 0xb6f } },
  645. { "osma"sv, { 0x104a0, 0x104a1, 0x104a2, 0x104a3, 0x104a4, 0x104a5, 0x104a6, 0x104a7, 0x104a8, 0x104a9 } },
  646. { "rohg"sv, { 0x10d30, 0x10d31, 0x10d32, 0x10d33, 0x10d34, 0x10d35, 0x10d36, 0x10d37, 0x10d38, 0x10d39 } },
  647. { "saur"sv, { 0xa8d0, 0xa8d1, 0xa8d2, 0xa8d3, 0xa8d4, 0xa8d5, 0xa8d6, 0xa8d7, 0xa8d8, 0xa8d9 } },
  648. { "segment"sv, { 0x1fbf0, 0x1fbf1, 0x1fbf2, 0x1fbf3, 0x1fbf4, 0x1fbf5, 0x1fbf6, 0x1fbf7, 0x1fbf8, 0x1fbf9 } },
  649. { "shrd"sv, { 0x111d0, 0x111d1, 0x111d2, 0x111d3, 0x111d4, 0x111d5, 0x111d6, 0x111d7, 0x111d8, 0x111d9 } },
  650. { "sind"sv, { 0x112f0, 0x112f1, 0x112f2, 0x112f3, 0x112f4, 0x112f5, 0x112f6, 0x112f7, 0x112f8, 0x112f9 } },
  651. { "sinh"sv, { 0xde6, 0xde7, 0xde8, 0xde9, 0xdea, 0xdeb, 0xdec, 0xded, 0xdee, 0xdef } },
  652. { "sora"sv, { 0x110f0, 0x110f1, 0x110f2, 0x110f3, 0x110f4, 0x110f5, 0x110f6, 0x110f7, 0x110f8, 0x110f9 } },
  653. { "sund"sv, { 0x1bb0, 0x1bb1, 0x1bb2, 0x1bb3, 0x1bb4, 0x1bb5, 0x1bb6, 0x1bb7, 0x1bb8, 0x1bb9 } },
  654. { "takr"sv, { 0x116c0, 0x116c1, 0x116c2, 0x116c3, 0x116c4, 0x116c5, 0x116c6, 0x116c7, 0x116c8, 0x116c9 } },
  655. { "talu"sv, { 0x19d0, 0x19d1, 0x19d2, 0x19d3, 0x19d4, 0x19d5, 0x19d6, 0x19d7, 0x19d8, 0x19d9 } },
  656. { "tamldec"sv, { 0xbe6, 0xbe7, 0xbe8, 0xbe9, 0xbea, 0xbeb, 0xbec, 0xbed, 0xbee, 0xbef } },
  657. { "telu"sv, { 0xc66, 0xc67, 0xc68, 0xc69, 0xc6a, 0xc6b, 0xc6c, 0xc6d, 0xc6e, 0xc6f } },
  658. { "thai"sv, { 0xe50, 0xe51, 0xe52, 0xe53, 0xe54, 0xe55, 0xe56, 0xe57, 0xe58, 0xe59 } },
  659. { "tibt"sv, { 0xf20, 0xf21, 0xf22, 0xf23, 0xf24, 0xf25, 0xf26, 0xf27, 0xf28, 0xf29 } },
  660. { "tirh"sv, { 0x114d0, 0x114d1, 0x114d2, 0x114d3, 0x114d4, 0x114d5, 0x114d6, 0x114d7, 0x114d8, 0x114d9 } },
  661. { "vaii"sv, { 0xa620, 0xa621, 0xa622, 0xa623, 0xa624, 0xa625, 0xa626, 0xa627, 0xa628, 0xa629 } },
  662. { "wara"sv, { 0x118e0, 0x118e1, 0x118e2, 0x118e3, 0x118e4, 0x118e5, 0x118e6, 0x118e7, 0x118e8, 0x118e9 } },
  663. { "wcho"sv, { 0x1e2f0, 0x1e2f1, 0x1e2f2, 0x1e2f3, 0x1e2f4, 0x1e2f5, 0x1e2f6, 0x1e2f7, 0x1e2f8, 0x1e2f9 } },
  664. };
  665. auto digits = s_numbering_system_digits.get(number_format.numbering_system());
  666. if (!digits.has_value())
  667. digits = s_numbering_system_digits.get("latn"sv);
  668. VERIFY(digits.has_value());
  669. StringBuilder builder;
  670. for (auto& ch : formatted_string) {
  671. if (is_ascii_digit(ch)) {
  672. u32 digit = digits->at(parse_ascii_digit(ch));
  673. builder.append_code_point(digit);
  674. } else {
  675. builder.append(ch);
  676. }
  677. }
  678. return builder.build();
  679. }
  680. static Vector<StringView> separate_integer_into_groups(Unicode::NumberGroupings const& grouping_sizes, StringView integer)
  681. {
  682. Utf8View utf8_integer { integer };
  683. Vector<StringView> groups;
  684. auto add_group = [&](size_t index, size_t length) {
  685. groups.prepend(utf8_integer.unicode_substring_view(index, length).as_string());
  686. };
  687. if (utf8_integer.length() > grouping_sizes.primary_grouping_size) {
  688. size_t index = utf8_integer.length() - grouping_sizes.primary_grouping_size;
  689. add_group(index, grouping_sizes.primary_grouping_size);
  690. while (index > grouping_sizes.secondary_grouping_size) {
  691. index -= grouping_sizes.secondary_grouping_size;
  692. add_group(index, grouping_sizes.secondary_grouping_size);
  693. }
  694. if (index > 0)
  695. add_group(0, index);
  696. } else {
  697. groups.append(integer);
  698. }
  699. return groups;
  700. }
  701. // 15.1.7 PartitionNotationSubPattern ( numberFormat, x, n, exponent ), https://tc39.es/ecma402/#sec-partitionnotationsubpattern
  702. Vector<PatternPartition> partition_notation_sub_pattern(NumberFormat& number_format, double number, String formatted_string, int exponent)
  703. {
  704. // 1. Let result be a new empty List.
  705. Vector<PatternPartition> result;
  706. auto grouping_sizes = Unicode::get_number_system_groupings(number_format.data_locale(), number_format.numbering_system());
  707. if (!grouping_sizes.has_value())
  708. return {};
  709. // 2. If x is NaN, then
  710. if (Value(number).is_nan()) {
  711. // a. Append a new Record { [[Type]]: "nan", [[Value]]: n } as the last element of result.
  712. result.append({ "nan"sv, move(formatted_string) });
  713. }
  714. // 3. Else if x is a non-finite Number, then
  715. else if (!Value(number).is_finite_number()) {
  716. // a. Append a new Record { [[Type]]: "infinity", [[Value]]: n } as the last element of result.
  717. result.append({ "infinity"sv, move(formatted_string) });
  718. }
  719. // 4. Else,
  720. else {
  721. // a. Let notationSubPattern be GetNotationSubPattern(numberFormat, exponent).
  722. auto notation_sub_pattern = get_notation_sub_pattern(number_format, exponent);
  723. if (!notation_sub_pattern.has_value())
  724. return {};
  725. // b. Let patternParts be PartitionPattern(notationSubPattern).
  726. auto pattern_parts = partition_pattern(*notation_sub_pattern);
  727. // c. For each Record { [[Type]], [[Value]] } patternPart of patternParts, do
  728. for (auto& pattern_part : pattern_parts) {
  729. // i. Let p be patternPart.[[Type]].
  730. auto part = pattern_part.type;
  731. // ii. If p is "literal", then
  732. if (part == "literal"sv) {
  733. // 1. Append a new Record { [[Type]]: "literal", [[Value]]: patternPart.[[Value]] } as the last element of result.
  734. result.append({ "literal"sv, move(pattern_part.value) });
  735. }
  736. // iii. Else if p is equal to "number", then
  737. else if (part == "number"sv) {
  738. // 1. If the numberFormat.[[NumberingSystem]] matches one of the values in the "Numbering System" column of Table 10 below, then
  739. // a. Let digits be a List whose 10 String valued elements are the UTF-16 string representations of the 10 digits specified in the "Digits" column of the matching row in Table 10.
  740. // b. Replace each digit in n with the value of digits[digit].
  741. // 2. Else use an implementation dependent algorithm to map n to the appropriate representation of n in the given numbering system.
  742. formatted_string = replace_digits_for_number_format(number_format, move(formatted_string));
  743. // 3. Let decimalSepIndex be ! StringIndexOf(n, ".", 0).
  744. auto decimal_sep_index = formatted_string.find('.');
  745. StringView integer;
  746. Optional<StringView> fraction;
  747. // 4. If decimalSepIndex > 0, then
  748. if (decimal_sep_index.has_value() && (*decimal_sep_index > 0)) {
  749. // a. Let integer be the substring of n from position 0, inclusive, to position decimalSepIndex, exclusive.
  750. integer = formatted_string.substring_view(0, *decimal_sep_index);
  751. // b. Let fraction be the substring of n from position decimalSepIndex, exclusive, to the end of n.
  752. fraction = formatted_string.substring_view(*decimal_sep_index + 1);
  753. }
  754. // 5. Else,
  755. else {
  756. // a. Let integer be n.
  757. integer = formatted_string;
  758. // b. Let fraction be undefined.
  759. }
  760. // 6. If the numberFormat.[[UseGrouping]] is true, then
  761. if (number_format.use_grouping()) {
  762. // a. Let groupSepSymbol be the implementation-, locale-, and numbering system-dependent (ILND) String representing the grouping separator.
  763. auto group_sep_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), "group"sv).value_or(","sv);
  764. // b. Let groups be a List whose elements are, in left to right order, the substrings defined by ILND set of locations within the integer.
  765. auto groups = separate_integer_into_groups(*grouping_sizes, integer);
  766. // c. Assert: The number of elements in groups List is greater than 0.
  767. VERIFY(!groups.is_empty());
  768. // d. Repeat, while groups List is not empty,
  769. while (!groups.is_empty()) {
  770. // i. Remove the first element from groups and let integerGroup be the value of that element.
  771. auto integer_group = groups.take_first();
  772. // ii. Append a new Record { [[Type]]: "integer", [[Value]]: integerGroup } as the last element of result.
  773. result.append({ "integer"sv, integer_group });
  774. // iii. If groups List is not empty, then
  775. if (!groups.is_empty()) {
  776. // i. Append a new Record { [[Type]]: "group", [[Value]]: groupSepSymbol } as the last element of result.
  777. result.append({ "group"sv, group_sep_symbol });
  778. }
  779. }
  780. }
  781. // 7. Else,
  782. else {
  783. // a. Append a new Record { [[Type]]: "integer", [[Value]]: integer } as the last element of result.
  784. result.append({ "integer"sv, integer });
  785. }
  786. // 8. If fraction is not undefined, then
  787. if (fraction.has_value()) {
  788. // a. Let decimalSepSymbol be the ILND String representing the decimal separator.
  789. auto decimal_sep_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), "decimal"sv).value_or("."sv);
  790. // b. Append a new Record { [[Type]]: "decimal", [[Value]]: decimalSepSymbol } as the last element of result.
  791. result.append({ "decimal"sv, decimal_sep_symbol });
  792. // c. Append a new Record { [[Type]]: "fraction", [[Value]]: fraction } as the last element of result.
  793. result.append({ "fraction"sv, fraction.release_value() });
  794. }
  795. }
  796. // iv. Else if p is equal to "compactSymbol", then
  797. else if (part == "compactSymbol"sv) {
  798. // 1. Let compactSymbol be an ILD string representing exponent in short form, which may depend on x in languages having different plural forms. The implementation must be able to provide this string, or else the pattern would not have a "{compactSymbol}" placeholder.
  799. // 2. Append a new Record { [[Type]]: "compact", [[Value]]: compactSymbol } as the last element of result.
  800. // FIXME: Implement this when GetNotationSubPattern is fully implemented.
  801. }
  802. // v. Else if p is equal to "compactName", then
  803. else if (part == "compactName"sv) {
  804. // 1. Let compactName be an ILD string representing exponent in long form, which may depend on x in languages having different plural forms. The implementation must be able to provide this string, or else the pattern would not have a "{compactName}" placeholder.
  805. // 2. Append a new Record { [[Type]]: "compact", [[Value]]: compactName } as the last element of result.
  806. // FIXME: Implement this when GetNotationSubPattern is fully implemented.
  807. }
  808. // vi. Else if p is equal to "scientificSeparator", then
  809. else if (part == "scientificSeparator"sv) {
  810. // 1. Let scientificSeparator be the ILND String representing the exponent separator.
  811. auto scientific_separator = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), "exponential"sv).value_or("E"sv);
  812. // 2. Append a new Record { [[Type]]: "exponentSeparator", [[Value]]: scientificSeparator } as the last element of result.
  813. result.append({ "exponentSeparator"sv, scientific_separator });
  814. }
  815. // vii. Else if p is equal to "scientificExponent", then
  816. else if (part == "scientificExponent"sv) {
  817. // 1. If exponent < 0, then
  818. if (exponent < 0) {
  819. // a. Let minusSignSymbol be the ILND String representing the minus sign.
  820. auto minus_sign_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), "minusSign"sv).value_or("-"sv);
  821. // b. Append a new Record { [[Type]]: "exponentMinusSign", [[Value]]: minusSignSymbol } as the last element of result.
  822. result.append({ "exponentMinusSign"sv, minus_sign_symbol });
  823. // c. Let exponent be -exponent.
  824. exponent *= -1;
  825. }
  826. // 2. Let exponentResult be ToRawFixed(exponent, 1, 0, 0).
  827. // Note: See the implementation of ToRawFixed for why we do not pass the 1.
  828. auto exponent_result = to_raw_fixed(exponent, 0, 0);
  829. // FIXME: The spec does not say to do this, but all of major engines perform this replacement.
  830. // Without this, formatting with non-Latin numbering systems will produce non-localized results.
  831. exponent_result.formatted_string = replace_digits_for_number_format(number_format, move(exponent_result.formatted_string));
  832. // 3. Append a new Record { [[Type]]: "exponentInteger", [[Value]]: exponentResult.[[FormattedString]] } as the last element of result.
  833. result.append({ "exponentInteger"sv, move(exponent_result.formatted_string) });
  834. }
  835. // viii. Else,
  836. else {
  837. // 1. Let unknown be an ILND String based on x and p.
  838. // 2. Append a new Record { [[Type]]: "unknown", [[Value]]: unknown } as the last element of result.
  839. // FIXME: Implement this when GetNotationSubPattern is fully implemented.
  840. }
  841. }
  842. }
  843. // 5. Return result.
  844. return result;
  845. }
  846. // 15.1.8 FormatNumeric ( numberFormat, x ), https://tc39.es/ecma402/#sec-formatnumber
  847. String format_numeric(NumberFormat& number_format, double number)
  848. {
  849. // 1. Let parts be ? PartitionNumberPattern(numberFormat, x).
  850. // Note: Our implementation of PartitionNumberPattern does not throw.
  851. auto parts = partition_number_pattern(number_format, number);
  852. // 2. Let result be the empty String.
  853. StringBuilder result;
  854. // 3. For each Record { [[Type]], [[Value]] } part in parts, do
  855. for (auto& part : parts) {
  856. // a. Set result to the string-concatenation of result and part.[[Value]].
  857. result.append(move(part.value));
  858. }
  859. // 4. Return result.
  860. return result.build();
  861. }
  862. // 15.1.9 FormatNumericToParts ( numberFormat, x ), https://tc39.es/ecma402/#sec-formatnumbertoparts
  863. Array* format_numeric_to_parts(GlobalObject& global_object, NumberFormat& number_format, double number)
  864. {
  865. auto& vm = global_object.vm();
  866. // 1. Let parts be ? PartitionNumberPattern(numberFormat, x).
  867. // Note: Our implementation of PartitionNumberPattern does not throw.
  868. auto parts = partition_number_pattern(number_format, number);
  869. // 2. Let result be ArrayCreate(0).
  870. auto* result = MUST(Array::create(global_object, 0));
  871. // 3. Let n be 0.
  872. size_t n = 0;
  873. // 4. For each Record { [[Type]], [[Value]] } part in parts, do
  874. for (auto& part : parts) {
  875. // a. Let O be OrdinaryObjectCreate(%Object.prototype%).
  876. auto* object = Object::create(global_object, global_object.object_prototype());
  877. // b. Perform ! CreateDataPropertyOrThrow(O, "type", part.[[Type]]).
  878. MUST(object->create_data_property_or_throw(vm.names.type, js_string(vm, part.type)));
  879. // c. Perform ! CreateDataPropertyOrThrow(O, "value", part.[[Value]]).
  880. MUST(object->create_data_property_or_throw(vm.names.value, js_string(vm, move(part.value))));
  881. // d. Perform ! CreateDataPropertyOrThrow(result, ! ToString(n), O).
  882. MUST(result->create_data_property_or_throw(n, object));
  883. // e. Increment n by 1.
  884. ++n;
  885. }
  886. // 5. Return result.
  887. return result;
  888. }
  889. static String cut_trailing_zeroes(StringView string, int cut)
  890. {
  891. // These steps are exactly the same between ToRawPrecision and ToRawFixed.
  892. // Repeat, while cut > 0 and the last character of m is "0",
  893. while ((cut > 0) && string.ends_with('0')) {
  894. // Remove the last character from m.
  895. string = string.substring_view(0, string.length() - 1);
  896. // Decrease cut by 1.
  897. --cut;
  898. }
  899. // If the last character of m is ".", then
  900. if (string.ends_with('.')) {
  901. // Remove the last character from m.
  902. string = string.substring_view(0, string.length() - 1);
  903. }
  904. return string.to_string();
  905. }
  906. // 15.1.10 ToRawPrecision ( x, minPrecision, maxPrecision ), https://tc39.es/ecma402/#sec-torawprecision
  907. RawFormatResult to_raw_precision(double number, int min_precision, int max_precision)
  908. {
  909. RawFormatResult result {};
  910. // 1. Let p be maxPrecision.
  911. int precision = max_precision;
  912. int exponent = 0;
  913. // 2. If x = 0, then
  914. if (number == 0.0) {
  915. // a. Let m be the String consisting of p occurrences of the character "0".
  916. result.formatted_string = String::repeated('0', precision);
  917. // b. Let e be 0.
  918. exponent = 0;
  919. // c. Let xFinal be 0.
  920. result.rounded_number = 0;
  921. }
  922. // 3. Else,
  923. else {
  924. // FIXME: The result of these steps isn't entirely accurate for large values of 'p' (which
  925. // defaults to 21, resulting in numbers on the order of 10^21). Either AK::format or
  926. // our Number::toString AO (double_to_string in Value.cpp) will need to be improved
  927. // to produce more accurate results.
  928. // a. Let e be the base 10 logarithm of x rounded down to the nearest integer.
  929. exponent = log10floor(number);
  930. double power = pow(10, exponent - precision + 1);
  931. // b. Let n be an integer such that 10^(p–1) ≤ n < 10^p and for which the exact mathematical value of n × 10^(e–p+1) – x
  932. // is as close to zero as possible. If there is more than one such n, pick the one for which n × 10^(e–p+1) is larger.
  933. double n = round(number / power);
  934. // c. Let m be the String consisting of the digits of the decimal representation of n (in order, with no leading zeroes).
  935. result.formatted_string = Value(n).to_string_without_side_effects();
  936. // d. Let xFinal be n × 10^(e–p+1).
  937. result.rounded_number = n * power;
  938. }
  939. // 4. If e ≥ p–1, then
  940. if (exponent >= (precision - 1)) {
  941. // a. Let m be the string-concatenation of m and e–p+1 occurrences of the character "0".
  942. result.formatted_string = String::formatted(
  943. "{}{}",
  944. result.formatted_string,
  945. String::repeated('0', exponent - precision + 1));
  946. // b. Let int be e+1.
  947. result.digits = exponent + 1;
  948. }
  949. // 5. Else if e ≥ 0, then
  950. else if (exponent >= 0) {
  951. // a. Let m be the string-concatenation of the first e+1 characters of m, the character ".", and the remaining p–(e+1) characters of m.
  952. result.formatted_string = String::formatted(
  953. "{}.{}",
  954. result.formatted_string.substring_view(0, exponent + 1),
  955. result.formatted_string.substring_view(exponent + 1));
  956. // b. Let int be e+1.
  957. result.digits = exponent + 1;
  958. }
  959. // 6. Else,
  960. else {
  961. // a. Assert: e < 0.
  962. // b. Let m be the string-concatenation of the String value "0.", –(e+1) occurrences of the character "0", and m.
  963. result.formatted_string = String::formatted(
  964. "0.{}{}",
  965. String::repeated('0', -1 * (exponent + 1)),
  966. result.formatted_string);
  967. // c. Let int be 1.
  968. result.digits = 1;
  969. }
  970. // 7. If m contains the character ".", and maxPrecision > minPrecision, then
  971. if (result.formatted_string.contains('.') && (max_precision > min_precision)) {
  972. // a. Let cut be maxPrecision – minPrecision.
  973. int cut = max_precision - min_precision;
  974. result.formatted_string = cut_trailing_zeroes(result.formatted_string, cut);
  975. }
  976. // 8. Return the Record { [[FormattedString]]: m, [[RoundedNumber]]: xFinal, [[IntegerDigitsCount]]: int }.
  977. return result;
  978. }
  979. // 15.1.11 ToRawFixed ( x, minInteger, minFraction, maxFraction ), https://tc39.es/ecma402/#sec-torawfixed
  980. // NOTE: The spec has a mistake here. The minInteger parameter is unused and is not provided by FormatNumericToString.
  981. RawFormatResult to_raw_fixed(double number, int min_fraction, int max_fraction)
  982. {
  983. RawFormatResult result {};
  984. // 1. Let f be maxFraction.
  985. int fraction = max_fraction;
  986. double power = pow(10, fraction);
  987. // 2. Let n be an integer for which the exact mathematical value of n / 10^f – x is as close to zero as possible. If there are two such n, pick the larger n.
  988. double n = round(number * power);
  989. // 3. Let xFinal be n / 10^f.
  990. result.rounded_number = n / power;
  991. // 4. If n = 0, let m be the String "0". Otherwise, let m be the String consisting of the digits of the decimal representation of n (in order, with no leading zeroes).
  992. result.formatted_string = n == 0.0 ? String("0"sv) : Value(n).to_string_without_side_effects();
  993. // 5. If f ≠ 0, then
  994. if (fraction != 0) {
  995. // a. Let k be the number of characters in m.
  996. auto decimals = result.formatted_string.length();
  997. // b. If k ≤ f, then
  998. if (decimals <= static_cast<size_t>(fraction)) {
  999. // i. Let z be the String value consisting of f+1–k occurrences of the character "0".
  1000. auto zeroes = String::repeated('0', fraction + 1 - decimals);
  1001. // ii. Let m be the string-concatenation of z and m.
  1002. result.formatted_string = String::formatted("{}{}", zeroes, result.formatted_string);
  1003. // iii. Let k be f+1.
  1004. decimals = fraction + 1;
  1005. }
  1006. // c. Let a be the first k–f characters of m, and let b be the remaining f characters of m.
  1007. auto a = result.formatted_string.substring_view(0, decimals - fraction);
  1008. auto b = result.formatted_string.substring_view(decimals - fraction, fraction);
  1009. // d. Let m be the string-concatenation of a, ".", and b.
  1010. result.formatted_string = String::formatted("{}.{}", a, b);
  1011. // e. Let int be the number of characters in a.
  1012. result.digits = a.length();
  1013. }
  1014. // 6. Else, let int be the number of characters in m.
  1015. else {
  1016. result.digits = result.formatted_string.length();
  1017. }
  1018. // 7. Let cut be maxFraction – minFraction.
  1019. int cut = max_fraction - min_fraction;
  1020. result.formatted_string = cut_trailing_zeroes(result.formatted_string, cut);
  1021. // 10. Return the Record { [[FormattedString]]: m, [[RoundedNumber]]: xFinal, [[IntegerDigitsCount]]: int }.
  1022. return result;
  1023. }
  1024. // 15.1.13 SetNumberFormatUnitOptions ( intlObj, options ), https://tc39.es/ecma402/#sec-setnumberformatunitoptions
  1025. ThrowCompletionOr<void> set_number_format_unit_options(GlobalObject& global_object, NumberFormat& intl_object, Object const& options)
  1026. {
  1027. auto& vm = global_object.vm();
  1028. // 1. Assert: Type(intlObj) is Object.
  1029. // 2. Assert: Type(options) is Object.
  1030. // 3. Let style be ? GetOption(options, "style", "string", « "decimal", "percent", "currency", "unit" », "decimal").
  1031. auto style = TRY(get_option(global_object, options, vm.names.style, Value::Type::String, { "decimal"sv, "percent"sv, "currency"sv, "unit"sv }, "decimal"sv));
  1032. // 4. Set intlObj.[[Style]] to style.
  1033. intl_object.set_style(style.as_string().string());
  1034. // 5. Let currency be ? GetOption(options, "currency", "string", undefined, undefined).
  1035. auto currency = TRY(get_option(global_object, options, vm.names.currency, Value::Type::String, {}, Empty {}));
  1036. // 6. If currency is undefined, then
  1037. if (currency.is_undefined()) {
  1038. // a. If style is "currency", throw a TypeError exception.
  1039. if (intl_object.style() == NumberFormat::Style::Currency)
  1040. return vm.throw_completion<TypeError>(global_object, ErrorType::IntlOptionUndefined, "currency"sv, "style"sv, style);
  1041. }
  1042. // 7. Else,
  1043. // a. If the result of IsWellFormedCurrencyCode(currency) is false, throw a RangeError exception.
  1044. else if (!is_well_formed_currency_code(currency.as_string().string()))
  1045. return vm.throw_completion<RangeError>(global_object, ErrorType::OptionIsNotValidValue, currency, "currency"sv);
  1046. // 8. Let currencyDisplay be ? GetOption(options, "currencyDisplay", "string", « "code", "symbol", "narrowSymbol", "name" », "symbol").
  1047. auto currency_display = TRY(get_option(global_object, options, vm.names.currencyDisplay, Value::Type::String, { "code"sv, "symbol"sv, "narrowSymbol"sv, "name"sv }, "symbol"sv));
  1048. // 9. Let currencySign be ? GetOption(options, "currencySign", "string", « "standard", "accounting" », "standard").
  1049. auto currency_sign = TRY(get_option(global_object, options, vm.names.currencySign, Value::Type::String, { "standard"sv, "accounting"sv }, "standard"sv));
  1050. // 10. Let unit be ? GetOption(options, "unit", "string", undefined, undefined).
  1051. auto unit = TRY(get_option(global_object, options, vm.names.unit, Value::Type::String, {}, Empty {}));
  1052. // 11. If unit is undefined, then
  1053. if (unit.is_undefined()) {
  1054. // a. If style is "unit", throw a TypeError exception.
  1055. if (intl_object.style() == NumberFormat::Style::Unit)
  1056. return vm.throw_completion<TypeError>(global_object, ErrorType::IntlOptionUndefined, "unit"sv, "style"sv, style);
  1057. }
  1058. // 12. Else,
  1059. // a. If the result of IsWellFormedUnitIdentifier(unit) is false, throw a RangeError exception.
  1060. else if (!is_well_formed_unit_identifier(unit.as_string().string()))
  1061. return vm.throw_completion<RangeError>(global_object, ErrorType::OptionIsNotValidValue, unit, "unit"sv);
  1062. // 13. Let unitDisplay be ? GetOption(options, "unitDisplay", "string", « "short", "narrow", "long" », "short").
  1063. auto unit_display = TRY(get_option(global_object, options, vm.names.unitDisplay, Value::Type::String, { "short"sv, "narrow"sv, "long"sv }, "short"sv));
  1064. // 14. If style is "currency", then
  1065. if (intl_object.style() == NumberFormat::Style::Currency) {
  1066. // a. Let currency be the result of converting currency to upper case as specified in 6.1.
  1067. // b. Set intlObj.[[Currency]] to currency.
  1068. intl_object.set_currency(currency.as_string().string().to_uppercase());
  1069. // c. Set intlObj.[[CurrencyDisplay]] to currencyDisplay.
  1070. intl_object.set_currency_display(currency_display.as_string().string());
  1071. // d. Set intlObj.[[CurrencySign]] to currencySign.
  1072. intl_object.set_currency_sign(currency_sign.as_string().string());
  1073. }
  1074. // 15. If style is "unit", then
  1075. if (intl_object.style() == NumberFormat::Style::Unit) {
  1076. // a. Set intlObj.[[Unit]] to unit.
  1077. intl_object.set_unit(unit.as_string().string());
  1078. // b. Set intlObj.[[UnitDisplay]] to unitDisplay.
  1079. intl_object.set_unit_display(unit_display.as_string().string());
  1080. }
  1081. return {};
  1082. }
  1083. // 15.1.14 GetNumberFormatPattern ( numberFormat, x ), https://tc39.es/ecma402/#sec-getnumberformatpattern
  1084. Optional<Variant<StringView, String>> get_number_format_pattern(NumberFormat& number_format, double number)
  1085. {
  1086. // 1. Let localeData be %NumberFormat%.[[LocaleData]].
  1087. // 2. Let dataLocale be numberFormat.[[DataLocale]].
  1088. // 3. Let dataLocaleData be localeData.[[<dataLocale>]].
  1089. // 4. Let patterns be dataLocaleData.[[patterns]].
  1090. // 5. Assert: patterns is a Record (see 15.3.3).
  1091. Optional<Unicode::NumberFormat> patterns;
  1092. // 6. Let style be numberFormat.[[Style]].
  1093. switch (number_format.style()) {
  1094. // 7. If style is "percent", then
  1095. case NumberFormat::Style::Percent:
  1096. // a. Let patterns be patterns.[[percent]].
  1097. patterns = Unicode::get_standard_number_system_format(number_format.data_locale(), number_format.numbering_system(), Unicode::StandardNumberFormatType::Percent);
  1098. break;
  1099. // 8. Else if style is "unit", then
  1100. case NumberFormat::Style::Unit:
  1101. // a. Let unit be numberFormat.[[Unit]].
  1102. // b. Let unitDisplay be numberFormat.[[UnitDisplay]].
  1103. // c. Let patterns be patterns.[[unit]].
  1104. // d. If patterns doesn't have a field [[<unit>]], then
  1105. // i. Let unit be "fallback".
  1106. // e. Let patterns be patterns.[[<unit>]].
  1107. // f. Let patterns be patterns.[[<unitDisplay>]].
  1108. // FIXME: LibUnicode will need to parse the cldr-units package.
  1109. break;
  1110. // 9. Else if style is "currency", then
  1111. case NumberFormat::Style::Currency:
  1112. // a. Let currency be numberFormat.[[Currency]].
  1113. // b. Let currencyDisplay be numberFormat.[[CurrencyDisplay]].
  1114. // c. Let currencySign be numberFormat.[[CurrencySign]].
  1115. // d. Let patterns be patterns.[[currency]].
  1116. // e. If patterns doesn't have a field [[<currency>]], then
  1117. // i. Let currency be "fallback".
  1118. // f. Let patterns be patterns.[[<currency>]].
  1119. // g. Let patterns be patterns.[[<currencyDisplay>]].
  1120. // h. Let patterns be patterns.[[<currencySign>]].
  1121. // Handling of other [[CurrencyDisplay]] options will occur after [[SignDisplay]].
  1122. if (number_format.currency_display() == NumberFormat::CurrencyDisplay::Name) {
  1123. auto maybe_patterns = Unicode::select_currency_unit_pattern(number_format.data_locale(), number_format.numbering_system(), number);
  1124. if (maybe_patterns.has_value()) {
  1125. patterns = maybe_patterns.release_value();
  1126. break;
  1127. }
  1128. }
  1129. switch (number_format.currency_sign()) {
  1130. case NumberFormat::CurrencySign::Standard:
  1131. patterns = Unicode::get_standard_number_system_format(number_format.data_locale(), number_format.numbering_system(), Unicode::StandardNumberFormatType::Currency);
  1132. break;
  1133. case NumberFormat::CurrencySign::Accounting:
  1134. patterns = Unicode::get_standard_number_system_format(number_format.data_locale(), number_format.numbering_system(), Unicode::StandardNumberFormatType::Accounting);
  1135. break;
  1136. }
  1137. break;
  1138. // 10. Else,
  1139. case NumberFormat::Style::Decimal:
  1140. // a. Assert: style is "decimal".
  1141. // b. Let patterns be patterns.[[decimal]].
  1142. patterns = Unicode::get_standard_number_system_format(number_format.data_locale(), number_format.numbering_system(), Unicode::StandardNumberFormatType::Decimal);
  1143. break;
  1144. default:
  1145. VERIFY_NOT_REACHED();
  1146. }
  1147. if (!patterns.has_value())
  1148. return {};
  1149. StringView pattern;
  1150. Value number_value(number);
  1151. bool is_positive_zero = number_value.is_positive_zero();
  1152. bool is_negative_zero = number_value.is_negative_zero();
  1153. bool is_nan = number_value.is_nan();
  1154. // 11. Let signDisplay be numberFormat.[[SignDisplay]].
  1155. switch (number_format.sign_display()) {
  1156. // 12. If signDisplay is "never", then
  1157. case NumberFormat::SignDisplay::Never:
  1158. // a. Let pattern be patterns.[[zeroPattern]].
  1159. pattern = patterns->zero_format;
  1160. break;
  1161. // 13. Else if signDisplay is "auto", then
  1162. case NumberFormat::SignDisplay::Auto:
  1163. // a. If x is 0 or x > 0 or x is NaN, then
  1164. if (is_positive_zero || (number > 0) || is_nan) {
  1165. // i. Let pattern be patterns.[[zeroPattern]].
  1166. pattern = patterns->zero_format;
  1167. }
  1168. // b. Else,
  1169. else {
  1170. // i. Let pattern be patterns.[[negativePattern]].
  1171. pattern = patterns->negative_format;
  1172. }
  1173. break;
  1174. // 14. Else if signDisplay is "always", then
  1175. case NumberFormat::SignDisplay::Always:
  1176. // a. If x is 0 or x > 0 or x is NaN, then
  1177. if (is_positive_zero || (number > 0) || is_nan) {
  1178. // i. Let pattern be patterns.[[positivePattern]].
  1179. pattern = patterns->positive_format;
  1180. }
  1181. // b. Else,
  1182. else {
  1183. // i. Let pattern be patterns.[[negativePattern]].
  1184. pattern = patterns->negative_format;
  1185. }
  1186. break;
  1187. // 15. Else,
  1188. case NumberFormat::SignDisplay::ExceptZero:
  1189. // a. Assert: signDisplay is "exceptZero".
  1190. // b. If x is 0 or x is -0 or x is NaN, then
  1191. if (is_positive_zero || is_negative_zero || is_nan) {
  1192. // i. Let pattern be patterns.[[zeroPattern]].
  1193. pattern = patterns->zero_format;
  1194. }
  1195. // c. Else if x > 0, then
  1196. else if (number > 0) {
  1197. // i. Let pattern be patterns.[[positivePattern]].
  1198. pattern = patterns->positive_format;
  1199. }
  1200. // d. Else,
  1201. else {
  1202. // i. Let pattern be patterns.[[negativePattern]].
  1203. pattern = patterns->negative_format;
  1204. }
  1205. break;
  1206. default:
  1207. VERIFY_NOT_REACHED();
  1208. }
  1209. // Handling of steps 9b/9g: Depending on the currency display and the format pattern found above,
  1210. // we might need to mutate the format pattern to inject a space between the currency display and
  1211. // the currency number.
  1212. if (number_format.style() == NumberFormat::Style::Currency) {
  1213. auto modified_pattern = Unicode::augment_currency_format_pattern(number_format.resolve_currency_display(), pattern);
  1214. if (modified_pattern.has_value())
  1215. return modified_pattern.release_value();
  1216. }
  1217. // 16. Return pattern.
  1218. return pattern;
  1219. }
  1220. // 15.1.15 GetNotationSubPattern ( numberFormat, exponent ), https://tc39.es/ecma402/#sec-getnotationsubpattern
  1221. Optional<StringView> get_notation_sub_pattern(NumberFormat& number_format, int exponent)
  1222. {
  1223. // 1. Let localeData be %NumberFormat%.[[LocaleData]].
  1224. // 2. Let dataLocale be numberFormat.[[DataLocale]].
  1225. // 3. Let dataLocaleData be localeData.[[<dataLocale>]].
  1226. // 4. Let notationSubPatterns be dataLocaleData.[[notationSubPatterns]].
  1227. // 5. Assert: notationSubPatterns is a Record (see 15.3.3).
  1228. // 6. Let notation be numberFormat.[[Notation]].
  1229. auto notation = number_format.notation();
  1230. // 7. If notation is "scientific" or notation is "engineering", then
  1231. if ((notation == NumberFormat::Notation::Scientific) || (notation == NumberFormat::Notation::Engineering)) {
  1232. // a. Return notationSubPatterns.[[scientific]].
  1233. auto notation_sub_patterns = Unicode::get_standard_number_system_format(number_format.data_locale(), number_format.numbering_system(), Unicode::StandardNumberFormatType::Scientific);
  1234. if (!notation_sub_patterns.has_value())
  1235. return {};
  1236. return notation_sub_patterns->zero_format;
  1237. }
  1238. // 8. Else if exponent is not 0, then
  1239. else if (exponent != 0) {
  1240. // FIXME: Implement this.
  1241. // a. Assert: notation is "compact".
  1242. // b. Let compactDisplay be numberFormat.[[CompactDisplay]].
  1243. // c. Let compactPatterns be notationSubPatterns.[[compact]].[[<compactDisplay>]].
  1244. // d. Return compactPatterns.[[<exponent>]].
  1245. }
  1246. // 9. Else,
  1247. // a. Return "{number}".
  1248. return "{number}"sv;
  1249. }
  1250. // 15.1.16 ComputeExponent ( numberFormat, x ), https://tc39.es/ecma402/#sec-computeexponent
  1251. int compute_exponent(NumberFormat& number_format, double number)
  1252. {
  1253. // 1. If x = 0, then
  1254. if (number == 0.0) {
  1255. // a. Return 0.
  1256. return 0;
  1257. }
  1258. // 2. If x < 0, then
  1259. if (number < 0) {
  1260. // a. Let x = -x.
  1261. number *= -1;
  1262. }
  1263. // 3. Let magnitude be the base 10 logarithm of x rounded down to the nearest integer.
  1264. int magnitude = log10floor(number);
  1265. // 4. Let exponent be ComputeExponentForMagnitude(numberFormat, magnitude).
  1266. int exponent = compute_exponent_for_magniude(number_format, magnitude);
  1267. // 5. Let x be x × 10^(-exponent).
  1268. number *= pow(10, -exponent);
  1269. // 6. Let formatNumberResult be FormatNumericToString(numberFormat, x).
  1270. auto format_number_result = format_numeric_to_string(number_format, number);
  1271. // 7. If formatNumberResult.[[RoundedNumber]] = 0, then
  1272. if (format_number_result.rounded_number == 0) {
  1273. // a. Return exponent.
  1274. return exponent;
  1275. }
  1276. // 8. Let newMagnitude be the base 10 logarithm of formatNumberResult.[[RoundedNumber]] rounded down to the nearest integer.
  1277. int new_magnitude = log10floor(format_number_result.rounded_number);
  1278. // 9. If newMagnitude is magnitude – exponent, then
  1279. if (new_magnitude == magnitude - exponent) {
  1280. // a. Return exponent.
  1281. return exponent;
  1282. }
  1283. // 10. Return ComputeExponentForMagnitude(numberFormat, magnitude + 1).
  1284. return compute_exponent_for_magniude(number_format, magnitude + 1);
  1285. }
  1286. // 15.1.17 ComputeExponentForMagnitude ( numberFormat, magnitude ), https://tc39.es/ecma402/#sec-computeexponentformagnitude
  1287. int compute_exponent_for_magniude(NumberFormat& number_format, int magnitude)
  1288. {
  1289. // 1. Let notation be numberFormat.[[Notation]].
  1290. switch (number_format.notation()) {
  1291. // 2. If notation is "standard", then
  1292. case NumberFormat::Notation::Standard:
  1293. // a. Return 0.
  1294. return 0;
  1295. // 3. Else if notation is "scientific", then
  1296. case NumberFormat::Notation::Scientific:
  1297. // a. Return magnitude.
  1298. return magnitude;
  1299. // 4. Else if notation is "engineering", then
  1300. case NumberFormat::Notation::Engineering: {
  1301. // a. Let thousands be the greatest integer that is not greater than magnitude / 3.
  1302. double thousands = floor(static_cast<double>(magnitude) / 3.0);
  1303. // b. Return thousands × 3.
  1304. return static_cast<int>(thousands) * 3;
  1305. }
  1306. // 5. Else,
  1307. case NumberFormat::Notation::Compact: {
  1308. // a. Assert: notation is "compact".
  1309. VERIFY(number_format.has_compact_display());
  1310. // b. Let exponent be an implementation- and locale-dependent (ILD) integer by which to scale a number of the given magnitude in compact notation for the current locale.
  1311. // c. Return exponent.
  1312. Vector<Unicode::NumberFormat> format_rules;
  1313. if (number_format.style() == NumberFormat::Style::Currency)
  1314. format_rules = Unicode::get_compact_number_system_formats(number_format.data_locale(), number_format.numbering_system(), Unicode::CompactNumberFormatType::CurrencyShort);
  1315. else if (number_format.compact_display() == NumberFormat::CompactDisplay::Long)
  1316. format_rules = Unicode::get_compact_number_system_formats(number_format.data_locale(), number_format.numbering_system(), Unicode::CompactNumberFormatType::DecimalLong);
  1317. else
  1318. format_rules = Unicode::get_compact_number_system_formats(number_format.data_locale(), number_format.numbering_system(), Unicode::CompactNumberFormatType::DecimalShort);
  1319. Unicode::NumberFormat const* best_number_format = nullptr;
  1320. for (auto const& format_rule : format_rules) {
  1321. if (format_rule.magnitude > magnitude)
  1322. break;
  1323. best_number_format = &format_rule;
  1324. }
  1325. return best_number_format ? best_number_format->exponent : 0;
  1326. }
  1327. default:
  1328. VERIFY_NOT_REACHED();
  1329. }
  1330. }
  1331. }