NumberFormat.cpp 75 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829
  1. /*
  2. * Copyright (c) 2021-2022, Tim Flynn <trflynn89@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Checked.h>
  7. #include <AK/Utf8View.h>
  8. #include <LibCrypto/BigInt/SignedBigInteger.h>
  9. #include <LibJS/Runtime/AbstractOperations.h>
  10. #include <LibJS/Runtime/Array.h>
  11. #include <LibJS/Runtime/BigInt.h>
  12. #include <LibJS/Runtime/GlobalObject.h>
  13. #include <LibJS/Runtime/Intl/NumberFormat.h>
  14. #include <LibJS/Runtime/Intl/NumberFormatFunction.h>
  15. #include <LibJS/Runtime/Intl/PluralRules.h>
  16. #include <LibUnicode/CurrencyCode.h>
  17. #include <math.h>
  18. #include <stdlib.h>
  19. namespace JS::Intl {
  20. NumberFormatBase::NumberFormatBase(Object& prototype)
  21. : Object(prototype)
  22. {
  23. }
  24. // 15 NumberFormat Objects, https://tc39.es/ecma402/#numberformat-objects
  25. NumberFormat::NumberFormat(Object& prototype)
  26. : NumberFormatBase(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_short_currency_mapping(data_locale(), currency());
  87. break;
  88. case NumberFormat::CurrencyDisplay::NarrowSymbol:
  89. m_resolved_currency_display = Unicode::get_locale_narrow_currency_mapping(data_locale(), currency());
  90. break;
  91. case NumberFormat::CurrencyDisplay::Name:
  92. m_resolved_currency_display = Unicode::get_locale_numeric_currency_mapping(data_locale(), currency());
  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. StringView NumberFormatBase::rounding_type_string() const
  139. {
  140. switch (m_rounding_type) {
  141. case RoundingType::SignificantDigits:
  142. return "significantDigits"sv;
  143. case RoundingType::FractionDigits:
  144. return "fractionDigits"sv;
  145. case RoundingType::MorePrecision:
  146. return "morePrecision"sv;
  147. case RoundingType::LessPrecision:
  148. return "lessPrecision"sv;
  149. default:
  150. VERIFY_NOT_REACHED();
  151. }
  152. }
  153. StringView NumberFormatBase::rounding_mode_string() const
  154. {
  155. switch (m_rounding_mode) {
  156. case RoundingMode::Ceil:
  157. return "ceil"sv;
  158. case RoundingMode::Expand:
  159. return "expand"sv;
  160. case RoundingMode::Floor:
  161. return "floor"sv;
  162. case RoundingMode::HalfCeil:
  163. return "halfCeil"sv;
  164. case RoundingMode::HalfEven:
  165. return "halfEven"sv;
  166. case RoundingMode::HalfExpand:
  167. return "halfExpand"sv;
  168. case RoundingMode::HalfFloor:
  169. return "halfFloor"sv;
  170. case RoundingMode::HalfTrunc:
  171. return "halfTrunc"sv;
  172. case RoundingMode::Trunc:
  173. return "trunc"sv;
  174. default:
  175. VERIFY_NOT_REACHED();
  176. }
  177. }
  178. void NumberFormatBase::set_rounding_mode(StringView rounding_mode)
  179. {
  180. if (rounding_mode == "ceil"sv)
  181. m_rounding_mode = RoundingMode::Ceil;
  182. else if (rounding_mode == "expand"sv)
  183. m_rounding_mode = RoundingMode::Expand;
  184. else if (rounding_mode == "floor"sv)
  185. m_rounding_mode = RoundingMode::Floor;
  186. else if (rounding_mode == "halfCeil"sv)
  187. m_rounding_mode = RoundingMode::HalfCeil;
  188. else if (rounding_mode == "halfEven"sv)
  189. m_rounding_mode = RoundingMode::HalfEven;
  190. else if (rounding_mode == "halfExpand"sv)
  191. m_rounding_mode = RoundingMode::HalfExpand;
  192. else if (rounding_mode == "halfFloor"sv)
  193. m_rounding_mode = RoundingMode::HalfFloor;
  194. else if (rounding_mode == "halfTrunc"sv)
  195. m_rounding_mode = RoundingMode::HalfTrunc;
  196. else if (rounding_mode == "trunc"sv)
  197. m_rounding_mode = RoundingMode::Trunc;
  198. else
  199. VERIFY_NOT_REACHED();
  200. }
  201. StringView NumberFormatBase::trailing_zero_display_string() const
  202. {
  203. switch (m_trailing_zero_display) {
  204. case TrailingZeroDisplay::Auto:
  205. return "auto"sv;
  206. case TrailingZeroDisplay::StripIfInteger:
  207. return "stripIfInteger"sv;
  208. default:
  209. VERIFY_NOT_REACHED();
  210. }
  211. }
  212. void NumberFormatBase::set_trailing_zero_display(StringView trailing_zero_display)
  213. {
  214. if (trailing_zero_display == "auto"sv)
  215. m_trailing_zero_display = TrailingZeroDisplay::Auto;
  216. else if (trailing_zero_display == "stripIfInteger"sv)
  217. m_trailing_zero_display = TrailingZeroDisplay::StripIfInteger;
  218. else
  219. VERIFY_NOT_REACHED();
  220. }
  221. Value NumberFormat::use_grouping_to_value(GlobalObject& global_object) const
  222. {
  223. auto& vm = global_object.vm();
  224. switch (m_use_grouping) {
  225. case UseGrouping::Always:
  226. return js_string(vm, "always"sv);
  227. case UseGrouping::Auto:
  228. return js_string(vm, "auto"sv);
  229. case UseGrouping::Min2:
  230. return js_string(vm, "min2"sv);
  231. case UseGrouping::False:
  232. return Value(false);
  233. default:
  234. VERIFY_NOT_REACHED();
  235. }
  236. }
  237. void NumberFormat::set_use_grouping(StringOrBoolean const& use_grouping)
  238. {
  239. use_grouping.visit(
  240. [this](StringView grouping) {
  241. if (grouping == "always"sv)
  242. m_use_grouping = UseGrouping::Always;
  243. else if (grouping == "auto"sv)
  244. m_use_grouping = UseGrouping::Auto;
  245. else if (grouping == "min2"sv)
  246. m_use_grouping = UseGrouping::Min2;
  247. else
  248. VERIFY_NOT_REACHED();
  249. },
  250. [this](bool grouping) {
  251. VERIFY(!grouping);
  252. m_use_grouping = UseGrouping::False;
  253. });
  254. }
  255. void NumberFormat::set_notation(StringView notation)
  256. {
  257. if (notation == "standard"sv)
  258. m_notation = Notation::Standard;
  259. else if (notation == "scientific"sv)
  260. m_notation = Notation::Scientific;
  261. else if (notation == "engineering"sv)
  262. m_notation = Notation::Engineering;
  263. else if (notation == "compact"sv)
  264. m_notation = Notation::Compact;
  265. else
  266. VERIFY_NOT_REACHED();
  267. }
  268. StringView NumberFormat::notation_string() const
  269. {
  270. switch (m_notation) {
  271. case Notation::Standard:
  272. return "standard"sv;
  273. case Notation::Scientific:
  274. return "scientific"sv;
  275. case Notation::Engineering:
  276. return "engineering"sv;
  277. case Notation::Compact:
  278. return "compact"sv;
  279. default:
  280. VERIFY_NOT_REACHED();
  281. }
  282. }
  283. void NumberFormat::set_compact_display(StringView compact_display)
  284. {
  285. if (compact_display == "short"sv)
  286. m_compact_display = CompactDisplay::Short;
  287. else if (compact_display == "long"sv)
  288. m_compact_display = CompactDisplay::Long;
  289. else
  290. VERIFY_NOT_REACHED();
  291. }
  292. StringView NumberFormat::compact_display_string() const
  293. {
  294. VERIFY(m_compact_display.has_value());
  295. switch (*m_compact_display) {
  296. case CompactDisplay::Short:
  297. return "short"sv;
  298. case CompactDisplay::Long:
  299. return "long"sv;
  300. default:
  301. VERIFY_NOT_REACHED();
  302. }
  303. }
  304. void NumberFormat::set_sign_display(StringView sign_display)
  305. {
  306. if (sign_display == "auto"sv)
  307. m_sign_display = SignDisplay::Auto;
  308. else if (sign_display == "never"sv)
  309. m_sign_display = SignDisplay::Never;
  310. else if (sign_display == "always"sv)
  311. m_sign_display = SignDisplay::Always;
  312. else if (sign_display == "exceptZero"sv)
  313. m_sign_display = SignDisplay::ExceptZero;
  314. else if (sign_display == "negative"sv)
  315. m_sign_display = SignDisplay::Negative;
  316. else
  317. VERIFY_NOT_REACHED();
  318. }
  319. StringView NumberFormat::sign_display_string() const
  320. {
  321. switch (m_sign_display) {
  322. case SignDisplay::Auto:
  323. return "auto"sv;
  324. case SignDisplay::Never:
  325. return "never"sv;
  326. case SignDisplay::Always:
  327. return "always"sv;
  328. case SignDisplay::ExceptZero:
  329. return "exceptZero"sv;
  330. case SignDisplay::Negative:
  331. return "negative"sv;
  332. default:
  333. VERIFY_NOT_REACHED();
  334. }
  335. }
  336. static ALWAYS_INLINE int log10floor(Value number)
  337. {
  338. if (number.is_number())
  339. return static_cast<int>(floor(log10(number.as_double())));
  340. // FIXME: Can we do this without string conversion?
  341. auto as_string = number.as_bigint().big_integer().to_base(10);
  342. return as_string.length() - 1;
  343. }
  344. static Value increment(GlobalObject& global_object, Value lhs)
  345. {
  346. if (lhs.is_number())
  347. return Value(lhs.as_double() + 1);
  348. return js_bigint(global_object.vm(), lhs.as_bigint().big_integer().plus("1"_bigint));
  349. }
  350. static Value decrement(GlobalObject& global_object, Value lhs)
  351. {
  352. if (lhs.is_number())
  353. return Value(lhs.as_double() - 1);
  354. return js_bigint(global_object.vm(), lhs.as_bigint().big_integer().minus("1"_bigint));
  355. }
  356. static Value subtract(GlobalObject& global_object, Value lhs, Value rhs)
  357. {
  358. if (lhs.is_number())
  359. return Value(lhs.as_double() - rhs.as_double());
  360. return js_bigint(global_object.vm(), lhs.as_bigint().big_integer().minus(rhs.as_bigint().big_integer()));
  361. }
  362. static Value multiply(GlobalObject& global_object, Value lhs, Checked<i32> rhs)
  363. {
  364. if (lhs.is_number())
  365. return Value(lhs.as_double() * rhs.value());
  366. auto rhs_bigint = Crypto::SignedBigInteger::create_from(rhs.value());
  367. return js_bigint(global_object.vm(), lhs.as_bigint().big_integer().multiplied_by(rhs_bigint));
  368. }
  369. static Value divide(GlobalObject& global_object, Value lhs, Checked<i32> rhs)
  370. {
  371. if (lhs.is_number())
  372. return Value(lhs.as_double() / rhs.value());
  373. auto rhs_bigint = Crypto::SignedBigInteger::create_from(rhs.value());
  374. return js_bigint(global_object.vm(), lhs.as_bigint().big_integer().divided_by(rhs_bigint).quotient);
  375. }
  376. static Value divide(GlobalObject& global_object, Value lhs, Value rhs)
  377. {
  378. if (lhs.is_number())
  379. return Value(lhs.as_double() / rhs.as_double());
  380. return js_bigint(global_object.vm(), lhs.as_bigint().big_integer().divided_by(rhs.as_bigint().big_integer()).quotient);
  381. }
  382. static Crypto::SignedBigInteger bigint_power(Checked<i32> base, Checked<i32> exponent)
  383. {
  384. VERIFY(exponent >= 0);
  385. auto base_bigint = Crypto::SignedBigInteger::create_from(base.value());
  386. auto result = Crypto::SignedBigInteger::create_from(1);
  387. for (i32 i = 0; i < exponent; ++i)
  388. result = result.multiplied_by(base_bigint);
  389. return result;
  390. }
  391. static ALWAYS_INLINE Value multiply_by_power(GlobalObject& global_object, Value number, Checked<i32> exponent)
  392. {
  393. if (number.is_number())
  394. return Value(number.as_double() * pow(10, exponent.value()));
  395. if (exponent < 0) {
  396. auto exponent_bigint = bigint_power(10, -exponent.value());
  397. return js_bigint(global_object.vm(), number.as_bigint().big_integer().divided_by(exponent_bigint).quotient);
  398. }
  399. auto exponent_bigint = bigint_power(10, exponent);
  400. return js_bigint(global_object.vm(), number.as_bigint().big_integer().multiplied_by(exponent_bigint));
  401. }
  402. static ALWAYS_INLINE Value divide_by_power(GlobalObject& global_object, Value number, Checked<i32> exponent)
  403. {
  404. if (number.is_number()) {
  405. if (exponent < 0)
  406. return Value(number.as_double() * pow(10, -exponent.value()));
  407. return Value(number.as_double() / pow(10, exponent.value()));
  408. }
  409. if (exponent < 0) {
  410. auto exponent_bigint = bigint_power(10, -exponent.value());
  411. return js_bigint(global_object.vm(), number.as_bigint().big_integer().multiplied_by(exponent_bigint));
  412. }
  413. auto exponent_bigint = bigint_power(10, exponent);
  414. return js_bigint(global_object.vm(), number.as_bigint().big_integer().divided_by(exponent_bigint).quotient);
  415. }
  416. static ALWAYS_INLINE bool is_equal(Value lhs, Value rhs)
  417. {
  418. if (lhs.is_number()) {
  419. static constexpr double epsilon = 5e-14;
  420. return fabs(lhs.as_double() - rhs.as_double()) < epsilon;
  421. }
  422. return lhs.as_bigint().big_integer() == rhs.as_bigint().big_integer();
  423. }
  424. static ALWAYS_INLINE bool is_zero(Value number)
  425. {
  426. if (number.is_number())
  427. return number.as_double() == 0.0;
  428. return number.as_bigint().big_integer().is_zero();
  429. }
  430. static bool modulo_is_zero(Value lhs, Checked<i32> rhs)
  431. {
  432. if (lhs.is_number()) {
  433. auto mod = modulo(lhs.as_double(), rhs.value());
  434. return is_equal(Value(mod), Value(0));
  435. }
  436. auto rhs_bigint = Crypto::SignedBigInteger::create_from(rhs.value());
  437. return modulo(lhs.as_bigint().big_integer(), rhs_bigint).is_zero();
  438. }
  439. static ALWAYS_INLINE bool is_greater_than_zero(Value number)
  440. {
  441. if (number.is_number())
  442. return number.as_double() > 0;
  443. return number.as_bigint().big_integer() > "0"_bigint;
  444. }
  445. static ALWAYS_INLINE bool is_less_than_zero(Value number)
  446. {
  447. if (number.is_number())
  448. return number.as_double() < 0;
  449. return number.as_bigint().big_integer() < "0"_bigint;
  450. }
  451. static ALWAYS_INLINE bool is_less_than(Value lhs, Value rhs)
  452. {
  453. if (lhs.is_number())
  454. return !is_equal(lhs, rhs) && (lhs.as_double() < rhs.as_double());
  455. return lhs.as_bigint().big_integer() < rhs.as_bigint().big_integer();
  456. }
  457. static ALWAYS_INLINE String number_to_string(Value number)
  458. {
  459. if (number.is_number())
  460. return number.to_string_without_side_effects();
  461. return number.as_bigint().big_integer().to_base(10);
  462. }
  463. // 15.5.1 CurrencyDigits ( currency ), https://tc39.es/ecma402/#sec-currencydigits
  464. int currency_digits(StringView currency)
  465. {
  466. // 1. If the ISO 4217 currency and funds code list contains currency as an alphabetic code, return the minor
  467. // unit value corresponding to the currency from the list; otherwise, return 2.
  468. if (auto currency_code = Unicode::get_currency_code(currency); currency_code.has_value())
  469. return currency_code->minor_unit.value_or(2);
  470. return 2;
  471. }
  472. // 15.5.3 FormatNumericToString ( intlObject, x ), https://tc39.es/ecma402/#sec-formatnumberstring
  473. // 1.1.5 FormatNumericToString ( intlObject, x ), https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#sec-formatnumberstring
  474. FormatResult format_numeric_to_string(GlobalObject& global_object, NumberFormatBase const& intl_object, Value number)
  475. {
  476. bool is_negative = false;
  477. // 1. If x is negative-zero, then
  478. if (number.is_negative_zero()) {
  479. // a. Let isNegative be true.
  480. is_negative = true;
  481. // b. Let x be the mathematical value 0.
  482. number = Value(0);
  483. }
  484. // 2. Assert: x is a mathematical value.
  485. VERIFY(number.is_number() || number.is_bigint());
  486. // 3. If x < 0, let isNegative be true; else let isNegative be false.
  487. // FIXME: Spec issue: this step would override step 1a, see https://github.com/tc39/proposal-intl-numberformat-v3/issues/67
  488. if (is_less_than_zero(number)) {
  489. is_negative = true;
  490. // 4. If isNegative, then
  491. // a. Let x be -x.
  492. number = multiply(global_object, number, -1);
  493. }
  494. // 5. Let unsignedRoundingMode be GetUnsignedRoundingMode(intlObject.[[RoundingMode]], isNegative).
  495. // FIXME: Spec issue: Intl.PluralRules does not have [[RoundingMode]], see https://github.com/tc39/proposal-intl-numberformat-v3/issues/103
  496. Optional<NumberFormat::UnsignedRoundingMode> unsigned_rounding_mode;
  497. if (intl_object.rounding_mode() != NumberFormat::RoundingMode::Invalid)
  498. unsigned_rounding_mode = get_unsigned_rounding_mode(intl_object.rounding_mode(), is_negative);
  499. RawFormatResult result {};
  500. switch (intl_object.rounding_type()) {
  501. // 6. If intlObject.[[RoundingType]] is significantDigits, then
  502. case NumberFormatBase::RoundingType::SignificantDigits:
  503. // a. Let result be ToRawPrecision(x, intlObject.[[MinimumSignificantDigits]], intlObject.[[MaximumSignificantDigits]], unsignedRoundingMode).
  504. result = to_raw_precision(global_object, number, intl_object.min_significant_digits(), intl_object.max_significant_digits(), unsigned_rounding_mode);
  505. break;
  506. // 7. Else if intlObject.[[RoundingType]] is fractionDigits, then
  507. case NumberFormatBase::RoundingType::FractionDigits:
  508. // a. Let result be ToRawFixed(x, intlObject.[[MinimumFractionDigits]], intlObject.[[MaximumFractionDigits]], intlObject.[[RoundingIncrement]], unsignedRoundingMode).
  509. result = to_raw_fixed(global_object, number, intl_object.min_fraction_digits(), intl_object.max_fraction_digits(), intl_object.rounding_increment(), unsigned_rounding_mode);
  510. break;
  511. // 8. Else,
  512. case NumberFormatBase::RoundingType::MorePrecision:
  513. case NumberFormatBase::RoundingType::LessPrecision: {
  514. // a. Let sResult be ToRawPrecision(x, intlObject.[[MinimumSignificantDigits]], intlObject.[[MaximumSignificantDigits]], unsignedRoundingMode).
  515. auto significant_result = to_raw_precision(global_object, number, intl_object.min_significant_digits(), intl_object.max_significant_digits(), unsigned_rounding_mode);
  516. // b. Let fResult be ToRawFixed(x, intlObject.[[MinimumFractionDigits]], intlObject.[[MaximumFractionDigits]], intlObject.[[RoundingIncrement]], unsignedRoundingMode).
  517. auto fraction_result = to_raw_fixed(global_object, number, intl_object.min_fraction_digits(), intl_object.max_fraction_digits(), intl_object.rounding_increment(), unsigned_rounding_mode);
  518. // c. If intlObj.[[RoundingType]] is morePrecision, then
  519. if (intl_object.rounding_type() == NumberFormatBase::RoundingType::MorePrecision) {
  520. // i. If sResult.[[RoundingMagnitude]] ≤ fResult.[[RoundingMagnitude]], then
  521. if (significant_result.rounding_magnitude <= fraction_result.rounding_magnitude) {
  522. // 1. Let result be sResult.
  523. result = move(significant_result);
  524. }
  525. // ii. Else,
  526. else {
  527. // 2. Let result be fResult.
  528. result = move(fraction_result);
  529. }
  530. }
  531. // d. Else,
  532. else {
  533. // i. Assert: intlObj.[[RoundingType]] is lessPrecision.
  534. VERIFY(intl_object.rounding_type() == NumberFormatBase::RoundingType::LessPrecision);
  535. // ii. If sResult.[[RoundingMagnitude]] ≤ fResult.[[RoundingMagnitude]], then
  536. if (significant_result.rounding_magnitude <= fraction_result.rounding_magnitude) {
  537. // 1. Let result be fResult.
  538. result = move(fraction_result);
  539. }
  540. // iii. Else,
  541. else {
  542. // 1. Let result be sResult.
  543. result = move(significant_result);
  544. }
  545. }
  546. break;
  547. }
  548. default:
  549. VERIFY_NOT_REACHED();
  550. }
  551. // 9. Let x be result.[[RoundedNumber]].
  552. number = result.rounded_number;
  553. // 10. Let string be result.[[FormattedString]].
  554. auto string = move(result.formatted_string);
  555. // 11. If intlObject.[[TrailingZeroDisplay]] is "stripIfInteger" and x modulo 1 = 0, then
  556. if ((intl_object.trailing_zero_display() == NumberFormat::TrailingZeroDisplay::StripIfInteger) && modulo_is_zero(number, 1)) {
  557. // a. If string contains ".", then
  558. if (auto index = string.find('.'); index.has_value()) {
  559. // i. Set string to the substring of string from index 0 to the index of ".".
  560. string = string.substring(0, *index);
  561. }
  562. }
  563. // 12. Let int be result.[[IntegerDigitsCount]].
  564. int digits = result.digits;
  565. // 13. Let minInteger be intlObject.[[MinimumIntegerDigits]].
  566. int min_integer = intl_object.min_integer_digits();
  567. // 14. If int < minInteger, then
  568. if (digits < min_integer) {
  569. // a. Let forwardZeros be the String consisting of minInteger–int occurrences of the character "0".
  570. auto forward_zeros = String::repeated('0', min_integer - digits);
  571. // b. Set string to the string-concatenation of forwardZeros and string.
  572. string = String::formatted("{}{}", forward_zeros, string);
  573. }
  574. // 15. If isNegative and x is 0, then
  575. if (is_negative && is_zero(number)) {
  576. // a. Let x be -0.
  577. number = Value(-0.0);
  578. }
  579. // 16. Else if isNegative, then
  580. else if (is_negative) {
  581. // b. Let x be -x.
  582. number = multiply(global_object, number, -1);
  583. }
  584. // 17. Return the Record { [[RoundedNumber]]: x, [[FormattedString]]: string }.
  585. return { move(string), number };
  586. }
  587. // 15.5.4 PartitionNumberPattern ( numberFormat, x ), https://tc39.es/ecma402/#sec-partitionnumberpattern
  588. Vector<PatternPartition> partition_number_pattern(GlobalObject& global_object, NumberFormat& number_format, Value number)
  589. {
  590. // 1. Let exponent be 0.
  591. int exponent = 0;
  592. String formatted_string;
  593. // 2. If x is NaN, then
  594. if (number.is_nan()) {
  595. // a. Let n be an implementation- and locale-dependent (ILD) String value indicating the NaN value.
  596. formatted_string = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), Unicode::NumericSymbol::NaN).value_or("NaN"sv);
  597. }
  598. // 3. Else if x is +∞, then
  599. else if (number.is_positive_infinity()) {
  600. // a. Let n be an ILD String value indicating positive infinity.
  601. formatted_string = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), Unicode::NumericSymbol::Infinity).value_or("infinity"sv);
  602. }
  603. // 4. Else if x is -∞, then
  604. else if (number.is_negative_infinity()) {
  605. // a. Let n be an ILD String value indicating negative infinity.
  606. // NOTE: The CLDR does not contain unique strings for negative infinity. The negative sign will
  607. // be inserted by the pattern returned from GetNumberFormatPattern.
  608. formatted_string = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), Unicode::NumericSymbol::Infinity).value_or("infinity"sv);
  609. }
  610. // 5. Else,
  611. else {
  612. // a. If numberFormat.[[Style]] is "percent", let x be 100 × x.
  613. if (number_format.style() == NumberFormat::Style::Percent)
  614. number = multiply(global_object, number, 100);
  615. // b. Let exponent be ComputeExponent(numberFormat, x).
  616. exponent = compute_exponent(global_object, number_format, number);
  617. // c. Let x be x × 10^(-exponent).
  618. number = multiply_by_power(global_object, number, -exponent);
  619. // d. Let formatNumberResult be FormatNumericToString(numberFormat, x).
  620. auto format_number_result = format_numeric_to_string(global_object, number_format, number);
  621. // e. Let n be formatNumberResult.[[FormattedString]].
  622. formatted_string = move(format_number_result.formatted_string);
  623. // f. Let x be formatNumberResult.[[RoundedNumber]].
  624. number = format_number_result.rounded_number;
  625. }
  626. Unicode::NumberFormat found_pattern {};
  627. // 6. Let pattern be GetNumberFormatPattern(numberFormat, x).
  628. auto pattern = get_number_format_pattern(global_object, number_format, number, found_pattern);
  629. if (!pattern.has_value())
  630. return {};
  631. // 7. Let result be a new empty List.
  632. Vector<PatternPartition> result;
  633. // 8. Let patternParts be PartitionPattern(pattern).
  634. auto pattern_parts = pattern->visit([](auto const& p) { return partition_pattern(p); });
  635. // 9. For each Record { [[Type]], [[Value]] } patternPart of patternParts, do
  636. for (auto& pattern_part : pattern_parts) {
  637. // a. Let p be patternPart.[[Type]].
  638. auto part = pattern_part.type;
  639. // b. If p is "literal", then
  640. if (part == "literal"sv) {
  641. // i. Append a new Record { [[Type]]: "literal", [[Value]]: patternPart.[[Value]] } as the last element of result.
  642. result.append({ "literal"sv, move(pattern_part.value) });
  643. }
  644. // c. Else if p is equal to "number", then
  645. else if (part == "number"sv) {
  646. // i. Let notationSubParts be PartitionNotationSubPattern(numberFormat, x, n, exponent).
  647. auto notation_sub_parts = partition_notation_sub_pattern(global_object, number_format, number, formatted_string, exponent);
  648. // ii. Append all elements of notationSubParts to result.
  649. result.extend(move(notation_sub_parts));
  650. }
  651. // d. Else if p is equal to "plusSign", then
  652. else if (part == "plusSign"sv) {
  653. // i. Let plusSignSymbol be the ILND String representing the plus sign.
  654. auto plus_sign_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), Unicode::NumericSymbol::PlusSign).value_or("+"sv);
  655. // ii. Append a new Record { [[Type]]: "plusSign", [[Value]]: plusSignSymbol } as the last element of result.
  656. result.append({ "plusSign"sv, plus_sign_symbol });
  657. }
  658. // e. Else if p is equal to "minusSign", then
  659. else if (part == "minusSign"sv) {
  660. // i. Let minusSignSymbol be the ILND String representing the minus sign.
  661. auto minus_sign_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), Unicode::NumericSymbol::MinusSign).value_or("-"sv);
  662. // ii. Append a new Record { [[Type]]: "minusSign", [[Value]]: minusSignSymbol } as the last element of result.
  663. result.append({ "minusSign"sv, minus_sign_symbol });
  664. }
  665. // f. Else if p is equal to "percentSign" and numberFormat.[[Style]] is "percent", then
  666. else if ((part == "percentSign"sv) && (number_format.style() == NumberFormat::Style::Percent)) {
  667. // i. Let percentSignSymbol be the ILND String representing the percent sign.
  668. auto percent_sign_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), Unicode::NumericSymbol::PercentSign).value_or("%"sv);
  669. // ii. Append a new Record { [[Type]]: "percentSign", [[Value]]: percentSignSymbol } as the last element of result.
  670. result.append({ "percentSign"sv, percent_sign_symbol });
  671. }
  672. // g. Else if p is equal to "unitPrefix" and numberFormat.[[Style]] is "unit", then
  673. // h. Else if p is equal to "unitSuffix" and numberFormat.[[Style]] is "unit", then
  674. else if ((part.starts_with("unitIdentifier:"sv)) && (number_format.style() == NumberFormat::Style::Unit)) {
  675. // Note: Our implementation combines "unitPrefix" and "unitSuffix" into one field, "unitIdentifier".
  676. auto identifier_index = part.substring_view("unitIdentifier:"sv.length()).to_uint();
  677. VERIFY(identifier_index.has_value());
  678. // i. Let unit be numberFormat.[[Unit]].
  679. // ii. Let unitDisplay be numberFormat.[[UnitDisplay]].
  680. // 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.
  681. auto unit_identifier = found_pattern.identifiers[*identifier_index];
  682. // iv. Append a new Record { [[Type]]: "unit", [[Value]]: mu } as the last element of result.
  683. result.append({ "unit"sv, unit_identifier });
  684. }
  685. // i. Else if p is equal to "currencyCode" and numberFormat.[[Style]] is "currency", then
  686. // j. Else if p is equal to "currencyPrefix" and numberFormat.[[Style]] is "currency", then
  687. // k. Else if p is equal to "currencySuffix" and numberFormat.[[Style]] is "currency", then
  688. //
  689. // Note: Our implementation manipulates the format string to inject/remove spacing around the
  690. // currency code during GetNumberFormatPattern so that we do not have to do currency
  691. // display / plurality lookups more than once.
  692. else if ((part == "currency"sv) && (number_format.style() == NumberFormat::Style::Currency)) {
  693. result.append({ "currency"sv, number_format.resolve_currency_display() });
  694. }
  695. // l. Else,
  696. else {
  697. // i. Let unknown be an ILND String based on x and p.
  698. // ii. Append a new Record { [[Type]]: "unknown", [[Value]]: unknown } as the last element of result.
  699. // LibUnicode doesn't generate any "unknown" patterns.
  700. VERIFY_NOT_REACHED();
  701. }
  702. }
  703. // 10. Return result.
  704. return result;
  705. }
  706. static Vector<StringView> separate_integer_into_groups(Unicode::NumberGroupings const& grouping_sizes, StringView integer, NumberFormat::UseGrouping use_grouping)
  707. {
  708. Utf8View utf8_integer { integer };
  709. if (utf8_integer.length() <= grouping_sizes.primary_grouping_size)
  710. return { integer };
  711. size_t index = utf8_integer.length() - grouping_sizes.primary_grouping_size;
  712. switch (use_grouping) {
  713. case NumberFormat::UseGrouping::Min2:
  714. if (utf8_integer.length() < 5)
  715. return { integer };
  716. break;
  717. case NumberFormat::UseGrouping::Auto:
  718. if (index < grouping_sizes.minimum_grouping_digits)
  719. return { integer };
  720. break;
  721. case NumberFormat::UseGrouping::Always:
  722. break;
  723. default:
  724. VERIFY_NOT_REACHED();
  725. }
  726. Vector<StringView> groups;
  727. auto add_group = [&](size_t index, size_t length) {
  728. groups.prepend(utf8_integer.unicode_substring_view(index, length).as_string());
  729. };
  730. add_group(index, grouping_sizes.primary_grouping_size);
  731. while (index > grouping_sizes.secondary_grouping_size) {
  732. index -= grouping_sizes.secondary_grouping_size;
  733. add_group(index, grouping_sizes.secondary_grouping_size);
  734. }
  735. if (index > 0)
  736. add_group(0, index);
  737. return groups;
  738. }
  739. // 15.5.5 PartitionNotationSubPattern ( numberFormat, x, n, exponent ), https://tc39.es/ecma402/#sec-partitionnotationsubpattern
  740. // 1.1.7 PartitionNotationSubPattern ( numberFormat, x, n, exponent ), https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#sec-partitionnotationsubpattern
  741. Vector<PatternPartition> partition_notation_sub_pattern(GlobalObject& global_object, NumberFormat& number_format, Value number, String formatted_string, int exponent)
  742. {
  743. // 1. Let result be a new empty List.
  744. Vector<PatternPartition> result;
  745. auto grouping_sizes = Unicode::get_number_system_groupings(number_format.data_locale(), number_format.numbering_system());
  746. if (!grouping_sizes.has_value())
  747. return {};
  748. // 2. If x is NaN, then
  749. if (number.is_nan()) {
  750. // a. Append a new Record { [[Type]]: "nan", [[Value]]: n } as the last element of result.
  751. result.append({ "nan"sv, move(formatted_string) });
  752. }
  753. // 3. Else if x is a non-finite Number, then
  754. else if (number.is_number() && !number.is_finite_number()) {
  755. // a. Append a new Record { [[Type]]: "infinity", [[Value]]: n } as the last element of result.
  756. result.append({ "infinity"sv, move(formatted_string) });
  757. }
  758. // 4. Else,
  759. else {
  760. // a. Let notationSubPattern be GetNotationSubPattern(numberFormat, exponent).
  761. auto notation_sub_pattern = get_notation_sub_pattern(number_format, exponent);
  762. if (!notation_sub_pattern.has_value())
  763. return {};
  764. // b. Let patternParts be PartitionPattern(notationSubPattern).
  765. auto pattern_parts = partition_pattern(*notation_sub_pattern);
  766. // c. For each Record { [[Type]], [[Value]] } patternPart of patternParts, do
  767. for (auto& pattern_part : pattern_parts) {
  768. // i. Let p be patternPart.[[Type]].
  769. auto part = pattern_part.type;
  770. // ii. If p is "literal", then
  771. if (part == "literal"sv) {
  772. // 1. Append a new Record { [[Type]]: "literal", [[Value]]: patternPart.[[Value]] } as the last element of result.
  773. result.append({ "literal"sv, move(pattern_part.value) });
  774. }
  775. // iii. Else if p is equal to "number", then
  776. else if (part == "number"sv) {
  777. // 1. If the numberFormat.[[NumberingSystem]] matches one of the values in the "Numbering System" column of Table 12 below, then
  778. // 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 12.
  779. // b. Replace each digit in n with the value of digits[digit].
  780. // 2. Else use an implementation dependent algorithm to map n to the appropriate representation of n in the given numbering system.
  781. formatted_string = Unicode::replace_digits_for_number_system(number_format.numbering_system(), formatted_string);
  782. // 3. Let decimalSepIndex be StringIndexOf(n, ".", 0).
  783. auto decimal_sep_index = formatted_string.find('.');
  784. StringView integer;
  785. Optional<StringView> fraction;
  786. // 4. If decimalSepIndex > 0, then
  787. if (decimal_sep_index.has_value() && (*decimal_sep_index > 0)) {
  788. // a. Let integer be the substring of n from position 0, inclusive, to position decimalSepIndex, exclusive.
  789. integer = formatted_string.substring_view(0, *decimal_sep_index);
  790. // b. Let fraction be the substring of n from position decimalSepIndex, exclusive, to the end of n.
  791. fraction = formatted_string.substring_view(*decimal_sep_index + 1);
  792. }
  793. // 5. Else,
  794. else {
  795. // a. Let integer be n.
  796. integer = formatted_string;
  797. // b. Let fraction be undefined.
  798. }
  799. // 6. If the numberFormat.[[UseGrouping]] is false, then
  800. if (number_format.use_grouping() == NumberFormat::UseGrouping::False) {
  801. // a. Append a new Record { [[Type]]: "integer", [[Value]]: integer } as the last element of result.
  802. result.append({ "integer"sv, integer });
  803. }
  804. // 7. Else,
  805. else {
  806. // a. Let groupSepSymbol be the implementation-, locale-, and numbering system-dependent (ILND) String representing the grouping separator.
  807. auto group_sep_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), Unicode::NumericSymbol::Group).value_or(","sv);
  808. // 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, which may depend on the value of numberFormat.[[UseGrouping]].
  809. auto groups = separate_integer_into_groups(*grouping_sizes, integer, number_format.use_grouping());
  810. // c. Assert: The number of elements in groups List is greater than 0.
  811. VERIFY(!groups.is_empty());
  812. // d. Repeat, while groups List is not empty,
  813. while (!groups.is_empty()) {
  814. // i. Remove the first element from groups and let integerGroup be the value of that element.
  815. auto integer_group = groups.take_first();
  816. // ii. Append a new Record { [[Type]]: "integer", [[Value]]: integerGroup } as the last element of result.
  817. result.append({ "integer"sv, integer_group });
  818. // iii. If groups List is not empty, then
  819. if (!groups.is_empty()) {
  820. // i. Append a new Record { [[Type]]: "group", [[Value]]: groupSepSymbol } as the last element of result.
  821. result.append({ "group"sv, group_sep_symbol });
  822. }
  823. }
  824. }
  825. // 8. If fraction is not undefined, then
  826. if (fraction.has_value()) {
  827. // a. Let decimalSepSymbol be the ILND String representing the decimal separator.
  828. auto decimal_sep_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), Unicode::NumericSymbol::Decimal).value_or("."sv);
  829. // b. Append a new Record { [[Type]]: "decimal", [[Value]]: decimalSepSymbol } as the last element of result.
  830. result.append({ "decimal"sv, decimal_sep_symbol });
  831. // c. Append a new Record { [[Type]]: "fraction", [[Value]]: fraction } as the last element of result.
  832. result.append({ "fraction"sv, fraction.release_value() });
  833. }
  834. }
  835. // iv. Else if p is equal to "compactSymbol", then
  836. // v. Else if p is equal to "compactName", then
  837. else if (part.starts_with("compactIdentifier:"sv)) {
  838. // Note: Our implementation combines "compactSymbol" and "compactName" into one field, "compactIdentifier".
  839. auto identifier_index = part.substring_view("compactIdentifier:"sv.length()).to_uint();
  840. VERIFY(identifier_index.has_value());
  841. // 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.
  842. auto compact_identifier = number_format.compact_format().identifiers[*identifier_index];
  843. // 2. Append a new Record { [[Type]]: "compact", [[Value]]: compactSymbol } as the last element of result.
  844. result.append({ "compact"sv, compact_identifier });
  845. }
  846. // vi. Else if p is equal to "scientificSeparator", then
  847. else if (part == "scientificSeparator"sv) {
  848. // 1. Let scientificSeparator be the ILND String representing the exponent separator.
  849. auto scientific_separator = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), Unicode::NumericSymbol::Exponential).value_or("E"sv);
  850. // 2. Append a new Record { [[Type]]: "exponentSeparator", [[Value]]: scientificSeparator } as the last element of result.
  851. result.append({ "exponentSeparator"sv, scientific_separator });
  852. }
  853. // vii. Else if p is equal to "scientificExponent", then
  854. else if (part == "scientificExponent"sv) {
  855. // 1. If exponent < 0, then
  856. if (exponent < 0) {
  857. // a. Let minusSignSymbol be the ILND String representing the minus sign.
  858. auto minus_sign_symbol = Unicode::get_number_system_symbol(number_format.data_locale(), number_format.numbering_system(), Unicode::NumericSymbol::MinusSign).value_or("-"sv);
  859. // b. Append a new Record { [[Type]]: "exponentMinusSign", [[Value]]: minusSignSymbol } as the last element of result.
  860. result.append({ "exponentMinusSign"sv, minus_sign_symbol });
  861. // c. Let exponent be -exponent.
  862. exponent *= -1;
  863. }
  864. // 2. Let exponentResult be ToRawFixed(exponent, 0, 0, 1, undefined).
  865. auto exponent_result = to_raw_fixed(global_object, Value(exponent), 0, 0, 1, {});
  866. // FIXME: The spec does not say to do this, but all of major engines perform this replacement.
  867. // Without this, formatting with non-Latin numbering systems will produce non-localized results.
  868. exponent_result.formatted_string = Unicode::replace_digits_for_number_system(number_format.numbering_system(), exponent_result.formatted_string);
  869. // 3. Append a new Record { [[Type]]: "exponentInteger", [[Value]]: exponentResult.[[FormattedString]] } as the last element of result.
  870. result.append({ "exponentInteger"sv, move(exponent_result.formatted_string) });
  871. }
  872. // viii. Else,
  873. else {
  874. // 1. Let unknown be an ILND String based on x and p.
  875. // 2. Append a new Record { [[Type]]: "unknown", [[Value]]: unknown } as the last element of result.
  876. // LibUnicode doesn't generate any "unknown" patterns.
  877. VERIFY_NOT_REACHED();
  878. }
  879. }
  880. }
  881. // 5. Return result.
  882. return result;
  883. }
  884. // 15.5.6 FormatNumeric ( numberFormat, x ), https://tc39.es/ecma402/#sec-formatnumber
  885. String format_numeric(GlobalObject& global_object, NumberFormat& number_format, Value number)
  886. {
  887. // 1. Let parts be ? PartitionNumberPattern(numberFormat, x).
  888. // Note: Our implementation of PartitionNumberPattern does not throw.
  889. auto parts = partition_number_pattern(global_object, number_format, number);
  890. // 2. Let result be the empty String.
  891. StringBuilder result;
  892. // 3. For each Record { [[Type]], [[Value]] } part in parts, do
  893. for (auto& part : parts) {
  894. // a. Set result to the string-concatenation of result and part.[[Value]].
  895. result.append(move(part.value));
  896. }
  897. // 4. Return result.
  898. return result.build();
  899. }
  900. // 15.5.7 FormatNumericToParts ( numberFormat, x ), https://tc39.es/ecma402/#sec-formatnumbertoparts
  901. Array* format_numeric_to_parts(GlobalObject& global_object, NumberFormat& number_format, Value number)
  902. {
  903. auto& vm = global_object.vm();
  904. // 1. Let parts be ? PartitionNumberPattern(numberFormat, x).
  905. // Note: Our implementation of PartitionNumberPattern does not throw.
  906. auto parts = partition_number_pattern(global_object, number_format, number);
  907. // 2. Let result be ! ArrayCreate(0).
  908. auto* result = MUST(Array::create(global_object, 0));
  909. // 3. Let n be 0.
  910. size_t n = 0;
  911. // 4. For each Record { [[Type]], [[Value]] } part in parts, do
  912. for (auto& part : parts) {
  913. // a. Let O be OrdinaryObjectCreate(%Object.prototype%).
  914. auto* object = Object::create(global_object, global_object.object_prototype());
  915. // b. Perform ! CreateDataPropertyOrThrow(O, "type", part.[[Type]]).
  916. MUST(object->create_data_property_or_throw(vm.names.type, js_string(vm, part.type)));
  917. // c. Perform ! CreateDataPropertyOrThrow(O, "value", part.[[Value]]).
  918. MUST(object->create_data_property_or_throw(vm.names.value, js_string(vm, move(part.value))));
  919. // d. Perform ! CreateDataPropertyOrThrow(result, ! ToString(n), O).
  920. MUST(result->create_data_property_or_throw(n, object));
  921. // e. Increment n by 1.
  922. ++n;
  923. }
  924. // 5. Return result.
  925. return result;
  926. }
  927. static String cut_trailing_zeroes(StringView string, int cut)
  928. {
  929. // These steps are exactly the same between ToRawPrecision and ToRawFixed.
  930. // Repeat, while cut > 0 and the last character of m is "0",
  931. while ((cut > 0) && string.ends_with('0')) {
  932. // Remove the last character from m.
  933. string = string.substring_view(0, string.length() - 1);
  934. // Decrease cut by 1.
  935. --cut;
  936. }
  937. // If the last character of m is ".", then
  938. if (string.ends_with('.')) {
  939. // Remove the last character from m.
  940. string = string.substring_view(0, string.length() - 1);
  941. }
  942. return string.to_string();
  943. }
  944. enum class PreferredResult {
  945. LessThanNumber,
  946. GreaterThanNumber,
  947. };
  948. // ToRawPrecisionFn, https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#eqn-ToRawPrecisionFn
  949. static auto to_raw_precision_function(GlobalObject& global_object, Value number, int precision, PreferredResult mode)
  950. {
  951. struct {
  952. Value number;
  953. int exponent { 0 };
  954. Value rounded;
  955. } result {};
  956. result.exponent = log10floor(number);
  957. if (number.is_number()) {
  958. result.number = divide_by_power(global_object, number, result.exponent - precision + 1);
  959. switch (mode) {
  960. case PreferredResult::LessThanNumber:
  961. result.number = Value(floor(result.number.as_double()));
  962. break;
  963. case PreferredResult::GreaterThanNumber:
  964. result.number = Value(ceil(result.number.as_double()));
  965. break;
  966. }
  967. } else {
  968. // NOTE: In order to round the BigInt to the proper precision, this computation is initially off by a
  969. // factor of 10. This lets us inspect the ones digit and then round up if needed.
  970. result.number = divide_by_power(global_object, number, result.exponent - precision);
  971. // FIXME: Can we do this without string conversion?
  972. auto digits = result.number.as_bigint().big_integer().to_base(10);
  973. auto digit = digits.substring_view(digits.length() - 1);
  974. result.number = divide(global_object, result.number, 10);
  975. if (mode == PreferredResult::GreaterThanNumber && digit.to_uint().value() != 0)
  976. result.number = js_bigint(global_object.vm(), result.number.as_bigint().big_integer().plus("1"_bigint));
  977. }
  978. result.rounded = multiply_by_power(global_object, result.number, result.exponent - precision + 1);
  979. return result;
  980. }
  981. // 15.5.8 ToRawPrecision ( x, minPrecision, maxPrecision ), https://tc39.es/ecma402/#sec-torawprecision
  982. // 1.1.10 ToRawPrecision ( x, minPrecision, maxPrecision, unsignedRoundingMode ), https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#sec-torawprecision
  983. RawFormatResult to_raw_precision(GlobalObject& global_object, Value number, int min_precision, int max_precision, Optional<NumberFormat::UnsignedRoundingMode> const& unsigned_rounding_mode)
  984. {
  985. RawFormatResult result {};
  986. // 1. Let p be maxPrecision.
  987. int precision = max_precision;
  988. int exponent = 0;
  989. // 2. If x = 0, then
  990. if (is_zero(number)) {
  991. // a. Let m be the String consisting of p occurrences of the character "0".
  992. result.formatted_string = String::repeated('0', precision);
  993. // b. Let e be 0.
  994. exponent = 0;
  995. // c. Let xFinal be 0.
  996. result.rounded_number = Value(0);
  997. }
  998. // 3. Else,
  999. else {
  1000. // FIXME: The result of these steps isn't entirely accurate for large values of 'p' (which
  1001. // defaults to 21, resulting in numbers on the order of 10^21). Either AK::format or
  1002. // our Number::toString AO (double_to_string in Value.cpp) will need to be improved
  1003. // to produce more accurate results.
  1004. // a. Let n1 and e1 each be an integer and r1 a mathematical value, with r1 = ToRawPrecisionFn(n1, e1, p), such that r1 ≤ x and r1 is maximized.
  1005. auto [number1, exponent1, rounded1] = to_raw_precision_function(global_object, number, precision, PreferredResult::LessThanNumber);
  1006. // b. Let n2 and e2 each be an integer and r2 a mathematical value, with r2 = ToRawPrecisionFn(n2, e2, p), such that r2 ≥ x and r2 is minimized.
  1007. auto [number2, exponent2, rounded2] = to_raw_precision_function(global_object, number, precision, PreferredResult::GreaterThanNumber);
  1008. // c. Let r be ApplyUnsignedRoundingMode(x, r1, r2, unsignedRoundingMode).
  1009. auto rounded = apply_unsigned_rounding_mode(global_object, number, rounded1, rounded2, unsigned_rounding_mode);
  1010. Value n;
  1011. // d. If r is r1, then
  1012. if (is_equal(rounded, rounded1)) {
  1013. // i. Let n be n1.
  1014. n = number1;
  1015. // ii. Let e be e1.
  1016. exponent = exponent1;
  1017. // iii. Let xFinal be r1.
  1018. result.rounded_number = rounded1;
  1019. }
  1020. // e. Else,
  1021. else {
  1022. // i. Let n be n2.
  1023. n = number2;
  1024. // ii. Let e be e2.
  1025. exponent = exponent2;
  1026. // iii. Let xFinal be r2.
  1027. result.rounded_number = rounded2;
  1028. }
  1029. // f. Let m be the String consisting of the digits of the decimal representation of n (in order, with no leading zeroes).
  1030. result.formatted_string = number_to_string(n);
  1031. }
  1032. // 4. If e ≥ p–1, then
  1033. if (exponent >= (precision - 1)) {
  1034. // a. Let m be the string-concatenation of m and e–p+1 occurrences of the character "0".
  1035. result.formatted_string = String::formatted(
  1036. "{}{}",
  1037. result.formatted_string,
  1038. String::repeated('0', exponent - precision + 1));
  1039. // b. Let int be e+1.
  1040. result.digits = exponent + 1;
  1041. }
  1042. // 5. Else if e ≥ 0, then
  1043. else if (exponent >= 0) {
  1044. // 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.
  1045. result.formatted_string = String::formatted(
  1046. "{}.{}",
  1047. result.formatted_string.substring_view(0, exponent + 1),
  1048. result.formatted_string.substring_view(exponent + 1));
  1049. // b. Let int be e+1.
  1050. result.digits = exponent + 1;
  1051. }
  1052. // 6. Else,
  1053. else {
  1054. // a. Assert: e < 0.
  1055. // b. Let m be the string-concatenation of "0.", –(e+1) occurrences of the character "0", and m.
  1056. result.formatted_string = String::formatted(
  1057. "0.{}{}",
  1058. String::repeated('0', -1 * (exponent + 1)),
  1059. result.formatted_string);
  1060. // c. Let int be 1.
  1061. result.digits = 1;
  1062. }
  1063. // 7. If m contains the character ".", and maxPrecision > minPrecision, then
  1064. if (result.formatted_string.contains('.') && (max_precision > min_precision)) {
  1065. // a. Let cut be maxPrecision – minPrecision.
  1066. int cut = max_precision - min_precision;
  1067. // Steps 8b-8c are implemented by cut_trailing_zeroes.
  1068. result.formatted_string = cut_trailing_zeroes(result.formatted_string, cut);
  1069. }
  1070. // 8. Return the Record { [[FormattedString]]: m, [[RoundedNumber]]: xFinal, [[IntegerDigitsCount]]: int, [[RoundingMagnitude]]: e–p+1 }.
  1071. result.rounding_magnitude = exponent - precision + 1;
  1072. return result;
  1073. }
  1074. // ToRawFixedFn, https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#eqn-ToRawFixedFn
  1075. static auto to_raw_fixed_function(GlobalObject& global_object, Value number, int fraction, int rounding_increment, PreferredResult mode)
  1076. {
  1077. struct {
  1078. Value number;
  1079. Value rounded;
  1080. } result {};
  1081. if (number.is_number()) {
  1082. result.number = multiply_by_power(global_object, number, fraction);
  1083. switch (mode) {
  1084. case PreferredResult::LessThanNumber:
  1085. result.number = Value(floor(result.number.as_double()));
  1086. break;
  1087. case PreferredResult::GreaterThanNumber:
  1088. result.number = Value(ceil(result.number.as_double()));
  1089. break;
  1090. }
  1091. } else {
  1092. // NOTE: In order to round the BigInt to the proper precision, this computation is initially off by a
  1093. // factor of 10. This lets us inspect the ones digit and then round up if needed.
  1094. result.number = multiply_by_power(global_object, number, fraction - 1);
  1095. // FIXME: Can we do this without string conversion?
  1096. auto digits = result.number.as_bigint().big_integer().to_base(10);
  1097. auto digit = digits.substring_view(digits.length() - 1);
  1098. result.number = multiply(global_object, result.number, 10);
  1099. if (mode == PreferredResult::GreaterThanNumber && digit.to_uint().value() != 0)
  1100. result.number = js_bigint(global_object.vm(), result.number.as_bigint().big_integer().plus("1"_bigint));
  1101. }
  1102. while (!modulo_is_zero(result.number, rounding_increment)) {
  1103. switch (mode) {
  1104. case PreferredResult::LessThanNumber:
  1105. result.number = decrement(global_object, result.number);
  1106. break;
  1107. case PreferredResult::GreaterThanNumber:
  1108. result.number = increment(global_object, result.number);
  1109. break;
  1110. }
  1111. }
  1112. result.rounded = divide_by_power(global_object, result.number, fraction);
  1113. return result;
  1114. }
  1115. // 15.5.9 ToRawFixed ( x, minInteger, minFraction, maxFraction ), https://tc39.es/ecma402/#sec-torawfixed
  1116. // 1.1.11 ToRawFixed ( x, minFraction, maxFraction, roundingIncrement, unsignedRoundingMode ), https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#sec-torawfixed
  1117. RawFormatResult to_raw_fixed(GlobalObject& global_object, Value number, int min_fraction, int max_fraction, int rounding_increment, Optional<NumberFormat::UnsignedRoundingMode> const& unsigned_rounding_mode)
  1118. {
  1119. RawFormatResult result {};
  1120. // 1. Let f be maxFraction.
  1121. int fraction = max_fraction;
  1122. // 2. Let n1 be an integer and r1 a mathematical value, with r1 = ToRawFixedFn(n1, f), such that n1 modulo roundingIncrement = 0, r1 ≤ x, and r1 is maximized.
  1123. auto [number1, rounded1] = to_raw_fixed_function(global_object, number, fraction, rounding_increment, PreferredResult::LessThanNumber);
  1124. // 3. Let n2 be an integer and r2 a mathematical value, with r2 = ToRawFixedFn(n2, f), such that n2 modulo roundingIncrement = 0, r2 ≥ x, and r2 is minimized.
  1125. auto [number2, rounded2] = to_raw_fixed_function(global_object, number, fraction, rounding_increment, PreferredResult::GreaterThanNumber);
  1126. // 4. Let r be ApplyUnsignedRoundingMode(x, r1, r2, unsignedRoundingMode).
  1127. auto rounded = apply_unsigned_rounding_mode(global_object, number, rounded1, rounded2, unsigned_rounding_mode);
  1128. Value n;
  1129. // 5. If r is r1, then
  1130. if (is_equal(rounded, rounded1)) {
  1131. // a. Let n be n1.
  1132. n = number1;
  1133. // b. Let xFinal be r1.
  1134. result.rounded_number = rounded1;
  1135. }
  1136. // 6. Else,
  1137. else {
  1138. // a. Let n be n2.
  1139. n = number2;
  1140. // b. Let xFinal be r2.
  1141. result.rounded_number = rounded2;
  1142. }
  1143. // 7. If n = 0, let m be "0". Otherwise, let m be the String consisting of the digits of the decimal representation of n (in order, with no leading zeroes).
  1144. result.formatted_string = is_zero(n) ? String("0"sv) : number_to_string(n);
  1145. // 8. If f ≠ 0, then
  1146. if (fraction != 0) {
  1147. // a. Let k be the number of characters in m.
  1148. auto decimals = result.formatted_string.length();
  1149. // b. If k ≤ f, then
  1150. if (decimals <= static_cast<size_t>(fraction)) {
  1151. // i. Let z be the String value consisting of f+1–k occurrences of the character "0".
  1152. auto zeroes = String::repeated('0', fraction + 1 - decimals);
  1153. // ii. Let m be the string-concatenation of z and m.
  1154. result.formatted_string = String::formatted("{}{}", zeroes, result.formatted_string);
  1155. // iii. Let k be f+1.
  1156. decimals = fraction + 1;
  1157. }
  1158. // c. Let a be the first k–f characters of m, and let b be the remaining f characters of m.
  1159. auto a = result.formatted_string.substring_view(0, decimals - fraction);
  1160. auto b = result.formatted_string.substring_view(decimals - fraction, fraction);
  1161. // d. Let m be the string-concatenation of a, ".", and b.
  1162. result.formatted_string = String::formatted("{}.{}", a, b);
  1163. // e. Let int be the number of characters in a.
  1164. result.digits = a.length();
  1165. }
  1166. // 9. Else, let int be the number of characters in m.
  1167. else {
  1168. result.digits = result.formatted_string.length();
  1169. }
  1170. // 10. Let cut be maxFraction – minFraction.
  1171. int cut = max_fraction - min_fraction;
  1172. // Steps 11-12 are implemented by cut_trailing_zeroes.
  1173. result.formatted_string = cut_trailing_zeroes(result.formatted_string, cut);
  1174. // 13. Return the Record { [[FormattedString]]: m, [[RoundedNumber]]: xFinal, [[IntegerDigitsCount]]: int, [[RoundingMagnitude]]: –f }.
  1175. result.rounding_magnitude = -fraction;
  1176. return result;
  1177. }
  1178. // 15.5.11 GetNumberFormatPattern ( numberFormat, x ), https://tc39.es/ecma402/#sec-getnumberformatpattern
  1179. // 1.1.14 GetNumberFormatPattern ( numberFormat, x ), https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#sec-getnumberformatpattern
  1180. Optional<Variant<StringView, String>> get_number_format_pattern(GlobalObject& global_object, NumberFormat& number_format, Value number, Unicode::NumberFormat& found_pattern)
  1181. {
  1182. // 1. Let localeData be %NumberFormat%.[[LocaleData]].
  1183. // 2. Let dataLocale be numberFormat.[[DataLocale]].
  1184. // 3. Let dataLocaleData be localeData.[[<dataLocale>]].
  1185. // 4. Let patterns be dataLocaleData.[[patterns]].
  1186. // 5. Assert: patterns is a Record (see 15.3.3).
  1187. Optional<Unicode::NumberFormat> patterns;
  1188. // 6. Let style be numberFormat.[[Style]].
  1189. switch (number_format.style()) {
  1190. // 7. If style is "percent", then
  1191. case NumberFormat::Style::Percent:
  1192. // a. Let patterns be patterns.[[percent]].
  1193. patterns = Unicode::get_standard_number_system_format(number_format.data_locale(), number_format.numbering_system(), Unicode::StandardNumberFormatType::Percent);
  1194. break;
  1195. // 8. Else if style is "unit", then
  1196. case NumberFormat::Style::Unit: {
  1197. // a. Let unit be numberFormat.[[Unit]].
  1198. // b. Let unitDisplay be numberFormat.[[UnitDisplay]].
  1199. // c. Let patterns be patterns.[[unit]].
  1200. // d. If patterns doesn't have a field [[<unit>]], then
  1201. // i. Let unit be "fallback".
  1202. // e. Let patterns be patterns.[[<unit>]].
  1203. // f. Let patterns be patterns.[[<unitDisplay>]].
  1204. auto formats = Unicode::get_unit_formats(number_format.data_locale(), number_format.unit(), number_format.unit_display());
  1205. auto plurality = resolve_plural(global_object, number_format, Unicode::PluralForm::Cardinal, number);
  1206. if (auto it = formats.find_if([&](auto& p) { return p.plurality == plurality; }); it != formats.end())
  1207. patterns = move(*it);
  1208. break;
  1209. }
  1210. // 9. Else if style is "currency", then
  1211. case NumberFormat::Style::Currency:
  1212. // a. Let currency be numberFormat.[[Currency]].
  1213. // b. Let currencyDisplay be numberFormat.[[CurrencyDisplay]].
  1214. // c. Let currencySign be numberFormat.[[CurrencySign]].
  1215. // d. Let patterns be patterns.[[currency]].
  1216. // e. If patterns doesn't have a field [[<currency>]], then
  1217. // i. Let currency be "fallback".
  1218. // f. Let patterns be patterns.[[<currency>]].
  1219. // g. Let patterns be patterns.[[<currencyDisplay>]].
  1220. // h. Let patterns be patterns.[[<currencySign>]].
  1221. // Handling of other [[CurrencyDisplay]] options will occur after [[SignDisplay]].
  1222. if (number_format.currency_display() == NumberFormat::CurrencyDisplay::Name) {
  1223. auto formats = Unicode::get_compact_number_system_formats(number_format.data_locale(), number_format.numbering_system(), Unicode::CompactNumberFormatType::CurrencyUnit);
  1224. auto plurality = resolve_plural(global_object, number_format, Unicode::PluralForm::Cardinal, number);
  1225. if (auto it = formats.find_if([&](auto& p) { return p.plurality == plurality; }); it != formats.end()) {
  1226. patterns = move(*it);
  1227. break;
  1228. }
  1229. }
  1230. switch (number_format.currency_sign()) {
  1231. case NumberFormat::CurrencySign::Standard:
  1232. patterns = Unicode::get_standard_number_system_format(number_format.data_locale(), number_format.numbering_system(), Unicode::StandardNumberFormatType::Currency);
  1233. break;
  1234. case NumberFormat::CurrencySign::Accounting:
  1235. patterns = Unicode::get_standard_number_system_format(number_format.data_locale(), number_format.numbering_system(), Unicode::StandardNumberFormatType::Accounting);
  1236. break;
  1237. }
  1238. break;
  1239. // 10. Else,
  1240. case NumberFormat::Style::Decimal:
  1241. // a. Assert: style is "decimal".
  1242. // b. Let patterns be patterns.[[decimal]].
  1243. patterns = Unicode::get_standard_number_system_format(number_format.data_locale(), number_format.numbering_system(), Unicode::StandardNumberFormatType::Decimal);
  1244. break;
  1245. default:
  1246. VERIFY_NOT_REACHED();
  1247. }
  1248. if (!patterns.has_value())
  1249. return {};
  1250. StringView pattern;
  1251. bool is_positive_zero = number.is_positive_zero() || (number.is_bigint() && is_zero(number));
  1252. bool is_negative_zero = number.is_negative_zero();
  1253. bool is_nan = number.is_nan();
  1254. // 11. Let signDisplay be numberFormat.[[SignDisplay]].
  1255. switch (number_format.sign_display()) {
  1256. // 12. If signDisplay is "never", then
  1257. case NumberFormat::SignDisplay::Never:
  1258. // a. Let pattern be patterns.[[zeroPattern]].
  1259. pattern = patterns->zero_format;
  1260. break;
  1261. // 13. Else if signDisplay is "auto", then
  1262. case NumberFormat::SignDisplay::Auto:
  1263. // a. If x is 0 or x > 0 or x is NaN, then
  1264. if (is_positive_zero || is_greater_than_zero(number) || is_nan) {
  1265. // i. Let pattern be patterns.[[zeroPattern]].
  1266. pattern = patterns->zero_format;
  1267. }
  1268. // b. Else,
  1269. else {
  1270. // i. Let pattern be patterns.[[negativePattern]].
  1271. pattern = patterns->negative_format;
  1272. }
  1273. break;
  1274. // 14. Else if signDisplay is "always", then
  1275. case NumberFormat::SignDisplay::Always:
  1276. // a. If x is 0 or x > 0 or x is NaN, then
  1277. if (is_positive_zero || is_greater_than_zero(number) || is_nan) {
  1278. // i. Let pattern be patterns.[[positivePattern]].
  1279. pattern = patterns->positive_format;
  1280. }
  1281. // b. Else,
  1282. else {
  1283. // i. Let pattern be patterns.[[negativePattern]].
  1284. pattern = patterns->negative_format;
  1285. }
  1286. break;
  1287. // 15. Else if signDisplay is "exceptZero", then
  1288. case NumberFormat::SignDisplay::ExceptZero:
  1289. // a. If x is NaN, or if x is finite and ℝ(x) is 0, then
  1290. if (is_positive_zero || is_negative_zero || is_nan) {
  1291. // i. Let pattern be patterns.[[zeroPattern]].
  1292. pattern = patterns->zero_format;
  1293. }
  1294. // b. Else if ℝ(x) > 0, then
  1295. else if (is_greater_than_zero(number)) {
  1296. // i. Let pattern be patterns.[[positivePattern]].
  1297. pattern = patterns->positive_format;
  1298. }
  1299. // c. Else,
  1300. else {
  1301. // i. Let pattern be patterns.[[negativePattern]].
  1302. pattern = patterns->negative_format;
  1303. }
  1304. break;
  1305. // 16. Else,
  1306. case NumberFormat::SignDisplay::Negative:
  1307. // a. Assert: signDisplay is "negative".
  1308. // b. If x is 0 or x is -0 or x > 0 or x is NaN, then
  1309. if (is_positive_zero || is_negative_zero || is_greater_than_zero(number) || is_nan) {
  1310. // i. Let pattern be patterns.[[zeroPattern]].
  1311. pattern = patterns->zero_format;
  1312. }
  1313. // c. Else,
  1314. else {
  1315. // i. Let pattern be patterns.[[negativePattern]].
  1316. pattern = patterns->negative_format;
  1317. }
  1318. break;
  1319. default:
  1320. VERIFY_NOT_REACHED();
  1321. }
  1322. found_pattern = patterns.release_value();
  1323. // Handling of steps 9b/9g: Depending on the currency display and the format pattern found above,
  1324. // we might need to mutate the format pattern to inject a space between the currency display and
  1325. // the currency number.
  1326. if (number_format.style() == NumberFormat::Style::Currency) {
  1327. auto modified_pattern = Unicode::augment_currency_format_pattern(number_format.resolve_currency_display(), pattern);
  1328. if (modified_pattern.has_value())
  1329. return modified_pattern.release_value();
  1330. }
  1331. // 16. Return pattern.
  1332. return pattern;
  1333. }
  1334. // 15.5.12 GetNotationSubPattern ( numberFormat, exponent ), https://tc39.es/ecma402/#sec-getnotationsubpattern
  1335. Optional<StringView> get_notation_sub_pattern(NumberFormat& number_format, int exponent)
  1336. {
  1337. // 1. Let localeData be %NumberFormat%.[[LocaleData]].
  1338. // 2. Let dataLocale be numberFormat.[[DataLocale]].
  1339. // 3. Let dataLocaleData be localeData.[[<dataLocale>]].
  1340. // 4. Let notationSubPatterns be dataLocaleData.[[notationSubPatterns]].
  1341. // 5. Assert: notationSubPatterns is a Record (see 15.3.3).
  1342. // 6. Let notation be numberFormat.[[Notation]].
  1343. auto notation = number_format.notation();
  1344. // 7. If notation is "scientific" or notation is "engineering", then
  1345. if ((notation == NumberFormat::Notation::Scientific) || (notation == NumberFormat::Notation::Engineering)) {
  1346. // a. Return notationSubPatterns.[[scientific]].
  1347. auto notation_sub_patterns = Unicode::get_standard_number_system_format(number_format.data_locale(), number_format.numbering_system(), Unicode::StandardNumberFormatType::Scientific);
  1348. if (!notation_sub_patterns.has_value())
  1349. return {};
  1350. return notation_sub_patterns->zero_format;
  1351. }
  1352. // 8. Else if exponent is not 0, then
  1353. else if (exponent != 0) {
  1354. // a. Assert: notation is "compact".
  1355. VERIFY(notation == NumberFormat::Notation::Compact);
  1356. // b. Let compactDisplay be numberFormat.[[CompactDisplay]].
  1357. // c. Let compactPatterns be notationSubPatterns.[[compact]].[[<compactDisplay>]].
  1358. // d. Return compactPatterns.[[<exponent>]].
  1359. if (number_format.has_compact_format())
  1360. return number_format.compact_format().zero_format;
  1361. }
  1362. // 9. Else,
  1363. // a. Return "{number}".
  1364. return "{number}"sv;
  1365. }
  1366. // 15.5.13 ComputeExponent ( numberFormat, x ), https://tc39.es/ecma402/#sec-computeexponent
  1367. int compute_exponent(GlobalObject& global_object, NumberFormat& number_format, Value number)
  1368. {
  1369. // 1. If x = 0, then
  1370. if (is_zero(number)) {
  1371. // a. Return 0.
  1372. return 0;
  1373. }
  1374. // 2. If x < 0, then
  1375. if (is_less_than_zero(number)) {
  1376. // a. Let x = -x.
  1377. number = multiply(global_object, number, -1);
  1378. }
  1379. // 3. Let magnitude be the base 10 logarithm of x rounded down to the nearest integer.
  1380. int magnitude = log10floor(number);
  1381. // 4. Let exponent be ComputeExponentForMagnitude(numberFormat, magnitude).
  1382. int exponent = compute_exponent_for_magnitude(number_format, magnitude);
  1383. // 5. Let x be x × 10^(-exponent).
  1384. number = multiply_by_power(global_object, number, -exponent);
  1385. // 6. Let formatNumberResult be FormatNumericToString(numberFormat, x).
  1386. auto format_number_result = format_numeric_to_string(global_object, number_format, number);
  1387. // 7. If formatNumberResult.[[RoundedNumber]] = 0, then
  1388. if (is_zero(format_number_result.rounded_number)) {
  1389. // a. Return exponent.
  1390. return exponent;
  1391. }
  1392. // 8. Let newMagnitude be the base 10 logarithm of formatNumberResult.[[RoundedNumber]] rounded down to the nearest integer.
  1393. int new_magnitude = log10floor(format_number_result.rounded_number);
  1394. // 9. If newMagnitude is magnitude – exponent, then
  1395. if (new_magnitude == magnitude - exponent) {
  1396. // a. Return exponent.
  1397. return exponent;
  1398. }
  1399. // 10. Return ComputeExponentForMagnitude(numberFormat, magnitude + 1).
  1400. return compute_exponent_for_magnitude(number_format, magnitude + 1);
  1401. }
  1402. // 15.5.14 ComputeExponentForMagnitude ( numberFormat, magnitude ), https://tc39.es/ecma402/#sec-computeexponentformagnitude
  1403. int compute_exponent_for_magnitude(NumberFormat& number_format, int magnitude)
  1404. {
  1405. // 1. Let notation be numberFormat.[[Notation]].
  1406. switch (number_format.notation()) {
  1407. // 2. If notation is "standard", then
  1408. case NumberFormat::Notation::Standard:
  1409. // a. Return 0.
  1410. return 0;
  1411. // 3. Else if notation is "scientific", then
  1412. case NumberFormat::Notation::Scientific:
  1413. // a. Return magnitude.
  1414. return magnitude;
  1415. // 4. Else if notation is "engineering", then
  1416. case NumberFormat::Notation::Engineering: {
  1417. // a. Let thousands be the greatest integer that is not greater than magnitude / 3.
  1418. double thousands = floor(static_cast<double>(magnitude) / 3.0);
  1419. // b. Return thousands × 3.
  1420. return static_cast<int>(thousands) * 3;
  1421. }
  1422. // 5. Else,
  1423. case NumberFormat::Notation::Compact: {
  1424. // a. Assert: notation is "compact".
  1425. VERIFY(number_format.has_compact_display());
  1426. // 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.
  1427. // c. Return exponent.
  1428. Vector<Unicode::NumberFormat> format_rules;
  1429. if (number_format.style() == NumberFormat::Style::Currency)
  1430. format_rules = Unicode::get_compact_number_system_formats(number_format.data_locale(), number_format.numbering_system(), Unicode::CompactNumberFormatType::CurrencyShort);
  1431. else if (number_format.compact_display() == NumberFormat::CompactDisplay::Long)
  1432. format_rules = Unicode::get_compact_number_system_formats(number_format.data_locale(), number_format.numbering_system(), Unicode::CompactNumberFormatType::DecimalLong);
  1433. else
  1434. format_rules = Unicode::get_compact_number_system_formats(number_format.data_locale(), number_format.numbering_system(), Unicode::CompactNumberFormatType::DecimalShort);
  1435. Unicode::NumberFormat const* best_number_format = nullptr;
  1436. for (auto const& format_rule : format_rules) {
  1437. if (format_rule.magnitude > magnitude)
  1438. break;
  1439. best_number_format = &format_rule;
  1440. }
  1441. if (best_number_format == nullptr)
  1442. return 0;
  1443. number_format.set_compact_format(*best_number_format);
  1444. return best_number_format->exponent;
  1445. }
  1446. default:
  1447. VERIFY_NOT_REACHED();
  1448. }
  1449. }
  1450. // 1.1.19 GetUnsignedRoundingMode ( roundingMode, isNegative ), https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#sec-getunsignedroundingmode
  1451. NumberFormat::UnsignedRoundingMode get_unsigned_rounding_mode(NumberFormat::RoundingMode rounding_mode, bool is_negative)
  1452. {
  1453. // 1. If isNegative is true, return the specification type in the third column of Table 2 where the first column is roundingMode and the second column is "negative".
  1454. // 2. Else, return the specification type in the third column of Table 2 where the first column is roundingMode and the second column is "positive".
  1455. // Table 2: Conversion from rounding mode to unsigned rounding mode, https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#table-intl-unsigned-rounding-modes
  1456. switch (rounding_mode) {
  1457. case NumberFormat::RoundingMode::Ceil:
  1458. return is_negative ? NumberFormat::UnsignedRoundingMode::Zero : NumberFormat::UnsignedRoundingMode::Infinity;
  1459. case NumberFormat::RoundingMode::Floor:
  1460. return is_negative ? NumberFormat::UnsignedRoundingMode::Infinity : NumberFormat::UnsignedRoundingMode::Zero;
  1461. case NumberFormat::RoundingMode::Expand:
  1462. return NumberFormat::UnsignedRoundingMode::Infinity;
  1463. case NumberFormat::RoundingMode::Trunc:
  1464. return NumberFormat::UnsignedRoundingMode::Zero;
  1465. case NumberFormat::RoundingMode::HalfCeil:
  1466. return is_negative ? NumberFormat::UnsignedRoundingMode::HalfZero : NumberFormat::UnsignedRoundingMode::HalfInfinity;
  1467. case NumberFormat::RoundingMode::HalfFloor:
  1468. return is_negative ? NumberFormat::UnsignedRoundingMode::HalfInfinity : NumberFormat::UnsignedRoundingMode::HalfZero;
  1469. case NumberFormat::RoundingMode::HalfExpand:
  1470. return NumberFormat::UnsignedRoundingMode::HalfInfinity;
  1471. case NumberFormat::RoundingMode::HalfTrunc:
  1472. return NumberFormat::UnsignedRoundingMode::HalfZero;
  1473. case NumberFormat::RoundingMode::HalfEven:
  1474. return NumberFormat::UnsignedRoundingMode::HalfEven;
  1475. default:
  1476. VERIFY_NOT_REACHED();
  1477. };
  1478. }
  1479. // 1.1.20 ApplyUnsignedRoundingMode ( x, r1, r2, unsignedRoundingMode ), https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#sec-applyunsignedroundingmode
  1480. Value apply_unsigned_rounding_mode(GlobalObject& global_object, Value x, Value r1, Value r2, Optional<NumberFormat::UnsignedRoundingMode> const& unsigned_rounding_mode)
  1481. {
  1482. // 1. If x is equal to r1, return r1.
  1483. if (is_equal(x, r1))
  1484. return r1;
  1485. // FIXME: We skip this assertion due floating point inaccuracies. For example, entering "1.2345"
  1486. // in the JS REPL results in "1.234499999999999", and may cause this assertion to fail.
  1487. //
  1488. // This should be resolved when the "Intl mathematical value" is implemented to support
  1489. // arbitrarily precise decimals.
  1490. // https://tc39.es/proposal-intl-numberformat-v3/out/numberformat/proposed.html#intl-mathematical-value
  1491. // 2. Assert: r1 < x < r2.
  1492. // 3. Assert: unsignedRoundingMode is not undefined.
  1493. VERIFY(unsigned_rounding_mode.has_value());
  1494. // 4. If unsignedRoundingMode is zero, return r1.
  1495. if (unsigned_rounding_mode == NumberFormat::UnsignedRoundingMode::Zero)
  1496. return r1;
  1497. // 5. If unsignedRoundingMode is infinity, return r2.
  1498. if (unsigned_rounding_mode == NumberFormat::UnsignedRoundingMode::Infinity)
  1499. return r2;
  1500. // 6. Let d1 be x – r1.
  1501. auto d1 = subtract(global_object, x, r1);
  1502. // 7. Let d2 be r2 – x.
  1503. auto d2 = subtract(global_object, r2, x);
  1504. // 8. If d1 < d2, return r1.
  1505. if (is_less_than(d1, d2))
  1506. return r1;
  1507. // 9. If d2 < d1, return r2.
  1508. if (is_less_than(d2, d1))
  1509. return r2;
  1510. // 10. Assert: d1 is equal to d2.
  1511. VERIFY(is_equal(d1, d2));
  1512. // 11. If unsignedRoundingMode is half-zero, return r1.
  1513. if (unsigned_rounding_mode == NumberFormat::UnsignedRoundingMode::HalfZero)
  1514. return r1;
  1515. // 12. If unsignedRoundingMode is half-infinity, return r2.
  1516. if (unsigned_rounding_mode == NumberFormat::UnsignedRoundingMode::HalfInfinity)
  1517. return r2;
  1518. // 13. Assert: unsignedRoundingMode is half-even.
  1519. VERIFY(unsigned_rounding_mode == NumberFormat::UnsignedRoundingMode::HalfEven);
  1520. // 14. Let cardinality be (r1 / (r2 – r1)) modulo 2.
  1521. auto cardinality = subtract(global_object, r2, r1);
  1522. cardinality = divide(global_object, r1, cardinality);
  1523. // 15. If cardinality is 0, return r1.
  1524. if (modulo_is_zero(cardinality, 2))
  1525. return r1;
  1526. // 16. Return r2.
  1527. return r2;
  1528. }
  1529. }