diff --git a/index.html b/index.html
index 702828ed..18921d35 100644
--- a/index.html
+++ b/index.html
@@ -1559,7 +1559,7 @@
 });
 
 let sdoMap = JSON.parse(`{}`);
-let biblio = JSON.parse(`{"refsByClause":{"sec-decimal.prototype.compare":["_ref_0","_ref_1","_ref_153","_ref_154","_ref_155","_ref_156","_ref_157"],"sec-decimal-method-round":["_ref_2","_ref_3","_ref_158","_ref_159","_ref_160","_ref_161","_ref_162","_ref_163","_ref_164","_ref_165"],"sec-decimal.prototype.tostring":["_ref_4","_ref_166","_ref_167","_ref_168"],"sec-decimal.prototype.toprecision":["_ref_5","_ref_175","_ref_176","_ref_177","_ref_178","_ref_179","_ref_180","_ref_181","_ref_182","_ref_183","_ref_184"],"sec-tointlmathematicalvalue":["_ref_6","_ref_188","_ref_189","_ref_190","_ref_191","_ref_192","_ref_193","_ref_194"],"sec-decimal-intro":["_ref_7","_ref_8","_ref_9","_ref_10","_ref_11","_ref_12","_ref_13","_ref_14","_ref_15","_ref_16","_ref_17","_ref_18","_ref_19","_ref_20","_ref_21","_ref_22","_ref_23","_ref_24","_ref_25","_ref_26","_ref_27","_ref_28","_ref_29","_ref_30","_ref_31","_ref_32","_ref_33","_ref_34","_ref_35","_ref_36","_ref_37","_ref_38","_ref_39","_ref_40","_ref_41","_ref_42","_ref_43","_ref_44","_ref_45","_ref_46","_ref_47","_ref_48","_ref_49"],"sec-decimal128-decimal128todecimalstring":["_ref_50","_ref_51"],"sec-decimal128toexponentialstring":["_ref_52","_ref_53"],"sec-decimal128-isintegraldecimal128value":["_ref_54","_ref_55","_ref_56"],"sec-decimal128-value-to-object":["_ref_57"],"sec-decimal128-d":["_ref_58","_ref_59","_ref_60","_ref_61","_ref_62"],"sec-decimal128-canonicalizedecimal128":["_ref_63","_ref_64","_ref_65","_ref_66"],"sec-the-decimal128-constructor-value":["_ref_67","_ref_68","_ref_69","_ref_70","_ref_71"],"sec-decimal.prototype.abs":["_ref_72","_ref_73","_ref_74","_ref_75","_ref_76","_ref_77"],"sec-decimal.prototype.negate":["_ref_78","_ref_79","_ref_80","_ref_81","_ref_82","_ref_83"],"sec-decimal.prototype.add":["_ref_84","_ref_85","_ref_86","_ref_87","_ref_88","_ref_89","_ref_90","_ref_91","_ref_92","_ref_93","_ref_94","_ref_95","_ref_96","_ref_97"],"sec-decimal.prototype.subtract":["_ref_98","_ref_99","_ref_100","_ref_101","_ref_102","_ref_103","_ref_104","_ref_105","_ref_106","_ref_107","_ref_108","_ref_109","_ref_110","_ref_111"],"sec-decimal.prototype.multiply":["_ref_112","_ref_113","_ref_114","_ref_115","_ref_116","_ref_117","_ref_118","_ref_119","_ref_120","_ref_121","_ref_122","_ref_123","_ref_124","_ref_125","_ref_126","_ref_127","_ref_128","_ref_129","_ref_130"],"sec-decimal.prototype.divide":["_ref_131","_ref_132","_ref_133","_ref_134","_ref_135","_ref_136","_ref_137","_ref_138","_ref_139","_ref_140"],"sec-decimal.prototype.remainder":["_ref_141","_ref_142","_ref_143","_ref_144","_ref_145","_ref_146","_ref_147","_ref_148","_ref_149","_ref_150"],"sec-decimal.prototype.equals":["_ref_151"],"sec-decimal.prototype.lessthan":["_ref_152"],"sec-decimal.prototype.toexponential":["_ref_169","_ref_170","_ref_171"],"sec-decimal.prototype.tofixed":["_ref_172","_ref_173","_ref_174"],"sec-number-constructor-number-value":["_ref_185"],"sec-bigint-constructor-number-value":["_ref_186"],"sec-numbertobigint":["_ref_187"],"sec-formatnumberstring":["_ref_195","_ref_196","_ref_197","_ref_198","_ref_199","_ref_200","_ref_201","_ref_202"],"sec-torawprecision":["_ref_203","_ref_204","_ref_205","_ref_206","_ref_207","_ref_208","_ref_209","_ref_210","_ref_211","_ref_212","_ref_213","_ref_214","_ref_215","_ref_216","_ref_217"],"sec-torawfixed":["_ref_218","_ref_219","_ref_220","_ref_221","_ref_222","_ref_223","_ref_224","_ref_225","_ref_226","_ref_227","_ref_228","_ref_229","_ref_230"],"sec-partitionnumberpattern":["_ref_231","_ref_232","_ref_233","_ref_234","_ref_235"]},"entries":[{"type":"clause","id":"sec-decimal-intro-","titleHTML":"Introduction","number":""},{"type":"term","term":"finite","id":"dfn-decimal128-finite","referencingIds":["_ref_11","_ref_12","_ref_15","_ref_16","_ref_19","_ref_31","_ref_32","_ref_35","_ref_37","_ref_39","_ref_41","_ref_43","_ref_46","_ref_49","_ref_54","_ref_189","_ref_205","_ref_220"]},{"type":"term","term":"zero","id":"dfn-decimal128-zero","referencingIds":["_ref_7","_ref_8","_ref_13","_ref_17","_ref_18","_ref_20","_ref_24","_ref_25","_ref_33","_ref_36","_ref_38","_ref_40","_ref_42","_ref_44","_ref_45","_ref_47","_ref_48","_ref_116","_ref_121","_ref_191","_ref_213"]},{"type":"term","term":"negative","refId":"sec-decimal-intro"},{"type":"term","term":"mathematical value","id":"dfn-decimal128-mathematical-value","referencingIds":["_ref_6","_ref_9","_ref_10","_ref_14","_ref_34","_ref_58","_ref_59","_ref_67","_ref_68","_ref_70","_ref_151","_ref_152","_ref_153","_ref_154","_ref_157","_ref_192","_ref_193","_ref_194","_ref_195","_ref_196","_ref_198","_ref_204","_ref_207","_ref_208","_ref_209","_ref_214","_ref_216","_ref_219","_ref_222","_ref_223","_ref_227","_ref_229","_ref_234"]},{"type":"term","term":"rounding mode","id":"dfn-decimal128-rounding-mode","referencingIds":["_ref_21","_ref_22","_ref_26","_ref_60","_ref_84","_ref_98","_ref_112","_ref_131","_ref_141","_ref_158","_ref_160","_ref_165"]},{"type":"term","term":"default rounding mode","id":"dfn-decimal128-default-rounding-mode","referencingIds":["_ref_2","_ref_3"]},{"type":"table","id":"table-decimal128-rounding-modes","number":1,"caption":"Table 1: Rounding modes in Decimal128 compared to IEEE 754 rounding modes"},{"type":"op","aoid":"cohort","id":"eqn-decimal128-cohort","referencingIds":["_ref_27","_ref_28","_ref_29","_ref_30","_ref_50","_ref_52","_ref_55","_ref_63","_ref_64","_ref_75","_ref_81","_ref_92","_ref_93","_ref_106","_ref_107","_ref_123","_ref_126","_ref_135","_ref_136","_ref_145","_ref_146","_ref_161","_ref_180"]},{"type":"op","aoid":"quantum","id":"eqn-decimal128-quantum","referencingIds":["_ref_51","_ref_53","_ref_56","_ref_76","_ref_82","_ref_94","_ref_95","_ref_108","_ref_109","_ref_127","_ref_128","_ref_137","_ref_138","_ref_147","_ref_148","_ref_162","_ref_181"]},{"type":"term","term":"exponent","refId":"sec-decimal-intro"},{"type":"term","term":"significand","refId":"sec-decimal-intro"},{"type":"term","term":"normalized","refId":"sec-decimal-intro"},{"type":"term","term":"denormalized","refId":"sec-decimal-intro"},{"type":"term","term":"truncated exponent","refId":"sec-decimal-intro"},{"type":"term","term":"scaled significand","refId":"sec-decimal-intro"},{"type":"clause","id":"sec-decimal-intro","titleHTML":"Introduction","number":"","referencingIds":["_ref_23","_ref_65","_ref_66","_ref_155","_ref_156","_ref_159","_ref_190","_ref_203","_ref_206","_ref_211","_ref_212","_ref_218","_ref_221","_ref_225","_ref_226","_ref_232","_ref_233"]},{"type":"op","aoid":"Decimal128ToDecimalString","refId":"sec-decimal128-decimal128todecimalstring"},{"type":"clause","id":"sec-decimal128-decimal128todecimalstring","title":"Decimal128ToDecimalString ( argument )","titleHTML":"Decimal128ToDecimalString ( <var>argument</var> )","number":"1.1.1","referencingIds":["_ref_166","_ref_168","_ref_172","_ref_174","_ref_175","_ref_177","_ref_182","_ref_184","_ref_210","_ref_224"]},{"type":"op","aoid":"Decimal128ToExponentialString","refId":"sec-decimal128toexponentialstring"},{"type":"clause","id":"sec-decimal128toexponentialstring","title":"Decimal128ToExponentialString ( argument )","titleHTML":"Decimal128ToExponentialString ( <var>argument</var> )","number":"1.1.2","referencingIds":["_ref_169","_ref_171"]},{"type":"op","aoid":"IsIntegralDecimal128","refId":"sec-decimal128-isintegraldecimal128value"},{"type":"clause","id":"sec-decimal128-isintegraldecimal128value","title":"IsIntegralDecimal128 ( argument )","titleHTML":"IsIntegralDecimal128 ( <var>argument</var> )","number":"1.1.3","referencingIds":["_ref_187"]},{"type":"op","aoid":"Decimal128ValueToObject","refId":"sec-decimal128-value-to-object"},{"type":"clause","id":"sec-decimal128-value-to-object","title":"Decimal128ValueToObject ( argument )","titleHTML":"Decimal128ValueToObject ( <var>argument</var> )","number":"1.1.4","referencingIds":["_ref_72","_ref_73","_ref_74","_ref_77","_ref_78","_ref_79","_ref_80","_ref_83","_ref_85","_ref_86","_ref_87","_ref_88","_ref_89","_ref_90","_ref_91","_ref_96","_ref_99","_ref_100","_ref_101","_ref_102","_ref_103","_ref_104","_ref_105","_ref_110","_ref_113","_ref_114","_ref_115","_ref_117","_ref_118","_ref_119","_ref_120","_ref_122","_ref_124","_ref_125","_ref_129","_ref_132","_ref_133","_ref_134","_ref_139","_ref_142","_ref_143","_ref_144","_ref_149","_ref_163"]},{"type":"op","aoid":"EnsureDecimal128Value","refId":"sec-decimal128-d"},{"type":"clause","id":"sec-decimal128-d","title":"EnsureDecimal128Value ( coefficient, intendedExponent, roundingMode )","titleHTML":"EnsureDecimal128Value ( <var>coefficient</var>, <var>intendedExponent</var>, <var>roundingMode</var> )","number":"1.1.5","referencingIds":["_ref_61","_ref_62","_ref_69","_ref_71","_ref_97","_ref_111","_ref_130","_ref_140","_ref_150","_ref_164","_ref_183"]},{"type":"op","aoid":"CanonicalizeDecimal128","refId":"sec-decimal128-canonicalizedecimal128"},{"type":"clause","id":"sec-decimal128-canonicalizedecimal128","title":"CanonicalizeDecimal128 ( d )","titleHTML":"CanonicalizeDecimal128 ( <var>d</var> )","number":"1.1.6","referencingIds":["_ref_167","_ref_170","_ref_173","_ref_176","_ref_178","_ref_179"]},{"type":"clause","id":"sec-decimal-abstract-ops","titleHTML":"Abstract Operations","number":"1.1"},{"type":"term","term":"%Decimal128%","refId":"sec-the-decimal-constructor"},{"type":"clause","id":"sec-the-decimal128-constructor-value","title":"Decimal128 ( x )","titleHTML":"Decimal128 ( <var>x</var> )","number":"1.2.1"},{"type":"clause","id":"sec-the-decimal-constructor","titleHTML":"The Decimal128 Constructor","number":"1.2","referencingIds":["_ref_57","_ref_185"]},{"type":"clause","id":"sec-the-decimal-object","titleHTML":"The Decimal128 Object","number":"1"},{"type":"clause","id":"sec-decimal.prototype.isnan","titleHTML":"Decimal128.prototype.isNaN ( )","number":"2.1"},{"type":"clause","id":"sec-decimal.prototype.isfinite","titleHTML":"Decimal128.prototype.isFinite ( )","number":"2.2"},{"type":"clause","id":"sec-decimal.prototype.abs","titleHTML":"Decimal128.prototype.abs ( )","number":"2.3"},{"type":"clause","id":"sec-decimal.prototype.negate","titleHTML":"Decimal128.prototype.negate ( )","number":"2.4"},{"type":"clause","id":"sec-decimal.prototype.add","title":"Decimal128.prototype.add ( x )","titleHTML":"Decimal128.prototype.add ( <var>x</var> )","number":"2.5"},{"type":"clause","id":"sec-decimal.prototype.subtract","title":"Decimal128.prototype.subtract ( x )","titleHTML":"Decimal128.prototype.subtract ( <var>x</var> )","number":"2.6"},{"type":"clause","id":"sec-decimal.prototype.multiply","title":"Decimal128.prototype.multiply ( x )","titleHTML":"Decimal128.prototype.multiply ( <var>x</var> )","number":"2.7"},{"type":"clause","id":"sec-decimal.prototype.divide","title":"Decimal128.prototype.divide ( x )","titleHTML":"Decimal128.prototype.divide ( <var>x</var> )","number":"2.8"},{"type":"clause","id":"sec-decimal.prototype.remainder","title":"Decimal128.prototype.remainder ( x )","titleHTML":"Decimal128.prototype.remainder ( <var>x</var> )","number":"2.9"},{"type":"clause","id":"sec-decimal.prototype.equals","title":"Decimal128.prototype.equals ( x )","titleHTML":"Decimal128.prototype.equals ( <var>x</var> )","number":"2.10","referencingIds":["_ref_1"]},{"type":"clause","id":"sec-decimal.prototype.lessthan","title":"Decimal128.prototype.lessThan ( x )","titleHTML":"Decimal128.prototype.lessThan ( <var>x</var> )","number":"2.11","referencingIds":["_ref_0"]},{"type":"clause","id":"sec-decimal.prototype.compare","title":"Decimal128.prototype.compare ( x )","titleHTML":"Decimal128.prototype.compare ( <var>x</var> )","number":"2.12"},{"type":"clause","id":"sec-decimal-method-round","title":"Decimal128.prototype.round ( numFractionalDigits [ , roundingMode ] )","titleHTML":"Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )","number":"2.13"},{"type":"clause","id":"sec-decimal.prototype.tostring","title":"Decimal128.prototype.toString ( [ options ] )","titleHTML":"Decimal128.prototype.toString ( [ <var>options</var> ] )","number":"2.14","referencingIds":["_ref_5"]},{"type":"clause","id":"sec-decimal.prototype.toexponential","title":"Decimal128.prototype.toExponential ( [ shouldCanonicalize ] )","titleHTML":"Decimal128.prototype.toExponential ( [ <var>shouldCanonicalize</var> ] )","number":"2.15","referencingIds":["_ref_4"]},{"type":"clause","id":"sec-decimal.prototype.tofixed","title":"Decimal128.prototype.toFixed ( numDigits [ , shouldCanonicalize ] )","titleHTML":"Decimal128.prototype.toFixed ( <var>numDigits</var> [ , <var>shouldCanonicalize</var> ] )","number":"2.16"},{"type":"clause","id":"sec-decimal.prototype.toprecision","title":"Decimal128.prototype.toPrecision ( precision [ , shouldCanonicalize ] )","titleHTML":"Decimal128.prototype.toPrecision ( <var>precision</var> [ , <var>shouldCanonicalize</var> ] )","number":"2.17"},{"type":"clause","id":"sec-decimal.prototype.valueof","title":"Decimal128.prototype.valueOf ( x )","titleHTML":"Decimal128.prototype.valueOf ( <var>x</var> )","number":"2.18"},{"type":"clause","id":"sec-decimal-prototype-properties","titleHTML":"Properties of the Decimal128 Prototype","number":"2"},{"type":"clause","id":"sec-number-constructor-number-value","title":"Number ( value )","titleHTML":"Number ( <var>value</var> )","number":"3.1.1.1"},{"type":"clause","id":"sec-number-constructor","titleHTML":"The Number Constructor","number":"3.1.1"},{"type":"clause","id":"sec-number-objects","titleHTML":"Number Objects","number":"3.1"},{"type":"op","aoid":"Decimal128ToBigInt","refId":"sec-numbertobigint"},{"type":"clause","id":"sec-numbertobigint","title":"Decimal128ToBigInt ( number )","titleHTML":"<ins>Decimal128ToBigInt ( <var>number</var> )</ins>","number":"3.2.1.1.1","referencingIds":["_ref_186"]},{"type":"clause","id":"sec-bigint-constructor-number-value","title":"BigInt ( value )","titleHTML":"BigInt ( <var>value</var> )","number":"3.2.1.1"},{"type":"clause","id":"sec-bigint-constructor","titleHTML":"The BigInt Constructor","number":"3.2.1"},{"type":"clause","id":"sec-bigint-objects","titleHTML":"BigInt Objects","number":"3.2"},{"type":"clause","id":"sec-numbers-and-dates","titleHTML":"Numbers and Dates","number":"3"},{"type":"clause","id":"sec-decimal-intl","titleHTML":"Amendments to the ECMAScript® 2024 Internationalization API Specification","number":""},{"type":"term","term":"Intl mathematical value","id":"intl-mathematical-value","referencingIds":["_ref_188","_ref_197","_ref_231"]},{"type":"op","aoid":"ToIntlMathematicalValue","refId":"sec-tointlmathematicalvalue"},{"type":"clause","id":"sec-tointlmathematicalvalue","title":"ToIntlMathematicalValue ( value )","titleHTML":"ToIntlMathematicalValue ( <var>value</var> )","number":"4.1.1"},{"type":"op","aoid":"FormatNumericToString","refId":"sec-formatnumberstring"},{"type":"clause","id":"sec-formatnumberstring","title":"FormatNumericToString ( intlObject, x )","titleHTML":"FormatNumericToString ( <var>intlObject</var>, <var>x</var> )","number":"4.1.2","referencingIds":["_ref_235"]},{"type":"op","aoid":"ToRawPrecisionFn","id":"eqn-ToRawPrecisionFn","referencingIds":["_ref_215","_ref_217"]},{"type":"op","aoid":"ToRawPrecision","refId":"sec-torawprecision"},{"type":"clause","id":"sec-torawprecision","title":"ToRawPrecision ( x, minPrecision, maxPrecision, unsignedRoundingMode )","titleHTML":"ToRawPrecision ( <var>x</var>, <var>minPrecision</var>, <var>maxPrecision</var>, <var>unsignedRoundingMode</var> )","number":"4.1.3","referencingIds":["_ref_199","_ref_201"]},{"type":"op","aoid":"ToRawFixedFn","id":"eqn-ToRawFixedFn","referencingIds":["_ref_228","_ref_230"]},{"type":"op","aoid":"ToRawFixed","refId":"sec-torawfixed"},{"type":"clause","id":"sec-torawfixed","title":"ToRawFixed ( x, minFraction, maxFraction, roundingIncrement, unsignedRoundingMode )","titleHTML":"ToRawFixed ( <var>x</var>, <var>minFraction</var>, <var>maxFraction</var>, <var>roundingIncrement</var>, <var>unsignedRoundingMode</var> )","number":"4.1.4","referencingIds":["_ref_200","_ref_202"]},{"type":"op","aoid":"PartitionNumberPattern","refId":"sec-partitionnumberpattern"},{"type":"clause","id":"sec-partitionnumberpattern","title":"PartitionNumberPattern ( numberFormat, x )","titleHTML":"PartitionNumberPattern ( <var>numberFormat</var>, <var>x</var> )","number":"4.1.5"},{"type":"clause","id":"sec-numberformat-abstracts","titleHTML":"Abstract Operations for NumberFormat Objects","number":"4.1"},{"type":"clause","id":"numberformat-objects","titleHTML":"NumberFormat Objects","number":"4"},{"type":"clause","id":"sec-copyright-and-software-license","title":"Copyright & Software License","titleHTML":"Copyright &amp; Software License","number":"A"}]}`);
+let biblio = JSON.parse(`{"refsByClause":{"sec-decimal.prototype.exponent":["_ref_0","_ref_88","_ref_89","_ref_90","_ref_91","_ref_92"],"sec-decimal.prototype.mantissa":["_ref_1","_ref_93","_ref_94","_ref_95","_ref_96","_ref_97","_ref_98"],"sec-decimal.prototype.compare":["_ref_2","_ref_3","_ref_4","_ref_5"],"sec-decimal-method-round":["_ref_6","_ref_7","_ref_214","_ref_215","_ref_216","_ref_217","_ref_218","_ref_219","_ref_220","_ref_221","_ref_222","_ref_223","_ref_224","_ref_225","_ref_226"],"sec-decimal.prototype.toprecision":["_ref_8","_ref_239","_ref_240","_ref_241","_ref_242","_ref_243","_ref_244"],"sec-tointlmathematicalvalue":["_ref_9","_ref_248","_ref_249","_ref_250","_ref_251","_ref_252","_ref_253","_ref_254"],"sec-decimal-intro":["_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"],"sec-decimal128-abs":["_ref_60","_ref_61","_ref_62"],"sec-decimal128-negate":["_ref_63","_ref_64"],"sec-decimal128-nonnegativedecimal128todecimalstring":["_ref_65","_ref_66","_ref_67"],"sec-decimal128-decimal128todecimalstring":["_ref_68","_ref_69","_ref_70"],"sec-decimal128toexponentialstring":["_ref_71","_ref_72"],"sec-decimal128-isintegraldecimal128value":["_ref_73","_ref_74"],"sec-decimal128-value-to-object":["_ref_75"],"sec-decimal128-d":["_ref_76","_ref_77","_ref_78","_ref_79","_ref_80"],"sec-the-decimal128-constructor-value":["_ref_81"],"sec-runtime-semantics-stringdecimalvalue":["_ref_82","_ref_83","_ref_84","_ref_85","_ref_86","_ref_87"],"sec-decimal.prototype.abs":["_ref_99","_ref_100"],"sec-decimal.prototype.negate":["_ref_101","_ref_102"],"sec-decimal.prototype.add":["_ref_103","_ref_104","_ref_105","_ref_106","_ref_107","_ref_108","_ref_109","_ref_110","_ref_111","_ref_112","_ref_113","_ref_114","_ref_115","_ref_116","_ref_117","_ref_118","_ref_119","_ref_120","_ref_121","_ref_122","_ref_123","_ref_124","_ref_125","_ref_126","_ref_127","_ref_128","_ref_129"],"sec-decimal.prototype.subtract":["_ref_130","_ref_131","_ref_132","_ref_133","_ref_134","_ref_135","_ref_136","_ref_137","_ref_138","_ref_139","_ref_140","_ref_141","_ref_142","_ref_143","_ref_144","_ref_145","_ref_146","_ref_147","_ref_148","_ref_149","_ref_150","_ref_151","_ref_152"],"sec-decimal.prototype.multiply":["_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","_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"],"sec-decimal.prototype.divide":["_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","_ref_198","_ref_199"],"sec-decimal.prototype.remainder":["_ref_200","_ref_201","_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-decimal-method-scale10":["_ref_227","_ref_228","_ref_229","_ref_230","_ref_231","_ref_232","_ref_233","_ref_234"],"sec-decimal.prototype.tostring":["_ref_235","_ref_236"],"sec-decimal.prototype.toexponential":["_ref_237"],"sec-decimal.prototype.tofixed":["_ref_238"],"sec-number-constructor-number-value":["_ref_245"],"sec-bigint-constructor-number-value":["_ref_246"],"sec-numbertobigint":["_ref_247"],"sec-formatnumberstring":["_ref_255","_ref_256","_ref_257","_ref_258","_ref_259","_ref_260","_ref_261","_ref_262"],"sec-torawprecision":["_ref_263","_ref_264","_ref_265","_ref_266","_ref_267","_ref_268","_ref_269","_ref_270","_ref_271","_ref_272","_ref_273","_ref_274","_ref_275","_ref_276","_ref_277"],"sec-torawfixed":["_ref_278","_ref_279","_ref_280","_ref_281","_ref_282","_ref_283","_ref_284","_ref_285","_ref_286","_ref_287","_ref_288","_ref_289","_ref_290"],"sec-partitionnumberpattern":["_ref_291","_ref_292","_ref_293","_ref_294","_ref_295"]},"entries":[{"type":"clause","id":"sec-decimal-intro-","titleHTML":"Introduction","number":""},{"type":"term","term":"finite","id":"dfn-decimal128-finite","referencingIds":["_ref_14","_ref_15","_ref_18","_ref_19","_ref_22","_ref_34","_ref_35","_ref_40","_ref_43","_ref_46","_ref_48","_ref_51","_ref_56","_ref_59","_ref_73","_ref_89","_ref_94","_ref_249","_ref_265","_ref_280"]},{"type":"term","term":"zero","id":"dfn-decimal128-zero","referencingIds":["_ref_10","_ref_11","_ref_16","_ref_20","_ref_21","_ref_23","_ref_27","_ref_28","_ref_36","_ref_41","_ref_44","_ref_47","_ref_49","_ref_52","_ref_55","_ref_57","_ref_58","_ref_90","_ref_95","_ref_157","_ref_162","_ref_251","_ref_273"]},{"type":"term","term":"negative","refId":"sec-decimal-intro"},{"type":"term","term":"mathematical value","id":"dfn-decimal128-mathematical-value","referencingIds":["_ref_2","_ref_3","_ref_4","_ref_5","_ref_9","_ref_12","_ref_13","_ref_17","_ref_37","_ref_76","_ref_77","_ref_88","_ref_92","_ref_93","_ref_252","_ref_253","_ref_254","_ref_255","_ref_256","_ref_258","_ref_264","_ref_267","_ref_268","_ref_269","_ref_274","_ref_276","_ref_279","_ref_282","_ref_283","_ref_287","_ref_289","_ref_294"]},{"type":"term","term":"rounding mode","id":"dfn-decimal128-rounding-mode","referencingIds":["_ref_24","_ref_25","_ref_29","_ref_78","_ref_103","_ref_130","_ref_153","_ref_184","_ref_200","_ref_214","_ref_216","_ref_226","_ref_234"]},{"type":"term","term":"default rounding mode","id":"dfn-decimal128-default-rounding-mode","referencingIds":["_ref_6","_ref_7"]},{"type":"table","id":"table-decimal128-rounding-modes","number":1,"caption":"Table 1: Rounding modes in Decimal128 compared to IEEE 754 rounding modes"},{"type":"op","aoid":"cohort","id":"eqn-decimal128-cohort","referencingIds":["_ref_30","_ref_31","_ref_32","_ref_33","_ref_61","_ref_63","_ref_66","_ref_71","_ref_74","_ref_83","_ref_91","_ref_96","_ref_111","_ref_112","_ref_138","_ref_139","_ref_164","_ref_167","_ref_188","_ref_189","_ref_204","_ref_205","_ref_220","_ref_230","_ref_240"]},{"type":"op","aoid":"quantum","id":"eqn-decimal128-quantum","referencingIds":["_ref_62","_ref_64","_ref_67","_ref_72","_ref_84","_ref_113","_ref_114","_ref_140","_ref_141","_ref_168","_ref_169","_ref_190","_ref_191","_ref_206","_ref_207","_ref_221","_ref_231","_ref_241"]},{"type":"term","term":"exponent","id":"dfn-decimal128-exponent","referencingIds":["_ref_0","_ref_38","_ref_45","_ref_50","_ref_53","_ref_54"]},{"type":"term","term":"significand","id":"dfn-decimal128-significand","referencingIds":["_ref_1","_ref_39","_ref_42"]},{"type":"term","term":"normalized","refId":"sec-decimal-intro"},{"type":"term","term":"denormalized","refId":"sec-decimal-intro"},{"type":"term","term":"truncated exponent","refId":"sec-decimal-intro"},{"type":"term","term":"scaled significand","refId":"sec-decimal-intro"},{"type":"clause","id":"sec-decimal-intro","titleHTML":"Introduction","number":"","referencingIds":["_ref_26","_ref_60","_ref_65","_ref_70","_ref_170","_ref_173","_ref_176","_ref_179","_ref_192","_ref_195","_ref_215","_ref_250","_ref_263","_ref_266","_ref_271","_ref_272","_ref_278","_ref_281","_ref_285","_ref_286","_ref_292","_ref_293"]},{"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.1","referencingIds":["_ref_68","_ref_100"]},{"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.2","referencingIds":["_ref_102"]},{"type":"op","aoid":"NonNegativeDecimal128ToDecimalString","refId":"sec-decimal128-nonnegativedecimal128todecimalstring"},{"type":"clause","id":"sec-decimal128-nonnegativedecimal128todecimalstring","title":"NonNegativeDecimal128ToDecimalString ( argument, shouldCanonicalize )","titleHTML":"NonNegativeDecimal128ToDecimalString ( <var>argument</var>, <var>shouldCanonicalize</var> )","number":"1.1.3","referencingIds":["_ref_69"]},{"type":"op","aoid":"Decimal128ToDecimalString","refId":"sec-decimal128-decimal128todecimalstring"},{"type":"clause","id":"sec-decimal128-decimal128todecimalstring","title":"Decimal128ToDecimalString ( argument, shouldCanonicalize )","titleHTML":"Decimal128ToDecimalString ( <var>argument</var>, <var>shouldCanonicalize</var> )","number":"1.1.4","referencingIds":["_ref_235","_ref_238","_ref_239","_ref_242","_ref_244","_ref_270","_ref_284"]},{"type":"op","aoid":"Decimal128ToExponentialString","refId":"sec-decimal128toexponentialstring"},{"type":"clause","id":"sec-decimal128toexponentialstring","title":"Decimal128ToExponentialString ( argument, shouldCanonicalize )","titleHTML":"Decimal128ToExponentialString ( <var>argument</var>, <var>shouldCanonicalize</var> )","number":"1.1.5","referencingIds":["_ref_236","_ref_237","_ref_245"]},{"type":"op","aoid":"IsIntegralDecimal128","refId":"sec-decimal128-isintegraldecimal128value"},{"type":"clause","id":"sec-decimal128-isintegraldecimal128value","title":"IsIntegralDecimal128 ( argument )","titleHTML":"IsIntegralDecimal128 ( <var>argument</var> )","number":"1.1.6","referencingIds":["_ref_247"]},{"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_97","_ref_99","_ref_101","_ref_104","_ref_105","_ref_106","_ref_107","_ref_108","_ref_109","_ref_110","_ref_115","_ref_116","_ref_117","_ref_118","_ref_119","_ref_120","_ref_121","_ref_122","_ref_123","_ref_124","_ref_125","_ref_126","_ref_127","_ref_128","_ref_131","_ref_132","_ref_133","_ref_134","_ref_135","_ref_136","_ref_137","_ref_142","_ref_143","_ref_144","_ref_145","_ref_146","_ref_147","_ref_148","_ref_149","_ref_150","_ref_151","_ref_154","_ref_155","_ref_156","_ref_158","_ref_159","_ref_160","_ref_161","_ref_163","_ref_165","_ref_166","_ref_171","_ref_172","_ref_174","_ref_175","_ref_177","_ref_178","_ref_180","_ref_181","_ref_182","_ref_185","_ref_186","_ref_187","_ref_193","_ref_194","_ref_196","_ref_197","_ref_198","_ref_201","_ref_202","_ref_203","_ref_208","_ref_209","_ref_210","_ref_211","_ref_212","_ref_217","_ref_218","_ref_219","_ref_222","_ref_223","_ref_225","_ref_227","_ref_228","_ref_229","_ref_232"]},{"type":"op","aoid":"EnsureDecimal128Value","refId":"sec-decimal128-d"},{"type":"clause","id":"sec-decimal128-d","title":"EnsureDecimal128Value ( coefficient, intendedExponent, roundingMode )","titleHTML":"EnsureDecimal128Value ( <var>coefficient</var>, <var>intendedExponent</var>, <var>roundingMode</var> )","number":"1.1.8","referencingIds":["_ref_79","_ref_80","_ref_85","_ref_86","_ref_87","_ref_98","_ref_129","_ref_152","_ref_183","_ref_199","_ref_213","_ref_224","_ref_233","_ref_243"]},{"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_81","_ref_82"]},{"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_75"]},{"type":"clause","id":"sec-the-decimal-object","titleHTML":"The Decimal128 Object","number":"1"},{"type":"clause","id":"sec-decimal.prototype.isnan","titleHTML":"Decimal128.prototype.isNaN ( )","number":"2.1"},{"type":"clause","id":"sec-decimal.prototype.isfinite","titleHTML":"Decimal128.prototype.isFinite ( )","number":"2.2"},{"type":"clause","id":"sec-decimal.prototype.exponent","titleHTML":"Decimal128.prototype.exponent ( )","number":"2.3"},{"type":"clause","id":"sec-decimal.prototype.mantissa","titleHTML":"Decimal128.prototype.mantissa ( )","number":"2.4"},{"type":"clause","id":"sec-decimal.prototype.abs","titleHTML":"Decimal128.prototype.abs ( )","number":"2.5"},{"type":"clause","id":"sec-decimal.prototype.negate","titleHTML":"Decimal128.prototype.negate ( )","number":"2.6"},{"type":"clause","id":"sec-decimal.prototype.add","title":"Decimal128.prototype.add ( x )","titleHTML":"Decimal128.prototype.add ( <var>x</var> )","number":"2.7"},{"type":"clause","id":"sec-decimal.prototype.subtract","title":"Decimal128.prototype.subtract ( x )","titleHTML":"Decimal128.prototype.subtract ( <var>x</var> )","number":"2.8"},{"type":"clause","id":"sec-decimal.prototype.multiply","title":"Decimal128.prototype.multiply ( x )","titleHTML":"Decimal128.prototype.multiply ( <var>x</var> )","number":"2.9"},{"type":"clause","id":"sec-decimal.prototype.divide","title":"Decimal128.prototype.divide ( x )","titleHTML":"Decimal128.prototype.divide ( <var>x</var> )","number":"2.10"},{"type":"clause","id":"sec-decimal.prototype.remainder","title":"Decimal128.prototype.remainder ( x )","titleHTML":"Decimal128.prototype.remainder ( <var>x</var> )","number":"2.11"},{"type":"clause","id":"sec-decimal.prototype.compare","title":"Decimal128.prototype.compare ( x )","titleHTML":"Decimal128.prototype.compare ( <var>x</var> )","number":"2.12"},{"type":"clause","id":"sec-decimal-method-round","title":"Decimal128.prototype.round ( numFractionalDigits [ , roundingMode ] )","titleHTML":"Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )","number":"2.13"},{"type":"clause","id":"sec-decimal-method-scale10","title":"Decimal128.prototype.scale10 ( n )","titleHTML":"Decimal128.prototype.scale10 ( <var>n</var> )","number":"2.14"},{"type":"clause","id":"sec-decimal.prototype.tostring","title":"Decimal128.prototype.toString ( [ options ] )","titleHTML":"Decimal128.prototype.toString ( [ <var>options</var> ] )","number":"2.15","referencingIds":["_ref_8"]},{"type":"clause","id":"sec-decimal.prototype.toexponential","title":"Decimal128.prototype.toExponential ( [ options ] )","titleHTML":"Decimal128.prototype.toExponential ( [ <var>options</var> ] )","number":"2.16"},{"type":"clause","id":"sec-decimal.prototype.tofixed","title":"Decimal128.prototype.toFixed ( [ options ] )","titleHTML":"Decimal128.prototype.toFixed ( [ <var>options</var> ] )","number":"2.17"},{"type":"clause","id":"sec-decimal.prototype.toprecision","title":"Decimal128.prototype.toPrecision ( [ options ] )","titleHTML":"Decimal128.prototype.toPrecision ( [ <var>options</var> ] )","number":"2.18"},{"type":"clause","id":"sec-decimal.prototype.valueof","title":"Decimal128.prototype.valueOf ( x )","titleHTML":"Decimal128.prototype.valueOf ( <var>x</var> )","number":"2.19"},{"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_246"]},{"type":"clause","id":"sec-bigint-constructor-number-value","title":"BigInt ( value )","titleHTML":"BigInt ( <var>value</var> )","number":"3.2.1.1"},{"type":"clause","id":"sec-bigint-constructor","titleHTML":"The BigInt Constructor","number":"3.2.1"},{"type":"clause","id":"sec-bigint-objects","titleHTML":"BigInt Objects","number":"3.2"},{"type":"clause","id":"sec-numbers-and-dates","titleHTML":"Numbers and Dates","number":"3"},{"type":"clause","id":"sec-decimal-intl","titleHTML":"Amendments to the ECMAScript® 2024 Internationalization API Specification","number":""},{"type":"term","term":"Intl mathematical value","id":"intl-mathematical-value","referencingIds":["_ref_248","_ref_257","_ref_291"]},{"type":"op","aoid":"ToIntlMathematicalValue","refId":"sec-tointlmathematicalvalue"},{"type":"clause","id":"sec-tointlmathematicalvalue","title":"ToIntlMathematicalValue ( value )","titleHTML":"ToIntlMathematicalValue ( <var>value</var> )","number":"4.1.1"},{"type":"op","aoid":"FormatNumericToString","refId":"sec-formatnumberstring"},{"type":"clause","id":"sec-formatnumberstring","title":"FormatNumericToString ( intlObject, x )","titleHTML":"FormatNumericToString ( <var>intlObject</var>, <var>x</var> )","number":"4.1.2","referencingIds":["_ref_295"]},{"type":"op","aoid":"ToRawPrecisionFn","id":"eqn-ToRawPrecisionFn","referencingIds":["_ref_275","_ref_277"]},{"type":"op","aoid":"ToRawPrecision","refId":"sec-torawprecision"},{"type":"clause","id":"sec-torawprecision","title":"ToRawPrecision ( x, minPrecision, maxPrecision, unsignedRoundingMode )","titleHTML":"ToRawPrecision ( <var>x</var>, <var>minPrecision</var>, <var>maxPrecision</var>, <var>unsignedRoundingMode</var> )","number":"4.1.3","referencingIds":["_ref_259","_ref_261"]},{"type":"op","aoid":"ToRawFixedFn","id":"eqn-ToRawFixedFn","referencingIds":["_ref_288","_ref_290"]},{"type":"op","aoid":"ToRawFixed","refId":"sec-torawfixed"},{"type":"clause","id":"sec-torawfixed","title":"ToRawFixed ( x, minFraction, maxFraction, roundingIncrement, unsignedRoundingMode )","titleHTML":"ToRawFixed ( <var>x</var>, <var>minFraction</var>, <var>maxFraction</var>, <var>roundingIncrement</var>, <var>unsignedRoundingMode</var> )","number":"4.1.4","referencingIds":["_ref_260","_ref_262"]},{"type":"op","aoid":"PartitionNumberPattern","refId":"sec-partitionnumberpattern"},{"type":"clause","id":"sec-partitionnumberpattern","title":"PartitionNumberPattern ( numberFormat, x )","titleHTML":"PartitionNumberPattern ( <var>numberFormat</var>, <var>x</var> )","number":"4.1.5"},{"type":"clause","id":"sec-numberformat-abstracts","titleHTML":"Abstract Operations for NumberFormat Objects","number":"4.1"},{"type":"clause","id":"numberformat-objects","titleHTML":"NumberFormat Objects","number":"4"},{"type":"clause","id":"sec-copyright-and-software-license","title":"Copyright & Software License","titleHTML":"Copyright &amp; Software License","number":"A"}]}`);
 ;let usesMultipage = false</script><style>/* IBM Plex fonts (Latin subset) have been downloaded from Google Fonts and modified to add support back in for the `zero` substitution (slashed zeroes) */
 
 /* https://fonts.googleapis.com/css2?family=IBM%20Plex%20Serif:ital,wght@0,400;0,700;1,400;1,700&display=swap */
@@ -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-none"></span><a href="#sec-decimal128-decimal128todecimalstring" title="Decimal128ToDecimalString ( argument )"><span class="secnum">1.1.1</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.2</span> Decimal128ToExponentialString ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-isintegraldecimal128value" title="IsIntegralDecimal128 ( argument )"><span class="secnum">1.1.3</span> IsIntegralDecimal128 ( <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.4</span> Decimal128ValueToObject ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-d" title="EnsureDecimal128Value ( coefficient, intendedExponent, roundingMode )"><span class="secnum">1.1.5</span> EnsureDecimal128Value ( <var>coefficient</var>, <var>intendedExponent</var>, <var>roundingMode</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-canonicalizedecimal128" title="CanonicalizeDecimal128 ( d )"><span class="secnum">1.1.6</span> CanonicalizeDecimal128 ( <var>d</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-none"></span><a href="#sec-the-decimal128-constructor-value" title="Decimal128 ( x )"><span class="secnum">1.2.1</span> Decimal128 ( <var>x</var> )</a></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-decimal.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-decimal.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-decimal.prototype.abs" title="Decimal128.prototype.abs ( )"><span class="secnum">2.3</span> Decimal128.prototype.abs ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.negate" title="Decimal128.prototype.negate ( )"><span class="secnum">2.4</span> Decimal128.prototype.negate ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.add" title="Decimal128.prototype.add ( x )"><span class="secnum">2.5</span> Decimal128.prototype.add ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.subtract" title="Decimal128.prototype.subtract ( x )"><span class="secnum">2.6</span> Decimal128.prototype.subtract ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.multiply" title="Decimal128.prototype.multiply ( x )"><span class="secnum">2.7</span> Decimal128.prototype.multiply ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.divide" title="Decimal128.prototype.divide ( x )"><span class="secnum">2.8</span> Decimal128.prototype.divide ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.remainder" title="Decimal128.prototype.remainder ( x )"><span class="secnum">2.9</span> Decimal128.prototype.remainder ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.equals" title="Decimal128.prototype.equals ( x )"><span class="secnum">2.10</span> Decimal128.prototype.equals ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.lessthan" title="Decimal128.prototype.lessThan ( x )"><span class="secnum">2.11</span> Decimal128.prototype.lessThan ( <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.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-decimal-method-round" title="Decimal128.prototype.round ( numFractionalDigits [ , roundingMode ] )"><span class="secnum">2.13</span> Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.tostring" title="Decimal128.prototype.toString ( [ options ] )"><span class="secnum">2.14</span> Decimal128.prototype.toString ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.toexponential" title="Decimal128.prototype.toExponential ( [ shouldCanonicalize ] )"><span class="secnum">2.15</span> Decimal128.prototype.toExponential ( [ <var>shouldCanonicalize</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.tofixed" title="Decimal128.prototype.toFixed ( numDigits [ , shouldCanonicalize ] )"><span class="secnum">2.16</span> Decimal128.prototype.toFixed ( <var>numDigits</var> [ , <var>shouldCanonicalize</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.toprecision" title="Decimal128.prototype.toPrecision ( precision [ , shouldCanonicalize ] )"><span class="secnum">2.17</span> Decimal128.prototype.toPrecision ( <var>precision</var> [ , <var>shouldCanonicalize</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.valueof" title="Decimal128.prototype.valueOf ( x )"><span class="secnum">2.18</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-none"></span><a href="#sec-decimal-intl" title="Amendments to the ECMAScript® 2024 Internationalization API Specification">Amendments to the ECMAScript® 2024 Internationalization API Specification</a></li><li><span class="item-toggle">+</span><a href="#numberformat-objects" title="NumberFormat Objects"><span class="secnum">4</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.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.1.1</span> ToIntlMathematicalValue ( <var>value</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-formatnumberstring" title="FormatNumericToString ( intlObject, x )"><span class="secnum">4.1.2</span> FormatNumericToString ( <var>intlObject</var>, <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-torawprecision" title="ToRawPrecision ( x, minPrecision, maxPrecision, unsignedRoundingMode )"><span class="secnum">4.1.3</span> ToRawPrecision ( <var>x</var>, <var>minPrecision</var>, <var>maxPrecision</var>, <var>unsignedRoundingMode</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-torawfixed" title="ToRawFixed ( x, minFraction, maxFraction, roundingIncrement, unsignedRoundingMode )"><span class="secnum">4.1.4</span> ToRawFixed ( <var>x</var>, <var>minFraction</var>, <var>maxFraction</var>, <var>roundingIncrement</var>, <var>unsignedRoundingMode</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-partitionnumberpattern" title="PartitionNumberPattern ( numberFormat, x )"><span class="secnum">4.1.5</span> PartitionNumberPattern ( <var>numberFormat</var>, <var>x</var> )</a></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 / June 11, 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-none"></span><a href="#sec-decimal128-abs" title="Decimal128Abs ( argument )"><span class="secnum">1.1.1</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.2</span> Decimal128Negate ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-nonnegativedecimal128todecimalstring" title="NonNegativeDecimal128ToDecimalString ( argument, shouldCanonicalize )"><span class="secnum">1.1.3</span> NonNegativeDecimal128ToDecimalString ( <var>argument</var>, <var>shouldCanonicalize</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-decimal128todecimalstring" title="Decimal128ToDecimalString ( argument, shouldCanonicalize )"><span class="secnum">1.1.4</span> Decimal128ToDecimalString ( <var>argument</var>, <var>shouldCanonicalize</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128toexponentialstring" title="Decimal128ToExponentialString ( argument, shouldCanonicalize )"><span class="secnum">1.1.5</span> Decimal128ToExponentialString ( <var>argument</var>, <var>shouldCanonicalize</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-isintegraldecimal128value" title="IsIntegralDecimal128 ( argument )"><span class="secnum">1.1.6</span> IsIntegralDecimal128 ( <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><li><span class="item-toggle-none"></span><a href="#sec-decimal128-d" title="EnsureDecimal128Value ( coefficient, intendedExponent, roundingMode )"><span class="secnum">1.1.8</span> EnsureDecimal128Value ( <var>coefficient</var>, <var>intendedExponent</var>, <var>roundingMode</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-decimal.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-decimal.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-decimal.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-decimal.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-decimal.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-decimal.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-decimal.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-decimal.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-decimal.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-decimal.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-decimal.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-decimal.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-decimal-method-round" title="Decimal128.prototype.round ( numFractionalDigits [ , roundingMode ] )"><span class="secnum">2.13</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.14</span> Decimal128.prototype.scale10 ( <var>n</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.tostring" title="Decimal128.prototype.toString ( [ options ] )"><span class="secnum">2.15</span> Decimal128.prototype.toString ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.toexponential" title="Decimal128.prototype.toExponential ( [ options ] )"><span class="secnum">2.16</span> Decimal128.prototype.toExponential ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.tofixed" title="Decimal128.prototype.toFixed ( [ options ] )"><span class="secnum">2.17</span> Decimal128.prototype.toFixed ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.toprecision" title="Decimal128.prototype.toPrecision ( [ options ] )"><span class="secnum">2.18</span> Decimal128.prototype.toPrecision ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.valueof" title="Decimal128.prototype.valueOf ( x )"><span class="secnum">2.19</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-none"></span><a href="#sec-decimal-intl" title="Amendments to the ECMAScript® 2024 Internationalization API Specification">Amendments to the ECMAScript® 2024 Internationalization API Specification</a></li><li><span class="item-toggle">+</span><a href="#numberformat-objects" title="NumberFormat Objects"><span class="secnum">4</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.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.1.1</span> ToIntlMathematicalValue ( <var>value</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-formatnumberstring" title="FormatNumericToString ( intlObject, x )"><span class="secnum">4.1.2</span> FormatNumericToString ( <var>intlObject</var>, <var>x</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-torawprecision" title="ToRawPrecision ( x, minPrecision, maxPrecision, unsignedRoundingMode )"><span class="secnum">4.1.3</span> ToRawPrecision ( <var>x</var>, <var>minPrecision</var>, <var>maxPrecision</var>, <var>unsignedRoundingMode</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-torawfixed" title="ToRawFixed ( x, minFraction, maxFraction, roundingIncrement, unsignedRoundingMode )"><span class="secnum">4.1.4</span> ToRawFixed ( <var>x</var>, <var>minFraction</var>, <var>maxFraction</var>, <var>roundingIncrement</var>, <var>unsignedRoundingMode</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-partitionnumberpattern" title="PartitionNumberPattern ( numberFormat, x )"><span class="secnum">4.1.5</span> PartitionNumberPattern ( <var>numberFormat</var>, <var>x</var> )</a></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 / June 12, 2024</h1><h1 class="title">Decimal</h1>
 
 <emu-intro id="sec-decimal-intro-">
   <h1>Introduction</h1>
@@ -3257,25 +3257,25 @@ <h1>Introduction</h1>
       <ul>
         <li><var>v</var> is either
         <ul>
-          <li><emu-val>+0</emu-val><sub>𝔻</sub>, represending non-negative <emu-xref href="#dfn-decimal128-zero" id="_ref_7"><a href="#dfn-decimal128-zero">zero</a></emu-xref> as a decimal value</li>
-          <li><emu-val>-0</emu-val><sub>𝔻</sub>, representing negative <emu-xref href="#dfn-decimal128-zero" id="_ref_8"><a href="#dfn-decimal128-zero">zero</a></emu-xref> as a decimal value, or</li>
-          <li>a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_9"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref></li>
+          <li><emu-val>+0</emu-val><sub>𝔻</sub>, represending non-negative <emu-xref href="#dfn-decimal128-zero" id="_ref_10"><a href="#dfn-decimal128-zero">zero</a></emu-xref> as a decimal value</li>
+          <li><emu-val>-0</emu-val><sub>𝔻</sub>, representing negative <emu-xref href="#dfn-decimal128-zero" id="_ref_11"><a href="#dfn-decimal128-zero">zero</a></emu-xref> as a decimal value, or</li>
+          <li>a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_12"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref></li>
         </ul></li>
         <li><var>q</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> satisfying -6176 ≤ <var>q</var> ≤ 6111,</li>
-        <li>If <var>v</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_10"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, then 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>If <var>v</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_13"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, then 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>
       </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>
     </div></emu-note>
-    <p>A Decimal128 value is said to be <dfn id="dfn-decimal128-finite" tabindex="-1">finite</dfn> if it has the form « <var>v</var>, <var>q</var> »<sub>𝔻</sub>. A <dfn id="dfn-decimal128-zero" tabindex="-1">zero</dfn> Decimal128 value is a <emu-xref href="#dfn-decimal128-finite" id="_ref_11"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value of the form « 0<sub>𝔻</sub>, <var>q</var> »<sub>𝔻</sub> or « -0<sub>𝔻</sub>, <var>q</var> »<sub>𝔻</sub>. A <emu-xref href="#dfn-decimal128-finite" id="_ref_12"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_13"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is one of the form « <var>v</var>, <var>q</var> »<sub>𝔻</sub> where <var>v</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_14"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>. A <emu-xref href="#dfn-decimal128-finite" id="_ref_15"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is said to be <dfn tabindex="-1">negative</dfn> if either <var>v</var> is -0<sub>D</sub> or <var>v</var> is a real number such that <var>v</var> &lt; 0.</p>
-    <p>The <dfn id="dfn-decimal128-mathematical-value" tabindex="-1">mathematical value</dfn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_16"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value <var>x</var> = « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is defined as follows:</p>
+    <p>A Decimal128 value is said to be <dfn id="dfn-decimal128-finite" tabindex="-1">finite</dfn> if it has the form « <var>v</var>, <var>q</var> »<sub>𝔻</sub>. A <dfn id="dfn-decimal128-zero" tabindex="-1">zero</dfn> Decimal128 value is a <emu-xref href="#dfn-decimal128-finite" id="_ref_14"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value of the form « 0<sub>𝔻</sub>, <var>q</var> »<sub>𝔻</sub> or « -0<sub>𝔻</sub>, <var>q</var> »<sub>𝔻</sub>. A <emu-xref href="#dfn-decimal128-finite" id="_ref_15"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_16"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is one of the form « <var>v</var>, <var>q</var> »<sub>𝔻</sub> where <var>v</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_17"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>. A <emu-xref href="#dfn-decimal128-finite" id="_ref_18"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is said to be <dfn tabindex="-1">negative</dfn> if either <var>v</var> is -0<sub>D</sub> or <var>v</var> is a real number such that <var>v</var> &lt; 0.</p>
+    <p>The <dfn id="dfn-decimal128-mathematical-value" tabindex="-1">mathematical value</dfn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_19"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value <var>x</var> = « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is defined as follows:</p>
     <ul>
-      <li>If <var>x</var> is <emu-xref href="#dfn-decimal128-zero" id="_ref_17"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> is 0</li>
-      <li>If <var>x</var> is non-<emu-xref href="#dfn-decimal128-zero" id="_ref_18"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> is v × 10<sup><var>q</var></sup></li>
+      <li>If <var>x</var> is <emu-xref href="#dfn-decimal128-zero" id="_ref_20"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> is 0</li>
+      <li>If <var>x</var> is non-<emu-xref href="#dfn-decimal128-zero" id="_ref_21"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> is v × 10<sup><var>q</var></sup></li>
     </ul>
     <emu-note><span class="note">Note 2</span><div class="note-contents">
-      <p>The <var>v</var> component of a <emu-xref href="#dfn-decimal128-finite" id="_ref_19"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_20"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is a rational number.</p>
+      <p>The <var>v</var> component of a <emu-xref href="#dfn-decimal128-finite" id="_ref_22"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_23"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is a rational number.</p>
     </div></emu-note>
     <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 Decimal128 values</a></emu-xref>. The full spectrum of values defined by Decimal128 are available here, though there is only one Decimal128 value, NaN<sub>𝔻</sub>, representing all possible IEEE 754 Decimal128 NaN values.</p>
     <p>A <dfn id="dfn-decimal128-rounding-mode" tabindex="-1">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>
@@ -3284,9 +3284,9 @@ <h1>Introduction</h1>
       <table class="real-table">
         <thead>
           <tr>
-            <th>Decimal128 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_21"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref></th>
+            <th>Decimal128 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_24"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref></th>
             <th>Description</th>
-            <th>IEEE 754 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_22"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref></th>
+            <th>IEEE 754 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_25"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref></th>
           </tr>
         </thead>
         <tbody>
@@ -3297,17 +3297,17 @@ <h1>Introduction</h1>
           </tr>
           <tr>
             <td><emu-val>"floor"</emu-val></td>
-            <td>Toward <emu-xref href="#sec-decimal-intro" id="_ref_23"><a href="#sec-decimal-intro">negative</a></emu-xref> infinity</td>
+            <td>Toward <emu-xref href="#sec-decimal-intro" id="_ref_26"><a href="#sec-decimal-intro">negative</a></emu-xref> infinity</td>
             <td><emu-val>"roundTowardNegative"</emu-val></td>
           </tr>
           <tr>
             <td><emu-val>"trunc"</emu-val></td>
-            <td>Toward <emu-xref href="#dfn-decimal128-zero" id="_ref_24"><a href="#dfn-decimal128-zero">zero</a></emu-xref></td>
+            <td>Toward <emu-xref href="#dfn-decimal128-zero" id="_ref_27"><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_25"><a href="#dfn-decimal128-zero">zero</a></emu-xref></td>
+            <td>Ties away from <emu-xref href="#dfn-decimal128-zero" id="_ref_28"><a href="#dfn-decimal128-zero">zero</a></emu-xref></td>
             <td><emu-val>"roundTiesToAway"</emu-val></td>
           </tr>
           <tr>
@@ -3317,74 +3317,87 @@ <h1>Introduction</h1>
           </tr>
         </tbody>
       </table>
-      <emu-note><span class="note">Note 3</span><div class="note-contents">The above five rounding modes are defined in IEEE 754. This table is offered for implementors who may need to convert the Decimal128 rounding modes defined here into a library that may use the official IEEE 754 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_26"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref> names. Additional rounding modes are used elsewhere in this specification, such as in <emu-xref href="#table-intl-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-rounding-modes">Intl.NumberFormat</a></emu-xref>.</div></emu-note>
+      <emu-note><span class="note">Note 3</span><div class="note-contents">The above five rounding modes are defined in IEEE 754. This table is offered for implementors who may need to convert the Decimal128 rounding modes defined here into a library that may use the official IEEE 754 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_29"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref> names. Additional rounding modes are used elsewhere in this specification, such as in <emu-xref href="#table-intl-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-rounding-modes">Intl.NumberFormat</a></emu-xref>.</div></emu-note>
     </figure></emu-table>
     <p>The <emu-eqn id="eqn-decimal128-cohort" aoid="cohort" class="inline">cohort(<var>x</var>)</emu-eqn> of a Decimal128 value <var>x</var> is defined as follows:</p>
     <ul>
-      <li><emu-xref aoid="cohort" id="_ref_27"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>) = <emu-val>NaN</emu-val><sub>𝔻</sub></li>
-      <li><emu-xref aoid="cohort" id="_ref_28"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>) = <emu-val>+∞</emu-val><sub>𝔻</sub></li>
-      <li><emu-xref aoid="cohort" id="_ref_29"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>) = <emu-val>-∞</emu-val><sub>𝔻</sub></li>
-      <li><emu-xref aoid="cohort" id="_ref_30"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(« <var>v</var>, <var>q</var> »<sub>𝔻</sub>) = <var>v</var></li>
+      <li><emu-xref aoid="cohort" id="_ref_30"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>) = <emu-val>NaN</emu-val><sub>𝔻</sub></li>
+      <li><emu-xref aoid="cohort" id="_ref_31"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>) = <emu-val>+∞</emu-val><sub>𝔻</sub></li>
+      <li><emu-xref aoid="cohort" id="_ref_32"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>) = <emu-val>-∞</emu-val><sub>𝔻</sub></li>
+      <li><emu-xref aoid="cohort" id="_ref_33"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(« <var>v</var>, <var>q</var> »<sub>𝔻</sub>) = <var>v</var></li>
     </ul>
-    <p>For every <emu-xref href="#dfn-decimal128-finite" id="_ref_31"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value <var>x</var> = « <var>v</var>, <var>q</var> », the <emu-eqn id="eqn-decimal128-quantum" aoid="quantum" class="inline">quantum(<var>x</var>) = <var>q</var></emu-eqn>.</p>
-    <p>For every <emu-xref href="#dfn-decimal128-finite" id="_ref_32"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_33"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> »<sub>𝔻</sub> there exists a unique <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>e</var> and <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_34"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> <var>s</var> such that</p>
+    <p>For every <emu-xref href="#dfn-decimal128-finite" id="_ref_34"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value <var>x</var> = « <var>v</var>, <var>q</var> », the <emu-eqn id="eqn-decimal128-quantum" aoid="quantum" class="inline">quantum(<var>x</var>) = <var>q</var></emu-eqn>.</p>
+    <p>For every <emu-xref href="#dfn-decimal128-finite" id="_ref_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 « <var>v</var>, <var>q</var> »<sub>𝔻</sub> there exists a unique <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>e</var> and <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_37"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> <var>s</var> such that</p>
     <ol>
       <li><var>v</var> = <var>s</var> × 10<sup><var>e</var></sup></li>
       <li>1 ≤ <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>s</var>) &lt; 10</li>
     </ol>
-    <p>We call <var>e</var> the <dfn tabindex="-1">exponent</dfn> and <var>s</var> the <dfn tabindex="-1">significand</dfn> of « <var>v</var>, <var>q</var> »<sub>𝔻</sub>. The exponent and significand are undefined for NaN, non-<emu-xref href="#dfn-decimal128-finite" id="_ref_35"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, and <emu-xref href="#dfn-decimal128-zero" id="_ref_36"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 values.</p>
+    <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>, <var>q</var> »<sub>𝔻</sub>. 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 4</span><div class="note-contents">
-      <p>The significand of a <emu-xref href="#dfn-decimal128-finite" id="_ref_37"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_38"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is a rational number.</p>
+      <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> Decimal128 value is a rational number.</p>
     </div></emu-note>
     <emu-note><span class="note">Note 5</span><div class="note-contents">
-      <p>The exponent <var>e</var> of <emu-xref href="#dfn-decimal128-finite" id="_ref_39"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_40"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 values is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> satisfying 6144 ≥ <var>e</var> ≥ -6176.</p>
+      <p>The <emu-xref href="#dfn-decimal128-exponent" id="_ref_45"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref> <var>e</var> of <emu-xref href="#dfn-decimal128-finite" id="_ref_46"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_47"><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_41"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_42"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is <dfn tabindex="-1">normalized</dfn> if its exponent <var>e</var> satisfies 6144 ≥ <var>e</var> ≥ -6143. A <emu-xref href="#dfn-decimal128-finite" id="_ref_43"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_44"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is <dfn tabindex="-1">denormalized</dfn> if its exponent <var>e</var> satisfies -6144 ≥ <var>e</var> ≥ -6176.</p>
-    <p>For a proper discussion of rounding, we need to separate how rounding occurs with normalized compared with denormlized values. For a normalized Decimal128 value we define its <dfn tabindex="-1">truncated exponent</dfn> as equal to its exponent. For <emu-xref href="#dfn-decimal128-zero" id="_ref_45"><a href="#dfn-decimal128-zero">zero</a></emu-xref> or denormalized Decimal128 values we define the truncated exponent as the constant -6143. Given this, we define the <dfn tabindex="-1">scaled significand</dfn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_46"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value as follows:</p>
+    <p>A <emu-xref href="#dfn-decimal128-finite" id="_ref_48"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_49"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is <dfn tabindex="-1">normalized</dfn> if its <emu-xref href="#dfn-decimal128-exponent" id="_ref_50"><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_51"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_52"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is <dfn tabindex="-1">denormalized</dfn> if its <emu-xref href="#dfn-decimal128-exponent" id="_ref_53"><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 normalized compared with denormlized values. For a normalized Decimal128 value we define its <dfn tabindex="-1">truncated exponent</dfn> as equal to its <emu-xref href="#dfn-decimal128-exponent" id="_ref_54"><a href="#dfn-decimal128-exponent">exponent</a></emu-xref>. For <emu-xref href="#dfn-decimal128-zero" id="_ref_55"><a href="#dfn-decimal128-zero">zero</a></emu-xref> or denormalized Decimal128 values we define the truncated exponent as the constant -6143. Given this, we define the <dfn tabindex="-1">scaled significand</dfn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_56"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value as follows:</p>
     <ul>
-      <li>The scaled significand of a <emu-xref href="#dfn-decimal128-zero" id="_ref_47"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is 0</li>
-      <li>The scaled significand of a non-<emu-xref href="#dfn-decimal128-zero" id="_ref_48"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value _x = « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is v × 10<sup>33 - <var>te</var></sup>, where <var>te</var> is the truncated exponent of <var>x</var>.</li>
+      <li>The scaled significand of a <emu-xref href="#dfn-decimal128-zero" id="_ref_57"><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_58"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value _x = « <var>v</var>, <var>q</var> »<sub>𝔻</sub> is v × 10<sup>33 - <var>te</var></sup>, where <var>te</var> is the truncated exponent of <var>x</var>.</li>
     </ul>
     <emu-note><span class="note">Note 6</span><div class="note-contents">
-      <p>The scaled significand of a <emu-xref href="#dfn-decimal128-finite" id="_ref_49"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value is always an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> whose absolute value is less than 10<sup>34</sup>.</p>
+      <p>The scaled significand of a <emu-xref href="#dfn-decimal128-finite" id="_ref_59"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value is always an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> whose absolute value is less than 10<sup>34</sup>.</p>
     </div></emu-note>
   </emu-intro>
   <emu-clause id="sec-decimal-abstract-ops">
     <h1><span class="secnum">1.1</span> Abstract Operations</h1>
 
+    <emu-clause id="sec-decimal128-abs" type="abstract operation" aoid="Decimal128Abs">
+      <h1><span class="secnum">1.1.1</span> Decimal128Abs ( <var>argument</var> )</h1>
+      <p>The abstract operation Decimal128Abs takes argument <var>argument</var> (a Decimal128 value) and returns either <emu-val>NaN</emu-val><sub>𝔻</sub> or a non-<emu-xref href="#sec-decimal-intro" id="_ref_60"><a href="#sec-decimal-intro">negative</a></emu-xref> Decimal128 value. It computes the absolute value of a Decimal128 value 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>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_61"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>argument</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_62"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>argument</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return « <emu-val>+0</emu-val><sub>𝔻</sub>, <var>q</var>&nbsp;»<sub>𝔻</sub>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return « <emu-val>+0</emu-val><sub>𝔻</sub>, <var>q</var>&nbsp;»<sub>𝔻</sub>.</li><li>Otherwise, return « <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>v</var>), <var>q</var>&nbsp;»<sub>𝔻</sub>.</li></ol></emu-alg>
+    </emu-clause>
+
+    <emu-clause id="sec-decimal128-negate" type="abstract operation" aoid="Decimal128Negate">
+      <h1><span class="secnum">1.1.2</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>
+      <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>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_63"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>argument</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_64"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>argument</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return « <emu-val>-0</emu-val><sub>𝔻</sub>, <var>q</var>&nbsp;»<sub>𝔻</sub>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return « <emu-val>+0</emu-val><sub>𝔻</sub>, <var>q</var>&nbsp;»<sub>𝔻</sub>.</li><li>Otherwise, return « -<var>v</var>, <var>q</var>&nbsp;»<sub>𝔻</sub>.</li></ol></emu-alg>
+    </emu-clause>
+
+    <emu-clause id="sec-decimal128-nonnegativedecimal128todecimalstring" type="abstract operation" aoid="NonNegativeDecimal128ToDecimalString">
+      <h1><span class="secnum">1.1.3</span> NonNegativeDecimal128ToDecimalString ( <var>argument</var>, <var>shouldCanonicalize</var> )</h1>
+      <p>The abstract operation NonNegativeDecimal128ToDecimalString takes arguments <var>argument</var> (a non-<emu-xref href="#sec-decimal-intro" id="_ref_65"><a href="#sec-decimal-intro">negative</a></emu-xref> Decimal128 value) and <var>shouldCanonicalize</var> (a Boolean) and returns a String. It renders <var>argument</var> as a string, possibly in exponential notation if the decimal representation of the number would require too many digits. It performs the following steps when called:</p>
+      <emu-alg><ol><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_66"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>argument</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_67"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>argument</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, let <var>integerPart</var> be <emu-val>"0"</emu-val>.</li><li>Otherwise, if <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, let <var>integerPart</var> be <emu-val>"-0"</emu-val>.</li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> for which <var>v</var> × 10<sup>-<var>q</var></sup> = <var>n</var>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li>Let <var>digits</var> be the unique decimal string representation of <var>n</var> without leading zeroes.</li><li>If <var>q</var> ≥ 0, then<ol><li>Let <var>trailingZeroes</var> be the String <emu-val>"0"</emu-val> repeated <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) - <var>q</var> times.</li><li>Return the concatenation of <var>digits</var> and <var>trailingZeroes</var>.</li></ol></li><li>Let <var>integerPart</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> from 0 to <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) - <var>q</var>.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val> and <var>v</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 <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) - <var>q</var> to the length of <var>digits</var>.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, set <var>nonIntegerPart</var> to a copy of <var>nonIntegerPart</var> with trailing <emu-val>"0"</emu-val>s removed.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>nonIntegerPart</var> is not <emu-val>""</emu-val>.</li><li>Return the concatenation of <var>integerPart</var>, <emu-val>"."</emu-val>, and <var>nonIntegerPart</var>.</li></ol></emu-alg>
+    </emu-clause>
+
     <emu-clause id="sec-decimal128-decimal128todecimalstring" type="abstract operation" aoid="Decimal128ToDecimalString">
-      <h1><span class="secnum">1.1.1</span> Decimal128ToDecimalString ( <var>argument</var> )</h1>
-      <p>The abstract operation Decimal128ToDecimalString takes argument <var>argument</var> (a Decimal128 value) and returns a String. It renders <var>argument</var> as a decimal (non-exponential) string. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If <var>argument</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>argument</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_50"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>argument</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_51"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>argument</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> for which <var>v</var> × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>n</var> is not 0.</li><li>Let <var>digits</var> be the unique decimal string representation of <var>n</var> without leading zeroes.</li><li>If <var>q</var> &lt; 0, then<ol><li>Let <var>trailingZeroes</var> be the String <emu-val>"0"</emu-val> repeated <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) - <var>q</var> times.</li><li>Return the concatenation of <var>digits</var> and <var>trailingZeroes</var>.</li></ol></li><li>Let <var>integerPart</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> from 0 to <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(n) - <var>q</var>.</li><li>Let <var>nonIntegerPart</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> from <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(n) - <var>q</var> to the length of <var>digits</var>.</li><li>Return the concatenation of <var>integerPart</var>, <emu-val>"."</emu-val>, and <var>nonIntegerPart</var>.</li></ol></emu-alg>
+      <h1><span class="secnum">1.1.4</span> Decimal128ToDecimalString ( <var>argument</var>, <var>shouldCanonicalize</var> )</h1>
+      <p>The abstract operation Decimal128ToDecimalString takes arguments <var>argument</var> (a Decimal128 value) and <var>shouldCanonicalize</var> (a Boolean) and returns a String. It renders <var>argument</var> as a string, possibly in exponential notation if the decimal representation of the number would require too many digits. 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>Let <var>abs</var> be <emu-xref aoid="Decimal128Abs" id="_ref_68"><a href="#sec-decimal128-abs">Decimal128Abs</a></emu-xref>(<var>argument</var>).</li><li>Let <var>renderedAbsoluateValue</var> be <emu-xref aoid="NonNegativeDecimal128ToDecimalString" id="_ref_69"><a href="#sec-decimal128-nonnegativedecimal128todecimalstring">NonNegativeDecimal128ToDecimalString</a></emu-xref>(<var>abs</var>, <var>shouldCanonicalize</var>).</li><li>If <var>argument</var> is <emu-xref href="#sec-decimal-intro" id="_ref_70"><a href="#sec-decimal-intro">negative</a></emu-xref>, return the concatenation of <emu-val>"-"</emu-val> and <var>renderedAbsoluateValue</var>.</li><li>Otherwise, return <var>renderedAbsoluateValue</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128toexponentialstring" type="abstract operation" aoid="Decimal128ToExponentialString">
-      <h1><span class="secnum">1.1.2</span> Decimal128ToExponentialString ( <var>argument</var> )</h1>
-      <p>The abstract operation Decimal128ToExponentialString takes argument <var>argument</var> (a Decimal128 value) and returns a String. It renders <var>argument</var> in exponential notation. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If <var>argument</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>argument</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_52"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>argument</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_53"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>argument</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>Let <var>coefficientStr</var> be the unique decimal string representation of <var>v</var> without leading zeroes.</li><li>Let <var>exponentStr</var> be the unique decimal string representation of <var>q</var> without leading zeroes.</li><li>Return the concatenation of <var>coefficientStr</var>, <emu-val>"e"</emu-val>, and <var>exponentStr</var>.</li></ol></emu-alg>
+      <h1><span class="secnum">1.1.5</span> Decimal128ToExponentialString ( <var>argument</var>, <var>shouldCanonicalize</var> )</h1>
+      <p>The abstract operation Decimal128ToExponentialString takes arguments <var>argument</var> (a Decimal128 value) and <var>shouldCanonicalize</var> (a Boolean) and returns a String. It renders <var>argument</var> in exponential notation. It performs the following steps when called:</p>
+      <emu-alg><ol><li>If <var>argument</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>argument</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_71"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>argument</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_72"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>argument</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>Let <var>coefficientStr</var> be the unique decimal string representation of <var>v</var> without leading zeroes.</li><li>Let <var>exponentStr</var> be the unique decimal string representation of <var>q</var> without leading zeroes.</li><li>Return the concatenation of <var>coefficientStr</var>, <emu-val>"e"</emu-val>, and <var>exponentStr</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-isintegraldecimal128value" type="abstract operation" aoid="IsIntegralDecimal128">
-      <h1><span class="secnum">1.1.3</span> IsIntegralDecimal128 ( <var>argument</var> )</h1>
-      <p>The abstract operation IsIntegralDecimal128 takes argument <var>argument</var> (A Decimal128 object) and returns a Boolean. It determines if <var>argument</var> is a <emu-xref href="#dfn-decimal128-finite" id="_ref_54"><a href="#dfn-decimal128-finite">finite</a></emu-xref> integral Decimal128 value. It performs the following steps when called:</p>
-      <emu-alg><ol><li>Let <var>d</var> be <var>argument</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_55"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_56"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and 0 ≤ <var>q</var>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></emu-alg>
+      <h1><span class="secnum">1.1.6</span> IsIntegralDecimal128 ( <var>argument</var> )</h1>
+      <p>The abstract operation IsIntegralDecimal128 takes argument <var>argument</var> (A Decimal128 object) and returns a Boolean. It determines if <var>argument</var> is a <emu-xref href="#dfn-decimal128-finite" id="_ref_73"><a href="#dfn-decimal128-finite">finite</a></emu-xref> integral Decimal128 value. It performs the following steps when called:</p>
+      <emu-alg><ol><li>Let <var>d</var> be <var>argument</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_74"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>If <var>v</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-value-to-object" type="abstract operation" aoid="Decimal128ValueToObject">
-      <h1><span class="secnum">1.1.4</span> Decimal128ValueToObject ( <var>argument</var> )</h1>
+      <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_57"><a href="#sec-the-decimal-constructor">%Decimal128%</a></emu-xref>, <emu-val>"%Decimal128.prototype%"</emu-val>, « <var class="field">[[Decimal128Data]]</var>&nbsp;»).</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <var>argument</var>.</li><li>Return <var>O</var>.</li></ol></emu-alg>
+      <emu-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_75"><a href="#sec-the-decimal-constructor">%Decimal128%</a></emu-xref>, <emu-val>"%Decimal128.prototype%"</emu-val>, « <var class="field">[[Decimal128Data]]</var>&nbsp;»).</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <var>argument</var>.</li><li>Return <var>O</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-d" type="abstract operation" aoid="EnsureDecimal128Value">
-      <h1><span class="secnum">1.1.5</span> EnsureDecimal128Value ( <var>coefficient</var>, <var>intendedExponent</var>, <var>roundingMode</var> )</h1>
-      <p>The abstract operation EnsureDecimal128Value takes arguments <var>coefficient</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_58"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var>intendedExponent</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_59"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), and <var>roundingMode</var> (a Decimal128 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_60"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>) and returns either a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">normal completion containing</a></emu-xref> a Decimal128 value or a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">throw completion</a></emu-xref>. It attempts to convert the pair of arguments, which might be out of range when considered as a Decimal128 value, into a Decimal128 value, throwing an exception if the conversion cannot be done. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If -6111 ≤ <var>intendedExponent</var> ≤ 6176, then<ol><li>If <var>coefficient</var> × 10<sup><var>intendedExponent</var></sup> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>n</var> such that 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>, return « _coefficient, <var>intendedExponent</var>&nbsp;»<sub>𝔻</sub>.</li><li>Throw a <emu-val>RangeError</emu-val> exception.</li></ol></li><li>If <var>intendedExponent</var> &lt; 0, return ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_61"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>coefficient</var> / 10, <var>intendedExponent</var> + 1, <var>roundingMode</var>).</li><li>Otherwise, return ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_62"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>coefficient</var> × 10, <var>intendedExponent</var> + 1, <var>roundingMode</var>).</li></ol></emu-alg>
-    </emu-clause>
-    <emu-clause id="sec-decimal128-canonicalizedecimal128" type="abstract operation" aoid="CanonicalizeDecimal128">
-      <h1><span class="secnum">1.1.6</span> CanonicalizeDecimal128 ( <var>d</var> )</h1>
-      <p>The abstract operation CanonicalizeDecimal128 takes argument <var>d</var> (a Decimal128 value) and returns a Decimal128 value. It converts the argument into a canonicalized, mathematically equal member of the same <emu-xref aoid="cohort" id="_ref_63"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, <emu-val>+∞</emu-val><sub>𝔻</sub>, or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <var>d</var>.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_64"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is is <emu-val>+0</emu-val><sub>𝔻</sub> or <emu-val>-0</emu-val><sub>𝔻</sub>, return <var>d</var>.</li><li>Let <var>e</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_65"><a href="#sec-decimal-intro">exponent</a></emu-xref> of <var>v</var>.</li><li>Let <var>s</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_66"><a href="#sec-decimal-intro">significand</a></emu-xref> of <var>v</var>.</li><li>Return « <var>s</var>, <var>e</var>&nbsp;».</li></ol></emu-alg>
+      <h1><span class="secnum">1.1.8</span> EnsureDecimal128Value ( <var>coefficient</var>, <var>intendedExponent</var>, <var>roundingMode</var> )</h1>
+      <p>The abstract operation EnsureDecimal128Value takes arguments <var>coefficient</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_76"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var>intendedExponent</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_77"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), and <var>roundingMode</var> (a Decimal128 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_78"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>) and returns either a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">normal completion containing</a></emu-xref> a Decimal128 value or a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">throw completion</a></emu-xref>. It attempts to convert the pair of arguments, which might be out of range when considered as a Decimal128 value, into a Decimal128 value, throwing an exception if the conversion cannot be done. It performs the following steps when called:</p>
+      <emu-alg><ol><li>If -6111 ≤ <var>intendedExponent</var> ≤ 6176, then<ol><li>If <var>coefficient</var> is 0, return « <emu-val>+0</emu-val><sub>𝔻</sub>, <var>intendedExponent</var>&nbsp;»<sub>𝔻</sub>.</li><li>If <var>coefficient</var> × 10<sup><var>intendedExponent</var></sup> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>n</var> such that 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>, return « <var>coefficient</var>, <var>intendedExponent</var>&nbsp;»<sub>𝔻</sub>.</li><li>Throw a <emu-val>RangeError</emu-val> exception.</li></ol></li><li>If <var>intendedExponent</var> &lt; 0, return ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_79"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>coefficient</var> / 10, <var>intendedExponent</var> + 1, <var>roundingMode</var>).</li><li>Otherwise, return ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_80"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>coefficient</var> × 10, <var>intendedExponent</var> + 1, <var>roundingMode</var>).</li></ol></emu-alg>
     </emu-clause>
   </emu-clause>
 
@@ -3399,10 +3412,54 @@ <h1><span class="secnum">1.2</span> The Decimal128 Constructor</h1>
     </ul>
     <emu-clause id="sec-the-decimal128-constructor-value">
       <h1><span class="secnum">1.2.1</span> Decimal128 ( <var>x</var> )</h1>
-      <emu-alg><ol><li>If NewTarget is <emu-val>undefined</emu-val>, throw a <emu-val>TypeError</emu-val> exception.</li><li>Let <var>toParse</var> be <emu-val>undefined</emu-val>.</li><li>If <var>x</var> <emu-xref href="#sec-ecmascript-language-types-bigint-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-bigint-type">is a BigInt</a></emu-xref>, set <var>toParse</var> to <emu-xref aoid="BigInt::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-bigint-tostring">BigInt::toString</a></emu-xref>(<var>x</var>, 10).</li><li>Otherwise, if <var>x</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is a Number</a></emu-xref>, set <var>toParse</var> to <emu-xref aoid="Number::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-tostring">Number::toString</a></emu-xref>(<var>x</var>, 10).</li><li>Otherwise, if <var>x</var> <emu-xref href="#sec-ecmascript-language-types-string-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-string-type">is a String</a></emu-xref>, set <var>toParse</var> to <var>x</var>.</li><li>If <var>toParse</var> <emu-xref href="#sec-ecmascript-language-types-string-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-string-type">is not a String</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>Let <var>O</var> be ?&nbsp;<emu-xref aoid="OrdinaryCreateFromConstructor"><a href="https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor">OrdinaryCreateFromConstructor</a></emu-xref>(NewTarget, <emu-val>"%Decimal128.prototype%"</emu-val>, « <var class="field">[[Decimal128Data]]</var>&nbsp;»).</li><li>If <var>toParse</var> is <emu-val>"NaN"</emu-val>, regardless of case, set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>NaN</emu-val><sub>𝔻</sub>.</li><li>If <var>toParse</var> is <emu-val>"-Infinity"</emu-val>, regardless of case, set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>-∞</emu-val><sub>𝔻</sub>.</li><li>If <var>toParse</var> is <emu-val>"Infinity"</emu-val>, regardless of case, set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <emu-val>+∞</emu-val><sub>𝔻</sub>.</li><li>Let <var>parseResult</var> be <emu-xref aoid="ParseText"><a href="https://tc39.es/ecma262/#sec-parsetext">ParseText</a></emu-xref>(<var>toParse</var>, <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalLiteral">DecimalLiteral</a></emu-nt>).</li><li>If <var>parseResult</var> is a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of errors, throw a <emu-val>SyntaxError</emu-val> exception.</li><li>If <var>parseResult</var> contains a <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalIntegerLiteral">DecimalIntegerLiteral</a></emu-nt>, then<ol><li>Let <var>integerPart</var> be the source text contained within the <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalIntegerLiteral">DecimalIntegerLiteral</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref>.</li></ol></li><li>Else,<ol><li>Let <var>integerPart</var> be <emu-val>"0"</emu-val>.</li></ol></li><li>Let <var>nonIntegerDigits</var> be the source text contained within the <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalLiteral">DecimalLiteral</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref>.</li><li>If <var>parseResult</var> contains a <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref> whose source text is not <emu-val>""</emu-val>, then<ol><li>Let <var>exponentPart</var> be the source text contained within the <emu-nt><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a></emu-nt> <emu-xref href="#sec-syntactic-grammar"><a href="https://tc39.es/ecma262/#sec-syntactic-grammar">Parse Node</a></emu-xref>.</li><li>Let <var>s</var> be the concatenation of <var>integerPart</var> and <var>nonIntegerDigits</var>.</li><li>Let <var>m</var> be the <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_67"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> whose decimal representation is <var>s</var>.</li><li>Let <var>e</var> be the <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_68"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> whose decimal representatin is <var>exponentPart</var>.</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_69"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>m</var>, <var>e</var>, <emu-val>"halfEven"</emu-val>).</li></ol></li><li>Else,<ol><li>Let <var>s</var> be the concatenation of <var>integerPart</var> and <var>nonIntegerDigits</var>.</li><li>Let <var>q</var> be the length of <var>nonIntegerDigits</var>.</li><li>Let <var>m</var> be the <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_70"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> whose decimal representation is <var>s</var>.</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_71"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>m</var>, -<var>q</var>, <emu-val>"halfEven"</emu-val>).</li></ol></li><li>Return <var>O</var>.</li></ol></emu-alg>
+      <emu-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_81"><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>
       </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>
+        <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>
+        <emu-nt><a href="https://tc39.es/ecma262/#prod-StrUnsignedDecimalLiteral">StrUnsignedDecimalLiteral</a></emu-nt>
+    </emu-rhs>
+</emu-production>
+</emu-grammar>
+        <emu-alg><ol><li>Let <var>a</var> be ?&nbsp;<emu-xref aoid="StringDecimalValue" id="_ref_82"><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>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_83"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>a</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_84"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>a</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return « <emu-val>-0</emu-val><sub>𝔻</sub>, <var>q</var>&nbsp;».</li><li>Return « -<var>v</var>, <var>q</var>&nbsp;».</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>
+</emu-grammar>
+        <emu-alg><ol><li>Return <emu-val>+∞</emu-val><sub>𝔻</sub>.</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="iokglhcc">
+        <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>
+        <emu-t>.</emu-t>
+        <emu-nt optional=""><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a><emu-mods><emu-opt>opt</emu-opt></emu-mods></emu-nt>
+        <emu-nt optional=""><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a><emu-mods><emu-opt>opt</emu-opt></emu-mods></emu-nt>
+    </emu-rhs>
+</emu-production>
+</emu-grammar>
+        <emu-alg><ol><li>Let <var>a</var> be MV 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 MV 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 MV 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 ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_85"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>((<var>a</var> + (<var>b</var> × 10<sup>-<var>n</var></sup>)) × 10<sup><var>e</var></sup>, <var>e</var> - <var>n</var>, <emu-val>"halfEven"</emu-val>).</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>
+        <emu-nt><a href="https://tc39.es/ecma262/#prod-DecimalDigits">DecimalDigits</a></emu-nt>
+        <emu-nt optional=""><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a><emu-mods><emu-opt>opt</emu-opt></emu-mods></emu-nt>
+    </emu-rhs>
+</emu-production>
+</emu-grammar>
+        <emu-alg><ol><li>Let <var>b</var> be MV 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 MV 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>Return ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_86"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>b</var> × 10<sup><var>e</var> - <var>n</var></sup>, <var>e</var> - <var>n</var>, <emu-val>"halfEven"</emu-val>).</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>
+        <emu-nt optional=""><a href="https://tc39.es/ecma262/#prod-ExponentPart">ExponentPart</a><emu-mods><emu-opt>opt</emu-opt></emu-mods></emu-nt>
+    </emu-rhs>
+</emu-production>
+</emu-grammar>
+        <emu-alg><ol><li>Let <var>a</var> be MV 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 MV 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 ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_87"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>a</var> × 10<sup><var>e</var></sup>, <var>e</var>, <emu-val>"halfEven"</emu-val>).</li></ol></emu-alg>
+      </emu-clause>
     </emu-clause>
   </emu-clause>
 </emu-clause>
@@ -3424,162 +3481,162 @@ <h1><span class="secnum">2.2</span> Decimal128.prototype.isFinite ( )</h1>
     <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>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>Otherwise, return <emu-val>false</emu-val>.</li></ol></emu-alg>
   </emu-clause>
 
+  <emu-clause id="sec-decimal.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>x</var> = « <var>v</var>, <var>q</var> »<sub>𝔻</sub>, there exists a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_88"><a href="#dfn-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. This method requires that the Decimal128 value held by the curernt Decimal128 object is <emu-xref href="#dfn-decimal128-finite" id="_ref_89"><a href="#dfn-decimal128-finite">finite</a></emu-xref> and non-<emu-xref href="#dfn-decimal128-zero" id="_ref_90"><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>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_91"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</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="#dfn-decimal128-mathematical-value" id="_ref_92"><a href="#dfn-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.</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-decimal.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="#dfn-decimal128-mathematical-value" id="_ref_93"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> <var>n</var> for which the current Decimal128 object, <var>x</var> = « <var>v</var>, <var>q</var> »<sub>𝔻</sub>, 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. This method requires that the Decimal128 value held by the curernt Decimal128 object is <emu-xref href="#dfn-decimal128-finite" id="_ref_94"><a href="#dfn-decimal128-finite">finite</a></emu-xref> and non-<emu-xref href="#dfn-decimal128-zero" id="_ref_95"><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>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_96"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>s</var> be the unique rational number for which there exists an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> <var>n</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.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_97"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(! <emu-xref aoid="EnsureDecimal128Value" id="_ref_98"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>s</var>, -<var>e</var>, <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+  </emu-clause>
+
   <emu-clause id="sec-decimal.prototype.abs">
-    <h1><span class="secnum">2.3</span> Decimal128.prototype.abs ( )</h1>
+    <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>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_72"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_73"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_74"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_75"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_76"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>( <var>d</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_77"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>v</var>), <var>q</var>&nbsp;»<sub>𝔻</sub>).</li></ol></emu-alg>
+    <emu-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_99"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="Decimal128Abs" id="_ref_100"><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>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.negate">
-    <h1><span class="secnum">2.4</span> Decimal128.prototype.negate ( )</h1>
+    <h1><span class="secnum">2.6</span> Decimal128.prototype.negate ( )</h1>
     <p>This method inverts the sign of a Decimal128 object.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_78"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_79"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_80"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_81"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_82"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_83"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« -1 × <var>v</var>, <var>q</var>&nbsp;»<sub>𝔻</sub>).</li></ol></emu-alg>
+    <emu-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_101"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-xref aoid="Decimal128Negate" id="_ref_102"><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>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.add">
-    <h1><span class="secnum">2.5</span> Decimal128.prototype.add ( <var>x</var> )</h1>
-    <p>This method computes the addition of a Decimal128 object with another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_84"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
+    <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, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_103"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_85"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_86"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_87"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_88"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_89"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_90"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_91"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>v1</var> be <emu-xref aoid="cohort" id="_ref_92"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be <emu-xref aoid="cohort" id="_ref_93"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be <emu-xref aoid="quantum" id="_ref_94"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be <emu-xref aoid="quantum" id="_ref_95"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_96"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_97"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> + <var>v2</var>, <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>q1</var>, <var>q2</var>]), <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-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_104"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_105"><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_106"><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_107"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_108"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_109"><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_110"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>v1</var> be <emu-xref aoid="cohort" id="_ref_111"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be <emu-xref aoid="cohort" id="_ref_112"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be <emu-xref aoid="quantum" id="_ref_113"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be <emu-xref aoid="quantum" id="_ref_114"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Let <var>newQ</var> be <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>q1</var>, <var>q2</var>).</li><li>If <var>v1</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>v2</var> <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>, <var>newQ</var>&nbsp;»).</li><li>If <var>v2</var> <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_116"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_117"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>v2</var>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v1</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>v2</var> <emu-val>+0</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>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>If <var>v2</var> <emu-val>-0</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>-0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_120"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>v2</var>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>v1</var> <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>, <var>newQ</var>&nbsp;»).</li><li>If <var>v1</var> <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>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_123"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>v1</var>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v2</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>v1</var> <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_124"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>If <var>v1</var> <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_125"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>-0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_126"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>v1</var>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v1</var> + <var>v2</var> = 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_127"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_128"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_129"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> + <var>v2</var>, <var>newQ</var>, <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.subtract">
-    <h1><span class="secnum">2.6</span> Decimal128.prototype.subtract ( <var>x</var> )</h1>
-    <p>This method computes subtracts the given Decimal128 object from the current one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_98"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
+    <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, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_130"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-      <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_99"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_100"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_101"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_102"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_103"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_104"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_105"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>v1</var> be <emu-xref aoid="cohort" id="_ref_106"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be <emu-xref aoid="cohort" id="_ref_107"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be <emu-xref aoid="quantum" id="_ref_108"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be <emu-xref aoid="quantum" id="_ref_109"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_110"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_111"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> - <var>v2</var>, <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>q1</var>, <var>q2</var>), <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+      <emu-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_131"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_132"><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_133"><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_134"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_135"><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_136"><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_137"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>v1</var> be <emu-xref aoid="cohort" id="_ref_138"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be <emu-xref aoid="cohort" id="_ref_139"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be <emu-xref aoid="quantum" id="_ref_140"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be <emu-xref aoid="quantum" id="_ref_141"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Let <var>newQ</var> be <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>q1</var>, <var>q2</var>).</li><li>If <var>v1</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>v2</var> <emu-val>+0</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>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>If <var>v2</var> <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>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_144"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>v2</var>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v1</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, then<ol><li>If <var>v2</var> <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_145"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>-0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>If <var>v2</var> <emu-val>-0</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>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_147"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>v2</var>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_148"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>v1</var>, <var>newQ</var>&nbsp;»).</li><li>If <var>v2</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_149"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>v1</var>, <var>newQ</var>&nbsp;»).</li><li>If <var>v1</var> + <var>v2</var> = 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_150"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_151"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_152"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> - <var>v2</var>, <var>newQ</var>, <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.multiply">
-    <h1><span class="secnum">2.7</span> Decimal128.prototype.multiply ( <var>x</var> )</h1>
-    <p>This method computes multiplies the current Decimal128 object by another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_112"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
+    <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, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_153"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_113"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_114"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_115"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_116"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_117"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_118"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_119"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_120"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_121"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_122"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Let <var>v2</var> be <emu-xref aoid="cohort" id="_ref_123"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>If <var>v2</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_124"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_125"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>v1</var> be <emu-xref aoid="cohort" id="_ref_126"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q1</var> be <emu-xref aoid="quantum" id="_ref_127"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be <emu-xref aoid="quantum" id="_ref_128"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_129"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_130"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref> (<var>v1</var> × _v2, <var>q1</var> + <var>q2</var>], <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-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_154"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_155"><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_156"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_157"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_158"><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_159"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_160"><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_161"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_162"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_163"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Let <var>v2</var> be <emu-xref aoid="cohort" id="_ref_164"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>If <var>v2</var> &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_165"><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_166"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Let <var>v1</var> be <emu-xref aoid="cohort" id="_ref_167"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q1</var> be <emu-xref aoid="quantum" id="_ref_168"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be <emu-xref aoid="quantum" id="_ref_169"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Let <var>newQ</var> be <var>q1</var> + <var>q2</var>.</li><li>If <var>v1</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, then<ol><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var> is <emu-xref href="#sec-decimal-intro" id="_ref_170"><a href="#sec-decimal-intro">negative</a></emu-xref>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_171"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>-0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_172"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v1</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, then<ol><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var> is <emu-xref href="#sec-decimal-intro" id="_ref_173"><a href="#sec-decimal-intro">negative</a></emu-xref>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_174"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_175"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>-0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, then<ol><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d1</var> is <emu-xref href="#sec-decimal-intro" id="_ref_176"><a href="#sec-decimal-intro">negative</a></emu-xref>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_177"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>-0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_178"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v2</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, then<ol><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d1</var> is <emu-xref href="#sec-decimal-intro" id="_ref_179"><a href="#sec-decimal-intro">negative</a></emu-xref>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_180"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, 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>, <var>newQ</var>&nbsp;»).</li></ol></li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>v1</var> × _v2 ≠ 0.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_182"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_183"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref> (<var>v1</var> × _v2, <var>newQ</var>, <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.divide">
-    <h1><span class="secnum">2.8</span> Decimal128.prototype.divide ( <var>x</var> )</h1>
-    <p>This method computes divides the current Decimal128 object by another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_131"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
+    <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, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_184"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_132"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_133"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_134"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Let <var>v1</var> be <emu-xref aoid="cohort" id="_ref_135"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be <emu-xref aoid="cohort" id="_ref_136"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be <emu-xref aoid="quantum" id="_ref_137"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be <emu-xref aoid="quantum" id="_ref_138"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_139"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_140"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> / <var>v2</var>, <var>q1</var> + <var>q2</var>, <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-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_185"><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_186"><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_187"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Let <var>v1</var> be <emu-xref aoid="cohort" id="_ref_188"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be <emu-xref aoid="cohort" id="_ref_189"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be <emu-xref aoid="quantum" id="_ref_190"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be <emu-xref aoid="quantum" id="_ref_191"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Let <var>newQ</var> be <var>q1</var> + <var>q2</var>.</li><li>If <var>v1</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, then<ol><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var> is <emu-xref href="#sec-decimal-intro" id="_ref_192"><a href="#sec-decimal-intro">negative</a></emu-xref>, 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>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, 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>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v1</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, then<ol><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var> is <emu-xref href="#sec-decimal-intro" id="_ref_195"><a href="#sec-decimal-intro">negative</a></emu-xref>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_196"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>+0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li><li>Otherwise, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_197"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>-0</emu-val><sub>𝔻</sub>, <var>newQ</var>&nbsp;»).</li></ol></li><li>If <var>v2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>v2</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_198"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_199"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> / <var>v2</var>, <var>newQ</var>, <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.remainder">
-    <h1><span class="secnum">2.9</span> Decimal128.prototype.remainder ( <var>x</var> )</h1>
-    <p>This method computes the remainder upon dividing the current Decimal128 object by another one. The computation proceeds as though infinite precision and unbounded range were available, rounding, if necessary, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_141"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
+    <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, according to the <emu-val>"halfEven"</emu-val> <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_200"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_142"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_143"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_144"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Let <var>v1</var> be <emu-xref aoid="cohort" id="_ref_145"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be <emu-xref aoid="cohort" id="_ref_146"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be <emu-xref aoid="quantum" id="_ref_147"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be <emu-xref aoid="quantum" id="_ref_148"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_149"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_150"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> % <var>v2</var>, <var>q1</var> + <var>q2</var>, <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-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_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>+∞</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>(<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_203"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Let <var>v1</var> be <emu-xref aoid="cohort" id="_ref_204"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d1</var>).</li><li>Let <var>v2</var> be <emu-xref aoid="cohort" id="_ref_205"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d2</var>).</li><li>Let <var>q1</var> be <emu-xref aoid="quantum" id="_ref_206"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d1</var>).</li><li>Let <var>q2</var> be <emu-xref aoid="quantum" id="_ref_207"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d2</var>).</li><li>Let <var>newQ</var> be <var>q1</var> + <var>q2</var>.</li><li>If <var>v2</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_208"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>v2</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_209"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>v1</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, 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>, <var>newQ</var>&nbsp;»).</li><li>If <var>v1</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, 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>, <var>newQ</var>&nbsp;»).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_212"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_213"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var> % <var>v2</var>, <var>newQ</var>, <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>The remainder operation specified here deviates from the <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref> remainder operation (defined there in Section 5.3.1). We follow the <emu-xref href="#sec-numeric-types-number-remainder"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-remainder">the remainder operation for Number</a></emu-xref> rather than IEEE 754, which specifies that, for example, the remainder 46 and 10 is -4 rather than 6.</p>
     </div></emu-note>
   </emu-clause>
 
-  <emu-clause id="sec-decimal.prototype.equals">
-    <h1><span class="secnum">2.10</span> Decimal128.prototype.equals ( <var>x</var> )</h1>
-    <p>This method computes whether the current Decimal128 object has the same <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_151"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> as another Decimal128 object.</p>
+  <emu-clause id="sec-decimal.prototype.compare">
+    <h1><span class="secnum">2.12</span> Decimal128.prototype.compare ( <var>x</var> )</h1>
+    <p>This method returns one of the 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> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.
-      I. If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li></ol></li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d1</var> is equal to the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></emu-alg>
+    <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>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 href="#dfn-decimal128-mathematical-value" id="_ref_2"><a href="#dfn-decimal128-mathematical-value">the mathematical value of</a></emu-xref> of <var>d1</var> is less than <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_3"><a href="#dfn-decimal128-mathematical-value">the mathematical value of</a></emu-xref> <var>d2</var>, return <emu-val>-1</emu-val><sub>𝔽</sub>.</li><li>If <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_4"><a href="#dfn-decimal128-mathematical-value">the mathematical value of of</a></emu-xref> <var>d2</var> is less than <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_5"><a href="#dfn-decimal128-mathematical-value">the mathematical value of</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 follows the specification of the <code>compareSignalingEqual</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>
+      <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>
   </emu-clause>
 
-  <emu-clause id="sec-decimal.prototype.lessthan">
-    <h1><span class="secnum">2.11</span> Decimal128.prototype.lessThan ( <var>x</var> )</h1>
-    <p>This method computes whether the current Decimal128 object has a strictly smaller <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_152"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> than another Decimal128 object.</p>
+  <emu-clause id="sec-decimal-method-round">
+    <h1><span class="secnum">2.13</span> Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )</h1>
+    <p>This method rounds the current Decimal128 object according to the specified <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_214"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, which, if omitted, is <emu-xref href="#dfn-decimal128-default-rounding-mode" id="_ref_6"><a href="#dfn-decimal128-default-rounding-mode">the default rounding mode</a></emu-xref>, with rounding taking place only after <var>numFractionalDigits</var> non-<emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> digits, which must be a non-<emu-xref href="#sec-decimal-intro" id="_ref_215"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> Number.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>Return <emu-val>true</emu-val>.</li></ol></li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>true</emu-val>.</li></ol></li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> of <var>d1</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></emu-alg>
+    <emu-alg><ol><li>If <var>numFractionalDigits</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is not a Number</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>numFractionalDigits</var> &lt; 0, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>numFractionalDigits</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>roundingMode</var> is neither <emu-val>undefined</emu-val> nor a String, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>roundingMode</var> is undefined, set <var>roundingMode</var> to <emu-xref href="#dfn-decimal128-default-rounding-mode" id="_ref_7"><a href="#dfn-decimal128-default-rounding-mode">the default rounding mode</a></emu-xref>.</li><li>If <var>roundingMode</var> is not a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_216"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_217"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_218"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_219"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_220"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_221"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_222"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>+0</emu-val><sub>𝔻</sub>, <var>numFractionalDigits</var>&nbsp;»).</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_223"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <emu-val>-0</emu-val><sub>𝔻</sub>, <var>numFractionalDigits</var>&nbsp;»).</li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that v × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li>Let <var>newD</var> be ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_224"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(v × 10<sup><var>numFractionalDigits</var></sup>, <var>q</var> + <var>numFractionalDigits</var>, <var>roundingMode</var>).</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_225"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<var>newD</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>compareSignalingLess</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>
+      <p>This operation follows the specification of the <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_226"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref> attributes discussed in Section 4.3 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
-  <emu-clause id="sec-decimal.prototype.compare">
-    <h1><span class="secnum">2.12</span> Decimal128.prototype.compare ( <var>x</var> )</h1>
-    <p>This method returns one of the three Number values <emu-val>-1</emu-val><sub>𝔽</sub>, <emu-val>+0</emu-val><sub>𝔽</sub>, and <emu-val>1</emu-val><sub>𝔽</sub>. It compares the current Decimal128 object with another one. If the current Decimal128 object has a strictly smaller <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_153"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, the result is <emu-val>-1</emu-val><sub>𝔽</sub>. If the current Decimal128 object has a strictly greater <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_154"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, it returns <emu-val>1</emu-val><sub>𝔽</sub>. If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> the two Decimal128 objects are the same, the exponents are compared and the computation proceeds similarly, returning <emu-val>-1</emu-val><sub>𝔽</sub> if the <emu-xref href="#sec-decimal-intro" id="_ref_155"><a href="#sec-decimal-intro">exponent</a></emu-xref> of the current Decimal128 object is strictly less than that of the argument, <emu-val>1</emu-val><sub>𝔽</sub> if if the <emu-xref href="#sec-decimal-intro" id="_ref_156"><a href="#sec-decimal-intro">exponent</a></emu-xref> is strictly greater, finally returning <emu-val>+0</emu-val><sub>𝔽</sub> if the exponents are mathematically equal.</p>
+  <emu-clause id="sec-decimal-method-scale10">
+    <h1><span class="secnum">2.14</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>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></li><li>If <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>+0</emu-val><sub>𝔽</sub>.</li><li>Return <emu-val>1</emu-val><sub>𝔽</sub>.</li></ol></li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>+0</emu-val><sub>𝔽</sub>.</li><li>Return <emu-val>-1</emu-val><sub>𝔽</sub>.</li></ol></li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>-1</emu-val><sub>𝔽</sub>.</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>1</emu-val><sub>𝔽</sub>.</li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> of <var>d1</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var>, return <emu-val>-1</emu-val><sub>𝔽</sub>.</li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> of <var>d2</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d1</var>, return <emu-val>1</emu-val><sub>𝔽</sub>.</li><li>Let <var>v1</var> be <var>d1</var>[1].</li><li>Let <var>v2</var> be <var>d2</var>[1].</li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>v1</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>v2</var>, return <emu-val>-1</emu-val><sub>𝔽</sub>.</li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>v2</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>v1</var>, return <emu-val>1</emu-val><sub>𝔽</sub>.</li><li>Return <emu-val>+0</emu-val><sub>𝔽</sub>.</li></ol></emu-alg>
-    <emu-note><span class="note">Note 1</span><div class="note-contents">
-      <p>This operation follows the specification of the <code>compareQuietOrdered</code> operation in Section 5.6.1 (and explained in Section 5.11) of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
-    </div></emu-note>
-    <emu-note><span class="note">Note 2</span><div class="note-contents">
-      <p>This operation compares Decimal128 values, intuitively understood as digit strings. Thus, for example, 1.2 and 1.20 are considered distinct values for this operation. To compare by <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_157"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, see <emu-xref href="#sec-decimal.prototype.lessthan" id="_ref_0"><a href="#sec-decimal.prototype.lessthan">lessThan</a></emu-xref> or <emu-xref href="#sec-decimal.prototype.equals" id="_ref_1"><a href="#sec-decimal.prototype.equals">equals</a></emu-xref>.</p>
-    </div></emu-note>
-  </emu-clause>
-
-  <emu-clause id="sec-decimal-method-round">
-    <h1><span class="secnum">2.13</span> Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )</h1>
-    <p>This method rounds the current Decimal128 object according to the specified <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_158"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, which, if omitted, is <emu-xref href="#dfn-decimal128-default-rounding-mode" id="_ref_2"><a href="#dfn-decimal128-default-rounding-mode">the default rounding mode</a></emu-xref>, with rounding taking place only after <var>numFractionalDigits</var> non-<emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> digits, which must be a non-<emu-xref href="#sec-decimal-intro" id="_ref_159"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> Number.</p>
-    <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>If <var>numFractionalDigits</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is not a Number</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>numFractionalDigits</var> &lt; 0, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>numFractionalDigits</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>roundingMode</var> is neither <emu-val>undefined</emu-val> nor a String, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>roundingMode</var> is undefined, set <var>roundingMode</var> to <emu-xref href="#dfn-decimal128-default-rounding-mode" id="_ref_3"><a href="#dfn-decimal128-default-rounding-mode">the default rounding mode</a></emu-xref>.</li><li>If <var>roundingMode</var> is not a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_160"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_161"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_162"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that v × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_163"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_164"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(v × 10<sup>-<var>numFractionalDigits</var></sup>, <var>q</var> + <var>numFractionalDigits</var>, <var>roundingMode</var>)).</li></ol></emu-alg>
+    <emu-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 <emu-val>NaN</emu-val><sub>𝔽</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>n</var> is <emu-val>+∞</emu-val><sub>𝔽</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>n</var> is <emu-val>-∞</emu-val><sub>𝔽</sub>, 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-xref aoid="Decimal128ValueToObject" id="_ref_227"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_228"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_229"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_230"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_231"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is neither <emu-val>+0</emu-val><sub>𝔻</sub> nor <emu-val>-0</emu-val><sub>𝔻</sub>, set <var>v</var> to <var>v</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_232"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_233"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v</var>, <var>q</var> + <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>n</var>), <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
-      <p>This operation follows the specification of the <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_165"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref> attributes discussed in Section 4.3 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
+      <p>This operation follows the specification of the <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_234"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref> attributes discussed in Section 4.3 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.tostring">
-    <h1><span class="secnum">2.14</span> Decimal128.prototype.toString ( [ <var>options</var> ] )</h1>
-    <p>This method generates a String representation of the current Decimal128 object, in decimal format. Unlike Number’s <emu-xref href="#sec-number.prototype.tostring"><a href="https://tc39.es/ecma262/#sec-number.prototype.tostring">toString</a></emu-xref>, this method always produces a decimal representation of the Decimal128 object and never produces an exponential representation. That functionality is provided by <emu-xref href="#sec-decimal.prototype.toexponential" id="_ref_4"><a href="#sec-decimal.prototype.toexponential">toExponential</a></emu-xref>.</p>
+    <h1><span class="secnum">2.15</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, provided the length of that string is less than 20. Otherwise, the decimal will be rendered in exponential 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>shouldCanonicalize</var> be ?&nbsp;<emu-xref aoid="Get"><a href="https://tc39.es/ecma262/#sec-get-o-p">Get</a></emu-xref>(<var>options</var>, <emu-val>"canonicalize"</emu-val>).</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_166"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_167"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_168"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>shouldCanonicalize</var> be <emu-val>true</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>shouldCanonicalize</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>"canonicalize"</emu-val>).</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li></ol></li><li>Let <var>inDecimalNotation</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_235"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>, <var>shouldCanonicalize</var>).</li><li>If the length of <var>inDecimalNotation</var> is less than 22, return <var>inDecimalNotation</var>.</li><li>Otherwise, return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_236"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>O</var>, <var>shouldCanonicalize</var>).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.toexponential">
-    <h1><span class="secnum">2.15</span> Decimal128.prototype.toExponential ( [ <var>shouldCanonicalize</var> ] )</h1>
+    <h1><span class="secnum">2.16</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>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_169"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_170"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_171"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>O</var>).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>shouldCanonicalize</var> be <emu-val>true</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>shouldCanonicalize</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>"canonicalize"</emu-val>).</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li></ol></li><li>Return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_237"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>O</var>, <var>shouldCanonicalize</var>).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.tofixed">
-    <h1><span class="secnum">2.16</span> Decimal128.prototype.toFixed ( <var>numDigits</var> [ , <var>shouldCanonicalize</var> ] )</h1>
+    <h1><span class="secnum">2.17</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>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>numDigits</var> is neither <emu-val>undefined</emu-val> nor a Number, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>numDigits</var> is <emu-val>undefined_, let _numDigits_ be *+0</emu-val><sub>𝔽</sub>.</li><li>If <var>numDigits</var> &lt; 0, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>numDigits</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_172"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_173"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)), otherwise let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_174"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li><li>If <var>s</var> is <emu-val>"NaN"</emu-val>, <emu-val>"Infinity"</emu-val>, or <emu-val>"-Infinity"</emu-val>, return <var>s</var>.</li><li>Let <var>integerDigits</var> be <emu-val>""</emu-val>.</li><li>Let <var>nonIntegerDigits</var> be <emu-val>""</emu-val>.</li><li>If <var>s</var> contains a <emu-val>"."</emu-val>, then<ol><li>Set <var>integerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> up to the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Set <var>nonIntegerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> after the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>If <var>numDigits</var> &gt; 0, set <var>nonIntegerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>nonIntegerDigits</var> from 0 to <var>numDigits</var>.</li></ol></li><li>Else,<ol><li>Set <var>integerDigits</var> to <var>s</var>.</li></ol></li><li>If <var>numDigits</var> is 0, return <var>integerDigits</var>.</li><li>Return the concatenation of <var>integerDigits</var>, <emu-val>"."</emu-val>, and <var>nonIntegerDigits</var>.</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>shouldCanonicalize</var> be <emu-val>true</emu-val>.</li><li>Let <var>numDigits</var> be <emu-val>+0</emu-val><sub>𝔽</sub>.</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>shouldCanonicalize</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>"canonicalize"</emu-val>).</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>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>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li></ol></li><li>If <var>numDigits</var> &lt; 0, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>numDigits</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>Let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_238"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>, <var>shouldCanonicalize</var>).</li><li>If <var>s</var> is <emu-val>"NaN"</emu-val>, <emu-val>"Infinity"</emu-val>, or <emu-val>"-Infinity"</emu-val>, return <var>s</var>.</li><li>Let <var>integerDigits</var> be <emu-val>""</emu-val>.</li><li>Let <var>nonIntegerDigits</var> be <emu-val>""</emu-val>.</li><li>If <var>s</var> contains a <emu-val>"."</emu-val>, then<ol><li>Set <var>integerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> up to the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Set <var>nonIntegerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> after the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>If <var>numDigits</var> &gt; 0, set <var>nonIntegerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>nonIntegerDigits</var> from 0 to <var>numDigits</var>.</li></ol></li><li>Else,<ol><li>Set <var>integerDigits</var> to <var>s</var>.</li></ol></li><li>If <var>numDigits</var> is 0, return <var>integerDigits</var>.</li><li>Return the concatenation of <var>integerDigits</var>, <emu-val>"."</emu-val>, and <var>nonIntegerDigits</var>.</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.toprecision">
-    <h1><span class="secnum">2.17</span> Decimal128.prototype.toPrecision ( <var>precision</var> [ , <var>shouldCanonicalize</var> ] )</h1>
-    <p>This method generates a String representation of the current Decimal128 object, in decimal format, with a specified number of significant digits. If the <var>precision</var> argument is omitted or is <emu-val>undefined</emu-val>, this method is equivalent to <emu-xref href="#sec-decimal.prototype.tostring" id="_ref_5"><a href="#sec-decimal.prototype.tostring">toString</a></emu-xref>. This method may produce results in exponential notation or decimal notation.</p>
+    <h1><span class="secnum">2.18</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-decimal.prototype.tostring" id="_ref_8"><a href="#sec-decimal.prototype.tostring">toString</a></emu-xref>. This method may produce results in exponential notation or decimal notation.</p>
     <p>It performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>If <var>shouldCanonicalize</var> is <emu-val>undefined</emu-val>, set <var>shouldCanonicalize</var> to <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> <emu-xref href="#sec-ecmascript-language-types-boolean-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-boolean-type">is not a Boolean</a></emu-xref> value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>precision</var> is neither <emu-val>undefined</emu-val> nor a Number, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>precision</var> is *undefined_, then<ol><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_175"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_176"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li><li>Otherwise, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_177"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-xref aoid="CanonicalizeDecimal128" id="_ref_178"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>)).</li></ol></li><li>If <var>precision</var> is not an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>precision</var> &lt; 1, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>shouldCanonicalize</var> is <emu-val>true</emu-val>, let <var>d</var> be <emu-xref aoid="CanonicalizeDecimal128" id="_ref_179"><a href="#sec-decimal128-canonicalizedecimal128">CanonicalizeDecimal128</a></emu-xref>(<var>O</var>).<var class="field">[[Decimal128Data]]</var>, otherwise let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_180"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_181"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>If -<var>q</var> &lt; <var>precision</var>, then<ol><li>Let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_182"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li><li>Let <var>integerDigits</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> up to the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Let <var>nonIntegerDigits</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> after the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Let <var>numTrailingZeroesToAdd</var> be <var>precision</var> minus the length of <var>nonIntegerDigits</var>.</li><li>Let <var>trailingZeroes</var> be the string <emu-val>"0"</emu-val> repeated <var>numTrailingZeroesToAdd</var> times.</li><li>Return the concatenation of <var>integerDigits</var>, <emu-val>"."</emu-val>, <var>nonIntegerDigits</var>, and <var>trailingZeroes</var>.</li></ol></li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that v × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li>Let <var>n1</var> be the largest multiple of 10 such that <var>n</var> - <var>n1</var> is less than 10<sup><var>precision</var></sup>.</li><li>Let <var>v1</var> be <var>v</var> - (<var>n1</var> / 10<sup><var>precision</var></sup>).</li><li>Let <var>N</var> be ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_183"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var>, <var>precision</var>, <emu-val>"halfEven"</emu-val>).</li><li>Return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_184"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>N</var>).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>shouldCanonicalize</var> be <emu-val>true</emu-val>.</li><li>If <var>shouldCanonicalize</var> is neither <emu-val>undefined</emu-val> nor a Boolean value, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>precision</var> is neither <emu-val>undefined</emu-val> nor a Number, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>precision</var> is <emu-val>undefined</emu-val>, return return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_239"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>, <var>shouldCanonicalize</var>).</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>Let <var>v</var> be <emu-xref aoid="cohort" id="_ref_240"><a href="#eqn-decimal128-cohort">cohort</a></emu-xref>(<var>d</var>).</li><li>Let <var>q</var> be <emu-xref aoid="quantum" id="_ref_241"><a href="#eqn-decimal128-quantum">quantum</a></emu-xref>(<var>d</var>).</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>If -<var>q</var> &lt; <var>precision</var>, then<ol><li>Let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_242"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>, <var>shouldCanonicalize</var>).</li><li>Let <var>integerDigits</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> up to the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Let <var>nonIntegerDigits</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> after the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Let <var>numTrailingZeroesToAdd</var> be <var>precision</var> minus the length of <var>nonIntegerDigits</var>.</li><li>Let <var>trailingZeroes</var> be the string <emu-val>"0"</emu-val> repeated <var>numTrailingZeroesToAdd</var> times.</li><li>Return the concatenation of <var>integerDigits</var>, <emu-val>"."</emu-val>, <var>nonIntegerDigits</var>, and <var>trailingZeroes</var>.</li></ol></li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that v × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li>Let <var>n1</var> be the largest multiple of 10 such that <var>n</var> - <var>n1</var> is less than 10<sup><var>precision</var></sup>.</li><li>Let <var>v1</var> be <var>v</var> - (<var>n1</var> / 10<sup><var>precision</var></sup>).</li><li>Let <var>N</var> be ?&nbsp;<emu-xref aoid="EnsureDecimal128Value" id="_ref_243"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>v1</var>, <var>precision</var>, <emu-val>"halfEven"</emu-val>).</li><li>Return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_244"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>N</var>, <var>shouldCanonicalize</var>).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
     </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.valueof">
-    <h1><span class="secnum">2.18</span> Decimal128.prototype.valueOf ( <var>x</var> )</h1>
+    <h1><span class="secnum">2.19</span> Decimal128.prototype.valueOf ( <var>x</var> )</h1>
     <p>This method 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>Throw a <emu-val>TypeError</emu-val> exception.</li></ol></emu-alg>
   </emu-clause>
@@ -3589,15 +3646,17 @@ <h1><span class="secnum">2.18</span> Decimal128.prototype.valueOf ( <var>x</var>
   <h1><span class="secnum">3</span> Numbers and Dates</h1>
   <emu-clause id="sec-number-objects">
     <h1><span class="secnum">3.1</span> Number Objects</h1>
+
     <emu-clause id="sec-number-constructor">
       <h1><span class="secnum">3.1.1</span> The Number Constructor</h1>
       <emu-clause id="sec-number-constructor-number-value">
         <h1><span class="secnum">3.1.1.1</span> Number ( <var>value</var> )</h1>
         <p>This function performs the following steps when called:</p>
-        <emu-alg><ol><li>If <var>value</var> is present, then<ol><li>Let <var>serialized</var> be the result of !&nbsp;<emu-xref aoid="Call"><a href="https://tc39.es/ecma262/#sec-call">Call</a></emu-xref>([<var>value</var>].<var class="field">[[toString]]</var>, <var>value</var>).</li><li>If <var>value</var> is a Decimal128 object, return !&nbsp;<emu-xref aoid="ToNumber"><a href="https://tc39.es/ecma262/#sec-tonumber">ToNumber</a></emu-xref>(<var>serialized</var>).</li><li>Let <var>prim</var> be ?&nbsp;<emu-xref aoid="ToNumeric"><a href="https://tc39.es/ecma262/#sec-tonumeric">ToNumeric</a></emu-xref>(<var>value</var>).</li><li>If <var>prim</var> <emu-xref href="#sec-ecmascript-language-types-bigint-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-bigint-type">is a BigInt</a></emu-xref>, let <var>n</var> be <emu-xref aoid="𝔽"><a href="https://tc39.es/ecma262/#𝔽">𝔽</a></emu-xref>(<emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>prim</var>)).</li><li>Otherwise, let <var>n</var> be <var>prim</var>.</li></ol></li><li>Else,<ol><li>Let <var>n</var> be <emu-val>+0</emu-val><sub>𝔽</sub>.</li></ol></li><li>If NewTarget is <emu-val>undefined</emu-val>, return <var>n</var>.</li><li>Let <var>O</var> be ?&nbsp;<emu-xref aoid="OrdinaryCreateFromConstructor"><a href="https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor">OrdinaryCreateFromConstructor</a></emu-xref>(<emu-xref href="#sec-the-decimal-constructor" id="_ref_185"><a href="#sec-the-decimal-constructor">%Decimal128%</a></emu-xref>, <emu-val>"%Number.prototype%"</emu-val>, « <var class="field">[[NumberData]]</var>&nbsp;»).</li><li>Set <var>O</var>.<var class="field">[[NumberData]]</var> to <var>n</var>.</li><li>Return <var>O</var>.</li></ol></emu-alg>
+        <emu-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_245"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>d</var>, <emu-val>false</emu-val>).</ins></li><li><ins>Return !&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>Let <var>prim</var> be ?&nbsp;<emu-xref aoid="ToNumeric"><a href="https://tc39.es/ecma262/#sec-tonumeric">ToNumeric</a></emu-xref>(<var>value</var>).</li><li>If <var>prim</var> <emu-xref href="#sec-ecmascript-language-types-bigint-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-bigint-type">is a BigInt</a></emu-xref>, let <var>n</var> be <emu-xref aoid="𝔽"><a href="https://tc39.es/ecma262/#𝔽">𝔽</a></emu-xref>(<emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>prim</var>)).</li><li>Otherwise, let <var>n</var> be <var>prim</var>.</li></ol></li><li>Else,<ol><li>Let <var>n</var> be <emu-val>+0</emu-val><sub>𝔽</sub>.</li></ol></li><li>If NewTarget is <emu-val>undefined</emu-val>, return <var>n</var>.</li><li>Let <var>O</var> be ?&nbsp;<emu-xref aoid="OrdinaryCreateFromConstructor"><a href="https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor">OrdinaryCreateFromConstructor</a></emu-xref>(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>
+
   <emu-clause id="sec-bigint-objects">
     <h1><span class="secnum">3.2</span> BigInt Objects</h1>
     <emu-clause id="sec-bigint-constructor">
@@ -3605,12 +3664,12 @@ <h1><span class="secnum">3.2.1</span> The BigInt Constructor</h1>
       <emu-clause id="sec-bigint-constructor-number-value">
         <h1><span class="secnum">3.2.1.1</span> BigInt ( <var>value</var> )</h1>
         <p>This function performs the following steps when called:</p>
-        <emu-alg><ol><li>If NewTarget is not <emu-val>undefined</emu-val>, throw a <emu-val>TypeError</emu-val> exception.</li><li><ins>If <var>value</var> is a Decimal128 object, return ?&nbsp;<emu-xref aoid="Decimal128ToBigInt" id="_ref_186"><a href="#sec-numbertobigint">Decimal128ToBigInt</a></emu-xref>(<var>value</var>).</ins></li><li>Let <var>prim</var> be ?&nbsp;<emu-xref aoid="ToPrimitive"><a href="https://tc39.es/ecma262/#sec-toprimitive">ToPrimitive</a></emu-xref>(<var>value</var>, <emu-const>number</emu-const>).</li><li>If <var>prim</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is a Number</a></emu-xref>, return ?&nbsp;<emu-xref aoid="NumberToBigInt"><a href="https://tc39.es/ecma262/#sec-numbertobigint">NumberToBigInt</a></emu-xref>(<var>prim</var>).</li><li>Otherwise, return ?&nbsp;<emu-xref aoid="ToBigInt"><a href="https://tc39.es/ecma262/#sec-tobigint">ToBigInt</a></emu-xref>(<var>prim</var>).</li></ol></emu-alg>
+        <emu-alg><ol><li>If NewTarget is not <emu-val>undefined</emu-val>, throw a <emu-val>TypeError</emu-val> exception.</li><li><ins>If <var>value</var> is a Decimal128 object, return ?&nbsp;<emu-xref aoid="Decimal128ToBigInt" id="_ref_246"><a href="#sec-numbertobigint">Decimal128ToBigInt</a></emu-xref>(<var>value</var>).</ins></li><li>Let <var>prim</var> be ?&nbsp;<emu-xref aoid="ToPrimitive"><a href="https://tc39.es/ecma262/#sec-toprimitive">ToPrimitive</a></emu-xref>(<var>value</var>, <emu-const>number</emu-const>).</li><li>If <var>prim</var> <emu-xref href="#sec-ecmascript-language-types-number-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type">is a Number</a></emu-xref>, return ?&nbsp;<emu-xref aoid="NumberToBigInt"><a href="https://tc39.es/ecma262/#sec-numbertobigint">NumberToBigInt</a></emu-xref>(<var>prim</var>).</li><li>Otherwise, return ?&nbsp;<emu-xref aoid="ToBigInt"><a href="https://tc39.es/ecma262/#sec-tobigint">ToBigInt</a></emu-xref>(<var>prim</var>).</li></ol></emu-alg>
 
          <emu-clause id="sec-numbertobigint" type="abstract operation" aoid="Decimal128ToBigInt">
           <h1><span class="secnum">3.2.1.1.1</span> <ins>Decimal128ToBigInt ( <var>number</var> )</ins></h1>
           <p>The abstract operation Decimal128ToBigInt takes argument <var>number</var> (a Decimal128 object) and returns either a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">normal completion containing</a></emu-xref> a BigInt or a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">throw completion</a></emu-xref>. It performs the following steps when called:</p>
-          <emu-alg><ol><li>If <emu-xref aoid="IsIntegralDecimal128" id="_ref_187"><a href="#sec-decimal128-isintegraldecimal128value">IsIntegralDecimal128</a></emu-xref>(<var>number</var>) is <emu-val>false</emu-val>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Return <emu-xref aoid="ℤ"><a href="https://tc39.es/ecma262/#ℤ">ℤ</a></emu-xref>(<emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>number</var>)).</li></ol></emu-alg>
+          <emu-alg><ol><li>If <emu-xref aoid="IsIntegralDecimal128" id="_ref_247"><a href="#sec-decimal128-isintegraldecimal128value">IsIntegralDecimal128</a></emu-xref>(<var>number</var>) is <emu-val>false</emu-val>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Return <emu-xref aoid="ℤ"><a href="https://tc39.es/ecma262/#ℤ">ℤ</a></emu-xref>(<emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>number</var>)).</li></ol></emu-alg>
         </emu-clause>
       </emu-clause>
     </emu-clause>
@@ -3634,44 +3693,44 @@ <h1><span class="secnum">4.1</span> Abstract Operations for NumberFormat Objects
 
     <emu-clause id="sec-tointlmathematicalvalue" type="abstract operation" aoid="ToIntlMathematicalValue">
       <h1><span class="secnum">4.1.1</span> ToIntlMathematicalValue ( <var>value</var> )</h1>
-      <p>The abstract operation ToIntlMathematicalValue takes argument <var>value</var> (an <emu-xref href="#sec-ecmascript-language-types"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types">ECMAScript language value</a></emu-xref>) and returns either a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">normal completion containing</a></emu-xref> an <emu-xref href="#intl-mathematical-value" id="_ref_188"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref> or a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">throw completion</a></emu-xref>. 
-          It returns <var>value</var> converted to an <dfn id="intl-mathematical-value" tabindex="-1">Intl mathematical value</dfn>, which is either <ins>(1) a <emu-xref href="#dfn-decimal128-finite" id="_ref_189"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, non-NaN, non-<emu-xref href="#sec-decimal-intro" id="_ref_190"><a href="#sec-decimal-intro">negative</a></emu-xref>-<emu-xref href="#dfn-decimal128-zero" id="_ref_191"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 object, (2)</ins> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_192"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><del> together with</del><ins>, or (3) one of</ins> <emu-const>positive-infinity</emu-const>, <emu-const>negative-infinity</emu-const>, <emu-const>not-a-number</emu-const>, and <emu-const>negative-zero</emu-const>.
-          This abstract operation is similar to <emu-xref href="#sec-tonumeric"><a href="https://tc39.es/ecma262/#sec-tonumeric">7.1.3</a></emu-xref>, but a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_193"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> can be returned instead of a Number or BigInt, so that exact decimal values can be represented.
+      <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_248"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref> or a <emu-xref href="#sec-completion-record-specification-type"><a href="https://tc39.es/ecma262/#sec-completion-record-specification-type">throw completion</a></emu-xref>. 
+          It returns <var>value</var> converted to an <dfn id="intl-mathematical-value" tabindex="-1">Intl mathematical value</dfn>, which is either <ins>(1) a <emu-xref href="#dfn-decimal128-finite" id="_ref_249"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, non-NaN, non-<emu-xref href="#sec-decimal-intro" id="_ref_250"><a href="#sec-decimal-intro">negative</a></emu-xref>-<emu-xref href="#dfn-decimal128-zero" id="_ref_251"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 object, (2)</ins> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_252"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><del> together with</del><ins>, or (3) one of</ins> <emu-const>positive-infinity</emu-const>, <emu-const>negative-infinity</emu-const>, <emu-const>not-a-number</emu-const>, and <emu-const>negative-zero</emu-const>.
+          This abstract operation is similar to <emu-xref href="#sec-tonumeric"><a href="https://tc39.es/ecma262/#sec-tonumeric">7.1.3</a></emu-xref>, but a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_253"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> can be returned instead of a Number or BigInt, so that exact decimal values can be represented.
          It performs the following steps when called:</p>
-      <emu-alg><ol><li><ins>If <var>value</var> is a Decimal128 object, then</ins><ol><li><ins>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>value</var>, <var class="field">[[Decimal128Data]]</var>).</ins></li><li><ins>Let <var>d</var> be <var>value</var>.<var class="field">[[Decimal128Data]]</var>.</ins></li><li><ins>If <var>d</var> is NaN<sub>𝔻</sub>, return <emu-const>not-a-number</emu-const>.</ins></li><li><ins>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-const>positive-infinity</emu-const>.</ins></li><li><ins>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-const>negative-infinity</emu-const>.</ins></li><li><ins>Let <var>v</var> be <var>d</var>[0].</ins></li><li><ins>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-const>negative-zero</emu-const>.</ins></li><li><ins>Return <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_6"><a href="#dfn-decimal128-mathematical-value">the mathematical value</a></emu-xref> of <var>d</var>.</ins></li></ol></li><li>Let <var>primValue</var> be ?&nbsp;<emu-xref aoid="ToPrimitive"><a href="https://tc39.es/ecma262/#sec-toprimitive">ToPrimitive</a></emu-xref>(<var>value</var>, <emu-const>number</emu-const>).</li><li>If <emu-xref aoid="Type"><a href="https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values">Type</a></emu-xref>(<var>primValue</var>) is BigInt, return <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>primValue</var>).</li><li>If <emu-xref aoid="Type"><a href="https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values">Type</a></emu-xref>(<var>primValue</var>) is String, then<ol><li>Let <var>str</var> be <var>primValue</var>.</li></ol></li><li>Else,<ol><li>Let <var>x</var> be ?&nbsp;<emu-xref aoid="ToNumber"><a href="https://tc39.es/ecma262/#sec-tonumber">ToNumber</a></emu-xref>(<var>primValue</var>).</li><li>If <var>x</var> is <emu-val>-0</emu-val><sub>𝔽</sub>, return <emu-const>negative-zero</emu-const>.</li><li>Let <var>str</var> be <emu-xref aoid="Number::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-tostring">Number::toString</a></emu-xref>(<var>x</var>, 10).</li></ol></li><li>Let <var>text</var> be <emu-xref aoid="StringToCodePoints"><a href="https://tc39.es/ecma262/#sec-stringtocodepoints">StringToCodePoints</a></emu-xref>(<var>str</var>).</li><li>Let <var>literal</var> be <emu-xref aoid="ParseText"><a href="https://tc39.es/ecma262/#sec-parsetext">ParseText</a></emu-xref>(<var>text</var>, <emu-nt><a href="https://tc39.es/ecma262/#prod-StringNumericLiteral">StringNumericLiteral</a></emu-nt>).</li><li>If <var>literal</var> is a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of errors, return <emu-const>not-a-number</emu-const>.</li><li>Let <var>intlMV</var> be the <emu-xref aoid="StringIntlMV"><a href="https://tc39.es/ecma402/#sec-runtime-semantics-stringintlmv">StringIntlMV</a></emu-xref> of <var>literal</var>.</li><li>If <var>intlMV</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_194"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, then<ol><li>Let <var>rounded</var> be <emu-xref aoid="RoundMVResult"><a href="https://tc39.es/ecma262/#sec-roundmvresult">RoundMVResult</a></emu-xref>(<emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>intlMV</var>)).</li><li>If <var>rounded</var> is <emu-val>+∞</emu-val><sub>𝔽</sub> and <var>intlMV</var> &lt; 0, return <emu-const>negative-infinity</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+∞</emu-val><sub>𝔽</sub>, return <emu-const>positive-infinity</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+0</emu-val><sub>𝔽</sub> and <var>intlMV</var> &lt; 0, return <emu-const>negative-zero</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+0</emu-val><sub>𝔽</sub>, return 0.</li></ol></li><li>Return <var>intlMV</var>.</li></ol></emu-alg>
+      <emu-alg><ol><li><ins>If <var>value</var> is a Decimal128 object, then</ins><ol><li><ins>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>value</var>, <var class="field">[[Decimal128Data]]</var>).</ins></li><li><ins>Let <var>d</var> be <var>value</var>.<var class="field">[[Decimal128Data]]</var>.</ins></li><li><ins>If <var>d</var> is NaN<sub>𝔻</sub>, return <emu-const>not-a-number</emu-const>.</ins></li><li><ins>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-const>positive-infinity</emu-const>.</ins></li><li><ins>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-const>negative-infinity</emu-const>.</ins></li><li><ins>Let <var>v</var> be <var>d</var>[0].</ins></li><li><ins>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-const>negative-zero</emu-const>.</ins></li><li><ins>Return <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_9"><a href="#dfn-decimal128-mathematical-value">the mathematical value</a></emu-xref> of <var>d</var>.</ins></li></ol></li><li>Let <var>primValue</var> be ?&nbsp;<emu-xref aoid="ToPrimitive"><a href="https://tc39.es/ecma262/#sec-toprimitive">ToPrimitive</a></emu-xref>(<var>value</var>, <emu-const>number</emu-const>).</li><li>If <emu-xref aoid="Type"><a href="https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values">Type</a></emu-xref>(<var>primValue</var>) is BigInt, return <emu-xref aoid="ℝ"><a href="https://tc39.es/ecma262/#ℝ">ℝ</a></emu-xref>(<var>primValue</var>).</li><li>If <emu-xref aoid="Type"><a href="https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values">Type</a></emu-xref>(<var>primValue</var>) is String, then<ol><li>Let <var>str</var> be <var>primValue</var>.</li></ol></li><li>Else,<ol><li>Let <var>x</var> be ?&nbsp;<emu-xref aoid="ToNumber"><a href="https://tc39.es/ecma262/#sec-tonumber">ToNumber</a></emu-xref>(<var>primValue</var>).</li><li>If <var>x</var> is <emu-val>-0</emu-val><sub>𝔽</sub>, return <emu-const>negative-zero</emu-const>.</li><li>Let <var>str</var> be <emu-xref aoid="Number::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-tostring">Number::toString</a></emu-xref>(<var>x</var>, 10).</li></ol></li><li>Let <var>text</var> be <emu-xref aoid="StringToCodePoints"><a href="https://tc39.es/ecma262/#sec-stringtocodepoints">StringToCodePoints</a></emu-xref>(<var>str</var>).</li><li>Let <var>literal</var> be <emu-xref aoid="ParseText"><a href="https://tc39.es/ecma262/#sec-parsetext">ParseText</a></emu-xref>(<var>text</var>, <emu-nt><a href="https://tc39.es/ecma262/#prod-StringNumericLiteral">StringNumericLiteral</a></emu-nt>).</li><li>If <var>literal</var> is a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of errors, return <emu-const>not-a-number</emu-const>.</li><li>Let <var>intlMV</var> be the <emu-xref aoid="StringIntlMV"><a href="https://tc39.es/ecma402/#sec-runtime-semantics-stringintlmv">StringIntlMV</a></emu-xref> of <var>literal</var>.</li><li>If <var>intlMV</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_254"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, then<ol><li>Let <var>rounded</var> be <emu-xref aoid="RoundMVResult"><a href="https://tc39.es/ecma262/#sec-roundmvresult">RoundMVResult</a></emu-xref>(<emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>intlMV</var>)).</li><li>If <var>rounded</var> is <emu-val>+∞</emu-val><sub>𝔽</sub> and <var>intlMV</var> &lt; 0, return <emu-const>negative-infinity</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+∞</emu-val><sub>𝔽</sub>, return <emu-const>positive-infinity</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+0</emu-val><sub>𝔽</sub> and <var>intlMV</var> &lt; 0, return <emu-const>negative-zero</emu-const>.</li><li>If <var>rounded</var> is <emu-val>+0</emu-val><sub>𝔽</sub>, return 0.</li></ol></li><li>Return <var>intlMV</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-formatnumberstring" type="abstract operation" aoid="FormatNumericToString">
       <h1><span class="secnum">4.1.2</span> FormatNumericToString ( <var>intlObject</var>, <var>x</var> )</h1>
-      <p>The abstract operation FormatNumericToString takes arguments <var>intlObject</var> (an Object) and <var>x</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_195"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, <emu-const>negative-zero</emu-const><ins>, or a Decimal128 value</ins>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_196"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> or <emu-const>negative-zero</emu-const>) and <var class="field">[[FormattedString]]</var> (a String). It rounds <var>x</var> to an <emu-xref href="#intl-mathematical-value" id="_ref_197"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref> according to the internal slots of <var>intlObject</var>. The <var class="field">[[RoundedNumber]]</var> field contains the rounded result value and the <var class="field">[[FormattedString]]</var> field contains a String value representation of that result formatted according to the internal slots of <var>intlObject</var>. It performs the following steps when called:</p>
-      <emu-alg><ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>intlObject</var> has <var class="field">[[RoundingMode]]</var>, <var class="field">[[RoundingType]]</var>, <var class="field">[[MinimumSignificantDigits]]</var>, <var class="field">[[MaximumSignificantDigits]]</var>, <var class="field">[[MinimumIntegerDigits]]</var>, <var class="field">[[MinimumFractionDigits]]</var>, <var class="field">[[MaximumFractionDigits]]</var>, <var class="field">[[RoundingIncrement]]</var>, and <var class="field">[[TrailingZeroDisplay]]</var> internal slots.</li><li>If <var>x</var> is <emu-const>negative-zero</emu-const>, then<ol><li>Let <var>sign</var> be <emu-const>negative</emu-const>.</li><li>Set <var>x</var> to 0.</li></ol></li><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>sign</var> be <emu-val>undefined</emu-val>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>NaN</emu-val><sub>𝔻</sub>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>+∞</emu-val><sub>𝔻</sub>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>-∞</emu-val><sub>𝔻</sub>.</ins></li><li><ins>Let <var>v</var> be <var>x</var>[0].</ins></li><li><ins>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, then</ins><ol><li><ins>Set <var>sign</var> be <emu-const>negative</emu-const>.</ins></li><li><ins>Set <var>x</var> to 0.</ins></li></ol></li><li><ins>Else,</ins><ol><li><ins>if <var>v</var> &lt; 0, set <var>sign</var> to <emu-const>negative</emu-const>.</ins></li><li><ins>Else, set <var>sign</var> to <emu-const>positive</emu-const>.</ins></li></ol></li><li>Set <var>x</var> to <var>v</var>.</li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_198"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>.</li><li>If <var>x</var> &lt; 0, let <var>sign</var> be <emu-const>negative</emu-const>; else let <var>sign</var> be <emu-const>positive</emu-const>.</li><li>If <var>sign</var> is <emu-const>negative</emu-const>, then<ol><li>Set <var>x</var> to -<var>x</var>.</li></ol></li></ol></li><li>Let <var>unsignedRoundingMode</var> be <emu-xref aoid="GetUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-getunsignedroundingmode">GetUnsignedRoundingMode</a></emu-xref>(<var>intlObject</var>.<var class="field">[[RoundingMode]]</var>, <var>sign</var>).</li><li>If <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>significant-digits</emu-const>, then<ol><li>Let <var>result</var> be <emu-xref aoid="ToRawPrecision" id="_ref_199"><a href="#sec-torawprecision">ToRawPrecision</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumSignificantDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumSignificantDigits]]</var>, <var>unsignedRoundingMode</var>).</li></ol></li><li>Else if <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>fraction-digits</emu-const>, then<ol><li>Let <var>result</var> be <emu-xref aoid="ToRawFixed" id="_ref_200"><a href="#sec-torawfixed">ToRawFixed</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[RoundingIncrement]]</var>, <var>unsignedRoundingMode</var>).</li></ol></li><li>Else,<ol><li>Let <var>sResult</var> be <emu-xref aoid="ToRawPrecision" id="_ref_201"><a href="#sec-torawprecision">ToRawPrecision</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumSignificantDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumSignificantDigits]]</var>, <var>unsignedRoundingMode</var>).</li><li>Let <var>fResult</var> be <emu-xref aoid="ToRawFixed" id="_ref_202"><a href="#sec-torawfixed">ToRawFixed</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[RoundingIncrement]]</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>more-precision</emu-const>, then<ol><li>If <var>sResult</var>.<var class="field">[[RoundingMagnitude]]</var> ≤ <var>fResult</var>.<var class="field">[[RoundingMagnitude]]</var>, then<ol><li>Let <var>result</var> be <var>sResult</var>.</li></ol></li><li>Else,<ol><li>Let <var>result</var> be <var>fResult</var>.</li></ol></li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>less-precision</emu-const>.</li><li>If <var>sResult</var>.<var class="field">[[RoundingMagnitude]]</var> ≤ <var>fResult</var>.<var class="field">[[RoundingMagnitude]]</var>, then<ol><li>Let <var>result</var> be <var>fResult</var>.</li></ol></li><li>Else,<ol><li>Let <var>result</var> be <var>sResult</var>.</li></ol></li></ol></li></ol></li><li>Set <var>x</var> to <var>result</var>.<var class="field">[[RoundedNumber]]</var>.</li><li>Let <var>string</var> be <var>result</var>.<var class="field">[[FormattedString]]</var>.</li><li>If <var>intlObject</var>.<var class="field">[[TrailingZeroDisplay]]</var> is <emu-val>"stripIfInteger"</emu-val> and <emu-eqn class="inline"><var>x</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> 1 = 0</emu-eqn>, then<ol><li>Let <var>i</var> be <emu-xref aoid="StringIndexOf"><a href="https://tc39.es/ecma262/#sec-stringindexof">StringIndexOf</a></emu-xref>(<var>string</var>, <emu-val>"."</emu-val>, 0).</li><li>If <var>i</var> ≠ -1, set <var>string</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>string</var> from 0 to <var>i</var>.</li></ol></li><li>Let <var>int</var> be <var>result</var>.<var class="field">[[IntegerDigitsCount]]</var>.</li><li>Let <var>minInteger</var> be <var>intlObject</var>.<var class="field">[[MinimumIntegerDigits]]</var>.</li><li>If <var>int</var> &lt; <var>minInteger</var>, then<ol><li>Let <var>forwardZeros</var> be the String consisting of <var>minInteger</var> - <var>int</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Set <var>string</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>forwardZeros</var> and <var>string</var>.</li></ol></li><li>If <var>sign</var> is <emu-const>negative</emu-const>, then<ol><li>If <var>x</var> is 0, set <var>x</var> to <emu-const>negative-zero</emu-const>. Otherwise, set <var>x</var> to -<var>x</var>.</li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[RoundedNumber]]</var>: <var>x</var>, <var class="field">[[FormattedString]]</var>: <var>string</var>&nbsp;}.</li></ol></emu-alg>
+      <p>The abstract operation FormatNumericToString takes arguments <var>intlObject</var> (an Object) and <var>x</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_255"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, <emu-const>negative-zero</emu-const><ins>, or a Decimal128 value</ins>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_256"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> or <emu-const>negative-zero</emu-const>) and <var class="field">[[FormattedString]]</var> (a String). It rounds <var>x</var> to an <emu-xref href="#intl-mathematical-value" id="_ref_257"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref> according to the internal slots of <var>intlObject</var>. The <var class="field">[[RoundedNumber]]</var> field contains the rounded result value and the <var class="field">[[FormattedString]]</var> field contains a String value representation of that result formatted according to the internal slots of <var>intlObject</var>. It performs the following steps when called:</p>
+      <emu-alg><ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>intlObject</var> has <var class="field">[[RoundingMode]]</var>, <var class="field">[[RoundingType]]</var>, <var class="field">[[MinimumSignificantDigits]]</var>, <var class="field">[[MaximumSignificantDigits]]</var>, <var class="field">[[MinimumIntegerDigits]]</var>, <var class="field">[[MinimumFractionDigits]]</var>, <var class="field">[[MaximumFractionDigits]]</var>, <var class="field">[[RoundingIncrement]]</var>, and <var class="field">[[TrailingZeroDisplay]]</var> internal slots.</li><li>If <var>x</var> is <emu-const>negative-zero</emu-const>, then<ol><li>Let <var>sign</var> be <emu-const>negative</emu-const>.</li><li>Set <var>x</var> to 0.</li></ol></li><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>sign</var> be <emu-val>undefined</emu-val>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>NaN</emu-val><sub>𝔻</sub>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>+∞</emu-val><sub>𝔻</sub>.</ins></li><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is not <emu-val>-∞</emu-val><sub>𝔻</sub>.</ins></li><li><ins>Let <var>v</var> be <var>x</var>[0].</ins></li><li><ins>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, then</ins><ol><li><ins>Set <var>sign</var> be <emu-const>negative</emu-const>.</ins></li><li><ins>Set <var>x</var> to 0.</ins></li></ol></li><li><ins>Else,</ins><ol><li><ins>if <var>v</var> &lt; 0, set <var>sign</var> to <emu-const>negative</emu-const>.</ins></li><li><ins>Else, set <var>sign</var> to <emu-const>positive</emu-const>.</ins></li></ol></li><li>Set <var>x</var> to <var>v</var>.</li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_258"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>.</li><li>If <var>x</var> &lt; 0, let <var>sign</var> be <emu-const>negative</emu-const>; else let <var>sign</var> be <emu-const>positive</emu-const>.</li><li>If <var>sign</var> is <emu-const>negative</emu-const>, then<ol><li>Set <var>x</var> to -<var>x</var>.</li></ol></li></ol></li><li>Let <var>unsignedRoundingMode</var> be <emu-xref aoid="GetUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-getunsignedroundingmode">GetUnsignedRoundingMode</a></emu-xref>(<var>intlObject</var>.<var class="field">[[RoundingMode]]</var>, <var>sign</var>).</li><li>If <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>significant-digits</emu-const>, then<ol><li>Let <var>result</var> be <emu-xref aoid="ToRawPrecision" id="_ref_259"><a href="#sec-torawprecision">ToRawPrecision</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumSignificantDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumSignificantDigits]]</var>, <var>unsignedRoundingMode</var>).</li></ol></li><li>Else if <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>fraction-digits</emu-const>, then<ol><li>Let <var>result</var> be <emu-xref aoid="ToRawFixed" id="_ref_260"><a href="#sec-torawfixed">ToRawFixed</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[RoundingIncrement]]</var>, <var>unsignedRoundingMode</var>).</li></ol></li><li>Else,<ol><li>Let <var>sResult</var> be <emu-xref aoid="ToRawPrecision" id="_ref_261"><a href="#sec-torawprecision">ToRawPrecision</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumSignificantDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumSignificantDigits]]</var>, <var>unsignedRoundingMode</var>).</li><li>Let <var>fResult</var> be <emu-xref aoid="ToRawFixed" id="_ref_262"><a href="#sec-torawfixed">ToRawFixed</a></emu-xref>(<var>x</var>, <var>intlObject</var>.<var class="field">[[MinimumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[MaximumFractionDigits]]</var>, <var>intlObject</var>.<var class="field">[[RoundingIncrement]]</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>more-precision</emu-const>, then<ol><li>If <var>sResult</var>.<var class="field">[[RoundingMagnitude]]</var> ≤ <var>fResult</var>.<var class="field">[[RoundingMagnitude]]</var>, then<ol><li>Let <var>result</var> be <var>sResult</var>.</li></ol></li><li>Else,<ol><li>Let <var>result</var> be <var>fResult</var>.</li></ol></li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>intlObject</var>.<var class="field">[[RoundingType]]</var> is <emu-const>less-precision</emu-const>.</li><li>If <var>sResult</var>.<var class="field">[[RoundingMagnitude]]</var> ≤ <var>fResult</var>.<var class="field">[[RoundingMagnitude]]</var>, then<ol><li>Let <var>result</var> be <var>fResult</var>.</li></ol></li><li>Else,<ol><li>Let <var>result</var> be <var>sResult</var>.</li></ol></li></ol></li></ol></li><li>Set <var>x</var> to <var>result</var>.<var class="field">[[RoundedNumber]]</var>.</li><li>Let <var>string</var> be <var>result</var>.<var class="field">[[FormattedString]]</var>.</li><li>If <var>intlObject</var>.<var class="field">[[TrailingZeroDisplay]]</var> is <emu-val>"stripIfInteger"</emu-val> and <emu-eqn class="inline"><var>x</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> 1 = 0</emu-eqn>, then<ol><li>Let <var>i</var> be <emu-xref aoid="StringIndexOf"><a href="https://tc39.es/ecma262/#sec-stringindexof">StringIndexOf</a></emu-xref>(<var>string</var>, <emu-val>"."</emu-val>, 0).</li><li>If <var>i</var> ≠ -1, set <var>string</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>string</var> from 0 to <var>i</var>.</li></ol></li><li>Let <var>int</var> be <var>result</var>.<var class="field">[[IntegerDigitsCount]]</var>.</li><li>Let <var>minInteger</var> be <var>intlObject</var>.<var class="field">[[MinimumIntegerDigits]]</var>.</li><li>If <var>int</var> &lt; <var>minInteger</var>, then<ol><li>Let <var>forwardZeros</var> be the String consisting of <var>minInteger</var> - <var>int</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Set <var>string</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>forwardZeros</var> and <var>string</var>.</li></ol></li><li>If <var>sign</var> is <emu-const>negative</emu-const>, then<ol><li>If <var>x</var> is 0, set <var>x</var> to <emu-const>negative-zero</emu-const>. Otherwise, set <var>x</var> to -<var>x</var>.</li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[RoundedNumber]]</var>: <var>x</var>, <var class="field">[[FormattedString]]</var>: <var>string</var>&nbsp;}.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-torawprecision" type="abstract operation" aoid="ToRawPrecision">
       <h1><span class="secnum">4.1.3</span> ToRawPrecision ( <var>x</var>, <var>minPrecision</var>, <var>maxPrecision</var>, <var>unsignedRoundingMode</var> )</h1>
-      <p>The abstract operation ToRawPrecision takes arguments <var>x</var> (a non-<emu-xref href="#sec-decimal-intro" id="_ref_203"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_204"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_205"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_206"><a href="#sec-decimal-intro">negative</a></emu-xref> Decimal128 value</ins>), <var>minPrecision</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 1 to 21), <var>maxPrecision</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 1 to 21), and <var>unsignedRoundingMode</var> (a specification type from the Unsigned Rounding Mode column of <emu-xref href="#table-intl-unsigned-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-unsigned-rounding-modes">Table 15</a></emu-xref>, or <emu-val>undefined</emu-val>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[FormattedString]]</var> (a String), <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_207"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var class="field">[[IntegerDigitsCount]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var class="field">[[RoundingMagnitude]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>).</p>
-          <p><ins>If <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_208"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, it</ins> <del>It</del> involves solving the following equation, which returns a valid <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_209"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> given <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> inputs:</p>
+      <p>The abstract operation ToRawPrecision takes arguments <var>x</var> (a non-<emu-xref href="#sec-decimal-intro" id="_ref_263"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_264"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_265"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_266"><a href="#sec-decimal-intro">negative</a></emu-xref> Decimal128 value</ins>), <var>minPrecision</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 1 to 21), <var>maxPrecision</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 1 to 21), and <var>unsignedRoundingMode</var> (a specification type from the Unsigned Rounding Mode column of <emu-xref href="#table-intl-unsigned-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-unsigned-rounding-modes">Table 15</a></emu-xref>, or <emu-val>undefined</emu-val>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[FormattedString]]</var> (a String), <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_267"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var class="field">[[IntegerDigitsCount]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var class="field">[[RoundingMagnitude]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>).</p>
+          <p><ins>If <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_268"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, it</ins> <del>It</del> involves solving the following equation, which returns a valid <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_269"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> given <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> inputs:</p>
           <emu-eqn id="eqn-ToRawPrecisionFn" aoid="ToRawPrecisionFn"><div>            ToRawPrecisionFn(<var>n</var>, <var>e</var>, <var>p</var>) = <var>n</var> × 10<sup><var>e</var>–<var>p</var>+1</sup></div><div>            where 10<sup><var>p</var>–1</sup> ≤ <var>n</var> &lt; 10<sup><var>p</var></sup></div></emu-eqn>
         
       <p>It performs the following steps when called:</p>
-      <emu-alg><ol><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>m</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_210"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>x</var>).</ins></li><li><ins>Let <var>e</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_211"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> of <var>x</var>.</ins></li><li><ins>Let <var>n</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_212"><a href="#sec-decimal-intro">scaled significand</a></emu-xref> of <var>x</var>.</ins></li></ol></li><li><ins>Else,</ins><ol><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref> <var>x</var> is a mathematival value.</ins></li><li>Let <var>p</var> be <var>maxPrecision</var>.</li><li>If <var>x</var> = 0<ins> or <var>x</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_213"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 object</ins>, then<ol><li>Let <var>m</var> be the String consisting of <var>p</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Let <var>e</var> be 0.</li><li>Let <var>xFinal</var> be 0.</li></ol></li><li>Else,<ol><li declared="n1,e1,r1">Let <var>n1</var> and <var>e1</var> each be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r1</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_214"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r1</var> = <emu-xref aoid="ToRawPrecisionFn" id="_ref_215"><a href="#eqn-ToRawPrecisionFn">ToRawPrecisionFn</a></emu-xref>(<var>n1</var>, <var>e1</var>, <var>p</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>r1</var> ≤ <var>x</var></emu-eqn> and <var>r1</var> is maximized.</li><li declared="n2,e2,r2">Let <var>n2</var> and <var>e2</var> each be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r2</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_216"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r2</var> = <emu-xref aoid="ToRawPrecisionFn" id="_ref_217"><a href="#eqn-ToRawPrecisionFn">ToRawPrecisionFn</a></emu-xref>(<var>n2</var>, <var>e2</var>, <var>p</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>r2</var> ≥ <var>x</var></emu-eqn> and <var>r2</var> is minimized.</li><li>Let <var>r</var> be <emu-xref aoid="ApplyUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-applyunsignedroundingmode">ApplyUnsignedRoundingMode</a></emu-xref>(<var>x</var>, <var>r1</var>, <var>r2</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>r</var> is <var>r1</var>, then<ol><li>Let <var>n</var> be <var>n1</var>.</li><li>Let <var>e</var> be <var>e1</var>.</li><li>Let <var>xFinal</var> be <var>r1</var>.</li></ol></li><li>Else,<ol><li>Let <var>n</var> be <var>n2</var>.</li><li>Let <var>e</var> be <var>e2</var>.</li><li>Let <var>xFinal</var> be <var>r2</var>.</li></ol></li><li>Let <var>m</var> be the String consisting of the digits of the decimal representation of <var>n</var> (in order, with no leading zeroes).</li></ol></li></ol></li><li>If <var>e</var> ≥ (<var>p</var> - 1), then<ol><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>m</var> and <var>e</var> - <var>p</var> + 1 occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Let <var>int</var> be <var>e</var> + 1.</li></ol></li><li>Else if <var>e</var> ≥ 0, then<ol><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of the first <var>e</var> + 1 code units of <var>m</var>, the code unit 0x002E (FULL STOP), and the remaining <var>p</var> - (<var>e</var> + 1) code units of <var>m</var>.</li><li>Let <var>int</var> be <var>e</var> + 1.</li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>e</var> &lt; 0.</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <emu-val>"0."</emu-val>, -(<var>e</var> + 1) occurrences of the code unit 0x0030 (DIGIT ZERO), and <var>m</var>.</li><li>Let <var>int</var> be 1.</li></ol></li><li>If <var>m</var> contains the code unit 0x002E (FULL STOP) and <var>maxPrecision</var> &gt; <var>minPrecision</var>, then<ol><li>Let <var>cut</var> be <var>maxPrecision</var> - <var>minPrecision</var>.</li><li>Repeat, while <var>cut</var> &gt; 0 and the last code unit of <var>m</var> is 0x0030 (DIGIT ZERO),<ol><li>Remove the last code unit from <var>m</var>.</li><li>Set <var>cut</var> to <var>cut</var> - 1.</li></ol></li><li>If the last code unit of <var>m</var> is 0x002E (FULL STOP), then<ol><li>Remove the last code unit from <var>m</var>.</li></ol></li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[FormattedString]]</var>: <var>m</var>, <var class="field">[[RoundedNumber]]</var>: <var>xFinal</var>, <var class="field">[[IntegerDigitsCount]]</var>: <var>int</var>, <var class="field">[[RoundingMagnitude]]</var>: <var>e</var>–<var>p</var>+1&nbsp;}.</li></ol></emu-alg>
+      <emu-alg><ol><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>m</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_270"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>x</var>, <emu-val>false</emu-val>).</ins></li><li><ins>Let <var>e</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_271"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> of <var>x</var>.</ins></li><li><ins>Let <var>n</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_272"><a href="#sec-decimal-intro">scaled significand</a></emu-xref> of <var>x</var>.</ins></li></ol></li><li><ins>Else,</ins><ol><li><ins><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref> <var>x</var> is a mathematival value.</ins></li><li>Let <var>p</var> be <var>maxPrecision</var>.</li><li>If <var>x</var> = 0<ins> or <var>x</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_273"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 object</ins>, then<ol><li>Let <var>m</var> be the String consisting of <var>p</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Let <var>e</var> be 0.</li><li>Let <var>xFinal</var> be 0.</li></ol></li><li>Else,<ol><li declared="n1,e1,r1">Let <var>n1</var> and <var>e1</var> each be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r1</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_274"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r1</var> = <emu-xref aoid="ToRawPrecisionFn" id="_ref_275"><a href="#eqn-ToRawPrecisionFn">ToRawPrecisionFn</a></emu-xref>(<var>n1</var>, <var>e1</var>, <var>p</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>r1</var> ≤ <var>x</var></emu-eqn> and <var>r1</var> is maximized.</li><li declared="n2,e2,r2">Let <var>n2</var> and <var>e2</var> each be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r2</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_276"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r2</var> = <emu-xref aoid="ToRawPrecisionFn" id="_ref_277"><a href="#eqn-ToRawPrecisionFn">ToRawPrecisionFn</a></emu-xref>(<var>n2</var>, <var>e2</var>, <var>p</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>r2</var> ≥ <var>x</var></emu-eqn> and <var>r2</var> is minimized.</li><li>Let <var>r</var> be <emu-xref aoid="ApplyUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-applyunsignedroundingmode">ApplyUnsignedRoundingMode</a></emu-xref>(<var>x</var>, <var>r1</var>, <var>r2</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>r</var> is <var>r1</var>, then<ol><li>Let <var>n</var> be <var>n1</var>.</li><li>Let <var>e</var> be <var>e1</var>.</li><li>Let <var>xFinal</var> be <var>r1</var>.</li></ol></li><li>Else,<ol><li>Let <var>n</var> be <var>n2</var>.</li><li>Let <var>e</var> be <var>e2</var>.</li><li>Let <var>xFinal</var> be <var>r2</var>.</li></ol></li><li>Let <var>m</var> be the String consisting of the digits of the decimal representation of <var>n</var> (in order, with no leading zeroes).</li></ol></li></ol></li><li>If <var>e</var> ≥ (<var>p</var> - 1), then<ol><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>m</var> and <var>e</var> - <var>p</var> + 1 occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Let <var>int</var> be <var>e</var> + 1.</li></ol></li><li>Else if <var>e</var> ≥ 0, then<ol><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of the first <var>e</var> + 1 code units of <var>m</var>, the code unit 0x002E (FULL STOP), and the remaining <var>p</var> - (<var>e</var> + 1) code units of <var>m</var>.</li><li>Let <var>int</var> be <var>e</var> + 1.</li></ol></li><li>Else,<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>e</var> &lt; 0.</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <emu-val>"0."</emu-val>, -(<var>e</var> + 1) occurrences of the code unit 0x0030 (DIGIT ZERO), and <var>m</var>.</li><li>Let <var>int</var> be 1.</li></ol></li><li>If <var>m</var> contains the code unit 0x002E (FULL STOP) and <var>maxPrecision</var> &gt; <var>minPrecision</var>, then<ol><li>Let <var>cut</var> be <var>maxPrecision</var> - <var>minPrecision</var>.</li><li>Repeat, while <var>cut</var> &gt; 0 and the last code unit of <var>m</var> is 0x0030 (DIGIT ZERO),<ol><li>Remove the last code unit from <var>m</var>.</li><li>Set <var>cut</var> to <var>cut</var> - 1.</li></ol></li><li>If the last code unit of <var>m</var> is 0x002E (FULL STOP), then<ol><li>Remove the last code unit from <var>m</var>.</li></ol></li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[FormattedString]]</var>: <var>m</var>, <var class="field">[[RoundedNumber]]</var>: <var>xFinal</var>, <var class="field">[[IntegerDigitsCount]]</var>: <var>int</var>, <var class="field">[[RoundingMagnitude]]</var>: <var>e</var>–<var>p</var>+1&nbsp;}.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-torawfixed" type="abstract operation" aoid="ToRawFixed">
       <h1><span class="secnum">4.1.4</span> ToRawFixed ( <var>x</var>, <var>minFraction</var>, <var>maxFraction</var>, <var>roundingIncrement</var>, <var>unsignedRoundingMode</var> )</h1>
-      <p>The abstract operation ToRawFixed takes arguments <var>x</var> (a non-<emu-xref href="#sec-decimal-intro" id="_ref_218"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_219"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_220"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_221"><a href="#sec-decimal-intro">negative</a></emu-xref> Decimal128 value</ins>), <var>minFraction</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 0 to 100), <var>maxFraction</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 0 to 100), <var>roundingIncrement</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var>unsignedRoundingMode</var> (a specification type from the Unsigned Rounding Mode column of <emu-xref href="#table-intl-unsigned-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-unsigned-rounding-modes">Table 15</a></emu-xref>, or <emu-val>undefined</emu-val>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[FormattedString]]</var> (a String), <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_222"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var class="field">[[IntegerDigitsCount]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var class="field">[[RoundingMagnitude]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>).</p>
-          <p><del>It</del> involves solving the following equation, which returns a valid <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_223"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> given <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> inputs:</p>
+      <p>The abstract operation ToRawFixed takes arguments <var>x</var> (a non-<emu-xref href="#sec-decimal-intro" id="_ref_278"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_279"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_280"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_281"><a href="#sec-decimal-intro">negative</a></emu-xref> Decimal128 value</ins>), <var>minFraction</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 0 to 100), <var>maxFraction</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> in the <emu-xref href="#inclusive-interval"><a href="https://tc39.es/ecma262/#inclusive-interval">inclusive interval</a></emu-xref> from 0 to 100), <var>roundingIncrement</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var>unsignedRoundingMode</var> (a specification type from the Unsigned Rounding Mode column of <emu-xref href="#table-intl-unsigned-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-unsigned-rounding-modes">Table 15</a></emu-xref>, or <emu-val>undefined</emu-val>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> with fields <var class="field">[[FormattedString]]</var> (a String), <var class="field">[[RoundedNumber]]</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_282"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var class="field">[[IntegerDigitsCount]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>), and <var class="field">[[RoundingMagnitude]]</var> (an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref>).</p>
+          <p><del>It</del> involves solving the following equation, which returns a valid <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_283"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref> given <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> inputs:</p>
           <emu-eqn id="eqn-ToRawFixedFn" aoid="ToRawFixedFn"><div>            ToRawFixedFn(<var>n</var>, <var>f</var>) = <var>n</var> × 10<sup>–<var>f</var></sup></div></emu-eqn>
         
       <p>It performs the following steps when called:</p>
-      <emu-alg><ol><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>m</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_224"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>x</var>).</ins></li><li><ins>Let <var>f</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_225"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> of <var>x</var>.</ins></li><li><ins>Let <var>n</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_226"><a href="#sec-decimal-intro">scaled significand</a></emu-xref> of <var>x</var>.</ins></li></ol></li><li>Else,<ol><li>Let <var>f</var> be <var>maxFraction</var>.</li><li declared="n1,r1">Let <var>n1</var> be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r1</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_227"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r1</var> = <emu-xref aoid="ToRawFixedFn" id="_ref_228"><a href="#eqn-ToRawFixedFn">ToRawFixedFn</a></emu-xref>(<var>n1</var>, <var>f</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>n1</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> <var>roundingIncrement</var> = 0</emu-eqn>, <emu-eqn class="inline"><var>r1</var> ≤ <var>x</var></emu-eqn>, and <var>r1</var> is maximized.</li><li declared="n2,r2">Let <var>n2</var> be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r2</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_229"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r2</var> = <emu-xref aoid="ToRawFixedFn" id="_ref_230"><a href="#eqn-ToRawFixedFn">ToRawFixedFn</a></emu-xref>(<var>n2</var>, <var>f</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>n2</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> <var>roundingIncrement</var> = 0</emu-eqn>, <emu-eqn class="inline"><var>r2</var> ≥ <var>x</var></emu-eqn>, and <var>r2</var> is minimized.</li><li>Let <var>r</var> be <emu-xref aoid="ApplyUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-applyunsignedroundingmode">ApplyUnsignedRoundingMode</a></emu-xref>(<var>x</var>, <var>r1</var>, <var>r2</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>r</var> is <var>r1</var>, then<ol><li>Set <var>n</var> to <var>n1</var>.</li><li>Let <var>xFinal</var> be <var>r1</var>.</li></ol></li><li>Else,<ol><li>Set <var>n</var> to <var>n2</var>.</li><li>Let <var>xFinal</var> be <var>r2</var>.</li></ol></li></ol></li><li>If <var>n</var> = 0, let <var>m</var> be <emu-val>"0"</emu-val>. Otherwise, let <var>m</var> be the String consisting of the digits of the decimal representation of <var>n</var> (in order, with no leading zeroes).</li><li>If <var>f</var> ≠ 0, then<ol><li>Let <var>k</var> be the length of <var>m</var>.</li><li>If <var>k</var> ≤ <var>f</var>, then<ol><li>Let <var>z</var> be the String value consisting of <var>f</var> + 1 - <var>k</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>z</var> and <var>m</var>.</li><li>Set <var>k</var> to <var>f</var> + 1.</li></ol></li><li>Let <var>a</var> be the first <var>k</var> - <var>f</var> code units of <var>m</var>, and let <var>b</var> be the remaining <var>f</var> code units of <var>m</var>.</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>a</var>, <emu-val>"."</emu-val>, and <var>b</var>.</li><li>Let <var>int</var> be the length of <var>a</var>.</li></ol></li><li>Else,<ol><li>Let <var>int</var> be the length of <var>m</var>.</li></ol></li><li>Let <var>cut</var> be <var>maxFraction</var> - <var>minFraction</var>.</li><li>Repeat, while <var>cut</var> &gt; 0 and the last code unit of <var>m</var> is 0x0030 (DIGIT ZERO),<ol><li>Remove the last code unit from <var>m</var>.</li><li>Set <var>cut</var> to <var>cut</var> - 1.</li></ol></li><li>If the last code unit of <var>m</var> is 0x002E (FULL STOP), then<ol><li>Remove the last code unit from <var>m</var>.</li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[FormattedString]]</var>: <var>m</var>, <var class="field">[[RoundedNumber]]</var>: <var>xFinal</var>, <var class="field">[[IntegerDigitsCount]]</var>: <var>int</var>, <var class="field">[[RoundingMagnitude]]</var>: –<var>f</var>&nbsp;}.</li></ol></emu-alg>
+      <emu-alg><ol><li><ins>If <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>m</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_284"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>x</var>, <emu-val>false</emu-val>).</ins></li><li><ins>Let <var>f</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_285"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> of <var>x</var>.</ins></li><li><ins>Let <var>n</var> be the <emu-xref href="#sec-decimal-intro" id="_ref_286"><a href="#sec-decimal-intro">scaled significand</a></emu-xref> of <var>x</var>.</ins></li></ol></li><li>Else,<ol><li>Let <var>f</var> be <var>maxFraction</var>.</li><li declared="n1,r1">Let <var>n1</var> be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r1</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_287"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r1</var> = <emu-xref aoid="ToRawFixedFn" id="_ref_288"><a href="#eqn-ToRawFixedFn">ToRawFixedFn</a></emu-xref>(<var>n1</var>, <var>f</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>n1</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> <var>roundingIncrement</var> = 0</emu-eqn>, <emu-eqn class="inline"><var>r1</var> ≤ <var>x</var></emu-eqn>, and <var>r1</var> is maximized.</li><li declared="n2,r2">Let <var>n2</var> be an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and <var>r2</var> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_289"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>, with <emu-eqn class="inline"><var>r2</var> = <emu-xref aoid="ToRawFixedFn" id="_ref_290"><a href="#eqn-ToRawFixedFn">ToRawFixedFn</a></emu-xref>(<var>n2</var>, <var>f</var>)</emu-eqn>, such that <emu-eqn class="inline"><var>n2</var> <emu-xref aoid="modulo"><a href="https://tc39.es/ecma262/#eqn-modulo">modulo</a></emu-xref> <var>roundingIncrement</var> = 0</emu-eqn>, <emu-eqn class="inline"><var>r2</var> ≥ <var>x</var></emu-eqn>, and <var>r2</var> is minimized.</li><li>Let <var>r</var> be <emu-xref aoid="ApplyUnsignedRoundingMode"><a href="https://tc39.es/ecma402/#sec-applyunsignedroundingmode">ApplyUnsignedRoundingMode</a></emu-xref>(<var>x</var>, <var>r1</var>, <var>r2</var>, <var>unsignedRoundingMode</var>).</li><li>If <var>r</var> is <var>r1</var>, then<ol><li>Set <var>n</var> to <var>n1</var>.</li><li>Let <var>xFinal</var> be <var>r1</var>.</li></ol></li><li>Else,<ol><li>Set <var>n</var> to <var>n2</var>.</li><li>Let <var>xFinal</var> be <var>r2</var>.</li></ol></li></ol></li><li>If <var>n</var> = 0, let <var>m</var> be <emu-val>"0"</emu-val>. Otherwise, let <var>m</var> be the String consisting of the digits of the decimal representation of <var>n</var> (in order, with no leading zeroes).</li><li>If <var>f</var> ≠ 0, then<ol><li>Let <var>k</var> be the length of <var>m</var>.</li><li>If <var>k</var> ≤ <var>f</var>, then<ol><li>Let <var>z</var> be the String value consisting of <var>f</var> + 1 - <var>k</var> occurrences of the code unit 0x0030 (DIGIT ZERO).</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>z</var> and <var>m</var>.</li><li>Set <var>k</var> to <var>f</var> + 1.</li></ol></li><li>Let <var>a</var> be the first <var>k</var> - <var>f</var> code units of <var>m</var>, and let <var>b</var> be the remaining <var>f</var> code units of <var>m</var>.</li><li>Set <var>m</var> to the <emu-xref href="#string-concatenation"><a href="https://tc39.es/ecma262/#string-concatenation">string-concatenation</a></emu-xref> of <var>a</var>, <emu-val>"."</emu-val>, and <var>b</var>.</li><li>Let <var>int</var> be the length of <var>a</var>.</li></ol></li><li>Else,<ol><li>Let <var>int</var> be the length of <var>m</var>.</li></ol></li><li>Let <var>cut</var> be <var>maxFraction</var> - <var>minFraction</var>.</li><li>Repeat, while <var>cut</var> &gt; 0 and the last code unit of <var>m</var> is 0x0030 (DIGIT ZERO),<ol><li>Remove the last code unit from <var>m</var>.</li><li>Set <var>cut</var> to <var>cut</var> - 1.</li></ol></li><li>If the last code unit of <var>m</var> is 0x002E (FULL STOP), then<ol><li>Remove the last code unit from <var>m</var>.</li></ol></li><li>Return the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[FormattedString]]</var>: <var>m</var>, <var class="field">[[RoundedNumber]]</var>: <var>xFinal</var>, <var class="field">[[IntegerDigitsCount]]</var>: <var>int</var>, <var class="field">[[RoundingMagnitude]]</var>: –<var>f</var>&nbsp;}.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-partitionnumberpattern" type="abstract operation" aoid="PartitionNumberPattern">
       <h1><span class="secnum">4.1.5</span> PartitionNumberPattern ( <var>numberFormat</var>, <var>x</var> )</h1>
-      <p>The abstract operation PartitionNumberPattern takes arguments <var>numberFormat</var> (an object initialized as a NumberFormat) and <var>x</var> (an <emu-xref href="#intl-mathematical-value" id="_ref_231"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Records</a></emu-xref> with fields <var class="field">[[Type]]</var> (a String) and <var class="field">[[Value]]</var> (a String). It creates the parts representing the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> according to the effective locale and the formatting options of <var>numberFormat</var>. It performs the following steps when called:</p>
+      <p>The abstract operation PartitionNumberPattern takes arguments <var>numberFormat</var> (an object initialized as a NumberFormat) and <var>x</var> (an <emu-xref href="#intl-mathematical-value" id="_ref_291"><a href="#intl-mathematical-value">Intl mathematical value</a></emu-xref>) and returns a <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref> of <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Records</a></emu-xref> with fields <var class="field">[[Type]]</var> (a String) and <var class="field">[[Value]]</var> (a String). It creates the parts representing the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> according to the effective locale and the formatting options of <var>numberFormat</var>. It performs the following steps when called:</p>
 
-      <emu-alg><ol><li>Let <var>exponent</var> be 0.</li><li>If <var>x</var> is <emu-const>not-a-number</emu-const>, then<ol><li>Let <var>n</var> be an implementation- and locale-dependent (ILD) String value indicating the <emu-val>NaN</emu-val> value.</li></ol></li><li>Else if <var>x</var> is <emu-const>positive-infinity</emu-const>, then<ol><li>Let <var>n</var> be an ILD String value indicating positive infinity.</li></ol></li><li>Else if <var>x</var> is <emu-const>negative-infinity</emu-const>, then<ol><li>Let <var>n</var> be an ILD String value indicating <emu-xref href="#sec-decimal-intro" id="_ref_232"><a href="#sec-decimal-intro">negative</a></emu-xref> infinity.</li></ol></li><li><ins>Else if <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>v</var> be <var>x</var>[0].</ins></li><li><ins>Let <var>q</var> be <var>x</var>[1].</ins></li><li><ins>If <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, set <var>x</var> to « <var>v</var> × 100, <var>q</var> + 2&nbsp;».</ins></li><li><ins>Set <var>exponent</var> to the <emu-xref href="#sec-decimal-intro" id="_ref_233"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> <var>x</var>.</ins></li><li><ins>Set <var>x</var> to !&nbsp;<var>v</var> × 10<sup>-<var>exponent</var></sup>.</ins></li></ol></li><li>Else,<ol><li>If <var>x</var> is not <emu-const>negative-zero</emu-const>, then<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_234"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>.</li><li>If <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, set <var>x</var> be 100 × <var>x</var>.</li><li>Set <var>exponent</var> to <emu-xref aoid="ComputeExponent"><a href="https://tc39.es/ecma402/#sec-computeexponent">ComputeExponent</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Set <var>x</var> to <var>x</var> × 10<sup>-<var>exponent</var></sup>.</li></ol></li><li>Let <var>formatNumberResult</var> be <emu-xref aoid="FormatNumericToString" id="_ref_235"><a href="#sec-formatnumberstring">FormatNumericToString</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Let <var>n</var> be <var>formatNumberResult</var>.<var class="field">[[FormattedString]]</var>.</li><li>Set <var>x</var> to <var>formatNumberResult</var>.<var class="field">[[RoundedNumber]]</var>.</li></ol></li><li>Let <var>pattern</var> be <emu-xref aoid="GetNumberFormatPattern"><a href="https://tc39.es/ecma402/#sec-getnumberformatpattern">GetNumberFormatPattern</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Let <var>result</var> be a new empty <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref>.</li><li>Let <var>patternParts</var> be <emu-xref aoid="PartitionPattern"><a href="https://tc39.es/ecma402/#sec-partitionpattern">PartitionPattern</a></emu-xref>(<var>pattern</var>).</li><li>For each <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>, <var class="field">[[Value]]</var>&nbsp;} <var>patternPart</var> of <var>patternParts</var>, do<ol><li>Let <var>p</var> be <var>patternPart</var>.<var class="field">[[Type]]</var>.</li><li>If <var>p</var> is <emu-val>"literal"</emu-val>, then<ol><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"literal"</emu-val>, <var class="field">[[Value]]</var>: <var>patternPart</var>.<var class="field">[[Value]]</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"number"</emu-val>, then<ol><li>Let <var>notationSubParts</var> be <emu-xref aoid="PartitionNotationSubPattern"><a href="https://tc39.es/ecma402/#sec-partitionnotationsubpattern">PartitionNotationSubPattern</a></emu-xref>(<var>numberFormat</var>, <var>x</var>, <var>n</var>, <var>exponent</var>).</li><li>For each <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>, <var class="field">[[Value]]</var>&nbsp;} <var>subPart</var> of <var>notationSubParts</var>, do<ol><li>Append <var>subPart</var> to <var>result</var>.</li></ol></li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"plusSign"</emu-val>, then<ol><li>Let <var>plusSignSymbol</var> be the ILND String representing the plus sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"plusSign"</emu-val>, <var class="field">[[Value]]</var>: <var>plusSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"minusSign"</emu-val>, then<ol><li>Let <var>minusSignSymbol</var> be the ILND String representing the minus sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"minusSign"</emu-val>, <var class="field">[[Value]]</var>: <var>minusSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"percentSign"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, then<ol><li>Let <var>percentSignSymbol</var> be the ILND String representing the percent sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"percentSign"</emu-val>, <var class="field">[[Value]]</var>: <var>percentSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"unitPrefix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"unit"</emu-val>, then<ol><li>Let <var>unit</var> be <var>numberFormat</var>.<var class="field">[[Unit]]</var>.</li><li>Let <var>unitDisplay</var> be <var>numberFormat</var>.<var class="field">[[UnitDisplay]]</var>.</li><li>Let <var>mu</var> be an ILD String value representing <var>unit</var> before <var>x</var> in <var>unitDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unit"</emu-val>, <var class="field">[[Value]]</var>: <var>mu</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"unitSuffix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"unit"</emu-val>, then<ol><li>Let <var>unit</var> be <var>numberFormat</var>.<var class="field">[[Unit]]</var>.</li><li>Let <var>unitDisplay</var> be <var>numberFormat</var>.<var class="field">[[UnitDisplay]]</var>.</li><li>Let <var>mu</var> be an ILD String value representing <var>unit</var> after <var>x</var> in <var>unitDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unit"</emu-val>, <var class="field">[[Value]]</var>: <var>mu</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencyCode"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>cd</var> be <var>currency</var>.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencyPrefix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>currencyDisplay</var> be <var>numberFormat</var>.<var class="field">[[CurrencyDisplay]]</var>.</li><li>Let <var>cd</var> be an ILD String value representing <var>currency</var> before <var>x</var> in <var>currencyDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencySuffix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>currencyDisplay</var> be <var>numberFormat</var>.<var class="field">[[CurrencyDisplay]]</var>.</li><li>Let <var>cd</var> be an ILD String value representing <var>currency</var> after <var>x</var> in <var>currencyDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms. If the implementation does not have such a representation of <var>currency</var>, use <var>currency</var> itself.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else,<ol><li>Let <var>unknown</var> be an ILND String based on <var>x</var> and <var>p</var>.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unknown"</emu-val>, <var class="field">[[Value]]</var>: <var>unknown</var>&nbsp;} to <var>result</var>.</li></ol></li></ol></li><li>Return <var>result</var>.</li></ol></emu-alg>
+      <emu-alg><ol><li>Let <var>exponent</var> be 0.</li><li>If <var>x</var> is <emu-const>not-a-number</emu-const>, then<ol><li>Let <var>n</var> be an implementation- and locale-dependent (ILD) String value indicating the <emu-val>NaN</emu-val> value.</li></ol></li><li>Else if <var>x</var> is <emu-const>positive-infinity</emu-const>, then<ol><li>Let <var>n</var> be an ILD String value indicating positive infinity.</li></ol></li><li>Else if <var>x</var> is <emu-const>negative-infinity</emu-const>, then<ol><li>Let <var>n</var> be an ILD String value indicating <emu-xref href="#sec-decimal-intro" id="_ref_292"><a href="#sec-decimal-intro">negative</a></emu-xref> infinity.</li></ol></li><li><ins>Else if <var>x</var> is a Decimal128 value, then</ins><ol><li><ins>Let <var>v</var> be <var>x</var>[0].</ins></li><li><ins>Let <var>q</var> be <var>x</var>[1].</ins></li><li><ins>If <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, set <var>x</var> to « <var>v</var> × 100, <var>q</var> + 2&nbsp;».</ins></li><li><ins>Set <var>exponent</var> to the <emu-xref href="#sec-decimal-intro" id="_ref_293"><a href="#sec-decimal-intro">truncated exponent</a></emu-xref> <var>x</var>.</ins></li><li><ins>Set <var>x</var> to !&nbsp;<var>v</var> × 10<sup>-<var>exponent</var></sup>.</ins></li></ol></li><li>Else,<ol><li>If <var>x</var> is not <emu-const>negative-zero</emu-const>, then<ol><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>x</var> is a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_294"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>.</li><li>If <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, set <var>x</var> be 100 × <var>x</var>.</li><li>Set <var>exponent</var> to <emu-xref aoid="ComputeExponent"><a href="https://tc39.es/ecma402/#sec-computeexponent">ComputeExponent</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Set <var>x</var> to <var>x</var> × 10<sup>-<var>exponent</var></sup>.</li></ol></li><li>Let <var>formatNumberResult</var> be <emu-xref aoid="FormatNumericToString" id="_ref_295"><a href="#sec-formatnumberstring">FormatNumericToString</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Let <var>n</var> be <var>formatNumberResult</var>.<var class="field">[[FormattedString]]</var>.</li><li>Set <var>x</var> to <var>formatNumberResult</var>.<var class="field">[[RoundedNumber]]</var>.</li></ol></li><li>Let <var>pattern</var> be <emu-xref aoid="GetNumberFormatPattern"><a href="https://tc39.es/ecma402/#sec-getnumberformatpattern">GetNumberFormatPattern</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Let <var>result</var> be a new empty <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref>.</li><li>Let <var>patternParts</var> be <emu-xref aoid="PartitionPattern"><a href="https://tc39.es/ecma402/#sec-partitionpattern">PartitionPattern</a></emu-xref>(<var>pattern</var>).</li><li>For each <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>, <var class="field">[[Value]]</var>&nbsp;} <var>patternPart</var> of <var>patternParts</var>, do<ol><li>Let <var>p</var> be <var>patternPart</var>.<var class="field">[[Type]]</var>.</li><li>If <var>p</var> is <emu-val>"literal"</emu-val>, then<ol><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"literal"</emu-val>, <var class="field">[[Value]]</var>: <var>patternPart</var>.<var class="field">[[Value]]</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"number"</emu-val>, then<ol><li>Let <var>notationSubParts</var> be <emu-xref aoid="PartitionNotationSubPattern"><a href="https://tc39.es/ecma402/#sec-partitionnotationsubpattern">PartitionNotationSubPattern</a></emu-xref>(<var>numberFormat</var>, <var>x</var>, <var>n</var>, <var>exponent</var>).</li><li>For each <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>, <var class="field">[[Value]]</var>&nbsp;} <var>subPart</var> of <var>notationSubParts</var>, do<ol><li>Append <var>subPart</var> to <var>result</var>.</li></ol></li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"plusSign"</emu-val>, then<ol><li>Let <var>plusSignSymbol</var> be the ILND String representing the plus sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"plusSign"</emu-val>, <var class="field">[[Value]]</var>: <var>plusSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"minusSign"</emu-val>, then<ol><li>Let <var>minusSignSymbol</var> be the ILND String representing the minus sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"minusSign"</emu-val>, <var class="field">[[Value]]</var>: <var>minusSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"percentSign"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, then<ol><li>Let <var>percentSignSymbol</var> be the ILND String representing the percent sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"percentSign"</emu-val>, <var class="field">[[Value]]</var>: <var>percentSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"unitPrefix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"unit"</emu-val>, then<ol><li>Let <var>unit</var> be <var>numberFormat</var>.<var class="field">[[Unit]]</var>.</li><li>Let <var>unitDisplay</var> be <var>numberFormat</var>.<var class="field">[[UnitDisplay]]</var>.</li><li>Let <var>mu</var> be an ILD String value representing <var>unit</var> before <var>x</var> in <var>unitDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unit"</emu-val>, <var class="field">[[Value]]</var>: <var>mu</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"unitSuffix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"unit"</emu-val>, then<ol><li>Let <var>unit</var> be <var>numberFormat</var>.<var class="field">[[Unit]]</var>.</li><li>Let <var>unitDisplay</var> be <var>numberFormat</var>.<var class="field">[[UnitDisplay]]</var>.</li><li>Let <var>mu</var> be an ILD String value representing <var>unit</var> after <var>x</var> in <var>unitDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unit"</emu-val>, <var class="field">[[Value]]</var>: <var>mu</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencyCode"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>cd</var> be <var>currency</var>.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencyPrefix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>currencyDisplay</var> be <var>numberFormat</var>.<var class="field">[[CurrencyDisplay]]</var>.</li><li>Let <var>cd</var> be an ILD String value representing <var>currency</var> before <var>x</var> in <var>currencyDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencySuffix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>currencyDisplay</var> be <var>numberFormat</var>.<var class="field">[[CurrencyDisplay]]</var>.</li><li>Let <var>cd</var> be an ILD String value representing <var>currency</var> after <var>x</var> in <var>currencyDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms. If the implementation does not have such a representation of <var>currency</var>, use <var>currency</var> itself.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else,<ol><li>Let <var>unknown</var> be an ILND String based on <var>x</var> and <var>p</var>.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unknown"</emu-val>, <var class="field">[[Value]]</var>: <var>unknown</var>&nbsp;} to <var>result</var>.</li></ol></li></ol></li><li>Return <var>result</var>.</li></ol></emu-alg>
     </emu-clause>
   </emu-clause>
 </emu-clause><emu-annex id="sec-copyright-and-software-license">
diff --git a/intl.emu b/intl.emu
index a6b98a09..06e2d2ad 100644
--- a/intl.emu
+++ b/intl.emu
@@ -152,7 +152,7 @@
       </dl>
       <emu-alg>
         1. <ins>If _x_ is a Decimal128 value, then</ins>
-          1. <ins>Let _m_ be Decimal128ToDecimalString(_x_).</ins>
+          1. <ins>Let _m_ be Decimal128ToDecimalString(_x_, *false*).</ins>
           1. <ins>Let _e_ be the truncated exponent of _x_.</ins>
           1. <ins>Let _n_ be the scaled significand of _x_.</ins>
         1. <ins>Else,</ins>
@@ -217,7 +217,7 @@
       </dl>
       <emu-alg>
         1. <ins>If _x_ is a Decimal128 value, then</ins>
-          1. <ins>Let _m_ be Decimal128ToDecimalString(_x_).</ins>
+          1. <ins>Let _m_ be Decimal128ToDecimalString(_x_, *false*).</ins>
           1. <ins>Let _f_ be the truncated exponent of _x_.</ins>
           1. <ins>Let _n_ be the scaled significand of _x_.</ins>
         1. Else,
diff --git a/package.json b/package.json
index eec0bfd5..74a326c6 100644
--- a/package.json
+++ b/package.json
@@ -4,8 +4,8 @@
   "description": "Representing base-10 decimal numbers",
   "scripts": {
     "start": "npm run build-loose -- --watch",
-    "build": "npm run build-loose --",
-    "build-loose": "ecmarkup --verbose --lint-spec --strict --load-biblio @tc39/ecma262-biblio --load-biblio @tc39/ecma402-biblio spec.emu index.html"
+    "build": "npm run build-loose -- --strict",
+    "build-loose": "ecmarkup --verbose --lint-spec --load-biblio @tc39/ecma262-biblio --load-biblio @tc39/ecma402-biblio spec.emu index.html"
   },
   "repository": {
     "type": "git",
diff --git a/spec.emu b/spec.emu
index baeb7b64..94e41c24 100644
--- a/spec.emu
+++ b/spec.emu
@@ -110,7 +110,7 @@ location: https://github.com/tc39/proposal-decimal/
       <li>_v_ = _s_ × 10<sup>_e_</sup></li>
       <li>1 ≤ abs(_s_) < 10</li>
     </ol>
-    <p>We call _e_ the <dfn>exponent</dfn> and _s_ the <dfn>significand</dfn> of « _v_, _q_ »<sub>𝔻</sub>. The exponent and significand are undefined for NaN, non-finite, and zero Decimal128 values.</p>
+    <p>We call _e_ the <dfn id="dfn-decimal128-exponent">exponent</dfn> and _s_ the <dfn id="dfn-decimal128-significand">significand</dfn> of « _v_, _q_ »<sub>𝔻</sub>. The exponent and significand are undefined for NaN, non-finite, and zero Decimal128 values.</p>
     <emu-note>
       <p>The significand of a finite non-zero Decimal128 value is a rational number.</p>
     </emu-note>
@@ -130,40 +130,110 @@ location: https://github.com/tc39/proposal-decimal/
   <emu-clause id="sec-decimal-abstract-ops">
     <h1>Abstract Operations</h1>
 
-    <emu-clause id="sec-decimal128-decimal128todecimalstring" type="abstract operation">
+    <emu-clause id="sec-decimal128-abs" type="abstract operation">
       <h1>
-        Decimal128ToDecimalString (
+        Decimal128Abs (
           _argument_ : a Decimal128 value
+        ): either *NaN*<sub>𝔻</sub> or a non-negative Decimal128 value
+      </h1>
+      <dl class="header">
+        <dt>description</dt>
+        <dd>It computes the absolute value of a Decimal128 value</dd>
+      </dl>
+      <emu-alg>
+        1. If _argument_ is *NaN*<sub>𝔻</sub>, return *NaN*<sub>𝔻</sub>.
+        1. If _argument_ is *+∞*<sub>𝔻</sub>, return *+∞*<sub>𝔻</sub>.
+        1. If _argument_ is *-∞*<sub>𝔻</sub>, return *-∞*<sub>𝔻</sub>.
+        1. Let _v_ be cohort(_argument_).
+        1. Let _q_ be quantum(_argument_).
+        1. If _v_ is *+0*<sub>𝔻</sub>, return « *+0*<sub>𝔻</sub>, _q_ »<sub>𝔻</sub>.
+        1. If _v_ is *-0*<sub>𝔻</sub>, return « *+0*<sub>𝔻</sub>, _q_ »<sub>𝔻</sub>.
+        1. Otherwise, return « abs(_v_), _q_ »<sub>𝔻</sub>.
+      </emu-alg>
+    </emu-clause>
+
+    <emu-clause id="sec-decimal128-negate" type="abstract operation">
+      <h1>
+        Decimal128Negate (
+          _argument_ : a Decimal128 value
+        ): a Decimal128 value
+      </h1>
+      <dl class="header">
+        <dt>description</dt>
+        <dd>It computes the negation of a Decimal128 value</dd>
+      </dl>
+      <emu-alg>
+        1. If _argument_ is *NaN*<sub>𝔻</sub>, return *NaN*<sub>𝔻</sub>.
+        1. If _argument_ is *+∞*<sub>𝔻</sub>, return *-∞*<sub>𝔻</sub>.
+        1. If _argument_ is *-∞*<sub>𝔻</sub>, return *+∞*<sub>𝔻</sub>.
+        1. Let _v_ be cohort(_argument_).
+        1. Let _q_ be quantum(_argument_).
+        1. If _v_ is *+0*<sub>𝔻</sub>, return « *-0*<sub>𝔻</sub>, _q_ »<sub>𝔻</sub>.
+        1. If _v_ is *-0*<sub>𝔻</sub>, return « *+0*<sub>𝔻</sub>, _q_ »<sub>𝔻</sub>.
+        1. Otherwise, return « -_v_, _q_ »<sub>𝔻</sub>.
+      </emu-alg>
+    </emu-clause>
+
+    <emu-clause id="sec-decimal128-nonnegativedecimal128todecimalstring" type="abstract operation">
+      <h1>
+        NonNegativeDecimal128ToDecimalString (
+          _argument_ : a non-negative Decimal128 value,
+          _shouldCanonicalize_ : a Boolean
         ): a String
       </h1>
       <dl class="header">
         <dt>description</dt>
-        <dd>It renders _argument_ as a decimal (non-exponential) string.</dd>
+        <dd>It renders _argument_ as a string, possibly in exponential notation if the decimal representation of the number would require too many digits.</dd>
       </dl>
       <emu-alg>
-        1. If _argument_ is *NaN*<sub>𝔻</sub>, return *"NaN"*.
         1. If _argument_ is *+∞*<sub>𝔻</sub>, return *"Infinity"*.
-        1. If _argument_ is *-∞*<sub>𝔻</sub>, return *"-Infinity"*.
         1. Let _v_ be cohort(_argument_).
         1. Let _q_ be quantum(_argument_).
-        1. If _v_ is *+0*<sub>𝔻</sub>, return *"0"*.
-        1. If _v_ is *-0*<sub>𝔻</sub>, return *"-0"*.
-        1. Let _n_ be the integer for which _v_ × 10<sup>-_q_</sup> = _n_ and 0 < abs(_n_) < 10<sup>34</sup>.
-        1. Assert: _n_ is not 0.
+        1. If _v_ is *+0*<sub>𝔻</sub>, let _integerPart_ be *"0"*.
+        1. Otherwise, if _v_ is *-0*<sub>𝔻</sub>, let _integerPart_ be *"-0"*.
+        1. Let _n_ be the integer for which _v_ × 10<sup>-_q_</sup> = _n_.
+        1. Assert: 0 < abs(_n_) < 10<sup>34</sup>.
         1. Let _digits_ be the unique decimal string representation of _n_ without leading zeroes.
-        1. If _q_ < 0, then
+        1. If _q_ ≥ 0, then
           1. Let _trailingZeroes_ be the String *"0"* repeated abs(_n_) - _q_ times.
           1. Return the concatenation of _digits_ and _trailingZeroes_.
-        1. Let _integerPart_ be the substring of _digits_ from 0 to abs(n) - _q_.
-        1. Let _nonIntegerPart_ be the substring of _digits_ from abs(n) - _q_ to the length of _digits_.
+        1. Let _integerPart_ be the substring of _digits_ from 0 to abs(_n_) - _q_.
+        1. If _shouldCanonicalize_ is *true* and _v_ 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 abs(_n_) - _q_ to the length of _digits_.
+        1. If _shouldCanonicalize_ is *true*, set _nonIntegerPart_ to a copy of _nonIntegerPart_ with trailing *"0"*s removed.
+        1. Assert: _nonIntegerPart_ is not *""*.
         1. Return the concatenation of _integerPart_, *"."*, and _nonIntegerPart_.
       </emu-alg>
     </emu-clause>
 
+    <emu-clause id="sec-decimal128-decimal128todecimalstring" type="abstract operation">
+      <h1>
+        Decimal128ToDecimalString (
+          _argument_ : a Decimal128 value,
+          _shouldCanonicalize_ : a Boolean
+        ): a String
+      </h1>
+      <dl class="header">
+        <dt>description</dt>
+        <dd>It renders _argument_ as a string, possibly in exponential notation if the decimal representation of the number would require too many digits.</dd>
+      </dl>
+      <emu-alg>
+        1. If _argument_ is *NaN*<sub>𝔻</sub>, return *"NaN"*.
+        1. Let _abs_ be Decimal128Abs(_argument_).
+        1. Let _renderedAbsoluateValue_ be NonNegativeDecimal128ToDecimalString(_abs_, _shouldCanonicalize_).
+        1. If _argument_ is negative, return the concatenation of *"-"* and _renderedAbsoluateValue_.
+        1. Otherwise, return _renderedAbsoluateValue_.
+      </emu-alg>
+    </emu-clause>
+
     <emu-clause id="sec-decimal128toexponentialstring" type="abstract operation">
       <h1>
         Decimal128ToExponentialString (
-          _argument_ : a Decimal128 value
+          _argument_ : a Decimal128 value,
+          _shouldCanonicalize_ : a Boolean
         ): a String
       </h1>
       <dl class="header">
@@ -199,9 +269,10 @@ location: https://github.com/tc39/proposal-decimal/
         1. If _d_ is *NaN*<sub>𝔻</sub>, return *false*.
         1. If _d_ is *+∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return *false*.
         1. Let _v_ be cohort(_d_).
-        1. Let _q_ be quantum(_d_).
-        1. If _v_ is an integer and 0 ≤ _q_, return *true*.
-        1. Return *false*.
+        1. If _v_ is *+0*<sub>𝔻</sub>, return *true*.
+        1. If _v_ is *-0*<sub>𝔻</sub>, return *true*.
+        1. If _v_ is an integer, return *true*.
+        1. Otherwise, return *false*.
       </emu-alg>
     </emu-clause>
 
@@ -236,31 +307,13 @@ location: https://github.com/tc39/proposal-decimal/
       </dl>
       <emu-alg>
         1. If -6111 ≤ _intendedExponent_ ≤ 6176, then
-          1. If _coefficient_ × 10<sup>_intendedExponent_</sup> is an integer _n_ such that 0 < abs(_n_) < 10<sup>34</sup>, return « _coefficient, _intendedExponent_ »<sub>𝔻</sub>.
+          1. If _coefficient_ is 0, return « *+0*<sub>𝔻</sub>, _intendedExponent_ »<sub>𝔻</sub>.
+          1. If _coefficient_ × 10<sup>_intendedExponent_</sup> is an integer _n_ such that 0 < abs(_n_) < 10<sup>34</sup>, return « _coefficient_, _intendedExponent_ »<sub>𝔻</sub>.
           1. Throw a *RangeError* exception.
         1. If _intendedExponent_ < 0, return ? EnsureDecimal128Value(_coefficient_ / 10, _intendedExponent_ + 1, _roundingMode_).
         1. Otherwise, return ? EnsureDecimal128Value(_coefficient_ × 10, _intendedExponent_ + 1, _roundingMode_).
       </emu-alg>
     </emu-clause>
-    <emu-clause id="sec-decimal128-canonicalizedecimal128" type="abstract operation">
-      <h1>
-        CanonicalizeDecimal128 (
-          _d_: a Decimal128 value
-        ): a Decimal128 value
-      </h1>
-      <dl class="header">
-        <dt>description</dt>
-        <dd>It converts the argument into a canonicalized, mathematically equal member of the same cohort.</dd>
-      </dl>
-      <emu-alg>
-        1. If _d_ is *NaN*<sub>𝔻</sub>, *+∞*<sub>𝔻</sub>, or *-∞*<sub>𝔻</sub>, return _d_.
-        1. Let _v_ be cohort(_d_).
-        1. If _v_ is is *+0*<sub>𝔻</sub> or *-0*<sub>𝔻</sub>, return _d_.
-        1. Let _e_ be the exponent of _v_.
-        1. Let _s_ be the significand of _v_.
-        1. Return « _s_, _e_ ».
-      </emu-alg>
-    </emu-clause>
   </emu-clause>
 
   <emu-clause id="sec-the-decimal-constructor">
@@ -278,36 +331,65 @@ location: https://github.com/tc39/proposal-decimal/
         1. If NewTarget is *undefined*, throw a *TypeError* exception.
         1. Let _toParse_ be *undefined*.
         1. If _x_ is a BigInt, set _toParse_ to BigInt::toString(_x_, 10).
-        1. Otherwise, if _x_ is a Number, set _toParse_ to Number::toString(_x_, 10).
+        1. Otherwise, if _x_ is a Number, set _toParse_ to ! Call(%Number.prototype.toExponential%, _x_, « »).
         1. Otherwise, if _x_ is a String, set _toParse_ to _x_.
         1. If _toParse_ is not a String, throw a *TypeError* exception.
         1. Let _O_ be ? OrdinaryCreateFromConstructor(NewTarget, *"%Decimal128.prototype%"*, « [[Decimal128Data]] »).
-        1. If _toParse_ is *"NaN"*, regardless of case, set _O_.[[Decimal128Data]] to *NaN*<sub>𝔻</sub>.
-        1. If _toParse_ is *"-Infinity"*, regardless of case, set _O_.[[Decimal128Data]] to *-∞*<sub>𝔻</sub>.
-        1. If _toParse_ is *"Infinity"*, regardless of case, set _O_.[[Decimal128Data]] to *+∞*<sub>𝔻</sub>.
-        1. Let _parseResult_ be ParseText(_toParse_, |DecimalLiteral|).
-        1. If _parseResult_ is a List of errors, throw a *SyntaxError* exception.
-        1. If _parseResult_ contains a |DecimalIntegerLiteral|, then
-          1. Let _integerPart_ be the source text contained within the |DecimalIntegerLiteral| Parse Node.
+        1. If _toParse_ is *"NaN"*, then
+          1. Set _O_.[[Decimal128Data]] to *NaN*<sub>𝔻</sub>.
         1. Else,
-          1. Let _integerPart_ be *"0"*.
-        1. Let _nonIntegerDigits_ be the source text contained within the |DecimalLiteral| Parse Node.
-        1. If _parseResult_ contains a |ExponentPart| Parse Node whose source text is not *""*, then
-          1. Let _exponentPart_ be the source text contained within the |ExponentPart| Parse Node.
-          1. Let _s_ be the concatenation of _integerPart_ and _nonIntegerDigits_.
-          1. Let _m_ be the mathematical value whose decimal representation is _s_.
-          1. Let _e_ be the mathematical value whose decimal representatin is _exponentPart_.
-          1. Set _O_.[[Decimal128Data]] to ? EnsureDecimal128Value(_m_, _e_, *"halfEven"*).
-        1. Else,
-          1. Let _s_ be the concatenation of _integerPart_ and _nonIntegerDigits_.
-          1. Let _q_ be the length of _nonIntegerDigits_.
-          1. Let _m_ be the mathematical value whose decimal representation is _s_.
-          1. Set _O_.[[Decimal128Data]] to ? EnsureDecimal128Value(_m_, -_q_, *"halfEven"*).
+          1. Let _parseResult_ be ParseText(_toParse_, |StrDecimalLiteral|).
+          1. If _parseResult_ is a List of errors, throw a *SyntaxError* exception.
+          1. Let _decimalValue_ be ? StringDecimalValue of _parseResult_.
+          1. Set _O_.[[Decimal128Data]] to _decimalValue_.
         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>
       </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>
+        <dl class="header">
+        </dl>
+        <emu-grammar>StrDecimalLiteral ::: `-` StrUnsignedDecimalLiteral</emu-grammar>
+        <emu-alg>
+          1. Let _a_ be ? StringDecimalValue of |StrUnsignedDecimalLiteral|.
+          1. If _a_ is *+∞*<sub>𝔻</sub>, return *-∞*<sub>𝔻</sub>.
+          1. Let _v_ be cohort(_a_).
+          1. Let _q_ be quantum(_a_).
+          1. If _v_ is *+0*<sub>𝔻</sub>, return « *-0*<sub>𝔻</sub>, _q_ ».
+          1. Return « -_v_, _q_ ».
+        </emu-alg>
+        <emu-grammar>StrUnsignedDecimalLiteral ::: `Infinity`</emu-grammar>
+        <emu-alg>
+          1. Return *+∞*<sub>𝔻</sub>.
+        </emu-alg>
+        <emu-grammar>StrUnsignedDecimalLiteral ::: DecimalDigits `.` DecimalDigits? ExponentPart?</emu-grammar>
+        <emu-alg>
+          1. Let _a_ be MV of the first |DecimalDigits|.
+          1. If the second |DecimalDigits| is present, then
+            1. Let _b_ be MV of the second |DecimalDigits|.
+            1. Let _n_ be the number of code points in the second |DecimalDigits|.
+          1. Else,
+            1. Let _b_ be 0.
+            1. Let _n_ be 0.
+          1. If |ExponentPart| is present, let _e_ be MV of |ExponentPart|. Otherwise, let _e_ be 0.
+          1. Return ? EnsureDecimal128Value((_a_ + (_b_ × 10<sup>-_n_</sup>)) × 10<sup>_e_</sup>, _e_ - _n_, *"halfEven"*).
+        </emu-alg>
+        <emu-grammar>StrUnsignedDecimalLiteral ::: `.` DecimalDigits ExponentPart?</emu-grammar>
+        <emu-alg>
+          1. Let _b_ be MV of |DecimalDigits|.
+          1. If |ExponentPart| is present, let _e_ be MV of |ExponentPart|. Otherwise, let _e_ be 0.
+          1. Let _n_ be the number of code points in |DecimalDigits|.
+          1. Return ? EnsureDecimal128Value(_b_ × 10<sup>_e_ - _n_</sup>, _e_ - _n_, *"halfEven"*).
+        </emu-alg>
+        <emu-grammar>StrUnsignedDecimalLiteral ::: DecimalDigits ExponentPart?</emu-grammar>
+        <emu-alg>
+          1. Let _a_ be MV of |DecimalDigits|.
+          1. If |ExponentPart| is present, let _e_ be MV of |ExponentPart|. Otherwise, let _e_ be 0.
+          1. Return ? EnsureDecimal128Value(_a_ × 10<sup>_e_</sup>, _e_, *"halfEven"*).
+        </emu-alg>
+      </emu-clause>
     </emu-clause>
   </emu-clause>
 </emu-clause>
@@ -341,6 +423,44 @@ location: https://github.com/tc39/proposal-decimal/
     </emu-alg>
   </emu-clause>
 
+  <emu-clause id="sec-decimal.prototype.exponent">
+    <h1>Decimal128.prototype.exponent ( )</h1>
+    <p>This method returns a Number value represents the <emu-xref href="#dfn-decimal128-exponent">exponent</emu-xref>, which is the integer _n_ for which the current Decimal128 object, _x_ = « _v_, _q_ »<sub>𝔻</sub>, there exists a mathematical value _s_ such that _v_ = _s_ × 10<sup>_e_</sup> and 1 ≤ abs(_s_) < 10. This method requires that the Decimal128 value held by the curernt Decimal128 object is finite and non-zero.</p>
+    <p>It performs the following steps when called:</p>
+    <emu-alg>
+      1. Let _O_ be the *this* value.
+      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
+      1. Let _d_ be _O_.[[Decimal128Data]].
+      1. If _d_ is *NaN*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. If _d_ is *+∞*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. If _d_ is *-∞*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. Let _v_ be cohort(_d_).
+      1. If _v_ is *+0*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. If _v_ is *-0*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. Let _e_ be the unique integer for which there exists a mathematical value _s_ such that _v_ = _s_ × 10<sup>_e_</sup> and 1 ≤ abs(_s_) < 10.
+      1. Return 𝔽(_e_).
+    </emu-alg>
+  </emu-clause>
+
+  <emu-clause id="sec-decimal.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, _x_ = « _v_, _q_ »<sub>𝔻</sub>, there exists an integer _e_ such such that _v_ = _s_ × 10<sup>_e_</sup> and 1 ≤ abs(_s_) < 10. This method requires that the Decimal128 value held by the curernt Decimal128 object is finite and non-zero.</p>
+    <p>It performs the following steps when called:</p>
+    <emu-alg>
+      1. Let _O_ be the *this* value.
+      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
+      1. Let _d_ be _O_.[[Decimal128Data]].
+      1. If _d_ is *NaN*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. If _d_ is *+∞*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. If _d_ is *-∞*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. Let _v_ be cohort(_d_).
+      1. If _v_ is *+0*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. If _v_ is *-0*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. Let _s_ be the unique rational number for which there exists an integer _n_ such that _v_ = _s_ × 10<sup>_e_</sup> and 1 ≤ abs(_s_) < 10.
+      1. Return Decimal128ValueToObject(! EnsureDecimal128Value(_s_, -_e_, *"halfEven"*)).
+    </emu-alg>
+  </emu-clause>
+
   <emu-clause id="sec-decimal.prototype.abs">
     <h1>Decimal128.prototype.abs ( )</h1>
     <p>This method computes the absolute value of a Decimal128 object.</p>
@@ -349,12 +469,7 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _O_ be the *this* value.
       1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
       1. Let _d_ be _O_.[[Decimal128Data]].
-      1. If _d_ is *NaN*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
-      1. If _d_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
-      1. If _d_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
-      1. Let _v_ be cohort(_d_).
-      1. Let _q_ be quantum( _d_).
-      1. Return Decimal128ValueToObject(« abs(_v_), _q_ »<sub>𝔻</sub>).
+      1. Return Decimal128ValueToObject(Decimal128Abs(_d_)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification in Section 5.5.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -369,12 +484,7 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _O_ be the *this* value.
       1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
       1. Let _d_ be _O_.[[Decimal128Data]].
-      1. If _d_ is *NaN*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
-      1. If _d_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
-      1. If _d_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
-      1. Let _v_ be cohort(_d_).
-      1. Let _q_ be quantum(_d_).
-      1. Return Decimal128ValueToObject(« -1 × _v_, _q_ »<sub>𝔻</sub>).
+      1. Return Decimal128ValueToObject(Decimal128Negate(_d_)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification in Section 5.5.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -404,7 +514,25 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _v2_ be cohort(_d2_).
       1. Let _q1_ be quantum(_d1_).
       1. Let _q2_ be quantum(_d2_).
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ + _v2_, min(_q1_, _q2_]), *"halfEven"*)).
+      1. Let _newQ_ be min(_q1_, _q2_).
+      1. If _v1_ is *+0*<sub>𝔻</sub>, then
+        1. If _v2_ *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. If _v2_ *-0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« _v2_, _newQ_ »).
+      1. If _v1_ is *-0*<sub>𝔻</sub>, then
+        1. If _v2_ *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. If _v2_ *-0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« _v2_, _newQ_ »).
+      1. If _v2_ is *+0*<sub>𝔻</sub>, then
+        1. If _v1_ *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. If _v1_ *-0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« _v1_, _newQ_ »).
+      1. If _v2_ is *-0*<sub>𝔻</sub>, then
+        1. If _v1_ *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. If _v1_ *-0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« _v1_, _newQ_ »).
+      1. If _v1_ + _v2_ = 0, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+      1. Otherwise, return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ + _v2_, _newQ_, *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -434,7 +562,19 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _v2_ be cohort(_d2_).
       1. Let _q1_ be quantum(_d1_).
       1. Let _q2_ be quantum(_d2_).
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ - _v2_, min(_q1_, _q2_), *"halfEven"*)).
+      1. Let _newQ_ be min(_q1_, _q2_).
+      1. If _v1_ is *+0*<sub>𝔻</sub>, then
+        1. If _v2_ *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. If _v2_ *-0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« _v2_, _newQ_ »).
+      1. If _v1_ is *-0*<sub>𝔻</sub>, then
+        1. If _v2_ *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _newQ_ »).
+        1. If _v2_ *-0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« _v2_, _newQ_ »).
+      1. If _v2_ is *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(« _v1_, _newQ_ »).
+      1. If _v2_ is *-0*<sub>𝔻</sub>, return Decimal128ValueToObject(« _v1_, _newQ_ »).
+      1. If _v1_ + _v2_ = 0, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+      1. Otherwise, return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ - _v2_, _newQ_, *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -467,7 +607,21 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _v1_ be cohort(_d1_).
       1. Let _q1_ be quantum(_d1_).
       1. Let _q2_ be quantum(_d2_).
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value (_v1_ × _v2, _q1_ + _q2_], *"halfEven"*)).
+      1. Let _newQ_ be _q1_ + _q2_.
+      1. If _v1_ is *+0*<sub>𝔻</sub>, then
+        1. If the mathematical value of _d2_ is negative, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+      1. If _v1_ is *-0*<sub>𝔻</sub>, then
+        1. If the mathematical value of _d2_ is negative, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _newQ_ »).
+      1. If _v2_ is *+0*<sub>𝔻</sub>, then
+        1. If the mathematical value of _d1_ is negative, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+      1. If _v2_ is *-0*<sub>𝔻</sub>, then
+        1. If the mathematical value of _d1_ is negative, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _newQ_ »).
+      1. Assert: _v1_ × _v2 ≠ 0.
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value (_v1_ × _v2, _newQ_, *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -491,7 +645,16 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _v2_ be cohort(_d2_).
       1. Let _q1_ be quantum(_d1_).
       1. Let _q2_ be quantum(_d2_).
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ / _v2_, _q1_ + _q2_, *"halfEven"*)).
+      1. Let _newQ_ be _q1_ + _q2_.
+      1. If _v1_ is *+0*<sub>𝔻</sub>, then
+        1. If the mathematical value of _d2_ is negative, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+      1. If _v1_ is *-0*<sub>𝔻</sub>, then
+        1. If the mathematical value of _d2_ is negative, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+        1. Otherwise, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _newQ_ »).
+      1. If _v2_ is *+0*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. If _v2_ is *-0*<sub>𝔻</sub>, throw a *RangeError* exception.
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ / _v2_, _newQ_, *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification in Section 5.4.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -515,68 +678,21 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _v2_ be cohort(_d2_).
       1. Let _q1_ be quantum(_d1_).
       1. Let _q2_ be quantum(_d2_).
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ % _v2_, _q1_ + _q2_, *"halfEven"*)).
+      1. Let _newQ_ be _q1_ + _q2_.
+      1. If _v2_ is *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
+      1. If _v2_ is *-0*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
+      1. If _v1_ is *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _newQ_ »).
+      1. If _v1_ is *-0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _newQ_ »).
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v1_ % _v2_, _newQ_, *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>The remainder operation specified here deviates from the <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref> remainder operation (defined there in Section 5.3.1). We follow the <emu-xref href="#sec-numeric-types-number-remainder">the remainder operation for Number</emu-xref> rather than IEEE 754, which specifies that, for example, the remainder 46 and 10 is -4 rather than 6.</p>
     </emu-note>
   </emu-clause>
 
-  <emu-clause id="sec-decimal.prototype.equals">
-    <h1>Decimal128.prototype.equals ( _x_ )</h1>
-    <p>This method computes whether the current Decimal128 object has the same mathematical value as another Decimal128 object.</p>
-    <p>It performs the following steps when called:</p>
-    <emu-alg>
-      1. Let _O_ be the *this* value.
-      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
-      1. Perform ? RequireInternalSlot(_x_, [[Decimal128Data]]).
-      1. Let _d1_ be _O_.[[Decimal128Data]].
-      1. Let _d2_ be _x_.[[Decimal128Data]].
-      1. If _d1_ or _d2_ is *NaN*<sub>𝔻</sub>, throw a *RangeError* exception.
-      1. If _d1_ is *+∞*<sub>𝔻</sub>, then
-        1. If _d2_ is *+∞*<sub>𝔻</sub>, return *true*.
-        1. Return *false*.
-      1. If _d1_ is *-∞*<sub>𝔻</sub>, then
-        1. If _d2_ is *-∞*<sub>𝔻</sub>, return *true*.
-        1. Return *false*.
-      I. If _d2_ is *+∞*<sub>𝔻</sub> or *+∞*<sub>𝔻</sub>, return *false*.
-      1. If the mathematical value of _d1_ is equal to the mathematical value of _d2_, return *true*.
-      1. Return *false*.
-    </emu-alg>
-    <emu-note>
-      <p>This operation follows the specification of the <code>compareSignalingEqual</code> operation in Section 5.6.1 (and explained in Section 5.11) of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
-    </emu-note>
-  </emu-clause>
-
-  <emu-clause id="sec-decimal.prototype.lessthan">
-    <h1>Decimal128.prototype.lessThan ( _x_ )</h1>
-    <p>This method computes whether the current Decimal128 object has a strictly smaller mathematical value than another Decimal128 object.</p>
-    <p>It performs the following steps when called:</p>
-    <emu-alg>
-      1. Let _O_ be the *this* value.
-      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
-      1. Perform ? RequireInternalSlot(_x_, [[Decimal128Data]]).
-      1. Let _d1_ be _O_.[[Decimal128Data]].
-      1. Let _d2_ be _x_.[[Decimal128Data]].
-      1. If _d1_ or _d2_ is *NaN*<sub>𝔻</sub>, throw a *RangeError* exception.
-      1. If _d1_ is *+∞*<sub>𝔻</sub>, then
-        1. If _d2_ is *+∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return *false*.
-        1. Return *true*.
-      1. If _d1_ is *+∞*<sub>𝔻</sub>, then
-        1. If _d2_ is *-∞*<sub>𝔻</sub>, return *false*.
-        1. If _d2_ is *+∞*<sub>𝔻</sub>, return *true*.
-        1. Return *true*.
-      1. If the mathematical value of of _d1_ is less than the mathematical value of _d2_, return *true*.
-      1. Return *false*.
-    </emu-alg>
-    <emu-note>
-      <p>This operation follows the specification of the <code>compareSignalingLess</code> operation in Section 5.6.1 (and explained in Section 5.11) of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
-    </emu-note>
-  </emu-clause>
-
   <emu-clause id="sec-decimal.prototype.compare">
     <h1>Decimal128.prototype.compare ( _x_ )</h1>
-    <p>This method returns one of the three Number values *-1*<sub>𝔽</sub>, *+0*<sub>𝔽</sub>, and *1*<sub>𝔽</sub>. It compares the current Decimal128 object with another one. If the current Decimal128 object has a strictly smaller mathematical value, the result is *-1*<sub>𝔽</sub>. If the current Decimal128 object has a strictly greater mathematical value, it returns *1*<sub>𝔽</sub>. If the mathematical value of the two Decimal128 objects are the same, the exponents are compared and the computation proceeds similarly, returning *-1*<sub>𝔽</sub> if the exponent of the current Decimal128 object is strictly less than that of the argument, *1*<sub>𝔽</sub> if if the exponent is strictly greater, finally returning *+0*<sub>𝔽</sub> if the exponents are mathematically equal.</p>
+    <p>This method returns one of the four Number values *-1*<sub>𝔽</sub>, *+0*<sub>𝔽</sub>, *1*<sub>𝔽</sub>, and *NaN*<sub>𝔽</sub>. It compares the mathematical value of the current Decimal128 object with that of another Decimal128 object.</p>
     <p>It performs the following steps when called:</p>
     <emu-alg>
       1. Let _O_ be the *this* value.
@@ -584,10 +700,7 @@ 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>, then
-        1. If _d2_ is *NaN*<sub>𝔻</sub>, return *true*.
-        1. Return *false*.
-      1. If _d2_ is *NaN*<sub>𝔻</sub>, return *false*.
+      1. If _d1_ is *NaN*<sub>𝔻</sub>, return *NaN*<sub>𝔽</sub>.
       1. If _d1_ is *+∞*<sub>𝔻</sub>, then
         1. If _d2_ is *+∞*<sub>𝔻</sub>, return *+0*<sub>𝔽</sub>.
         1. Return *1*<sub>𝔽</sub>.
@@ -596,19 +709,12 @@ location: https://github.com/tc39/proposal-decimal/
         1. Return *-1*<sub>𝔽</sub>.
       1. If _d2_ is *+∞*<sub>𝔻</sub>, return *-1*<sub>𝔽</sub>.
       1. If _d2_ is *-∞*<sub>𝔻</sub>, return *1*<sub>𝔽</sub>.
-      1. If the mathematical value of of _d1_ is less than the mathematical value of _d2_, return *-1*<sub>𝔽</sub>.
-      1. If the mathematical value of of _d2_ is less than the mathematical value of _d1_, return *1*<sub>𝔽</sub>.
-      1. Let _v1_ be _d1_[1].
-      1. Let _v2_ be _d2_[1].
-      1. If the mathematical value of _v1_ is less than the mathematical value of _v2_, return *-1*<sub>𝔽</sub>.
-      1. If the mathematical value of _v2_ is less than the mathematical value of _v1_, return *1*<sub>𝔽</sub>.
-      1. Return *+0*<sub>𝔽</sub>.
+      1. If <emu-xref href="#dfn-decimal128-mathematical-value">the mathematical value of</emu-xref> of _d1_ is less than <emu-xref href="#dfn-decimal128-mathematical-value">the mathematical value of</emu-xref> _d2_, return *-1*<sub>𝔽</sub>.
+      1. If <emu-xref href="#dfn-decimal128-mathematical-value">the mathematical value of of</emu-xref> _d2_ is less than <emu-xref href="#dfn-decimal128-mathematical-value">the mathematical value of</emu-xref> _d1_, return *1*<sub>𝔽</sub>.
+      1. Otherwise, return *+0*<sub>𝔻</sub>.
     </emu-alg>
     <emu-note>
-      <p>This operation follows the specification of the <code>compareQuietOrdered</code> operation in Section 5.6.1 (and explained in Section 5.11) of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
-    </emu-note>
-    <emu-note>
-      <p>This operation compares Decimal128 values, intuitively understood as digit strings. Thus, for example, 1.2 and 1.20 are considered distinct values for this operation. To compare by mathematical value, see <emu-xref href="#sec-decimal.prototype.lessthan">lessThan</emu-xref> or <emu-xref href="#sec-decimal.prototype.equals">equals</emu-xref>.</p>
+      <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">IEEE 754-2019</emu-xref>.</p>
     </emu-note>
   </emu-clause>
 
@@ -626,15 +732,41 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _O_ be the *this* value.
       1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
       1. Let _d_ be _O_.[[Decimal128Data]].
-      1. If _d_ is *NaN*<sub>𝔻</sub>, return _O_.
-      1. If _d_ is *+∞*<sub>𝔻</sub>, return _O_.
-      1. If _d_ is *-∞*<sub>𝔻</sub>, return _O_.
+      1. If _d_ is *NaN*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
+      1. If _d_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
+      1. If _d_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
       1. Let _v_ be cohort(_d_).
       1. Let _q_ be quantum(_d_).
-      1. If _v_ is *+0*<sub>𝔻</sub>, return _O_.
-      1. If _v_ is *-0*<sub>𝔻</sub>, return _O_.
+      1. If _v_ is *+0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *+0*<sub>𝔻</sub>, _numFractionalDigits_ »).
+      1. If _v_ is *-0*<sub>𝔻</sub>, return Decimal128ValueToObject(« *-0*<sub>𝔻</sub>, _numFractionalDigits_ »).
       1. Let _n_ be the integer such that v × 10<sup>-_q_</sup> = _n_ and 0 < abs(_n_) < 10<sup>34</sup>.
-      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(v × 10<sup>-_numFractionalDigits_</sup>, _q_ + _numFractionalDigits_, _roundingMode_)).
+      1. Let _newD_ be ? EnsureDecimal128Value(v × 10<sup>_numFractionalDigits_</sup>, _q_ + _numFractionalDigits_, _roundingMode_).
+      1. Return Decimal128ValueToObject(_newD_).
+    </emu-alg>
+    <emu-note>
+      <p>This operation follows the specification of the rounding mode attributes discussed in Section 4.3 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
+    </emu-note>
+  </emu-clause>
+
+  <emu-clause id="sec-decimal-method-scale10">
+    <h1>Decimal128.prototype.scale10 ( _n_ )</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>
+      1. Let _O_ be the *this* value.
+      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
+      1. If _n_ is not a Number, throw a *TypeError* exception.
+      1. If _n_ is *NaN*<sub>𝔽</sub>, throw a *RangeError* exception.
+      1. If _n_ is *+∞*<sub>𝔽</sub>, throw a *RangeError* exception.
+      1. If _n_ is *-∞*<sub>𝔽</sub>, throw a *RangeError* exception.
+      1. Let _d_ be _O_.[[Decimal128Data]].
+      1. If _d_ is *NaN*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
+      1. If _d_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
+      1. If _d_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
+      1. Let _v_ be cohort(_d_).
+      1. Let _q_ be quantum(_d_).
+      1. If _v_ is neither *+0*<sub>𝔻</sub> nor *-0*<sub>𝔻</sub>, set _v_ to _v_ × 10<sup>ℝ(_n_)</sup>.
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_v_, _q_ + ℝ(_n_), *"halfEven"*)).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification of the rounding mode attributes discussed in Section 4.3 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -643,16 +775,19 @@ location: https://github.com/tc39/proposal-decimal/
 
   <emu-clause id="sec-decimal.prototype.tostring">
     <h1>Decimal128.prototype.toString ( [ _options_ ] )</h1>
-    <p>This method generates a String representation of the current Decimal128 object, in decimal format. Unlike Number’s <emu-xref href="#sec-number.prototype.tostring">toString</emu-xref>, this method always produces a decimal representation of the Decimal128 object and never produces an exponential representation. That functionality is provided by <emu-xref href="#sec-decimal.prototype.toexponential">toExponential</emu-xref>.</p>
+    <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">toString</emu-xref> by rendering the decimal in decimal notation, provided the length of that string is less than 20. Otherwise, the decimal will be rendered in exponential notation.</p>
     <p>It performs the following steps when called:</p>
     <emu-alg>
       1. Let _O_ be the *this* value.
       1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
-      1. Let _shouldCanonicalize_ be ? Get(_options_, *"canonicalize"*).
-      1. If _shouldCanonicalize_ is *undefined*, set _shouldCanonicalize_ to *true*.
-      1. If _shouldCanonicalize_ is not a Boolean value, throw a *TypeError* exception.
-      1. If _shouldCanonicalize_ is *true*, return Decimal128ToDecimalString(CanonicalizeDecimal128(_O_)).
-      1. Otherwise, return Decimal128ToDecimalString(_O_).
+      1. Let _shouldCanonicalize_ be *true*.
+      1. If _options_ is not *undefined*, then
+        1. If _options_ is not an Object, throw a *TypeError* exception.
+        1. Set _shouldCanonicalize_ to ? Get(_options_, *"canonicalize"*).
+        1. If _shouldCanonicalize_ is not a Boolean value, throw a *TypeError* exception.
+      1. Let _inDecimalNotation_ be Decimal128ToDecimalString(_O_, _shouldCanonicalize_).
+      1. If the length of _inDecimalNotation_ is less than 22, return _inDecimalNotation_.
+      1. Otherwise, return Decimal128ToExponentialString(_O_, _shouldCanonicalize_).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -660,16 +795,18 @@ location: https://github.com/tc39/proposal-decimal/
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.toexponential">
-    <h1>Decimal128.prototype.toExponential ( [ _shouldCanonicalize_ ] )</h1>
+    <h1>Decimal128.prototype.toExponential ( [ _options_ ] )</h1>
     <p>This method generates a String representation of the current Decimal128 object, in exponential format (e.g., *"123e-4"*).</p>
     <p>It performs the following steps when called:</p>
     <emu-alg>
       1. Let _O_ be the *this* value.
       1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
-      1. If _shouldCanonicalize_ is *undefined*, set _shouldCanonicalize_ to *true*.
-      1. If _shouldCanonicalize_ is not a Boolean value, throw a *TypeError* exception.
-      1. If _shouldCanonicalize_ is *true*, return Decimal128ToExponentialString(CanonicalizeDecimal128(_O_)).
-      1. Otherwise, return Decimal128ToExponentialString(_O_).
+      1. Let _shouldCanonicalize_ be *true*.
+      1. If _options_ is not *undefined*, then
+        1. If _options_ is not an Object, throw a *TypeError* exception.
+        1. Set _shouldCanonicalize_ to ? Get(_options_, *"canonicalize"*).
+        1. If _shouldCanonicalize_ is not a Boolean value, throw a *TypeError* exception.
+      1. Return Decimal128ToExponentialString(_O_, _shouldCanonicalize_).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -677,20 +814,24 @@ location: https://github.com/tc39/proposal-decimal/
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.tofixed">
-    <h1>Decimal128.prototype.toFixed ( _numDigits_ [ , _shouldCanonicalize_ ] )</h1>
+    <h1>Decimal128.prototype.toFixed ( [ _options_ ] )</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>
       1. Let _O_ be the *this* value.
       1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
-      1. If _shouldCanonicalize_ is *undefined*, set _shouldCanonicalize_ to *true*.
-      1. If _numDigits_ is neither *undefined* nor a Number, throw a *TypeError* exception.
-      1. If _numDigits_ is *undefined_, let _numDigits_ be *+0*<sub>𝔽</sub>.
+      1. Let _shouldCanonicalize_ be *true*.
+      1. Let _numDigits_ be *+0*<sub>𝔽</sub>.
+      1. If _options_ is not *undefined*, then
+        1. If _options_ is not an Object, throw a *TypeError* exception.
+        1. Set _shouldCanonicalize_ to ? Get(_options_, *"canonicalize"*).
+        1. Set _numDigits_ to ? Get(_options_, *"digits"*).
+        1. If _numDigits_ is not a Number, throw a *TypeError* exception.
+        1. If _shouldCanonicalize_ is not a Boolean value, throw a *TypeError* exception.
       1. If _numDigits_ < 0, throw a *RangeError* exception.
       1. If _numDigits_ is not an integer, throw a *RangeError* exception.
-      1. If _shouldCanonicalize_ is *undefined*, set _shouldCanonicalize_ to *true*.
       1. If _shouldCanonicalize_ is not a Boolean value, throw a *TypeError* exception.
-      1. If _shouldCanonicalize_ is *true*, let _s_ be Decimal128ToDecimalString(CanonicalizeDecimal128(_O_)), otherwise let _s_ be Decimal128ToDecimalString(_O_).
+      1. Let _s_ be Decimal128ToDecimalString(_O_, _shouldCanonicalize_).
       1. If _s_ is *"NaN"*, *"Infinity"*, or *"-Infinity"*, return _s_.
       1. Let _integerDigits_ be *""*.
       1. Let _nonIntegerDigits_ be *""*.
@@ -709,21 +850,19 @@ location: https://github.com/tc39/proposal-decimal/
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.toprecision">
-    <h1>Decimal128.prototype.toPrecision ( _precision_ [ , _shouldCanonicalize_ ] )</h1>
+    <h1>Decimal128.prototype.toPrecision ( [ _options_ ] )</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 _precision_ argument is omitted or is *undefined*, this method is equivalent to <emu-xref href="#sec-decimal.prototype.tostring">toString</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>
       1. Let _O_ be the *this* value.
       1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
-      1. If _shouldCanonicalize_ is *undefined*, set _shouldCanonicalize_ to *true*.
-      1. If _shouldCanonicalize_ is not a Boolean value, throw a *TypeError* exception.
+      1. Let _shouldCanonicalize_ be *true*.
+      1. If _shouldCanonicalize_ is neither *undefined* nor a Boolean value, throw a *TypeError* exception.
       1. If _precision_ is neither *undefined* nor a Number, throw a *TypeError* exception.
-      1. If _precision_ is *undefined_, then
-        1. If _shouldCanonicalize_ is *true*, return Decimal128ToDecimalString(CanonicalizeDecimal128(_O_)).
-        1. Otherwise, return Decimal128ToDecimalString(CanonicalizeDecimal128(_O_)).
+      1. If _precision_ is *undefined*, return return Decimal128ToDecimalString(_O_, _shouldCanonicalize_).
       1. If _precision_ is not an integer, throw a *RangeError* exception.
       1. If _precision_ < 1, throw a *RangeError* exception.
-      1. If _shouldCanonicalize_ is *true*, let _d_ be CanonicalizeDecimal128(_O_).[[Decimal128Data]], otherwise let _d_ be _O_.[[Decimal128Data]].
+      1. Let _d_ be _O_.[[Decimal128Data]].
       1. If _d_ is *NaN*<sub>𝔻</sub>, return *"NaN"*.
       1. If _d_ is *+∞*<sub>𝔻</sub>, return *"Infinity"*.
       1. If _d_ is *-∞*<sub>𝔻</sub>, return *"-Infinity"*.
@@ -732,7 +871,7 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _v_ is *+0*<sub>𝔻</sub>, return *"0"*.
       1. If _v_ is *-0*<sub>𝔻</sub>, return *"-0"*.
       1. If -_q_ < _precision_, then
-        1. Let _s_ be Decimal128ToDecimalString(_O_).
+        1. Let _s_ be Decimal128ToDecimalString(_O_, _shouldCanonicalize_).
         1. Let _integerDigits_ be the substring of _s_ up to the first occurrence of *"."* in _s_.
         1. Let _nonIntegerDigits_ be the substring of _s_ after the first occurrence of *"."* in _s_.
         1. Let _numTrailingZeroesToAdd_ be _precision_ minus the length of _nonIntegerDigits_.
@@ -742,7 +881,7 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _n1_ be the largest multiple of 10 such that _n_ - _n1_ is less than 10<sup>_precision_</sup>.
       1. Let _v1_ be _v_ - (_n1_ / 10<sup>_precision_</sup>).
       1. Let _N_ be ? EnsureDecimal128Value(_v1_, _precision_, *"halfEven"*).
-      1. Return Decimal128ToDecimalString(_N_).
+      1. Return Decimal128ToDecimalString(_N_, _shouldCanonicalize_).
     </emu-alg>
     <emu-note>
       <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
@@ -764,6 +903,7 @@ location: https://github.com/tc39/proposal-decimal/
   <h1>Numbers and Dates</h1>
   <emu-clause id="sec-number-objects">
     <h1>Number Objects</h1>
+
     <emu-clause id="sec-number-constructor">
       <h1>The Number Constructor</h1>
       <emu-clause id="sec-number-constructor-number-value">
@@ -771,21 +911,24 @@ location: https://github.com/tc39/proposal-decimal/
         <p>This function performs the following steps when called:</p>
         <emu-alg>
           1. If _value_ is present, then
-            1. Let _serialized_ be the result of ! Call([_value_].[[toString]], _value_).
-            1. If _value_ is a Decimal128 object, return ! ToNumber(_serialized_).
+            1. <ins>If _value_ is an object that has an [[Decimal128Data]] internal slot, then</ins>
+              1. <ins>Let _d_ be _value_.[[Decimal128Data]].</ins>
+              1. <ins>Let _serialized_ be Decimal128ToExponentialString(_d_, *false*).</ins>
+              1. <ins>Return ! ToNumber(_serialized_).</ins>
             1. Let _prim_ be ? ToNumeric(_value_).
             1. If _prim_ is a BigInt, let _n_ be 𝔽(ℝ(_prim_)).
             1. Otherwise, let _n_ be _prim_.
           1. Else,
             1. Let _n_ be *+0*<sub>𝔽</sub>.
           1. If NewTarget is *undefined*, return _n_.
-          1. Let _O_ be ? OrdinaryCreateFromConstructor(%Decimal128%, *"%Number.prototype%"*, « [[NumberData]] »).
+          1. Let _O_ be ? OrdinaryCreateFromConstructor(NewTarget, *"%Number.prototype%"*, « [[NumberData]] »).
           1. Set _O_.[[NumberData]] to _n_.
           1. Return _O_.
         </emu-alg>
       </emu-clause>
     </emu-clause>
   </emu-clause>
+
   <emu-clause id="sec-bigint-objects">
     <h1>BigInt Objects</h1>
     <emu-clause id="sec-bigint-constructor">