diff --git a/index.html b/index.html
index 7f93652..2c9a2f3 100644
--- a/index.html
+++ b/index.html
@@ -1559,7 +1559,7 @@
 });
 
 let sdoMap = JSON.parse(`{}`);
-let biblio = JSON.parse(`{"refsByClause":{"sec-decimal128.prototype.exponent":["_ref_0","_ref_84","_ref_85","_ref_86"],"sec-decimal128.prototype.mantissa":["_ref_1","_ref_87","_ref_88","_ref_89","_ref_90","_ref_91","_ref_92","_ref_93","_ref_94","_ref_95","_ref_96"],"sec-decimal-method-round":["_ref_2","_ref_3","_ref_196","_ref_197","_ref_198","_ref_199","_ref_200","_ref_201"],"sec-decimal128.prototype.tolocalestring":["_ref_4"],"sec-decimal128.prototype.tofixed":["_ref_5","_ref_217","_ref_218"],"sec-decimal128.prototype.toprecision":["_ref_6","_ref_219","_ref_220","_ref_221"],"sup-decimal128.prototype.tolocalestring":["_ref_7"],"sec-decimal-intro":["_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","_ref_50","_ref_51","_ref_52","_ref_53","_ref_54"],"sec-decimal128-roundtodecimal128domain":["_ref_55","_ref_56","_ref_57","_ref_58","_ref_59","_ref_60","_ref_61"],"sec-decimal128-applyroundingmodetopositive":["_ref_62","_ref_63","_ref_64"],"sec-decimal128-decimal128todecimalstring":["_ref_65","_ref_66","_ref_67"],"sec-decimal128toexponentialstring":["_ref_68","_ref_69"],"sec-decimal128-value-to-object":["_ref_70"],"sec-the-decimal128-constructor-value":["_ref_71"],"sec-runtime-semantics-stringdecimalvalue":["_ref_72","_ref_73","_ref_74","_ref_75","_ref_76","_ref_77","_ref_78","_ref_79","_ref_80","_ref_81","_ref_82","_ref_83"],"sec-decimal128.prototype.abs":["_ref_97","_ref_98"],"sec-decimal128.prototype.negate":["_ref_99","_ref_100","_ref_101"],"sec-decimal128.prototype.add":["_ref_102","_ref_103","_ref_104","_ref_105","_ref_106","_ref_107","_ref_108","_ref_109"],"sec-decimal128.prototype.subtract":["_ref_110","_ref_111","_ref_112","_ref_113","_ref_114","_ref_115","_ref_116","_ref_117"],"sec-decimal128.prototype.multiply":["_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","_ref_131","_ref_132","_ref_133","_ref_134","_ref_135","_ref_136","_ref_137","_ref_138","_ref_139","_ref_140"],"sec-decimal128.prototype.divide":["_ref_141","_ref_142","_ref_143","_ref_144","_ref_145","_ref_146","_ref_147","_ref_148","_ref_149","_ref_150","_ref_151","_ref_152","_ref_153","_ref_154","_ref_155","_ref_156","_ref_157","_ref_158","_ref_159","_ref_160","_ref_161","_ref_162","_ref_163","_ref_164","_ref_165","_ref_166","_ref_167"],"sec-decimal128.prototype.remainder":["_ref_168","_ref_169","_ref_170","_ref_171","_ref_172","_ref_173","_ref_174"],"sec-decimal128.prototype.compare":["_ref_175","_ref_176","_ref_177","_ref_178"],"sec-decimal128.prototype.equals":["_ref_179","_ref_180","_ref_181"],"sec-decimal128.prototype.notequals":["_ref_182","_ref_183","_ref_184"],"sec-decimal128.prototype.lessthan":["_ref_185","_ref_186","_ref_187"],"sec-decimal128.prototype.lessthanorequal":["_ref_188","_ref_189","_ref_190"],"sec-decimal128.prototype.greaterthan":["_ref_191","_ref_192","_ref_193"],"sec-decimal128.prototype.greaterthanorequal":["_ref_194","_ref_195"],"sec-decimal-method-scale10":["_ref_202","_ref_203","_ref_204","_ref_205","_ref_206","_ref_207","_ref_208","_ref_209","_ref_210","_ref_211","_ref_212","_ref_213"],"sec-decimal128.prototype.tostring":["_ref_214","_ref_215"],"sec-decimal128.prototype.toexponential":["_ref_216"],"sec-number-constructor-number-value":["_ref_222"],"sec-bigint-constructor-number-value":["_ref_223"],"sec-tointlmathematicalvalue":["_ref_224","_ref_225","_ref_226","_ref_227"],"sec-resolvepluralrange":["_ref_228","_ref_229"]},"entries":[{"type":"clause","id":"sec-decimal-intro-","titleHTML":"Introduction","number":""},{"type":"term","term":"finite","id":"dfn-decimal128-finite","referencingIds":["_ref_12","_ref_15","_ref_27","_ref_32","_ref_35","_ref_38","_ref_40","_ref_43","_ref_51","_ref_54","_ref_73"]},{"type":"term","term":"zero","id":"dfn-decimal128-zero","referencingIds":["_ref_8","_ref_9","_ref_13","_ref_20","_ref_21","_ref_28","_ref_33","_ref_36","_ref_39","_ref_41","_ref_44","_ref_49","_ref_52","_ref_53","_ref_85","_ref_88","_ref_89","_ref_119","_ref_125"]},{"type":"term","term":"mathematical value","id":"decimal128-mathematical-value","referencingIds":["_ref_10","_ref_11","_ref_14","_ref_29","_ref_55","_ref_57","_ref_58","_ref_60","_ref_62","_ref_64","_ref_84","_ref_86","_ref_87","_ref_95","_ref_179","_ref_182","_ref_185","_ref_188","_ref_191","_ref_225","_ref_226","_ref_227"]},{"type":"op","aoid":"MV","id":"dfn-decimal128-mv","referencingIds":["_ref_16","_ref_17","_ref_18","_ref_74","_ref_75","_ref_76","_ref_78","_ref_79","_ref_81","_ref_82","_ref_175","_ref_176","_ref_177","_ref_178","_ref_180","_ref_181","_ref_183","_ref_184","_ref_186","_ref_187","_ref_189","_ref_190","_ref_192","_ref_193","_ref_194","_ref_195"]},{"type":"term","term":"Decimal128 rounding mode","id":"dfn-decimal128-rounding-mode","referencingIds":["_ref_5","_ref_19","_ref_56","_ref_63"]},{"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-2019 rounding modes"},{"type":"op","aoid":"sign","id":"dfn-decimal128-sign","referencingIds":["_ref_22","_ref_23","_ref_24","_ref_25","_ref_26","_ref_65","_ref_68","_ref_99","_ref_121","_ref_122","_ref_127","_ref_128","_ref_131","_ref_132","_ref_135","_ref_136","_ref_143","_ref_147","_ref_150","_ref_153","_ref_198","_ref_217","_ref_220"]},{"type":"term","term":"exponent","id":"dfn-decimal128-exponent","referencingIds":["_ref_0","_ref_30","_ref_37","_ref_42","_ref_45","_ref_48","_ref_221"]},{"type":"term","term":"significand","id":"dfn-decimal128-significand","referencingIds":["_ref_1","_ref_31","_ref_34"]},{"type":"term","term":"normalized","id":"dfn-decimal128-normalized","referencingIds":["_ref_46","_ref_47"]},{"type":"term","term":"denormalized","id":"dfn-decimal128-denormalized-","referencingIds":["_ref_50"]},{"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_94"]},{"type":"op","aoid":"ApplyRoundingModeToPositive","refId":"sec-decimal128-applyroundingmodetopositive"},{"type":"clause","id":"sec-decimal128-applyroundingmodetopositive","title":"ApplyRoundingModeToPositive ( m, roundingMode )","titleHTML":"ApplyRoundingModeToPositive ( <var>m</var>, <var>roundingMode</var> )","number":"1.1.1.1","referencingIds":["_ref_61","_ref_199","_ref_218"]},{"type":"op","aoid":"RoundToDecimal128Domain","refId":"sec-decimal128-roundtodecimal128domain"},{"type":"clause","id":"sec-decimal128-roundtodecimal128domain","title":"RoundToDecimal128Domain ( v [ , roundingMode ] )","titleHTML":"RoundToDecimal128Domain ( <var>v</var> [ , <var>roundingMode</var> ] )","number":"1.1.1","referencingIds":["_ref_59","_ref_77","_ref_80","_ref_83","_ref_109","_ref_117","_ref_140","_ref_167","_ref_201","_ref_213"]},{"type":"op","aoid":"Decimal128Abs","refId":"sec-decimal128-abs"},{"type":"clause","id":"sec-decimal128-abs","title":"Decimal128Abs ( argument )","titleHTML":"Decimal128Abs ( <var>argument</var> )","number":"1.1.2","referencingIds":["_ref_66","_ref_69","_ref_98"]},{"type":"op","aoid":"Decimal128Negate","refId":"sec-decimal128-negate"},{"type":"clause","id":"sec-decimal128-negate","title":"Decimal128Negate ( argument )","titleHTML":"Decimal128Negate ( <var>argument</var> )","number":"1.1.3","referencingIds":["_ref_101"]},{"type":"op","aoid":"CanonicalizeDecimalString","refId":"sec-decimal128-canonicalizedecimalstring"},{"type":"clause","id":"sec-decimal128-canonicalizedecimalstring","title":"CanonicalizeDecimalString ( digits )","titleHTML":"CanonicalizeDecimalString ( <var>digits</var> )","number":"1.1.4","referencingIds":["_ref_67"]},{"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.5","referencingIds":["_ref_215","_ref_219"]},{"type":"op","aoid":"Decimal128ToExponentialString","refId":"sec-decimal128toexponentialstring"},{"type":"clause","id":"sec-decimal128toexponentialstring","title":"Decimal128ToExponentialString ( argument )","titleHTML":"Decimal128ToExponentialString ( <var>argument</var> )","number":"1.1.6","referencingIds":["_ref_214","_ref_216","_ref_222"]},{"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.7","referencingIds":["_ref_90","_ref_91","_ref_92","_ref_93","_ref_96","_ref_97","_ref_100","_ref_102","_ref_103","_ref_104","_ref_105","_ref_106","_ref_107","_ref_108","_ref_110","_ref_111","_ref_112","_ref_113","_ref_114","_ref_115","_ref_116","_ref_118","_ref_120","_ref_123","_ref_124","_ref_126","_ref_129","_ref_130","_ref_133","_ref_134","_ref_137","_ref_138","_ref_139","_ref_141","_ref_142","_ref_144","_ref_145","_ref_146","_ref_148","_ref_149","_ref_151","_ref_152","_ref_154","_ref_155","_ref_156","_ref_157","_ref_158","_ref_159","_ref_160","_ref_161","_ref_162","_ref_163","_ref_164","_ref_165","_ref_166","_ref_168","_ref_169","_ref_170","_ref_171","_ref_172","_ref_173","_ref_174","_ref_196","_ref_197","_ref_200","_ref_202","_ref_203","_ref_204","_ref_205","_ref_206","_ref_207","_ref_208","_ref_209","_ref_210","_ref_211","_ref_212"]},{"type":"clause","id":"sec-decimal-abstract-ops","titleHTML":"Abstract Operations","number":"1.1"},{"type":"term","term":"%Decimal128%","refId":"sec-the-decimal-constructor"},{"type":"op","aoid":"StringDecimalValue","refId":"sec-runtime-semantics-stringdecimalvalue"},{"type":"clause","id":"sec-runtime-semantics-stringdecimalvalue","titleHTML":"Runtime Semantics: StringDecimalValue","number":"1.2.1.1","referencingIds":["_ref_71","_ref_72"]},{"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_70"]},{"type":"clause","id":"sec-the-decimal-object","titleHTML":"The Decimal128 Object","number":"1"},{"type":"clause","id":"sec-decimal128.prototype.isnan","titleHTML":"Decimal128.prototype.isNaN ( )","number":"2.1"},{"type":"clause","id":"sec-decimal128.prototype.isfinite","titleHTML":"Decimal128.prototype.isFinite ( )","number":"2.2"},{"type":"clause","id":"sec-decimal128.prototype.exponent","titleHTML":"Decimal128.prototype.exponent ( )","number":"2.3"},{"type":"clause","id":"sec-decimal128.prototype.mantissa","titleHTML":"Decimal128.prototype.mantissa ( )","number":"2.4"},{"type":"clause","id":"sec-decimal128.prototype.abs","titleHTML":"Decimal128.prototype.abs ( )","number":"2.5"},{"type":"clause","id":"sec-decimal128.prototype.negate","titleHTML":"Decimal128.prototype.negate ( )","number":"2.6"},{"type":"clause","id":"sec-decimal128.prototype.add","title":"Decimal128.prototype.add ( x )","titleHTML":"Decimal128.prototype.add ( <var>x</var> )","number":"2.7"},{"type":"clause","id":"sec-decimal128.prototype.subtract","title":"Decimal128.prototype.subtract ( x )","titleHTML":"Decimal128.prototype.subtract ( <var>x</var> )","number":"2.8"},{"type":"clause","id":"sec-decimal128.prototype.multiply","title":"Decimal128.prototype.multiply ( x )","titleHTML":"Decimal128.prototype.multiply ( <var>x</var> )","number":"2.9"},{"type":"clause","id":"sec-decimal128.prototype.divide","title":"Decimal128.prototype.divide ( x )","titleHTML":"Decimal128.prototype.divide ( <var>x</var> )","number":"2.10"},{"type":"clause","id":"sec-decimal128.prototype.remainder","title":"Decimal128.prototype.remainder ( x )","titleHTML":"Decimal128.prototype.remainder ( <var>x</var> )","number":"2.11"},{"type":"clause","id":"sec-decimal128.prototype.compare","title":"Decimal128.prototype.compare ( x )","titleHTML":"Decimal128.prototype.compare ( <var>x</var> )","number":"2.12"},{"type":"clause","id":"sec-decimal128.prototype.equals","title":"Decimal128.prototype.equals ( x )","titleHTML":"Decimal128.prototype.equals ( <var>x</var> )","number":"2.13"},{"type":"clause","id":"sec-decimal128.prototype.notequals","title":"Decimal128.prototype.notEquals ( x )","titleHTML":"Decimal128.prototype.notEquals ( <var>x</var> )","number":"2.14"},{"type":"clause","id":"sec-decimal128.prototype.lessthan","title":"Decimal128.prototype.lessThan ( x )","titleHTML":"Decimal128.prototype.lessThan ( <var>x</var> )","number":"2.15"},{"type":"clause","id":"sec-decimal128.prototype.lessthanorequal","title":"Decimal128.prototype.lessThanOrEqual ( x )","titleHTML":"Decimal128.prototype.lessThanOrEqual ( <var>x</var> )","number":"2.16"},{"type":"clause","id":"sec-decimal128.prototype.greaterthan","title":"Decimal128.prototype.greaterThan ( x )","titleHTML":"Decimal128.prototype.greaterThan ( <var>x</var> )","number":"2.17"},{"type":"clause","id":"sec-decimal128.prototype.greaterthanorequal","title":"Decimal128.prototype.greaterThanOrEqual ( x )","titleHTML":"Decimal128.prototype.greaterThanOrEqual ( <var>x</var> )","number":"2.18"},{"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.19"},{"type":"clause","id":"sec-decimal-method-scale10","title":"Decimal128.prototype.scale10 ( n )","titleHTML":"Decimal128.prototype.scale10 ( <var>n</var> )","number":"2.20"},{"type":"clause","id":"sec-decimal128.prototype.tostring","title":"Decimal128.prototype.toString ( [ options ] )","titleHTML":"Decimal128.prototype.toString ( [ <var>options</var> ] )","number":"2.21","referencingIds":["_ref_4","_ref_6"]},{"type":"clause","id":"sec-decimal128.prototype.tolocalestring","title":"Decimal128.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )","titleHTML":"Decimal128.prototype.toLocaleString ( [ <var>reserved1</var> [ , <var>reserved2</var> ] ] )","number":"2.22","referencingIds":["_ref_7"]},{"type":"clause","id":"sec-decimal128.prototype.toexponential","title":"Decimal128.prototype.toExponential ( [ options ] )","titleHTML":"Decimal128.prototype.toExponential ( [ <var>options</var> ] )","number":"2.23"},{"type":"clause","id":"sec-decimal128.prototype.tofixed","title":"Decimal128.prototype.toFixed ( [ options ] )","titleHTML":"Decimal128.prototype.toFixed ( [ <var>options</var> ] )","number":"2.24"},{"type":"clause","id":"sec-decimal128.prototype.tojson","titleHTML":"Decimal128.prototype.toJSON ( )","number":"2.25"},{"type":"clause","id":"sec-decimal128.prototype.toprecision","title":"Decimal128.prototype.toPrecision ( [ options ] )","titleHTML":"Decimal128.prototype.toPrecision ( [ <var>options</var> ] )","number":"2.26"},{"type":"clause","id":"sec-decimal128.prototype.valueof","title":"Decimal128.prototype.valueOf ( x )","titleHTML":"Decimal128.prototype.valueOf ( <var>x</var> )","number":"2.27"},{"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_223"]},{"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":"sup-decimal128.prototype.tolocalestring","title":"Decimal128.prototype.toLocaleString ( [ locales [ , options ] ] )","titleHTML":"Decimal128.prototype.toLocaleString ( [ <var>locales</var> [ , <var>options</var> ] ] )","number":"4.1.1"},{"type":"clause","id":"sup-properties-of-the-decimal128-prototype-object","titleHTML":"Properties of the Decimal128 Prototype Object","number":"4.1"},{"type":"term","term":"Intl mathematical value","id":"intl-mathematical-value","referencingIds":["_ref_224"]},{"type":"op","aoid":"ToIntlMathematicalValue","refId":"sec-tointlmathematicalvalue"},{"type":"clause","id":"sec-tointlmathematicalvalue","title":"ToIntlMathematicalValue ( value )","titleHTML":"ToIntlMathematicalValue ( <var>value</var> )","number":"4.2.1.1"},{"type":"clause","id":"sec-numberformat-abstracts","titleHTML":"Abstract Operations for NumberFormat Objects","number":"4.2.1"},{"type":"clause","id":"numberformat-objects","titleHTML":"NumberFormat Objects","number":"4.2"},{"type":"op","aoid":"ResolvePlural","refId":"sec-resolveplural"},{"type":"clause","id":"sec-resolveplural","title":"ResolvePlural ( pluralRules, n )","titleHTML":"ResolvePlural ( <var>pluralRules</var>, <var>n</var> )","number":"4.3.1.1","referencingIds":["_ref_228","_ref_229"]},{"type":"op","aoid":"ResolvePluralRange","refId":"sec-resolvepluralrange"},{"type":"clause","id":"sec-resolvepluralrange","title":"ResolvePluralRange ( pluralRules, x, y )","titleHTML":"ResolvePluralRange ( <var>pluralRules</var>, <var>x</var>, <var>y</var> )","number":"4.3.1.2"},{"type":"clause","id":"sec-intl-pluralrules-abstracts","titleHTML":"Abstract Operations for PluralRules Objects","number":"4.3.1"},{"type":"clause","id":"pluralrules-objects","titleHTML":"PluralRules Objects","number":"4.3"},{"type":"clause","id":"sec-decimal-intl","titleHTML":"Amendments to the ECMAScript® 2024 Internationalization API Specification","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-decimal128.prototype.exponent":["_ref_0","_ref_112","_ref_113","_ref_114"],"sec-decimal128.prototype.mantissa":["_ref_1","_ref_115","_ref_116","_ref_117","_ref_118","_ref_119","_ref_120","_ref_121","_ref_122","_ref_123","_ref_124"],"sec-decimal-method-round":["_ref_2","_ref_3","_ref_226","_ref_227","_ref_228","_ref_229","_ref_230","_ref_231"],"sec-decimal128.prototype.tolocalestring":["_ref_4"],"sec-decimal128.prototype.tofixed":["_ref_5","_ref_244","_ref_245","_ref_246","_ref_247"],"sec-decimal128.prototype.toprecision":["_ref_6","_ref_248","_ref_249","_ref_250","_ref_251","_ref_252"],"sup-decimal128.prototype.tolocalestring":["_ref_7"],"sec-decimal-intro":["_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","_ref_50","_ref_51","_ref_52","_ref_53","_ref_54","_ref_55","_ref_56","_ref_57","_ref_58","_ref_59","_ref_60","_ref_61","_ref_62","_ref_63","_ref_64","_ref_65","_ref_66","_ref_67","_ref_68","_ref_69","_ref_70"],"sec-decimal128-roundtodecimal128domain":["_ref_71","_ref_72","_ref_73","_ref_74","_ref_75","_ref_76","_ref_77"],"sec-decimal128-applyroundingmodetopositive":["_ref_78","_ref_79","_ref_80"],"sec-decimal128-abs":["_ref_81","_ref_82","_ref_83"],"sec-decimal128-negate":["_ref_84","_ref_85","_ref_86"],"sec-decimal128-decimal128todecimalstring":["_ref_87","_ref_88","_ref_89","_ref_90"],"sec-decimal128toexponentialstring":["_ref_91","_ref_92","_ref_93","_ref_94"],"sec-decimal128-value-to-object":["_ref_95","_ref_96","_ref_97"],"sec-the-decimal128-constructor-value":["_ref_98"],"sec-runtime-semantics-stringdecimalvalue":["_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-decimal128.prototype.abs":["_ref_125","_ref_126"],"sec-decimal128.prototype.negate":["_ref_127","_ref_128","_ref_129"],"sec-decimal128.prototype.add":["_ref_130","_ref_131","_ref_132","_ref_133","_ref_134","_ref_135","_ref_136","_ref_137"],"sec-decimal128.prototype.subtract":["_ref_138","_ref_139","_ref_140","_ref_141","_ref_142","_ref_143","_ref_144","_ref_145"],"sec-decimal128.prototype.multiply":["_ref_146","_ref_147","_ref_148","_ref_149","_ref_150","_ref_151","_ref_152","_ref_153","_ref_154","_ref_155","_ref_156","_ref_157","_ref_158","_ref_159","_ref_160","_ref_161","_ref_162","_ref_163","_ref_164","_ref_165","_ref_166","_ref_167","_ref_168","_ref_169","_ref_170"],"sec-decimal128.prototype.divide":["_ref_171","_ref_172","_ref_173","_ref_174","_ref_175","_ref_176","_ref_177","_ref_178","_ref_179","_ref_180","_ref_181","_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","_ref_195","_ref_196","_ref_197"],"sec-decimal128.prototype.remainder":["_ref_198","_ref_199","_ref_200","_ref_201","_ref_202","_ref_203","_ref_204"],"sec-decimal128.prototype.compare":["_ref_205","_ref_206","_ref_207","_ref_208"],"sec-decimal128.prototype.equals":["_ref_209","_ref_210","_ref_211"],"sec-decimal128.prototype.notequals":["_ref_212","_ref_213","_ref_214"],"sec-decimal128.prototype.lessthan":["_ref_215","_ref_216","_ref_217"],"sec-decimal128.prototype.lessthanorequal":["_ref_218","_ref_219","_ref_220"],"sec-decimal128.prototype.greaterthan":["_ref_221","_ref_222","_ref_223"],"sec-decimal128.prototype.greaterthanorequal":["_ref_224","_ref_225"],"sec-decimal-method-scale10":["_ref_232","_ref_233","_ref_234","_ref_235","_ref_236","_ref_237","_ref_238","_ref_239","_ref_240"],"sec-decimal128.prototype.tostring":["_ref_241","_ref_242"],"sec-decimal128.prototype.toexponential":["_ref_243"],"sec-number-constructor-number-value":["_ref_253"],"sec-bigint-constructor-number-value":["_ref_254"],"sec-tointlmathematicalvalue":["_ref_255","_ref_256","_ref_257","_ref_258"],"sec-resolvepluralrange":["_ref_259","_ref_260"]},"entries":[{"type":"clause","id":"sec-decimal-intro-","titleHTML":"Introduction","number":""},{"type":"term","term":"Decimal128 value","id":"def-decimal128-value","referencingIds":["_ref_11","_ref_12","_ref_14","_ref_17","_ref_20","_ref_24","_ref_28","_ref_36","_ref_45","_ref_51","_ref_55","_ref_59","_ref_64","_ref_66","_ref_68","_ref_70","_ref_81","_ref_82","_ref_83","_ref_84","_ref_85","_ref_86","_ref_87","_ref_91","_ref_95","_ref_96","_ref_99","_ref_115","_ref_148","_ref_155"]},{"type":"term","term":"finite","id":"dfn-decimal128-finite","referencingIds":["_ref_15","_ref_19","_ref_34","_ref_40","_ref_43","_ref_47","_ref_49","_ref_53","_ref_63","_ref_69","_ref_101"]},{"type":"term","term":"zero","id":"dfn-decimal128-zero","referencingIds":["_ref_8","_ref_9","_ref_16","_ref_26","_ref_27","_ref_35","_ref_41","_ref_44","_ref_48","_ref_50","_ref_54","_ref_61","_ref_65","_ref_67","_ref_113","_ref_117","_ref_118","_ref_147","_ref_154"]},{"type":"term","term":"mathematical value","id":"decimal128-mathematical-value","referencingIds":["_ref_10","_ref_13","_ref_18","_ref_37","_ref_71","_ref_73","_ref_74","_ref_76","_ref_78","_ref_80","_ref_112","_ref_114","_ref_116","_ref_123","_ref_209","_ref_212","_ref_215","_ref_218","_ref_221","_ref_256","_ref_257","_ref_258"]},{"type":"op","aoid":"MV","id":"dfn-decimal128-mv","referencingIds":["_ref_21","_ref_22","_ref_23","_ref_102","_ref_103","_ref_104","_ref_106","_ref_107","_ref_109","_ref_110","_ref_205","_ref_206","_ref_207","_ref_208","_ref_210","_ref_211","_ref_213","_ref_214","_ref_216","_ref_217","_ref_219","_ref_220","_ref_222","_ref_223","_ref_224","_ref_225"]},{"type":"term","term":"Decimal128 rounding mode","id":"dfn-decimal128-rounding-mode","referencingIds":["_ref_5","_ref_25","_ref_72","_ref_79"]},{"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-2019 rounding modes"},{"type":"op","aoid":"sign","id":"dfn-decimal128-sign","referencingIds":["_ref_29","_ref_30","_ref_31","_ref_32","_ref_33","_ref_88","_ref_92","_ref_127","_ref_150","_ref_151","_ref_157","_ref_158","_ref_161","_ref_162","_ref_165","_ref_166","_ref_173","_ref_177","_ref_180","_ref_183","_ref_228","_ref_244","_ref_249"]},{"type":"term","term":"exponent","id":"dfn-decimal128-exponent","referencingIds":["_ref_0","_ref_38","_ref_46","_ref_52","_ref_56","_ref_60"]},{"type":"term","term":"significand","id":"dfn-decimal128-significand","referencingIds":["_ref_1","_ref_39","_ref_42"]},{"type":"term","term":"normalized","id":"dfn-decimal128-normalized","referencingIds":["_ref_57","_ref_58"]},{"type":"term","term":"denormalized","id":"dfn-decimal128-denormalized-","referencingIds":["_ref_62"]},{"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":""},{"type":"op","aoid":"ApplyRoundingModeToPositive","refId":"sec-decimal128-applyroundingmodetopositive"},{"type":"clause","id":"sec-decimal128-applyroundingmodetopositive","title":"ApplyRoundingModeToPositive ( m, roundingMode )","titleHTML":"ApplyRoundingModeToPositive ( <var>m</var>, <var>roundingMode</var> )","number":"1.1.1.1","referencingIds":["_ref_77","_ref_229","_ref_245","_ref_251"]},{"type":"op","aoid":"RoundToDecimal128Domain","refId":"sec-decimal128-roundtodecimal128domain"},{"type":"clause","id":"sec-decimal128-roundtodecimal128domain","title":"RoundToDecimal128Domain ( v [ , roundingMode ] )","titleHTML":"RoundToDecimal128Domain ( <var>v</var> [ , <var>roundingMode</var> ] )","number":"1.1.1","referencingIds":["_ref_75","_ref_105","_ref_108","_ref_111","_ref_137","_ref_145","_ref_170","_ref_197","_ref_231","_ref_240"]},{"type":"op","aoid":"Decimal128Abs","refId":"sec-decimal128-abs"},{"type":"clause","id":"sec-decimal128-abs","title":"Decimal128Abs ( argument )","titleHTML":"Decimal128Abs ( <var>argument</var> )","number":"1.1.2","referencingIds":["_ref_89","_ref_93","_ref_126"]},{"type":"op","aoid":"Decimal128Negate","refId":"sec-decimal128-negate"},{"type":"clause","id":"sec-decimal128-negate","title":"Decimal128Negate ( argument )","titleHTML":"Decimal128Negate ( <var>argument</var> )","number":"1.1.3","referencingIds":["_ref_129"]},{"type":"op","aoid":"CanonicalizeDecimalString","refId":"sec-decimal128-canonicalizedecimalstring"},{"type":"clause","id":"sec-decimal128-canonicalizedecimalstring","title":"CanonicalizeDecimalString ( digits )","titleHTML":"CanonicalizeDecimalString ( <var>digits</var> )","number":"1.1.4","referencingIds":["_ref_90","_ref_247"]},{"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.5","referencingIds":["_ref_94","_ref_242","_ref_246","_ref_248","_ref_250","_ref_252"]},{"type":"op","aoid":"Decimal128ToExponentialString","refId":"sec-decimal128toexponentialstring"},{"type":"clause","id":"sec-decimal128toexponentialstring","title":"Decimal128ToExponentialString ( argument )","titleHTML":"Decimal128ToExponentialString ( <var>argument</var> )","number":"1.1.6","referencingIds":["_ref_241","_ref_243","_ref_253"]},{"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.7","referencingIds":["_ref_119","_ref_120","_ref_121","_ref_122","_ref_124","_ref_125","_ref_128","_ref_130","_ref_131","_ref_132","_ref_133","_ref_134","_ref_135","_ref_136","_ref_138","_ref_139","_ref_140","_ref_141","_ref_142","_ref_143","_ref_144","_ref_146","_ref_149","_ref_152","_ref_153","_ref_156","_ref_159","_ref_160","_ref_163","_ref_164","_ref_167","_ref_168","_ref_169","_ref_171","_ref_172","_ref_174","_ref_175","_ref_176","_ref_178","_ref_179","_ref_181","_ref_182","_ref_184","_ref_185","_ref_186","_ref_187","_ref_188","_ref_189","_ref_190","_ref_191","_ref_192","_ref_193","_ref_194","_ref_195","_ref_196","_ref_198","_ref_199","_ref_200","_ref_201","_ref_202","_ref_203","_ref_204","_ref_226","_ref_227","_ref_230","_ref_232","_ref_233","_ref_234","_ref_235","_ref_236","_ref_237","_ref_238","_ref_239"]},{"type":"clause","id":"sec-decimal-abstract-ops","titleHTML":"Abstract Operations","number":"1.1"},{"type":"term","term":"%Decimal128%","refId":"sec-the-decimal-constructor"},{"type":"op","aoid":"StringDecimalValue","refId":"sec-runtime-semantics-stringdecimalvalue"},{"type":"clause","id":"sec-runtime-semantics-stringdecimalvalue","titleHTML":"Runtime Semantics: StringDecimalValue","number":"1.2.1.1","referencingIds":["_ref_98","_ref_100"]},{"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_97"]},{"type":"clause","id":"sec-the-decimal-object","titleHTML":"The Decimal128 Object","number":"1"},{"type":"clause","id":"sec-decimal128.prototype.isnan","titleHTML":"Decimal128.prototype.isNaN ( )","number":"2.1"},{"type":"clause","id":"sec-decimal128.prototype.isfinite","titleHTML":"Decimal128.prototype.isFinite ( )","number":"2.2"},{"type":"clause","id":"sec-decimal128.prototype.exponent","titleHTML":"Decimal128.prototype.exponent ( )","number":"2.3"},{"type":"clause","id":"sec-decimal128.prototype.mantissa","titleHTML":"Decimal128.prototype.mantissa ( )","number":"2.4"},{"type":"clause","id":"sec-decimal128.prototype.abs","titleHTML":"Decimal128.prototype.abs ( )","number":"2.5"},{"type":"clause","id":"sec-decimal128.prototype.negate","titleHTML":"Decimal128.prototype.negate ( )","number":"2.6"},{"type":"clause","id":"sec-decimal128.prototype.add","title":"Decimal128.prototype.add ( x )","titleHTML":"Decimal128.prototype.add ( <var>x</var> )","number":"2.7"},{"type":"clause","id":"sec-decimal128.prototype.subtract","title":"Decimal128.prototype.subtract ( x )","titleHTML":"Decimal128.prototype.subtract ( <var>x</var> )","number":"2.8"},{"type":"clause","id":"sec-decimal128.prototype.multiply","title":"Decimal128.prototype.multiply ( x )","titleHTML":"Decimal128.prototype.multiply ( <var>x</var> )","number":"2.9"},{"type":"clause","id":"sec-decimal128.prototype.divide","title":"Decimal128.prototype.divide ( x )","titleHTML":"Decimal128.prototype.divide ( <var>x</var> )","number":"2.10"},{"type":"clause","id":"sec-decimal128.prototype.remainder","title":"Decimal128.prototype.remainder ( x )","titleHTML":"Decimal128.prototype.remainder ( <var>x</var> )","number":"2.11"},{"type":"clause","id":"sec-decimal128.prototype.compare","title":"Decimal128.prototype.compare ( x )","titleHTML":"Decimal128.prototype.compare ( <var>x</var> )","number":"2.12"},{"type":"clause","id":"sec-decimal128.prototype.equals","title":"Decimal128.prototype.equals ( x )","titleHTML":"Decimal128.prototype.equals ( <var>x</var> )","number":"2.13"},{"type":"clause","id":"sec-decimal128.prototype.notequals","title":"Decimal128.prototype.notEquals ( x )","titleHTML":"Decimal128.prototype.notEquals ( <var>x</var> )","number":"2.14"},{"type":"clause","id":"sec-decimal128.prototype.lessthan","title":"Decimal128.prototype.lessThan ( x )","titleHTML":"Decimal128.prototype.lessThan ( <var>x</var> )","number":"2.15"},{"type":"clause","id":"sec-decimal128.prototype.lessthanorequal","title":"Decimal128.prototype.lessThanOrEqual ( x )","titleHTML":"Decimal128.prototype.lessThanOrEqual ( <var>x</var> )","number":"2.16"},{"type":"clause","id":"sec-decimal128.prototype.greaterthan","title":"Decimal128.prototype.greaterThan ( x )","titleHTML":"Decimal128.prototype.greaterThan ( <var>x</var> )","number":"2.17"},{"type":"clause","id":"sec-decimal128.prototype.greaterthanorequal","title":"Decimal128.prototype.greaterThanOrEqual ( x )","titleHTML":"Decimal128.prototype.greaterThanOrEqual ( <var>x</var> )","number":"2.18"},{"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.19"},{"type":"clause","id":"sec-decimal-method-scale10","title":"Decimal128.prototype.scale10 ( n )","titleHTML":"Decimal128.prototype.scale10 ( <var>n</var> )","number":"2.20"},{"type":"clause","id":"sec-decimal128.prototype.tostring","title":"Decimal128.prototype.toString ( [ options ] )","titleHTML":"Decimal128.prototype.toString ( [ <var>options</var> ] )","number":"2.21","referencingIds":["_ref_4","_ref_6"]},{"type":"clause","id":"sec-decimal128.prototype.tolocalestring","title":"Decimal128.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )","titleHTML":"Decimal128.prototype.toLocaleString ( [ <var>reserved1</var> [ , <var>reserved2</var> ] ] )","number":"2.22","referencingIds":["_ref_7"]},{"type":"clause","id":"sec-decimal128.prototype.toexponential","title":"Decimal128.prototype.toExponential ( [ options ] )","titleHTML":"Decimal128.prototype.toExponential ( [ <var>options</var> ] )","number":"2.23"},{"type":"clause","id":"sec-decimal128.prototype.tofixed","title":"Decimal128.prototype.toFixed ( [ options ] )","titleHTML":"Decimal128.prototype.toFixed ( [ <var>options</var> ] )","number":"2.24"},{"type":"clause","id":"sec-decimal128.prototype.tojson","titleHTML":"Decimal128.prototype.toJSON ( )","number":"2.25"},{"type":"clause","id":"sec-decimal128.prototype.toprecision","title":"Decimal128.prototype.toPrecision ( [ options ] )","titleHTML":"Decimal128.prototype.toPrecision ( [ <var>options</var> ] )","number":"2.26"},{"type":"clause","id":"sec-decimal128.prototype.valueof","title":"Decimal128.prototype.valueOf ( x )","titleHTML":"Decimal128.prototype.valueOf ( <var>x</var> )","number":"2.27"},{"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_254"]},{"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":"sup-decimal128.prototype.tolocalestring","title":"Decimal128.prototype.toLocaleString ( [ locales [ , options ] ] )","titleHTML":"Decimal128.prototype.toLocaleString ( [ <var>locales</var> [ , <var>options</var> ] ] )","number":"4.1.1"},{"type":"clause","id":"sup-properties-of-the-decimal128-prototype-object","titleHTML":"Properties of the Decimal128 Prototype Object","number":"4.1"},{"type":"term","term":"Intl mathematical value","id":"intl-mathematical-value","referencingIds":["_ref_255"]},{"type":"op","aoid":"ToIntlMathematicalValue","refId":"sec-tointlmathematicalvalue"},{"type":"clause","id":"sec-tointlmathematicalvalue","title":"ToIntlMathematicalValue ( value )","titleHTML":"ToIntlMathematicalValue ( <var>value</var> )","number":"4.2.1.1"},{"type":"clause","id":"sec-numberformat-abstracts","titleHTML":"Abstract Operations for NumberFormat Objects","number":"4.2.1"},{"type":"clause","id":"numberformat-objects","titleHTML":"NumberFormat Objects","number":"4.2"},{"type":"op","aoid":"ResolvePlural","refId":"sec-resolveplural"},{"type":"clause","id":"sec-resolveplural","title":"ResolvePlural ( pluralRules, n )","titleHTML":"ResolvePlural ( <var>pluralRules</var>, <var>n</var> )","number":"4.3.1.1","referencingIds":["_ref_259","_ref_260"]},{"type":"op","aoid":"ResolvePluralRange","refId":"sec-resolvepluralrange"},{"type":"clause","id":"sec-resolvepluralrange","title":"ResolvePluralRange ( pluralRules, x, y )","titleHTML":"ResolvePluralRange ( <var>pluralRules</var>, <var>x</var>, <var>y</var> )","number":"4.3.1.2"},{"type":"clause","id":"sec-intl-pluralrules-abstracts","titleHTML":"Abstract Operations for PluralRules Objects","number":"4.3.1"},{"type":"clause","id":"pluralrules-objects","titleHTML":"PluralRules Objects","number":"4.3"},{"type":"clause","id":"sec-decimal-intl","titleHTML":"Amendments to the ECMAScript® 2024 Internationalization API Specification","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 */
@@ -3231,7 +3231,7 @@
 </ul></div><div id="menu-toggle"><svg xmlns="http://www.w3.org/2000/svg" style="width:100%; height:100%; stroke:currentColor" viewBox="0 0 120 120" width="54" height="54">
       <title>Menu</title>
       <path stroke-width="10" stroke-linecap="round" d="M30,60 h60  M30,30 m0,5 h60  M30,90 m0,-5 h60"></path>
-    </svg></div><div id="menu-spacer" class="menu-spacer"></div><div id="menu"><div id="menu-search"><input type="text" id="menu-search-box" placeholder="Search..."><div id="menu-search-results" class="inactive"></div></div><div id="menu-pins"><div class="menu-pane-header">Pins<button class="unpin-all">clear</button></div><ul id="menu-pins-list"></ul></div><div class="menu-pane-header">Table of Contents</div><div id="menu-toc"><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal-intro-" title="Introduction">Introduction</a></li><li><span class="item-toggle">+</span><a href="#sec-the-decimal-object" title="The Decimal128 Object"><span class="secnum">1</span> The Decimal128 Object</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal-intro" title="Introduction">Introduction</a></li><li><span class="item-toggle">+</span><a href="#sec-decimal-abstract-ops" title="Abstract Operations"><span class="secnum">1.1</span> Abstract Operations</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-decimal128-roundtodecimal128domain" title="RoundToDecimal128Domain ( v [ , roundingMode ] )"><span class="secnum">1.1.1</span> RoundToDecimal128Domain ( <var>v</var> [ , <var>roundingMode</var> ] )</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal128-applyroundingmodetopositive" title="ApplyRoundingModeToPositive ( m, roundingMode )"><span class="secnum">1.1.1.1</span> ApplyRoundingModeToPositive ( <var>m</var>, <var>roundingMode</var> )</a></li></ol></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-abs" title="Decimal128Abs ( argument )"><span class="secnum">1.1.2</span> Decimal128Abs ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-negate" title="Decimal128Negate ( argument )"><span class="secnum">1.1.3</span> Decimal128Negate ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-canonicalizedecimalstring" title="CanonicalizeDecimalString ( digits )"><span class="secnum">1.1.4</span> CanonicalizeDecimalString ( <var>digits</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-decimal128todecimalstring" title="Decimal128ToDecimalString ( argument )"><span class="secnum">1.1.5</span> Decimal128ToDecimalString ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128toexponentialstring" title="Decimal128ToExponentialString ( argument )"><span class="secnum">1.1.6</span> Decimal128ToExponentialString ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-value-to-object" title="Decimal128ValueToObject ( argument )"><span class="secnum">1.1.7</span> Decimal128ValueToObject ( <var>argument</var> )</a></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-the-decimal-constructor" title="The Decimal128 Constructor"><span class="secnum">1.2</span> The Decimal128 Constructor</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-the-decimal128-constructor-value" title="Decimal128 ( x )"><span class="secnum">1.2.1</span> Decimal128 ( <var>x</var> )</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-runtime-semantics-stringdecimalvalue" title="Runtime Semantics: StringDecimalValue"><span class="secnum">1.2.1.1</span> RS: StringDecimalValue</a></li></ol></li></ol></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-decimal-prototype-properties" title="Properties of the Decimal128 Prototype"><span class="secnum">2</span> Properties of the Decimal128 Prototype</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.isnan" title="Decimal128.prototype.isNaN ( )"><span class="secnum">2.1</span> Decimal128.prototype.isNaN ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.isfinite" title="Decimal128.prototype.isFinite ( )"><span class="secnum">2.2</span> Decimal128.prototype.isFinite ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.exponent" title="Decimal128.prototype.exponent ( )"><span class="secnum">2.3</span> Decimal128.prototype.exponent ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.mantissa" title="Decimal128.prototype.mantissa ( )"><span class="secnum">2.4</span> Decimal128.prototype.mantissa ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.abs" title="Decimal128.prototype.abs ( )"><span class="secnum">2.5</span> Decimal128.prototype.abs ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.negate" title="Decimal128.prototype.negate ( )"><span class="secnum">2.6</span> Decimal128.prototype.negate ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.add" title="Decimal128.prototype.add ( x )"><span class="secnum">2.7</span> Decimal128.prototype.add ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.subtract" title="Decimal128.prototype.subtract ( x )"><span class="secnum">2.8</span> Decimal128.prototype.subtract ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.multiply" title="Decimal128.prototype.multiply ( x )"><span class="secnum">2.9</span> Decimal128.prototype.multiply ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.divide" title="Decimal128.prototype.divide ( x )"><span class="secnum">2.10</span> Decimal128.prototype.divide ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.remainder" title="Decimal128.prototype.remainder ( x )"><span class="secnum">2.11</span> Decimal128.prototype.remainder ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.compare" title="Decimal128.prototype.compare ( x )"><span class="secnum">2.12</span> Decimal128.prototype.compare ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.equals" title="Decimal128.prototype.equals ( x )"><span class="secnum">2.13</span> Decimal128.prototype.equals ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.notequals" title="Decimal128.prototype.notEquals ( x )"><span class="secnum">2.14</span> Decimal128.prototype.notEquals ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.lessthan" title="Decimal128.prototype.lessThan ( x )"><span class="secnum">2.15</span> Decimal128.prototype.lessThan ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.lessthanorequal" title="Decimal128.prototype.lessThanOrEqual ( x )"><span class="secnum">2.16</span> Decimal128.prototype.lessThanOrEqual ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.greaterthan" title="Decimal128.prototype.greaterThan ( x )"><span class="secnum">2.17</span> Decimal128.prototype.greaterThan ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.greaterthanorequal" title="Decimal128.prototype.greaterThanOrEqual ( x )"><span class="secnum">2.18</span> Decimal128.prototype.greaterThanOrEqual ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal-method-round" title="Decimal128.prototype.round ( numFractionalDigits [ , roundingMode ] )"><span class="secnum">2.19</span> Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal-method-scale10" title="Decimal128.prototype.scale10 ( n )"><span class="secnum">2.20</span> Decimal128.prototype.scale10 ( <var>n</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.tostring" title="Decimal128.prototype.toString ( [ options ] )"><span class="secnum">2.21</span> Decimal128.prototype.toString ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.tolocalestring" title="Decimal128.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )"><span class="secnum">2.22</span> Decimal128.prototype.toLocaleString ( [ <var>reserved1</var> [ , <var>reserved2</var> ] ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.toexponential" title="Decimal128.prototype.toExponential ( [ options ] )"><span class="secnum">2.23</span> Decimal128.prototype.toExponential ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.tofixed" title="Decimal128.prototype.toFixed ( [ options ] )"><span class="secnum">2.24</span> Decimal128.prototype.toFixed ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.tojson" title="Decimal128.prototype.toJSON ( )"><span class="secnum">2.25</span> Decimal128.prototype.toJSON ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.toprecision" title="Decimal128.prototype.toPrecision ( [ options ] )"><span class="secnum">2.26</span> Decimal128.prototype.toPrecision ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.valueof" title="Decimal128.prototype.valueOf ( x )"><span class="secnum">2.27</span> Decimal128.prototype.valueOf ( <var>x</var> )</a></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-numbers-and-dates" title="Numbers and Dates"><span class="secnum">3</span> Numbers and Dates</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-number-objects" title="Number Objects"><span class="secnum">3.1</span> Number Objects</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-number-constructor" title="The Number Constructor"><span class="secnum">3.1.1</span> The Number Constructor</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-number-constructor-number-value" title="Number ( value )"><span class="secnum">3.1.1.1</span> Number ( <var>value</var> )</a></li></ol></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-bigint-objects" title="BigInt Objects"><span class="secnum">3.2</span> BigInt Objects</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-bigint-constructor" title="The BigInt Constructor"><span class="secnum">3.2.1</span> The BigInt Constructor</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-bigint-constructor-number-value" title="BigInt ( value )"><span class="secnum">3.2.1.1</span> BigInt ( <var>value</var> )</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-numbertobigint" title="Decimal128ToBigInt ( number )"><span class="secnum">3.2.1.1.1</span> <ins>Decimal128ToBigInt ( <var>number</var> )</ins></a></li></ol></li></ol></li></ol></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-decimal-intl" title="Amendments to the ECMAScript® 2024 Internationalization API Specification"><span class="secnum">4</span> Amendments to the ECMAScript® 2024 Internationalization API Specification</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sup-properties-of-the-decimal128-prototype-object" title="Properties of the Decimal128 Prototype Object"><span class="secnum">4.1</span> Properties of the Decimal128 Prototype Object</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sup-decimal128.prototype.tolocalestring" title="Decimal128.prototype.toLocaleString ( [ locales [ , options ] ] )"><span class="secnum">4.1.1</span> Decimal128.prototype.toLocaleString ( [ <var>locales</var> [ , <var>options</var> ] ] )</a></li></ol></li><li><span class="item-toggle">+</span><a href="#numberformat-objects" title="NumberFormat Objects"><span class="secnum">4.2</span> NumberFormat Objects</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-numberformat-abstracts" title="Abstract Operations for NumberFormat Objects"><span class="secnum">4.2.1</span> Abstract Operations for NumberFormat Objects</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-tointlmathematicalvalue" title="ToIntlMathematicalValue ( value )"><span class="secnum">4.2.1.1</span> ToIntlMathematicalValue ( <var>value</var> )</a></li></ol></li></ol></li><li><span class="item-toggle">+</span><a href="#pluralrules-objects" title="PluralRules Objects"><span class="secnum">4.3</span> PluralRules Objects</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-intl-pluralrules-abstracts" title="Abstract Operations for PluralRules Objects"><span class="secnum">4.3.1</span> Abstract Operations for PluralRules Objects</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-resolveplural" title="ResolvePlural ( pluralRules, n )"><span class="secnum">4.3.1.1</span> ResolvePlural ( <var>pluralRules</var>, <var>n</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-resolvepluralrange" title="ResolvePluralRange ( pluralRules, x, y )"><span class="secnum">4.3.1.2</span> ResolvePluralRange ( <var>pluralRules</var>, <var>x</var>, <var>y</var> )</a></li></ol></li></ol></li></ol></li><li><span class="item-toggle-none"></span><a href="#sec-copyright-and-software-license" title="Copyright &amp; Software License"><span class="secnum">A</span> Copyright &amp; Software License</a></li></ol></div></div><div id="spec-container"><h1 class="version">Stage 1 Draft / October 8, 2024</h1><h1 class="title">Decimal</h1>
+    </svg></div><div id="menu-spacer" class="menu-spacer"></div><div id="menu"><div id="menu-search"><input type="text" id="menu-search-box" placeholder="Search..."><div id="menu-search-results" class="inactive"></div></div><div id="menu-pins"><div class="menu-pane-header">Pins<button class="unpin-all">clear</button></div><ul id="menu-pins-list"></ul></div><div class="menu-pane-header">Table of Contents</div><div id="menu-toc"><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal-intro-" title="Introduction">Introduction</a></li><li><span class="item-toggle">+</span><a href="#sec-the-decimal-object" title="The Decimal128 Object"><span class="secnum">1</span> The Decimal128 Object</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal-intro" title="Introduction">Introduction</a></li><li><span class="item-toggle">+</span><a href="#sec-decimal-abstract-ops" title="Abstract Operations"><span class="secnum">1.1</span> Abstract Operations</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-decimal128-roundtodecimal128domain" title="RoundToDecimal128Domain ( v [ , roundingMode ] )"><span class="secnum">1.1.1</span> RoundToDecimal128Domain ( <var>v</var> [ , <var>roundingMode</var> ] )</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal128-applyroundingmodetopositive" title="ApplyRoundingModeToPositive ( m, roundingMode )"><span class="secnum">1.1.1.1</span> ApplyRoundingModeToPositive ( <var>m</var>, <var>roundingMode</var> )</a></li></ol></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-abs" title="Decimal128Abs ( argument )"><span class="secnum">1.1.2</span> Decimal128Abs ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-negate" title="Decimal128Negate ( argument )"><span class="secnum">1.1.3</span> Decimal128Negate ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-canonicalizedecimalstring" title="CanonicalizeDecimalString ( digits )"><span class="secnum">1.1.4</span> CanonicalizeDecimalString ( <var>digits</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-decimal128todecimalstring" title="Decimal128ToDecimalString ( argument )"><span class="secnum">1.1.5</span> Decimal128ToDecimalString ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128toexponentialstring" title="Decimal128ToExponentialString ( argument )"><span class="secnum">1.1.6</span> Decimal128ToExponentialString ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-value-to-object" title="Decimal128ValueToObject ( argument )"><span class="secnum">1.1.7</span> Decimal128ValueToObject ( <var>argument</var> )</a></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-the-decimal-constructor" title="The Decimal128 Constructor"><span class="secnum">1.2</span> The Decimal128 Constructor</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-the-decimal128-constructor-value" title="Decimal128 ( x )"><span class="secnum">1.2.1</span> Decimal128 ( <var>x</var> )</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-runtime-semantics-stringdecimalvalue" title="Runtime Semantics: StringDecimalValue"><span class="secnum">1.2.1.1</span> RS: StringDecimalValue</a></li></ol></li></ol></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-decimal-prototype-properties" title="Properties of the Decimal128 Prototype"><span class="secnum">2</span> Properties of the Decimal128 Prototype</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.isnan" title="Decimal128.prototype.isNaN ( )"><span class="secnum">2.1</span> Decimal128.prototype.isNaN ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.isfinite" title="Decimal128.prototype.isFinite ( )"><span class="secnum">2.2</span> Decimal128.prototype.isFinite ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.exponent" title="Decimal128.prototype.exponent ( )"><span class="secnum">2.3</span> Decimal128.prototype.exponent ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.mantissa" title="Decimal128.prototype.mantissa ( )"><span class="secnum">2.4</span> Decimal128.prototype.mantissa ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.abs" title="Decimal128.prototype.abs ( )"><span class="secnum">2.5</span> Decimal128.prototype.abs ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.negate" title="Decimal128.prototype.negate ( )"><span class="secnum">2.6</span> Decimal128.prototype.negate ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.add" title="Decimal128.prototype.add ( x )"><span class="secnum">2.7</span> Decimal128.prototype.add ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.subtract" title="Decimal128.prototype.subtract ( x )"><span class="secnum">2.8</span> Decimal128.prototype.subtract ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.multiply" title="Decimal128.prototype.multiply ( x )"><span class="secnum">2.9</span> Decimal128.prototype.multiply ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.divide" title="Decimal128.prototype.divide ( x )"><span class="secnum">2.10</span> Decimal128.prototype.divide ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.remainder" title="Decimal128.prototype.remainder ( x )"><span class="secnum">2.11</span> Decimal128.prototype.remainder ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.compare" title="Decimal128.prototype.compare ( x )"><span class="secnum">2.12</span> Decimal128.prototype.compare ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.equals" title="Decimal128.prototype.equals ( x )"><span class="secnum">2.13</span> Decimal128.prototype.equals ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.notequals" title="Decimal128.prototype.notEquals ( x )"><span class="secnum">2.14</span> Decimal128.prototype.notEquals ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.lessthan" title="Decimal128.prototype.lessThan ( x )"><span class="secnum">2.15</span> Decimal128.prototype.lessThan ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.lessthanorequal" title="Decimal128.prototype.lessThanOrEqual ( x )"><span class="secnum">2.16</span> Decimal128.prototype.lessThanOrEqual ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.greaterthan" title="Decimal128.prototype.greaterThan ( x )"><span class="secnum">2.17</span> Decimal128.prototype.greaterThan ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.greaterthanorequal" title="Decimal128.prototype.greaterThanOrEqual ( x )"><span class="secnum">2.18</span> Decimal128.prototype.greaterThanOrEqual ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal-method-round" title="Decimal128.prototype.round ( numFractionalDigits [ , roundingMode ] )"><span class="secnum">2.19</span> Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal-method-scale10" title="Decimal128.prototype.scale10 ( n )"><span class="secnum">2.20</span> Decimal128.prototype.scale10 ( <var>n</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.tostring" title="Decimal128.prototype.toString ( [ options ] )"><span class="secnum">2.21</span> Decimal128.prototype.toString ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.tolocalestring" title="Decimal128.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )"><span class="secnum">2.22</span> Decimal128.prototype.toLocaleString ( [ <var>reserved1</var> [ , <var>reserved2</var> ] ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.toexponential" title="Decimal128.prototype.toExponential ( [ options ] )"><span class="secnum">2.23</span> Decimal128.prototype.toExponential ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.tofixed" title="Decimal128.prototype.toFixed ( [ options ] )"><span class="secnum">2.24</span> Decimal128.prototype.toFixed ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.tojson" title="Decimal128.prototype.toJSON ( )"><span class="secnum">2.25</span> Decimal128.prototype.toJSON ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.toprecision" title="Decimal128.prototype.toPrecision ( [ options ] )"><span class="secnum">2.26</span> Decimal128.prototype.toPrecision ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128.prototype.valueof" title="Decimal128.prototype.valueOf ( x )"><span class="secnum">2.27</span> Decimal128.prototype.valueOf ( <var>x</var> )</a></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-numbers-and-dates" title="Numbers and Dates"><span class="secnum">3</span> Numbers and Dates</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-number-objects" title="Number Objects"><span class="secnum">3.1</span> Number Objects</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-number-constructor" title="The Number Constructor"><span class="secnum">3.1.1</span> The Number Constructor</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-number-constructor-number-value" title="Number ( value )"><span class="secnum">3.1.1.1</span> Number ( <var>value</var> )</a></li></ol></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-bigint-objects" title="BigInt Objects"><span class="secnum">3.2</span> BigInt Objects</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-bigint-constructor" title="The BigInt Constructor"><span class="secnum">3.2.1</span> The BigInt Constructor</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-bigint-constructor-number-value" title="BigInt ( value )"><span class="secnum">3.2.1.1</span> BigInt ( <var>value</var> )</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-numbertobigint" title="Decimal128ToBigInt ( number )"><span class="secnum">3.2.1.1.1</span> <ins>Decimal128ToBigInt ( <var>number</var> )</ins></a></li></ol></li></ol></li></ol></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-decimal-intl" title="Amendments to the ECMAScript® 2024 Internationalization API Specification"><span class="secnum">4</span> Amendments to the ECMAScript® 2024 Internationalization API Specification</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sup-properties-of-the-decimal128-prototype-object" title="Properties of the Decimal128 Prototype Object"><span class="secnum">4.1</span> Properties of the Decimal128 Prototype Object</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sup-decimal128.prototype.tolocalestring" title="Decimal128.prototype.toLocaleString ( [ locales [ , options ] ] )"><span class="secnum">4.1.1</span> Decimal128.prototype.toLocaleString ( [ <var>locales</var> [ , <var>options</var> ] ] )</a></li></ol></li><li><span class="item-toggle">+</span><a href="#numberformat-objects" title="NumberFormat Objects"><span class="secnum">4.2</span> NumberFormat Objects</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-numberformat-abstracts" title="Abstract Operations for NumberFormat Objects"><span class="secnum">4.2.1</span> Abstract Operations for NumberFormat Objects</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-tointlmathematicalvalue" title="ToIntlMathematicalValue ( value )"><span class="secnum">4.2.1.1</span> ToIntlMathematicalValue ( <var>value</var> )</a></li></ol></li></ol></li><li><span class="item-toggle">+</span><a href="#pluralrules-objects" title="PluralRules Objects"><span class="secnum">4.3</span> PluralRules Objects</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-intl-pluralrules-abstracts" title="Abstract Operations for PluralRules Objects"><span class="secnum">4.3.1</span> Abstract Operations for PluralRules Objects</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-resolveplural" title="ResolvePlural ( pluralRules, n )"><span class="secnum">4.3.1.1</span> ResolvePlural ( <var>pluralRules</var>, <var>n</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-resolvepluralrange" title="ResolvePluralRange ( pluralRules, x, y )"><span class="secnum">4.3.1.2</span> ResolvePluralRange ( <var>pluralRules</var>, <var>x</var>, <var>y</var> )</a></li></ol></li></ol></li></ol></li><li><span class="item-toggle-none"></span><a href="#sec-copyright-and-software-license" title="Copyright &amp; Software License"><span class="secnum">A</span> Copyright &amp; Software License</a></li></ol></div></div><div id="spec-container"><h1 class="version">Stage 1 Draft / December 11, 2024</h1><h1 class="title">Decimal</h1>
 
 <emu-intro id="sec-decimal-intro-">
   <h1>Introduction</h1>
@@ -3247,7 +3247,9 @@ <h1><span class="secnum">1</span> The Decimal128 Object</h1>
 
   <emu-intro id="sec-decimal-intro">
     <h1>Introduction</h1>
-    <p>Decimal128 values, as specified here, are intended to represent base-10 (decimal) numbers as specified in <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019 Decimal128</a></emu-xref>. Only a subset of the values specified in <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> Decimal128 are modeled here, namely, the set of <emu-val>canonicalized</emu-val> values, which can be intuitively understood as decimal numbers without trailing zeroes. A Decimal128 value, as specified here, is one of the following six kinds of values:</p>
+    <p>Decimal128 values, as specified here, are intended to represent base-10 (decimal) numbers as specified in <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019 Decimal128</a></emu-xref>. All values specified in <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> Decimal128 are modeled here, though mathematically equal members of a cohort (intuitively, <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> Decimal128 values that differ only in the number of trailing zeroes after the decimal point) are indistinguishable here.</p>
+
+    <p>A <dfn id="def-decimal128-value" tabindex="-1">Decimal128 value</dfn>, as specified here, is one of the following six kinds of values:</p>
 
     <ul>
       <li><emu-val>NaN</emu-val><sub>𝔻</sub>, represending a decimal not-a-number</li>
@@ -3258,27 +3260,27 @@ <h1>Introduction</h1>
       <li>a <emu-xref href="#decimal128-mathematical-value" id="_ref_10"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> <var>v</var> for which there exists an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>q</var> satisfing the following conditions:</li>
       <ul>
         <li>-6176 ≤ <var>q</var> ≤ 6111,</li>
-        <li>v × 10<sup>−<var>q</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></li>
+        <li><var>v</var> × 10<sup>−<var>q</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></li>
       </ul>
     </ul>
     <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>
+      <p>A <emu-xref href="#def-decimal128-value" id="_ref_11"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> 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>A Decimal128 value is said to be <dfn id="dfn-decimal128-finite" tabindex="-1">finite</dfn> if it is either a <emu-xref href="#decimal128-mathematical-value" id="_ref_11"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>, <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>. A <dfn id="dfn-decimal128-zero" tabindex="-1">zero</dfn> Decimal128 value is one of <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><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 a <emu-xref href="#decimal128-mathematical-value" id="_ref_14"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> satisfying the conditions listed above.</p>
-    <p>The <dfn id="decimal128-mathematical-value" tabindex="-1">mathematical value</dfn> <emu-eqn id="dfn-decimal128-mv" aoid="MV" class="inline">MV(<var>x</var>)</emu-eqn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_15"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value <var>x</var> is defined as follows:</p>
+    <p>A <emu-xref href="#def-decimal128-value" id="_ref_12"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> is said to be <dfn id="dfn-decimal128-finite" tabindex="-1">finite</dfn> if it is either a <emu-xref href="#decimal128-mathematical-value" id="_ref_13"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>, <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>. A <dfn id="dfn-decimal128-zero" tabindex="-1">zero</dfn> <emu-xref href="#def-decimal128-value" id="_ref_14"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> is one of <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><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> <emu-xref href="#def-decimal128-value" id="_ref_17"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> is a <emu-xref href="#decimal128-mathematical-value" id="_ref_18"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> satisfying the conditions listed above.</p>
+    <p>The <dfn id="decimal128-mathematical-value" tabindex="-1">mathematical value</dfn> <emu-eqn id="dfn-decimal128-mv" aoid="MV" class="inline">MV(<var>x</var>)</emu-eqn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_19"><a href="#dfn-decimal128-finite">finite</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_20"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> <var>x</var> is defined as follows:</p>
     <ul>
-      <li><emu-xref aoid="MV" id="_ref_16"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>) = 0</li>
-      <li><emu-xref aoid="MV" id="_ref_17"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<emu-val>-0</emu-val><sub>𝔻</sub>) = 0</li>
-      <li><emu-xref aoid="MV" id="_ref_18"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>v</var>) = <var>v</var> (provided <var>v</var> is neither <emu-val>+0</emu-val><sub>𝔻</sub> nor <emu-val>-0</emu-val><sub>𝔻</sub>)</li>
+      <li><emu-xref aoid="MV" id="_ref_21"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>) = 0</li>
+      <li><emu-xref aoid="MV" id="_ref_22"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<emu-val>-0</emu-val><sub>𝔻</sub>) = 0</li>
+      <li><emu-xref aoid="MV" id="_ref_23"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>v</var>) = <var>v</var> (provided <var>v</var> is neither <emu-val>+0</emu-val><sub>𝔻</sub> nor <emu-val>-0</emu-val><sub>𝔻</sub>)</li>
     </ul>
-    <p>Decimal128 values defined in this section are ECMAScript analogues of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019 Decimal128 values</a></emu-xref>. It is important to note that the full spectrum of values defined by <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> Decimal128 are not available here, namely non-canonical Decimal128 values, which can be underdtood as values containing trailing zeroes. Also, this specification simplifies <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> Decimal128 in a further way: there is only one Decimal128 value, NaN<sub>𝔻</sub>, representing all possible <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> Decimal128 NaN values.</p>
+    <p>Decimal128 values defined in this section are ECMAScript analogues of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019 Decimal128 values</a></emu-xref>. It is important to note that the full spectrum of values defined by <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> Decimal128 are not available here, namely non-canonical Decimal128 values, which can be underdtood as values containing trailing zeroes. Also, this specification simplifies <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> Decimal128 in a further way: there is only one <emu-xref href="#def-decimal128-value" id="_ref_24"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>, NaN<sub>𝔻</sub>, representing all possible <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> Decimal128 NaN values.</p>
     <p>A <dfn id="dfn-decimal128-rounding-mode" tabindex="-1">Decimal128 rounding mode</dfn> is one of the String values <emu-val>"ceil"</emu-val>, <emu-val>"floor"</emu-val>, <emu-val>"trunc"</emu-val>, <emu-val>"halfExpand"</emu-val>, and <emu-val>"halfEven"</emu-val>. The <dfn id="dfn-decimal128-default-rounding-mode" tabindex="-1">default rounding mode</dfn> is the String value <emu-val>"halfEven"</emu-val>.</p>
     <emu-table id="table-decimal128-rounding-modes"><figure><figcaption>Table 1: Rounding modes in Decimal128 compared to <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> rounding modes</figcaption>
       
       <table class="real-table">
         <thead>
           <tr>
-            <th><emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_19"><a href="#dfn-decimal128-rounding-mode">Decimal128 rounding mode</a></emu-xref></th>
+            <th><emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_25"><a href="#dfn-decimal128-rounding-mode">Decimal128 rounding mode</a></emu-xref></th>
             <th>Description</th>
             <th><emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> rounding mode</th>
           </tr>
@@ -3296,12 +3298,12 @@ <h1>Introduction</h1>
           </tr>
           <tr>
             <td><emu-val>"trunc"</emu-val></td>
-            <td>Toward <emu-xref href="#dfn-decimal128-zero" id="_ref_20"><a href="#dfn-decimal128-zero">zero</a></emu-xref></td>
+            <td>Toward <emu-xref href="#dfn-decimal128-zero" id="_ref_26"><a href="#dfn-decimal128-zero">zero</a></emu-xref></td>
             <td><emu-val>"roundTowardZero"</emu-val></td>
           </tr>
           <tr>
             <td><emu-val>"halfExpand"</emu-val></td>
-            <td>Ties away from <emu-xref href="#dfn-decimal128-zero" id="_ref_21"><a href="#dfn-decimal128-zero">zero</a></emu-xref></td>
+            <td>Ties away from <emu-xref href="#dfn-decimal128-zero" id="_ref_27"><a href="#dfn-decimal128-zero">zero</a></emu-xref></td>
             <td><emu-val>"roundTiesToAway"</emu-val></td>
           </tr>
           <tr>
@@ -3313,34 +3315,34 @@ <h1>Introduction</h1>
       </table>
       <emu-note><span class="note">Note 2</span><div class="note-contents">The above five rounding modes are defined in <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>. 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 <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> rounding mode 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>For every non-NaN Decimal128 value, we define its <emu-eqn id="dfn-decimal128-sign" aoid="sign" class="inline">sign</emu-eqn> as follows:</p>
+    <p>For every non-NaN <emu-xref href="#def-decimal128-value" id="_ref_28"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>, we define its <emu-eqn id="dfn-decimal128-sign" aoid="sign" class="inline">sign</emu-eqn> as follows:</p>
     <ul>
-      <li><emu-xref aoid="sign" id="_ref_22"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>) = 1</li>
-      <li><emu-xref aoid="sign" id="_ref_23"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>) = -1</li>
-      <li><emu-xref aoid="sign" id="_ref_24"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>) = 1</li>
-      <li><emu-xref aoid="sign" id="_ref_25"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>) = -1</li>
-      <li><emu-xref aoid="sign" id="_ref_26"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>v</var>) = <var>v</var> / <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>v</var>) for all other Decimal128 values <var>v</var></li>
+      <li><emu-xref aoid="sign" id="_ref_29"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>) = 1</li>
+      <li><emu-xref aoid="sign" id="_ref_30"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>) = -1</li>
+      <li><emu-xref aoid="sign" id="_ref_31"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>) = 1</li>
+      <li><emu-xref aoid="sign" id="_ref_32"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>) = -1</li>
+      <li><emu-xref aoid="sign" id="_ref_33"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>v</var>) = <var>v</var> / <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>v</var>) for all other Decimal128 values <var>v</var></li>
     </ul>
-    <p>For every <emu-xref href="#dfn-decimal128-finite" id="_ref_27"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_28"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value <var>v</var> 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="#decimal128-mathematical-value" id="_ref_29"><a href="#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_34"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_35"><a href="#dfn-decimal128-zero">zero</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_36"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> <var>v</var> 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="#decimal128-mathematical-value" id="_ref_37"><a href="#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 id="dfn-decimal128-exponent" tabindex="-1">exponent</dfn> and <var>s</var> the <dfn id="dfn-decimal128-significand" tabindex="-1">significand</dfn> of <var>v</var>. The <emu-xref href="#dfn-decimal128-exponent" id="_ref_30"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref> and <emu-xref href="#dfn-decimal128-significand" id="_ref_31"><a href="#dfn-decimal128-significand">significand</a></emu-xref> are undefined for NaN, non-<emu-xref href="#dfn-decimal128-finite" id="_ref_32"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, and <emu-xref href="#dfn-decimal128-zero" id="_ref_33"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 values.</p>
+    <p>We call <var>e</var> the <dfn id="dfn-decimal128-exponent" tabindex="-1">exponent</dfn> and <var>s</var> the <dfn id="dfn-decimal128-significand" tabindex="-1">significand</dfn> of <var>v</var>. The <emu-xref href="#dfn-decimal128-exponent" id="_ref_38"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref> and <emu-xref href="#dfn-decimal128-significand" id="_ref_39"><a href="#dfn-decimal128-significand">significand</a></emu-xref> are undefined for NaN, non-<emu-xref href="#dfn-decimal128-finite" id="_ref_40"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, and <emu-xref href="#dfn-decimal128-zero" id="_ref_41"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 values.</p>
     <emu-note><span class="note">Note 3</span><div class="note-contents">
-      <p>The <emu-xref href="#dfn-decimal128-significand" id="_ref_34"><a href="#dfn-decimal128-significand">significand</a></emu-xref> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_35"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_36"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is a rational number.</p>
+      <p>The <emu-xref href="#dfn-decimal128-significand" id="_ref_42"><a href="#dfn-decimal128-significand">significand</a></emu-xref> of 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> <emu-xref href="#def-decimal128-value" id="_ref_45"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> is a rational number.</p>
     </div></emu-note>
     <emu-note><span class="note">Note 4</span><div class="note-contents">
-      <p>The <emu-xref href="#dfn-decimal128-exponent" id="_ref_37"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref> <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 <emu-xref href="#dfn-decimal128-exponent" id="_ref_46"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref> <var>e</var> of <emu-xref href="#dfn-decimal128-finite" id="_ref_47"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_48"><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 id="dfn-decimal128-normalized" tabindex="-1">normalized</dfn> if its <emu-xref href="#dfn-decimal128-exponent" id="_ref_42"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref> <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 id="dfn-decimal128-denormalized-" tabindex="-1">denormalized</dfn> if its <emu-xref href="#dfn-decimal128-exponent" id="_ref_45"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref> <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 <emu-xref href="#dfn-decimal128-normalized" id="_ref_46"><a href="#dfn-decimal128-normalized">normalized</a></emu-xref> compared with denormlized values. For a <emu-xref href="#dfn-decimal128-normalized" id="_ref_47"><a href="#dfn-decimal128-normalized">normalized</a></emu-xref> Decimal128 value we define its <dfn tabindex="-1">truncated exponent</dfn> as equal to its <emu-xref href="#dfn-decimal128-exponent" id="_ref_48"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref>. For <emu-xref href="#dfn-decimal128-zero" id="_ref_49"><a href="#dfn-decimal128-zero">zero</a></emu-xref> or <emu-xref href="#dfn-decimal128-denormalized-" id="_ref_50"><a href="#dfn-decimal128-denormalized-">denormalized</a></emu-xref> 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_51"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value as follows:</p>
+    <p>A <emu-xref href="#dfn-decimal128-finite" id="_ref_49"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_50"><a href="#dfn-decimal128-zero">zero</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_51"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> is <dfn id="dfn-decimal128-normalized" tabindex="-1">normalized</dfn> if its <emu-xref href="#dfn-decimal128-exponent" id="_ref_52"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref> <var>e</var> satisfies 6144 ≥ <var>e</var> ≥ -6143. A <emu-xref href="#dfn-decimal128-finite" id="_ref_53"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_54"><a href="#dfn-decimal128-zero">zero</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_55"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> is <dfn id="dfn-decimal128-denormalized-" tabindex="-1">denormalized</dfn> if its <emu-xref href="#dfn-decimal128-exponent" id="_ref_56"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref> <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 <emu-xref href="#dfn-decimal128-normalized" id="_ref_57"><a href="#dfn-decimal128-normalized">normalized</a></emu-xref> compared with denormlized values. For a <emu-xref href="#dfn-decimal128-normalized" id="_ref_58"><a href="#dfn-decimal128-normalized">normalized</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_59"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> we define its <dfn tabindex="-1">truncated exponent</dfn> as equal to its <emu-xref href="#dfn-decimal128-exponent" id="_ref_60"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref>. For <emu-xref href="#dfn-decimal128-zero" id="_ref_61"><a href="#dfn-decimal128-zero">zero</a></emu-xref> or <emu-xref href="#dfn-decimal128-denormalized-" id="_ref_62"><a href="#dfn-decimal128-denormalized-">denormalized</a></emu-xref> 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_63"><a href="#dfn-decimal128-finite">finite</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_64"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> as follows:</p>
     <ul>
-      <li>The scaled significand of a <emu-xref href="#dfn-decimal128-zero" id="_ref_52"><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_53"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value <var>v</var> is <var>v</var> × 10<sup>33</sup> − <var>te</var>, 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_65"><a href="#dfn-decimal128-zero">zero</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_66"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> is 0.</li>
+      <li>The scaled significand of a non-<emu-xref href="#dfn-decimal128-zero" id="_ref_67"><a href="#dfn-decimal128-zero">zero</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_68"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> <var>v</var> is <var>v</var> × 10<sup>33</sup> − <var>te</var>, where <var>te</var> is the truncated exponent of <var>x</var>.</li>
     </ul>
     <emu-note><span class="note">Note 5</span><div class="note-contents">
-      <p>The scaled significand of a <emu-xref href="#dfn-decimal128-finite" id="_ref_54"><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_69"><a href="#dfn-decimal128-finite">finite</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_70"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> 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">
@@ -3348,50 +3350,50 @@ <h1><span class="secnum">1.1</span> Abstract Operations</h1>
 
     <emu-clause id="sec-decimal128-roundtodecimal128domain" type="abstract operation" aoid="RoundToDecimal128Domain">
       <h1><span class="secnum">1.1.1</span> RoundToDecimal128Domain ( <var>v</var> [ , <var>roundingMode</var> ] )</h1>
-      <p>The abstract operation RoundToDecimal128Domain takes argument <var>v</var> (a <emu-xref href="#decimal128-mathematical-value" id="_ref_55"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>) and optional argument <var>roundingMode</var> (a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_56"><a href="#dfn-decimal128-rounding-mode">Decimal128 rounding mode</a></emu-xref>) and returns <emu-val>+∞</emu-val><sub>𝔻</sub>, <emu-val>-∞</emu-val><sub>𝔻</sub>, <emu-val>+0</emu-val><sub>𝔻</sub>, <emu-val>−0</emu-val><sub>𝔻</sub>, or a <emu-xref href="#decimal128-mathematical-value" id="_ref_57"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>. It computes the closest approximation to a given <emu-xref href="#decimal128-mathematical-value" id="_ref_58"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>, rounded according to the given rounding mode, that is available within the limits of Decimal128. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If <var>v</var> = 0, return <emu-val>+0</emu-val><sub>𝔻</sub>.</li><li>If v &lt; 0, then<ol><li>Let <var>reverseRoundingMode</var> be <var>roundingMode</var>.</li><li>If <var>roundingMode</var> is <emu-val>"floor"</emu-val>, set <var>reverseRoundingMode</var> to <emu-val>"ceil"</emu-val>.</li><li>If <var>roundingMode</var> is <emu-val>"ceil"</emu-val>, set <var>reverseRoundingMode</var> to <emu-val>"floor"</emu-val>.</li><li>Let <var>d</var> be <emu-xref aoid="RoundToDecimal128Domain" id="_ref_59"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(–<var>v</var>, <var>reverseRoundingMode</var>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>–∞</emu-val><sub>𝔻</sub>.</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>−0</emu-val><sub>𝔻</sub>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>d</var> is a <emu-xref href="#decimal128-mathematical-value" id="_ref_60"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>.</li><li>Return –<var>d</var>.</li></ol></li><li>Let <var>e</var> be the unique <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that 10<sup><var>e</var></sup> ≤ <var>v</var> &lt; 10<sup><var>e</var>+1</sup>.</li><li>Let <var>te</var> be <var>e</var> − 33.</li><li>If <var>te</var> &lt; –6176, set <var>te</var> to –6176.</li><li>Let <var>m</var> be <var>v</var> × 10<sup>–<var>te</var></sup>.</li><li>Let <var>rounded</var> be <emu-xref aoid="ApplyRoundingModeToPositive" id="_ref_61"><a href="#sec-decimal128-applyroundingmodetopositive">ApplyRoundingModeToPositive</a></emu-xref>(<var>m</var>, <var>roundingMode</var>).</li><li>If <var>rounded</var> = 10<sup>34</sup>, then<ol><li>Set <var>te</var> to <var>te</var> + 1.</li><li>Set <var>rounded</var> to 10<sup>33</sup>.</li></ol></li><li>If <var>te</var> &gt; 6111, return <emu-val>+∞</emu-val><sub>𝔻</sub>.</li><li>If <var>rounded</var> = 0, return <emu-val>+0</emu-val><sub>𝔻</sub>.</li><li>Return <var>rounded</var> × 10<sup><var>te</var></sup>.</li></ol></emu-alg>
+      <p>The abstract operation RoundToDecimal128Domain takes argument <var>v</var> (a <emu-xref href="#decimal128-mathematical-value" id="_ref_71"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>) and optional argument <var>roundingMode</var> (a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_72"><a href="#dfn-decimal128-rounding-mode">Decimal128 rounding mode</a></emu-xref>) and returns <emu-val>+∞</emu-val><sub>𝔻</sub>, <emu-val>-∞</emu-val><sub>𝔻</sub>, <emu-val>+0</emu-val><sub>𝔻</sub>, <emu-val>−0</emu-val><sub>𝔻</sub>, or a <emu-xref href="#decimal128-mathematical-value" id="_ref_73"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>. It computes the closest approximation to a given <emu-xref href="#decimal128-mathematical-value" id="_ref_74"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>, rounded according to the given rounding mode, that is available within the limits of Decimal128. It performs the following steps when called:</p>
+      <emu-alg><ol><li>If <var>v</var> = 0, return <emu-val>+0</emu-val><sub>𝔻</sub>.</li><li>If v &lt; 0, then<ol><li>Let <var>reverseRoundingMode</var> be <var>roundingMode</var>.</li><li>If <var>roundingMode</var> is <emu-val>"floor"</emu-val>, set <var>reverseRoundingMode</var> to <emu-val>"ceil"</emu-val>.</li><li>If <var>roundingMode</var> is <emu-val>"ceil"</emu-val>, set <var>reverseRoundingMode</var> to <emu-val>"floor"</emu-val>.</li><li>Let <var>d</var> be <emu-xref aoid="RoundToDecimal128Domain" id="_ref_75"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(–<var>v</var>, <var>reverseRoundingMode</var>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>–∞</emu-val><sub>𝔻</sub>.</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>−0</emu-val><sub>𝔻</sub>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>d</var> is a <emu-xref href="#decimal128-mathematical-value" id="_ref_76"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>.</li><li>Return –<var>d</var>.</li></ol></li><li>Let <var>e</var> be the unique <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that 10<sup><var>e</var></sup> ≤ <var>v</var> &lt; 10<sup><var>e</var>+1</sup>.</li><li>Let <var>te</var> be <var>e</var> − 33.</li><li>If <var>te</var> &lt; –6176, set <var>te</var> to –6176.</li><li>Let <var>m</var> be <var>v</var> × 10<sup>–<var>te</var></sup>.</li><li>Let <var>rounded</var> be <emu-xref aoid="ApplyRoundingModeToPositive" id="_ref_77"><a href="#sec-decimal128-applyroundingmodetopositive">ApplyRoundingModeToPositive</a></emu-xref>(<var>m</var>, <var>roundingMode</var>).</li><li>If <var>rounded</var> = 10<sup>34</sup>, then<ol><li>Set <var>te</var> to <var>te</var> + 1.</li><li>Set <var>rounded</var> to 10<sup>33</sup>.</li></ol></li><li>If <var>te</var> &gt; 6111, return <emu-val>+∞</emu-val><sub>𝔻</sub>.</li><li>If <var>rounded</var> = 0, return <emu-val>+0</emu-val><sub>𝔻</sub>.</li><li>Return <var>rounded</var> × 10<sup><var>te</var></sup>.</li></ol></emu-alg>
 
       <emu-clause id="sec-decimal128-applyroundingmodetopositive" type="abstract operation" aoid="ApplyRoundingModeToPositive">
         <h1><span class="secnum">1.1.1.1</span> ApplyRoundingModeToPositive ( <var>m</var>, <var>roundingMode</var> )</h1>
-        <p>The abstract operation ApplyRoundingModeToPositive takes arguments <var>m</var> (a positive <emu-xref href="#decimal128-mathematical-value" id="_ref_62"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>) and <var>roundingMode</var> (a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_63"><a href="#dfn-decimal128-rounding-mode">Decimal128 rounding mode</a></emu-xref>) and returns an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>. It computes the closest <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> approximation to a given positive <emu-xref href="#decimal128-mathematical-value" id="_ref_64"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>, rounded according to the given rounding mode. It performs the following steps when called:</p>
+        <p>The abstract operation ApplyRoundingModeToPositive takes arguments <var>m</var> (a positive <emu-xref href="#decimal128-mathematical-value" id="_ref_78"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>) and <var>roundingMode</var> (a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_79"><a href="#dfn-decimal128-rounding-mode">Decimal128 rounding mode</a></emu-xref>) and returns an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>. It computes the closest <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> approximation to a given positive <emu-xref href="#decimal128-mathematical-value" id="_ref_80"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>, rounded according to the given rounding mode. It performs the following steps when called:</p>
         <emu-alg><ol><li>Let <var>mLow</var> be <emu-xref aoid="floor"><a href="https://tc39.es/ecma262/#eqn-floor">floor</a></emu-xref>(<var>m</var>).</li><li>Let <var>fraction</var> be <var>m</var> – <var>mLow</var>.</li><li>If <var>fraction</var> = 0, return <var>mLow</var>.</li><li>Let <var>mHigh</var> be <var>mLow</var> + 1.</li><li>If <var>roundingMode</var> is <emu-val>"floor"</emu-val> or <emu-val>"trunc"</emu-val>, return <var>mLow</var>.</li><li>If <var>roundingMode</var> is <emu-val>"ceil"</emu-val>, return <var>mHigh</var>.</li><li>If <var>fraction</var> &lt; 0.5, return <var>mLow</var>.</li><li>If <var>fraction</var> &gt; 0.5, return <var>mHigh</var>.</li><li>If <var>roundingMode</var> is <emu-val>"halfExpand"</emu-val>, return <var>mHigh</var>.</li><li>If <var>mLow</var> is an even <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, return <var>mLow</var>.</li><li>Return <var>mHigh</var>.</li></ol></emu-alg>
       </emu-clause>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-abs" type="abstract operation" aoid="Decimal128Abs">
       <h1><span class="secnum">1.1.2</span> Decimal128Abs ( <var>argument</var> )</h1>
-      <p>The abstract operation Decimal128Abs takes argument <var>argument</var> (a Decimal128 value) and returns a Decimal128 value. It computes the absolute value of a Decimal128 value It performs the following steps when called:</p>
+      <p>The abstract operation Decimal128Abs takes argument <var>argument</var> (a <emu-xref href="#def-decimal128-value" id="_ref_81"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>) and returns a <emu-xref href="#def-decimal128-value" id="_ref_82"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>. It computes the absolute value of a <emu-xref href="#def-decimal128-value" id="_ref_83"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> 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><sub>𝔻</sub>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>+∞</emu-val><sub>𝔻</sub>.</li><li>If <var>argument</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-val>+0</emu-val><sub>𝔻</sub>.</li><li>Otherwise, return <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>argument</var>).</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-negate" type="abstract operation" aoid="Decimal128Negate">
       <h1><span class="secnum">1.1.3</span> Decimal128Negate ( <var>argument</var> )</h1>
-      <p>The abstract operation Decimal128Negate takes argument <var>argument</var> (a Decimal128 value) and returns a Decimal128 value. It computes the negation of a Decimal128 value It performs the following steps when called:</p>
+      <p>The abstract operation Decimal128Negate takes argument <var>argument</var> (a <emu-xref href="#def-decimal128-value" id="_ref_84"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>) and returns a <emu-xref href="#def-decimal128-value" id="_ref_85"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>. It computes the negation of a <emu-xref href="#def-decimal128-value" id="_ref_86"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> 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><sub>𝔻</sub>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>-∞</emu-val><sub>𝔻</sub>.</li><li>If <var>argument</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>+∞</emu-val><sub>𝔻</sub>.</li><li>If <var>argument</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>−0</emu-val><sub>𝔻</sub>.</li><li>If <var>argument</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-val>+0</emu-val><sub>𝔻</sub>.</li><li>Otherwise, return −<var>argument</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-canonicalizedecimalstring" type="abstract operation" aoid="CanonicalizeDecimalString">
       <h1><span class="secnum">1.1.4</span> CanonicalizeDecimalString ( <var>digits</var> )</h1>
       <p>The abstract operation CanonicalizeDecimalString takes argument <var>digits</var> (a String) and returns a String. It removes trailing zeroes, if any, from <var>digits</var>, which is assumed to be a string of digits, possibily followed by a <emu-val>"."</emu-val> and a non-empty sequence of digits. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If <var>digits</var> does not contain the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> <emu-val>"."</emu-val>, return <var>digits</var>.</li><li>If the final code unit of <var>digits</var> is not the code unit 0x0030 (DIGIT ZERO), return <var>digits</var>.</li><li>Let <var>lhs</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> up to the first occurrence of the string <emu-val>"."</emu-val>.</li><li>Let <var>rhs</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> starting at the first code point after the first occurrence of the string <emu-val>"."</emu-val>.</li><li>Let <var>noTrailingZeroes</var> be the shortest <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>rhs</var> that does not terminate with a sequence of the code point 0x0030 (DIGIT ZERO).</li><li>If <var>noTrailingZeroes</var> is <emu-val>""</emu-val>, return <var>lhs</var>.</li><li>Otherwise, return the concatenation of <var>lhs</var>, <emu-val>"."</emu-val>, and <var>noTrailingZeroes</var>.</li></ol></emu-alg>
+      <emu-alg><ol><li>If <var>digits</var> does not contain the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> <emu-val>"."</emu-val>, return <var>digits</var>.</li><li>If the final code unit of <var>digits</var> is not the code unit 0x0030 (DIGIT ZERO), return <var>digits</var>.</li><li>Let <var>lhs</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> up to the first occurrence of the string <emu-val>"."</emu-val>.</li><li>Let <var>rhs</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> starting at the first code point after the first occurrence of the string <emu-val>"."</emu-val>.</li><li>Let <var>noTrailingZeroes</var> be the longest <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>rhs</var> that does not terminate with a sequence of the code point 0x0030 (DIGIT ZERO).</li><li>If <var>noTrailingZeroes</var> is <emu-val>""</emu-val>, return <var>lhs</var>.</li><li>Otherwise, return the concatenation of <var>lhs</var>, <emu-val>"."</emu-val>, and <var>noTrailingZeroes</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-decimal128todecimalstring" type="abstract operation" aoid="Decimal128ToDecimalString">
       <h1><span class="secnum">1.1.5</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 string in decimal notation, regardless of how many decimal digits would be required. 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>sign</var> be <emu-xref aoid="sign" id="_ref_65"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>argument</var>).</li><li>If <var>sign</var> = -1, let <var>prefix</var> be <emu-val>"-"</emu-val>, else let <var>prefix</var> be <emu-val>""</emu-val>.</li><li>Let <var>argument</var> be <emu-xref aoid="Decimal128Abs" id="_ref_66"><a href="#sec-decimal128-abs">Decimal128Abs</a></emu-xref>(<var>argument</var>).</li><li>If <var>argument</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return the string concatenation of <var>prefix</var> and <emu-val>"0"</emu-val>.</li><li>Let <var>q</var> be the smallest <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that <var>argument</var> × 10<sup>−<var>q</var></sup> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>.</li><li>Let <var>n</var> be <var>argument</var> × 10<sup>−<var>q</var></sup>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: 0 &lt; <var>n</var> &lt; 10<sup>34</sup>.</li><li>Let <var>digits</var> be the unique decimal string representation of <var>n</var> without leading zeroes.</li><li>Let <var>numDigits</var> be the length of <var>digits</var>.</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 <var>numDigits</var>.</li><li>If <var>argument</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, then<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>integerPart</var> is not <emu-val>""</emu-val>.</li><li>Return <var>integerPart</var>.</li></ol></li><li>If <var>integerPart</var> is <emu-val>""</emu-val>, set <var>integerPart</var> to <emu-val>"0"</emu-val>.</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 <var>numDigits</var>.</li><li>Let <var>renderedAbsoluteValue</var> be the concatenation of _integerPart, <emu-val>"."</emu-val>, and <var>nonIntegerPart</var>.</li><li>Let <var>s</var> be the concatenation of _prefix and <var>renderedAbsoluteValue</var>.</li><li>Return <emu-xref aoid="CanonicalizeDecimalString" id="_ref_67"><a href="#sec-decimal128-canonicalizedecimalstring">CanonicalizeDecimalString</a></emu-xref>(<var>s</var>).</li></ol></emu-alg>
+      <p>The abstract operation Decimal128ToDecimalString takes argument <var>argument</var> (a <emu-xref href="#def-decimal128-value" id="_ref_87"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>) and returns a String. It renders <var>argument</var> as a string in decimal notation, regardless of how many decimal digits would be required. 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>sign</var> be <emu-xref aoid="sign" id="_ref_88"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>argument</var>).</li><li>If <var>sign</var> = -1, let <var>prefix</var> be <emu-val>"-"</emu-val>, else let <var>prefix</var> be <emu-val>""</emu-val>.</li><li>Let <var>argument</var> be <emu-xref aoid="Decimal128Abs" id="_ref_89"><a href="#sec-decimal128-abs">Decimal128Abs</a></emu-xref>(<var>argument</var>).</li><li>If <var>argument</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return the string concatenation of <var>prefix</var> and <emu-val>"0"</emu-val>.</li><li>Let <var>q</var> be the largest <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that <var>argument</var> × 10<sup>−<var>q</var></sup> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>.</li><li>Let <var>n</var> be <var>argument</var> × 10<sup>−<var>q</var></sup>.</li><li>Let <var>x</var> be <emu-xref aoid="floor"><a href="https://tc39.es/ecma262/#eqn-floor">floor</a></emu-xref>(<var>argument</var>).</li><li>Let <var>y</var> be <var>argument</var> mod 1.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: 0 &lt; <var>n</var> &lt; 10<sup>34</sup>.</li><li>Let <var>digits</var> be the unique decimal string representation of <var>x</var> without leading zeroes.</li><li>If <var>y</var> = 0, let <var>fractionalPart</var> be <emu-val>""</emu-val>, else let <var>fractionalPart</var> be the unique decimal string representation of <var>y</var> without leading zeroes.</li><li>Let <var>numDigits</var> be the length of <var>digits</var>.</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 <var>numDigits</var>.</li><li>If <var>argument</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, then<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>integerPart</var> is not <emu-val>""</emu-val>.</li><li>Return <var>integerPart</var>.</li></ol></li><li>If <var>integerPart</var> is <emu-val>""</emu-val>, set <var>integerPart</var> to <emu-val>"0"</emu-val>.</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>fractionalPart</var> from 0 to <var>numDigits</var>.</li><li>Let <var>renderedAbsoluteValue</var> be the concatenation of <var>integerPart</var>, <emu-val>"."</emu-val>, and <var>nonIntegerPart</var>.</li><li>Let <var>s</var> be the concatenation of <var>prefix</var> and <var>renderedAbsoluteValue</var>.</li><li>Return <emu-xref aoid="CanonicalizeDecimalString" id="_ref_90"><a href="#sec-decimal128-canonicalizedecimalstring">CanonicalizeDecimalString</a></emu-xref>(<var>s</var>).</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128toexponentialstring" type="abstract operation" aoid="Decimal128ToExponentialString">
       <h1><span class="secnum">1.1.6</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>sign</var> be <emu-xref aoid="sign" id="_ref_68"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>argument</var>).</li><li>Let <var>argument</var> be <emu-xref aoid="Decimal128Abs" id="_ref_69"><a href="#sec-decimal128-abs">Decimal128Abs</a></emu-xref>(<var>argument</var>).</li><li>If <var>sign</var> = -1, let <var>prefix</var> be <emu-val>"-"</emu-val>, else let <var>prefix</var> be <emu-val>""</emu-val>.</li><li>If <var>argument</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return the string concatenation of <var>prefix</var> and *"0e+0".</li><li>Let <var>q</var> be the smallest <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that <var>argument</var> × 10<sup>−<var>q</var></sup> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>.</li><li>Let <var>n</var> be <var>argument</var> × 10<sup>−<var>q</var></sup>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: 0 &lt; <var>n</var> &lt; 10<sup>34</sup>.</li><li>Let <var>coefficientStr</var> be the unique decimal string representation of <var>n</var> without leading zeroes.</li><li>Let <var>e</var> be the unique <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> for which 1 ≤ <var>n</var> × 10<sup><var>e</var></sup> &lt; 10.</li><li>Let <var>adjustedExp</var> be -<var>e</var>.</li><li>Let <var>adjustedExpStr</var> be the unique decimal string representation of <var>adjustedExp</var> without leading zeroes.</li><li>Let <var>firstDigit</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>coefficientStr</var> from 0 to 1.</li><li>Let <var>remainingDigits</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>coefficientStr</var> starting at 1.</li><li>Return the concatenation of <var>prefix</var>, <var>firstDigit</var>, <emu-val>"."</emu-val>, <var>remainingDigits</var>, <emu-val>"e"</emu-val>, and <var>adjustedExpStr</var>.</li></ol></emu-alg>
+      <p>The abstract operation Decimal128ToExponentialString takes argument <var>argument</var> (a <emu-xref href="#def-decimal128-value" id="_ref_91"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>) 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>sign</var> be <emu-xref aoid="sign" id="_ref_92"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>argument</var>).</li><li>Let <var>argument</var> be <emu-xref aoid="Decimal128Abs" id="_ref_93"><a href="#sec-decimal128-abs">Decimal128Abs</a></emu-xref>(<var>argument</var>).</li><li>If <var>sign</var> = -1, let <var>prefix</var> be <emu-val>"-"</emu-val>, else let <var>prefix</var> be <emu-val>""</emu-val>.</li><li>If <var>argument</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return the string concatenation of <var>prefix</var> and *"0e+0".</li><li>Let <var>e</var> be the unique <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> for which 1 ≤ <var>argument</var> × 10<sup><var>e</var></sup> &lt; 10.</li><li>Let <var>mantissa</var> be <var>argument</var> / 10<sup><var>e</var></sup>.</li><li>Let <var>coefficientStr</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_94"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>mantissa</var>).</li><li>Let <var>exponentStr</var> be the unique decimal string representation of <var>e</var> without leading zeroes.</li><li>Return the concatenation of <var>prefix</var>, <var>coefficientStr</var>, <emu-val>"e"</emu-val>, and <var>exponentStr</var>.</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.7</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_70"><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>
+      <p>The abstract operation Decimal128ValueToObject takes argument <var>argument</var> (a <emu-xref href="#def-decimal128-value" id="_ref_95"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>) and returns a Decimal128 object. It converts a <emu-xref href="#def-decimal128-value" id="_ref_96"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> 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_97"><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>
 
@@ -3406,13 +3408,13 @@ <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 !&nbsp;<emu-xref aoid="Call"><a href="https://tc39.es/ecma262/#sec-call">Call</a></emu-xref>(%Number.prototype.toExponential%, <var>x</var>, «&nbsp;»).</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>, then<ol><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>NaN</emu-val><sub>𝔻</sub>.</li></ol></li><li>Else,<ol><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-StrDecimalLiteral">StrDecimalLiteral</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>Let <var>decimalValue</var> be ?&nbsp;<emu-xref aoid="StringDecimalValue" id="_ref_71"><a href="#sec-runtime-semantics-stringdecimalvalue">StringDecimalValue</a></emu-xref> of <var>parseResult</var>.</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <var>decimalValue</var>.</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 !&nbsp;<emu-xref aoid="Call"><a href="https://tc39.es/ecma262/#sec-call">Call</a></emu-xref>(%Number.prototype.toExponential%, <var>x</var>, «&nbsp;»).</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>, then<ol><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>NaN</emu-val><sub>𝔻</sub>.</li></ol></li><li>Else,<ol><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-StrDecimalLiteral">StrDecimalLiteral</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>Let <var>decimalValue</var> be ?&nbsp;<emu-xref aoid="StringDecimalValue" id="_ref_98"><a href="#sec-runtime-semantics-stringdecimalvalue">StringDecimalValue</a></emu-xref> of <var>parseResult</var>.</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <var>decimalValue</var>.</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>
+        <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 desired. 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>
       <emu-clause id="sec-runtime-semantics-stringdecimalvalue" type="sdo" aoid="StringDecimalValue">
         <h1><span class="secnum">1.2.1.1</span> Runtime Semantics: StringDecimalValue</h1>
-        <p>The <emu-xref href="#sec-algorithm-conventions-syntax-directed-operations"><a href="https://tc39.es/ecma262/#sec-algorithm-conventions-syntax-directed-operations">syntax-directed operation</a></emu-xref> StringDecimalValue takes no arguments 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 is defined piecewise over the following productions:</p>
+        <p>The <emu-xref href="#sec-algorithm-conventions-syntax-directed-operations"><a href="https://tc39.es/ecma262/#sec-algorithm-conventions-syntax-directed-operations">syntax-directed operation</a></emu-xref> StringDecimalValue takes no arguments 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 <emu-xref href="#def-decimal128-value" id="_ref_99"><a href="#def-decimal128-value">Decimal128 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 is defined piecewise over the following productions:</p>
         <emu-grammar><emu-production name="StrDecimalLiteral" type="regexp" collapsed="">
     <emu-nt><a href="https://tc39.es/ecma262/#prod-StrDecimalLiteral">StrDecimalLiteral</a></emu-nt> <emu-geq>:::</emu-geq> <emu-rhs a="1g8bpsll">
         <emu-t>-</emu-t>
@@ -3420,7 +3422,7 @@ <h1><span class="secnum">1.2.1.1</span> Runtime Semantics: StringDecimalValue</h
     </emu-rhs>
 </emu-production>
 </emu-grammar>
-        <emu-alg><ol><li>Let <var>a</var> be ?&nbsp;<emu-xref aoid="StringDecimalValue" id="_ref_72"><a href="#sec-runtime-semantics-stringdecimalvalue">StringDecimalValue</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-StrUnsignedDecimalLiteral">StrUnsignedDecimalLiteral</a></emu-nt>.</li><li>If <var>a</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>-∞</emu-val><sub>𝔻</sub>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>a</var> is <emu-xref href="#dfn-decimal128-finite" id="_ref_73"><a href="#dfn-decimal128-finite">finite</a></emu-xref>.</li><li>If <var>a</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>−0</emu-val><sub>𝔻</sub>.</li><li>Return −<var>a</var>.</li></ol></emu-alg>
+        <emu-alg><ol><li>Let <var>a</var> be ?&nbsp;<emu-xref aoid="StringDecimalValue" id="_ref_100"><a href="#sec-runtime-semantics-stringdecimalvalue">StringDecimalValue</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-StrUnsignedDecimalLiteral">StrUnsignedDecimalLiteral</a></emu-nt>.</li><li>If <var>a</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>-∞</emu-val><sub>𝔻</sub>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>a</var> is <emu-xref href="#dfn-decimal128-finite" id="_ref_101"><a href="#dfn-decimal128-finite">finite</a></emu-xref>.</li><li>If <var>a</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>−0</emu-val><sub>𝔻</sub>.</li><li>Return −<var>a</var>.</li></ol></emu-alg>
         <emu-grammar><emu-production name="StrUnsignedDecimalLiteral" type="regexp" collapsed="">
     <emu-nt><a href="https://tc39.es/ecma262/#prod-StrUnsignedDecimalLiteral">StrUnsignedDecimalLiteral</a></emu-nt> <emu-geq>:::</emu-geq> <emu-rhs a="sv6n-gkb"><emu-t>Infinity</emu-t></emu-rhs>
 </emu-production>
@@ -3435,7 +3437,7 @@ <h1><span class="secnum">1.2.1.1</span> Runtime Semantics: StringDecimalValue</h
     </emu-rhs>
 </emu-production>
 </emu-grammar>
-        <emu-alg><ol><li>Let <var>a</var> be <emu-xref aoid="MV" id="_ref_74"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of the first <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li><li>If the second <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt> is present, then<ol><li>Let <var>b</var> be <emu-xref aoid="MV" id="_ref_75"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of the second <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li><li>Let <var>n</var> be the number of code points in the second <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li></ol></li><li>Else,<ol><li>Let <var>b</var> be 0.</li><li>Let <var>n</var> be 0.</li></ol></li><li>If <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> is present, let <var>e</var> be <emu-xref aoid="MV" id="_ref_76"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt>. Otherwise, let <var>e</var> be 0.</li><li>Return <emu-xref aoid="RoundToDecimal128Domain" id="_ref_77"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>((<var>a</var> + (<var>b</var> × 10<sup>−<var>n</var></sup>)) × 10<sup><var>e</var></sup>).</li></ol></emu-alg>
+        <emu-alg><ol><li>Let <var>a</var> be <emu-xref aoid="MV" id="_ref_102"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of the first <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li><li>If the second <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt> is present, then<ol><li>Let <var>b</var> be <emu-xref aoid="MV" id="_ref_103"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of the second <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li><li>Let <var>n</var> be the number of code points in the second <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li></ol></li><li>Else,<ol><li>Let <var>b</var> be 0.</li><li>Let <var>n</var> be 0.</li></ol></li><li>If <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> is present, let <var>e</var> be <emu-xref aoid="MV" id="_ref_104"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt>. Otherwise, let <var>e</var> be 0.</li><li>Return <emu-xref aoid="RoundToDecimal128Domain" id="_ref_105"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>((<var>a</var> + (<var>b</var> × 10<sup>−<var>n</var></sup>)) × 10<sup><var>e</var></sup>).</li></ol></emu-alg>
         <emu-grammar><emu-production name="StrUnsignedDecimalLiteral" type="regexp" collapsed="">
     <emu-nt><a href="https://tc39.es/ecma262/#prod-StrUnsignedDecimalLiteral">StrUnsignedDecimalLiteral</a></emu-nt> <emu-geq>:::</emu-geq> <emu-rhs a="xpoqnclz">
         <emu-t>.</emu-t>
@@ -3444,7 +3446,7 @@ <h1><span class="secnum">1.2.1.1</span> Runtime Semantics: StringDecimalValue</h
     </emu-rhs>
 </emu-production>
 </emu-grammar>
-        <emu-alg><ol><li>Let <var>b</var> be <emu-xref aoid="MV" id="_ref_78"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li><li>If <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> is present, let <var>e</var> be <emu-xref aoid="MV" id="_ref_79"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt>. Otherwise, let <var>e</var> be 0.</li><li>Let <var>n</var> be the number of code points in <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li><li>Let <var>newValue</var> be <var>b</var> × 10<sup><var>e</var> − <var>n</var></sup>.</li><li>Return <emu-xref aoid="RoundToDecimal128Domain" id="_ref_80"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>newValue</var>).</li></ol></emu-alg>
+        <emu-alg><ol><li>Let <var>b</var> be <emu-xref aoid="MV" id="_ref_106"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li><li>If <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> is present, let <var>e</var> be <emu-xref aoid="MV" id="_ref_107"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt>. Otherwise, let <var>e</var> be 0.</li><li>Let <var>n</var> be the number of code points in <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li><li>Let <var>newValue</var> be <var>b</var> × 10<sup><var>e</var> − <var>n</var></sup>.</li><li>Return <emu-xref aoid="RoundToDecimal128Domain" id="_ref_108"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>newValue</var>).</li></ol></emu-alg>
         <emu-grammar><emu-production name="StrUnsignedDecimalLiteral" type="regexp" collapsed="">
     <emu-nt><a href="https://tc39.es/ecma262/#prod-StrUnsignedDecimalLiteral">StrUnsignedDecimalLiteral</a></emu-nt> <emu-geq>:::</emu-geq> <emu-rhs a="joj696lw">
         <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>
@@ -3452,7 +3454,7 @@ <h1><span class="secnum">1.2.1.1</span> Runtime Semantics: StringDecimalValue</h
     </emu-rhs>
 </emu-production>
 </emu-grammar>
-        <emu-alg><ol><li>Let <var>a</var> be <emu-xref aoid="MV" id="_ref_81"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li><li>If <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> is present, let <var>e</var> be <emu-xref aoid="MV" id="_ref_82"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt>. Otherwise, let <var>e</var> be 0.</li><li>Return <emu-xref aoid="RoundToDecimal128Domain" id="_ref_83"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>a</var> × 10<sup><var>e</var></sup>).</li></ol></emu-alg>
+        <emu-alg><ol><li>Let <var>a</var> be <emu-xref aoid="MV" id="_ref_109"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>.</li><li>If <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> is present, let <var>e</var> be <emu-xref aoid="MV" id="_ref_110"><a href="#dfn-decimal128-mv">MV</a></emu-xref> of <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt>. Otherwise, let <var>e</var> be 0.</li><li>Return <emu-xref aoid="RoundToDecimal128Domain" id="_ref_111"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>a</var> × 10<sup><var>e</var></sup>).</li></ol></emu-alg>
       </emu-clause>
     </emu-clause>
   </emu-clause>
@@ -3477,23 +3479,23 @@ <h1><span class="secnum">2.2</span> Decimal128.prototype.isFinite ( )</h1>
 
   <emu-clause id="sec-decimal128.prototype.exponent">
     <h1><span class="secnum">2.3</span> Decimal128.prototype.exponent ( )</h1>
-    <p>This method returns a Number value represents the <emu-xref href="#dfn-decimal128-exponent" id="_ref_0"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref>, which is the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>n</var> for which the current Decimal128 object, <var>v</var>, there exists a <emu-xref href="#decimal128-mathematical-value" id="_ref_84"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> <var>s</var> such that <var>v</var> = <var>s</var> × 10<sup><var>e</var></sup> and 1 ≤ <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>s</var>) &lt; 10. If the current Decimal128 object is infinite, it returns <emu-val>+∞</emu-val>. If the current Decimal128 object is a <emu-xref href="#dfn-decimal128-zero" id="_ref_85"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, it returns <emu-val>-∞</emu-val>.</p>
+    <p>This method returns a Number value represents the <emu-xref href="#dfn-decimal128-exponent" id="_ref_0"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref>, which is the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>n</var> for which the current Decimal128 object, <var>v</var>, there exists a <emu-xref href="#decimal128-mathematical-value" id="_ref_112"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> <var>s</var> such that <var>v</var> = <var>s</var> × 10<sup><var>e</var></sup> and 1 ≤ <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>s</var>) &lt; 10. If the current Decimal128 object is infinite, it returns <emu-val>+∞</emu-val>. If the current Decimal128 object is a <emu-xref href="#dfn-decimal128-zero" id="_ref_113"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, it returns <emu-val>-∞</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>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><sub>𝔽</sub>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>+∞</emu-val><sub>𝔽</sub>.</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-val>-∞</emu-val><sub>𝔽</sub>.</li><li>Let <var>e</var> be the unique <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> for which there exists a <emu-xref href="#decimal128-mathematical-value" id="_ref_86"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> <var>s</var> such that <var>d</var> = <var>s</var> × 10<sup><var>e</var></sup> and 1 ≤ <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>s</var>) &lt; 10.</li><li>Return <emu-xref aoid="𝔽"><a href="https://tc39.es/ecma262/#𝔽">𝔽</a></emu-xref>(<var>e</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>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><sub>𝔽</sub>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>+∞</emu-val><sub>𝔽</sub>.</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-val>-∞</emu-val><sub>𝔽</sub>.</li><li>Let <var>e</var> be the unique <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> for which there exists a <emu-xref href="#decimal128-mathematical-value" id="_ref_114"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> <var>s</var> such that <var>d</var> = <var>s</var> × 10<sup><var>e</var></sup> and 1 ≤ <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>s</var>) &lt; 10.</li><li>Return <emu-xref aoid="𝔽"><a href="https://tc39.es/ecma262/#𝔽">𝔽</a></emu-xref>(<var>e</var>).</li></ol></emu-alg>
   </emu-clause>
 
   <emu-clause id="sec-decimal128.prototype.mantissa">
     <h1><span class="secnum">2.4</span> Decimal128.prototype.mantissa ( )</h1>
-    <p>This method returns a Decimal128 value representing the <emu-xref href="#dfn-decimal128-significand" id="_ref_1"><a href="#dfn-decimal128-significand">significand</a></emu-xref> of the current Decimal128 object, which is the <emu-xref href="#decimal128-mathematical-value" id="_ref_87"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> <var>n</var> for which the current Decimal128 object, <var>v</var>, there exists an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>e</var> such such that <var>v</var> = <var>s</var> × 10<sup><var>e</var></sup> and 1 ≤ <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>s</var>) &lt; 10. IF the current Decimal128 object is a <emu-xref href="#dfn-decimal128-zero" id="_ref_88"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, it returns a <emu-xref href="#dfn-decimal128-zero" id="_ref_89"><a href="#dfn-decimal128-zero">zero</a></emu-xref>.</p>
+    <p>This method returns a <emu-xref href="#def-decimal128-value" id="_ref_115"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref> representing the <emu-xref href="#dfn-decimal128-significand" id="_ref_1"><a href="#dfn-decimal128-significand">significand</a></emu-xref> of the current Decimal128 object, which is the <emu-xref href="#decimal128-mathematical-value" id="_ref_116"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> <var>s</var> for which the current Decimal128 object, <var>v</var>, there exists an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>e</var> such such that <var>v</var> = <var>s</var> × 10<sup><var>e</var></sup> and 1 ≤ <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>s</var>) &lt; 10. If the current Decimal128 object is a <emu-xref href="#dfn-decimal128-zero" id="_ref_117"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, it returns a <emu-xref href="#dfn-decimal128-zero" id="_ref_118"><a href="#dfn-decimal128-zero">zero</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>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_90"><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> or <emu-val>-∞</emu-val><sub>𝔻</sub>, 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><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_92"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>−0</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>-0</emu-val><sub>𝔻</sub>).</li><li>Let <var>e</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_94"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> of <var>d</var>.</li><li>Let <var>s</var> be the unique <emu-xref href="#decimal128-mathematical-value" id="_ref_95"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> such that <var>d</var> = <var>s</var> × 10<sup><var>e</var></sup> and 1 ≤ <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>s</var>) &lt; 10.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_96"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>s</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>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_119"><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> or <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>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_121"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_122"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-0</emu-val><sub>𝔻</sub>).</li><li>Let <var>s</var> be the unique <emu-xref href="#decimal128-mathematical-value" id="_ref_123"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> such that <var>d</var> = <var>s</var> × 10<sup><var>e</var></sup> and 1 ≤ <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>s</var>) &lt; 10.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_124"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>s</var>).</li></ol></emu-alg>
   </emu-clause>
 
   <emu-clause id="sec-decimal128.prototype.abs">
     <h1><span class="secnum">2.5</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>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_97"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="Decimal128Abs" id="_ref_98"><a href="#sec-decimal128-abs">Decimal128Abs</a></emu-xref>(<var>d</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>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_125"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="Decimal128Abs" id="_ref_126"><a href="#sec-decimal128-abs">Decimal128Abs</a></emu-xref>(<var>d</var>)).</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>
@@ -3501,9 +3503,9 @@ <h1><span class="secnum">2.5</span> Decimal128.prototype.abs ( )</h1>
 
   <emu-clause id="sec-decimal128.prototype.negate">
     <h1><span class="secnum">2.6</span> Decimal128.prototype.negate ( )</h1>
-    <p>This method inverts the <emu-xref aoid="sign" id="_ref_99"><a href="#dfn-decimal128-sign">sign</a></emu-xref> of a Decimal128 object.</p>
+    <p>This method inverts the <emu-xref aoid="sign" id="_ref_127"><a href="#dfn-decimal128-sign">sign</a></emu-xref> 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>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_100"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="Decimal128Negate" id="_ref_101"><a href="#sec-decimal128-negate">Decimal128Negate</a></emu-xref>(<var>d</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>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_128"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="Decimal128Negate" id="_ref_129"><a href="#sec-decimal128-negate">Decimal128Negate</a></emu-xref>(<var>d</var>)).</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>
@@ -3513,7 +3515,7 @@ <h1><span class="secnum">2.6</span> Decimal128.prototype.negate ( )</h1>
     <h1><span class="secnum">2.7</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.</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_102"><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 <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub> or <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>NaN</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>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub> or <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>d1</var> is not <emu-val>+∞</emu-val><sub>𝔻</sub> and <var>d2</var> is not <emu-val>+∞</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>If <var>d1</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_106"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d2</var>).</li><li>If <var>d2</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_107"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d1</var>).</li><li>If <var>d1</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, set <var>d1</var> to 0.</li><li>If <var>d2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, set <var>d2</var> to 0.</li><li>Let <var>sum</var> be <var>d1</var> + <var>d2</var>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_108"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_109"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>sum</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>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_130"><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 <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub> or <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_131"><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_132"><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> or <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>d1</var> is not <emu-val>+∞</emu-val><sub>𝔻</sub> and <var>d2</var> is not <emu-val>+∞</emu-val><sub>𝔻</sub>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_133"><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>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_134"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d2</var>).</li><li>If <var>d2</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_135"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d1</var>).</li><li>If <var>d1</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, set <var>d1</var> to 0.</li><li>If <var>d2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, set <var>d2</var> to 0.</li><li>Let <var>sum</var> be <var>d1</var> + <var>d2</var>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_136"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_137"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>sum</var>)).</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>
@@ -3523,7 +3525,7 @@ <h1><span class="secnum">2.7</span> Decimal128.prototype.add ( <var>x</var> )</h
     <h1><span class="secnum">2.8</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.</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_110"><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>, then<ol><li>If <var>d2</var> is <var>d1</var>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_111"><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_112"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d1</var>).</li></ol></li><li>If <var>d2</var> is <emu-val>+∞</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>-∞</emu-val><sub>𝔻</sub>).</li><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>d1</var> is <emu-val>−0</emu-val><sub>𝔻</sub> and <var>d2</var> is <emu-val>+0</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>−0</emu-val><sub>𝔻</sub>)).</li><li>If <var>d1</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, set <var>d1</var> to 0.</li><li>If <var>d2</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, set <var>d2</var> to 0.</li><li>Let <var>difference</var> be <var>d1</var> − <var>d2</var>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_116"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_117"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>difference</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>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_138"><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>, then<ol><li>If <var>d2</var> is <var>d1</var>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_139"><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_140"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d1</var>).</li></ol></li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_141"><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_142"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>−0</emu-val><sub>𝔻</sub> and <var>d2</var> is <emu-val>+0</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>−0</emu-val><sub>𝔻</sub>)).</li><li>If <var>d1</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, set <var>d1</var> to 0.</li><li>If <var>d2</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, set <var>d2</var> to 0.</li><li>Let <var>difference</var> be <var>d1</var> − <var>d2</var>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_144"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_145"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>difference</var>)).</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>
@@ -3533,7 +3535,7 @@ <h1><span class="secnum">2.8</span> Decimal128.prototype.subtract ( <var>x</var>
     <h1><span class="secnum">2.9</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.</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_118"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d1</var> or <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_119"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_120"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <emu-xref aoid="sign" id="_ref_121"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1 or <emu-xref aoid="sign" id="_ref_122"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_123"><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_124"><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> or <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d1</var> or <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_125"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_126"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <emu-xref aoid="sign" id="_ref_127"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1 and <emu-xref aoid="sign" id="_ref_128"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_129"><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_130"><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> or <var>d2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, then<ol><li>If <emu-xref aoid="sign" id="_ref_131"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1 or <emu-xref aoid="sign" id="_ref_132"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_133"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_134"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> or <var>d2</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, then<ol><li>If <emu-xref aoid="sign" id="_ref_135"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1 and <emu-xref aoid="sign" id="_ref_136"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_137"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>_).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_138"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>product</var> be <var>d1</var> × <var>d2</var>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>product</var> ≠ 0.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_139"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_140"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>product</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>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_146"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d1</var> or <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_147"><a href="#dfn-decimal128-zero">zero</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_148"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_149"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <emu-xref aoid="sign" id="_ref_150"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1 or <emu-xref aoid="sign" id="_ref_151"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_152"><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_153"><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> or <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d1</var> or <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_154"><a href="#dfn-decimal128-zero">zero</a></emu-xref> <emu-xref href="#def-decimal128-value" id="_ref_155"><a href="#def-decimal128-value">Decimal128 value</a></emu-xref>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_156"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <emu-xref aoid="sign" id="_ref_157"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1 and <emu-xref aoid="sign" id="_ref_158"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_159"><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_160"><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> or <var>d2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, then<ol><li>If <emu-xref aoid="sign" id="_ref_161"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1 or <emu-xref aoid="sign" id="_ref_162"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_163"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_164"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> or <var>d2</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, then<ol><li>If <emu-xref aoid="sign" id="_ref_165"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1 and <emu-xref aoid="sign" id="_ref_166"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_167"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>_).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_168"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>product</var> be <var>d1</var> × <var>d2</var>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>product</var> ≠ 0.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_169"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_170"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>product</var>)).</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>
@@ -3543,7 +3545,7 @@ <h1><span class="secnum">2.9</span> Decimal128.prototype.multiply ( <var>x</var>
     <h1><span class="secnum">2.10</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.</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_141"><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> or <emu-val>-∞</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 <emu-xref aoid="sign" id="_ref_143"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_144"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_145"><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> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_146"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <emu-xref aoid="sign" id="_ref_147"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_148"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_149"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <emu-xref aoid="sign" id="_ref_150"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_151"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_152"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <emu-xref aoid="sign" id="_ref_153"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_154"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_155"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d1</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_156"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_157"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_158"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d2</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d1</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_159"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_160"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_161"><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>+0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_162"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_163"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_164"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_165"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>quotient</var> be <var>d1</var> / <var>d2</var>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_166"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_167"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>quotient</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>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_171"><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> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_172"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <emu-xref aoid="sign" id="_ref_173"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_174"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_175"><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> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_176"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <emu-xref aoid="sign" id="_ref_177"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d2</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_178"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_179"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <emu-xref aoid="sign" id="_ref_180"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_181"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_182"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <emu-xref aoid="sign" id="_ref_183"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d1</var>) = -1, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_184"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_185"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d1</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_186"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_187"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_188"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d2</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d1</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_189"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_190"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_191"><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>+0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_192"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_193"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_194"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_195"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>quotient</var> be <var>d1</var> / <var>d2</var>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_196"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_197"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>quotient</var>)).</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>
@@ -3553,7 +3555,7 @@ <h1><span class="secnum">2.10</span> Decimal128.prototype.divide ( <var>x</var>
     <h1><span class="secnum">2.11</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.</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_168"><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_169"><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_170"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d1</var>).</li><li>If <var>d2</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_171"><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>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_172"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d1</var>).</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>d2</var> ≠ 0.</li><li>Let <var>quotient</var> be <var>d1</var> / <var>d2</var>.</li><li>Let <var>q</var> be <emu-xref aoid="truncate"><a href="https://tc39.es/ecma262/#eqn-truncate">truncate</a></emu-xref>(<var>quotient</var>).</li><li>Let <var>r</var> be <var>d1</var> - (<var>d2</var> × <var>q</var>).</li><li>If <var>r</var> = 0, and <var>d1</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_173"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔽</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_174"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>r</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>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_198"><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_199"><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_200"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d1</var>).</li><li>If <var>d2</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_201"><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>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_202"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d1</var>).</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>d2</var> ≠ 0.</li><li>Let <var>quotient</var> be <var>d1</var> / <var>d2</var>.</li><li>Let <var>q</var> be <emu-xref aoid="truncate"><a href="https://tc39.es/ecma262/#eqn-truncate">truncate</a></emu-xref>(<var>quotient</var>).</li><li>Let <var>r</var> be <var>d1</var> - (<var>d2</var> × <var>q</var>).</li><li>If <var>r</var> = 0, and <var>d1</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_203"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_204"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>r</var>).</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>
@@ -3563,7 +3565,7 @@ <h1><span class="secnum">2.11</span> Decimal128.prototype.remainder ( <var>x</va
     <h1><span class="secnum">2.12</span> Decimal128.prototype.compare ( <var>x</var> )</h1>
     <p>This method returns one of the four Number values <emu-val>-1</emu-val><sub>𝔽</sub>, <emu-val>+0</emu-val><sub>𝔽</sub>, <emu-val>1</emu-val><sub>𝔽</sub>, and <emu-val>NaN</emu-val><sub>𝔽</sub>. It compares the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> the current Decimal128 object with that of 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> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>NaN</emu-val><sub>𝔽</sub>.</li><li>If <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <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-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 <emu-xref aoid="MV" id="_ref_175"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) &lt; <emu-xref aoid="MV" id="_ref_176"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>-1</emu-val><sub>𝔽</sub>.</li><li>If <emu-xref aoid="MV" id="_ref_177"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>) &lt; <emu-xref aoid="MV" id="_ref_178"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>), return <emu-val>1</emu-val><sub>𝔽</sub>.</li><li>Otherwise, return <emu-val>+0</emu-val><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>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>, return <emu-val>NaN</emu-val><sub>𝔽</sub>.</li><li>If <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <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-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 <emu-xref aoid="MV" id="_ref_205"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) &lt; <emu-xref aoid="MV" id="_ref_206"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>-1</emu-val><sub>𝔽</sub>.</li><li>If <emu-xref aoid="MV" id="_ref_207"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>) &lt; <emu-xref aoid="MV" id="_ref_208"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>), return <emu-val>1</emu-val><sub>𝔽</sub>.</li><li>Otherwise, return <emu-val>+0</emu-val><sub>𝔽</sub>.</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation combines the <code>compareQuietEqual</code>, <code>compareQuietLess</code> operations 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>
@@ -3571,9 +3573,9 @@ <h1><span class="secnum">2.12</span> Decimal128.prototype.compare ( <var>x</var>
 
   <emu-clause id="sec-decimal128.prototype.equals">
     <h1><span class="secnum">2.13</span> Decimal128.prototype.equals ( <var>x</var> )</h1>
-    <p>This method returns either <emu-val>true</emu-val>, <emu-val>false</emu-val>, or <emu-val>undefined</emu-val> according as the current Decimal128 object has the same <emu-xref href="#decimal128-mathematical-value" id="_ref_179"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> as the given Decimal128 object. The value <emu-val>undefined</emu-val> is returned if the current Decimal128 object or the argument is a NaN.</p>
+    <p>This method returns either <emu-val>true</emu-val> or <emu-val>false</emu-val> according as the current Decimal128 object has the same <emu-xref href="#decimal128-mathematical-value" id="_ref_209"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> as the given Decimal128 object. The value <emu-val>false</emu-val> is returned if the current Decimal128 object or the argument is a NaN.</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>, return <emu-val>undefined</emu-val>.</li><li>If <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>undefined</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>true</emu-val>.</li><li>Otherwise, 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>Otherwise, return <emu-val>false</emu-val>.</li></ol></li><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>If <emu-xref aoid="MV" id="_ref_180"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) = <emu-xref aoid="MV" id="_ref_181"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</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> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</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>true</emu-val>.</li><li>Otherwise, 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>Otherwise, return <emu-val>false</emu-val>.</li></ol></li><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>If <emu-xref aoid="MV" id="_ref_210"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) = <emu-xref aoid="MV" id="_ref_211"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation corresponds to the <code>compareQuietEqual</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>
@@ -3581,9 +3583,9 @@ <h1><span class="secnum">2.13</span> Decimal128.prototype.equals ( <var>x</var>
 
   <emu-clause id="sec-decimal128.prototype.notequals">
     <h1><span class="secnum">2.14</span> Decimal128.prototype.notEquals ( <var>x</var> )</h1>
-    <p>This method returns either <emu-val>true</emu-val>, <emu-val>false</emu-val>, or <emu-val>undefined</emu-val> according as the current Decimal128 object has a different <emu-xref href="#decimal128-mathematical-value" id="_ref_182"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> as the given Decimal128 object. The value <emu-val>undefined</emu-val> is returned if the current Decimal128 object or the argument is a NaN.</p>
+    <p>This method returns either <emu-val>true</emu-val> or <emu-val>false</emu-val> according as the current Decimal128 object has a strictly smaller <emu-xref href="#decimal128-mathematical-value" id="_ref_212"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> as that of the given Decimal128 object. The value <emu-val>false</emu-val> is returned if either the current Decimal128 object or the argument is a NaN.</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>, return <emu-val>undefined</emu-val>.</li><li>If <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>undefined</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>false</emu-val>.</li><li>Otherwise, 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>Otherwise, return <emu-val>true</emu-val>.</li></ol></li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <emu-xref aoid="MV" id="_ref_183"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) ≠ <emu-xref aoid="MV" id="_ref_184"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</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> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</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>false</emu-val>.</li><li>Otherwise, 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>Otherwise, return <emu-val>true</emu-val>.</li></ol></li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <emu-xref aoid="MV" id="_ref_213"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) ≠ <emu-xref aoid="MV" id="_ref_214"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation corresponds to the <code>compareQuietNotEqual</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>
@@ -3591,9 +3593,9 @@ <h1><span class="secnum">2.14</span> Decimal128.prototype.notEquals ( <var>x</va
 
   <emu-clause id="sec-decimal128.prototype.lessthan">
     <h1><span class="secnum">2.15</span> Decimal128.prototype.lessThan ( <var>x</var> )</h1>
-    <p>This method returns either <emu-val>true</emu-val>, <emu-val>false</emu-val> according as the current Decimal128 object has the same <emu-xref href="#decimal128-mathematical-value" id="_ref_185"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> as the given Decimal128 object. The value <emu-val>false</emu-val> is returned if the current Decimal128 object or the argument is a NaN.</p>
+    <p>This method returns either <emu-val>true</emu-val> or <emu-val>false</emu-val> according as the current Decimal128 object has the same <emu-xref href="#decimal128-mathematical-value" id="_ref_215"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> as the given Decimal128 object. The value <emu-val>false</emu-val> is returned if the current Decimal128 object or the argument is a NaN.</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>, return <emu-val>false</emu-val>.</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>, 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>false</emu-val>.</li><li>Otherwise, return <emu-val>true</emu-val>.</li></ol></li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <emu-xref aoid="MV" id="_ref_186"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) &lt; <emu-xref aoid="MV" id="_ref_187"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</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> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</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>, 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>false</emu-val>.</li><li>Otherwise, return <emu-val>true</emu-val>.</li></ol></li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <emu-xref aoid="MV" id="_ref_216"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) &lt; <emu-xref aoid="MV" id="_ref_217"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation corresponds to the <code>compareQuietEqual</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>
@@ -3601,9 +3603,9 @@ <h1><span class="secnum">2.15</span> Decimal128.prototype.lessThan ( <var>x</var
 
   <emu-clause id="sec-decimal128.prototype.lessthanorequal">
     <h1><span class="secnum">2.16</span> Decimal128.prototype.lessThanOrEqual ( <var>x</var> )</h1>
-    <p>This method returns either <emu-val>true</emu-val>, <emu-val>false</emu-val>, or <emu-val>undefined</emu-val> according as the current Decimal128 object has the same or smaller <emu-xref href="#decimal128-mathematical-value" id="_ref_188"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> as the given Decimal128 object. The value <emu-val>false</emu-val> is returned if the current Decimal128 object or the argument is a NaN.</p>
+    <p>This method returns either <emu-val>true</emu-val>, <emu-val>false</emu-val>, or <emu-val>undefined</emu-val> according as the current Decimal128 object has the same or smaller <emu-xref href="#decimal128-mathematical-value" id="_ref_218"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> as the given Decimal128 object. The value <emu-val>false</emu-val> is returned if the current Decimal128 object or the argument is a NaN.</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>, return <emu-val>false</emu-val>.</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>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <emu-xref aoid="MV" id="_ref_189"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) ≤ <emu-xref aoid="MV" id="_ref_190"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</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> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</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>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <emu-xref aoid="MV" id="_ref_219"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) ≤ <emu-xref aoid="MV" id="_ref_220"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation corresponds to the <code>compareQuietLessEqual</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>
@@ -3611,9 +3613,9 @@ <h1><span class="secnum">2.16</span> Decimal128.prototype.lessThanOrEqual ( <var
 
   <emu-clause id="sec-decimal128.prototype.greaterthan">
     <h1><span class="secnum">2.17</span> Decimal128.prototype.greaterThan ( <var>x</var> )</h1>
-    <p>This method returns either <emu-val>true</emu-val>, <emu-val>false</emu-val> according as the current Decimal128 object has a greater <emu-xref href="#decimal128-mathematical-value" id="_ref_191"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> as the given Decimal128 object. The value <emu-val>false</emu-val> is returned if either the current Decimal128 object or the argument is a NaN.</p>
+    <p>This method returns either <emu-val>true</emu-val>, <emu-val>false</emu-val> according as the current Decimal128 object has a greater <emu-xref href="#decimal128-mathematical-value" id="_ref_221"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref> as the given Decimal128 object. The value <emu-val>false</emu-val> is returned if either the current Decimal128 object or the argument is a NaN.</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>, return <emu-val>false</emu-val>.</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>false</emu-val>.</li><li>Otherwise, return <emu-val>true</emu-val>.</li></ol></li><li>If <var>d1</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>false</emu-val>.</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <emu-xref aoid="MV" id="_ref_192"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) &gt; <emu-xref aoid="MV" id="_ref_193"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</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> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</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>false</emu-val>.</li><li>Otherwise, return <emu-val>true</emu-val>.</li></ol></li><li>If <var>d1</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>false</emu-val>.</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <emu-xref aoid="MV" id="_ref_222"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) &gt; <emu-xref aoid="MV" id="_ref_223"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation corresponds to the <code>compareQuietGreater</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>
@@ -3623,7 +3625,7 @@ <h1><span class="secnum">2.17</span> Decimal128.prototype.greaterThan ( <var>x</
     <h1><span class="secnum">2.18</span> Decimal128.prototype.greaterThanOrEqual ( <var>x</var> )</h1>
     <p>This method returns either <emu-val>true</emu-val>, <emu-val>false</emu-val><emu-val> according as the current Decimal128 object has a greater or equal mathematical value as the given Decimal128 object. The value *false</emu-val> is returned if the current Decimal128 object or the argument is a NaN.</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>, return <emu-val>false</emu-val>.</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>, return <emu-val>true</emu-val>.</li><li>If <var>d1</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>false</emu-val>.</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <emu-xref aoid="MV" id="_ref_194"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) ≥ <emu-xref aoid="MV" id="_ref_195"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</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> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</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>, return <emu-val>true</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>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></li><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>If <emu-xref aoid="MV" id="_ref_224"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d1</var>) ≥ <emu-xref aoid="MV" id="_ref_225"><a href="#dfn-decimal128-mv">MV</a></emu-xref>(<var>d2</var>), return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation corresponds to the <code>compareQuietGreaterEqual</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>
@@ -3633,7 +3635,7 @@ <h1><span class="secnum">2.18</span> Decimal128.prototype.greaterThanOrEqual ( <
     <h1><span class="secnum">2.19</span> Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )</h1>
     <p>This method rounds the current Decimal128 object according to the specified rounding mode, 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-negative <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>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>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> 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 rounding mode, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is one of « <emu-val>NaN</emu-val><sub>𝔻</sub>, <emu-val>+∞</emu-val><sub>𝔻</sub>, <emu-val>-∞</emu-val><sub>𝔻</sub>&nbsp;» return <emu-xref aoid="Decimal128ValueToObject" id="_ref_196"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_197"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li><li>Let <var>sign</var> be <emu-xref aoid="sign" id="_ref_198"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d</var>).</li><li>Let <var>scaledV</var> be <var>d</var> × 10<sup><emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>numFractionalDigits</var>)</sup>.</li><li>If <var>sign</var> = -1, then<ol><li>Set <var>scaledV</var> to −<var>scaledV</var>.</li><li>If <var>roundingMode</var> is <emu-val>"floor"</emu-val>, set <var>roundingMode</var> to <emu-val>"ceil"</emu-val>.</li><li>Else if <var>roundingMode</var> is <emu-val>"ceil"</emu-val>, set <var>roundingMode</var> to <emu-val>"floor"</emu-val>.</li></ol></li><li>Let <var>roundedScaledV</var> be <emu-xref aoid="ApplyRoundingModeToPositive" id="_ref_199"><a href="#sec-decimal128-applyroundingmodetopositive">ApplyRoundingModeToPositive</a></emu-xref>(<var>scaledV</var>, <var>roundingMode</var>).</li><li>If <var>sign</var> = -1, set <var>roundedScaledV</var> to −<var>roundedScaledV</var>.</li><li>Let <var>rescaledRoundedV</var> be <var>roundedScaledV</var> × 10<sup>−<var>numFractionalDigits</var></sup>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_200"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_201"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>rescaledRoundedV</var>, <var>roundingMode</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>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> 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 rounding mode, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is one of « <emu-val>NaN</emu-val><sub>𝔻</sub>, <emu-val>+∞</emu-val><sub>𝔻</sub>, <emu-val>-∞</emu-val><sub>𝔻</sub>&nbsp;» return <emu-xref aoid="Decimal128ValueToObject" id="_ref_226"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_227"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li><li>Let <var>sign</var> be <emu-xref aoid="sign" id="_ref_228"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d</var>).</li><li>Let <var>scaledV</var> be <var>d</var> × 10<sup><emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>numFractionalDigits</var>)</sup>.</li><li>If <var>sign</var> = -1, then<ol><li>Set <var>scaledV</var> to −<var>scaledV</var>.</li><li>If <var>roundingMode</var> is <emu-val>"floor"</emu-val>, set <var>roundingMode</var> to <emu-val>"ceil"</emu-val>.</li><li>Else if <var>roundingMode</var> is <emu-val>"ceil"</emu-val>, set <var>roundingMode</var> to <emu-val>"floor"</emu-val>.</li></ol></li><li>Let <var>roundedScaledV</var> be <emu-xref aoid="ApplyRoundingModeToPositive" id="_ref_229"><a href="#sec-decimal128-applyroundingmodetopositive">ApplyRoundingModeToPositive</a></emu-xref>(<var>scaledV</var>, <var>roundingMode</var>).</li><li>If <var>sign</var> = -1, set <var>roundedScaledV</var> to −<var>roundedScaledV</var>.</li><li>Let <var>rescaledRoundedV</var> be <var>roundedScaledV</var> × 10<sup><emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(−<var>numFractionalDigits</var>)</sup>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_230"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_231"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>rescaledRoundedV</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 rounding mode 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>
@@ -3643,7 +3645,7 @@ <h1><span class="secnum">2.19</span> Decimal128.prototype.round ( <var>numFracti
     <h1><span class="secnum">2.20</span> Decimal128.prototype.scale10 ( <var>n</var> )</h1>
     <p>This method multiplies the current Decimal128 object by 10 raised to the given power.</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>n</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>n</var> is not one of « <emu-val>NaN</emu-val><sub>𝔽</sub>, <emu-val>+∞</emu-val><sub>𝔽</sub>, <emu-val>-∞</emu-val><sub>𝔽</sub>&nbsp;», then<ol><li>If <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>n</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></ol></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>, <emu-val>+∞</emu-val><sub>𝔻</sub>, or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_202"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li><li>If <var>d</var> is either <emu-val>+0</emu-val><sub>𝔻</sub> nor <emu-val>−0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>n</var> is <emu-val>NaN</emu-val><sub>𝔽</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_203"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li><li>If <var>n</var> is <emu-val>+∞</emu-val><sub>𝔽</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_204"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li><li>If <var>n</var> is <emu-val>-∞</emu-val><sub>𝔽</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_205"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_206"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li></ol></li><li>If <var>n</var> is <emu-val>NaN</emu-val><sub>𝔽</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_207"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>n</var> is <emu-val>+∞</emu-val><sub>𝔽</sub>, then<ol><li>If <var>d</var> &gt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_208"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_209"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>n</var> is <emu-val>-∞</emu-val><sub>𝔽</sub>, then<ol><li>If <var>d</var> &gt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_210"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_211"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>w</var> be v × 10<sup><emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>n</var>)</sup>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_212"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_213"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>w</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>n</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>n</var> is not one of « <emu-val>NaN</emu-val><sub>𝔽</sub>, <emu-val>+∞</emu-val><sub>𝔽</sub>, <emu-val>-∞</emu-val><sub>𝔽</sub>&nbsp;», then<ol><li>If <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>n</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></ol></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>, <emu-val>+∞</emu-val><sub>𝔻</sub>, or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_232"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li><li>If <var>d</var> is either <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_233"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>d</var>).</li><li>If <var>n</var> is <emu-val>NaN</emu-val><sub>𝔽</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_234"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>n</var> is <emu-val>+∞</emu-val><sub>𝔽</sub>, then<ol><li>If <var>d</var> &gt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_235"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_236"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>n</var> is <emu-val>-∞</emu-val><sub>𝔽</sub>, then<ol><li>If <var>d</var> &gt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_237"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+0</emu-val><sub>𝔻</sub>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_238"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>−0</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>w</var> be <var>d</var> × 10<sup><emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>n</var>)</sup>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_239"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="RoundToDecimal128Domain" id="_ref_240"><a href="#sec-decimal128-roundtodecimal128domain">RoundToDecimal128Domain</a></emu-xref>(<var>w</var>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification of the <code>scaleB</code> operation discussed in Section 5.3.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>
@@ -3653,7 +3655,7 @@ <h1><span class="secnum">2.20</span> Decimal128.prototype.scale10 ( <var>n</var>
     <h1><span class="secnum">2.21</span> Decimal128.prototype.toString ( [ <var>options</var> ] )</h1>
     <p>This method generates a String representation of the current Decimal128 object, in decimal format. Its behaviour is similar to that of Number’s <emu-xref href="#sec-number.prototype.tostring"><a href="https://tc39.es/ecma262/#sec-number.prototype.tostring">toString</a></emu-xref> by rendering the decimal in decimal notation, but will use exponential notation if the the magnitude of the number is less than 10<sup>-6</sup> or greater than 10<sup>34</sup>.</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>options</var> is not <emu-val>undefined</emu-val>, then<ol><li>If <var>options</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is not an Object</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li></ol></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 "NaN".</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return "Infinity".</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return "-Infinity".</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>d</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>If <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>d</var>) &lt; 10<sup>-6</sup> or <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>d</var>) ≥ 10<sup>34</sup>, return return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_214"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>O</var>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_215"><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>If <var>options</var> is not <emu-val>undefined</emu-val>, then<ol><li>If <var>options</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is not an Object</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li></ol></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 "NaN".</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return "Infinity".</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return "-Infinity".</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>d</var> is <emu-val>−0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>If <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>d</var>) &lt; 10<sup>-6</sup> or <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>d</var>) ≥ 10<sup>34</sup>, return return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_241"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>O</var>).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_242"><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 <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> 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>
@@ -3670,7 +3672,7 @@ <h1><span class="secnum">2.22</span> Decimal128.prototype.toLocaleString ( [ <va
     <h1><span class="secnum">2.23</span> Decimal128.prototype.toExponential ( [ <var>options</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>options</var> is not <emu-val>undefined</emu-val>, then<ol><li>If <var>options</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is not an Object</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li></ol></li><li>Return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_216"><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>options</var> is not <emu-val>undefined</emu-val>, then<ol><li>If <var>options</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is not an Object</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li></ol></li><li>Return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_243"><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 <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> 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>
@@ -3680,7 +3682,7 @@ <h1><span class="secnum">2.23</span> Decimal128.prototype.toExponential ( [ <var
     <h1><span class="secnum">2.24</span> Decimal128.prototype.toFixed ( [ <var>options</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>Let <var>numDigits</var> be <emu-val>+0</emu-val><sub>𝔽</sub>.</li><li>Let <var>roundingMode</var> be <emu-val>undefined</emu-val>.</li><li>If <var>options</var> is not <emu-val>undefined</emu-val>, then<ol><li>If <var>options</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is not an Object</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>Set <var>numDigits</var> to ?&nbsp;<emu-xref aoid="Get"><a href="https://tc39.es/ecma262/#sec-get-o-p">Get</a></emu-xref>(<var>options</var>, <emu-val>"digits"</emu-val>).</li><li>Set <var>roundingMode</var> to ?&nbsp;<emu-xref aoid="Get"><a href="https://tc39.es/ecma262/#sec-get-o-p">Get</a></emu-xref>(<var>options</var>, <emu-val>"roundingMode"</emu-val>).</li></ol></li><li>If <var>numDigits</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>numDigits</var> is <emu-val>NaN</emu-val><sub>𝔽</sub>, <emu-val>+∞</emu-val><sub>𝔽</sub>, or <emu-val>-∞</emu-val><sub>𝔽</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Set <var>numDigits</var> to <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>numDigits</var>).</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>roundingMode</var> is <emu-val>undefined</emu-val>, set <var>roundingMode</var> to <emu-val>"halfEven"</emu-val>.</li><li>Else if <var>roundingMode</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>Else if <var>roundingMode</var> is not a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_5"><a href="#dfn-decimal128-rounding-mode">Decimal128 rounding mode</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</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-val>"NaN"</emu-val>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infintiy"</emu-val>.</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infintiy"</emu-val>.</li><li>If <emu-xref aoid="sign" id="_ref_217"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d</var>) = 1, let <var>signPrefix</var> be <emu-val>""</emu-val>, else let <var>signPrefix</var> be <emu-val>"-"</emu-val>.</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>numDigits</var> = 0, then<ol><li>Return the concatenation of <var>signPrefix</var> and <emu-val>"0"</emu-val>.</li></ol></li><li>Otherwise:<ol><li>Let <var>trailingZeroes</var> be <emu-val>"0"</emu-val> repeated <var>numDigits</var> times.</li><li>Return the concatenation of _signPrefix, <emu-val>"0"</emu-val>, <emu-val>"."</emu-val>, and <var>trailingZeroes</var>.</li></ol></li></ol></li><li>Set <var>d</var> to <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>d</var>).</li><li>Let <var>scaledV</var> be <var>d</var> × 10<sup><var>numDigits</var></sup>.</li><li>Let <var>roundedScaledV</var> be <emu-xref aoid="ApplyRoundingModeToPositive" id="_ref_218"><a href="#sec-decimal128-applyroundingmodetopositive">ApplyRoundingModeToPositive</a></emu-xref>(<var>scaledV</var>, <var>roundingMode</var>).</li><li>Let <var>s</var> be the unique decimal string representation of <var>roundedScaledV</var> without leading zeroes.</li><li>Let <var>integerDigits</var> be <var>s</var>.</li><li>Let <var>nonIntegerDigits</var> be <emu-val>""</emu-val>.</li><li>If <var>s</var> contains an occurrence of <emu-val>"."</emu-val>, then<ol><li>Let <var>i</var> be the index of the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><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> from 0 to <var>i</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> from <var>i</var> + 1.</li></ol></li><li>If <var>numDigits</var> = 0, return <var>integerDigits</var>.</li><li>Let <var>numNonIntegerDigits</var> be the length of <var>nonIntegerDigits</var>.</li><li>If the <var>numNonIntegerDigits</var> &lt; <var>numDigits</var>, then<ol><li>Let <var>additionalZeroes</var> be the string <emu-val>"0"</emu-val> repeated <var>numDigits</var> - <var>numNonIntegerDigits</var> times.</li><li>Set <var>nonIntegerDigits</var> to the concatenation of <var>nonIntegerDigits</var> and <var>additionalZeroes</var>.</li></ol></li><li>Else if <var>numNonIntegerDigits</var> &gt; <var>numDigits</var>, then<ol><li>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>Return the concatenation of <var>signPrefix</var>, <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>Let <var>numDigits</var> be <emu-val>+0</emu-val><sub>𝔽</sub>.</li><li>Let <var>roundingMode</var> be <emu-val>undefined</emu-val>.</li><li>If <var>options</var> is not <emu-val>undefined</emu-val>, then<ol><li>If <var>options</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is not an Object</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>Set <var>numDigits</var> to ?&nbsp;<emu-xref aoid="Get"><a href="https://tc39.es/ecma262/#sec-get-o-p">Get</a></emu-xref>(<var>options</var>, <emu-val>"digits"</emu-val>).</li><li>Set <var>roundingMode</var> to ?&nbsp;<emu-xref aoid="Get"><a href="https://tc39.es/ecma262/#sec-get-o-p">Get</a></emu-xref>(<var>options</var>, <emu-val>"roundingMode"</emu-val>).</li></ol></li><li>If <var>numDigits</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>numDigits</var> is <emu-val>NaN</emu-val><sub>𝔽</sub>, <emu-val>+∞</emu-val><sub>𝔽</sub>, or <emu-val>-∞</emu-val><sub>𝔽</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Set <var>numDigits</var> to <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>numDigits</var>).</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>roundingMode</var> is <emu-val>undefined</emu-val>, set <var>roundingMode</var> to <emu-val>"halfEven"</emu-val>.</li><li>Else if <var>roundingMode</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>Else if <var>roundingMode</var> is not a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_5"><a href="#dfn-decimal128-rounding-mode">Decimal128 rounding mode</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</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-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>If <emu-xref aoid="sign" id="_ref_244"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d</var>) = 1, let <var>signPrefix</var> be <emu-val>""</emu-val>, else let <var>signPrefix</var> be <emu-val>"-"</emu-val>.</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>numDigits</var> = 0, then<ol><li>Return the concatenation of <var>signPrefix</var> and <emu-val>"0"</emu-val>.</li></ol></li><li>Otherwise:<ol><li>Let <var>trailingZeroes</var> be <emu-val>"0"</emu-val> repeated <var>numDigits</var> times.</li><li>Return the concatenation of <var>signPrefix</var>, <emu-val>"0"</emu-val>, <emu-val>"."</emu-val>, and <var>trailingZeroes</var>.</li></ol></li></ol></li><li>Set <var>d</var> to <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>d</var>).</li><li>Let <var>scaledV</var> be <var>d</var> × 10<sup><var>numDigits</var></sup>.</li><li>Let <var>roundedScaledV</var> be <emu-xref aoid="ApplyRoundingModeToPositive" id="_ref_245"><a href="#sec-decimal128-applyroundingmodetopositive">ApplyRoundingModeToPositive</a></emu-xref>(<var>scaledV</var>, <var>roundingMode</var>).</li><li>Let <var>remainder</var> be <var>scaledV</var> - <var>roundedScaledV</var>.</li><li>Let <var>remainderStr</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_246"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>remainder</var>).</li><li>Let <var>integerDigits</var> be the unique decimal string representation of <var>roundedScaledV</var> without leading zeroes.</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>remainderStr</var> from 0 to <var>numDigits</var> + 1.</li><li>Let <var>s</var> be the concatenation of <var>signPrefix</var>, <var>integerDigits</var>, <emu-val>"."</emu-val>, and <var>nonIntegerDigits</var>.</li><li>Return <emu-xref aoid="CanonicalizeDecimalString" id="_ref_247"><a href="#sec-decimal128-canonicalizedecimalstring">CanonicalizeDecimalString</a></emu-xref>(<var>s</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 <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> 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>
@@ -3699,7 +3701,7 @@ <h1><span class="secnum">2.25</span> Decimal128.prototype.toJSON ( )</h1>
     <h1><span class="secnum">2.26</span> Decimal128.prototype.toPrecision ( [ <var>options</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-decimal128.prototype.tostring" id="_ref_6"><a href="#sec-decimal128.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>Let <var>precision</var> be 0.</li><li>If <var>options</var> is not <emu-val>undefined</emu-val>, then<ol><li>If <var>options</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is not an Object</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>Let <var>optPrecision</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>"precision"</emu-val>).</li><li>If <var>optPrecision</var> is neither <emu-val>undefined</emu-val> nor a Number, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>optPrecision</var> is <emu-val>undefined</emu-val>, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_219"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li><li>If <var>precision</var> is <emu-val>NaN</emu-val><sub>𝔽</sub>, <emu-val>+∞</emu-val><sub>𝔽</sub> or <emu-val>+∞</emu-val><sub>𝔽</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Set <var>precision</var> to <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>precision</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>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>If <emu-xref aoid="sign" id="_ref_220"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d</var>) = 1, let <var>signPrefix</var> be <emu-val>""</emu-val>, else let <var>signPrefix</var> be <emu-val>"-"</emu-val>.</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>precision</var> = 0, then<ol><li>Return <emu-val>"0"</emu-val>.</li></ol></li><li>Otherwise:<ol><li>Let <var>extraZeroes</var> be the string <emu-val>"0"</emu-val> repeated <var>precision</var> times.</li><li>Return the string concatenation of <emu-val>"0"</emu-val>, <emu-val>"."</emu-val>, and <var>extraZeroes</var>.</li></ol></li></ol></li><li>Set <var>d</var> to <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>d</var>).</li><li>Let <var>coefficient</var> be <var>d</var> × 10<sup>-q</sup>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>coefficient</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>.</li><li>Let <var>coefficientStr</var> be the unique decimal string representation of <var>coefficient</var> without leading zeroes.</li><li>Let <var>firstDigit</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>coefficientStr</var> from 0 to 1.</li><li>Let <var>remainingDigits</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>coefficientStr</var> from 1.</li><li>Let <var>numCoefficientDigits</var> be the length of <var>coefficientStr</var>.</li><li>Let <var>m</var> be the mantissa of <var>d</var>.</li><li>Let <var>scaledM</var> be <var>m</var> × 10<sup><var>numCoefficientDigits</var></sup>.</li><li>Let <var>fractionalPart</var> be <var>scaledM</var> mod 1.</li><li>Let <var>e</var> be the <emu-xref href="#dfn-decimal128-exponent" id="_ref_221"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref> of <var>d</var>.</li><li>Let <var>eStr</var> be the unique decimal string representation of <var>e</var> without leading zeroes.</li><li>If <var>numCoefficientDigits</var> ≤ <var>numCoefficientDigits</var>, then<ol><li>Let <var>adjustedMantissa</var> be <var>m</var> - (<var>fractionalPart</var> × 10<sup>-_numDigits</sup>).</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>adjustedMantissa</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>.</li><li>Let <var>adjustedMantissaStr</var> be the unique decimal string representation of <var>adjustedMantissa</var> without leading zeroes and without trailing zeroes.</li><li>If <var>e</var> ≥ 0, set <var>eStr</var> to the concation of <emu-val>"+"</emu-val> and <var>eStr</var>.</li><li>Return the concation of <var>signPrefix</var>, <var>adjustedMantissaStr</var>, <emu-val>"e"</emu-val>, and <var>eStr</var>.</li></ol></li><li>Otherwise:<ol><li>Let <var>extraZeroes</var> be the string <emu-val>"0"</emu-val> repeated <var>numCoefficientDigits</var> - 1 - <var>numCoefficientDigits</var> times.</li><li>Let <var>s</var> be the string concatenation of <var>firstDigit</var>, <emu-val>"."</emu-val>, <var>remainingDigits</var>, <var>extraZeroes</var>, <emu-val>"e"</emu-val>, and <var>eStr</var>.</li><li>Return <var>s</var>.</li></ol></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>precision</var> be 0.</li><li>Let <var>roundingMode</var> be <emu-val>undefined</emu-val>.</li><li>If <var>options</var> is not <emu-val>undefined</emu-val>, then<ol><li>If <var>options</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is not an Object</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>Let <var>optPrecision</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>"precision"</emu-val>).</li><li>If <var>optPrecision</var> is neither <emu-val>undefined</emu-val> nor a Number, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>optPrecision</var> is <emu-val>undefined</emu-val>, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_248"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li><li>If <var>precision</var> is <emu-val>NaN</emu-val><sub>𝔽</sub>, <emu-val>+∞</emu-val><sub>𝔽</sub> or <emu-val>+∞</emu-val><sub>𝔽</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Set <var>roundingMode</var> to ?&nbsp;<emu-xref aoid="Get"><a href="https://tc39.es/ecma262/#sec-get-o-p">Get</a></emu-xref>(<var>options</var>, <emu-val>"roundingMode"</emu-val>).</li><li>Set <var>precision</var> to <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>precision</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>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>If <emu-xref aoid="sign" id="_ref_249"><a href="#dfn-decimal128-sign">sign</a></emu-xref>(<var>d</var>) = 1, let <var>signPrefix</var> be <emu-val>""</emu-val>, else let <var>signPrefix</var> be <emu-val>"-"</emu-val>.</li><li>If <var>d</var> is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>precision</var> = 1, then<ol><li>Return the string concatenation of <var>signPrefix</var> and <emu-val>"0"</emu-val>.</li></ol></li><li>Else,<ol><li>Let <var>additionalZeroes</var> be the string <emu-val>"0"</emu-val> repeated <var>precision</var> times.</li><li>Return the string concatenation of <emu-val>"0"</emu-val>, <emu-val>"."</emu-val>, and <var>additionalZeroes</var>.</li></ol></li></ol></li><li>Let <var>q</var> be the largest <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that <var>d</var> × 10<sup>−<var>q</var></sup> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>.</li><li>Let <var>n</var> be <var>d</var> × 10<sup>−<var>q</var></sup>.</li><li>Let <var>coefficient</var> be the unique decimal representation of <var>n</var> without leading zeroes.</li><li>Let <var>numDigits</var> be the string length of <var>coefficient</var>.</li><li>If <var>numDigits</var> &lt; <var>precision</var>, then<ol><li>Let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_250"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>d</var>).</li><li>If <var>d</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, then<ol><li>Let <var>additionalZeroes</var> be the string <emu-val>"0"</emu-val> repeated <var>precision</var> - <var>numDigits</var> times.</li><li>Return the string concatenationof <var>coefficient</var>, <emu-val>"."</emu-val>, and <var>additionalZeroes</var>.</li></ol></li><li>Otherwise:<ol><li>Let <var>additionalZeroes</var> be the string <emu-val>"0"</emu-val> repeated <var>precision</var> - <var>numDigits</var> times.</li><li>Return the string concatenationof _signPrefix, <var>s</var> and <var>additionalZeroes</var>.</li></ol></li></ol></li><li>Else if <var>numDigits</var> = <var>precision</var>, then<ol><li>Return <var>coefficient</var>.</li></ol></li><li>Otherwise:<ol><li>Let <var>exp</var> be <var>q</var> + <var>precision</var>.</li><li>Let <var>scaled</var> be <var>d</var> × 10<sup>-<var>exp</var></sup>.</li><li>Let <var>scaledAndRounded</var> be <emu-xref aoid="ApplyRoundingModeToPositive" id="_ref_251"><a href="#sec-decimal128-applyroundingmodetopositive">ApplyRoundingModeToPositive</a></emu-xref>(<var>scaled</var>, <var>roundingMode</var>).</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>scaledAndRounded</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>.</li><li>Let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_252"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>scaledAndRounded</var>).</li><li>Let <var>renderedQ</var> be the unique decimal string representation of <var>q</var>.</li><li>Return the string concatenation of <var>signPrefix</var>, <var>s</var>, <emu-val>"e"</emu-val>, and <var>renderedQ</var>.</li></ol></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 <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> 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>
@@ -3722,7 +3724,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><ins>If <var>value</var> is an object that has an <var class="field">[[Decimal128Data]]</var> internal slot, then</ins><ol><li><ins>Let <var>d</var> be <var>value</var>.<var class="field">[[Decimal128Data]]</var>.</ins></li><li><ins>Let <var>serialized</var> be <emu-xref aoid="Decimal128ToExponentialString" id="_ref_222"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>d</var>).</ins></li><li><ins>Let <var>n</var> be !&nbsp;<emu-xref aoid="ToNumber"><a href="https://tc39.es/ecma262/#sec-tonumber">ToNumber</a></emu-xref>(<var>serialized</var>).</ins></li></ol></li><li>Else,<ol><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></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>(NewTarget, <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><ins>If <var>value</var> is an object that has an <var class="field">[[Decimal128Data]]</var> internal slot, then</ins><ol><li><ins>Let <var>d</var> be <var>value</var>.<var class="field">[[Decimal128Data]]</var>.</ins></li><li><ins>Let <var>serialized</var> be <emu-xref aoid="Decimal128ToExponentialString" id="_ref_253"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>d</var>).</ins></li><li><ins>Let <var>n</var> be !&nbsp;<emu-xref aoid="ToNumber"><a href="https://tc39.es/ecma262/#sec-tonumber">ToNumber</a></emu-xref>(<var>serialized</var>).</ins></li></ol></li><li>Else,<ol><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></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>(NewTarget, <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>
@@ -3734,7 +3736,7 @@ <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> has a <var class="field">[[Decimal128Data]]</var> internal slot, return ?&nbsp;<emu-xref aoid="Decimal128ToBigInt" id="_ref_223"><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> has a <var class="field">[[Decimal128Data]]</var> internal slot, return ?&nbsp;<emu-xref aoid="Decimal128ToBigInt" id="_ref_254"><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>
@@ -3782,11 +3784,11 @@ <h1><span class="secnum">4.2.1</span> Abstract Operations for NumberFormat Objec
 
       <emu-clause id="sec-tointlmathematicalvalue" type="abstract operation" aoid="ToIntlMathematicalValue">
         <h1><span class="secnum">4.2.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_224"><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 a <emu-xref href="#decimal128-mathematical-value" id="_ref_225"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>, or one of <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="#decimal128-mathematical-value" id="_ref_226"><a href="#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_255"><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 a <emu-xref href="#decimal128-mathematical-value" id="_ref_256"><a href="#decimal128-mathematical-value">mathematical value</a></emu-xref>, or one of <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="#decimal128-mathematical-value" id="_ref_257"><a href="#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> has a <var class="field">[[Decimal128Data]]</var> internal slot, then</ins><ol><li><ins>Let <var>d</var> be <var>value</var>.<var class="field">[[Decimal128Data]]</var>.</ins></li><li><ins>If <var>d</var> is <emu-val>NaN</emu-val><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>Return <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="#decimal128-mathematical-value" id="_ref_227"><a href="#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> has a <var class="field">[[Decimal128Data]]</var> internal slot, then</ins><ol><li><ins>Let <var>d</var> be <var>value</var>.<var class="field">[[Decimal128Data]]</var>.</ins></li><li><ins>If <var>d</var> is <emu-val>NaN</emu-val><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>Return <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="#decimal128-mathematical-value" id="_ref_258"><a href="#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>
   </emu-clause>
@@ -3806,7 +3808,7 @@ <h1><span class="secnum">4.3.1.1</span> ResolvePlural ( <var>pluralRules</var>,
       <emu-clause id="sec-resolvepluralrange" type="abstract operation" aoid="ResolvePluralRange">
         <h1><span class="secnum">4.3.1.2</span> ResolvePluralRange ( <var>pluralRules</var>, <var>x</var>, <var>y</var> )</h1>
         <p>The abstract operation ResolvePluralRange takes arguments <var>pluralRules</var> (an Intl.PluralRules), <var>x</var> (a Number<ins> or an Object with a <var class="field">[[Decimal128Data]]</var> internal slot</ins>), and <var>y</var> (a Number<ins> or an Object with a <var class="field">[[Decimal128Data]]</var> internal slot</ins>) 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> either <emu-val>"zero"</emu-val>, <emu-val>"one"</emu-val>, <emu-val>"two"</emu-val>, <emu-val>"few"</emu-val>, <emu-val>"many"</emu-val>, or <emu-val>"other"</emu-val>, 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>. The returned String value represents the plural form of the range starting from <var>x</var> and ending at <var>y</var> according to the effective locale and the options of <var>pluralRules</var>. It performs the following steps when called:</p>
-        <emu-alg><ol><li>If <var>x</var> is <emu-val>NaN</emu-val> <ins>or <emu-val>NaN</emu-val><sub>𝔻</sub></ins> or <var>y</var> is <emu-val>NaN</emu-val><ins>or <emu-val>NaN</emu-val><sub>𝔻</sub></ins>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>xp</var> be <emu-xref aoid="ResolvePlural" id="_ref_228"><a href="#sec-resolveplural">ResolvePlural</a></emu-xref>(<var>pluralRules</var>, <var>x</var>).</li><li>Let <var>yp</var> be <emu-xref aoid="ResolvePlural" id="_ref_229"><a href="#sec-resolveplural">ResolvePlural</a></emu-xref>(<var>pluralRules</var>, <var>y</var>).</li><li>If <var>xp</var>.<var class="field">[[FormattedString]]</var> is <var>yp</var>.<var class="field">[[FormattedString]]</var>, then<ol><li>Return <var>xp</var>.<var class="field">[[PluralCategory]]</var>.</li></ol></li><li>Let <var>locale</var> be <var>pluralRules</var>.<var class="field">[[Locale]]</var>.</li><li>Let <var>type</var> be <var>pluralRules</var>.<var class="field">[[Type]]</var>.</li><li>Return <emu-xref aoid="PluralRuleSelectRange"><a href="https://tc39.es/ecma402/#sec-pluralruleselectrange">PluralRuleSelectRange</a></emu-xref>(<var>locale</var>, <var>type</var>, <var>xp</var>.<var class="field">[[PluralCategory]]</var>, <var>yp</var>.<var class="field">[[PluralCategory]]</var>).</li></ol></emu-alg>
+        <emu-alg><ol><li>If <var>x</var> is <emu-val>NaN</emu-val> <ins>or <emu-val>NaN</emu-val><sub>𝔻</sub></ins> or <var>y</var> is <emu-val>NaN</emu-val><ins>or <emu-val>NaN</emu-val><sub>𝔻</sub></ins>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>xp</var> be <emu-xref aoid="ResolvePlural" id="_ref_259"><a href="#sec-resolveplural">ResolvePlural</a></emu-xref>(<var>pluralRules</var>, <var>x</var>).</li><li>Let <var>yp</var> be <emu-xref aoid="ResolvePlural" id="_ref_260"><a href="#sec-resolveplural">ResolvePlural</a></emu-xref>(<var>pluralRules</var>, <var>y</var>).</li><li>If <var>xp</var>.<var class="field">[[FormattedString]]</var> is <var>yp</var>.<var class="field">[[FormattedString]]</var>, then<ol><li>Return <var>xp</var>.<var class="field">[[PluralCategory]]</var>.</li></ol></li><li>Let <var>locale</var> be <var>pluralRules</var>.<var class="field">[[Locale]]</var>.</li><li>Let <var>type</var> be <var>pluralRules</var>.<var class="field">[[Type]]</var>.</li><li>Return <emu-xref aoid="PluralRuleSelectRange"><a href="https://tc39.es/ecma402/#sec-pluralruleselectrange">PluralRuleSelectRange</a></emu-xref>(<var>locale</var>, <var>type</var>, <var>xp</var>.<var class="field">[[PluralCategory]]</var>, <var>yp</var>.<var class="field">[[PluralCategory]]</var>).</li></ol></emu-alg>
       </emu-clause>
     </emu-clause>
   </emu-clause>
diff --git a/spec.emu b/spec.emu
index 1d7d44c..f5dc784 100644
--- a/spec.emu
+++ b/spec.emu
@@ -25,7 +25,9 @@ location: https://github.com/tc39/proposal-decimal/
 
   <emu-intro id="sec-decimal-intro">
     <h1>Introduction</h1>
-    <p>Decimal128 values, as specified here, are intended to represent base-10 (decimal) numbers as specified in <emu-xref href="#sec-bibliography">IEEE 754-2019 Decimal128</emu-xref>. Only a subset of the values specified in IEEE 754-2019 Decimal128 are modeled here, namely, the set of *canonicalized* values, which can be intuitively understood as decimal numbers without trailing zeroes. A Decimal128 value, as specified here, is one of the following six kinds of values:</p>
+    <p>Decimal128 values, as specified here, are intended to represent base-10 (decimal) numbers as specified in <emu-xref href="#sec-bibliography">IEEE 754-2019 Decimal128</emu-xref>. All values specified in IEEE 754-2019 Decimal128 are modeled here, though mathematically equal members of a cohort (intuitively, IEEE 754-2019 Decimal128 values that differ only in the number of trailing zeroes after the decimal point) are indistinguishable here.</p>
+
+    <p>A <dfn id="def-decimal128-value">Decimal128 value</dfn>, as specified here, is one of the following six kinds of values:</p>
 
     <ul>
       <li>*NaN*<sub>𝔻</sub>, represending a decimal not-a-number</li>
@@ -36,7 +38,7 @@ location: https://github.com/tc39/proposal-decimal/
       <li>a mathematical value _v_ for which there exists an integer _q_ satisfing the following conditions:</li>
       <ul>
         <li>-6176 ≤ _q_ ≤ 6111,</li>
-        <li>v × 10<sup>−_q_</sup> is an integer _n_ such that 0 < abs(_n_) < 10<sup>34</sup></li>
+        <li>_v_ × 10<sup>−_q_</sup> is an integer _n_ such that 0 < abs(_n_) < 10<sup>34</sup></li>
       </ul>
     </ul>
     <emu-note>
@@ -237,7 +239,7 @@ location: https://github.com/tc39/proposal-decimal/
         1. If the final code unit of _digits_ is not the code unit 0x0030 (DIGIT ZERO), return _digits_.
         1. Let _lhs_ be the substring of _digits_ up to the first occurrence of the string *"."*.
         1. Let _rhs_ be the substring of _digits_ starting at the first code point after the first occurrence of the string *"."*.
-        1. Let _noTrailingZeroes_ be the shortest substring of _rhs_ that does not terminate with a sequence of the code point 0x0030 (DIGIT ZERO).
+        1. Let _noTrailingZeroes_ be the longest substring of _rhs_ that does not terminate with a sequence of the code point 0x0030 (DIGIT ZERO).
         1. If _noTrailingZeroes_ is *""*, return _lhs_.
         1. Otherwise, return the concatenation of _lhs_, *"."*, and _noTrailingZeroes_.
       </emu-alg>
@@ -261,19 +263,22 @@ location: https://github.com/tc39/proposal-decimal/
         1. If _sign_ = -1, let _prefix_ be *"-"*, else let _prefix_ be *""*.
         1. Let _argument_ be Decimal128Abs(_argument_).
         1. If _argument_ is *+0*<sub>𝔻</sub>, return the string concatenation of _prefix_ and *"0"*.
-        1. Let _q_ be the smallest integer such that _argument_ × 10<sup>−_q_</sup> is an integer.
+        1. Let _q_ be the largest integer such that _argument_ × 10<sup>−_q_</sup> is an integer.
         1. Let _n_ be _argument_ × 10<sup>−_q_</sup>.
+        1. Let _x_ be floor(_argument_).
+        1. Let _y_ be _argument_ mod 1.
         1. Assert: 0 < _n_ < 10<sup>34</sup>.
-        1. Let _digits_ be the unique decimal string representation of _n_ without leading zeroes.
+        1. Let _digits_ be the unique decimal string representation of _x_ without leading zeroes.
+        1. If _y_ = 0, let _fractionalPart_ be *""*, else let _fractionalPart_ be the unique decimal string representation of _y_ without leading zeroes.
         1. Let _numDigits_ be the length of _digits_.
         1. Let _integerPart_ be the substring of _digits_ from 0 to _numDigits_.
         1. If _argument_ is an integer, then
           1. Assert: _integerPart_ is not *""*.
           1. Return _integerPart_.
         1. If _integerPart_ is *""*, set _integerPart_ to *"0"*.
-        1. Let _nonIntegerPart_ be the substring of _digits_ from _numDigits_.
-        1. Let _renderedAbsoluteValue_ be the concatenation of _integerPart, *"."*, and _nonIntegerPart_.
-        1. Let _s_ be the concatenation of _prefix and _renderedAbsoluteValue_.
+        1. Let _nonIntegerPart_ be the substring of _fractionalPart_ from 0 to _numDigits_.
+        1. Let _renderedAbsoluteValue_ be the concatenation of _integerPart_, *"."*, and _nonIntegerPart_.
+        1. Let _s_ be the concatenation of _prefix_ and _renderedAbsoluteValue_.
         1. Return CanonicalizeDecimalString(_s_).
       </emu-alg>
     </emu-clause>
@@ -296,16 +301,11 @@ location: https://github.com/tc39/proposal-decimal/
         1. Let _argument_ be Decimal128Abs(_argument_).
         1. If _sign_ = -1, let _prefix_ be *"-"*, else let _prefix_ be *""*.
         1. If _argument_ is *+0*<sub>𝔻</sub> or *−0*<sub>𝔻</sub>, return the string concatenation of _prefix_ and *"0e+0".
-        1. Let _q_ be the smallest integer such that _argument_ × 10<sup>−_q_</sup> is an integer.
-        1. Let _n_ be _argument_ × 10<sup>−_q_</sup>.
-        1. Assert: 0 < _n_ < 10<sup>34</sup>.
-        1. Let _coefficientStr_ be the unique decimal string representation of _n_ without leading zeroes.
-        1. Let _e_ be the unique integer for which 1 ≤ _n_ × 10<sup>_e_</sup> < 10.
-        1. Let _adjustedExp_ be -_e_.
-        1. Let _adjustedExpStr_ be the unique decimal string representation of _adjustedExp_ without leading zeroes.
-        1. Let _firstDigit_ be the substring of _coefficientStr_ from 0 to 1.
-        1. Let _remainingDigits_ be the substring of _coefficientStr_ starting at 1.
-        1. Return the concatenation of _prefix_, _firstDigit_, *"."*, _remainingDigits_, *"e"*, and _adjustedExpStr_.
+        1. Let _e_ be the unique integer for which 1 ≤ _argument_ × 10<sup>_e_</sup> < 10.
+        1. Let _mantissa_ be _argument_ / 10<sup>_e_</sup>.
+        1. Let _coefficientStr_ be Decimal128ToDecimalString(_mantissa_).
+        1. Let _exponentStr_ be the unique decimal string representation of _e_ without leading zeroes.
+        1. Return the concatenation of _prefix_, _coefficientStr_, *"e"*, and _exponentStr_.
       </emu-alg>
     </emu-clause>
 
@@ -356,7 +356,7 @@ location: https://github.com/tc39/proposal-decimal/
         1. Return _O_.
       </emu-alg>
       <emu-note>
-        <p>Given a Number argument, the constructor converts it to a String using the <emu-xref href="#sec-number.prototype.tostring">toString</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 constructor not with the number but rather with, for instance, the result of calling <emu-xref href="#sec-number.prototype.tofixed">toFixed</emu-xref> or <emu-xref href="#sec-number.prototype.toprecision">toPrecision</emu-xref> on the Number, thereby ensuring a certain level of precision that may get lost when using Number’s toString.</p>
+        <p>Given a Number argument, the constructor converts it to a String using the <emu-xref href="#sec-number.prototype.tostring">toString</emu-xref> method (with no arguments). In some cases, this may not be desired. In some use cases, given a Number, one may wish to call the Decimal128 constructor not with the number but rather with, for instance, the result of calling <emu-xref href="#sec-number.prototype.tofixed">toFixed</emu-xref> or <emu-xref href="#sec-number.prototype.toprecision">toPrecision</emu-xref> on the Number, thereby ensuring a certain level of precision that may get lost when using Number’s toString.</p>
       </emu-note>
       <emu-clause id="sec-runtime-semantics-stringdecimalvalue" type="sdo">
         <h1>Runtime Semantics: StringDecimalValue ( ): either a normal completion containing a Decimal128 value or a throw completion</h1>
@@ -452,7 +452,7 @@ location: https://github.com/tc39/proposal-decimal/
 
   <emu-clause id="sec-decimal128.prototype.mantissa">
     <h1>Decimal128.prototype.mantissa ( )</h1>
-    <p>This method returns a Decimal128 value representing the <emu-xref href="#dfn-decimal128-significand">significand</emu-xref> of the current Decimal128 object, which is the mathematical value _n_ for which the current Decimal128 object, _v_, there exists an integer _e_ such such that _v_ = _s_ × 10<sup>_e_</sup> and 1 ≤ abs(_s_) < 10. IF the current Decimal128 object is a zero, it returns a zero.</p>
+    <p>This method returns a Decimal128 value representing the <emu-xref href="#dfn-decimal128-significand">significand</emu-xref> of the current Decimal128 object, which is the mathematical value _s_ for which the current Decimal128 object, _v_, there exists an integer _e_ such such that _v_ = _s_ × 10<sup>_e_</sup> and 1 ≤ abs(_s_) < 10. If the current Decimal128 object is a zero, it returns a zero.</p>
     <p>It performs the following steps when called:</p>
     <emu-alg>
       1. Let _O_ be the *this* value.
@@ -462,7 +462,6 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d_ is *+∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔽</sub>).
       1. If _d_ is *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(*+0*<sub>𝔻</sub>).
       1. If _d_ is *−0*<sub>𝔻</sub>, return Decimal128ValueToObject(*-0*<sub>𝔻</sub>).
-      1. Let _e_ be the truncated exponent of _d_.
       1. Let _s_ be the unique mathematical value such that _d_ = _s_ × 10<sup>_e_</sup> and 1 ≤ abs(_s_) < 10.
       1. Return Decimal128ValueToObject(_s_).
     </emu-alg>
@@ -647,14 +646,14 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _d2_ be _x_.[[Decimal128Data]].
       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(_d1_).
+      1. If _d2_ is *+∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(_d1_).
       1. If _d2_ is *+0*<sub>𝔻</sub> or *−0*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d1_ is *+0*<sub>𝔻</sub> or *−0*<sub>𝔻</sub>, return Decimal128ValueToObject(_d1_).
       1. Assert: _d2_ ≠ 0.
       1. Let _quotient_ be _d1_ / _d2_.
       1. Let _q_ be truncate(_quotient_).
       1. Let _r_ be _d1_ - (_d2_ × _q_).
-      1. If _r_ = 0, and _d1_ < 0, return Decimal128ValueToObject(*−0*<sub>𝔽</sub>).
+      1. If _r_ = 0, and _d1_ < 0, return Decimal128ValueToObject(*−0*<sub>𝔻</sub>).
       1. Otherwise, return Decimal128ValueToObject(_r_).
     </emu-alg>
     <emu-note>
@@ -693,7 +692,7 @@ location: https://github.com/tc39/proposal-decimal/
 
   <emu-clause id="sec-decimal128.prototype.equals">
     <h1>Decimal128.prototype.equals ( _x_ )</h1>
-    <p>This method returns either *true*, *false*, or *undefined* according as the current Decimal128 object has the same mathematical value as the given Decimal128 object. The value *undefined* is returned if the current Decimal128 object or the argument is a NaN.</p>
+    <p>This method returns either *true* or *false* according as the current Decimal128 object has the same mathematical value as the given Decimal128 object. The value *false* is returned if the current Decimal128 object or the argument is a NaN.</p>
     <p>It performs the following steps when called:</p>
     <emu-alg>
       1. Let _O_ be the *this* value.
@@ -701,8 +700,8 @@ location: https://github.com/tc39/proposal-decimal/
       1. Perform ? RequireInternalSlot(_x_, [[Decimal128Data]]).
       1. Let _d1_ be _O_.[[Decimal128Data]].
       1. Let _d2_ be _x_.[[Decimal128Data]].
-      1. If _d1_ is *NaN*<sub>𝔻</sub>, return *undefined*.
-      1. If _d2_ is *NaN*<sub>𝔻</sub>, return *undefined*.
+      1. If _d1_ is *NaN*<sub>𝔻</sub>, return *false*.
+      1. If _d2_ is *NaN*<sub>𝔻</sub>, return *false*.
       1. If _d1_ is *+∞*<sub>𝔻</sub>, then
         1. If _d2_ is *+∞*<sub>𝔻</sub>, return *true*.
         1. Otherwise, return *false*.
@@ -720,7 +719,7 @@ location: https://github.com/tc39/proposal-decimal/
 
   <emu-clause id="sec-decimal128.prototype.notequals">
     <h1>Decimal128.prototype.notEquals ( _x_ )</h1>
-    <p>This method returns either *true*, *false*, or *undefined* according as the current Decimal128 object has a different mathematical value as the given Decimal128 object. The value *undefined* is returned if the current Decimal128 object or the argument is a NaN.</p>
+    <p>This method returns either *true* or *false* according as the current Decimal128 object has a strictly smaller mathematical value as that of the given Decimal128 object. The value *false* is returned if either the current Decimal128 object or the argument is a NaN.</p>
     <p>It performs the following steps when called:</p>
     <emu-alg>
       1. Let _O_ be the *this* value.
@@ -728,8 +727,8 @@ location: https://github.com/tc39/proposal-decimal/
       1. Perform ? RequireInternalSlot(_x_, [[Decimal128Data]]).
       1. Let _d1_ be _O_.[[Decimal128Data]].
       1. Let _d2_ be _x_.[[Decimal128Data]].
-      1. If _d1_ is *NaN*<sub>𝔻</sub>, return *undefined*.
-      1. If _d2_ is *NaN*<sub>𝔻</sub>, return *undefined*.
+      1. If _d1_ is *NaN*<sub>𝔻</sub>, return *false*.
+      1. If _d2_ is *NaN*<sub>𝔻</sub>, return *false*.
       1. If _d1_ is *+∞*<sub>𝔻</sub>, then
         1. If _d2_ is *+∞*<sub>𝔻</sub>, return *false*.
         1. Otherwise, return *true*.
@@ -747,7 +746,7 @@ location: https://github.com/tc39/proposal-decimal/
 
   <emu-clause id="sec-decimal128.prototype.lessthan">
     <h1>Decimal128.prototype.lessThan ( _x_ )</h1>
-    <p>This method returns either *true*, *false* according as the current Decimal128 object has the same mathematical value as the given Decimal128 object. The value *false* is returned if the current Decimal128 object or the argument is a NaN.</p>
+    <p>This method returns either *true* or *false* according as the current Decimal128 object has the same mathematical value as the given Decimal128 object. The value *false* is returned if the current Decimal128 object or the argument is a NaN.</p>
     <p>It performs the following steps when called:</p>
     <emu-alg>
       1. Let _O_ be the *this* value.
@@ -836,7 +835,9 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d1_ is *NaN*<sub>𝔻</sub>, return *false*.
       1. If _d2_ is *NaN*<sub>𝔻</sub>, return *false*.
       1. If _d1_ is *+∞*<sub>𝔻</sub>, return *true*.
-      1. If _d1_ is *-∞*<sub>𝔻</sub>, return *false*.
+      1. If _d1_ is *-∞*<sub>𝔻</sub>, then
+        1. If _d2_ is *-∞*<sub>𝔻</sub>, return *true*.
+        1. Otherwise, return *false*.
       1. If _d2_ is *+∞*<sub>𝔻</sub>, return *false*.
       1. If _d2_ is *-∞*<sub>𝔻</sub>, return *true*.
       1. If MV(_d1_) ≥ MV(_d2_), return *true*.
@@ -870,7 +871,7 @@ location: https://github.com/tc39/proposal-decimal/
         1. Else if _roundingMode_ is *"ceil"*, set _roundingMode_ to *"floor"*.
       1. Let _roundedScaledV_ be ApplyRoundingModeToPositive(_scaledV_, _roundingMode_).
       1. If _sign_ = -1, set _roundedScaledV_ to −_roundedScaledV_.
-      1. Let _rescaledRoundedV_ be _roundedScaledV_ × 10<sup>−_numFractionalDigits_</sup>.
+      1. Let _rescaledRoundedV_ be _roundedScaledV_ × 10<sup>ℝ(−_numFractionalDigits_)</sup>.
       1. Return Decimal128ValueToObject(RoundToDecimal128Domain(_rescaledRoundedV_, _roundingMode_)).
     </emu-alg>
     <emu-note>
@@ -890,11 +891,7 @@ location: https://github.com/tc39/proposal-decimal/
         1. If ℝ(_n_) is not an integer, throw a *RangeError* exception.
       1. Let _d_ be _O_.[[Decimal128Data]].
       1. If _d_ is *NaN*<sub>𝔻</sub>, *+∞*<sub>𝔻</sub>, or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(_d_).
-      1. If _d_ is either *+0*<sub>𝔻</sub> nor *−0*<sub>𝔻</sub>, then
-        1. If _n_ is *NaN*<sub>𝔽</sub>, return Decimal128ValueToObject(_d_).
-        1. If _n_ is *+∞*<sub>𝔽</sub>, return Decimal128ValueToObject(_d_).
-        1. If _n_ is *-∞*<sub>𝔽</sub>, return Decimal128ValueToObject(_d_).
-        1. Otherwise, return Decimal128ValueToObject(_d_).
+      1. If _d_ is either *+0*<sub>𝔻</sub> or *−0*<sub>𝔻</sub>, return Decimal128ValueToObject(_d_).
       1. If _n_ is *NaN*<sub>𝔽</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _n_ is *+∞*<sub>𝔽</sub>, then
         1. If _d_ > 0, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
@@ -902,7 +899,7 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _n_ is *-∞*<sub>𝔽</sub>, then
         1. If _d_ > 0, return Decimal128ValueToObject(*+0*<sub>𝔻</sub>).
         1. Otherwise, return Decimal128ValueToObject(*−0*<sub>𝔻</sub>).
-      1. Let _w_ be v × 10<sup>ℝ(_n_)</sup>.
+      1. Let _w_ be _d_ × 10<sup>ℝ(_n_)</sup>.
       1. Return Decimal128ValueToObject(RoundToDecimal128Domain(_w_)).
     </emu-alg>
     <emu-note>
@@ -979,33 +976,24 @@ location: https://github.com/tc39/proposal-decimal/
       1. Else if _roundingMode_ is not a <emu-xref href="#dfn-decimal128-rounding-mode">Decimal128 rounding mode</emu-xref>, throw a *RangeError* exception.
       1. Let _d_ be _O_.[[Decimal128Data]].
       1. If _d_ is *NaN*<sub>𝔻</sub>, return *"NaN"*.
-      1. If _d_ is *+∞*<sub>𝔻</sub>, return *"Infintiy"*.
-      1. If _d_ is *-∞*<sub>𝔻</sub>, return *"-Infintiy"*.
+      1. If _d_ is *+∞*<sub>𝔻</sub>, return *"Infinity"*.
+      1. If _d_ is *-∞*<sub>𝔻</sub>, return *"-Infinity"*.
       1. If sign(_d_) = 1, let _signPrefix_ be *""*, else let _signPrefix_ be *"-"*.
       1. If _d_ is *+0*<sub>𝔻</sub> or *-0*<sub>𝔻</sub>, then
         1. If _numDigits_ = 0, then
           1. Return the concatenation of _signPrefix_ and *"0"*.
         1. Otherwise:
           1. Let _trailingZeroes_ be *"0"* repeated _numDigits_ times.
-          1. Return the concatenation of _signPrefix, *"0"*, *"."*, and _trailingZeroes_.
+          1. Return the concatenation of _signPrefix_, *"0"*, *"."*, and _trailingZeroes_.
       1. Set _d_ to abs(_d_).
       1. Let _scaledV_ be _d_ × 10<sup>_numDigits_</sup>.
       1. Let _roundedScaledV_ be ApplyRoundingModeToPositive(_scaledV_, _roundingMode_).
-      1. Let _s_ be the unique decimal string representation of _roundedScaledV_ without leading zeroes.
-      1. Let _integerDigits_ be _s_.
-      1. Let _nonIntegerDigits_ be *""*.
-      1. If _s_ contains an occurrence of *"."*, then
-        1. Let _i_ be the index of the first occurrence of *"."* in _s_.
-        1. Set _integerDigits_ to the substring of _s_ from 0 to _i_.
-        1. Set _nonIntegerDigits_ to the substring of _s_ from _i_ + 1.
-      1. If _numDigits_ = 0, return _integerDigits_.
-      1. Let _numNonIntegerDigits_ be the length of _nonIntegerDigits_.
-      1. If the _numNonIntegerDigits_ < _numDigits_, then
-        1. Let _additionalZeroes_ be the string *"0"* repeated _numDigits_ - _numNonIntegerDigits_ times.
-        1. Set _nonIntegerDigits_ to the concatenation of _nonIntegerDigits_ and _additionalZeroes_.
-      1. Else if _numNonIntegerDigits_ > _numDigits_, then
-        1. Set _nonIntegerDigits_ to the substring of _nonIntegerDigits_ from 0 to _numDigits_.
-      1. Return the concatenation of _signPrefix_, _integerDigits_, *"."*, and _nonIntegerDigits_.
+      1. Let _remainder_ be _scaledV_ - _roundedScaledV_.
+      1. Let _remainderStr_ be Decimal128ToDecimalString(_remainder_).
+      1. Let _integerDigits_ be the unique decimal string representation of _roundedScaledV_ without leading zeroes.
+      1. Let _nonIntegerDigits_ be the substring of _remainderStr_ from 0 to _numDigits_ + 1.
+      1. Let _s_ be the concatenation of _signPrefix_, _integerDigits_, *"."*, and _nonIntegerDigits_.
+      1. Return CanonicalizeDecimalString(_s_).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification of the conversion of IEEE 754-2019 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -1031,12 +1019,14 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _O_ be the *this* value.
       1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
       1. Let _precision_ be 0.
+      1. Let _roundingMode_ be *undefined*.
       1. If _options_ is not *undefined*, then
         1. If _options_ is not an Object, throw a *TypeError* exception.
         1. Let _optPrecision_ be ? Get(_options_, *"precision"*).
         1. If _optPrecision_ is neither *undefined* nor a Number, throw a *TypeError* exception.
         1. If _optPrecision_ is *undefined*, return Decimal128ToDecimalString(_O_).
         1. If _precision_ is *NaN*<sub>𝔽</sub>, *+∞*<sub>𝔽</sub> or *+∞*<sub>𝔽</sub>, throw a *RangeError* exception.
+        1. Set _roundingMode_ to ? Get(_options_, *"roundingMode"*).
         1. Set _precision_ to ℝ(_precision_).
       1. If _precision_ is not an integer, throw a *RangeError* exception.
       1. If _precision_ < 1, throw a *RangeError* exception.
@@ -1046,33 +1036,33 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d_ is *-∞*<sub>𝔻</sub>, return *"-Infinity"*.
       1. If sign(_d_) = 1, let _signPrefix_ be *""*, else let _signPrefix_ be *"-"*.
       1. If _d_ is *+0*<sub>𝔻</sub> or *-0*<sub>𝔻</sub>, then
-        1. If _precision_ = 0, then
-          1. Return *"0"*.
+        1. If _precision_ = 1, then
+          1. Return the string concatenation of _signPrefix_ and *"0"*.
+        1. Else,
+          1. Let _additionalZeroes_ be the string *"0"* repeated _precision_ times.
+          1. Return the string concatenation of *"0"*, *"."*, and _additionalZeroes_.
+      1. Let _q_ be the largest integer such that _d_ × 10<sup>−_q_</sup> is an integer.
+      1. Let _n_ be _d_ × 10<sup>−_q_</sup>.
+      1. Let _coefficient_ be the unique decimal representation of _n_ without leading zeroes.
+      1. Let _numDigits_ be the string length of _coefficient_.
+      1. If _numDigits_ < _precision_, then
+        1. Let _s_ be Decimal128ToDecimalString(_d_).
+        1. If _d_ is an integer, then
+          1. Let _additionalZeroes_ be the string *"0"* repeated _precision_ - _numDigits_ times.
+          1. Return the string concatenationof _coefficient_, *"."*, and _additionalZeroes_.
         1. Otherwise:
-          1. Let _extraZeroes_ be the string *"0"* repeated _precision_ times.
-          1. Return the string concatenation of *"0"*, *"."*, and _extraZeroes_.
-      1. Set _d_ to abs(_d_).
-      1. Let _coefficient_ be _d_ × 10<sup>-q</sup>.
-      1. Assert: _coefficient_ is an integer.
-      1. Let _coefficientStr_ be the unique decimal string representation of _coefficient_ without leading zeroes.
-      1. Let _firstDigit_ be the substring of _coefficientStr_ from 0 to 1.
-      1. Let _remainingDigits_ be the substring of _coefficientStr_ from 1.
-      1. Let _numCoefficientDigits_ be the length of _coefficientStr_.
-      1. Let _m_ be the mantissa of _d_.
-      1. Let _scaledM_ be _m_ × 10<sup>_numCoefficientDigits_</sup>.
-      1. Let _fractionalPart_ be _scaledM_ mod 1.
-      1. Let _e_ be the exponent of _d_.
-      1. Let _eStr_ be the unique decimal string representation of _e_ without leading zeroes.
-      1. If _numCoefficientDigits_ ≤ _numCoefficientDigits_, then
-        1. Let _adjustedMantissa_ be _m_ - (_fractionalPart_ × 10<sup>-_numDigits</sup>).
-        1. Assert: _adjustedMantissa_ is an integer.
-        1. Let _adjustedMantissaStr_ be the unique decimal string representation of _adjustedMantissa_ without leading zeroes and without trailing zeroes.
-        1. If _e_ ≥ 0, set _eStr_ to the concation of *"+"* and _eStr_.
-        1. Return the concation of _signPrefix_, _adjustedMantissaStr_, *"e"*, and _eStr_.
+          1. Let _additionalZeroes_ be the string *"0"* repeated _precision_ - _numDigits_ times.
+          1. Return the string concatenationof _signPrefix, _s_ and _additionalZeroes_.
+      1. Else if _numDigits_ = _precision_, then
+        1. Return _coefficient_.
       1. Otherwise:
-        1. Let _extraZeroes_ be the string *"0"* repeated _numCoefficientDigits_ - 1 - _numCoefficientDigits_ times.
-        1. Let _s_ be the string concatenation of _firstDigit_, *"."*, _remainingDigits_, _extraZeroes_, *"e"*, and _eStr_.
-        1. Return _s_.
+        1. Let _exp_ be _q_ + _precision_.
+        1. Let _scaled_ be _d_ × 10<sup>-_exp_</sup>.
+        1. Let _scaledAndRounded_ be ApplyRoundingModeToPositive(_scaled_, _roundingMode_).
+        1. Assert: _scaledAndRounded_ is not an integer.
+        1. Let _s_ be Decimal128ToDecimalString(_scaledAndRounded_).
+        1. Let _renderedQ_ be the unique decimal string representation of _q_.
+        1. Return the string concatenation of _signPrefix_, _s_, *"e"*, and _renderedQ_.
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification of the conversion of IEEE 754-2019 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>