From dde15aaa171b7ac84955b410609111c96b9a19a8 Mon Sep 17 00:00:00 2001
From: Jesse Alama <jessealama@users.noreply.github.com>
Date: Tue, 11 Jun 2024 16:03:49 +0300
Subject: [PATCH] Use "cohort of" and "quantum of" rather than array indices
 (#156)

* Define "finite" and "zero" before "mathematical value"

* Define cohort and quantum as an AO

---------

Co-authored-by: Philip Chimento <pchimento@igalia.com>
---
 index.html | 139 +++++++++++++++++++++++++++--------------------------
 spec.emu   |  67 +++++++++++++++++---------
 2 files changed, 114 insertions(+), 92 deletions(-)

diff --git a/index.html b/index.html
index dd4cdfab..53429848 100644
--- a/index.html
+++ b/index.html
@@ -1559,7 +1559,7 @@
 });
 
 let sdoMap = JSON.parse(`{}`);
-let biblio = JSON.parse(`{"refsByClause":{"sec-decimal.prototype.compare":["_ref_0","_ref_1","_ref_121","_ref_122","_ref_123","_ref_124","_ref_125"],"sec-decimal-method-round":["_ref_2","_ref_3","_ref_126","_ref_127","_ref_128","_ref_129","_ref_130","_ref_131"],"sec-decimal.prototype.tostring":["_ref_4","_ref_132","_ref_133","_ref_134"],"sec-decimal.prototype.toprecision":["_ref_5","_ref_141","_ref_142","_ref_143","_ref_144","_ref_145","_ref_146","_ref_147","_ref_148"],"sec-tointlmathematicalvalue":["_ref_6","_ref_152","_ref_153","_ref_154","_ref_155","_ref_156","_ref_157","_ref_158"],"sec-decimal-intro":["_ref_7","_ref_8","_ref_9","_ref_10","_ref_11","_ref_12","_ref_13","_ref_14","_ref_15","_ref_16","_ref_17","_ref_18","_ref_19","_ref_20","_ref_21","_ref_22","_ref_23","_ref_24","_ref_25","_ref_26","_ref_27","_ref_28","_ref_29","_ref_30","_ref_31","_ref_32","_ref_33","_ref_34","_ref_35","_ref_36","_ref_37","_ref_38","_ref_39","_ref_40","_ref_41","_ref_42","_ref_43","_ref_44","_ref_45","_ref_46","_ref_47","_ref_48"],"sec-decimal128-isintegraldecimal128value":["_ref_49"],"sec-decimal128-value-to-object":["_ref_50"],"sec-decimal128-d":["_ref_51","_ref_52","_ref_53","_ref_54","_ref_55"],"sec-decimal128-canonicalizedecimal128":["_ref_56","_ref_57","_ref_58"],"sec-the-decimal128-constructor-value":["_ref_59","_ref_60","_ref_61","_ref_62","_ref_63"],"sec-decimal.prototype.abs":["_ref_64","_ref_65","_ref_66","_ref_67"],"sec-decimal.prototype.negate":["_ref_68","_ref_69","_ref_70","_ref_71"],"sec-decimal.prototype.add":["_ref_72","_ref_73","_ref_74","_ref_75","_ref_76","_ref_77","_ref_78","_ref_79","_ref_80","_ref_81"],"sec-decimal.prototype.subtract":["_ref_82","_ref_83","_ref_84","_ref_85","_ref_86","_ref_87","_ref_88","_ref_89","_ref_90","_ref_91"],"sec-decimal.prototype.multiply":["_ref_92","_ref_93","_ref_94","_ref_95","_ref_96","_ref_97","_ref_98","_ref_99","_ref_100","_ref_101","_ref_102","_ref_103","_ref_104","_ref_105","_ref_106"],"sec-decimal.prototype.divide":["_ref_107","_ref_108","_ref_109","_ref_110","_ref_111","_ref_112"],"sec-decimal.prototype.remainder":["_ref_113","_ref_114","_ref_115","_ref_116","_ref_117","_ref_118"],"sec-decimal.prototype.equals":["_ref_119"],"sec-decimal.prototype.lessthan":["_ref_120"],"sec-decimal.prototype.toexponential":["_ref_135","_ref_136","_ref_137"],"sec-decimal.prototype.tofixed":["_ref_138","_ref_139","_ref_140"],"sec-number-constructor-number-value":["_ref_149"],"sec-bigint-constructor-number-value":["_ref_150"],"sec-numbertobigint":["_ref_151"],"sec-formatnumberstring":["_ref_159","_ref_160","_ref_161","_ref_162","_ref_163","_ref_164","_ref_165","_ref_166"],"sec-torawprecision":["_ref_167","_ref_168","_ref_169","_ref_170","_ref_171","_ref_172","_ref_173","_ref_174","_ref_175","_ref_176","_ref_177","_ref_178","_ref_179","_ref_180","_ref_181"],"sec-torawfixed":["_ref_182","_ref_183","_ref_184","_ref_185","_ref_186","_ref_187","_ref_188","_ref_189","_ref_190","_ref_191","_ref_192","_ref_193","_ref_194"],"sec-partitionnumberpattern":["_ref_195","_ref_196","_ref_197","_ref_198","_ref_199"]},"entries":[{"type":"clause","id":"sec-decimal-intro-","titleHTML":"Introduction","number":""},{"type":"term","term":"mathematical value","id":"dfn-decimal128-mathematical-value","referencingIds":["_ref_6","_ref_9","_ref_10","_ref_17","_ref_33","_ref_51","_ref_52","_ref_59","_ref_60","_ref_62","_ref_119","_ref_120","_ref_121","_ref_122","_ref_125","_ref_156","_ref_157","_ref_158","_ref_159","_ref_160","_ref_162","_ref_168","_ref_171","_ref_172","_ref_173","_ref_178","_ref_180","_ref_183","_ref_186","_ref_187","_ref_191","_ref_193","_ref_198"]},{"type":"term","term":"finite","id":"dfn-decimal128-finite","referencingIds":["_ref_11","_ref_14","_ref_15","_ref_18","_ref_19","_ref_31","_ref_34","_ref_36","_ref_38","_ref_40","_ref_42","_ref_45","_ref_48","_ref_49","_ref_153","_ref_169","_ref_184"]},{"type":"term","term":"zero","id":"dfn-decimal128-zero","referencingIds":["_ref_7","_ref_8","_ref_12","_ref_13","_ref_16","_ref_20","_ref_24","_ref_25","_ref_32","_ref_35","_ref_37","_ref_39","_ref_41","_ref_43","_ref_44","_ref_46","_ref_47","_ref_96","_ref_101","_ref_155","_ref_177"]},{"type":"term","term":"negative","refId":"sec-decimal-intro"},{"type":"term","term":"rounding mode","id":"dfn-decimal128-rounding-mode","referencingIds":["_ref_21","_ref_22","_ref_26","_ref_53","_ref_72","_ref_82","_ref_92","_ref_107","_ref_113","_ref_126","_ref_128","_ref_131"]},{"type":"term","term":"default rounding mode","id":"dfn-decimal128-default-rounding-mode","referencingIds":["_ref_2","_ref_3"]},{"type":"table","id":"table-decimal128-rounding-modes","number":1,"caption":"Table 1: Rounding modes in Decimal128 compared to IEEE 754 rounding modes"},{"type":"term","term":"cohort","id":"dfn-decimal128-cohort","referencingIds":["_ref_27","_ref_28","_ref_29","_ref_30","_ref_56"]},{"type":"term","term":"exponent","refId":"sec-decimal-intro"},{"type":"term","term":"significand","refId":"sec-decimal-intro"},{"type":"term","term":"normalized","refId":"sec-decimal-intro"},{"type":"term","term":"denormalized","refId":"sec-decimal-intro"},{"type":"term","term":"truncated exponent","refId":"sec-decimal-intro"},{"type":"term","term":"scaled significand","refId":"sec-decimal-intro"},{"type":"clause","id":"sec-decimal-intro","titleHTML":"Introduction","number":"","referencingIds":["_ref_23","_ref_57","_ref_58","_ref_123","_ref_124","_ref_127","_ref_154","_ref_167","_ref_170","_ref_175","_ref_176","_ref_182","_ref_185","_ref_189","_ref_190","_ref_196","_ref_197"]},{"type":"op","aoid":"Decimal128ToDecimalString","refId":"sec-decimal128-decimal128todecimalstring"},{"type":"clause","id":"sec-decimal128-decimal128todecimalstring","title":"Decimal128ToDecimalString ( argument )","titleHTML":"Decimal128ToDecimalString ( <var>argument</var> )","number":"1.1.1","referencingIds":["_ref_132","_ref_134","_ref_138","_ref_140","_ref_141","_ref_143","_ref_146","_ref_148","_ref_174","_ref_188"]},{"type":"op","aoid":"Decimal128ToExponentialString","refId":"sec-decimal128toexponentialstring"},{"type":"clause","id":"sec-decimal128toexponentialstring","title":"Decimal128ToExponentialString ( argument )","titleHTML":"Decimal128ToExponentialString ( <var>argument</var> )","number":"1.1.2","referencingIds":["_ref_135","_ref_137"]},{"type":"op","aoid":"IsIntegralDecimal128","refId":"sec-decimal128-isintegraldecimal128value"},{"type":"clause","id":"sec-decimal128-isintegraldecimal128value","title":"IsIntegralDecimal128 ( argument )","titleHTML":"IsIntegralDecimal128 ( <var>argument</var> )","number":"1.1.3","referencingIds":["_ref_151"]},{"type":"op","aoid":"Decimal128ValueToObject","refId":"sec-decimal128-value-to-object"},{"type":"clause","id":"sec-decimal128-value-to-object","title":"Decimal128ValueToObject ( argument )","titleHTML":"Decimal128ValueToObject ( <var>argument</var> )","number":"1.1.4","referencingIds":["_ref_64","_ref_65","_ref_66","_ref_67","_ref_68","_ref_69","_ref_70","_ref_71","_ref_73","_ref_74","_ref_75","_ref_76","_ref_77","_ref_78","_ref_79","_ref_80","_ref_83","_ref_84","_ref_85","_ref_86","_ref_87","_ref_88","_ref_89","_ref_90","_ref_93","_ref_94","_ref_95","_ref_97","_ref_98","_ref_99","_ref_100","_ref_102","_ref_103","_ref_104","_ref_105","_ref_108","_ref_109","_ref_110","_ref_111","_ref_114","_ref_115","_ref_116","_ref_117","_ref_129"]},{"type":"op","aoid":"EnsureDecimal128Value","refId":"sec-decimal128-d"},{"type":"clause","id":"sec-decimal128-d","title":"EnsureDecimal128Value ( coefficient, intendedExponent, roundingMode )","titleHTML":"EnsureDecimal128Value ( <var>coefficient</var>, <var>intendedExponent</var>, <var>roundingMode</var> )","number":"1.1.5","referencingIds":["_ref_54","_ref_55","_ref_61","_ref_63","_ref_81","_ref_91","_ref_106","_ref_112","_ref_118","_ref_130","_ref_147"]},{"type":"op","aoid":"CanonicalizeDecimal128","refId":"sec-decimal128-canonicalizedecimal128"},{"type":"clause","id":"sec-decimal128-canonicalizedecimal128","title":"CanonicalizeDecimal128 ( d )","titleHTML":"CanonicalizeDecimal128 ( <var>d</var> )","number":"1.1.6","referencingIds":["_ref_133","_ref_136","_ref_139","_ref_142","_ref_144","_ref_145"]},{"type":"clause","id":"sec-decimal-abstract-ops","titleHTML":"Abstract Operations","number":"1.1"},{"type":"term","term":"%Decimal128%","refId":"sec-the-decimal-constructor"},{"type":"clause","id":"sec-the-decimal128-constructor-value","title":"Decimal128 ( x )","titleHTML":"Decimal128 ( <var>x</var> )","number":"1.2.1"},{"type":"clause","id":"sec-the-decimal-constructor","titleHTML":"The Decimal128 Constructor","number":"1.2","referencingIds":["_ref_50","_ref_149"]},{"type":"clause","id":"sec-the-decimal-object","titleHTML":"The Decimal128 Object","number":"1"},{"type":"clause","id":"sec-decimal.prototype.isnan","titleHTML":"Decimal128.prototype.isNaN ( )","number":"2.1"},{"type":"clause","id":"sec-decimal.prototype.isfinite","titleHTML":"Decimal128.prototype.isFinite ( )","number":"2.2"},{"type":"clause","id":"sec-decimal.prototype.abs","titleHTML":"Decimal128.prototype.abs ( )","number":"2.3"},{"type":"clause","id":"sec-decimal.prototype.negate","titleHTML":"Decimal128.prototype.negate ( )","number":"2.4"},{"type":"clause","id":"sec-decimal.prototype.add","title":"Decimal128.prototype.add ( x )","titleHTML":"Decimal128.prototype.add ( <var>x</var> )","number":"2.5"},{"type":"clause","id":"sec-decimal.prototype.subtract","title":"Decimal128.prototype.subtract ( x )","titleHTML":"Decimal128.prototype.subtract ( <var>x</var> )","number":"2.6"},{"type":"clause","id":"sec-decimal.prototype.multiply","title":"Decimal128.prototype.multiply ( x )","titleHTML":"Decimal128.prototype.multiply ( <var>x</var> )","number":"2.7"},{"type":"clause","id":"sec-decimal.prototype.divide","title":"Decimal128.prototype.divide ( x )","titleHTML":"Decimal128.prototype.divide ( <var>x</var> )","number":"2.8"},{"type":"clause","id":"sec-decimal.prototype.remainder","title":"Decimal128.prototype.remainder ( x )","titleHTML":"Decimal128.prototype.remainder ( <var>x</var> )","number":"2.9"},{"type":"clause","id":"sec-decimal.prototype.equals","title":"Decimal128.prototype.equals ( x )","titleHTML":"Decimal128.prototype.equals ( <var>x</var> )","number":"2.10","referencingIds":["_ref_1"]},{"type":"clause","id":"sec-decimal.prototype.lessthan","title":"Decimal128.prototype.lessThan ( x )","titleHTML":"Decimal128.prototype.lessThan ( <var>x</var> )","number":"2.11","referencingIds":["_ref_0"]},{"type":"clause","id":"sec-decimal.prototype.compare","title":"Decimal128.prototype.compare ( x )","titleHTML":"Decimal128.prototype.compare ( <var>x</var> )","number":"2.12"},{"type":"clause","id":"sec-decimal-method-round","title":"Decimal128.prototype.round ( numFractionalDigits [ , roundingMode ] )","titleHTML":"Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )","number":"2.13"},{"type":"clause","id":"sec-decimal.prototype.tostring","title":"Decimal128.prototype.toString ( [ options ] )","titleHTML":"Decimal128.prototype.toString ( [ <var>options</var> ] )","number":"2.14","referencingIds":["_ref_5"]},{"type":"clause","id":"sec-decimal.prototype.toexponential","title":"Decimal128.prototype.toExponential ( [ shouldCanonicalize ] )","titleHTML":"Decimal128.prototype.toExponential ( [ <var>shouldCanonicalize</var> ] )","number":"2.15","referencingIds":["_ref_4"]},{"type":"clause","id":"sec-decimal.prototype.tofixed","title":"Decimal128.prototype.toFixed ( numDigits [ , shouldCanonicalize ] )","titleHTML":"Decimal128.prototype.toFixed ( <var>numDigits</var> [ , <var>shouldCanonicalize</var> ] )","number":"2.16"},{"type":"clause","id":"sec-decimal.prototype.toprecision","title":"Decimal128.prototype.toPrecision ( precision [ , shouldCanonicalize ] )","titleHTML":"Decimal128.prototype.toPrecision ( <var>precision</var> [ , <var>shouldCanonicalize</var> ] )","number":"2.17"},{"type":"clause","id":"sec-decimal.prototype.valueof","title":"Decimal128.prototype.valueOf ( x )","titleHTML":"Decimal128.prototype.valueOf ( <var>x</var> )","number":"2.18"},{"type":"clause","id":"sec-decimal-prototype-properties","titleHTML":"Properties of the Decimal128 Prototype","number":"2"},{"type":"clause","id":"sec-number-constructor-number-value","title":"Number ( value )","titleHTML":"Number ( <var>value</var> )","number":"3.1.1.1"},{"type":"clause","id":"sec-number-constructor","titleHTML":"The Number Constructor","number":"3.1.1"},{"type":"clause","id":"sec-number-objects","titleHTML":"Number Objects","number":"3.1"},{"type":"op","aoid":"Decimal128ToBigInt","refId":"sec-numbertobigint"},{"type":"clause","id":"sec-numbertobigint","title":"Decimal128ToBigInt ( number )","titleHTML":"<ins>Decimal128ToBigInt ( <var>number</var> )</ins>","number":"3.2.1.1.1","referencingIds":["_ref_150"]},{"type":"clause","id":"sec-bigint-constructor-number-value","title":"BigInt ( value )","titleHTML":"BigInt ( <var>value</var> )","number":"3.2.1.1"},{"type":"clause","id":"sec-bigint-constructor","titleHTML":"The BigInt Constructor","number":"3.2.1"},{"type":"clause","id":"sec-bigint-objects","titleHTML":"BigInt Objects","number":"3.2"},{"type":"clause","id":"sec-numbers-and-dates","titleHTML":"Numbers and Dates","number":"3"},{"type":"clause","id":"sec-decimal-intl","titleHTML":"Amendments to the ECMAScript® 2024 Internationalization API Specification","number":""},{"type":"term","term":"Intl mathematical value","id":"intl-mathematical-value","referencingIds":["_ref_152","_ref_161","_ref_195"]},{"type":"op","aoid":"ToIntlMathematicalValue","refId":"sec-tointlmathematicalvalue"},{"type":"clause","id":"sec-tointlmathematicalvalue","title":"ToIntlMathematicalValue ( value )","titleHTML":"ToIntlMathematicalValue ( <var>value</var> )","number":"4.1.1"},{"type":"op","aoid":"FormatNumericToString","refId":"sec-formatnumberstring"},{"type":"clause","id":"sec-formatnumberstring","title":"FormatNumericToString ( intlObject, x )","titleHTML":"FormatNumericToString ( <var>intlObject</var>, <var>x</var> )","number":"4.1.2","referencingIds":["_ref_199"]},{"type":"op","aoid":"ToRawPrecisionFn","id":"eqn-ToRawPrecisionFn","referencingIds":["_ref_179","_ref_181"]},{"type":"op","aoid":"ToRawPrecision","refId":"sec-torawprecision"},{"type":"clause","id":"sec-torawprecision","title":"ToRawPrecision ( x, minPrecision, maxPrecision, unsignedRoundingMode )","titleHTML":"ToRawPrecision ( <var>x</var>, <var>minPrecision</var>, <var>maxPrecision</var>, <var>unsignedRoundingMode</var> )","number":"4.1.3","referencingIds":["_ref_163","_ref_165"]},{"type":"op","aoid":"ToRawFixedFn","id":"eqn-ToRawFixedFn","referencingIds":["_ref_192","_ref_194"]},{"type":"op","aoid":"ToRawFixed","refId":"sec-torawfixed"},{"type":"clause","id":"sec-torawfixed","title":"ToRawFixed ( x, minFraction, maxFraction, roundingIncrement, unsignedRoundingMode )","titleHTML":"ToRawFixed ( <var>x</var>, <var>minFraction</var>, <var>maxFraction</var>, <var>roundingIncrement</var>, <var>unsignedRoundingMode</var> )","number":"4.1.4","referencingIds":["_ref_164","_ref_166"]},{"type":"op","aoid":"PartitionNumberPattern","refId":"sec-partitionnumberpattern"},{"type":"clause","id":"sec-partitionnumberpattern","title":"PartitionNumberPattern ( numberFormat, x )","titleHTML":"PartitionNumberPattern ( <var>numberFormat</var>, <var>x</var> )","number":"4.1.5"},{"type":"clause","id":"sec-numberformat-abstracts","titleHTML":"Abstract Operations for NumberFormat Objects","number":"4.1"},{"type":"clause","id":"numberformat-objects","titleHTML":"NumberFormat Objects","number":"4"},{"type":"clause","id":"sec-copyright-and-software-license","title":"Copyright & Software License","titleHTML":"Copyright &amp; Software License","number":"A"}]}`);
+let biblio = JSON.parse(`{"refsByClause":{"sec-decimal.prototype.compare":["_ref_0","_ref_1","_ref_153","_ref_154","_ref_155","_ref_156","_ref_157"],"sec-decimal-method-round":["_ref_2","_ref_3","_ref_158","_ref_159","_ref_160","_ref_161","_ref_162","_ref_163","_ref_164","_ref_165"],"sec-decimal.prototype.tostring":["_ref_4","_ref_166","_ref_167","_ref_168"],"sec-decimal.prototype.toprecision":["_ref_5","_ref_175","_ref_176","_ref_177","_ref_178","_ref_179","_ref_180","_ref_181","_ref_182","_ref_183","_ref_184"],"sec-tointlmathematicalvalue":["_ref_6","_ref_188","_ref_189","_ref_190","_ref_191","_ref_192","_ref_193","_ref_194"],"sec-decimal-intro":["_ref_7","_ref_8","_ref_9","_ref_10","_ref_11","_ref_12","_ref_13","_ref_14","_ref_15","_ref_16","_ref_17","_ref_18","_ref_19","_ref_20","_ref_21","_ref_22","_ref_23","_ref_24","_ref_25","_ref_26","_ref_27","_ref_28","_ref_29","_ref_30","_ref_31","_ref_32","_ref_33","_ref_34","_ref_35","_ref_36","_ref_37","_ref_38","_ref_39","_ref_40","_ref_41","_ref_42","_ref_43","_ref_44","_ref_45","_ref_46","_ref_47","_ref_48","_ref_49"],"sec-decimal128-decimal128todecimalstring":["_ref_50","_ref_51"],"sec-decimal128toexponentialstring":["_ref_52","_ref_53"],"sec-decimal128-isintegraldecimal128value":["_ref_54","_ref_55","_ref_56"],"sec-decimal128-value-to-object":["_ref_57"],"sec-decimal128-d":["_ref_58","_ref_59","_ref_60","_ref_61","_ref_62"],"sec-decimal128-canonicalizedecimal128":["_ref_63","_ref_64","_ref_65","_ref_66"],"sec-the-decimal128-constructor-value":["_ref_67","_ref_68","_ref_69","_ref_70","_ref_71"],"sec-decimal.prototype.abs":["_ref_72","_ref_73","_ref_74","_ref_75","_ref_76","_ref_77"],"sec-decimal.prototype.negate":["_ref_78","_ref_79","_ref_80","_ref_81","_ref_82","_ref_83"],"sec-decimal.prototype.add":["_ref_84","_ref_85","_ref_86","_ref_87","_ref_88","_ref_89","_ref_90","_ref_91","_ref_92","_ref_93","_ref_94","_ref_95","_ref_96","_ref_97"],"sec-decimal.prototype.subtract":["_ref_98","_ref_99","_ref_100","_ref_101","_ref_102","_ref_103","_ref_104","_ref_105","_ref_106","_ref_107","_ref_108","_ref_109","_ref_110","_ref_111"],"sec-decimal.prototype.multiply":["_ref_112","_ref_113","_ref_114","_ref_115","_ref_116","_ref_117","_ref_118","_ref_119","_ref_120","_ref_121","_ref_122","_ref_123","_ref_124","_ref_125","_ref_126","_ref_127","_ref_128","_ref_129","_ref_130"],"sec-decimal.prototype.divide":["_ref_131","_ref_132","_ref_133","_ref_134","_ref_135","_ref_136","_ref_137","_ref_138","_ref_139","_ref_140"],"sec-decimal.prototype.remainder":["_ref_141","_ref_142","_ref_143","_ref_144","_ref_145","_ref_146","_ref_147","_ref_148","_ref_149","_ref_150"],"sec-decimal.prototype.equals":["_ref_151"],"sec-decimal.prototype.lessthan":["_ref_152"],"sec-decimal.prototype.toexponential":["_ref_169","_ref_170","_ref_171"],"sec-decimal.prototype.tofixed":["_ref_172","_ref_173","_ref_174"],"sec-number-constructor-number-value":["_ref_185"],"sec-bigint-constructor-number-value":["_ref_186"],"sec-numbertobigint":["_ref_187"],"sec-formatnumberstring":["_ref_195","_ref_196","_ref_197","_ref_198","_ref_199","_ref_200","_ref_201","_ref_202"],"sec-torawprecision":["_ref_203","_ref_204","_ref_205","_ref_206","_ref_207","_ref_208","_ref_209","_ref_210","_ref_211","_ref_212","_ref_213","_ref_214","_ref_215","_ref_216","_ref_217"],"sec-torawfixed":["_ref_218","_ref_219","_ref_220","_ref_221","_ref_222","_ref_223","_ref_224","_ref_225","_ref_226","_ref_227","_ref_228","_ref_229","_ref_230"],"sec-partitionnumberpattern":["_ref_231","_ref_232","_ref_233","_ref_234","_ref_235"]},"entries":[{"type":"clause","id":"sec-decimal-intro-","titleHTML":"Introduction","number":""},{"type":"term","term":"finite","id":"dfn-decimal128-finite","referencingIds":["_ref_11","_ref_12","_ref_15","_ref_16","_ref_19","_ref_31","_ref_32","_ref_35","_ref_37","_ref_39","_ref_41","_ref_43","_ref_46","_ref_49","_ref_54","_ref_189","_ref_205","_ref_220"]},{"type":"term","term":"zero","id":"dfn-decimal128-zero","referencingIds":["_ref_7","_ref_8","_ref_13","_ref_17","_ref_18","_ref_20","_ref_24","_ref_25","_ref_33","_ref_36","_ref_38","_ref_40","_ref_42","_ref_44","_ref_45","_ref_47","_ref_48","_ref_116","_ref_121","_ref_191","_ref_213"]},{"type":"term","term":"negative","refId":"sec-decimal-intro"},{"type":"term","term":"mathematical value","id":"dfn-decimal128-mathematical-value","referencingIds":["_ref_6","_ref_9","_ref_10","_ref_14","_ref_34","_ref_58","_ref_59","_ref_67","_ref_68","_ref_70","_ref_151","_ref_152","_ref_153","_ref_154","_ref_157","_ref_192","_ref_193","_ref_194","_ref_195","_ref_196","_ref_198","_ref_204","_ref_207","_ref_208","_ref_209","_ref_214","_ref_216","_ref_219","_ref_222","_ref_223","_ref_227","_ref_229","_ref_234"]},{"type":"term","term":"rounding mode","id":"dfn-decimal128-rounding-mode","referencingIds":["_ref_21","_ref_22","_ref_26","_ref_60","_ref_84","_ref_98","_ref_112","_ref_131","_ref_141","_ref_158","_ref_160","_ref_165"]},{"type":"term","term":"default rounding mode","id":"dfn-decimal128-default-rounding-mode","referencingIds":["_ref_2","_ref_3"]},{"type":"table","id":"table-decimal128-rounding-modes","number":1,"caption":"Table 1: Rounding modes in Decimal128 compared to IEEE 754 rounding modes"},{"type":"op","aoid":"cohort","id":"eqn-decimal128-cohort","referencingIds":["_ref_27","_ref_28","_ref_29","_ref_30","_ref_50","_ref_52","_ref_55","_ref_63","_ref_64","_ref_75","_ref_81","_ref_92","_ref_93","_ref_106","_ref_107","_ref_123","_ref_126","_ref_135","_ref_136","_ref_145","_ref_146","_ref_161","_ref_180"]},{"type":"op","aoid":"quantum","id":"eqn-decimal128-quantum","referencingIds":["_ref_51","_ref_53","_ref_56","_ref_76","_ref_82","_ref_94","_ref_95","_ref_108","_ref_109","_ref_127","_ref_128","_ref_137","_ref_138","_ref_147","_ref_148","_ref_162","_ref_181"]},{"type":"term","term":"exponent","refId":"sec-decimal-intro"},{"type":"term","term":"significand","refId":"sec-decimal-intro"},{"type":"term","term":"normalized","refId":"sec-decimal-intro"},{"type":"term","term":"denormalized","refId":"sec-decimal-intro"},{"type":"term","term":"truncated exponent","refId":"sec-decimal-intro"},{"type":"term","term":"scaled significand","refId":"sec-decimal-intro"},{"type":"clause","id":"sec-decimal-intro","titleHTML":"Introduction","number":"","referencingIds":["_ref_23","_ref_65","_ref_66","_ref_155","_ref_156","_ref_159","_ref_190","_ref_203","_ref_206","_ref_211","_ref_212","_ref_218","_ref_221","_ref_225","_ref_226","_ref_232","_ref_233"]},{"type":"op","aoid":"Decimal128ToDecimalString","refId":"sec-decimal128-decimal128todecimalstring"},{"type":"clause","id":"sec-decimal128-decimal128todecimalstring","title":"Decimal128ToDecimalString ( argument )","titleHTML":"Decimal128ToDecimalString ( <var>argument</var> )","number":"1.1.1","referencingIds":["_ref_166","_ref_168","_ref_172","_ref_174","_ref_175","_ref_177","_ref_182","_ref_184","_ref_210","_ref_224"]},{"type":"op","aoid":"Decimal128ToExponentialString","refId":"sec-decimal128toexponentialstring"},{"type":"clause","id":"sec-decimal128toexponentialstring","title":"Decimal128ToExponentialString ( argument )","titleHTML":"Decimal128ToExponentialString ( <var>argument</var> )","number":"1.1.2","referencingIds":["_ref_169","_ref_171"]},{"type":"op","aoid":"IsIntegralDecimal128","refId":"sec-decimal128-isintegraldecimal128value"},{"type":"clause","id":"sec-decimal128-isintegraldecimal128value","title":"IsIntegralDecimal128 ( argument )","titleHTML":"IsIntegralDecimal128 ( <var>argument</var> )","number":"1.1.3","referencingIds":["_ref_187"]},{"type":"op","aoid":"Decimal128ValueToObject","refId":"sec-decimal128-value-to-object"},{"type":"clause","id":"sec-decimal128-value-to-object","title":"Decimal128ValueToObject ( argument )","titleHTML":"Decimal128ValueToObject ( <var>argument</var> )","number":"1.1.4","referencingIds":["_ref_72","_ref_73","_ref_74","_ref_77","_ref_78","_ref_79","_ref_80","_ref_83","_ref_85","_ref_86","_ref_87","_ref_88","_ref_89","_ref_90","_ref_91","_ref_96","_ref_99","_ref_100","_ref_101","_ref_102","_ref_103","_ref_104","_ref_105","_ref_110","_ref_113","_ref_114","_ref_115","_ref_117","_ref_118","_ref_119","_ref_120","_ref_122","_ref_124","_ref_125","_ref_129","_ref_132","_ref_133","_ref_134","_ref_139","_ref_142","_ref_143","_ref_144","_ref_149","_ref_163"]},{"type":"op","aoid":"EnsureDecimal128Value","refId":"sec-decimal128-d"},{"type":"clause","id":"sec-decimal128-d","title":"EnsureDecimal128Value ( coefficient, intendedExponent, roundingMode )","titleHTML":"EnsureDecimal128Value ( <var>coefficient</var>, <var>intendedExponent</var>, <var>roundingMode</var> )","number":"1.1.5","referencingIds":["_ref_61","_ref_62","_ref_69","_ref_71","_ref_97","_ref_111","_ref_130","_ref_140","_ref_150","_ref_164","_ref_183"]},{"type":"op","aoid":"CanonicalizeDecimal128","refId":"sec-decimal128-canonicalizedecimal128"},{"type":"clause","id":"sec-decimal128-canonicalizedecimal128","title":"CanonicalizeDecimal128 ( d )","titleHTML":"CanonicalizeDecimal128 ( <var>d</var> )","number":"1.1.6","referencingIds":["_ref_167","_ref_170","_ref_173","_ref_176","_ref_178","_ref_179"]},{"type":"clause","id":"sec-decimal-abstract-ops","titleHTML":"Abstract Operations","number":"1.1"},{"type":"term","term":"%Decimal128%","refId":"sec-the-decimal-constructor"},{"type":"clause","id":"sec-the-decimal128-constructor-value","title":"Decimal128 ( x )","titleHTML":"Decimal128 ( <var>x</var> )","number":"1.2.1"},{"type":"clause","id":"sec-the-decimal-constructor","titleHTML":"The Decimal128 Constructor","number":"1.2","referencingIds":["_ref_57","_ref_185"]},{"type":"clause","id":"sec-the-decimal-object","titleHTML":"The Decimal128 Object","number":"1"},{"type":"clause","id":"sec-decimal.prototype.isnan","titleHTML":"Decimal128.prototype.isNaN ( )","number":"2.1"},{"type":"clause","id":"sec-decimal.prototype.isfinite","titleHTML":"Decimal128.prototype.isFinite ( )","number":"2.2"},{"type":"clause","id":"sec-decimal.prototype.abs","titleHTML":"Decimal128.prototype.abs ( )","number":"2.3"},{"type":"clause","id":"sec-decimal.prototype.negate","titleHTML":"Decimal128.prototype.negate ( )","number":"2.4"},{"type":"clause","id":"sec-decimal.prototype.add","title":"Decimal128.prototype.add ( x )","titleHTML":"Decimal128.prototype.add ( <var>x</var> )","number":"2.5"},{"type":"clause","id":"sec-decimal.prototype.subtract","title":"Decimal128.prototype.subtract ( x )","titleHTML":"Decimal128.prototype.subtract ( <var>x</var> )","number":"2.6"},{"type":"clause","id":"sec-decimal.prototype.multiply","title":"Decimal128.prototype.multiply ( x )","titleHTML":"Decimal128.prototype.multiply ( <var>x</var> )","number":"2.7"},{"type":"clause","id":"sec-decimal.prototype.divide","title":"Decimal128.prototype.divide ( x )","titleHTML":"Decimal128.prototype.divide ( <var>x</var> )","number":"2.8"},{"type":"clause","id":"sec-decimal.prototype.remainder","title":"Decimal128.prototype.remainder ( x )","titleHTML":"Decimal128.prototype.remainder ( <var>x</var> )","number":"2.9"},{"type":"clause","id":"sec-decimal.prototype.equals","title":"Decimal128.prototype.equals ( x )","titleHTML":"Decimal128.prototype.equals ( <var>x</var> )","number":"2.10","referencingIds":["_ref_1"]},{"type":"clause","id":"sec-decimal.prototype.lessthan","title":"Decimal128.prototype.lessThan ( x )","titleHTML":"Decimal128.prototype.lessThan ( <var>x</var> )","number":"2.11","referencingIds":["_ref_0"]},{"type":"clause","id":"sec-decimal.prototype.compare","title":"Decimal128.prototype.compare ( x )","titleHTML":"Decimal128.prototype.compare ( <var>x</var> )","number":"2.12"},{"type":"clause","id":"sec-decimal-method-round","title":"Decimal128.prototype.round ( numFractionalDigits [ , roundingMode ] )","titleHTML":"Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )","number":"2.13"},{"type":"clause","id":"sec-decimal.prototype.tostring","title":"Decimal128.prototype.toString ( [ options ] )","titleHTML":"Decimal128.prototype.toString ( [ <var>options</var> ] )","number":"2.14","referencingIds":["_ref_5"]},{"type":"clause","id":"sec-decimal.prototype.toexponential","title":"Decimal128.prototype.toExponential ( [ shouldCanonicalize ] )","titleHTML":"Decimal128.prototype.toExponential ( [ <var>shouldCanonicalize</var> ] )","number":"2.15","referencingIds":["_ref_4"]},{"type":"clause","id":"sec-decimal.prototype.tofixed","title":"Decimal128.prototype.toFixed ( numDigits [ , shouldCanonicalize ] )","titleHTML":"Decimal128.prototype.toFixed ( <var>numDigits</var> [ , <var>shouldCanonicalize</var> ] )","number":"2.16"},{"type":"clause","id":"sec-decimal.prototype.toprecision","title":"Decimal128.prototype.toPrecision ( precision [ , shouldCanonicalize ] )","titleHTML":"Decimal128.prototype.toPrecision ( <var>precision</var> [ , <var>shouldCanonicalize</var> ] )","number":"2.17"},{"type":"clause","id":"sec-decimal.prototype.valueof","title":"Decimal128.prototype.valueOf ( x )","titleHTML":"Decimal128.prototype.valueOf ( <var>x</var> )","number":"2.18"},{"type":"clause","id":"sec-decimal-prototype-properties","titleHTML":"Properties of the Decimal128 Prototype","number":"2"},{"type":"clause","id":"sec-number-constructor-number-value","title":"Number ( value )","titleHTML":"Number ( <var>value</var> )","number":"3.1.1.1"},{"type":"clause","id":"sec-number-constructor","titleHTML":"The Number Constructor","number":"3.1.1"},{"type":"clause","id":"sec-number-objects","titleHTML":"Number Objects","number":"3.1"},{"type":"op","aoid":"Decimal128ToBigInt","refId":"sec-numbertobigint"},{"type":"clause","id":"sec-numbertobigint","title":"Decimal128ToBigInt ( number )","titleHTML":"<ins>Decimal128ToBigInt ( <var>number</var> )</ins>","number":"3.2.1.1.1","referencingIds":["_ref_186"]},{"type":"clause","id":"sec-bigint-constructor-number-value","title":"BigInt ( value )","titleHTML":"BigInt ( <var>value</var> )","number":"3.2.1.1"},{"type":"clause","id":"sec-bigint-constructor","titleHTML":"The BigInt Constructor","number":"3.2.1"},{"type":"clause","id":"sec-bigint-objects","titleHTML":"BigInt Objects","number":"3.2"},{"type":"clause","id":"sec-numbers-and-dates","titleHTML":"Numbers and Dates","number":"3"},{"type":"clause","id":"sec-decimal-intl","titleHTML":"Amendments to the ECMAScript® 2024 Internationalization API Specification","number":""},{"type":"term","term":"Intl mathematical value","id":"intl-mathematical-value","referencingIds":["_ref_188","_ref_197","_ref_231"]},{"type":"op","aoid":"ToIntlMathematicalValue","refId":"sec-tointlmathematicalvalue"},{"type":"clause","id":"sec-tointlmathematicalvalue","title":"ToIntlMathematicalValue ( value )","titleHTML":"ToIntlMathematicalValue ( <var>value</var> )","number":"4.1.1"},{"type":"op","aoid":"FormatNumericToString","refId":"sec-formatnumberstring"},{"type":"clause","id":"sec-formatnumberstring","title":"FormatNumericToString ( intlObject, x )","titleHTML":"FormatNumericToString ( <var>intlObject</var>, <var>x</var> )","number":"4.1.2","referencingIds":["_ref_235"]},{"type":"op","aoid":"ToRawPrecisionFn","id":"eqn-ToRawPrecisionFn","referencingIds":["_ref_215","_ref_217"]},{"type":"op","aoid":"ToRawPrecision","refId":"sec-torawprecision"},{"type":"clause","id":"sec-torawprecision","title":"ToRawPrecision ( x, minPrecision, maxPrecision, unsignedRoundingMode )","titleHTML":"ToRawPrecision ( <var>x</var>, <var>minPrecision</var>, <var>maxPrecision</var>, <var>unsignedRoundingMode</var> )","number":"4.1.3","referencingIds":["_ref_199","_ref_201"]},{"type":"op","aoid":"ToRawFixedFn","id":"eqn-ToRawFixedFn","referencingIds":["_ref_228","_ref_230"]},{"type":"op","aoid":"ToRawFixed","refId":"sec-torawfixed"},{"type":"clause","id":"sec-torawfixed","title":"ToRawFixed ( x, minFraction, maxFraction, roundingIncrement, unsignedRoundingMode )","titleHTML":"ToRawFixed ( <var>x</var>, <var>minFraction</var>, <var>maxFraction</var>, <var>roundingIncrement</var>, <var>unsignedRoundingMode</var> )","number":"4.1.4","referencingIds":["_ref_200","_ref_202"]},{"type":"op","aoid":"PartitionNumberPattern","refId":"sec-partitionnumberpattern"},{"type":"clause","id":"sec-partitionnumberpattern","title":"PartitionNumberPattern ( numberFormat, x )","titleHTML":"PartitionNumberPattern ( <var>numberFormat</var>, <var>x</var> )","number":"4.1.5"},{"type":"clause","id":"sec-numberformat-abstracts","titleHTML":"Abstract Operations for NumberFormat Objects","number":"4.1"},{"type":"clause","id":"numberformat-objects","titleHTML":"NumberFormat Objects","number":"4"},{"type":"clause","id":"sec-copyright-and-software-license","title":"Copyright & Software License","titleHTML":"Copyright &amp; Software License","number":"A"}]}`);
 ;let usesMultipage = false</script><style>/* IBM Plex fonts (Latin subset) have been downloaded from Google Fonts and modified to add support back in for the `zero` substitution (slashed zeroes) */
 
 /* https://fonts.googleapis.com/css2?family=IBM%20Plex%20Serif:ital,wght@0,400;0,700;1,400;1,700&display=swap */
@@ -3268,12 +3268,12 @@ <h1>Introduction</h1>
     <emu-note><span class="note">Note 1</span><div class="note-contents">
       <p>A Decimal128 value is not an <emu-xref href="#sec-ecmascript-language-types"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types">ECMAScript language value</a></emu-xref>.</p>
     </div></emu-note>
-    <p>The <dfn id="dfn-decimal128-mathematical-value" tabindex="-1">mathematical value</dfn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_11"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value <var>x</var> = « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is defined as follows:</p>
+    <p>A Decimal128 value is said to be <dfn id="dfn-decimal128-finite" tabindex="-1">finite</dfn> if it has the form « <var>v</var>, <var>q</var> »<sub>𝔻</sub>. A <dfn id="dfn-decimal128-zero" tabindex="-1">zero</dfn> Decimal128 value is a <emu-xref href="#dfn-decimal128-finite" id="_ref_11"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value of the form « 0<sub>𝔻</sub>, <var>q</var> »<sub>𝔻</sub> or « -0<sub>𝔻</sub>, <var>q</var> »<sub>𝔻</sub>. A <emu-xref href="#dfn-decimal128-finite" id="_ref_12"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_13"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is one of the form « <var>v</var>, <var>q</var> »<sub>𝔻</sub> where <var>v</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_14"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>. A <emu-xref href="#dfn-decimal128-finite" id="_ref_15"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is said to be <dfn tabindex="-1">negative</dfn> if either <var>v</var> is -0<sub>D</sub> or <var>v</var> is a real number such that <var>v</var> &lt; 0.</p>
+    <p>The <dfn id="dfn-decimal128-mathematical-value" tabindex="-1">mathematical value</dfn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_16"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value <var>x</var> = « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is defined as follows:</p>
     <ul>
-      <li>If <var>x</var> is <emu-xref href="#dfn-decimal128-zero" id="_ref_12"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> is 0</li>
-      <li>If <var>x</var> is non-<emu-xref href="#dfn-decimal128-zero" id="_ref_13"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> is v × 10<sup><var>q</var></sup></li>
+      <li>If <var>x</var> is <emu-xref href="#dfn-decimal128-zero" id="_ref_17"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> is 0</li>
+      <li>If <var>x</var> is non-<emu-xref href="#dfn-decimal128-zero" id="_ref_18"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> is v × 10<sup><var>q</var></sup></li>
     </ul>
-    <p>A Decimal128 value is said to be <dfn id="dfn-decimal128-finite" tabindex="-1">finite</dfn> if it has the form « <var>v</var>, <var>q</var> »<sub>𝔻</sub>. A <dfn id="dfn-decimal128-zero" tabindex="-1">zero</dfn> Decimal128 value is a <emu-xref href="#dfn-decimal128-finite" id="_ref_14"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value of the form « 0<sub>𝔻</sub>, <var>q</var> »<sub>𝔻</sub> or « -0<sub>𝔻</sub>, <var>q</var> »<sub>𝔻</sub>. A <emu-xref href="#dfn-decimal128-finite" id="_ref_15"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_16"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is one of the form « <var>v</var>, <var>q</var> »<sub>𝔻</sub> where <var>v</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_17"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>. A <emu-xref href="#dfn-decimal128-finite" id="_ref_18"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is said to be <dfn tabindex="-1">negative</dfn> if either <var>v</var> is -0<sub>D</sub> or <var>v</var> is a real number such that <var>v</var> &lt; 0.</p>
     <emu-note><span class="note">Note 2</span><div class="note-contents">
       <p>The <var>v</var> component of a <emu-xref href="#dfn-decimal128-finite" id="_ref_19"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_20"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is a rational number.</p>
     </div></emu-note>
@@ -3319,33 +3319,34 @@ <h1>Introduction</h1>
       </table>
       <emu-note><span class="note">Note 3</span><div class="note-contents">The above five rounding modes are defined in IEEE 754. This table is offered for implementors who may need to convert the Decimal128 rounding modes defined here into a library that may use the official IEEE 754 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_26"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref> names. Additional rounding modes are used elsewhere in this specification, such as in <emu-xref href="#table-intl-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-rounding-modes">Intl.NumberFormat</a></emu-xref>.</div></emu-note>
     </figure></emu-table>
-    <p>The <dfn id="dfn-decimal128-cohort" tabindex="-1">cohort</dfn> of a Decimal128 value is defined as follows:</p>
+    <p>The <emu-eqn id="eqn-decimal128-cohort" aoid="cohort" class="inline">cohort(<var>x</var>)</emu-eqn> of a Decimal128 value <var>x</var> is defined as follows:</p>
     <ul>
-      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_27"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>) = <emu-val>NaN</emu-val><sub>𝔻</sub></li>
-      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_28"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>) = <emu-val>+∞</emu-val><sub>𝔻</sub></li>
-      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_29"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>) = <emu-val>-∞</emu-val><sub>𝔻</sub></li>
-      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_30"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(« <var>v</var>, <var>q</var> »<sub>𝔻</sub>) = <var>v</var></li>
+      <li><emu-xref aoid="cohort" id="_ref_27"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>) = <emu-val>NaN</emu-val><sub>𝔻</sub></li>
+      <li><emu-xref aoid="cohort" id="_ref_28"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>) = <emu-val>+∞</emu-val><sub>𝔻</sub></li>
+      <li><emu-xref aoid="cohort" id="_ref_29"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>) = <emu-val>-∞</emu-val><sub>𝔻</sub></li>
+      <li><emu-xref aoid="cohort" id="_ref_30"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(« <var>v</var>, <var>q</var> »<sub>𝔻</sub>) = <var>v</var></li>
     </ul>
-    <p>For every <emu-xref href="#dfn-decimal128-finite" id="_ref_31"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_32"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> »<sub>𝔻</sub> there exists a unique <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>e</var> and <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_33"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> <var>s</var> such that</p>
+    <p>For every <emu-xref href="#dfn-decimal128-finite" id="_ref_31"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value <var>x</var> = « <var>v</var>, <var>q</var> », the <emu-eqn id="eqn-decimal128-quantum" aoid="quantum" class="inline">quantum(<var>x</var>) = <var>q</var></emu-eqn>.</p>
+    <p>For every <emu-xref href="#dfn-decimal128-finite" id="_ref_32"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_33"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> »<sub>𝔻</sub> there exists a unique <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>e</var> and <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_34"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> <var>s</var> such that</p>
     <ol>
       <li><var>v</var> = <var>s</var> × 10<sup><var>e</var></sup></li>
       <li>1 ≤ <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>s</var>) &lt; 10</li>
     </ol>
-    <p>We call <var>e</var> the <dfn tabindex="-1">exponent</dfn> and <var>s</var> the <dfn tabindex="-1">significand</dfn> of « <var>v</var>, <var>q</var> »<sub>𝔻</sub>. The exponent and significand are undefined for NaN, non-<emu-xref href="#dfn-decimal128-finite" id="_ref_34"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, and <emu-xref href="#dfn-decimal128-zero" id="_ref_35"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 values.</p>
+    <p>We call <var>e</var> the <dfn tabindex="-1">exponent</dfn> and <var>s</var> the <dfn tabindex="-1">significand</dfn> of « <var>v</var>, <var>q</var> »<sub>𝔻</sub>. The exponent and significand are undefined for NaN, non-<emu-xref href="#dfn-decimal128-finite" id="_ref_35"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, and <emu-xref href="#dfn-decimal128-zero" id="_ref_36"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 values.</p>
     <emu-note><span class="note">Note 4</span><div class="note-contents">
-      <p>The significand of a <emu-xref href="#dfn-decimal128-finite" id="_ref_36"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_37"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is a rational number.</p>
+      <p>The significand of a <emu-xref href="#dfn-decimal128-finite" id="_ref_37"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_38"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is a rational number.</p>
     </div></emu-note>
     <emu-note><span class="note">Note 5</span><div class="note-contents">
-      <p>The exponent <var>e</var> of <emu-xref href="#dfn-decimal128-finite" id="_ref_38"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_39"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 values is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> satisfying 6144 ≥ <var>e</var> ≥ -6176.</p>
+      <p>The exponent <var>e</var> of <emu-xref href="#dfn-decimal128-finite" id="_ref_39"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_40"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 values is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> satisfying 6144 ≥ <var>e</var> ≥ -6176.</p>
     </div></emu-note>
-    <p>A <emu-xref href="#dfn-decimal128-finite" id="_ref_40"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_41"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is <dfn tabindex="-1">normalized</dfn> if its exponent <var>e</var> satisfies 6144 ≥ <var>e</var> ≥ -6143. A <emu-xref href="#dfn-decimal128-finite" id="_ref_42"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_43"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is <dfn tabindex="-1">denormalized</dfn> if its exponent <var>e</var> satisfies -6144 ≥ <var>e</var> ≥ -6176.</p>
-    <p>For a proper discussion of rounding, we need to separate how rounding occurs with normalized compared with denormlized values. For a normalized Decimal128 value we define its <dfn tabindex="-1">truncated exponent</dfn> as equal to its exponent. For <emu-xref href="#dfn-decimal128-zero" id="_ref_44"><a href="#dfn-decimal128-zero">zero</a></emu-xref> or denormalized Decimal128 values we define the truncated exponent as the constant -6143. Given this, we define the <dfn tabindex="-1">scaled significand</dfn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_45"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value as follows:</p>
+    <p>A <emu-xref href="#dfn-decimal128-finite" id="_ref_41"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_42"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is <dfn tabindex="-1">normalized</dfn> if its exponent <var>e</var> satisfies 6144 ≥ <var>e</var> ≥ -6143. A <emu-xref href="#dfn-decimal128-finite" id="_ref_43"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_44"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is <dfn tabindex="-1">denormalized</dfn> if its exponent <var>e</var> satisfies -6144 ≥ <var>e</var> ≥ -6176.</p>
+    <p>For a proper discussion of rounding, we need to separate how rounding occurs with normalized compared with denormlized values. For a normalized Decimal128 value we define its <dfn tabindex="-1">truncated exponent</dfn> as equal to its exponent. For <emu-xref href="#dfn-decimal128-zero" id="_ref_45"><a href="#dfn-decimal128-zero">zero</a></emu-xref> or denormalized Decimal128 values we define the truncated exponent as the constant -6143. Given this, we define the <dfn tabindex="-1">scaled significand</dfn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_46"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value as follows:</p>
     <ul>
-      <li>The scaled significand of a <emu-xref href="#dfn-decimal128-zero" id="_ref_46"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is 0</li>
-      <li>The scaled significand of a non-<emu-xref href="#dfn-decimal128-zero" id="_ref_47"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value _x = « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is v × 10<sup>33 - <var>te</var></sup>, where <var>te</var> is the truncated exponent of <var>x</var>.</li>
+      <li>The scaled significand of a <emu-xref href="#dfn-decimal128-zero" id="_ref_47"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is 0</li>
+      <li>The scaled significand of a non-<emu-xref href="#dfn-decimal128-zero" id="_ref_48"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value _x = « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is v × 10<sup>33 - <var>te</var></sup>, where <var>te</var> is the truncated exponent of <var>x</var>.</li>
     </ul>
     <emu-note><span class="note">Note 6</span><div class="note-contents">
-      <p>The scaled significand of a <emu-xref href="#dfn-decimal128-finite" id="_ref_48"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value is always an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> whose absolute value is less than 10<sup>34</sup>.</p>
+      <p>The scaled significand of a <emu-xref href="#dfn-decimal128-finite" id="_ref_49"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value is always an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> whose absolute value is less than 10<sup>34</sup>.</p>
     </div></emu-note>
   </emu-intro>
   <emu-clause id="sec-decimal-abstract-ops">
@@ -3354,36 +3355,36 @@ <h1><span class="secnum">1.1</span> Abstract Operations</h1>
     <emu-clause id="sec-decimal128-decimal128todecimalstring" type="abstract operation" aoid="Decimal128ToDecimalString">
       <h1><span class="secnum">1.1.1</span> Decimal128ToDecimalString ( <var>argument</var> )</h1>
       <p>The abstract operation Decimal128ToDecimalString takes argument <var>argument</var> (a Decimal128 value) and returns a String. It renders <var>argument</var> as a decimal (non-exponential) string. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If <var>argument</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>argument</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be <var>argument</var>[0].</li><li>Let <var>q</var> be <var>argument</var>[1].</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> for which <var>v</var> × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>n</var> is not 0.</li><li>Let <var>digits</var> be the unique decimal string representation of <var>n</var> without leading zeroes.</li><li>If <var>q</var> &lt; 0, then<ol><li>Let <var>trailingZeroes</var> be the String <emu-val>"0"</emu-val> repeated <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) - <var>q</var> times.</li><li>Return the concatenation of <var>digits</var> and <var>trailingZeroes</var>.</li></ol></li><li>Let <var>integerPart</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> from 0 to <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(n) - <var>q</var>.</li><li>Let <var>nonIntegerPart</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> from <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(n) - <var>q</var> to the length of <var>digits</var>.</li><li>Return the concatenation of <var>integerPart</var>, <emu-val>"."</emu-val>, and <var>nonIntegerPart</var>.</li></ol></emu-alg>
+      <emu-alg><ol><li>If <var>argument</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>argument</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be the <emu-xref aoid="cohort" id="_ref_50"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>argument</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_51"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>argument</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> for which <var>v</var> × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>n</var> is not 0.</li><li>Let <var>digits</var> be the unique decimal string representation of <var>n</var> without leading zeroes.</li><li>If <var>q</var> &lt; 0, then<ol><li>Let <var>trailingZeroes</var> be the String <emu-val>"0"</emu-val> repeated <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) - <var>q</var> times.</li><li>Return the concatenation of <var>digits</var> and <var>trailingZeroes</var>.</li></ol></li><li>Let <var>integerPart</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> from 0 to <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(n) - <var>q</var>.</li><li>Let <var>nonIntegerPart</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> from <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(n) - <var>q</var> to the length of <var>digits</var>.</li><li>Return the concatenation of <var>integerPart</var>, <emu-val>"."</emu-val>, and <var>nonIntegerPart</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128toexponentialstring" type="abstract operation" aoid="Decimal128ToExponentialString">
       <h1><span class="secnum">1.1.2</span> Decimal128ToExponentialString ( <var>argument</var> )</h1>
       <p>The abstract operation Decimal128ToExponentialString takes argument <var>argument</var> (a Decimal128 value) and returns a String. It renders <var>argument</var> in exponential notation. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If <var>argument</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>argument</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be <var>argument</var>[0].</li><li>Let <var>q</var> be <var>argument</var>[1].</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>Let <var>coefficientStr</var> be the unique decimal string representation of <var>v</var> without leading zeroes.</li><li>Let <var>exponentStr</var> be the unique decimal string representation of <var>q</var> without leading zeroes.</li><li>Return the concatenation of <var>coefficientStr</var>, <emu-val>"e"</emu-val>, and <var>exponentStr</var>.</li></ol></emu-alg>
+      <emu-alg><ol><li>If <var>argument</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>argument</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be the <emu-xref aoid="cohort" id="_ref_52"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>argument</var>).</li><li>Let <var>q</var> be the <emu-xref aoid="quantum" id="_ref_53"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>argument</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>Let <var>coefficientStr</var> be the unique decimal string representation of <var>v</var> without leading zeroes.</li><li>Let <var>exponentStr</var> be the unique decimal string representation of <var>q</var> without leading zeroes.</li><li>Return the concatenation of <var>coefficientStr</var>, <emu-val>"e"</emu-val>, and <var>exponentStr</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-isintegraldecimal128value" type="abstract operation" aoid="IsIntegralDecimal128">
       <h1><span class="secnum">1.1.3</span> IsIntegralDecimal128 ( <var>argument</var> )</h1>
-      <p>The abstract operation IsIntegralDecimal128 takes argument <var>argument</var> (A Decimal128 object) and returns a Boolean. It determines if <var>argument</var> is a <emu-xref href="#dfn-decimal128-finite" id="_ref_49"><a href="#dfn-decimal128-finite">finite</a></emu-xref> integral Decimal128 value. It performs the following steps when called:</p>
-      <emu-alg><ol><li>Let <var>d</var> be <var>argument</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>If <var>v</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and 0 ≤ <var>q</var>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></emu-alg>
+      <p>The abstract operation IsIntegralDecimal128 takes argument <var>argument</var> (A Decimal128 object) and returns a Boolean. It determines if <var>argument</var> is a <emu-xref href="#dfn-decimal128-finite" id="_ref_54"><a href="#dfn-decimal128-finite">finite</a></emu-xref> integral Decimal128 value. It performs the following steps when called:</p>
+      <emu-alg><ol><li>Let <var>d</var> be <var>argument</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>Let <var>v</var> be the <emu-xref aoid="cohort" id="_ref_55"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be the <emu-xref aoid="quantum" id="_ref_56"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and 0 ≤ <var>q</var>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-value-to-object" type="abstract operation" aoid="Decimal128ValueToObject">
       <h1><span class="secnum">1.1.4</span> Decimal128ValueToObject ( <var>argument</var> )</h1>
       <p>The abstract operation Decimal128ValueToObject takes argument <var>argument</var> (a Decimal128 value) and returns a Decimal128 object. It converts a Decimal128 value to a Decimal128 object. It performs the following steps when called:</p>
-      <emu-alg><ol><li>Let <var>O</var> be !&nbsp;<emu-xref aoid="OrdinaryCreateFromConstructor"><a href="https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor">OrdinaryCreateFromConstructor</a></emu-xref>(<emu-xref href="#sec-the-decimal-constructor" id="_ref_50"><a href="#sec-the-decimal-constructor">%Decimal128%</a></emu-xref>, <emu-val>"%Decimal128.prototype%"</emu-val>, « <var class="field">[[Decimal128Data]]</var>&nbsp;»).</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <var>argument</var>.</li><li>Return <var>O</var>.</li></ol></emu-alg>
+      <emu-alg><ol><li>Let <var>O</var> be !&nbsp;<emu-xref aoid="OrdinaryCreateFromConstructor"><a href="https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor">OrdinaryCreateFromConstructor</a></emu-xref>(<emu-xref href="#sec-the-decimal-constructor" id="_ref_57"><a href="#sec-the-decimal-constructor">%Decimal128%</a></emu-xref>, <emu-val>"%Decimal128.prototype%"</emu-val>, « <var class="field">[[Decimal128Data]]</var>&nbsp;»).</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <var>argument</var>.</li><li>Return <var>O</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-d" type="abstract operation" aoid="EnsureDecimal128Value">
       <h1><span class="secnum">1.1.5</span> EnsureDecimal128Value ( <var>coefficient</var>, <var>intendedExponent</var>, <var>roundingMode</var> )</h1>
-      <p>The abstract operation EnsureDecimal128Value takes arguments <var>coefficient</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_51"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var>intendedExponent</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_52"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), and <var>roundingMode</var> (a Decimal128 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_53"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>) and returns either a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">normal completion containing</a></emu-xref> a Decimal128 value or a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">throw completion</a></emu-xref>. It attempts to convert the pair of arguments, which might be out of range when considered as a Decimal128 value, into a Decimal128 value, throwing an exception if the conversion cannot be done. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If -6111 ≤ <var>intendedExponent</var> ≤ 6176, then<ol><li>If <var>coefficient</var> × 10<sup><var>intendedExponent</var></sup> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>n</var> such that 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>, return « _coefficient, <var>intendedExponent</var>&nbsp;»<sub>𝔻</sub>.</li><li>Throw a <emu-val>RangeError</emu-val> exception.</li></ol></li><li>If <var>intendedExponent</var> &lt; 0, return ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_54"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>coefficient</var> / 10, <var>intendedExponent</var> + 1, <var>roundingMode</var>).</li><li>Otherwise, return ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_55"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>coefficient</var> × 10, <var>intendedExponent</var> + 1, <var>roundingMode</var>).</li></ol></emu-alg>
+      <p>The abstract operation EnsureDecimal128Value takes arguments <var>coefficient</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_58"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var>intendedExponent</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_59"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), and <var>roundingMode</var> (a Decimal128 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_60"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>) and returns either a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">normal completion containing</a></emu-xref> a Decimal128 value or a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">throw completion</a></emu-xref>. It attempts to convert the pair of arguments, which might be out of range when considered as a Decimal128 value, into a Decimal128 value, throwing an exception if the conversion cannot be done. It performs the following steps when called:</p>
+      <emu-alg><ol><li>If -6111 ≤ <var>intendedExponent</var> ≤ 6176, then<ol><li>If <var>coefficient</var> × 10<sup><var>intendedExponent</var></sup> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>n</var> such that 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>, return « _coefficient, <var>intendedExponent</var>&nbsp;»<sub>𝔻</sub>.</li><li>Throw a <emu-val>RangeError</emu-val> exception.</li></ol></li><li>If <var>intendedExponent</var> &lt; 0, return ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_61"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>coefficient</var> / 10, <var>intendedExponent</var> + 1, <var>roundingMode</var>).</li><li>Otherwise, return ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_62"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>coefficient</var> × 10, <var>intendedExponent</var> + 1, <var>roundingMode</var>).</li></ol></emu-alg>
     </emu-clause>
     <emu-clause id="sec-decimal128-canonicalizedecimal128" type="abstract operation" aoid="CanonicalizeDecimal128">
       <h1><span class="secnum">1.1.6</span> CanonicalizeDecimal128 ( <var>d</var> )</h1>
-      <p>The abstract operation CanonicalizeDecimal128 takes argument <var>d</var> (a Decimal128 value) and returns a Decimal128 value. It converts the argument into a canonicalized, mathematically equal member of the same <emu-xref href="#dfn-decimal128-cohort" id="_ref_56"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, <emu-val>+∞</emu-val><sub>𝔻</sub>, or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <var>d</var>.</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>If <var>v</var> is is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, return <var>d</var>.</li><li>Let <var>e</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_57"><a href="#sec-decimal-intro">exponent</a></emu-xref> of <var>v</var>.</li><li>Let <var>s</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_58"><a href="#sec-decimal-intro">significand</a></emu-xref> of <var>v</var>.</li><li>Return « <var>s</var>, <var>e</var>&nbsp;».</li></ol></emu-alg>
+      <p>The abstract operation CanonicalizeDecimal128 takes argument <var>d</var> (a Decimal128 value) and returns a Decimal128 value. It converts the argument into a canonicalized, mathematically equal member of the same <emu-xref aoid="cohort" id="_ref_63"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>. It performs the following steps when called:</p>
+      <emu-alg><ol><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, <emu-val>+∞</emu-val><sub>𝔻</sub>, or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <var>d</var>.</li><li>Let <var>v</var> be the <emu-xref aoid="cohort" id="_ref_64"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, return <var>d</var>.</li><li>Let <var>e</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_65"><a href="#sec-decimal-intro">exponent</a></emu-xref> of <var>v</var>.</li><li>Let <var>s</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_66"><a href="#sec-decimal-intro">significand</a></emu-xref> of <var>v</var>.</li><li>Return « <var>s</var>, <var>e</var>&nbsp;».</li></ol></emu-alg>
     </emu-clause>
   </emu-clause>
 
@@ -3398,7 +3399,7 @@ <h1><span class="secnum">1.2</span> The Decimal128 Constructor</h1>
     </ul>
     <emu-clause id="sec-the-decimal128-constructor-value">
       <h1><span class="secnum">1.2.1</span> Decimal128 ( <var>x</var> )</h1>
-      <emu-alg><ol><li>If NewTarget is <emu-val>undefined</emu-val>, throw a <emu-val>TypeError</emu-val> exception.</li><li>Let <var>toParse</var> be <emu-val>undefined</emu-val>.</li><li>If <var>x</var> <emu-xref href="#sec-ecmascript-language-types-bigint-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-bigint-type">is a BigInt</a></emu-xref>, set <var>toParse</var> to <emu-xref aoid="BigInt::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-bigint-tostring">BigInt::toString</a></emu-xref>(<var>x</var>, 10).</li><li>Otherwise, if <var>x</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is a Number</a></emu-xref>, set <var>toParse</var> to <emu-xref aoid="Number::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-tostring">Number::toString</a></emu-xref>(<var>x</var>, 10).</li><li>Otherwise, if <var>x</var> <emu-xref href="#sec-ecmascript-language-types-string-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-string-type">is a String</a></emu-xref>, set <var>toParse</var> to <var>x</var>.</li><li>If <var>toParse</var> <emu-xref href="#sec-ecmascript-language-types-string-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-string-type">is not a String</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>Let <var>O</var> be ?&nbsp;<emu-xref aoid="OrdinaryCreateFromConstructor"><a href="https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor">OrdinaryCreateFromConstructor</a></emu-xref>(NewTarget, <emu-val>"%Decimal128.prototype%"</emu-val>, « <var class="field">[[Decimal128Data]]</var>&nbsp;»).</li><li>If <var>toParse</var> is <emu-val>"NaN"</emu-val>, regardless of case, set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>NaN</emu-val><sub>𝔻</sub>.</li><li>If <var>toParse</var> is <emu-val>"-Infinity"</emu-val>, regardless of case, set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>-∞</emu-val><sub>𝔻</sub>.</li><li>If <var>toParse</var> is <emu-val>"Infinity"</emu-val>, regardless of case, set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>+∞</emu-val><sub>𝔻</sub>.</li><li>Let <var>parseResult</var> be <emu-xref aoid="ParseText"><a href="https://tc39.es/ecma262/#sec-parsetext">ParseText</a></emu-xref>(<var>toParse</var>, <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalLiteral">DecimalLiteral</a></emu-nt>).</li><li>If <var>parseResult</var> is a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of errors, throw a <emu-val>SyntaxError</emu-val> exception.</li><li>If <var>parseResult</var> contains a <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalIntegerLiteral">DecimalIntegerLiteral</a></emu-nt>, then<ol><li>Let <var>integerPart</var> be the source text contained within the <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalIntegerLiteral">DecimalIntegerLiteral</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref>.</li></ol></li><li>Else,<ol><li>Let <var>integerPart</var> be <emu-val>"0"</emu-val>.</li></ol></li><li>Let <var>nonIntegerDigits</var> be the source text contained within the <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalLiteral">DecimalLiteral</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref>.</li><li>If <var>parseResult</var> contains a <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref> whose source text is not <emu-val>""</emu-val>, then<ol><li>Let <var>exponentPart</var> be the source text contained within the <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref>.</li><li>Let <var>s</var> be the concatenation of <var>integerPart</var> and <var>nonIntegerDigits</var>.</li><li>Let <var>m</var> be the <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_59"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> whose decimal representation is <var>s</var>.</li><li>Let <var>e</var> be the <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_60"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> whose decimal representatin is <var>exponentPart</var>.</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_61"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>m</var>, <var>e</var>, <emu-val>"halfEven"</emu-val>).</li></ol></li><li>Else,<ol><li>Let <var>s</var> be the concatenation of <var>integerPart</var> and <var>nonIntegerDigits</var>.</li><li>Let <var>q</var> be the length of <var>nonIntegerDigits</var>.</li><li>Let <var>m</var> be the <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_62"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> whose decimal representation is <var>s</var>.</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_63"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>m</var>, -<var>q</var>, <emu-val>"halfEven"</emu-val>).</li></ol></li><li>Return <var>O</var>.</li></ol></emu-alg>
+      <emu-alg><ol><li>If NewTarget is <emu-val>undefined</emu-val>, throw a <emu-val>TypeError</emu-val> exception.</li><li>Let <var>toParse</var> be <emu-val>undefined</emu-val>.</li><li>If <var>x</var> <emu-xref href="#sec-ecmascript-language-types-bigint-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-bigint-type">is a BigInt</a></emu-xref>, set <var>toParse</var> to <emu-xref aoid="BigInt::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-bigint-tostring">BigInt::toString</a></emu-xref>(<var>x</var>, 10).</li><li>Otherwise, if <var>x</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is a Number</a></emu-xref>, set <var>toParse</var> to <emu-xref aoid="Number::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-tostring">Number::toString</a></emu-xref>(<var>x</var>, 10).</li><li>Otherwise, if <var>x</var> <emu-xref href="#sec-ecmascript-language-types-string-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-string-type">is a String</a></emu-xref>, set <var>toParse</var> to <var>x</var>.</li><li>If <var>toParse</var> <emu-xref href="#sec-ecmascript-language-types-string-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-string-type">is not a String</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>Let <var>O</var> be ?&nbsp;<emu-xref aoid="OrdinaryCreateFromConstructor"><a href="https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor">OrdinaryCreateFromConstructor</a></emu-xref>(NewTarget, <emu-val>"%Decimal128.prototype%"</emu-val>, « <var class="field">[[Decimal128Data]]</var>&nbsp;»).</li><li>If <var>toParse</var> is <emu-val>"NaN"</emu-val>, regardless of case, set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>NaN</emu-val><sub>𝔻</sub>.</li><li>If <var>toParse</var> is <emu-val>"-Infinity"</emu-val>, regardless of case, set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>-∞</emu-val><sub>𝔻</sub>.</li><li>If <var>toParse</var> is <emu-val>"Infinity"</emu-val>, regardless of case, set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>+∞</emu-val><sub>𝔻</sub>.</li><li>Let <var>parseResult</var> be <emu-xref aoid="ParseText"><a href="https://tc39.es/ecma262/#sec-parsetext">ParseText</a></emu-xref>(<var>toParse</var>, <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalLiteral">DecimalLiteral</a></emu-nt>).</li><li>If <var>parseResult</var> is a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of errors, throw a <emu-val>SyntaxError</emu-val> exception.</li><li>If <var>parseResult</var> contains a <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalIntegerLiteral">DecimalIntegerLiteral</a></emu-nt>, then<ol><li>Let <var>integerPart</var> be the source text contained within the <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalIntegerLiteral">DecimalIntegerLiteral</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref>.</li></ol></li><li>Else,<ol><li>Let <var>integerPart</var> be <emu-val>"0"</emu-val>.</li></ol></li><li>Let <var>nonIntegerDigits</var> be the source text contained within the <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalLiteral">DecimalLiteral</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref>.</li><li>If <var>parseResult</var> contains a <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref> whose source text is not <emu-val>""</emu-val>, then<ol><li>Let <var>exponentPart</var> be the source text contained within the <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref>.</li><li>Let <var>s</var> be the concatenation of <var>integerPart</var> and <var>nonIntegerDigits</var>.</li><li>Let <var>m</var> be the <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_67"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> whose decimal representation is <var>s</var>.</li><li>Let <var>e</var> be the <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_68"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> whose decimal representatin is <var>exponentPart</var>.</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_69"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>m</var>, <var>e</var>, <emu-val>"halfEven"</emu-val>).</li></ol></li><li>Else,<ol><li>Let <var>s</var> be the concatenation of <var>integerPart</var> and <var>nonIntegerDigits</var>.</li><li>Let <var>q</var> be the length of <var>nonIntegerDigits</var>.</li><li>Let <var>m</var> be the <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_70"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> whose decimal representation is <var>s</var>.</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_71"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>m</var>, -<var>q</var>, <emu-val>"halfEven"</emu-val>).</li></ol></li><li>Return <var>O</var>.</li></ol></emu-alg>
       <emu-note><span class="note">Note</span><div class="note-contents">
         <p>Given a Number argument, the <emu-xref href="#constructor"><a href="https://tc39.es/ecma262/#constructor">constructor</a></emu-xref> converts it to a String using the <emu-xref href="#sec-number.prototype.tostring"><a href="https://tc39.es/ecma262/#sec-number.prototype.tostring">toString</a></emu-xref> method (with no arguments). In some cases, this may not be desited. In some use cases, given a Number, one may wish to call the Decimal128 <emu-xref href="#constructor"><a href="https://tc39.es/ecma262/#constructor">constructor</a></emu-xref> not with the number but rather with, for instance, the result of calling <emu-xref href="#sec-number.prototype.tofixed"><a href="https://tc39.es/ecma262/#sec-number.prototype.tofixed">toFixed</a></emu-xref> or <emu-xref href="#sec-number.prototype.toprecision"><a href="https://tc39.es/ecma262/#sec-number.prototype.toprecision">toPrecision</a></emu-xref> on the Number, thereby ensuring a certain level of precision that may get lost when using Number’s toString.</p>
       </div></emu-note>
@@ -3427,7 +3428,7 @@ <h1><span class="secnum">2.2</span> Decimal128.prototype.isFinite ( )</h1>
     <h1><span class="secnum">2.3</span> Decimal128.prototype.abs ( )</h1>
     <p>This method computes the absolute value of a Decimal128 object.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_64"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_65"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_66"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_67"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>v</var>), <var>q</var>&nbsp;»<sub>𝔻</sub>).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_72"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_73"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_74"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be the <emu-xref aoid="cohort" id="_ref_75"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be the <emu-xref aoid="quantum" id="_ref_76"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>( <var>d</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_77"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>v</var>), <var>q</var>&nbsp;»<sub>𝔻</sub>).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification in Section 5.5.1 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
@@ -3437,7 +3438,7 @@ <h1><span class="secnum">2.3</span> Decimal128.prototype.abs ( )</h1>
     <h1><span class="secnum">2.4</span> Decimal128.prototype.negate ( )</h1>
     <p>This method inverts the sign of a Decimal128 object.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_68"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_69"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_70"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_71"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« -1 × <var>v</var>, <var>q</var>&nbsp;»<sub>𝔻</sub>).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_78"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_79"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_80"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be the <emu-xref aoid="cohort" id="_ref_81"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be the <emu-xref aoid="quantum" id="_ref_82"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_83"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« -1 × <var>v</var>, <var>q</var>&nbsp;»<sub>𝔻</sub>).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification in Section 5.5.1 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
@@ -3445,9 +3446,9 @@ <h1><span class="secnum">2.4</span> Decimal128.prototype.negate ( )</h1>
 
   <emu-clause id="sec-decimal.prototype.add">
     <h1><span class="secnum">2.5</span> Decimal128.prototype.add ( <var>x</var> )</h1>
-    <p>This method computes the addition of a Decimal128 object with another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_72"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
+    <p>This method computes the addition of a Decimal128 object with another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_84"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_73"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_74"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_75"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_76"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_77"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_78"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_79"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_80"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_81"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>d1</var>[0] + <var>d2</var>[0], <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>d1</var>[1], <var>d2</var>[1]), <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_85"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_86"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_87"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_88"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_89"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_90"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_91"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>v1</var> be the <emu-xref aoid="cohort" id="_ref_92"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be the <emu-xref aoid="cohort" id="_ref_93"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be the <emu-xref aoid="quantum" id="_ref_94"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be the <emu-xref aoid="quantum" id="_ref_95"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_96"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_97"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> + <var>v2</var>, <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>q1</var>, <var>q2</var>]), <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
@@ -3455,9 +3456,9 @@ <h1><span class="secnum">2.5</span> Decimal128.prototype.add ( <var>x</var> )</h
 
   <emu-clause id="sec-decimal.prototype.subtract">
     <h1><span class="secnum">2.6</span> Decimal128.prototype.subtract ( <var>x</var> )</h1>
-    <p>This method computes subtracts the given Decimal128 object from the current one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_82"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
+    <p>This method computes subtracts the given Decimal128 object from the current one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_98"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-      <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_83"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_84"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_85"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_86"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_87"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_88"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_89"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_90"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_91"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(d1[0] - d2[0], <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(d1[1], d2[1]), <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+      <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_99"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_100"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_101"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_102"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_103"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_104"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_105"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>v1</var> be the <emu-xref aoid="cohort" id="_ref_106"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be the <emu-xref aoid="cohort" id="_ref_107"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be the <emu-xref aoid="quantum" id="_ref_108"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be the <emu-xref aoid="quantum" id="_ref_109"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_110"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_111"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> - <var>v2</var>, <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>q1</var>, <var>q2</var>), <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
@@ -3465,9 +3466,9 @@ <h1><span class="secnum">2.6</span> Decimal128.prototype.subtract ( <var>x</var>
 
   <emu-clause id="sec-decimal.prototype.multiply">
     <h1><span class="secnum">2.7</span> Decimal128.prototype.multiply ( <var>x</var> )</h1>
-    <p>This method computes multiplies the current Decimal128 object by another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_92"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
+    <p>This method computes multiplies the current Decimal128 object by another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_112"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_93"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_94"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_95"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_96"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_97"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_98"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_99"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_100"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_101"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_102"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var>[0] &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_103"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_104"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_105"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_106"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref> (<var>d1</var>[0] × <var>d2</var>[0], <var>d1</var>[1] + <var>d2</var>[1], <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_113"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_114"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_115"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_116"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_117"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_118"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_119"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_120"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_121"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_122"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Let <var>v2</var> be the <emu-xref aoid="cohort" id="_ref_123"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>If <var>v2</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_124"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_125"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>v1</var> be the <emu-xref aoid="cohort" id="_ref_126"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q1</var> be the <emu-xref aoid="quantum" id="_ref_127"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be the <emu-xref aoid="quantum" id="_ref_128"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_129"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_130"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref> (<var>v1</var> × _v2, <var>q1</var> + <var>q2</var>], <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
@@ -3475,9 +3476,9 @@ <h1><span class="secnum">2.7</span> Decimal128.prototype.multiply ( <var>x</var>
 
   <emu-clause id="sec-decimal.prototype.divide">
     <h1><span class="secnum">2.8</span> Decimal128.prototype.divide ( <var>x</var> )</h1>
-    <p>This method computes divides the current Decimal128 object by another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_107"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
+    <p>This method computes divides the current Decimal128 object by another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_131"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_108"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_109"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_110"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_111"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_112"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>d1</var>[0] / <var>d2</var>[0], <var>d1</var>[1] + <var>d2</var>[1], <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_132"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_133"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_134"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Let <var>v1</var> be the <emu-xref aoid="cohort" id="_ref_135"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be the <emu-xref aoid="cohort" id="_ref_136"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be the <emu-xref aoid="quantum" id="_ref_137"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be the <emu-xref aoid="quantum" id="_ref_138"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_139"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_140"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> / <var>v2</var>, <var>q1</var> + <var>q2</var>, <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
@@ -3485,9 +3486,9 @@ <h1><span class="secnum">2.8</span> Decimal128.prototype.divide ( <var>x</var> )
 
   <emu-clause id="sec-decimal.prototype.remainder">
     <h1><span class="secnum">2.9</span> Decimal128.prototype.remainder ( <var>x</var> )</h1>
-    <p>This method computes the remainder upon dividing the current Decimal128 object by another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_113"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
+    <p>This method computes the remainder upon dividing the current Decimal128 object by another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_141"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_114"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_115"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_116"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_117"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_118"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>d1</var>[0] % <var>d2</var>[0], <var>d1</var>[1] + <var>d2</var>[1], <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_142"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_143"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_144"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Let <var>v1</var> be the <emu-xref aoid="cohort" id="_ref_145"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be the <emu-xref aoid="cohort" id="_ref_146"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be the <emu-xref aoid="quantum" id="_ref_147"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be the <emu-xref aoid="quantum" id="_ref_148"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_149"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_150"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> % <var>v2</var>, <var>q1</var> + <var>q2</var>, <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>The remainder operation specified here deviates from the <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> remainder operation (defined there in Section 5.3.1). We follow the <emu-xref href="#sec-numeric-types-number-remainder"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-remainder">the remainder operation for Number</a></emu-xref> rather than IEEE 754, which specifies that, for example, the remainder 46 and 10 is -4 rather than 6.</p>
     </div></emu-note>
@@ -3495,7 +3496,7 @@ <h1><span class="secnum">2.9</span> Decimal128.prototype.remainder ( <var>x</var
 
   <emu-clause id="sec-decimal.prototype.equals">
     <h1><span class="secnum">2.10</span> Decimal128.prototype.equals ( <var>x</var> )</h1>
-    <p>This method computes whether the current Decimal128 object has the same <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_119"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> as another Decimal128 object.</p>
+    <p>This method computes whether the current Decimal128 object has the same <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_151"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> as another Decimal128 object.</p>
     <p>It performs the following steps when called:</p>
     <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.
       I. If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li></ol></li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d1</var> is equal to the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></emu-alg>
@@ -3506,7 +3507,7 @@ <h1><span class="secnum">2.10</span> Decimal128.prototype.equals ( <var>x</var>
 
   <emu-clause id="sec-decimal.prototype.lessthan">
     <h1><span class="secnum">2.11</span> Decimal128.prototype.lessThan ( <var>x</var> )</h1>
-    <p>This method computes whether the current Decimal128 object has a strictly smaller <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_120"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> than another Decimal128 object.</p>
+    <p>This method computes whether the current Decimal128 object has a strictly smaller <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_152"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> than another Decimal128 object.</p>
     <p>It performs the following steps when called:</p>
     <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>Return <emu-val>true</emu-val>.</li></ol></li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>true</emu-val>.</li></ol></li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> of <var>d1</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
@@ -3516,24 +3517,24 @@ <h1><span class="secnum">2.11</span> Decimal128.prototype.lessThan ( <var>x</var
 
   <emu-clause id="sec-decimal.prototype.compare">
     <h1><span class="secnum">2.12</span> Decimal128.prototype.compare ( <var>x</var> )</h1>
-    <p>This method returns one of the three Number values <emu-val>-1</emu-val><sub>𝔽</sub>, <emu-val>+0</emu-val><sub>𝔽</sub>, and <emu-val>1</emu-val><sub>𝔽</sub>. It compares the current Decimal128 object with another one. If the current Decimal128 object has a strictly smaller <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_121"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, the result is <emu-val>-1</emu-val><sub>𝔽</sub>. If the current Decimal128 object has a strictly greater <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_122"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, it returns <emu-val>1</emu-val><sub>𝔽</sub>. If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> the two Decimal128 objects are the same, the exponents are compared and the computation proceeds similarly, returning <emu-val>-1</emu-val><sub>𝔽</sub> if the <emu-xref href="#sec-decimal-intro" id="_ref_123"><a href="#sec-decimal-intro">exponent</a></emu-xref> of the current Decimal128 object is strictly less than that of the argument, <emu-val>1</emu-val><sub>𝔽</sub> if if the <emu-xref href="#sec-decimal-intro" id="_ref_124"><a href="#sec-decimal-intro">exponent</a></emu-xref> is strictly greater, finally returning <emu-val>+0</emu-val><sub>𝔽</sub> if the exponents are mathematically equal.</p>
+    <p>This method returns one of the three Number values <emu-val>-1</emu-val><sub>𝔽</sub>, <emu-val>+0</emu-val><sub>𝔽</sub>, and <emu-val>1</emu-val><sub>𝔽</sub>. It compares the current Decimal128 object with another one. If the current Decimal128 object has a strictly smaller <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_153"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, the result is <emu-val>-1</emu-val><sub>𝔽</sub>. If the current Decimal128 object has a strictly greater <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_154"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, it returns <emu-val>1</emu-val><sub>𝔽</sub>. If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> the two Decimal128 objects are the same, the exponents are compared and the computation proceeds similarly, returning <emu-val>-1</emu-val><sub>𝔽</sub> if the <emu-xref href="#sec-decimal-intro" id="_ref_155"><a href="#sec-decimal-intro">exponent</a></emu-xref> of the current Decimal128 object is strictly less than that of the argument, <emu-val>1</emu-val><sub>𝔽</sub> if if the <emu-xref href="#sec-decimal-intro" id="_ref_156"><a href="#sec-decimal-intro">exponent</a></emu-xref> is strictly greater, finally returning <emu-val>+0</emu-val><sub>𝔽</sub> if the exponents are mathematically equal.</p>
     <p>It performs the following steps when called:</p>
     <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></li><li>If <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>+0</emu-val><sub>𝔽</sub>.</li><li>Return <emu-val>1</emu-val><sub>𝔽</sub>.</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>+0</emu-val><sub>𝔽</sub>.</li><li>Return <emu-val>-1</emu-val><sub>𝔽</sub>.</li></ol></li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>-1</emu-val><sub>𝔽</sub>.</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>1</emu-val><sub>𝔽</sub>.</li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> of <var>d1</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var>, return <emu-val>-1</emu-val><sub>𝔽</sub>.</li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> of <var>d2</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d1</var>, return <emu-val>1</emu-val><sub>𝔽</sub>.</li><li>Let <var>v1</var> be <var>d1</var>[1].</li><li>Let <var>v2</var> be <var>d2</var>[1].</li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>v1</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>v2</var>, return <emu-val>-1</emu-val><sub>𝔽</sub>.</li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>v2</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>v1</var>, return <emu-val>1</emu-val><sub>𝔽</sub>.</li><li>Return <emu-val>+0</emu-val><sub>𝔽</sub>.</li></ol></emu-alg>
     <emu-note><span class="note">Note 1</span><div class="note-contents">
       <p>This operation follows the specification of the <code>compareQuietOrdered</code> operation in Section 5.6.1 (and explained in Section 5.11) of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
     <emu-note><span class="note">Note 2</span><div class="note-contents">
-      <p>This operation compares Decimal128 values, intuitively understood as digit strings. Thus, for example, 1.2 and 1.20 are considered distinct values for this operation. To compare by <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_125"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, see <emu-xref href="#sec-decimal.prototype.lessthan" id="_ref_0"><a href="#sec-decimal.prototype.lessthan">lessThan</a></emu-xref> or <emu-xref href="#sec-decimal.prototype.equals" id="_ref_1"><a href="#sec-decimal.prototype.equals">equals</a></emu-xref>.</p>
+      <p>This operation compares Decimal128 values, intuitively understood as digit strings. Thus, for example, 1.2 and 1.20 are considered distinct values for this operation. To compare by <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_157"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, see <emu-xref href="#sec-decimal.prototype.lessthan" id="_ref_0"><a href="#sec-decimal.prototype.lessthan">lessThan</a></emu-xref> or <emu-xref href="#sec-decimal.prototype.equals" id="_ref_1"><a href="#sec-decimal.prototype.equals">equals</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal-method-round">
     <h1><span class="secnum">2.13</span> Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )</h1>
-    <p>This method rounds the current Decimal128 object according to the specified <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_126"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, which, if omitted, is <emu-xref href="#dfn-decimal128-default-rounding-mode" id="_ref_2"><a href="#dfn-decimal128-default-rounding-mode">the default rounding mode</a></emu-xref>, with rounding taking place only after <var>numFractionalDigits</var> non-<emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> digits, which must be a non-<emu-xref href="#sec-decimal-intro" id="_ref_127"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> Number.</p>
+    <p>This method rounds the current Decimal128 object according to the specified <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_158"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, which, if omitted, is <emu-xref href="#dfn-decimal128-default-rounding-mode" id="_ref_2"><a href="#dfn-decimal128-default-rounding-mode">the default rounding mode</a></emu-xref>, with rounding taking place only after <var>numFractionalDigits</var> non-<emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> digits, which must be a non-<emu-xref href="#sec-decimal-intro" id="_ref_159"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> Number.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>If <var>numFractionalDigits</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is not a Number</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>numFractionalDigits</var> &lt; 0, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>numFractionalDigits</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>roundingMode</var> is neither <emu-val>undefined</emu-val> nor a String, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>roundingMode</var> is undefined, set <var>roundingMode</var> to <emu-xref href="#dfn-decimal128-default-rounding-mode" id="_ref_3"><a href="#dfn-decimal128-default-rounding-mode">the default rounding mode</a></emu-xref>.</li><li>If <var>roundingMode</var> is not a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_128"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that v × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_129"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_130"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(v × 10<sup>-<var>numFractionalDigits</var></sup>, <var>q</var> + <var>numFractionalDigits</var>, <var>roundingMode</var>)).</li></ol></emu-alg>
+    <emu-alg><ol><li>If <var>numFractionalDigits</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is not a Number</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>numFractionalDigits</var> &lt; 0, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>numFractionalDigits</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>roundingMode</var> is neither <emu-val>undefined</emu-val> nor a String, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>roundingMode</var> is undefined, set <var>roundingMode</var> to <emu-xref href="#dfn-decimal128-default-rounding-mode" id="_ref_3"><a href="#dfn-decimal128-default-rounding-mode">the default rounding mode</a></emu-xref>.</li><li>If <var>roundingMode</var> is not a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_160"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>Let <var>v</var> be the <emu-xref aoid="cohort" id="_ref_161"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be the <emu-xref aoid="quantum" id="_ref_162"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that v × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_163"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_164"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(v × 10<sup>-<var>numFractionalDigits</var></sup>, <var>q</var> + <var>numFractionalDigits</var>, <var>roundingMode</var>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
-      <p>This operation follows the specification of the <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_131"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref> attributes discussed in Section 4.3 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
+      <p>This operation follows the specification of the <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_165"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref> attributes discussed in Section 4.3 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
@@ -3541,7 +3542,7 @@ <h1><span class="secnum">2.13</span> Decimal128.prototype.round ( <var>numFracti
     <h1><span class="secnum">2.14</span> Decimal128.prototype.toString ( [ <var>options</var> ] )</h1>
     <p>This method generates a String representation of the current Decimal128 object, in decimal format. Unlike Number’s <emu-xref href="#sec-number.prototype.tostring"><a href="https://tc39.es/ecma262/#sec-number.prototype.tostring">toString</a></emu-xref>, this method always produces a decimal representation of the Decimal128 object and never produces an exponential representation. That functionality is provided by <emu-xref href="#sec-decimal.prototype.toexponential" id="_ref_4"><a href="#sec-decimal.prototype.toexponential">toExponential</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>shouldCanonicalize</var> be ?&nbsp;<emu-xref aoid="Get"><a href="https://tc39.es/ecma262/#sec-get-o-p">Get</a></emu-xref>(<var>options</var>, <emu-val>"canonicalize"</emu-val>).</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_132"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_133"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_134"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>shouldCanonicalize</var> be ?&nbsp;<emu-xref aoid="Get"><a href="https://tc39.es/ecma262/#sec-get-o-p">Get</a></emu-xref>(<var>options</var>, <emu-val>"canonicalize"</emu-val>).</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_166"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_167"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_168"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
@@ -3551,7 +3552,7 @@ <h1><span class="secnum">2.14</span> Decimal128.prototype.toString ( [ <var>opti
     <h1><span class="secnum">2.15</span> Decimal128.prototype.toExponential ( [ <var>shouldCanonicalize</var> ] )</h1>
     <p>This method generates a String representation of the current Decimal128 object, in exponential format (e.g., <emu-val>"123e-4"</emu-val>).</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_135"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_136"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_137"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>O</var>).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_169"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_170"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_171"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>O</var>).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
@@ -3561,7 +3562,7 @@ <h1><span class="secnum">2.15</span> Decimal128.prototype.toExponential ( [ <var
     <h1><span class="secnum">2.16</span> Decimal128.prototype.toFixed ( <var>numDigits</var> [ , <var>shouldCanonicalize</var> ] )</h1>
     <p>This method generates a String representation of the current Decimal128 object, in decimal format, with a specified number of digits after the decimal point.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>numDigits</var> is neither <emu-val>undefined</emu-val> nor a Number, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>numDigits</var> is <emu-val>undefined_, let _numDigits_ be *+0</emu-val><sub>𝔽</sub>.</li><li>If <var>numDigits</var> &lt; 0, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>numDigits</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_138"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_139"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)), otherwise let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_140"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li><li>If <var>s</var> is <emu-val>"NaN"</emu-val>, <emu-val>"Infinity"</emu-val>, or <emu-val>"-Infinity"</emu-val>, return <var>s</var>.</li><li>Let <var>integerDigits</var> be <emu-val>""</emu-val>.</li><li>Let <var>nonIntegerDigits</var> be <emu-val>""</emu-val>.</li><li>If <var>s</var> contains a <emu-val>"."</emu-val>, then<ol><li>Set <var>integerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> up to the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Set <var>nonIntegerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> after the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>If <var>numDigits</var> &gt; 0, set <var>nonIntegerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>nonIntegerDigits</var> from 0 to <var>numDigits</var>.</li></ol></li><li>Else,<ol><li>Set <var>integerDigits</var> to <var>s</var>.</li></ol></li><li>If <var>numDigits</var> is 0, return <var>integerDigits</var>.</li><li>Return the concatenation of <var>integerDigits</var>, <emu-val>"."</emu-val>, and <var>nonIntegerDigits</var>.</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>numDigits</var> is neither <emu-val>undefined</emu-val> nor a Number, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>numDigits</var> is <emu-val>undefined_, let _numDigits_ be *+0</emu-val><sub>𝔽</sub>.</li><li>If <var>numDigits</var> &lt; 0, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>numDigits</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_172"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_173"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)), otherwise let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_174"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li><li>If <var>s</var> is <emu-val>"NaN"</emu-val>, <emu-val>"Infinity"</emu-val>, or <emu-val>"-Infinity"</emu-val>, return <var>s</var>.</li><li>Let <var>integerDigits</var> be <emu-val>""</emu-val>.</li><li>Let <var>nonIntegerDigits</var> be <emu-val>""</emu-val>.</li><li>If <var>s</var> contains a <emu-val>"."</emu-val>, then<ol><li>Set <var>integerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> up to the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Set <var>nonIntegerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> after the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>If <var>numDigits</var> &gt; 0, set <var>nonIntegerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>nonIntegerDigits</var> from 0 to <var>numDigits</var>.</li></ol></li><li>Else,<ol><li>Set <var>integerDigits</var> to <var>s</var>.</li></ol></li><li>If <var>numDigits</var> is 0, return <var>integerDigits</var>.</li><li>Return the concatenation of <var>integerDigits</var>, <emu-val>"."</emu-val>, and <var>nonIntegerDigits</var>.</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
@@ -3571,7 +3572,7 @@ <h1><span class="secnum">2.16</span> Decimal128.prototype.toFixed ( <var>numDigi
     <h1><span class="secnum">2.17</span> Decimal128.prototype.toPrecision ( <var>precision</var> [ , <var>shouldCanonicalize</var> ] )</h1>
     <p>This method generates a String representation of the current Decimal128 object, in decimal format, with a specified number of significant digits. If the <var>precision</var> argument is omitted or is <emu-val>undefined</emu-val>, this method is equivalent to <emu-xref href="#sec-decimal.prototype.tostring" id="_ref_5"><a href="#sec-decimal.prototype.tostring">toString</a></emu-xref>. This method may produce results in exponential notation or decimal notation.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>precision</var> is neither <emu-val>undefined</emu-val> nor a Number, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>precision</var> is *undefined_, then<ol><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_141"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_142"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_143"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_144"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li></ol></li><li>If <var>precision</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>precision</var> &lt; 1, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, let <var>d</var> be <emu-xref aoid="CanonicalizeDecimal128" id="_ref_145"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>).<var class="field">[[Decimal128Data]]</var>, otherwise let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>If -<var>q</var> &lt; <var>precision</var>, then<ol><li>Let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_146"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li><li>Let <var>integerDigits</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> up to the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Let <var>nonIntegerDigits</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> after the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Let <var>numTrailingZeroesToAdd</var> be <var>precision</var> minus the length of <var>nonIntegerDigits</var>.</li><li>Let <var>trailingZeroes</var> be the string <emu-val>"0"</emu-val> repeated <var>numTrailingZeroesToAdd</var> times.</li><li>Return the concatenation of <var>integerDigits</var>, <emu-val>"."</emu-val>, <var>nonIntegerDigits</var>, and <var>trailingZeroes</var>.</li></ol></li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that v × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li>Let <var>n1</var> be the largest multiple of 10 such that <var>n</var> - <var>n1</var> is less than 10<sup><var>precision</var></sup>.</li><li>Let <var>v1</var> be <var>v</var> - (<var>n1</var> / 10<sup><var>precision</var></sup>).</li><li>Let <var>N</var> be ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_147"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var>, <var>precision</var>, <emu-val>"halfEven"</emu-val>).</li><li>Return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_148"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>N</var>).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>precision</var> is neither <emu-val>undefined</emu-val> nor a Number, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>precision</var> is *undefined_, then<ol><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_175"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_176"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_177"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_178"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li></ol></li><li>If <var>precision</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>precision</var> &lt; 1, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, let <var>d</var> be <emu-xref aoid="CanonicalizeDecimal128" id="_ref_179"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>).<var class="field">[[Decimal128Data]]</var>, otherwise let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be the <emu-xref aoid="cohort" id="_ref_180"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be the <emu-xref aoid="quantum" id="_ref_181"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>If -<var>q</var> &lt; <var>precision</var>, then<ol><li>Let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_182"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li><li>Let <var>integerDigits</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> up to the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Let <var>nonIntegerDigits</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> after the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Let <var>numTrailingZeroesToAdd</var> be <var>precision</var> minus the length of <var>nonIntegerDigits</var>.</li><li>Let <var>trailingZeroes</var> be the string <emu-val>"0"</emu-val> repeated <var>numTrailingZeroesToAdd</var> times.</li><li>Return the concatenation of <var>integerDigits</var>, <emu-val>"."</emu-val>, <var>nonIntegerDigits</var>, and <var>trailingZeroes</var>.</li></ol></li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that v × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li>Let <var>n1</var> be the largest multiple of 10 such that <var>n</var> - <var>n1</var> is less than 10<sup><var>precision</var></sup>.</li><li>Let <var>v1</var> be <var>v</var> - (<var>n1</var> / 10<sup><var>precision</var></sup>).</li><li>Let <var>N</var> be ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_183"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var>, <var>precision</var>, <emu-val>"halfEven"</emu-val>).</li><li>Return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_184"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>N</var>).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
@@ -3593,7 +3594,7 @@ <h1><span class="secnum">3.1.1</span> The Number Constructor</h1>
       <emu-clause id="sec-number-constructor-number-value">
         <h1><span class="secnum">3.1.1.1</span> Number ( <var>value</var> )</h1>
         <p>This function performs the following steps when called:</p>
-        <emu-alg><ol><li>If <var>value</var> is present, then<ol><li>Let <var>serialized</var> be the result of !&nbsp;<emu-xref aoid="Call"><a href="https://tc39.es/ecma262/#sec-call">Call</a></emu-xref>([<var>value</var>].<var class="field">[[toString]]</var>, <var>value</var>).</li><li>If <var>value</var> is a Decimal128 object, return !&nbsp;<emu-xref aoid="ToNumber"><a href="https://tc39.es/ecma262/#sec-tonumber">ToNumber</a></emu-xref>(<var>serialized</var>).</li><li>Let <var>prim</var> be ?&nbsp;<emu-xref aoid="ToNumeric"><a href="https://tc39.es/ecma262/#sec-tonumeric">ToNumeric</a></emu-xref>(<var>value</var>).</li><li>If <var>prim</var> <emu-xref href="#sec-ecmascript-language-types-bigint-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-bigint-type">is a BigInt</a></emu-xref>, let <var>n</var> be <emu-xref aoid="𝔽"><a href="https://tc39.es/ecma262/#𝔽">𝔽</a></emu-xref>(<emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>prim</var>)).</li><li>Otherwise, let <var>n</var> be <var>prim</var>.</li></ol></li><li>Else,<ol><li>Let <var>n</var> be <emu-val>+0</emu-val><sub>𝔽</sub>.</li></ol></li><li>If NewTarget is <emu-val>undefined</emu-val>, return <var>n</var>.</li><li>Let <var>O</var> be ?&nbsp;<emu-xref aoid="OrdinaryCreateFromConstructor"><a href="https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor">OrdinaryCreateFromConstructor</a></emu-xref>(<emu-xref href="#sec-the-decimal-constructor" id="_ref_149"><a href="#sec-the-decimal-constructor">%Decimal128%</a></emu-xref>, <emu-val>"%Number.prototype%"</emu-val>, « <var class="field">[[NumberData]]</var>&nbsp;»).</li><li>Set <var>O</var>.<var class="field">[[NumberData]]</var> to <var>n</var>.</li><li>Return <var>O</var>.</li></ol></emu-alg>
+        <emu-alg><ol><li>If <var>value</var> is present, then<ol><li>Let <var>serialized</var> be the result of !&nbsp;<emu-xref aoid="Call"><a href="https://tc39.es/ecma262/#sec-call">Call</a></emu-xref>([<var>value</var>].<var class="field">[[toString]]</var>, <var>value</var>).</li><li>If <var>value</var> is a Decimal128 object, return !&nbsp;<emu-xref aoid="ToNumber"><a href="https://tc39.es/ecma262/#sec-tonumber">ToNumber</a></emu-xref>(<var>serialized</var>).</li><li>Let <var>prim</var> be ?&nbsp;<emu-xref aoid="ToNumeric"><a href="https://tc39.es/ecma262/#sec-tonumeric">ToNumeric</a></emu-xref>(<var>value</var>).</li><li>If <var>prim</var> <emu-xref href="#sec-ecmascript-language-types-bigint-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-bigint-type">is a BigInt</a></emu-xref>, let <var>n</var> be <emu-xref aoid="𝔽"><a href="https://tc39.es/ecma262/#𝔽">𝔽</a></emu-xref>(<emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>prim</var>)).</li><li>Otherwise, let <var>n</var> be <var>prim</var>.</li></ol></li><li>Else,<ol><li>Let <var>n</var> be <emu-val>+0</emu-val><sub>𝔽</sub>.</li></ol></li><li>If NewTarget is <emu-val>undefined</emu-val>, return <var>n</var>.</li><li>Let <var>O</var> be ?&nbsp;<emu-xref aoid="OrdinaryCreateFromConstructor"><a href="https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor">OrdinaryCreateFromConstructor</a></emu-xref>(<emu-xref href="#sec-the-decimal-constructor" id="_ref_185"><a href="#sec-the-decimal-constructor">%Decimal128%</a></emu-xref>, <emu-val>"%Number.prototype%"</emu-val>, « <var class="field">[[NumberData]]</var>&nbsp;»).</li><li>Set <var>O</var>.<var class="field">[[NumberData]]</var> to <var>n</var>.</li><li>Return <var>O</var>.</li></ol></emu-alg>
       </emu-clause>
     </emu-clause>
   </emu-clause>
@@ -3604,12 +3605,12 @@ <h1><span class="secnum">3.2.1</span> The BigInt Constructor</h1>
       <emu-clause id="sec-bigint-constructor-number-value">
         <h1><span class="secnum">3.2.1.1</span> BigInt ( <var>value</var> )</h1>
         <p>This function performs the following steps when called:</p>
-        <emu-alg><ol><li>If NewTarget is not <emu-val>undefined</emu-val>, throw a <emu-val>TypeError</emu-val> exception.</li><li><ins>If <var>value</var> is a Decimal128 object, return ?&nbsp;<emu-xref aoid="Decimal128ToBigInt" id="_ref_150"><a href="#sec-numbertobigint">Decimal128ToBigInt</a></emu-xref>(<var>value</var>).</ins></li><li>Let <var>prim</var> be ?&nbsp;<emu-xref aoid="ToPrimitive"><a href="https://tc39.es/ecma262/#sec-toprimitive">ToPrimitive</a></emu-xref>(<var>value</var>, <emu-const>number</emu-const>).</li><li>If <var>prim</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is a Number</a></emu-xref>, return ?&nbsp;<emu-xref aoid="NumberToBigInt"><a href="https://tc39.es/ecma262/#sec-numbertobigint">NumberToBigInt</a></emu-xref>(<var>prim</var>).</li><li>Otherwise, return ?&nbsp;<emu-xref aoid="ToBigInt"><a href="https://tc39.es/ecma262/#sec-tobigint">ToBigInt</a></emu-xref>(<var>prim</var>).</li></ol></emu-alg>
+        <emu-alg><ol><li>If NewTarget is not <emu-val>undefined</emu-val>, throw a <emu-val>TypeError</emu-val> exception.</li><li><ins>If <var>value</var> is a Decimal128 object, return ?&nbsp;<emu-xref aoid="Decimal128ToBigInt" id="_ref_186"><a href="#sec-numbertobigint">Decimal128ToBigInt</a></emu-xref>(<var>value</var>).</ins></li><li>Let <var>prim</var> be ?&nbsp;<emu-xref aoid="ToPrimitive"><a href="https://tc39.es/ecma262/#sec-toprimitive">ToPrimitive</a></emu-xref>(<var>value</var>, <emu-const>number</emu-const>).</li><li>If <var>prim</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is a Number</a></emu-xref>, return ?&nbsp;<emu-xref aoid="NumberToBigInt"><a href="https://tc39.es/ecma262/#sec-numbertobigint">NumberToBigInt</a></emu-xref>(<var>prim</var>).</li><li>Otherwise, return ?&nbsp;<emu-xref aoid="ToBigInt"><a href="https://tc39.es/ecma262/#sec-tobigint">ToBigInt</a></emu-xref>(<var>prim</var>).</li></ol></emu-alg>
 
          <emu-clause id="sec-numbertobigint" type="abstract operation" aoid="Decimal128ToBigInt">
           <h1><span class="secnum">3.2.1.1.1</span> <ins>Decimal128ToBigInt ( <var>number</var> )</ins></h1>
           <p>The abstract operation Decimal128ToBigInt takes argument <var>number</var> (a Decimal128 object) and returns either a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">normal completion containing</a></emu-xref> a BigInt or a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">throw completion</a></emu-xref>. It performs the following steps when called:</p>
-          <emu-alg><ol><li>If <emu-xref aoid="IsIntegralDecimal128" id="_ref_151"><a href="#sec-decimal128-isintegraldecimal128value">IsIntegralDecimal128</a></emu-xref>(<var>number</var>) is <emu-val>false</emu-val>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Return <emu-xref aoid="ℤ"><a href="https://tc39.es/ecma262/#ℤ">ℤ</a></emu-xref>(<emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>number</var>)).</li></ol></emu-alg>
+          <emu-alg><ol><li>If <emu-xref aoid="IsIntegralDecimal128" id="_ref_187"><a href="#sec-decimal128-isintegraldecimal128value">IsIntegralDecimal128</a></emu-xref>(<var>number</var>) is <emu-val>false</emu-val>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Return <emu-xref aoid="ℤ"><a href="https://tc39.es/ecma262/#ℤ">ℤ</a></emu-xref>(<emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>number</var>)).</li></ol></emu-alg>
         </emu-clause>
       </emu-clause>
     </emu-clause>
@@ -3633,44 +3634,44 @@ <h1><span class="secnum">4.1</span> Abstract Operations for NumberFormat Objects
 
     <emu-clause id="sec-tointlmathematicalvalue" type="abstract operation" aoid="ToIntlMathematicalValue">
       <h1><span class="secnum">4.1.1</span> ToIntlMathematicalValue ( <var>value</var> )</h1>
-      <p>The abstract operation ToIntlMathematicalValue takes argument <var>value</var> (an <emu-xref href="#sec-ecmascript-language-types"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types">ECMAScript language value</a></emu-xref>) and returns either a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">normal completion containing</a></emu-xref> an <emu-xref href="#intl-mathematical-value" id="_ref_152"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref> or a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">throw completion</a></emu-xref>. 
-          It returns <var>value</var> converted to an <dfn id="intl-mathematical-value" tabindex="-1">Intl mathematical value</dfn>, which is either <ins>(1) a <emu-xref href="#dfn-decimal128-finite" id="_ref_153"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, non-NaN, non-<emu-xref href="#sec-decimal-intro" id="_ref_154"><a href="#sec-decimal-intro">negative</a></emu-xref>-<emu-xref href="#dfn-decimal128-zero" id="_ref_155"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 object, (2)</ins> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_156"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><del> together with</del><ins>, or (3) one of</ins> <emu-const>positive-infinity</emu-const>, <emu-const>negative-infinity</emu-const>, <emu-const>not-a-number</emu-const>, and <emu-const>negative-zero</emu-const>.
-          This abstract operation is similar to <emu-xref href="#sec-tonumeric"><a href="https://tc39.es/ecma262/#sec-tonumeric">7.1.3</a></emu-xref>, but a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_157"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> can be returned instead of a Number or BigInt, so that exact decimal values can be represented.
+      <p>The abstract operation ToIntlMathematicalValue takes argument <var>value</var> (an <emu-xref href="#sec-ecmascript-language-types"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types">ECMAScript language value</a></emu-xref>) and returns either a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">normal completion containing</a></emu-xref> an <emu-xref href="#intl-mathematical-value" id="_ref_188"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref> or a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">throw completion</a></emu-xref>. 
+          It returns <var>value</var> converted to an <dfn id="intl-mathematical-value" tabindex="-1">Intl mathematical value</dfn>, which is either <ins>(1) a <emu-xref href="#dfn-decimal128-finite" id="_ref_189"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, non-NaN, non-<emu-xref href="#sec-decimal-intro" id="_ref_190"><a href="#sec-decimal-intro">negative</a></emu-xref>-<emu-xref href="#dfn-decimal128-zero" id="_ref_191"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 object, (2)</ins> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_192"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><del> together with</del><ins>, or (3) one of</ins> <emu-const>positive-infinity</emu-const>, <emu-const>negative-infinity</emu-const>, <emu-const>not-a-number</emu-const>, and <emu-const>negative-zero</emu-const>.
+          This abstract operation is similar to <emu-xref href="#sec-tonumeric"><a href="https://tc39.es/ecma262/#sec-tonumeric">7.1.3</a></emu-xref>, but a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_193"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> can be returned instead of a Number or BigInt, so that exact decimal values can be represented.
          It performs the following steps when called:</p>
-      <emu-alg><ol><li><ins>If <var>value</var> is a Decimal128 object, then</ins><ol><li><ins>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>value</var>, <var class="field">[[Decimal128Data]]</var>).</ins></li><li><ins>Let <var>d</var> be <var>value</var>.<var class="field">[[Decimal128Data]]</var>.</ins></li><li><ins>If <var>d</var> is NaN<sub>𝔻</sub>, return <emu-const>not-a-number</emu-const>.</ins></li><li><ins>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-const>positive-infinity</emu-const>.</ins></li><li><ins>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-const>negative-infinity</emu-const>.</ins></li><li><ins>Let <var>v</var> be <var>d</var>[0].</ins></li><li><ins>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-const>negative-zero</emu-const>.</ins></li><li><ins>Return <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_6"><a href="#dfn-decimal128-mathematical-value">the mathematical value</a></emu-xref> of <var>d</var>.</ins></li></ol></li><li>Let <var>primValue</var> be ?&nbsp;<emu-xref aoid="ToPrimitive"><a href="https://tc39.es/ecma262/#sec-toprimitive">ToPrimitive</a></emu-xref>(<var>value</var>, <emu-const>number</emu-const>).</li><li>If <emu-xref aoid="Type"><a href="https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values">Type</a></emu-xref>(<var>primValue</var>) is BigInt, return <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>primValue</var>).</li><li>If <emu-xref aoid="Type"><a href="https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values">Type</a></emu-xref>(<var>primValue</var>) is String, then<ol><li>Let <var>str</var> be <var>primValue</var>.</li></ol></li><li>Else,<ol><li>Let <var>x</var> be ?&nbsp;<emu-xref aoid="ToNumber"><a href="https://tc39.es/ecma262/#sec-tonumber">ToNumber</a></emu-xref>(<var>primValue</var>).</li><li>If <var>x</var> is <emu-val>-0</emu-val><sub>𝔽</sub>, return <emu-const>negative-zero</emu-const>.</li><li>Let <var>str</var> be <emu-xref aoid="Number::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-tostring">Number::toString</a></emu-xref>(<var>x</var>, 10).</li></ol></li><li>Let <var>text</var> be <emu-xref aoid="StringToCodePoints"><a href="https://tc39.es/ecma262/#sec-stringtocodepoints">StringToCodePoints</a></emu-xref>(<var>str</var>).</li><li>Let <var>literal</var> be <emu-xref aoid="ParseText"><a href="https://tc39.es/ecma262/#sec-parsetext">ParseText</a></emu-xref>(<var>text</var>, <emu-nt><a href="https://tc39.es/ecma262/#prod-StringNumericLiteral">StringNumericLiteral</a></emu-nt>).</li><li>If <var>literal</var> is a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of errors, return <emu-const>not-a-number</emu-const>.</li><li>Let <var>intlMV</var> be the <emu-xref aoid="StringIntlMV"><a href="https://tc39.es/ecma402/#sec-runtime-semantics-stringintlmv">StringIntlMV</a></emu-xref> of <var>literal</var>.</li><li>If <var>intlMV</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_158"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, then<ol><li>Let <var>rounded</var> be <emu-xref aoid="RoundMVResult"><a href="https://tc39.es/ecma262/#sec-roundmvresult">RoundMVResult</a></emu-xref>(<emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>intlMV</var>)).</li><li>If <var>rounded</var> is <emu-val>+∞</emu-val><sub>𝔽</sub> and <var>intlMV</var> &lt; 0, return <emu-const>negative-infinity</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+∞</emu-val><sub>𝔽</sub>, return <emu-const>positive-infinity</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+0</emu-val><sub>𝔽</sub> and <var>intlMV</var> &lt; 0, return <emu-const>negative-zero</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+0</emu-val><sub>𝔽</sub>, return 0.</li></ol></li><li>Return <var>intlMV</var>.</li></ol></emu-alg>
+      <emu-alg><ol><li><ins>If <var>value</var> is a Decimal128 object, then</ins><ol><li><ins>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>value</var>, <var class="field">[[Decimal128Data]]</var>).</ins></li><li><ins>Let <var>d</var> be <var>value</var>.<var class="field">[[Decimal128Data]]</var>.</ins></li><li><ins>If <var>d</var> is NaN<sub>𝔻</sub>, return <emu-const>not-a-number</emu-const>.</ins></li><li><ins>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-const>positive-infinity</emu-const>.</ins></li><li><ins>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-const>negative-infinity</emu-const>.</ins></li><li><ins>Let <var>v</var> be <var>d</var>[0].</ins></li><li><ins>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-const>negative-zero</emu-const>.</ins></li><li><ins>Return <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_6"><a href="#dfn-decimal128-mathematical-value">the mathematical value</a></emu-xref> of <var>d</var>.</ins></li></ol></li><li>Let <var>primValue</var> be ?&nbsp;<emu-xref aoid="ToPrimitive"><a href="https://tc39.es/ecma262/#sec-toprimitive">ToPrimitive</a></emu-xref>(<var>value</var>, <emu-const>number</emu-const>).</li><li>If <emu-xref aoid="Type"><a href="https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values">Type</a></emu-xref>(<var>primValue</var>) is BigInt, return <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>primValue</var>).</li><li>If <emu-xref aoid="Type"><a href="https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values">Type</a></emu-xref>(<var>primValue</var>) is String, then<ol><li>Let <var>str</var> be <var>primValue</var>.</li></ol></li><li>Else,<ol><li>Let <var>x</var> be ?&nbsp;<emu-xref aoid="ToNumber"><a href="https://tc39.es/ecma262/#sec-tonumber">ToNumber</a></emu-xref>(<var>primValue</var>).</li><li>If <var>x</var> is <emu-val>-0</emu-val><sub>𝔽</sub>, return <emu-const>negative-zero</emu-const>.</li><li>Let <var>str</var> be <emu-xref aoid="Number::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-tostring">Number::toString</a></emu-xref>(<var>x</var>, 10).</li></ol></li><li>Let <var>text</var> be <emu-xref aoid="StringToCodePoints"><a href="https://tc39.es/ecma262/#sec-stringtocodepoints">StringToCodePoints</a></emu-xref>(<var>str</var>).</li><li>Let <var>literal</var> be <emu-xref aoid="ParseText"><a href="https://tc39.es/ecma262/#sec-parsetext">ParseText</a></emu-xref>(<var>text</var>, <emu-nt><a href="https://tc39.es/ecma262/#prod-StringNumericLiteral">StringNumericLiteral</a></emu-nt>).</li><li>If <var>literal</var> is a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of errors, return <emu-const>not-a-number</emu-const>.</li><li>Let <var>intlMV</var> be the <emu-xref aoid="StringIntlMV"><a href="https://tc39.es/ecma402/#sec-runtime-semantics-stringintlmv">StringIntlMV</a></emu-xref> of <var>literal</var>.</li><li>If <var>intlMV</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_194"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, then<ol><li>Let <var>rounded</var> be <emu-xref aoid="RoundMVResult"><a href="https://tc39.es/ecma262/#sec-roundmvresult">RoundMVResult</a></emu-xref>(<emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>intlMV</var>)).</li><li>If <var>rounded</var> is <emu-val>+∞</emu-val><sub>𝔽</sub> and <var>intlMV</var> &lt; 0, return <emu-const>negative-infinity</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+∞</emu-val><sub>𝔽</sub>, return <emu-const>positive-infinity</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+0</emu-val><sub>𝔽</sub> and <var>intlMV</var> &lt; 0, return <emu-const>negative-zero</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+0</emu-val><sub>𝔽</sub>, return 0.</li></ol></li><li>Return <var>intlMV</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-formatnumberstring" type="abstract operation" aoid="FormatNumericToString">
       <h1><span class="secnum">4.1.2</span> FormatNumericToString ( <var>intlObject</var>, <var>x</var> )</h1>
-      <p>The abstract operation FormatNumericToString takes arguments <var>intlObject</var> (an Object) and <var>x</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_159"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, <emu-const>negative-zero</emu-const><ins>, or a Decimal128 value</ins>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_160"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> or <emu-const>negative-zero</emu-const>) and <var class="field">[[FormattedString]]</var> (a String). It rounds <var>x</var> to an <emu-xref href="#intl-mathematical-value" id="_ref_161"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref> according to the internal slots of <var>intlObject</var>. The <var class="field">[[RoundedNumber]]</var> field contains the rounded result value and the <var class="field">[[FormattedString]]</var> field contains a String value representation of that result formatted according to the internal slots of <var>intlObject</var>. It performs the following steps when called:</p>
-      <emu-alg><ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>intlObject</var> has <var class="field">[[RoundingMode]]</var>, <var class="field">[[RoundingType]]</var>, <var class="field">[[MinimumSignificantDigits]]</var>, <var class="field">[[MaximumSignificantDigits]]</var>, <var class="field">[[MinimumIntegerDigits]]</var>, <var class="field">[[MinimumFractionDigits]]</var>, <var class="field">[[MaximumFractionDigits]]</var>, <var class="field">[[RoundingIncrement]]</var>, and <var class="field">[[TrailingZeroDisplay]]</var> internal slots.</li><li>If <var>x</var> is <emu-const>negative-zero</emu-const>, then<ol><li>Let <var>sign</var> be <emu-const>negative</emu-const>.</li><li>Set <var>x</var> to 0.</li></ol></li><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>sign</var> be <emu-val>undefined</emu-val>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>NaN</emu-val><sub>𝔻</sub>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>+∞</emu-val><sub>𝔻</sub>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>-∞</emu-val><sub>𝔻</sub>.</ins></li><li><ins>Let <var>v</var> be <var>x</var>[0].</ins></li><li><ins>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, then</ins><ol><li><ins>Set <var>sign</var> be <emu-const>negative</emu-const>.</ins></li><li><ins>Set <var>x</var> to 0.</ins></li></ol></li><li><ins>Else,</ins><ol><li><ins>if <var>v</var> &lt; 0, set <var>sign</var> to <emu-const>negative</emu-const>.</ins></li><li><ins>Else, set <var>sign</var> to <emu-const>positive</emu-const>.</ins></li></ol></li><li>Set <var>x</var> to <var>v</var>.</li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_162"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>.</li><li>If <var>x</var> &lt; 0, let <var>sign</var> be <emu-const>negative</emu-const>; else let <var>sign</var> be <emu-const>positive</emu-const>.</li><li>If <var>sign</var> is <emu-const>negative</emu-const>, then<ol><li>Set <var>x</var> to -<var>x</var>.</li></ol></li></ol></li><li>Let <var>unsignedRoundingMode</var> be <emu-xref aoid="GetUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-getunsignedroundingmode">GetUnsignedRoundingMode</a></emu-xref>(<var>intlObject</var>.<var class="field">[[RoundingMode]]</var>, <var>sign</var>).</li><li>If <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>significant-digits</emu-const>, then<ol><li>Let <var>result</var> be <emu-xref aoid="ToRawPrecision" id="_ref_163"><a href="#sec-torawprecision">ToRawPrecision</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumSignificantDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumSignificantDigits]]</var>, <var>unsignedRoundingMode</var>).</li></ol></li><li>Else if <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>fraction-digits</emu-const>, then<ol><li>Let <var>result</var> be <emu-xref aoid="ToRawFixed" id="_ref_164"><a href="#sec-torawfixed">ToRawFixed</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[RoundingIncrement]]</var>, <var>unsignedRoundingMode</var>).</li></ol></li><li>Else,<ol><li>Let <var>sResult</var> be <emu-xref aoid="ToRawPrecision" id="_ref_165"><a href="#sec-torawprecision">ToRawPrecision</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumSignificantDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumSignificantDigits]]</var>, <var>unsignedRoundingMode</var>).</li><li>Let <var>fResult</var> be <emu-xref aoid="ToRawFixed" id="_ref_166"><a href="#sec-torawfixed">ToRawFixed</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[RoundingIncrement]]</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>more-precision</emu-const>, then<ol><li>If <var>sResult</var>.<var class="field">[[RoundingMagnitude]]</var> ≤ <var>fResult</var>.<var class="field">[[RoundingMagnitude]]</var>, then<ol><li>Let <var>result</var> be <var>sResult</var>.</li></ol></li><li>Else,<ol><li>Let <var>result</var> be <var>fResult</var>.</li></ol></li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>less-precision</emu-const>.</li><li>If <var>sResult</var>.<var class="field">[[RoundingMagnitude]]</var> ≤ <var>fResult</var>.<var class="field">[[RoundingMagnitude]]</var>, then<ol><li>Let <var>result</var> be <var>fResult</var>.</li></ol></li><li>Else,<ol><li>Let <var>result</var> be <var>sResult</var>.</li></ol></li></ol></li></ol></li><li>Set <var>x</var> to <var>result</var>.<var class="field">[[RoundedNumber]]</var>.</li><li>Let <var>string</var> be <var>result</var>.<var class="field">[[FormattedString]]</var>.</li><li>If <var>intlObject</var>.<var class="field">[[TrailingZeroDisplay]]</var> is <emu-val>"stripIfInteger"</emu-val> and <emu-eqn class="inline"><var>x</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> 1 = 0</emu-eqn>, then<ol><li>Let <var>i</var> be <emu-xref aoid="StringIndexOf"><a href="https://tc39.es/ecma262/#sec-stringindexof">StringIndexOf</a></emu-xref>(<var>string</var>, <emu-val>"."</emu-val>, 0).</li><li>If <var>i</var> ≠ -1, set <var>string</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>string</var> from 0 to <var>i</var>.</li></ol></li><li>Let <var>int</var> be <var>result</var>.<var class="field">[[IntegerDigitsCount]]</var>.</li><li>Let <var>minInteger</var> be <var>intlObject</var>.<var class="field">[[MinimumIntegerDigits]]</var>.</li><li>If <var>int</var> &lt; <var>minInteger</var>, then<ol><li>Let <var>forwardZeros</var> be the String consisting of <var>minInteger</var> - <var>int</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Set <var>string</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>forwardZeros</var> and <var>string</var>.</li></ol></li><li>If <var>sign</var> is <emu-const>negative</emu-const>, then<ol><li>If <var>x</var> is 0, set <var>x</var> to <emu-const>negative-zero</emu-const>. Otherwise, set <var>x</var> to -<var>x</var>.</li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[RoundedNumber]]</var>: <var>x</var>, <var class="field">[[FormattedString]]</var>: <var>string</var>&nbsp;}.</li></ol></emu-alg>
+      <p>The abstract operation FormatNumericToString takes arguments <var>intlObject</var> (an Object) and <var>x</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_195"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, <emu-const>negative-zero</emu-const><ins>, or a Decimal128 value</ins>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_196"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> or <emu-const>negative-zero</emu-const>) and <var class="field">[[FormattedString]]</var> (a String). It rounds <var>x</var> to an <emu-xref href="#intl-mathematical-value" id="_ref_197"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref> according to the internal slots of <var>intlObject</var>. The <var class="field">[[RoundedNumber]]</var> field contains the rounded result value and the <var class="field">[[FormattedString]]</var> field contains a String value representation of that result formatted according to the internal slots of <var>intlObject</var>. It performs the following steps when called:</p>
+      <emu-alg><ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>intlObject</var> has <var class="field">[[RoundingMode]]</var>, <var class="field">[[RoundingType]]</var>, <var class="field">[[MinimumSignificantDigits]]</var>, <var class="field">[[MaximumSignificantDigits]]</var>, <var class="field">[[MinimumIntegerDigits]]</var>, <var class="field">[[MinimumFractionDigits]]</var>, <var class="field">[[MaximumFractionDigits]]</var>, <var class="field">[[RoundingIncrement]]</var>, and <var class="field">[[TrailingZeroDisplay]]</var> internal slots.</li><li>If <var>x</var> is <emu-const>negative-zero</emu-const>, then<ol><li>Let <var>sign</var> be <emu-const>negative</emu-const>.</li><li>Set <var>x</var> to 0.</li></ol></li><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>sign</var> be <emu-val>undefined</emu-val>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>NaN</emu-val><sub>𝔻</sub>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>+∞</emu-val><sub>𝔻</sub>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>-∞</emu-val><sub>𝔻</sub>.</ins></li><li><ins>Let <var>v</var> be <var>x</var>[0].</ins></li><li><ins>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, then</ins><ol><li><ins>Set <var>sign</var> be <emu-const>negative</emu-const>.</ins></li><li><ins>Set <var>x</var> to 0.</ins></li></ol></li><li><ins>Else,</ins><ol><li><ins>if <var>v</var> &lt; 0, set <var>sign</var> to <emu-const>negative</emu-const>.</ins></li><li><ins>Else, set <var>sign</var> to <emu-const>positive</emu-const>.</ins></li></ol></li><li>Set <var>x</var> to <var>v</var>.</li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_198"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>.</li><li>If <var>x</var> &lt; 0, let <var>sign</var> be <emu-const>negative</emu-const>; else let <var>sign</var> be <emu-const>positive</emu-const>.</li><li>If <var>sign</var> is <emu-const>negative</emu-const>, then<ol><li>Set <var>x</var> to -<var>x</var>.</li></ol></li></ol></li><li>Let <var>unsignedRoundingMode</var> be <emu-xref aoid="GetUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-getunsignedroundingmode">GetUnsignedRoundingMode</a></emu-xref>(<var>intlObject</var>.<var class="field">[[RoundingMode]]</var>, <var>sign</var>).</li><li>If <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>significant-digits</emu-const>, then<ol><li>Let <var>result</var> be <emu-xref aoid="ToRawPrecision" id="_ref_199"><a href="#sec-torawprecision">ToRawPrecision</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumSignificantDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumSignificantDigits]]</var>, <var>unsignedRoundingMode</var>).</li></ol></li><li>Else if <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>fraction-digits</emu-const>, then<ol><li>Let <var>result</var> be <emu-xref aoid="ToRawFixed" id="_ref_200"><a href="#sec-torawfixed">ToRawFixed</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[RoundingIncrement]]</var>, <var>unsignedRoundingMode</var>).</li></ol></li><li>Else,<ol><li>Let <var>sResult</var> be <emu-xref aoid="ToRawPrecision" id="_ref_201"><a href="#sec-torawprecision">ToRawPrecision</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumSignificantDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumSignificantDigits]]</var>, <var>unsignedRoundingMode</var>).</li><li>Let <var>fResult</var> be <emu-xref aoid="ToRawFixed" id="_ref_202"><a href="#sec-torawfixed">ToRawFixed</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[RoundingIncrement]]</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>more-precision</emu-const>, then<ol><li>If <var>sResult</var>.<var class="field">[[RoundingMagnitude]]</var> ≤ <var>fResult</var>.<var class="field">[[RoundingMagnitude]]</var>, then<ol><li>Let <var>result</var> be <var>sResult</var>.</li></ol></li><li>Else,<ol><li>Let <var>result</var> be <var>fResult</var>.</li></ol></li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>less-precision</emu-const>.</li><li>If <var>sResult</var>.<var class="field">[[RoundingMagnitude]]</var> ≤ <var>fResult</var>.<var class="field">[[RoundingMagnitude]]</var>, then<ol><li>Let <var>result</var> be <var>fResult</var>.</li></ol></li><li>Else,<ol><li>Let <var>result</var> be <var>sResult</var>.</li></ol></li></ol></li></ol></li><li>Set <var>x</var> to <var>result</var>.<var class="field">[[RoundedNumber]]</var>.</li><li>Let <var>string</var> be <var>result</var>.<var class="field">[[FormattedString]]</var>.</li><li>If <var>intlObject</var>.<var class="field">[[TrailingZeroDisplay]]</var> is <emu-val>"stripIfInteger"</emu-val> and <emu-eqn class="inline"><var>x</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> 1 = 0</emu-eqn>, then<ol><li>Let <var>i</var> be <emu-xref aoid="StringIndexOf"><a href="https://tc39.es/ecma262/#sec-stringindexof">StringIndexOf</a></emu-xref>(<var>string</var>, <emu-val>"."</emu-val>, 0).</li><li>If <var>i</var> ≠ -1, set <var>string</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>string</var> from 0 to <var>i</var>.</li></ol></li><li>Let <var>int</var> be <var>result</var>.<var class="field">[[IntegerDigitsCount]]</var>.</li><li>Let <var>minInteger</var> be <var>intlObject</var>.<var class="field">[[MinimumIntegerDigits]]</var>.</li><li>If <var>int</var> &lt; <var>minInteger</var>, then<ol><li>Let <var>forwardZeros</var> be the String consisting of <var>minInteger</var> - <var>int</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Set <var>string</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>forwardZeros</var> and <var>string</var>.</li></ol></li><li>If <var>sign</var> is <emu-const>negative</emu-const>, then<ol><li>If <var>x</var> is 0, set <var>x</var> to <emu-const>negative-zero</emu-const>. Otherwise, set <var>x</var> to -<var>x</var>.</li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[RoundedNumber]]</var>: <var>x</var>, <var class="field">[[FormattedString]]</var>: <var>string</var>&nbsp;}.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-torawprecision" type="abstract operation" aoid="ToRawPrecision">
       <h1><span class="secnum">4.1.3</span> ToRawPrecision ( <var>x</var>, <var>minPrecision</var>, <var>maxPrecision</var>, <var>unsignedRoundingMode</var> )</h1>
-      <p>The abstract operation ToRawPrecision takes arguments <var>x</var> (a non-<emu-xref href="#sec-decimal-intro" id="_ref_167"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_168"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_169"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_170"><a href="#sec-decimal-intro">negative</a></emu-xref> Decimal128 value</ins>), <var>minPrecision</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 1 to 21), <var>maxPrecision</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 1 to 21), and <var>unsignedRoundingMode</var> (a specification type from the Unsigned Rounding Mode column of <emu-xref href="#table-intl-unsigned-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-unsigned-rounding-modes">Table 15</a></emu-xref>, or <emu-val>undefined</emu-val>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[FormattedString]]</var> (a String), <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_171"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var class="field">[[IntegerDigitsCount]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var class="field">[[RoundingMagnitude]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>).</p>
-          <p><ins>If <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_172"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, it</ins> <del>It</del> involves solving the following equation, which returns a valid <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_173"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> given <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> inputs:</p>
+      <p>The abstract operation ToRawPrecision takes arguments <var>x</var> (a non-<emu-xref href="#sec-decimal-intro" id="_ref_203"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_204"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_205"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_206"><a href="#sec-decimal-intro">negative</a></emu-xref> Decimal128 value</ins>), <var>minPrecision</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 1 to 21), <var>maxPrecision</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 1 to 21), and <var>unsignedRoundingMode</var> (a specification type from the Unsigned Rounding Mode column of <emu-xref href="#table-intl-unsigned-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-unsigned-rounding-modes">Table 15</a></emu-xref>, or <emu-val>undefined</emu-val>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[FormattedString]]</var> (a String), <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_207"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var class="field">[[IntegerDigitsCount]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var class="field">[[RoundingMagnitude]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>).</p>
+          <p><ins>If <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_208"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, it</ins> <del>It</del> involves solving the following equation, which returns a valid <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_209"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> given <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> inputs:</p>
           <emu-eqn id="eqn-ToRawPrecisionFn" aoid="ToRawPrecisionFn"><div>            ToRawPrecisionFn(<var>n</var>, <var>e</var>, <var>p</var>) = <var>n</var> × 10<sup><var>e</var>–<var>p</var>+1</sup></div><div>            where 10<sup><var>p</var>–1</sup> ≤ <var>n</var> &lt; 10<sup><var>p</var></sup></div></emu-eqn>
         
       <p>It performs the following steps when called:</p>
-      <emu-alg><ol><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>m</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_174"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>x</var>).</ins></li><li><ins>Let <var>e</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_175"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> of <var>x</var>.</ins></li><li><ins>Let <var>n</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_176"><a href="#sec-decimal-intro">scaled significand</a></emu-xref> of <var>x</var>.</ins></li></ol></li><li><ins>Else,</ins><ol><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref> <var>x</var> is a mathematival value.</ins></li><li>Let <var>p</var> be <var>maxPrecision</var>.</li><li>If <var>x</var> = 0<ins> or <var>x</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_177"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 object</ins>, then<ol><li>Let <var>m</var> be the String consisting of <var>p</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Let <var>e</var> be 0.</li><li>Let <var>xFinal</var> be 0.</li></ol></li><li>Else,<ol><li declared="n1,e1,r1">Let <var>n1</var> and <var>e1</var> each be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r1</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_178"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r1</var> = <emu-xref aoid="ToRawPrecisionFn" id="_ref_179"><a href="#eqn-ToRawPrecisionFn">ToRawPrecisionFn</a></emu-xref>(<var>n1</var>, <var>e1</var>, <var>p</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>r1</var> ≤ <var>x</var></emu-eqn> and <var>r1</var> is maximized.</li><li declared="n2,e2,r2">Let <var>n2</var> and <var>e2</var> each be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r2</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_180"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r2</var> = <emu-xref aoid="ToRawPrecisionFn" id="_ref_181"><a href="#eqn-ToRawPrecisionFn">ToRawPrecisionFn</a></emu-xref>(<var>n2</var>, <var>e2</var>, <var>p</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>r2</var> ≥ <var>x</var></emu-eqn> and <var>r2</var> is minimized.</li><li>Let <var>r</var> be <emu-xref aoid="ApplyUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-applyunsignedroundingmode">ApplyUnsignedRoundingMode</a></emu-xref>(<var>x</var>, <var>r1</var>, <var>r2</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>r</var> is <var>r1</var>, then<ol><li>Let <var>n</var> be <var>n1</var>.</li><li>Let <var>e</var> be <var>e1</var>.</li><li>Let <var>xFinal</var> be <var>r1</var>.</li></ol></li><li>Else,<ol><li>Let <var>n</var> be <var>n2</var>.</li><li>Let <var>e</var> be <var>e2</var>.</li><li>Let <var>xFinal</var> be <var>r2</var>.</li></ol></li><li>Let <var>m</var> be the String consisting of the digits of the decimal representation of <var>n</var> (in order, with no leading zeroes).</li></ol></li></ol></li><li>If <var>e</var> ≥ (<var>p</var> - 1), then<ol><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>m</var> and <var>e</var> - <var>p</var> + 1 occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Let <var>int</var> be <var>e</var> + 1.</li></ol></li><li>Else if <var>e</var> ≥ 0, then<ol><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of the first <var>e</var> + 1 code units of <var>m</var>, the code unit 0x002E (FULL STOP), and the remaining <var>p</var> - (<var>e</var> + 1) code units of <var>m</var>.</li><li>Let <var>int</var> be <var>e</var> + 1.</li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>e</var> &lt; 0.</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <emu-val>"0."</emu-val>, -(<var>e</var> + 1) occurrences of the code unit 0x0030 (DIGIT ZERO), and <var>m</var>.</li><li>Let <var>int</var> be 1.</li></ol></li><li>If <var>m</var> contains the code unit 0x002E (FULL STOP) and <var>maxPrecision</var> &gt; <var>minPrecision</var>, then<ol><li>Let <var>cut</var> be <var>maxPrecision</var> - <var>minPrecision</var>.</li><li>Repeat, while <var>cut</var> &gt; 0 and the last code unit of <var>m</var> is 0x0030 (DIGIT ZERO),<ol><li>Remove the last code unit from <var>m</var>.</li><li>Set <var>cut</var> to <var>cut</var> - 1.</li></ol></li><li>If the last code unit of <var>m</var> is 0x002E (FULL STOP), then<ol><li>Remove the last code unit from <var>m</var>.</li></ol></li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[FormattedString]]</var>: <var>m</var>, <var class="field">[[RoundedNumber]]</var>: <var>xFinal</var>, <var class="field">[[IntegerDigitsCount]]</var>: <var>int</var>, <var class="field">[[RoundingMagnitude]]</var>: <var>e</var>–<var>p</var>+1&nbsp;}.</li></ol></emu-alg>
+      <emu-alg><ol><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>m</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_210"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>x</var>).</ins></li><li><ins>Let <var>e</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_211"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> of <var>x</var>.</ins></li><li><ins>Let <var>n</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_212"><a href="#sec-decimal-intro">scaled significand</a></emu-xref> of <var>x</var>.</ins></li></ol></li><li><ins>Else,</ins><ol><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref> <var>x</var> is a mathematival value.</ins></li><li>Let <var>p</var> be <var>maxPrecision</var>.</li><li>If <var>x</var> = 0<ins> or <var>x</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_213"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 object</ins>, then<ol><li>Let <var>m</var> be the String consisting of <var>p</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Let <var>e</var> be 0.</li><li>Let <var>xFinal</var> be 0.</li></ol></li><li>Else,<ol><li declared="n1,e1,r1">Let <var>n1</var> and <var>e1</var> each be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r1</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_214"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r1</var> = <emu-xref aoid="ToRawPrecisionFn" id="_ref_215"><a href="#eqn-ToRawPrecisionFn">ToRawPrecisionFn</a></emu-xref>(<var>n1</var>, <var>e1</var>, <var>p</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>r1</var> ≤ <var>x</var></emu-eqn> and <var>r1</var> is maximized.</li><li declared="n2,e2,r2">Let <var>n2</var> and <var>e2</var> each be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r2</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_216"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r2</var> = <emu-xref aoid="ToRawPrecisionFn" id="_ref_217"><a href="#eqn-ToRawPrecisionFn">ToRawPrecisionFn</a></emu-xref>(<var>n2</var>, <var>e2</var>, <var>p</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>r2</var> ≥ <var>x</var></emu-eqn> and <var>r2</var> is minimized.</li><li>Let <var>r</var> be <emu-xref aoid="ApplyUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-applyunsignedroundingmode">ApplyUnsignedRoundingMode</a></emu-xref>(<var>x</var>, <var>r1</var>, <var>r2</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>r</var> is <var>r1</var>, then<ol><li>Let <var>n</var> be <var>n1</var>.</li><li>Let <var>e</var> be <var>e1</var>.</li><li>Let <var>xFinal</var> be <var>r1</var>.</li></ol></li><li>Else,<ol><li>Let <var>n</var> be <var>n2</var>.</li><li>Let <var>e</var> be <var>e2</var>.</li><li>Let <var>xFinal</var> be <var>r2</var>.</li></ol></li><li>Let <var>m</var> be the String consisting of the digits of the decimal representation of <var>n</var> (in order, with no leading zeroes).</li></ol></li></ol></li><li>If <var>e</var> ≥ (<var>p</var> - 1), then<ol><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>m</var> and <var>e</var> - <var>p</var> + 1 occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Let <var>int</var> be <var>e</var> + 1.</li></ol></li><li>Else if <var>e</var> ≥ 0, then<ol><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of the first <var>e</var> + 1 code units of <var>m</var>, the code unit 0x002E (FULL STOP), and the remaining <var>p</var> - (<var>e</var> + 1) code units of <var>m</var>.</li><li>Let <var>int</var> be <var>e</var> + 1.</li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>e</var> &lt; 0.</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <emu-val>"0."</emu-val>, -(<var>e</var> + 1) occurrences of the code unit 0x0030 (DIGIT ZERO), and <var>m</var>.</li><li>Let <var>int</var> be 1.</li></ol></li><li>If <var>m</var> contains the code unit 0x002E (FULL STOP) and <var>maxPrecision</var> &gt; <var>minPrecision</var>, then<ol><li>Let <var>cut</var> be <var>maxPrecision</var> - <var>minPrecision</var>.</li><li>Repeat, while <var>cut</var> &gt; 0 and the last code unit of <var>m</var> is 0x0030 (DIGIT ZERO),<ol><li>Remove the last code unit from <var>m</var>.</li><li>Set <var>cut</var> to <var>cut</var> - 1.</li></ol></li><li>If the last code unit of <var>m</var> is 0x002E (FULL STOP), then<ol><li>Remove the last code unit from <var>m</var>.</li></ol></li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[FormattedString]]</var>: <var>m</var>, <var class="field">[[RoundedNumber]]</var>: <var>xFinal</var>, <var class="field">[[IntegerDigitsCount]]</var>: <var>int</var>, <var class="field">[[RoundingMagnitude]]</var>: <var>e</var>–<var>p</var>+1&nbsp;}.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-torawfixed" type="abstract operation" aoid="ToRawFixed">
       <h1><span class="secnum">4.1.4</span> ToRawFixed ( <var>x</var>, <var>minFraction</var>, <var>maxFraction</var>, <var>roundingIncrement</var>, <var>unsignedRoundingMode</var> )</h1>
-      <p>The abstract operation ToRawFixed takes arguments <var>x</var> (a non-<emu-xref href="#sec-decimal-intro" id="_ref_182"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_183"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_184"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_185"><a href="#sec-decimal-intro">negative</a></emu-xref> Decimal128 value</ins>), <var>minFraction</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 0 to 100), <var>maxFraction</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 0 to 100), <var>roundingIncrement</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var>unsignedRoundingMode</var> (a specification type from the Unsigned Rounding Mode column of <emu-xref href="#table-intl-unsigned-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-unsigned-rounding-modes">Table 15</a></emu-xref>, or <emu-val>undefined</emu-val>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[FormattedString]]</var> (a String), <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_186"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var class="field">[[IntegerDigitsCount]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var class="field">[[RoundingMagnitude]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>).</p>
-          <p><del>It</del> involves solving the following equation, which returns a valid <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_187"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> given <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> inputs:</p>
+      <p>The abstract operation ToRawFixed takes arguments <var>x</var> (a non-<emu-xref href="#sec-decimal-intro" id="_ref_218"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_219"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_220"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_221"><a href="#sec-decimal-intro">negative</a></emu-xref> Decimal128 value</ins>), <var>minFraction</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 0 to 100), <var>maxFraction</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 0 to 100), <var>roundingIncrement</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var>unsignedRoundingMode</var> (a specification type from the Unsigned Rounding Mode column of <emu-xref href="#table-intl-unsigned-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-unsigned-rounding-modes">Table 15</a></emu-xref>, or <emu-val>undefined</emu-val>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[FormattedString]]</var> (a String), <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_222"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var class="field">[[IntegerDigitsCount]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var class="field">[[RoundingMagnitude]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>).</p>
+          <p><del>It</del> involves solving the following equation, which returns a valid <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_223"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> given <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> inputs:</p>
           <emu-eqn id="eqn-ToRawFixedFn" aoid="ToRawFixedFn"><div>            ToRawFixedFn(<var>n</var>, <var>f</var>) = <var>n</var> × 10<sup>–<var>f</var></sup></div></emu-eqn>
         
       <p>It performs the following steps when called:</p>
-      <emu-alg><ol><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>m</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_188"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>x</var>).</ins></li><li><ins>Let <var>f</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_189"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> of <var>x</var>.</ins></li><li><ins>Let <var>n</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_190"><a href="#sec-decimal-intro">scaled significand</a></emu-xref> of <var>x</var>.</ins></li></ol></li><li>Else,<ol><li>Let <var>f</var> be <var>maxFraction</var>.</li><li declared="n1,r1">Let <var>n1</var> be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r1</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_191"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r1</var> = <emu-xref aoid="ToRawFixedFn" id="_ref_192"><a href="#eqn-ToRawFixedFn">ToRawFixedFn</a></emu-xref>(<var>n1</var>, <var>f</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>n1</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> <var>roundingIncrement</var> = 0</emu-eqn>, <emu-eqn class="inline"><var>r1</var> ≤ <var>x</var></emu-eqn>, and <var>r1</var> is maximized.</li><li declared="n2,r2">Let <var>n2</var> be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r2</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_193"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r2</var> = <emu-xref aoid="ToRawFixedFn" id="_ref_194"><a href="#eqn-ToRawFixedFn">ToRawFixedFn</a></emu-xref>(<var>n2</var>, <var>f</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>n2</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> <var>roundingIncrement</var> = 0</emu-eqn>, <emu-eqn class="inline"><var>r2</var> ≥ <var>x</var></emu-eqn>, and <var>r2</var> is minimized.</li><li>Let <var>r</var> be <emu-xref aoid="ApplyUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-applyunsignedroundingmode">ApplyUnsignedRoundingMode</a></emu-xref>(<var>x</var>, <var>r1</var>, <var>r2</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>r</var> is <var>r1</var>, then<ol><li>Set <var>n</var> to <var>n1</var>.</li><li>Let <var>xFinal</var> be <var>r1</var>.</li></ol></li><li>Else,<ol><li>Set <var>n</var> to <var>n2</var>.</li><li>Let <var>xFinal</var> be <var>r2</var>.</li></ol></li></ol></li><li>If <var>n</var> = 0, let <var>m</var> be <emu-val>"0"</emu-val>. Otherwise, let <var>m</var> be the String consisting of the digits of the decimal representation of <var>n</var> (in order, with no leading zeroes).</li><li>If <var>f</var> ≠ 0, then<ol><li>Let <var>k</var> be the length of <var>m</var>.</li><li>If <var>k</var> ≤ <var>f</var>, then<ol><li>Let <var>z</var> be the String value consisting of <var>f</var> + 1 - <var>k</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>z</var> and <var>m</var>.</li><li>Set <var>k</var> to <var>f</var> + 1.</li></ol></li><li>Let <var>a</var> be the first <var>k</var> - <var>f</var> code units of <var>m</var>, and let <var>b</var> be the remaining <var>f</var> code units of <var>m</var>.</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>a</var>, <emu-val>"."</emu-val>, and <var>b</var>.</li><li>Let <var>int</var> be the length of <var>a</var>.</li></ol></li><li>Else,<ol><li>Let <var>int</var> be the length of <var>m</var>.</li></ol></li><li>Let <var>cut</var> be <var>maxFraction</var> - <var>minFraction</var>.</li><li>Repeat, while <var>cut</var> &gt; 0 and the last code unit of <var>m</var> is 0x0030 (DIGIT ZERO),<ol><li>Remove the last code unit from <var>m</var>.</li><li>Set <var>cut</var> to <var>cut</var> - 1.</li></ol></li><li>If the last code unit of <var>m</var> is 0x002E (FULL STOP), then<ol><li>Remove the last code unit from <var>m</var>.</li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[FormattedString]]</var>: <var>m</var>, <var class="field">[[RoundedNumber]]</var>: <var>xFinal</var>, <var class="field">[[IntegerDigitsCount]]</var>: <var>int</var>, <var class="field">[[RoundingMagnitude]]</var>: –<var>f</var>&nbsp;}.</li></ol></emu-alg>
+      <emu-alg><ol><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>m</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_224"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>x</var>).</ins></li><li><ins>Let <var>f</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_225"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> of <var>x</var>.</ins></li><li><ins>Let <var>n</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_226"><a href="#sec-decimal-intro">scaled significand</a></emu-xref> of <var>x</var>.</ins></li></ol></li><li>Else,<ol><li>Let <var>f</var> be <var>maxFraction</var>.</li><li declared="n1,r1">Let <var>n1</var> be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r1</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_227"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r1</var> = <emu-xref aoid="ToRawFixedFn" id="_ref_228"><a href="#eqn-ToRawFixedFn">ToRawFixedFn</a></emu-xref>(<var>n1</var>, <var>f</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>n1</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> <var>roundingIncrement</var> = 0</emu-eqn>, <emu-eqn class="inline"><var>r1</var> ≤ <var>x</var></emu-eqn>, and <var>r1</var> is maximized.</li><li declared="n2,r2">Let <var>n2</var> be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r2</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_229"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r2</var> = <emu-xref aoid="ToRawFixedFn" id="_ref_230"><a href="#eqn-ToRawFixedFn">ToRawFixedFn</a></emu-xref>(<var>n2</var>, <var>f</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>n2</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> <var>roundingIncrement</var> = 0</emu-eqn>, <emu-eqn class="inline"><var>r2</var> ≥ <var>x</var></emu-eqn>, and <var>r2</var> is minimized.</li><li>Let <var>r</var> be <emu-xref aoid="ApplyUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-applyunsignedroundingmode">ApplyUnsignedRoundingMode</a></emu-xref>(<var>x</var>, <var>r1</var>, <var>r2</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>r</var> is <var>r1</var>, then<ol><li>Set <var>n</var> to <var>n1</var>.</li><li>Let <var>xFinal</var> be <var>r1</var>.</li></ol></li><li>Else,<ol><li>Set <var>n</var> to <var>n2</var>.</li><li>Let <var>xFinal</var> be <var>r2</var>.</li></ol></li></ol></li><li>If <var>n</var> = 0, let <var>m</var> be <emu-val>"0"</emu-val>. Otherwise, let <var>m</var> be the String consisting of the digits of the decimal representation of <var>n</var> (in order, with no leading zeroes).</li><li>If <var>f</var> ≠ 0, then<ol><li>Let <var>k</var> be the length of <var>m</var>.</li><li>If <var>k</var> ≤ <var>f</var>, then<ol><li>Let <var>z</var> be the String value consisting of <var>f</var> + 1 - <var>k</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>z</var> and <var>m</var>.</li><li>Set <var>k</var> to <var>f</var> + 1.</li></ol></li><li>Let <var>a</var> be the first <var>k</var> - <var>f</var> code units of <var>m</var>, and let <var>b</var> be the remaining <var>f</var> code units of <var>m</var>.</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>a</var>, <emu-val>"."</emu-val>, and <var>b</var>.</li><li>Let <var>int</var> be the length of <var>a</var>.</li></ol></li><li>Else,<ol><li>Let <var>int</var> be the length of <var>m</var>.</li></ol></li><li>Let <var>cut</var> be <var>maxFraction</var> - <var>minFraction</var>.</li><li>Repeat, while <var>cut</var> &gt; 0 and the last code unit of <var>m</var> is 0x0030 (DIGIT ZERO),<ol><li>Remove the last code unit from <var>m</var>.</li><li>Set <var>cut</var> to <var>cut</var> - 1.</li></ol></li><li>If the last code unit of <var>m</var> is 0x002E (FULL STOP), then<ol><li>Remove the last code unit from <var>m</var>.</li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[FormattedString]]</var>: <var>m</var>, <var class="field">[[RoundedNumber]]</var>: <var>xFinal</var>, <var class="field">[[IntegerDigitsCount]]</var>: <var>int</var>, <var class="field">[[RoundingMagnitude]]</var>: –<var>f</var>&nbsp;}.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-partitionnumberpattern" type="abstract operation" aoid="PartitionNumberPattern">
       <h1><span class="secnum">4.1.5</span> PartitionNumberPattern ( <var>numberFormat</var>, <var>x</var> )</h1>
-      <p>The abstract operation PartitionNumberPattern takes arguments <var>numberFormat</var> (an object initialized as a NumberFormat) and <var>x</var> (an <emu-xref href="#intl-mathematical-value" id="_ref_195"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Records</a></emu-xref> with fields <var class="field">[[Type]]</var> (a String) and <var class="field">[[Value]]</var> (a String). It creates the parts representing the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> according to the effective locale and the formatting options of <var>numberFormat</var>. It performs the following steps when called:</p>
+      <p>The abstract operation PartitionNumberPattern takes arguments <var>numberFormat</var> (an object initialized as a NumberFormat) and <var>x</var> (an <emu-xref href="#intl-mathematical-value" id="_ref_231"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Records</a></emu-xref> with fields <var class="field">[[Type]]</var> (a String) and <var class="field">[[Value]]</var> (a String). It creates the parts representing the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> according to the effective locale and the formatting options of <var>numberFormat</var>. It performs the following steps when called:</p>
 
-      <emu-alg><ol><li>Let <var>exponent</var> be 0.</li><li>If <var>x</var> is <emu-const>not-a-number</emu-const>, then<ol><li>Let <var>n</var> be an implementation- and locale-dependent (ILD) String value indicating the <emu-val>NaN</emu-val> value.</li></ol></li><li>Else if <var>x</var> is <emu-const>positive-infinity</emu-const>, then<ol><li>Let <var>n</var> be an ILD String value indicating positive infinity.</li></ol></li><li>Else if <var>x</var> is <emu-const>negative-infinity</emu-const>, then<ol><li>Let <var>n</var> be an ILD String value indicating <emu-xref href="#sec-decimal-intro" id="_ref_196"><a href="#sec-decimal-intro">negative</a></emu-xref> infinity.</li></ol></li><li><ins>Else if <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>v</var> be <var>x</var>[0].</ins></li><li><ins>Let <var>q</var> be <var>x</var>[1].</ins></li><li><ins>If <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, set <var>x</var> to « <var>v</var> × 100, <var>q</var> + 2&nbsp;».</ins></li><li><ins>Set <var>exponent</var> to the <emu-xref href="#sec-decimal-intro" id="_ref_197"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> <var>x</var>.</ins></li><li><ins>Set <var>x</var> to !&nbsp;<var>v</var> × 10<sup>-<var>exponent</var></sup>.</ins></li></ol></li><li>Else,<ol><li>If <var>x</var> is not <emu-const>negative-zero</emu-const>, then<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_198"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>.</li><li>If <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, set <var>x</var> be 100 × <var>x</var>.</li><li>Set <var>exponent</var> to <emu-xref aoid="ComputeExponent"><a href="https://tc39.es/ecma402/#sec-computeexponent">ComputeExponent</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Set <var>x</var> to <var>x</var> × 10<sup>-<var>exponent</var></sup>.</li></ol></li><li>Let <var>formatNumberResult</var> be <emu-xref aoid="FormatNumericToString" id="_ref_199"><a href="#sec-formatnumberstring">FormatNumericToString</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Let <var>n</var> be <var>formatNumberResult</var>.<var class="field">[[FormattedString]]</var>.</li><li>Set <var>x</var> to <var>formatNumberResult</var>.<var class="field">[[RoundedNumber]]</var>.</li></ol></li><li>Let <var>pattern</var> be <emu-xref aoid="GetNumberFormatPattern"><a href="https://tc39.es/ecma402/#sec-getnumberformatpattern">GetNumberFormatPattern</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Let <var>result</var> be a new empty <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref>.</li><li>Let <var>patternParts</var> be <emu-xref aoid="PartitionPattern"><a href="https://tc39.es/ecma402/#sec-partitionpattern">PartitionPattern</a></emu-xref>(<var>pattern</var>).</li><li>For each <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>, <var class="field">[[Value]]</var>&nbsp;} <var>patternPart</var> of <var>patternParts</var>, do<ol><li>Let <var>p</var> be <var>patternPart</var>.<var class="field">[[Type]]</var>.</li><li>If <var>p</var> is <emu-val>"literal"</emu-val>, then<ol><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"literal"</emu-val>, <var class="field">[[Value]]</var>: <var>patternPart</var>.<var class="field">[[Value]]</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"number"</emu-val>, then<ol><li>Let <var>notationSubParts</var> be <emu-xref aoid="PartitionNotationSubPattern"><a href="https://tc39.es/ecma402/#sec-partitionnotationsubpattern">PartitionNotationSubPattern</a></emu-xref>(<var>numberFormat</var>, <var>x</var>, <var>n</var>, <var>exponent</var>).</li><li>For each <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>, <var class="field">[[Value]]</var>&nbsp;} <var>subPart</var> of <var>notationSubParts</var>, do<ol><li>Append <var>subPart</var> to <var>result</var>.</li></ol></li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"plusSign"</emu-val>, then<ol><li>Let <var>plusSignSymbol</var> be the ILND String representing the plus sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"plusSign"</emu-val>, <var class="field">[[Value]]</var>: <var>plusSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"minusSign"</emu-val>, then<ol><li>Let <var>minusSignSymbol</var> be the ILND String representing the minus sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"minusSign"</emu-val>, <var class="field">[[Value]]</var>: <var>minusSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"percentSign"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, then<ol><li>Let <var>percentSignSymbol</var> be the ILND String representing the percent sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"percentSign"</emu-val>, <var class="field">[[Value]]</var>: <var>percentSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"unitPrefix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"unit"</emu-val>, then<ol><li>Let <var>unit</var> be <var>numberFormat</var>.<var class="field">[[Unit]]</var>.</li><li>Let <var>unitDisplay</var> be <var>numberFormat</var>.<var class="field">[[UnitDisplay]]</var>.</li><li>Let <var>mu</var> be an ILD String value representing <var>unit</var> before <var>x</var> in <var>unitDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unit"</emu-val>, <var class="field">[[Value]]</var>: <var>mu</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"unitSuffix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"unit"</emu-val>, then<ol><li>Let <var>unit</var> be <var>numberFormat</var>.<var class="field">[[Unit]]</var>.</li><li>Let <var>unitDisplay</var> be <var>numberFormat</var>.<var class="field">[[UnitDisplay]]</var>.</li><li>Let <var>mu</var> be an ILD String value representing <var>unit</var> after <var>x</var> in <var>unitDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unit"</emu-val>, <var class="field">[[Value]]</var>: <var>mu</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencyCode"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>cd</var> be <var>currency</var>.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencyPrefix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>currencyDisplay</var> be <var>numberFormat</var>.<var class="field">[[CurrencyDisplay]]</var>.</li><li>Let <var>cd</var> be an ILD String value representing <var>currency</var> before <var>x</var> in <var>currencyDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencySuffix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>currencyDisplay</var> be <var>numberFormat</var>.<var class="field">[[CurrencyDisplay]]</var>.</li><li>Let <var>cd</var> be an ILD String value representing <var>currency</var> after <var>x</var> in <var>currencyDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms. If the implementation does not have such a representation of <var>currency</var>, use <var>currency</var> itself.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else,<ol><li>Let <var>unknown</var> be an ILND String based on <var>x</var> and <var>p</var>.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unknown"</emu-val>, <var class="field">[[Value]]</var>: <var>unknown</var>&nbsp;} to <var>result</var>.</li></ol></li></ol></li><li>Return <var>result</var>.</li></ol></emu-alg>
+      <emu-alg><ol><li>Let <var>exponent</var> be 0.</li><li>If <var>x</var> is <emu-const>not-a-number</emu-const>, then<ol><li>Let <var>n</var> be an implementation- and locale-dependent (ILD) String value indicating the <emu-val>NaN</emu-val> value.</li></ol></li><li>Else if <var>x</var> is <emu-const>positive-infinity</emu-const>, then<ol><li>Let <var>n</var> be an ILD String value indicating positive infinity.</li></ol></li><li>Else if <var>x</var> is <emu-const>negative-infinity</emu-const>, then<ol><li>Let <var>n</var> be an ILD String value indicating <emu-xref href="#sec-decimal-intro" id="_ref_232"><a href="#sec-decimal-intro">negative</a></emu-xref> infinity.</li></ol></li><li><ins>Else if <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>v</var> be <var>x</var>[0].</ins></li><li><ins>Let <var>q</var> be <var>x</var>[1].</ins></li><li><ins>If <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, set <var>x</var> to « <var>v</var> × 100, <var>q</var> + 2&nbsp;».</ins></li><li><ins>Set <var>exponent</var> to the <emu-xref href="#sec-decimal-intro" id="_ref_233"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> <var>x</var>.</ins></li><li><ins>Set <var>x</var> to !&nbsp;<var>v</var> × 10<sup>-<var>exponent</var></sup>.</ins></li></ol></li><li>Else,<ol><li>If <var>x</var> is not <emu-const>negative-zero</emu-const>, then<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_234"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>.</li><li>If <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, set <var>x</var> be 100 × <var>x</var>.</li><li>Set <var>exponent</var> to <emu-xref aoid="ComputeExponent"><a href="https://tc39.es/ecma402/#sec-computeexponent">ComputeExponent</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Set <var>x</var> to <var>x</var> × 10<sup>-<var>exponent</var></sup>.</li></ol></li><li>Let <var>formatNumberResult</var> be <emu-xref aoid="FormatNumericToString" id="_ref_235"><a href="#sec-formatnumberstring">FormatNumericToString</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Let <var>n</var> be <var>formatNumberResult</var>.<var class="field">[[FormattedString]]</var>.</li><li>Set <var>x</var> to <var>formatNumberResult</var>.<var class="field">[[RoundedNumber]]</var>.</li></ol></li><li>Let <var>pattern</var> be <emu-xref aoid="GetNumberFormatPattern"><a href="https://tc39.es/ecma402/#sec-getnumberformatpattern">GetNumberFormatPattern</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Let <var>result</var> be a new empty <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref>.</li><li>Let <var>patternParts</var> be <emu-xref aoid="PartitionPattern"><a href="https://tc39.es/ecma402/#sec-partitionpattern">PartitionPattern</a></emu-xref>(<var>pattern</var>).</li><li>For each <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>, <var class="field">[[Value]]</var>&nbsp;} <var>patternPart</var> of <var>patternParts</var>, do<ol><li>Let <var>p</var> be <var>patternPart</var>.<var class="field">[[Type]]</var>.</li><li>If <var>p</var> is <emu-val>"literal"</emu-val>, then<ol><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"literal"</emu-val>, <var class="field">[[Value]]</var>: <var>patternPart</var>.<var class="field">[[Value]]</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"number"</emu-val>, then<ol><li>Let <var>notationSubParts</var> be <emu-xref aoid="PartitionNotationSubPattern"><a href="https://tc39.es/ecma402/#sec-partitionnotationsubpattern">PartitionNotationSubPattern</a></emu-xref>(<var>numberFormat</var>, <var>x</var>, <var>n</var>, <var>exponent</var>).</li><li>For each <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>, <var class="field">[[Value]]</var>&nbsp;} <var>subPart</var> of <var>notationSubParts</var>, do<ol><li>Append <var>subPart</var> to <var>result</var>.</li></ol></li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"plusSign"</emu-val>, then<ol><li>Let <var>plusSignSymbol</var> be the ILND String representing the plus sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"plusSign"</emu-val>, <var class="field">[[Value]]</var>: <var>plusSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"minusSign"</emu-val>, then<ol><li>Let <var>minusSignSymbol</var> be the ILND String representing the minus sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"minusSign"</emu-val>, <var class="field">[[Value]]</var>: <var>minusSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"percentSign"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, then<ol><li>Let <var>percentSignSymbol</var> be the ILND String representing the percent sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"percentSign"</emu-val>, <var class="field">[[Value]]</var>: <var>percentSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"unitPrefix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"unit"</emu-val>, then<ol><li>Let <var>unit</var> be <var>numberFormat</var>.<var class="field">[[Unit]]</var>.</li><li>Let <var>unitDisplay</var> be <var>numberFormat</var>.<var class="field">[[UnitDisplay]]</var>.</li><li>Let <var>mu</var> be an ILD String value representing <var>unit</var> before <var>x</var> in <var>unitDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unit"</emu-val>, <var class="field">[[Value]]</var>: <var>mu</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"unitSuffix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"unit"</emu-val>, then<ol><li>Let <var>unit</var> be <var>numberFormat</var>.<var class="field">[[Unit]]</var>.</li><li>Let <var>unitDisplay</var> be <var>numberFormat</var>.<var class="field">[[UnitDisplay]]</var>.</li><li>Let <var>mu</var> be an ILD String value representing <var>unit</var> after <var>x</var> in <var>unitDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unit"</emu-val>, <var class="field">[[Value]]</var>: <var>mu</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencyCode"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>cd</var> be <var>currency</var>.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencyPrefix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>currencyDisplay</var> be <var>numberFormat</var>.<var class="field">[[CurrencyDisplay]]</var>.</li><li>Let <var>cd</var> be an ILD String value representing <var>currency</var> before <var>x</var> in <var>currencyDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencySuffix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>currencyDisplay</var> be <var>numberFormat</var>.<var class="field">[[CurrencyDisplay]]</var>.</li><li>Let <var>cd</var> be an ILD String value representing <var>currency</var> after <var>x</var> in <var>currencyDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms. If the implementation does not have such a representation of <var>currency</var>, use <var>currency</var> itself.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else,<ol><li>Let <var>unknown</var> be an ILND String based on <var>x</var> and <var>p</var>.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unknown"</emu-val>, <var class="field">[[Value]]</var>: <var>unknown</var>&nbsp;} to <var>result</var>.</li></ol></li></ol></li><li>Return <var>result</var>.</li></ol></emu-alg>
     </emu-clause>
   </emu-clause>
 </emu-clause><emu-annex id="sec-copyright-and-software-license">
diff --git a/spec.emu b/spec.emu
index 38ab8cab..13fbd3c3 100644
--- a/spec.emu
+++ b/spec.emu
@@ -46,12 +46,12 @@ location: https://github.com/tc39/proposal-decimal/
     <emu-note>
       <p>A Decimal128 value is not an ECMAScript language value.</p>
     </emu-note>
+    <p>A Decimal128 value is said to be <dfn id="dfn-decimal128-finite">finite</dfn> if it has the form « _v_, _q_ »<sub>𝔻</sub>. A <dfn id="dfn-decimal128-zero">zero</dfn> Decimal128 value is a finite Decimal128 value of the form « 0<sub>𝔻</sub>, _q_ »<sub>𝔻</sub> or « -0<sub>𝔻</sub>, _q_ »<sub>𝔻</sub>. A finite non-zero Decimal128 value is one of the form « _v_, _q_ »<sub>𝔻</sub> where _v_ is a mathematical value. A finite Decimal128 value « _v_, _q_ »<sub>𝔻</sub> is said to be <dfn>negative</dfn> if either _v_ is -0<sub>D</sub> or _v_ is a real number such that _v_ < 0.</p>
     <p>The <dfn id="dfn-decimal128-mathematical-value">mathematical value</dfn> of a finite Decimal128 value _x_ = « _v_, _q_ »<sub>𝔻</sub> is defined as follows:</p>
     <ul>
       <li>If _x_ is zero, the mathematical value of _x_ is 0</li>
       <li>If _x_ is non-zero, the mathematical value of _x_ is v × 10<sup>_q_</sup></li>
     </ul>
-    <p>A Decimal128 value is said to be <dfn id="dfn-decimal128-finite">finite</dfn> if it has the form « _v_, _q_ »<sub>𝔻</sub>. A <dfn id="dfn-decimal128-zero">zero</dfn> Decimal128 value is a finite Decimal128 value of the form « 0<sub>𝔻</sub>, _q_ »<sub>𝔻</sub> or « -0<sub>𝔻</sub>, _q_ »<sub>𝔻</sub>. A finite non-zero Decimal128 value is one of the form « _v_, _q_ »<sub>𝔻</sub> where _v_ is a mathematical value. A finite Decimal128 value « _v_, _q_ »<sub>𝔻</sub> is said to be <dfn>negative</dfn> if either _v_ is -0<sub>D</sub> or _v_ is a real number such that _v_ < 0.</p>
     <emu-note>
       <p>The _v_ component of a finite non-zero Decimal128 value « _v_, _q_ »<sub>𝔻</sub> is a rational number.</p>
     </emu-note>
@@ -97,13 +97,14 @@ location: https://github.com/tc39/proposal-decimal/
       </table>
       <emu-note>The above five rounding modes are defined in IEEE 754. This table is offered for implementors who may need to convert the Decimal128 rounding modes defined here into a library that may use the official IEEE 754 rounding mode names. Additional rounding modes are used elsewhere in this specification, such as in <emu-xref href="#table-intl-rounding-modes">Intl.NumberFormat</emu-xref>.</emu-note>
     </emu-table>
-    <p>The <dfn id="dfn-decimal128-cohort">cohort</dfn> of a Decimal128 value is defined as follows:</p>
+    <p>The <emu-eqn id="eqn-decimal128-cohort" aoid="cohort">cohort(_x_)</emu-eqn> of a Decimal128 value _x_ is defined as follows:</p>
     <ul>
       <li>cohort(*NaN*<sub>𝔻</sub>) = *NaN*<sub>𝔻</sub></li>
       <li>cohort(*+∞*<sub>𝔻</sub>) = *+∞*<sub>𝔻</sub></li>
       <li>cohort(*-∞*<sub>𝔻</sub>) = *-∞*<sub>𝔻</sub></li>
       <li>cohort(« _v_, _q_ »<sub>𝔻</sub>) = _v_</li>
     </ul>
+    <p>For every finite Decimal128 value _x_ = « _v_, _q_ », the <emu-eqn id="eqn-decimal128-quantum" aoid="quantum">quantum(_x_) = _q_</emu-eqn>.</p>
     <p>For every finite non-zero Decimal128 value « _v_, _q_ »<sub>𝔻</sub> there exists a unique integer _e_ and mathematical value _s_ such that</p>
     <ol>
       <li>_v_ = _s_ × 10<sup>_e_</sup></li>
@@ -143,8 +144,8 @@ location: https://github.com/tc39/proposal-decimal/
         1. If _argument_ is *NaN*<sub>𝔻</sub>, return *"NaN"*.
         1. If _argument_ is *+∞*<sub>𝔻</sub>, return *"Infinity"*.
         1. If _argument_ is *-∞*<sub>𝔻</sub>, return *"-Infinity"*.
-        1. Let _v_ be _argument_[0].
-        1. Let _q_ be _argument_[1].
+        1. Let _v_ be the cohort(_argument_).
+        1. Let _q_ be quantum(_argument_).
         1. If _v_ is *+0*<sub>𝔻</sub>, return *"0"*.
         1. If _v_ is *-0*<sub>𝔻</sub>, return *"-0"*.
         1. Let _n_ be the integer for which _v_ × 10<sup>-_q_</sup> = _n_ and 0 < abs(_n_) < 10<sup>34</sup>.
@@ -173,8 +174,8 @@ location: https://github.com/tc39/proposal-decimal/
         1. If _argument_ is *NaN*<sub>𝔻</sub>, return *"NaN"*.
         1. If _argument_ is *+∞*<sub>𝔻</sub>, return *"Infinity"*.
         1. If _argument_ is *-∞*<sub>𝔻</sub>, return *"-Infinity"*.
-        1. Let _v_ be _argument_[0].
-        1. Let _q_ be _argument_[1].
+        1. Let _v_ be the cohort(_argument_).
+        1. Let _q_ be the quantum(_argument_).
         1. If _v_ is *+0*<sub>𝔻</sub>, return *"0"*.
         1. If _v_ is *-0*<sub>𝔻</sub>, return *"-0"*.
         1. Let _coefficientStr_ be the unique decimal string representation of _v_ without leading zeroes.
@@ -197,8 +198,8 @@ location: https://github.com/tc39/proposal-decimal/
         1. Let _d_ be _argument_.[[Decimal128Data]].
         1. If _d_ is *NaN*<sub>𝔻</sub>, return *false*.
         1. If _d_ is *+∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return *false*.
-        1. Let _v_ be _d_[0].
-        1. Let _q_ be _d_[1].
+        1. Let _v_ be the cohort(_d_).
+        1. Let _q_ be the quantum(_d_).
         1. If _v_ is an integer and 0 ≤ _q_, return *true*.
         1. Return *false*.
       </emu-alg>
@@ -253,7 +254,7 @@ location: https://github.com/tc39/proposal-decimal/
       </dl>
       <emu-alg>
         1. If _d_ is *NaN*<sub>𝔻</sub>, *+∞*<sub>𝔻</sub>, or *-∞*<sub>𝔻</sub>, return _d_.
-        1. Let _v_ be _d_[0].
+        1. Let _v_ be the cohort(_d_).
         1. If _v_ is is *+0*<sub>𝔻</sub> or *-0*<sub>𝔻</sub>, return _d_.
         1. Let _e_ be the exponent of _v_.
         1. Let _s_ be the significand of _v_.
@@ -351,8 +352,8 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d_ is *NaN*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
       1. If _d_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
-      1. Let _v_ be _d_[0].
-      1. Let _q_ be _d_[1].
+      1. Let _v_ be the cohort(_d_).
+      1. Let _q_ be the quantum( _d_).
       1. Return Decimal128ValueToObject(« abs(_v_), _q_ »<sub>𝔻</sub>).
     </emu-alg>
     <emu-note>
@@ -371,8 +372,8 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d_ is *NaN*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
       1. If _d_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
-      1. Let _v_ be _d_[0].
-      1. Let _q_ be _d_[1].
+      1. Let _v_ be the cohort(_d_).
+      1. Let _q_ be the quantum(_d_).
       1. Return Decimal128ValueToObject(« -1 × _v_, _q_ »<sub>𝔻</sub>).
     </emu-alg>
     <emu-note>
@@ -399,7 +400,11 @@ location: https://github.com/tc39/proposal-decimal/
         1. If _d2_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
         1. If _d2_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
         1. Return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_d1_[0] + _d2_[0], min(_d1_[1], _d2_[1]), *"halfEven"*)).
+      1. Let _v1_ be the cohort(_d1_).
+      1. Let _v2_ be the cohort(_d2_).
+      1. Let _q1_ be the quantum(_d1_).
+      1. Let _q2_ be the quantum(_d2_).
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ + _v2_, min(_q1_, _q2_]), *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -425,7 +430,11 @@ location: https://github.com/tc39/proposal-decimal/
         1. If _d2_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
         1. If _d2_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
         1. Return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(d1[0] - d2[0], min(d1[1], d2[1]), *"halfEven"*)).
+      1. Let _v1_ be the cohort(_d1_).
+      1. Let _v2_ be the cohort(_d2_).
+      1. Let _q1_ be the quantum(_d1_).
+      1. Let _q2_ be the quantum(_d2_).
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ - _v2_, min(_q1_, _q2_), *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -452,9 +461,13 @@ location: https://github.com/tc39/proposal-decimal/
         1. If _d2_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
         1. If _d2_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
         1. If _d2_ is a zero Decimal128 value, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
-        1. If _d2_[0] < 0, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
+        1. Let _v2_ be the cohort(_d2_).
+        1. If _v2_ < 0, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
         1. Return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value (_d1_[0] × _d2_[0], _d1_[1] + _d2_[1], *"halfEven"*)).
+      1. Let _v1_ be the cohort(_d1_).
+      1. Let _q1_ be the quantum(_d1_).
+      1. Let _q2_ be the quantum(_d2_).
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value (_v1_ × _v2, _q1_ + _q2_], *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -474,7 +487,11 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d1_ or _d2_ is *NaN*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d1_ is *+∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d2_ is *-∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_d1_[0] / _d2_[0], _d1_[1] + _d2_[1], *"halfEven"*)).
+      1. Let _v1_ be the cohort(_d1_).
+      1. Let _v2_ be the cohort(_d2_).
+      1. Let _q1_ be the quantum(_d1_).
+      1. Let _q2_ be the quantum(_d2_).
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ / _v2_, _q1_ + _q2_, *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -494,7 +511,11 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d1_ or _d2_ is *NaN*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d1_ is *+∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d1_ is *-∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_d1_[0] % _d2_[0], _d1_[1] + _d2_[1], *"halfEven"*)).
+      1. Let _v1_ be the cohort(_d1_).
+      1. Let _v2_ be the cohort(_d2_).
+      1. Let _q1_ be the quantum(_d1_).
+      1. Let _q2_ be the quantum(_d2_).
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ % _v2_, _q1_ + _q2_, *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>The remainder operation specified here deviates from the <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref> remainder operation (defined there in Section 5.3.1). We follow the <emu-xref href="#sec-numeric-types-number-remainder">the remainder operation for Number</emu-xref> rather than IEEE 754, which specifies that, for example, the remainder 46 and 10 is -4 rather than 6.</p>
@@ -608,8 +629,8 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d_ is *NaN*<sub>𝔻</sub>, return _O_.
       1. If _d_ is *+∞*<sub>𝔻</sub>, return _O_.
       1. If _d_ is *-∞*<sub>𝔻</sub>, return _O_.
-      1. Let _v_ be _d_[0].
-      1. Let _q_ be _d_[1].
+      1. Let _v_ be the cohort(_d_).
+      1. Let _q_ be the quantum(_d_).
       1. If _v_ is *+0*<sub>𝔻</sub>, return _O_.
       1. If _v_ is *-0*<sub>𝔻</sub>, return _O_.
       1. Let _n_ be the integer such that v × 10<sup>-_q_</sup> = _n_ and 0 < abs(_n_) < 10<sup>34</sup>.
@@ -706,8 +727,8 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d_ is *NaN*<sub>𝔻</sub>, return *"NaN"*.
       1. If _d_ is *+∞*<sub>𝔻</sub>, return *"Infinity"*.
       1. If _d_ is *-∞*<sub>𝔻</sub>, return *"-Infinity"*.
-      1. Let _v_ be _d_[0].
-      1. Let _q_ be _d_[1].
+      1. Let _v_ be the cohort(_d_).
+      1. Let _q_ be the quantum(_d_).
       1. If _v_ is *+0*<sub>𝔻</sub>, return *"0"*.
       1. If _v_ is *-0*<sub>𝔻</sub>, return *"-0"*.
       1. If -_q_ < _precision_, then