diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml
index 6659d2b3..5b15464e 100644
--- a/.github/workflows/lint.yaml
+++ b/.github/workflows/lint.yaml
@@ -16,7 +16,7 @@ jobs:
       - name: ensure no line starts with tabs
       - run: |
           for f in *emu; do
-            if ! [ grep '^\t' "$f"]; then
+            if ! [ grep '^\t' "$f" ]; then
               echo "$f has lines that begin with a tab";
               exit 1;
             fi
diff --git a/Makefile b/Makefile
index aeefcafd..830c03a3 100644
--- a/Makefile
+++ b/Makefile
@@ -2,8 +2,8 @@
 
 all: index.html
 
-index.html:
-	npx ecmarkup --lint-spec --strict --load-biblio @tc39/ecma262-biblio --load-biblio @tc39/ecma402-biblio spec.emu $<
+index.html: spec.emu intl.emu
+	npx ecmarkup --lint-spec --strict --load-biblio @tc39/ecma262-biblio --load-biblio @tc39/ecma402-biblio spec.emu $@
 
 clean:
 	rm -f index.html
diff --git a/index.html b/index.html
index aaea927d..0585d8d8 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_96"],"sec-decimal-method-round":["_ref_2","_ref_97"],"sec-decimal.prototype.tostring":["_ref_3","_ref_4","_ref_98","_ref_99"],"sec-tointlmathematicalvalue":["_ref_5","_ref_104","_ref_105","_ref_106","_ref_107","_ref_108","_ref_109","_ref_110"],"sec-tostring":["_ref_6","_ref_7"],"sec-decimal-intro":["_ref_8","_ref_9","_ref_10","_ref_11","_ref_12","_ref_13","_ref_14","_ref_15","_ref_16","_ref_17","_ref_18","_ref_19","_ref_20","_ref_21","_ref_22","_ref_23","_ref_24","_ref_25","_ref_26","_ref_27","_ref_28","_ref_29","_ref_30","_ref_31","_ref_32","_ref_33","_ref_34","_ref_35","_ref_36","_ref_37","_ref_38","_ref_39","_ref_40","_ref_41","_ref_42","_ref_43","_ref_44","_ref_45","_ref_46","_ref_47","_ref_48","_ref_49"],"sec-decimal128-isintegraldecimal128value":["_ref_50"],"sec-the-decimal128-constructor-value":["_ref_51"],"sec-decimal.prototype.isfinite":["_ref_52"],"sec-decimal.prototype.abs":["_ref_53","_ref_54","_ref_55"],"sec-decimal.prototype.neg":["_ref_56","_ref_57","_ref_58"],"sec-decimal.prototype.add":["_ref_59","_ref_60","_ref_61","_ref_62","_ref_63","_ref_64","_ref_65","_ref_66"],"sec-decimal.prototype.subtract":["_ref_67","_ref_68","_ref_69","_ref_70","_ref_71","_ref_72","_ref_73","_ref_74"],"sec-decimal.prototype.multiply":["_ref_75","_ref_76","_ref_77","_ref_78","_ref_79","_ref_80","_ref_81","_ref_82","_ref_83","_ref_84","_ref_85","_ref_86","_ref_87"],"sec-decimal.prototype.divide":["_ref_88","_ref_89","_ref_90","_ref_91"],"sec-decimal.prototype.remainder":["_ref_92","_ref_93","_ref_94","_ref_95"],"sec-decimal.prototype.tobigint":["_ref_100"],"sec-decimal.prototype.tonumber":["_ref_101"],"sec-bigint-constructor-number-value":["_ref_102"],"sec-numbertobigint":["_ref_103"],"sec-formatnumberstring":["_ref_111","_ref_112","_ref_113","_ref_114","_ref_115","_ref_116","_ref_117","_ref_118"],"sec-torawprecision":["_ref_119","_ref_120","_ref_121","_ref_122","_ref_123","_ref_124","_ref_125","_ref_126","_ref_127","_ref_128","_ref_129","_ref_130","_ref_131","_ref_132","_ref_133"],"sec-torawfixed":["_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"],"sec-partitionnumberpattern":["_ref_147","_ref_148","_ref_149","_ref_150","_ref_151"]},"entries":[{"type":"clause","id":"sec-decimal-intro-","titleHTML":"Introduction","number":""},{"type":"op","aoid":"ToString","refId":"sec-tostring"},{"type":"clause","id":"sec-tostring","title":"ToString ( argument )","titleHTML":"ToString ( <var>argument</var> )","number":"1.1.1","referencingIds":["_ref_7"]},{"type":"clause","id":"sec-type-conversion","titleHTML":"Type Conversion","number":"1.1"},{"type":"clause","id":"sec-abstract-operations","titleHTML":"Abstract Operations","number":"1"},{"type":"term","term":"mathematical value","id":"dfn-decimal128-mathematical-value","referencingIds":["_ref_5","_ref_10","_ref_11","_ref_18","_ref_34","_ref_96","_ref_108","_ref_109","_ref_110","_ref_111","_ref_112","_ref_114","_ref_120","_ref_123","_ref_124","_ref_125","_ref_130","_ref_132","_ref_135","_ref_138","_ref_139","_ref_143","_ref_145","_ref_150"]},{"type":"term","term":"finite","id":"dfn-decimal128-finite","referencingIds":["_ref_12","_ref_15","_ref_16","_ref_19","_ref_20","_ref_32","_ref_35","_ref_37","_ref_39","_ref_41","_ref_43","_ref_46","_ref_49","_ref_50","_ref_52","_ref_105","_ref_121","_ref_136"]},{"type":"term","term":"zero","id":"dfn-decimal128-zero","referencingIds":["_ref_8","_ref_9","_ref_13","_ref_14","_ref_17","_ref_21","_ref_25","_ref_26","_ref_33","_ref_36","_ref_38","_ref_40","_ref_42","_ref_44","_ref_45","_ref_47","_ref_48","_ref_78","_ref_83","_ref_107","_ref_129"]},{"type":"term","term":"negative","refId":"sec-decimal-intro"},{"type":"term","term":"rounding mode","id":"dfn-decimal128-rounding-mode","referencingIds":["_ref_2","_ref_4","_ref_22","_ref_23","_ref_27"]},{"type":"term","term":"default rounding mode","id":"dfn-decimal128-default-rounding-mode","referencingIds":["_ref_3"]},{"type":"table","id":"table-decimal128-rounding-modes","number":1,"caption":"Table 1: Rounding modes in Decimal128 compared to IEEE 754 rounding modes"},{"type":"term","term":"cohort","id":"dfn-decimal128-cohort","referencingIds":["_ref_28","_ref_29","_ref_30","_ref_31"]},{"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_24","_ref_106","_ref_119","_ref_122","_ref_127","_ref_128","_ref_134","_ref_137","_ref_141","_ref_142","_ref_148","_ref_149"]},{"type":"op","aoid":"ToDecimal128","refId":"sec-decimal128-todecimal128"},{"type":"clause","id":"sec-decimal128-todecimal128","title":"ToDecimal128 ( argument )","titleHTML":"ToDecimal128 ( <var>argument</var> )","number":"2.1.1","referencingIds":["_ref_51"]},{"type":"op","aoid":"Decimal128ToDecimalString","refId":"sec-decimal128-decimal128todecimalstring"},{"type":"clause","id":"sec-decimal128-decimal128todecimalstring","title":"Decimal128ToDecimalString ( argument )","titleHTML":"Decimal128ToDecimalString ( <var>argument</var> )","number":"2.1.2","referencingIds":["_ref_6","_ref_98","_ref_101","_ref_126","_ref_140"]},{"type":"op","aoid":"Decimal128ToExponentialString","refId":"sec-decimal128toexponentialstring"},{"type":"clause","id":"sec-decimal128toexponentialstring","title":"Decimal128ToExponentialString ( argument )","titleHTML":"Decimal128ToExponentialString ( <var>argument</var> )","number":"2.1.3","referencingIds":["_ref_99"]},{"type":"op","aoid":"IsIntegralDecimal128","refId":"sec-decimal128-isintegraldecimal128value"},{"type":"clause","id":"sec-decimal128-isintegraldecimal128value","title":"IsIntegralDecimal128 ( argument )","titleHTML":"IsIntegralDecimal128 ( <var>argument</var> )","number":"2.1.4","referencingIds":["_ref_100","_ref_103"]},{"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":"2.1.5","referencingIds":["_ref_53","_ref_54","_ref_55","_ref_56","_ref_57","_ref_58","_ref_59","_ref_60","_ref_61","_ref_62","_ref_63","_ref_64","_ref_65","_ref_66","_ref_67","_ref_68","_ref_69","_ref_70","_ref_71","_ref_72","_ref_73","_ref_74","_ref_75","_ref_76","_ref_77","_ref_79","_ref_80","_ref_81","_ref_82","_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_97"]},{"type":"clause","id":"sec-decimal-abstract-ops","titleHTML":"Abstract Operations","number":"2.1"},{"type":"term","term":"%Decimal128","refId":"sec-the-decimal-constructor"},{"type":"clause","id":"sec-the-decimal128-constructor-value","title":"Decimal128 ( x [ , options ] )","titleHTML":"Decimal128 ( <var>x</var> [ , <var>options</var> ] )","number":"2.2.1"},{"type":"clause","id":"sec-the-decimal-constructor","titleHTML":"The Decimal128 Constructor","number":"2.2"},{"type":"clause","id":"sec-the-decimal-object","titleHTML":"The Decimal128 Object","number":"2"},{"type":"clause","id":"sec-decimal.prototype.isnan","titleHTML":"get Decimal128.prototype.isNaN","number":"3.1"},{"type":"clause","id":"sec-decimal.prototype.isfinite","titleHTML":"get Decimal128.prototype.isFinite","number":"3.2"},{"type":"clause","id":"sec-decimal.prototype.abs","titleHTML":"Decimal128.prototype.abs ( )","number":"3.3"},{"type":"clause","id":"sec-decimal.prototype.neg","titleHTML":"Decimal128.prototype.neg ( )","number":"3.4"},{"type":"clause","id":"sec-decimal.prototype.add","title":"Decimal128.prototype.add ( x )","titleHTML":"Decimal128.prototype.add ( <var>x</var> )","number":"3.5"},{"type":"clause","id":"sec-decimal.prototype.subtract","title":"Decimal128.prototype.subtract ( x )","titleHTML":"Decimal128.prototype.subtract ( <var>x</var> )","number":"3.6"},{"type":"clause","id":"sec-decimal.prototype.multiply","title":"Decimal128.prototype.multiply ( x )","titleHTML":"Decimal128.prototype.multiply ( <var>x</var> )","number":"3.7"},{"type":"clause","id":"sec-decimal.prototype.divide","title":"Decimal128.prototype.divide ( x )","titleHTML":"Decimal128.prototype.divide ( <var>x</var> )","number":"3.8"},{"type":"clause","id":"sec-decimal.prototype.remainder","title":"Decimal128.prototype.remainder ( x )","titleHTML":"Decimal128.prototype.remainder ( <var>x</var> )","number":"3.9"},{"type":"clause","id":"sec-decimal.prototype.equals","title":"Decimal128.prototype.equals ( x )","titleHTML":"Decimal128.prototype.equals ( <var>x</var> )","number":"3.10","referencingIds":["_ref_1"]},{"type":"clause","id":"sec-decimal.prototype.lessthan","title":"Decimal128.prototype.lessThan ( x )","titleHTML":"Decimal128.prototype.lessThan ( <var>x</var> )","number":"3.11","referencingIds":["_ref_0"]},{"type":"clause","id":"sec-decimal.prototype.compare","title":"Decimal128.prototype.compare ( x )","titleHTML":"Decimal128.prototype.compare ( <var>x</var> )","number":"3.12"},{"type":"clause","id":"sec-decimal-method-round","title":"Decimal128.prototype.round ( numFractionalDigits [ , mode ] )","titleHTML":"Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>mode</var> ] )","number":"3.13"},{"type":"clause","id":"sec-decimal.prototype.tostring","title":"Decimal128.prototype.toString ( [ options ] )","titleHTML":"Decimal128.prototype.toString ( [ <var>options</var> ] )","number":"3.14"},{"type":"clause","id":"sec-decimal.prototype.tobigint","titleHTML":"Decimal128.prototype.toBigInt ( )","number":"3.15"},{"type":"clause","id":"sec-decimal.prototype.tonumber","titleHTML":"Decimal128.prototype.toNumber ( )","number":"3.16"},{"type":"clause","id":"sec-decimal.prototype.valueof","title":"Decimal128.prototype.valueOf ( x )","titleHTML":"Decimal128.prototype.valueOf ( <var>x</var> )","number":"3.17"},{"type":"clause","id":"sec-decimal-prototype-properties","titleHTML":"Properties of the Decimal128 Prototype","number":"3"},{"type":"clause","id":"sec-number-constructor-number-value","title":"Number ( value )","titleHTML":"Number ( <var>value</var> )","number":"4.1.1.1"},{"type":"clause","id":"sec-number-constructor","titleHTML":"The Number Constructor","number":"4.1.1"},{"type":"clause","id":"sec-number-objects","titleHTML":"Number Objects","number":"4.1"},{"type":"op","aoid":"Decimal128ToBigInt","refId":"sec-numbertobigint"},{"type":"clause","id":"sec-numbertobigint","title":"Decimal128ToBigInt ( number )","titleHTML":"<ins>Decimal128ToBigInt ( <var>number</var> )</ins>","number":"4.2.1.1.1","referencingIds":["_ref_102"]},{"type":"clause","id":"sec-bigint-constructor-number-value","title":"BigInt ( value )","titleHTML":"BigInt ( <var>value</var> )","number":"4.2.1.1"},{"type":"clause","id":"sec-bigint-constructor","titleHTML":"The BigInt Constructor","number":"4.2.1"},{"type":"clause","id":"sec-bigint-objects","titleHTML":"BigInt Objects","number":"4.2"},{"type":"clause","id":"sec-numbers-and-dates","titleHTML":"Numbers and Dates","number":"4"},{"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_104","_ref_113","_ref_147"]},{"type":"op","aoid":"ToIntlMathematicalValue","refId":"sec-tointlmathematicalvalue"},{"type":"clause","id":"sec-tointlmathematicalvalue","title":"ToIntlMathematicalValue ( value )","titleHTML":"ToIntlMathematicalValue ( <var>value</var> )","number":"5.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":"5.1.2","referencingIds":["_ref_151"]},{"type":"op","aoid":"ToRawPrecisionFn","id":"eqn-ToRawPrecisionFn","referencingIds":["_ref_131","_ref_133"]},{"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":"5.1.3","referencingIds":["_ref_115","_ref_117"]},{"type":"op","aoid":"ToRawFixedFn","id":"eqn-ToRawFixedFn","referencingIds":["_ref_144","_ref_146"]},{"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":"5.1.4","referencingIds":["_ref_116","_ref_118"]},{"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":"5.1.5"},{"type":"clause","id":"sec-numberformat-abstracts","titleHTML":"Abstract Operations for NumberFormat Objects","number":"5.1"},{"type":"clause","id":"numberformat-objects","titleHTML":"NumberFormat Objects","number":"5"},{"type":"clause","id":"sec-copyright-and-software-license","title":"Copyright & Software License","titleHTML":"Copyright &amp; Software License","number":"A"}]}`);
+let biblio = JSON.parse(`{"refsByClause":{"sec-decimal.prototype.compare":["_ref_0","_ref_1","_ref_109"],"sec-decimal-method-round":["_ref_2","_ref_110","_ref_111","_ref_112","_ref_113"],"sec-tointlmathematicalvalue":["_ref_3","_ref_126","_ref_127","_ref_128","_ref_129","_ref_130","_ref_131","_ref_132"],"sec-tostring":["_ref_4","_ref_5"],"sec-decimal-intro":["_ref_6","_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"],"sec-decimal128-isintegraldecimal128value":["_ref_48"],"sec-decimal128-value-to-object":["_ref_49"],"sec-decimal128-d":["_ref_50","_ref_51","_ref_52","_ref_53","_ref_54"],"sec-the-decimal128-constructor-value":["_ref_55","_ref_56","_ref_57","_ref_58","_ref_59"],"sec-decimal.prototype.isfinite":["_ref_60"],"sec-decimal.prototype.abs":["_ref_61","_ref_62","_ref_63"],"sec-decimal.prototype.neg":["_ref_64","_ref_65","_ref_66"],"sec-decimal.prototype.add":["_ref_67","_ref_68","_ref_69","_ref_70","_ref_71","_ref_72","_ref_73","_ref_74","_ref_75"],"sec-decimal.prototype.subtract":["_ref_76","_ref_77","_ref_78","_ref_79","_ref_80","_ref_81","_ref_82","_ref_83","_ref_84"],"sec-decimal.prototype.multiply":["_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","_ref_98"],"sec-decimal.prototype.divide":["_ref_99","_ref_100","_ref_101","_ref_102","_ref_103"],"sec-decimal.prototype.remainder":["_ref_104","_ref_105","_ref_106","_ref_107","_ref_108"],"sec-decimal.prototype.tostring":["_ref_114"],"sec-decimal.prototype.toexponential":["_ref_115"],"sec-decimal.prototype.tofixed":["_ref_116"],"sec-decimal.prototype.toprecision":["_ref_117","_ref_118","_ref_119","_ref_120"],"sec-decimal.prototype.tobigint":["_ref_121"],"sec-decimal.prototype.tonumber":["_ref_122"],"sec-number-constructor-number-value":["_ref_123"],"sec-bigint-constructor-number-value":["_ref_124"],"sec-numbertobigint":["_ref_125"],"sec-formatnumberstring":["_ref_133","_ref_134","_ref_135","_ref_136","_ref_137","_ref_138","_ref_139","_ref_140"],"sec-torawprecision":["_ref_141","_ref_142","_ref_143","_ref_144","_ref_145","_ref_146","_ref_147","_ref_148","_ref_149","_ref_150","_ref_151","_ref_152","_ref_153","_ref_154","_ref_155"],"sec-torawfixed":["_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"],"sec-partitionnumberpattern":["_ref_169","_ref_170","_ref_171","_ref_172","_ref_173"]},"entries":[{"type":"clause","id":"sec-decimal-intro-","titleHTML":"Introduction","number":""},{"type":"op","aoid":"ToString","refId":"sec-tostring"},{"type":"clause","id":"sec-tostring","title":"ToString ( argument )","titleHTML":"ToString ( <var>argument</var> )","number":"1.1.1","referencingIds":["_ref_5"]},{"type":"clause","id":"sec-type-conversion","titleHTML":"Type Conversion","number":"1.1"},{"type":"clause","id":"sec-abstract-operations","titleHTML":"Abstract Operations","number":"1"},{"type":"term","term":"mathematical value","id":"dfn-decimal128-mathematical-value","referencingIds":["_ref_3","_ref_8","_ref_9","_ref_16","_ref_32","_ref_50","_ref_51","_ref_55","_ref_56","_ref_58","_ref_109","_ref_130","_ref_131","_ref_132","_ref_133","_ref_134","_ref_136","_ref_142","_ref_145","_ref_146","_ref_147","_ref_152","_ref_154","_ref_157","_ref_160","_ref_161","_ref_165","_ref_167","_ref_172"]},{"type":"term","term":"finite","id":"dfn-decimal128-finite","referencingIds":["_ref_10","_ref_13","_ref_14","_ref_17","_ref_18","_ref_30","_ref_33","_ref_35","_ref_37","_ref_39","_ref_41","_ref_44","_ref_47","_ref_48","_ref_60","_ref_127","_ref_143","_ref_158"]},{"type":"term","term":"zero","id":"dfn-decimal128-zero","referencingIds":["_ref_6","_ref_7","_ref_11","_ref_12","_ref_15","_ref_19","_ref_23","_ref_24","_ref_31","_ref_34","_ref_36","_ref_38","_ref_40","_ref_42","_ref_43","_ref_45","_ref_46","_ref_88","_ref_93","_ref_129","_ref_151"]},{"type":"term","term":"negative","refId":"sec-decimal-intro"},{"type":"term","term":"rounding mode","id":"dfn-decimal128-rounding-mode","referencingIds":["_ref_20","_ref_21","_ref_25","_ref_52","_ref_110","_ref_113"]},{"type":"term","term":"default rounding mode","id":"dfn-decimal128-default-rounding-mode","referencingIds":["_ref_2"]},{"type":"table","id":"table-decimal128-rounding-modes","number":1,"caption":"Table 1: Rounding modes in Decimal128 compared to IEEE 754 rounding modes"},{"type":"term","term":"cohort","id":"dfn-decimal128-cohort","referencingIds":["_ref_26","_ref_27","_ref_28","_ref_29"]},{"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_22","_ref_128","_ref_141","_ref_144","_ref_149","_ref_150","_ref_156","_ref_159","_ref_163","_ref_164","_ref_170","_ref_171"]},{"type":"op","aoid":"Decimal128ToDecimalString","refId":"sec-decimal128-decimal128todecimalstring"},{"type":"clause","id":"sec-decimal128-decimal128todecimalstring","title":"Decimal128ToDecimalString ( argument )","titleHTML":"Decimal128ToDecimalString ( <var>argument</var> )","number":"2.1.1","referencingIds":["_ref_4","_ref_114","_ref_116","_ref_117","_ref_118","_ref_120","_ref_122","_ref_148","_ref_162"]},{"type":"op","aoid":"Decimal128ToExponentialString","refId":"sec-decimal128toexponentialstring"},{"type":"clause","id":"sec-decimal128toexponentialstring","title":"Decimal128ToExponentialString ( argument )","titleHTML":"Decimal128ToExponentialString ( <var>argument</var> )","number":"2.1.2","referencingIds":["_ref_115"]},{"type":"op","aoid":"IsIntegralDecimal128","refId":"sec-decimal128-isintegraldecimal128value"},{"type":"clause","id":"sec-decimal128-isintegraldecimal128value","title":"IsIntegralDecimal128 ( argument )","titleHTML":"IsIntegralDecimal128 ( <var>argument</var> )","number":"2.1.3","referencingIds":["_ref_121","_ref_125"]},{"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":"2.1.4","referencingIds":["_ref_61","_ref_62","_ref_63","_ref_64","_ref_65","_ref_66","_ref_67","_ref_68","_ref_69","_ref_70","_ref_71","_ref_72","_ref_73","_ref_74","_ref_76","_ref_77","_ref_78","_ref_79","_ref_80","_ref_81","_ref_82","_ref_83","_ref_85","_ref_86","_ref_87","_ref_89","_ref_90","_ref_91","_ref_92","_ref_94","_ref_95","_ref_96","_ref_97","_ref_99","_ref_100","_ref_101","_ref_102","_ref_104","_ref_105","_ref_106","_ref_107","_ref_111"]},{"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":"2.1.5","referencingIds":["_ref_53","_ref_54","_ref_57","_ref_59","_ref_75","_ref_84","_ref_98","_ref_103","_ref_108","_ref_112","_ref_119"]},{"type":"clause","id":"sec-decimal-abstract-ops","titleHTML":"Abstract Operations","number":"2.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":"2.2.1"},{"type":"clause","id":"sec-the-decimal-constructor","titleHTML":"The Decimal128 Constructor","number":"2.2","referencingIds":["_ref_49","_ref_123"]},{"type":"clause","id":"sec-the-decimal-object","titleHTML":"The Decimal128 Object","number":"2"},{"type":"clause","id":"sec-decimal.prototype.isnan","titleHTML":"get Decimal128.prototype.isNaN","number":"3.1"},{"type":"clause","id":"sec-decimal.prototype.isfinite","titleHTML":"get Decimal128.prototype.isFinite","number":"3.2"},{"type":"clause","id":"sec-decimal.prototype.abs","titleHTML":"Decimal128.prototype.abs ( )","number":"3.3"},{"type":"clause","id":"sec-decimal.prototype.neg","titleHTML":"Decimal128.prototype.neg ( )","number":"3.4"},{"type":"clause","id":"sec-decimal.prototype.add","title":"Decimal128.prototype.add ( x )","titleHTML":"Decimal128.prototype.add ( <var>x</var> )","number":"3.5"},{"type":"clause","id":"sec-decimal.prototype.subtract","title":"Decimal128.prototype.subtract ( x )","titleHTML":"Decimal128.prototype.subtract ( <var>x</var> )","number":"3.6"},{"type":"clause","id":"sec-decimal.prototype.multiply","title":"Decimal128.prototype.multiply ( x )","titleHTML":"Decimal128.prototype.multiply ( <var>x</var> )","number":"3.7"},{"type":"clause","id":"sec-decimal.prototype.divide","title":"Decimal128.prototype.divide ( x )","titleHTML":"Decimal128.prototype.divide ( <var>x</var> )","number":"3.8"},{"type":"clause","id":"sec-decimal.prototype.remainder","title":"Decimal128.prototype.remainder ( x )","titleHTML":"Decimal128.prototype.remainder ( <var>x</var> )","number":"3.9"},{"type":"clause","id":"sec-decimal.prototype.equals","title":"Decimal128.prototype.equals ( x )","titleHTML":"Decimal128.prototype.equals ( <var>x</var> )","number":"3.10","referencingIds":["_ref_1"]},{"type":"clause","id":"sec-decimal.prototype.lessthan","title":"Decimal128.prototype.lessThan ( x )","titleHTML":"Decimal128.prototype.lessThan ( <var>x</var> )","number":"3.11","referencingIds":["_ref_0"]},{"type":"clause","id":"sec-decimal.prototype.compare","title":"Decimal128.prototype.compare ( x )","titleHTML":"Decimal128.prototype.compare ( <var>x</var> )","number":"3.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":"3.13"},{"type":"clause","id":"sec-decimal.prototype.tostring","titleHTML":"Decimal128.prototype.toString ( )","number":"3.14"},{"type":"clause","id":"sec-decimal.prototype.toexponential","titleHTML":"Decimal128.prototype.toExponential ( )","number":"3.15"},{"type":"clause","id":"sec-decimal.prototype.tofixed","title":"Decimal128.prototype.toFixed ( [ numDigits ] )","titleHTML":"Decimal128.prototype.toFixed ( [ <var>numDigits</var> ] )","number":"3.16"},{"type":"clause","id":"sec-decimal.prototype.toprecision","title":"Decimal128.prototype.toPrecision ( [ precision ] )","titleHTML":"Decimal128.prototype.toPrecision ( [ <var>precision</var> ] )","number":"3.17"},{"type":"clause","id":"sec-decimal.prototype.tobigint","titleHTML":"Decimal128.prototype.toBigInt ( )","number":"3.18"},{"type":"clause","id":"sec-decimal.prototype.tonumber","titleHTML":"Decimal128.prototype.toNumber ( )","number":"3.19"},{"type":"clause","id":"sec-decimal.prototype.valueof","title":"Decimal128.prototype.valueOf ( x )","titleHTML":"Decimal128.prototype.valueOf ( <var>x</var> )","number":"3.20"},{"type":"clause","id":"sec-decimal-prototype-properties","titleHTML":"Properties of the Decimal128 Prototype","number":"3"},{"type":"clause","id":"sec-number-constructor-number-value","title":"Number ( value )","titleHTML":"Number ( <var>value</var> )","number":"4.1.1.1"},{"type":"clause","id":"sec-number-constructor","titleHTML":"The Number Constructor","number":"4.1.1"},{"type":"clause","id":"sec-number-objects","titleHTML":"Number Objects","number":"4.1"},{"type":"op","aoid":"Decimal128ToBigInt","refId":"sec-numbertobigint"},{"type":"clause","id":"sec-numbertobigint","title":"Decimal128ToBigInt ( number )","titleHTML":"<ins>Decimal128ToBigInt ( <var>number</var> )</ins>","number":"4.2.1.1.1","referencingIds":["_ref_124"]},{"type":"clause","id":"sec-bigint-constructor-number-value","title":"BigInt ( value )","titleHTML":"BigInt ( <var>value</var> )","number":"4.2.1.1"},{"type":"clause","id":"sec-bigint-constructor","titleHTML":"The BigInt Constructor","number":"4.2.1"},{"type":"clause","id":"sec-bigint-objects","titleHTML":"BigInt Objects","number":"4.2"},{"type":"clause","id":"sec-numbers-and-dates","titleHTML":"Numbers and Dates","number":"4"},{"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_126","_ref_135","_ref_169"]},{"type":"op","aoid":"ToIntlMathematicalValue","refId":"sec-tointlmathematicalvalue"},{"type":"clause","id":"sec-tointlmathematicalvalue","title":"ToIntlMathematicalValue ( value )","titleHTML":"ToIntlMathematicalValue ( <var>value</var> )","number":"5.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":"5.1.2","referencingIds":["_ref_173"]},{"type":"op","aoid":"ToRawPrecisionFn","id":"eqn-ToRawPrecisionFn","referencingIds":["_ref_153","_ref_155"]},{"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":"5.1.3","referencingIds":["_ref_137","_ref_139"]},{"type":"op","aoid":"ToRawFixedFn","id":"eqn-ToRawFixedFn","referencingIds":["_ref_166","_ref_168"]},{"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":"5.1.4","referencingIds":["_ref_138","_ref_140"]},{"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":"5.1.5"},{"type":"clause","id":"sec-numberformat-abstracts","titleHTML":"Abstract Operations for NumberFormat Objects","number":"5.1"},{"type":"clause","id":"numberformat-objects","titleHTML":"NumberFormat Objects","number":"5"},{"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-abstract-operations" title="Abstract Operations"><span class="secnum">1</span> Abstract Operations</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-type-conversion" title="Type Conversion"><span class="secnum">1.1</span> Type Conversion</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-tostring" title="ToString ( argument )"><span class="secnum">1.1.1</span> ToString ( <var>argument</var> )</a></li></ol></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-the-decimal-object" title="The Decimal128 Object"><span class="secnum">2</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">2.1</span> Abstract Operations</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal128-todecimal128" title="ToDecimal128 ( argument )"><span class="secnum">2.1.1</span> ToDecimal128 ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128-decimal128todecimalstring" title="Decimal128ToDecimalString ( argument )"><span class="secnum">2.1.2</span> Decimal128ToDecimalString ( <var>argument</var> )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal128toexponentialstring" title="Decimal128ToExponentialString ( argument )"><span class="secnum">2.1.3</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">2.1.4</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">2.1.5</span> Decimal128ValueToObject ( <var>argument</var> )</a></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-the-decimal-constructor" title="The Decimal128 Constructor"><span class="secnum">2.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 [ , options ] )"><span class="secnum">2.2.1</span> Decimal128 ( <var>x</var> [ , <var>options</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">3</span> Properties of the Decimal128 Prototype</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.isnan" title="get Decimal128.prototype.isNaN"><span class="secnum">3.1</span> get Decimal128.prototype.isNaN</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.isfinite" title="get Decimal128.prototype.isFinite"><span class="secnum">3.2</span> get 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">3.3</span> Decimal128.prototype.abs ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.neg" title="Decimal128.prototype.neg ( )"><span class="secnum">3.4</span> Decimal128.prototype.neg ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.add" title="Decimal128.prototype.add ( x )"><span class="secnum">3.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">3.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">3.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">3.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">3.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">3.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">3.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">3.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 [ , mode ] )"><span class="secnum">3.13</span> Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>mode</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.tostring" title="Decimal128.prototype.toString ( [ options ] )"><span class="secnum">3.14</span> Decimal128.prototype.toString ( [ <var>options</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.tobigint" title="Decimal128.prototype.toBigInt ( )"><span class="secnum">3.15</span> Decimal128.prototype.toBigInt ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.tonumber" title="Decimal128.prototype.toNumber ( )"><span class="secnum">3.16</span> Decimal128.prototype.toNumber ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.valueof" title="Decimal128.prototype.valueOf ( x )"><span class="secnum">3.17</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">4</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">4.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">4.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">4.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">4.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">4.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">4.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">4.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">5</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">5.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">5.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">5.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">5.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">5.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">5.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 / May 30, 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-abstract-operations" title="Abstract Operations"><span class="secnum">1</span> Abstract Operations</a><ol class="toc"><li><span class="item-toggle">+</span><a href="#sec-type-conversion" title="Type Conversion"><span class="secnum">1.1</span> Type Conversion</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-tostring" title="ToString ( argument )"><span class="secnum">1.1.1</span> ToString ( <var>argument</var> )</a></li></ol></li></ol></li><li><span class="item-toggle">+</span><a href="#sec-the-decimal-object" title="The Decimal128 Object"><span class="secnum">2</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">2.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">2.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">2.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">2.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">2.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">2.1.5</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">2.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">2.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">3</span> Properties of the Decimal128 Prototype</a><ol class="toc"><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.isnan" title="get Decimal128.prototype.isNaN"><span class="secnum">3.1</span> get Decimal128.prototype.isNaN</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.isfinite" title="get Decimal128.prototype.isFinite"><span class="secnum">3.2</span> get 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">3.3</span> Decimal128.prototype.abs ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.neg" title="Decimal128.prototype.neg ( )"><span class="secnum">3.4</span> Decimal128.prototype.neg ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.add" title="Decimal128.prototype.add ( x )"><span class="secnum">3.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">3.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">3.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">3.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">3.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">3.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">3.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">3.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">3.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 ( )"><span class="secnum">3.14</span> Decimal128.prototype.toString ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.toexponential" title="Decimal128.prototype.toExponential ( )"><span class="secnum">3.15</span> Decimal128.prototype.toExponential ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.tofixed" title="Decimal128.prototype.toFixed ( [ numDigits ] )"><span class="secnum">3.16</span> Decimal128.prototype.toFixed ( [ <var>numDigits</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.toprecision" title="Decimal128.prototype.toPrecision ( [ precision ] )"><span class="secnum">3.17</span> Decimal128.prototype.toPrecision ( [ <var>precision</var> ] )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.tobigint" title="Decimal128.prototype.toBigInt ( )"><span class="secnum">3.18</span> Decimal128.prototype.toBigInt ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.tonumber" title="Decimal128.prototype.toNumber ( )"><span class="secnum">3.19</span> Decimal128.prototype.toNumber ( )</a></li><li><span class="item-toggle-none"></span><a href="#sec-decimal.prototype.valueof" title="Decimal128.prototype.valueOf ( x )"><span class="secnum">3.20</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">4</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">4.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">4.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">4.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">4.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">4.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">4.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">4.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">5</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">5.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">5.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">5.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">5.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">5.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">5.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 / May 30, 2024</h1><h1 class="title">Decimal</h1>
 
 <emu-intro id="sec-decimal-intro-">
   <h1>Introduction</h1>
@@ -3251,7 +3251,7 @@ <h1><span class="secnum">1.1</span> Type Conversion</h1>
     <emu-clause id="sec-tostring" type="abstract operation" aoid="ToString">
       <h1><span class="secnum">1.1.1</span> ToString ( <var>argument</var> )</h1>
       <p>The abstract operation ToString takes argument <var>argument</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> a String 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 converts <var>argument</var> to a value of type String. It performs the following steps when called:</p>
-      <emu-alg><ol><li>If <var>argument</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>, return <var>argument</var>.</li><li>If <var>argument</var> <emu-xref href="#sec-ecmascript-language-types-symbol-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-symbol-type">is a Symbol</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>argument</var> is <emu-val>undefined</emu-val>, return <emu-val>"undefined"</emu-val>.</li><li>If <var>argument</var> is <emu-val>null</emu-val>, return <emu-val>"null"</emu-val>.</li><li>If <var>argument</var> is <emu-val>true</emu-val>, return <emu-val>"true"</emu-val>.</li><li>If <var>argument</var> is <emu-val>false</emu-val>, return <emu-val>"false"</emu-val>.</li><li>If <var>argument</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 <emu-xref aoid="Number::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-tostring">Number::toString</a></emu-xref>(<var>argument</var>, 10).</li><li>If <var>argument</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>, return <emu-xref aoid="BigInt::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-bigint-tostring">BigInt::toString</a></emu-xref>(<var>argument</var>, 10).</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>argument</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is an Object</a></emu-xref>.</li><li><ins>If <var>argument</var> has a <var class="field">[[Decimal128Data]]</var> internal slot, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_6"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>argument</var>.<var class="field">[[Decimal128Data]]</var>).</ins></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>argument</var>, <emu-const>string</emu-const>).</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>primValue</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is not an Object</a></emu-xref>.</li><li>Return ?&nbsp;<emu-xref aoid="ToString" id="_ref_7"><a href="#sec-tostring">ToString</a></emu-xref>(<var>primValue</var>).</li></ol></emu-alg>
+      <emu-alg><ol><li>If <var>argument</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>, return <var>argument</var>.</li><li>If <var>argument</var> <emu-xref href="#sec-ecmascript-language-types-symbol-type"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types-symbol-type">is a Symbol</a></emu-xref>, throw a <emu-val>TypeError</emu-val> exception.</li><li>If <var>argument</var> is <emu-val>undefined</emu-val>, return <emu-val>"undefined"</emu-val>.</li><li>If <var>argument</var> is <emu-val>null</emu-val>, return <emu-val>"null"</emu-val>.</li><li>If <var>argument</var> is <emu-val>true</emu-val>, return <emu-val>"true"</emu-val>.</li><li>If <var>argument</var> is <emu-val>false</emu-val>, return <emu-val>"false"</emu-val>.</li><li>If <var>argument</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 <emu-xref aoid="Number::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-number-tostring">Number::toString</a></emu-xref>(<var>argument</var>, 10).</li><li>If <var>argument</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>, return <emu-xref aoid="BigInt::toString"><a href="https://tc39.es/ecma262/#sec-numeric-types-bigint-tostring">BigInt::toString</a></emu-xref>(<var>argument</var>, 10).</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>argument</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is an Object</a></emu-xref>.</li><li><ins>If <var>argument</var> has a <var class="field">[[Decimal128Data]]</var> internal slot, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_4"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>argument</var>.<var class="field">[[Decimal128Data]]</var>).</ins></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>argument</var>, <emu-const>string</emu-const>).</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>primValue</var> <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">is not an Object</a></emu-xref>.</li><li>Return ?&nbsp;<emu-xref aoid="ToString" id="_ref_5"><a href="#sec-tostring">ToString</a></emu-xref>(<var>primValue</var>).</li></ol></emu-alg>
     </emu-clause>
   </emu-clause>
 </emu-clause>
@@ -3271,33 +3271,36 @@ <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_8"><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_9"><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_10"><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_6"><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_7"><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_8"><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_11"><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; <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_9"><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>
-    <p>The <dfn id="dfn-decimal128-mathematical-value" tabindex="-1">mathematical value</dfn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_12"><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>
+    <emu-note><span class="note">Note 1</span><div class="note-contents">
+      <p>A Decimal128 value is not an <emu-xref href="#sec-ecmascript-language-types"><a href="https://tc39.es/ecma262/#sec-ecmascript-language-types">ECMAScript language value</a></emu-xref>.</p>
+    </div></emu-note>
+    <p>The <dfn id="dfn-decimal128-mathematical-value" tabindex="-1">mathematical value</dfn> of a <emu-xref href="#dfn-decimal128-finite" id="_ref_10"><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_13"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> is 0</li>
-      <li>If <var>x</var> is non-<emu-xref href="#dfn-decimal128-zero" id="_ref_14"><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_11"><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_12"><a href="#dfn-decimal128-zero">zero</a></emu-xref>, the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>x</var> is v × 10<sup><var>q</var></sup></li>
     </ul>
-    <p>A Decimal128 value is said to be <dfn id="dfn-decimal128-finite" tabindex="-1">finite</dfn> if it has the form « <var>v</var>, <var>q</var> ». A <dfn id="dfn-decimal128-zero" tabindex="-1">zero</dfn> Decimal128 value is a <emu-xref href="#dfn-decimal128-finite" id="_ref_15"><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_16"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_17"><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_18"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>. A <emu-xref href="#dfn-decimal128-finite" id="_ref_19"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> » is said to be <dfn tabindex="-1">negative</dfn> if either <var>v</var> is -0<sub>D</sub> or <var>v</var> is a real number such that <var>v</var> &lt; 0.</p>
-    <emu-note><span class="note">Note 1</span><div class="note-contents">
-      <p>The <var>v</var> component of a <emu-xref href="#dfn-decimal128-finite" id="_ref_20"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_21"><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>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> ». A <dfn id="dfn-decimal128-zero" tabindex="-1">zero</dfn> Decimal128 value is a <emu-xref href="#dfn-decimal128-finite" id="_ref_13"><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_14"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_15"><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_16"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>. A <emu-xref href="#dfn-decimal128-finite" id="_ref_17"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value « <var>v</var>, <var>q</var> » is said to be <dfn tabindex="-1">negative</dfn> if either <var>v</var> is -0<sub>D</sub> or <var>v</var> is a real number such that <var>v</var> &lt; 0.</p>
+    <emu-note><span class="note">Note 2</span><div class="note-contents">
+      <p>The <var>v</var> component of a <emu-xref href="#dfn-decimal128-finite" id="_ref_18"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_19"><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>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>
     <emu-table id="table-decimal128-rounding-modes"><figure><figcaption>Table 1: Rounding modes in Decimal128 compared to IEEE 754 rounding modes</figcaption>
       
       <table class="real-table">
         <thead>
           <tr>
-            <th>Decimal128 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_22"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref></th>
+            <th>Decimal128 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_20"><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_23"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref></th>
+            <th>IEEE 754 <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_21"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref></th>
           </tr>
         </thead>
         <tbody>
@@ -3308,17 +3311,17 @@ <h1>Introduction</h1>
           </tr>
           <tr>
             <td><emu-val>"floor"</emu-val></td>
-            <td>Toward <emu-xref href="#sec-decimal-intro" id="_ref_24"><a href="#sec-decimal-intro">negative</a></emu-xref> infinity</td>
+            <td>Toward <emu-xref href="#sec-decimal-intro" id="_ref_22"><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_25"><a href="#dfn-decimal128-zero">zero</a></emu-xref></td>
+            <td>Toward <emu-xref href="#dfn-decimal128-zero" id="_ref_23"><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_26"><a href="#dfn-decimal128-zero">zero</a></emu-xref></td>
+            <td>Ties away from <emu-xref href="#dfn-decimal128-zero" id="_ref_24"><a href="#dfn-decimal128-zero">zero</a></emu-xref></td>
             <td><emu-val>"roundTiesToAway"</emu-val></td>
           </tr>
           <tr>
@@ -3328,67 +3331,68 @@ <h1>Introduction</h1>
           </tr>
         </tbody>
       </table>
-      <emu-note><span class="note">Note 2</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_27"><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_25"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref> names. Additional rounding modes are used elsewhere in this specification, such as in <emu-xref href="#table-intl-rounding-modes"><a href="https://tc39.es/ecma402/#table-intl-rounding-modes">Intl.NumberFormat</a></emu-xref>.</div></emu-note>
     </figure></emu-table>
     <p>The <dfn id="dfn-decimal128-cohort" tabindex="-1">cohort</dfn> of a Decimal128 value is defined as follows:</p>
     <ul>
-      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_28"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>) = <emu-val>NaN</emu-val><sub>𝔻</sub></li>
-      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_29"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>) = <emu-val>+∞</emu-val><sub>𝔻</sub></li>
-      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_30"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>) = <emu-val>-∞</emu-val><sub>𝔻</sub></li>
-      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_31"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(« <var>v</var>, <var>q</var> »<sub>𝔻</sub>) = <var>v</var></li>
+      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_26"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>) = <emu-val>NaN</emu-val><sub>𝔻</sub></li>
+      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_27"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>) = <emu-val>+∞</emu-val><sub>𝔻</sub></li>
+      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_28"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>) = <emu-val>-∞</emu-val><sub>𝔻</sub></li>
+      <li><emu-xref href="#dfn-decimal128-cohort" id="_ref_29"><a href="#dfn-decimal128-cohort">cohort</a></emu-xref>(« <var>v</var>, <var>q</var> »<sub>𝔻</sub>) = <var>v</var></li>
     </ul>
-    <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_30"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_31"><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_32"><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>
-    <emu-note><span class="note">Note 3</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>
-    </div></emu-note>
+    <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_33"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, and <emu-xref href="#dfn-decimal128-zero" id="_ref_34"><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 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 significand of a <emu-xref href="#dfn-decimal128-finite" id="_ref_35"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#dfn-decimal128-zero" id="_ref_36"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value is a rational number.</p>
     </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>
+    <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_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 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_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 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_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">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_43"><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_44"><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>t</var> is the truncated exponent of <var>x</var>.</li>
+      <li>The scaled significand of a <emu-xref href="#dfn-decimal128-zero" id="_ref_45"><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_46"><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>t</var> is the truncated exponent of <var>x</var>.</li>
     </ul>
-    <emu-note><span class="note">Note 5</span><div class="note-contents">
-      <p>The scaled significand of a <emu-xref href="#dfn-decimal128-finite" id="_ref_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>
+    <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_47"><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">2.1</span> Abstract Operations</h1>
-    <emu-clause id="sec-decimal128-todecimal128" type="abstract operation" aoid="ToDecimal128">
-      <h1><span class="secnum">2.1.1</span> ToDecimal128 ( <var>argument</var> )</h1>
-      <p>The abstract operation ToDecimal128 takes argument <var>argument</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> a 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 converts a <var>argument</var> to a Decimal128 value. It performs the following steps when called:</p>
-      <emu-alg><ol><li>Let <var>toParse</var> be <emu-val>undefined</emu-val>.</li><li>If <var>argument</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>argument</var>, 10).</li><li>If <var>argument</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>argument</var>, 10).</li><li>If <var>argument</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>argument</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>Return <mark>« 42, 42&nbsp;»</mark>.</li></ol></emu-alg>
-    </emu-clause>
 
     <emu-clause id="sec-decimal128-decimal128todecimalstring" type="abstract operation" aoid="Decimal128ToDecimalString">
-      <h1><span class="secnum">2.1.2</span> Decimal128ToDecimalString ( <var>argument</var> )</h1>
+      <h1><span class="secnum">2.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>Return <mark><emu-val>"42"</emu-val></mark>.</li></ol></emu-alg>
+      <emu-alg><ol><li>If <var>argument</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>argument</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be <var>argument</var>[0].</li><li>Let <var>q</var> be <var>argument</var>[1].</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> for which <var>v</var> × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li><emu-xref href="#assert"><a href="https://tc39.es/ecma262/#assert">Assert</a></emu-xref>: <var>n</var> is not 0.</li><li>Let <var>digits</var> be the unique decimal string representation of <var>n</var> without leading zeroes.</li><li>If <var>q</var> &lt; 0, then<ol><li>Let <var>trailingZeroes</var> be the String <emu-val>"0"</emu-val> repeated <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) -<var>q</var> times.</li><li>Return the concatenation of <var>digits</var> and <var>trailingZeroes</var>.</li></ol></li><li>Let <var>integerPart</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> from 0 to <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(n) - <var>q</var>.</li><li>Let <var>nonIntegerPart</var> be the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>digits</var> from <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(n) - <var>q</var> to the length of <var>digits</var>.</li><li>Return the concatenation of <var>integerPart</var>, <emu-val>"."</emu-val>, and <var>nonIntegerPart</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128toexponentialstring" type="abstract operation" aoid="Decimal128ToExponentialString">
-      <h1><span class="secnum">2.1.3</span> Decimal128ToExponentialString ( <var>argument</var> )</h1>
+      <h1><span class="secnum">2.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>Return <mark><emu-val>"42E42"</emu-val></mark>.</li></ol></emu-alg>
+      <emu-alg><ol><li>If <var>argument</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>"NaN"</emu-val>.</li><li>If <var>argument</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>"Infinity"</emu-val>.</li><li>If <var>argument</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>"-Infinity"</emu-val>.</li><li>Let <var>v</var> be <var>argument</var>[0].</li><li>Let <var>q</var> be <var>argument</var>[1].</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>Let <var>coefficientStr</var> be the unique decimal string representation of <var>v</var> without leading zeroes.</li><li>Let <var>exponentStr</var> be the unique decimal string representation of <var>q</var> without leading zeroes.</li><li>Return the concatenation of <var>coefficientStr</var>, <emu-val>"e"</emu-val>, and <var>exponentStr</var>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-isintegraldecimal128value" type="abstract operation" aoid="IsIntegralDecimal128">
-      <h1><span class="secnum">2.1.4</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_50"><a href="#dfn-decimal128-finite">finite</a></emu-xref> integral Decimal128 value. It performs the following steps when called:</p>
-      <emu-alg><ol><li>Let <var>d</var> be <var>argument</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>If <var>v</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and 0 ≤ <var>q</var>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></emu-alg>
+      <h1><span class="secnum">2.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_48"><a href="#dfn-decimal128-finite">finite</a></emu-xref> integral Decimal128 value. It performs the following steps when called:</p>
+      <emu-alg><ol><li>Let <var>d</var> be <var>argument</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>If <var>v</var> is an <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> and 0 ≤ <var>q</var>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></emu-alg>
     </emu-clause>
 
     <emu-clause id="sec-decimal128-value-to-object" type="abstract operation" aoid="Decimal128ValueToObject">
-      <h1><span class="secnum">2.1.5</span> Decimal128ValueToObject ( <var>argument</var> )</h1>
+      <h1><span class="secnum">2.1.4</span> Decimal128ValueToObject ( <var>argument</var> )</h1>
       <p>The abstract operation Decimal128ValueToObject takes argument <var>argument</var> (a Decimal128 value) and returns a Decimal128 object. It converts a Decimal128 value to a Decimal128 object. It performs the following steps when called:</p>
-      <emu-alg><ol><li>Let <var>O</var> be !&nbsp;<emu-xref aoid="OrdinaryCreateFromConstructor"><a href="https://tc39.es/ecma262/#sec-ordinarycreatefromconstructor">OrdinaryCreateFromConstructor</a></emu-xref>(NewTarget, <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_49"><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">2.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_50"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref>), <var>intendedExponent</var> (a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_51"><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_52"><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;».</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_53"><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_54"><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>
 
@@ -3396,14 +3400,17 @@ <h1><span class="secnum">2.1.5</span> Decimal128ValueToObject ( <var>argument</v
     <h1><span class="secnum">2.2</span> The Decimal128 Constructor</h1>
     <p>The Decimal128 <emu-xref href="#constructor"><a href="https://tc39.es/ecma262/#constructor">constructor</a></emu-xref>:</p>
     <ul>
-      <li>is <dfn tabindex="-1">%Decimal128</dfn>.</li>
+      <li>is <dfn tabindex="-1">%Decimal128%</dfn>.</li>
       <li>is the initial value of the the <emu-val>"Decimal128"</emu-val> property of the <emu-xref href="#sec-global-object"><a href="https://tc39.es/ecma262/#sec-global-object">global object</a></emu-xref>.</li>
       <li>creates and initializes a new Decimal128 object when called as a <emu-xref href="#constructor"><a href="https://tc39.es/ecma262/#constructor">constructor</a></emu-xref></li>
       <li>may be used as the value of an <emu-val>extends</emu-val> clause of a class definition. Subclass <emu-xref href="#constructor"><a href="https://tc39.es/ecma262/#constructor">constructors</a></emu-xref> that intend to inherit the specified Decimal128 behaviour must include a <emu-val>super</emu-val> call to the Decimal128 <emu-xref href="#constructor"><a href="https://tc39.es/ecma262/#constructor">constructor</a></emu-xref> to create and initialize the subclass instance with a <var class="field">[[Decimal128Data]]</var> internal slot.</li>
     </ul>
     <emu-clause id="sec-the-decimal128-constructor-value">
-      <h1><span class="secnum">2.2.1</span> Decimal128 ( <var>x</var> [ , <var>options</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>n</var> be ?&nbsp;<emu-xref aoid="ToDecimal128" id="_ref_51"><a href="#sec-decimal128-todecimal128">ToDecimal128</a></emu-xref>(<var>x</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>"%Decimal128.prototype%"</emu-val>, « <var class="field">[[Decimal128Data]]</var>&nbsp;»).</li><li>Set <var>O</var>.<var class="field">[[Decimal128Data]]</var> to <var>n</var>.</li><li>Return <var>O</var>.</li></ol></emu-alg>
+      <h1><span class="secnum">2.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_55"><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_56"><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_57"><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_58"><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_59"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>m</var>, -<var>q</var>, <emu-val>"halfEven"</emu-val>).</li></ol></li><li>Return <var>O</var>.</li></ol></emu-alg>
+      <emu-note><span class="note">Note</span><div class="note-contents">
+        <p>Given a Number argument, the <emu-xref href="#constructor"><a href="https://tc39.es/ecma262/#constructor">constructor</a></emu-xref> converts it to a String using the <emu-xref href="#sec-number.prototype.tostring"><a href="https://tc39.es/ecma262/#sec-number.prototype.tostring">toString</a></emu-xref> method (with no arguments). In some cases, this may not be desited. In some use cases, given a Number, one may wish to call the Decimal128 <emu-xref href="#constructor"><a href="https://tc39.es/ecma262/#constructor">constructor</a></emu-xref> not with the number but rather with, for instance, the result of calling <emu-xref href="#sec-number.prototype.tofixed"><a href="https://tc39.es/ecma262/#sec-number.prototype.tofixed">toFixed</a></emu-xref> or <emu-xref href="#sec-number.prototype.toprecision"><a href="https://tc39.es/ecma262/#sec-number.prototype.toprecision">toPrecision</a></emu-xref> on the Number, thereby ensuring a certain level of precision that may get lost when using Number’s toString.</p>
+      </div></emu-note>
     </emu-clause>
   </emu-clause>
 </emu-clause>
@@ -3418,51 +3425,69 @@ <h1><span class="secnum">3.1</span> get Decimal128.prototype.isNaN</h1>
 
   <emu-clause id="sec-decimal.prototype.isfinite">
     <h1><span class="secnum">3.2</span> get Decimal128.prototype.isFinite</h1>
-    <p>An <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">accessor property</a></emu-xref> indicating whether <emu-val>this</emu-val> value represents a <emu-xref href="#dfn-decimal128-finite" id="_ref_52"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value. The possible values are <emu-val>true</emu-val> and <emu-val>false</emu-val>.</p>
+    <p>An <emu-xref href="#sec-object-type"><a href="https://tc39.es/ecma262/#sec-object-type">accessor property</a></emu-xref> indicating whether <emu-val>this</emu-val> value represents a <emu-xref href="#dfn-decimal128-finite" id="_ref_60"><a href="#dfn-decimal128-finite">finite</a></emu-xref> Decimal128 value. The possible values are <emu-val>true</emu-val> and <emu-val>false</emu-val>.</p>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.abs">
     <h1><span class="secnum">3.3</span> Decimal128.prototype.abs ( )</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>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_53"><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_54"><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_55"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>Let <var>n</var> be « <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>v</var>), <var>q</var>&nbsp;».</li><li>Let <var>N</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>Set <var>N</var>.<var class="field">[[Decimal128Data]]</var> to <var>n</var>.</li><li>Return <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>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_61"><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_62"><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_63"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>Let <var>n</var> be « <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>v</var>), <var>q</var>&nbsp;».</li><li>Let <var>N</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>Set <var>N</var>.<var class="field">[[Decimal128Data]]</var> to <var>n</var>.</li><li>Return <var>N</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.neg">
     <h1><span class="secnum">3.4</span> Decimal128.prototype.neg ( )</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>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_56"><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_57"><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_58"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>Let <var>n</var> be « -1 × <var>v</var>, <var>q</var>&nbsp;».</li><li>Let <var>N</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>Set <var>N</var>.<var class="field">[[Decimal128Data]]</var> to <var>n</var>.</li><li>Return <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>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_64"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_65"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_66"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>Let <var>n</var> be « -1 × <var>v</var>, <var>q</var>&nbsp;».</li><li>Let <var>N</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>Set <var>N</var>.<var class="field">[[Decimal128Data]]</var> to <var>n</var>.</li><li>Return <var>N</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">3.5</span> Decimal128.prototype.add ( <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>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_59"><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_60"><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_61"><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_62"><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_63"><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_64"><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_65"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Return <mark><emu-xref aoid="Decimal128ValueToObject" id="_ref_66"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>d1</var>[0] + <var>d2</var>[0], <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>d1</var>[1], <var>d2</var>[1])&nbsp;»)</mark>.</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_67"><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_68"><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_69"><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_70"><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_71"><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_72"><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_73"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_74"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_75"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>d1</var>[0] + <var>d2</var>[0], <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>d1</var>[1], <var>d2</var>[1]), <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-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">3.6</span> Decimal128.prototype.subtract ( <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>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_67"><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_68"><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_69"><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_70"><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_71"><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_72"><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_73"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Return <mark><emu-xref aoid="Decimal128ValueToObject" id="_ref_74"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« d1[0] - d2[0], <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(d1[1], d2[1])&nbsp;»)</mark>.</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_76"><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_77"><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_78"><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_79"><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_80"><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_81"><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_82"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_83"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_84"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(d1[0] - d2[0], <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(d1[1], d2[1]), <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-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">3.7</span> Decimal128.prototype.multiply ( <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>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_75"><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_76"><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_77"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_78"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_79"><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_80"><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_81"><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_82"><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_83"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_84"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var>[0] &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_85"><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_86"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Return <mark><emu-xref aoid="Decimal128ValueToObject" id="_ref_87"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>d1</var>[0] × <var>d2</var>[0], <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>d1</var>[1], <var>d2</var>[1])&nbsp;»)</mark>.</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_85"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_86"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>+∞</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_87"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var> is a <emu-xref href="#dfn-decimal128-zero" id="_ref_88"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, 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>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></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_91"><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_92"><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_93"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 value, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_94"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d2</var>[0] &lt; 0, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_95"><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_96"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>-∞</emu-val><sub>𝔻</sub>).</li></ol></li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_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>d1</var>[0] × <var>d2</var>[0], <var>d1</var>[1] + <var>d2</var>[1], <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-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">3.8</span> Decimal128.prototype.divide ( <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>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_88"><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_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> or <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>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <mark><emu-xref aoid="Decimal128ValueToObject" id="_ref_91"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>d1</var>[0] / <var>d2</var>[0], <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>d1</var>[1], <var>d2</var>[1])&nbsp;»)</mark>.</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_99"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <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>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_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-xref aoid="EnsureDecimal128Value" id="_ref_103"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>d1</var>[0] / <var>d2</var>[0], <var>d1</var>[1] + <var>d2</var>[1], <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
+    <emu-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">3.9</span> Decimal128.prototype.remainder ( <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>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_92"><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_93"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>If <var>d1</var> is <emu-val>-∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-xref aoid="Decimal128ValueToObject" id="_ref_94"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>).</li><li>Return <mark><emu-xref aoid="Decimal128ValueToObject" id="_ref_95"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(« <var>d1</var>[0] % <var>d2</var>[0], <emu-xref aoid="min"><a href="https://tc39.es/ecma262/#eqn-min">min</a></emu-xref>(<var>d1</var>[1], <var>d2</var>[1])&nbsp;»)</mark>.</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> or <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>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_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-xref aoid="EnsureDecimal128Value" id="_ref_108"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(<var>d1</var>[0] % <var>d2</var>[0], <var>d1</var>[1] + <var>d2</var>[1], <emu-val>"halfEven"</emu-val>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
-      <p>The remainder operation specified here deviates from the IEEE 754 remainder operation. 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>
+      <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>
 
@@ -3471,55 +3496,99 @@ <h1><span class="secnum">3.10</span> Decimal128.prototype.equals ( <var>x</var>
     <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>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-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>
+    </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.lessthan">
     <h1><span class="secnum">3.11</span> Decimal128.prototype.lessThan ( <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>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>x</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d1</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>d2</var> be <var>x</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d1</var> or <var>d2</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub> or <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>Return <emu-val>true</emu-val>.</li></ol></li><li>If <var>d1</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, then<ol><li>If <var>d2</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <emu-val>false</emu-val>.</li><li>If <var>d2</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>true</emu-val>.</li></ol></li><li>If the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> of <var>d1</var> is less than the <emu-xref href="#mathematical-value-of"><a href="https://tc39.es/ecma262/#mathematical-value-of">mathematical value of</a></emu-xref> <var>d2</var>, return <emu-val>true</emu-val>.</li><li>Return <emu-val>false</emu-val>.</li></ol></emu-alg>
+    <emu-note><span class="note">Note</span><div class="note-contents">
+      <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>
+    </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.compare">
     <h1><span class="secnum">3.12</span> Decimal128.prototype.compare ( <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>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</span><div class="note-contents">
-      <p>This operation compares Decimal128 values 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_96"><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> and <emu-xref href="#sec-decimal.prototype.equals" id="_ref_1"><a href="#sec-decimal.prototype.equals">equals</a></emu-xref>.</p>
+    <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_109"><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">3.13</span> Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>mode</var> ] )</h1>
+    <h1><span class="secnum">3.13</span> Decimal128.prototype.round ( <var>numFractionalDigits</var> [ , <var>roundingMode</var> ] )</h1>
     <p>This method performs the following steps when called:</p>
-    <emu-alg><ol><li><mark>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_97"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(<emu-val>NaN</emu-val><sub>𝔻</sub>)</mark>.</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_2"><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_110"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>If <var>d</var> is <emu-val>NaN</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>d</var> is <emu-val>+∞</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>d</var> is <emu-val>-∞</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>Let <var>v</var> be <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <var>O</var>.</li><li>Let <var>n</var> be the <emu-xref href="#integer"><a href="https://tc39.es/ecma262/#integer">integer</a></emu-xref> such that v × 10<sup>-<var>q</var></sup> = <var>n</var> and 0 &lt; <emu-xref aoid="abs"><a href="https://tc39.es/ecma262/#eqn-abs">abs</a></emu-xref>(<var>n</var>) &lt; 10<sup>34</sup>.</li><li>Return <emu-xref aoid="Decimal128ValueToObject" id="_ref_111"><a href="#sec-decimal128-value-to-object">Decimal128ValueToObject</a></emu-xref>(? <emu-xref aoid="EnsureDecimal128Value" id="_ref_112"><a href="#sec-decimal128-d">EnsureDecimal128Value</a></emu-xref>(v × 10<sup>-<var>numFractionalDigits</var></sup>, <var>q</var> + <var>numFractionalDigits</var>, <var>roundingMode</var>)).</li></ol></emu-alg>
     <emu-note><span class="note">Note</span><div class="note-contents">
-      <p>If <var>mode</var> is neither <emu-val>undefined</emu-val> nor a String, throw a <emu-val>TypeError</emu-val> exception.</p>
-      <p>If <var>mode</var> is not a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_2"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</p>
+      <p>This operation follows the specification of the <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_113"><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">3.14</span> Decimal128.prototype.toString ( [ <var>options</var> ] )</h1>
+    <h1><span class="secnum">3.14</span> Decimal128.prototype.toString ( )</h1>
     <p>This method performs the following steps when called:</p>
-    <emu-alg><ol><li>Let <var>roundingMode</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>"roundingMode"</emu-val>).</li><li>If <var>roundingMode</var> is <emu-val>undefined</emu-val>, set <var>roundingMode</var> to the <emu-xref href="#dfn-decimal128-default-rounding-mode" id="_ref_3"><a href="#dfn-decimal128-default-rounding-mode">default rounding mode</a></emu-xref>.</li><li>If <var>roundingMode</var> is not a <emu-xref href="#dfn-decimal128-rounding-mode" id="_ref_4"><a href="#dfn-decimal128-rounding-mode">rounding mode</a></emu-xref>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Let <var>format</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>"format</emu-val>").</li><li>If <var>format</var> is <emu-val>undefined</emu-val>, set <var>format</var> to <emu-val>"decimal"</emu-val>.</li><li>If <var>format</var> is not in « <emu-val>"decimal"</emu-val>, <emu-val>"exponential"</emu-val>&nbsp;», then throw a <emu-val>RangeError</emu-val> exception.</li><li>If <var>format</var> is <emu-val>"decimal</emu-val>", then<ol><li>Return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_98"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<emu-val>this</emu-val>).</li></ol></li><li>Return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_99"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<emu-val>this</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>Return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_114"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li></ol></emu-alg>
+    <emu-note><span class="note">Note</span><div class="note-contents">
+      <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
+    </div></emu-note>
+  </emu-clause>
+
+  <emu-clause id="sec-decimal.prototype.toexponential">
+    <h1><span class="secnum">3.15</span> Decimal128.prototype.toExponential ( )</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>Return <emu-xref aoid="Decimal128ToExponentialString" id="_ref_115"><a href="#sec-decimal128toexponentialstring">Decimal128ToExponentialString</a></emu-xref>(<var>O</var>).</li></ol></emu-alg>
+    <emu-note><span class="note">Note</span><div class="note-contents">
+      <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
+    </div></emu-note>
+  </emu-clause>
+
+  <emu-clause id="sec-decimal.prototype.tofixed">
+    <h1><span class="secnum">3.16</span> Decimal128.prototype.toFixed ( [ <var>numDigits</var> ] )</h1>
+    <p>This method performs the following steps when called:</p>
+    <emu-alg><ol><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>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>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_116"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>O</var>).</li><li>If <var>s</var> is <emu-val>"NaN"</emu-val>, <emu-val>"Infinity"</emu-val>, or <emu-val>"-Infinity"</emu-val>, return <var>s</var>.</li><li>Let <var>integerDigits</var> be <emu-val>""</emu-val>.</li><li>Let <var>nonIntegerDigits</var> be <emu-val>""</emu-val>.</li><li>If <var>s</var> contains a <emu-val>"."</emu-val>, then<ol><li>Set <var>integerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> up to the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>Set <var>nonIntegerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>s</var> after the first occurrence of <emu-val>"."</emu-val> in <var>s</var>.</li><li>If <var>numDigits</var> &gt; 0, set <var>nonIntegerDigits</var> to the <emu-xref href="#substring"><a href="https://tc39.es/ecma262/#substring">substring</a></emu-xref> of <var>nonIntegerDigits</var> from 0 to <var>numDigits</var>.</li></ol></li><li>Else,<ol><li>Set <var>integerDigits</var> to <var>s</var>.</li></ol></li><li>If <var>numDigits</var> is 0, return <var>integerDigits</var>.</li><li>Return the concatenation of <var>integerDigits</var>, <emu-val>"."</emu-val>, and <var>nonIntegerDigits</var>.</li></ol></emu-alg>
+    <emu-note><span class="note">Note</span><div class="note-contents">
+      <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
+    </div></emu-note>
+  </emu-clause>
+
+  <emu-clause id="sec-decimal.prototype.toprecision">
+    <h1><span class="secnum">3.17</span> Decimal128.prototype.toPrecision ( [ <var>precision</var> ] )</h1>
+    <p>This method performs the following steps when called:</p>
+    <emu-alg><ol><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>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>precision</var> is *undefined_, return <emu-xref aoid="Decimal128ToDecimalString" id="_ref_117"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(_O_).</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 <var>d</var>[0].</li><li>Let <var>q</var> be <var>d</var>[1].</li><li>If <var>v</var> is <emu-val>+0</emu-val><sub>𝔻</sub>, return <emu-val>"0"</emu-val>.</li><li>If <var>v</var> is <emu-val>-0</emu-val><sub>𝔻</sub>, return <emu-val>"-0"</emu-val>.</li><li>If -<var>q</var> &lt; <var>precision</var>, then<ol><li>Let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_118"><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_119"><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_120"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>N</var>).</li></ol></emu-alg>
+    <emu-note><span class="note">Note</span><div class="note-contents">
+      <p>This operation follows the specification of the conversion of IEEE 754 Decimal128 values to strings (external character sequences) discussed in Section 5.12 of <emu-xref href="#sec-bibliography"><a href="https://tc39.es/ecma262/#sec-bibliography">IEEE 754-2019</a></emu-xref>.</p>
+    </div></emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.tobigint">
-    <h1><span class="secnum">3.15</span> Decimal128.prototype.toBigInt ( )</h1>
+    <h1><span class="secnum">3.18</span> Decimal128.prototype.toBigInt ( )</h1>
     <p>This method performs the following steps when called:</p>
-    <emu-alg><ol><li>If <emu-xref aoid="IsIntegralDecimal128" id="_ref_100"><a href="#sec-decimal128-isintegraldecimal128value">IsIntegralDecimal128</a></emu-xref>(<emu-val>this</emu-val>) is <emu-val>false</emu-val>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Return !&nbsp;<emu-xref aoid="ToBigInt"><a href="https://tc39.es/ecma262/#sec-tobigint">ToBigInt</a></emu-xref>(Call (<emu-val>this</emu-val>.<var class="field">[[toString]]</var>, <emu-val>this</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>If <emu-xref aoid="IsIntegralDecimal128" id="_ref_121"><a href="#sec-decimal128-isintegraldecimal128value">IsIntegralDecimal128</a></emu-xref>(<var>O</var>) is <emu-val>false</emu-val>, throw a <emu-val>RangeError</emu-val> exception.</li><li>Return !&nbsp;<emu-xref aoid="ToBigInt"><a href="https://tc39.es/ecma262/#sec-tobigint">ToBigInt</a></emu-xref>(Call (<var>O</var>.<var class="field">[[toString]]</var>, <emu-val>this</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 <code>convertToIntegerTiesToEven</code> operation defined 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.tonumber">
-    <h1><span class="secnum">3.16</span> Decimal128.prototype.toNumber ( )</h1>
+    <h1><span class="secnum">3.19</span> Decimal128.prototype.toNumber ( )</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>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_101"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>d</var>).</li><li>Return <emu-xref aoid="StringToNumber"><a href="https://tc39.es/ecma262/#sec-stringtonumber">StringToNumber</a></emu-xref>(<var>s</var>).</li></ol></emu-alg>
+    <emu-alg><ol><li>Let <var>O</var> be the <emu-val>this</emu-val> value.</li><li>Perform ?&nbsp;<emu-xref aoid="RequireInternalSlot"><a href="https://tc39.es/ecma262/#sec-requireinternalslot">RequireInternalSlot</a></emu-xref>(<var>O</var>, <var class="field">[[Decimal128Data]]</var>).</li><li>Let <var>d</var> be <var>O</var>.<var class="field">[[Decimal128Data]]</var>.</li><li>Let <var>s</var> be <emu-xref aoid="Decimal128ToDecimalString" id="_ref_122"><a href="#sec-decimal128-decimal128todecimalstring">Decimal128ToDecimalString</a></emu-xref>(<var>d</var>).</li><li>Return <emu-xref aoid="StringToNumber"><a href="https://tc39.es/ecma262/#sec-stringtonumber">StringToNumber</a></emu-xref>(<var>s</var>).</li></ol></emu-alg>
+    <emu-note><span class="note">Note</span><div class="note-contents">
+      <p>This operation follows the specification of the conversion operation defined in Section 5.4.2 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">3.17</span> Decimal128.prototype.valueOf ( <var>x</var> )</h1>
+    <h1><span class="secnum">3.20</span> Decimal128.prototype.valueOf ( <var>x</var> )</h1>
     <p>This method performs the following steps when called:</p>
-    <emu-alg><ol><li>Throw a <emu-val>TypeError</emu-val> exception.</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>Throw a <emu-val>TypeError</emu-val> exception.</li></ol></emu-alg>
   </emu-clause>
 </emu-clause>
 
@@ -3532,7 +3601,7 @@ <h1><span class="secnum">4.1.1</span> The Number Constructor</h1>
       <emu-clause id="sec-number-constructor-number-value">
         <h1><span class="secnum">4.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>(NewTarget, <emu-val>"%Number.prototype%"</emu-val>, « <var class="field">[[NumberData]]</var>&nbsp;»).</li><li>Set <var>O</var>.<var class="field">[[NumberData]]</var> to <var>n</var>.</li><li>Return <var>O</var>.</li></ol></emu-alg>
+        <emu-alg><ol><li>If <var>value</var> is present, then<ol><li>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_123"><a href="#sec-the-decimal-constructor">%Decimal128%</a></emu-xref>, <emu-val>"%Number.prototype%"</emu-val>, « <var class="field">[[NumberData]]</var>&nbsp;»).</li><li>Set <var>O</var>.<var class="field">[[NumberData]]</var> to <var>n</var>.</li><li>Return <var>O</var>.</li></ol></emu-alg>
       </emu-clause>
     </emu-clause>
   </emu-clause>
@@ -3543,12 +3612,12 @@ <h1><span class="secnum">4.2.1</span> The BigInt Constructor</h1>
       <emu-clause id="sec-bigint-constructor-number-value">
         <h1><span class="secnum">4.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_102"><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_124"><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">4.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_103"><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_125"><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>
@@ -3572,44 +3641,44 @@ <h1><span class="secnum">5.1</span> Abstract Operations for NumberFormat Objects
 
     <emu-clause id="sec-tointlmathematicalvalue" type="abstract operation" aoid="ToIntlMathematicalValue">
       <h1><span class="secnum">5.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_104"><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_105"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, non-NaN, non-<emu-xref href="#sec-decimal-intro" id="_ref_106"><a href="#sec-decimal-intro">negative</a></emu-xref>-<emu-xref href="#dfn-decimal128-zero" id="_ref_107"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 object, (2)</ins> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_108"><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_109"><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_126"><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_127"><a href="#dfn-decimal128-finite">finite</a></emu-xref>, non-NaN, non-<emu-xref href="#sec-decimal-intro" id="_ref_128"><a href="#sec-decimal-intro">negative</a></emu-xref>-<emu-xref href="#dfn-decimal128-zero" id="_ref_129"><a href="#dfn-decimal128-zero">zero</a></emu-xref> Decimal128 object, (2)</ins> a <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_130"><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_131"><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_5"><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_110"><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_3"><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_132"><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">5.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_111"><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_112"><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_113"><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_114"><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_115"><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_116"><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_117"><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_118"><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_133"><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_134"><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_135"><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_136"><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_137"><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_138"><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_139"><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_140"><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">5.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_119"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_120"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_121"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_122"><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_123"><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_124"><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_125"><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_141"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_142"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_143"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_144"><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_145"><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_146"><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_147"><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_126"><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_127"><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_128"><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_129"><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_130"><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_131"><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_132"><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_133"><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_148"><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_149"><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_150"><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_151"><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_152"><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_153"><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_154"><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_155"><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">5.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_134"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_135"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_136"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_137"><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_138"><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_139"><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_156"><a href="#sec-decimal-intro">negative</a></emu-xref> <emu-xref href="#dfn-decimal128-mathematical-value" id="_ref_157"><a href="#dfn-decimal128-mathematical-value">mathematical value</a></emu-xref><ins> or a <emu-xref href="#dfn-decimal128-finite" id="_ref_158"><a href="#dfn-decimal128-finite">finite</a></emu-xref> non-<emu-xref href="#sec-decimal-intro" id="_ref_159"><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_160"><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_161"><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_140"><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_141"><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_142"><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_143"><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_144"><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_145"><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_146"><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_162"><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_163"><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_164"><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_165"><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_166"><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_167"><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_168"><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">5.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_147"><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_169"><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_148"><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_149"><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_150"><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_151"><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_170"><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_171"><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_172"><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_173"><a href="#sec-formatnumberstring">FormatNumericToString</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Let <var>n</var> be <var>formatNumberResult</var>.<var class="field">[[FormattedString]]</var>.</li><li>Set <var>x</var> to <var>formatNumberResult</var>.<var class="field">[[RoundedNumber]]</var>.</li></ol></li><li>Let <var>pattern</var> be <emu-xref aoid="GetNumberFormatPattern"><a href="https://tc39.es/ecma402/#sec-getnumberformatpattern">GetNumberFormatPattern</a></emu-xref>(<var>numberFormat</var>, <var>x</var>).</li><li>Let <var>result</var> be a new empty <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">List</a></emu-xref>.</li><li>Let <var>patternParts</var> be <emu-xref aoid="PartitionPattern"><a href="https://tc39.es/ecma402/#sec-partitionpattern">PartitionPattern</a></emu-xref>(<var>pattern</var>).</li><li>For each <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>, <var class="field">[[Value]]</var>&nbsp;} <var>patternPart</var> of <var>patternParts</var>, do<ol><li>Let <var>p</var> be <var>patternPart</var>.<var class="field">[[Type]]</var>.</li><li>If <var>p</var> is <emu-val>"literal"</emu-val>, then<ol><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"literal"</emu-val>, <var class="field">[[Value]]</var>: <var>patternPart</var>.<var class="field">[[Value]]</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"number"</emu-val>, then<ol><li>Let <var>notationSubParts</var> be <emu-xref aoid="PartitionNotationSubPattern"><a href="https://tc39.es/ecma402/#sec-partitionnotationsubpattern">PartitionNotationSubPattern</a></emu-xref>(<var>numberFormat</var>, <var>x</var>, <var>n</var>, <var>exponent</var>).</li><li>For each <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>, <var class="field">[[Value]]</var>&nbsp;} <var>subPart</var> of <var>notationSubParts</var>, do<ol><li>Append <var>subPart</var> to <var>result</var>.</li></ol></li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"plusSign"</emu-val>, then<ol><li>Let <var>plusSignSymbol</var> be the ILND String representing the plus sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"plusSign"</emu-val>, <var class="field">[[Value]]</var>: <var>plusSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"minusSign"</emu-val>, then<ol><li>Let <var>minusSignSymbol</var> be the ILND String representing the minus sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"minusSign"</emu-val>, <var class="field">[[Value]]</var>: <var>minusSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"percentSign"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"percent"</emu-val>, then<ol><li>Let <var>percentSignSymbol</var> be the ILND String representing the percent sign.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"percentSign"</emu-val>, <var class="field">[[Value]]</var>: <var>percentSignSymbol</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"unitPrefix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"unit"</emu-val>, then<ol><li>Let <var>unit</var> be <var>numberFormat</var>.<var class="field">[[Unit]]</var>.</li><li>Let <var>unitDisplay</var> be <var>numberFormat</var>.<var class="field">[[UnitDisplay]]</var>.</li><li>Let <var>mu</var> be an ILD String value representing <var>unit</var> before <var>x</var> in <var>unitDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unit"</emu-val>, <var class="field">[[Value]]</var>: <var>mu</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"unitSuffix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"unit"</emu-val>, then<ol><li>Let <var>unit</var> be <var>numberFormat</var>.<var class="field">[[Unit]]</var>.</li><li>Let <var>unitDisplay</var> be <var>numberFormat</var>.<var class="field">[[UnitDisplay]]</var>.</li><li>Let <var>mu</var> be an ILD String value representing <var>unit</var> after <var>x</var> in <var>unitDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unit"</emu-val>, <var class="field">[[Value]]</var>: <var>mu</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencyCode"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>cd</var> be <var>currency</var>.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencyPrefix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>currencyDisplay</var> be <var>numberFormat</var>.<var class="field">[[CurrencyDisplay]]</var>.</li><li>Let <var>cd</var> be an ILD String value representing <var>currency</var> before <var>x</var> in <var>currencyDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else if <var>p</var> is equal to <emu-val>"currencySuffix"</emu-val> and <var>numberFormat</var>.<var class="field">[[Style]]</var> is <emu-val>"currency"</emu-val>, then<ol><li>Let <var>currency</var> be <var>numberFormat</var>.<var class="field">[[Currency]]</var>.</li><li>Let <var>currencyDisplay</var> be <var>numberFormat</var>.<var class="field">[[CurrencyDisplay]]</var>.</li><li>Let <var>cd</var> be an ILD String value representing <var>currency</var> after <var>x</var> in <var>currencyDisplay</var> form, which may depend on <var>x</var> in languages having different plural forms. If the implementation does not have such a representation of <var>currency</var>, use <var>currency</var> itself.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"currency"</emu-val>, <var class="field">[[Value]]</var>: <var>cd</var>&nbsp;} to <var>result</var>.</li></ol></li><li>Else,<ol><li>Let <var>unknown</var> be an ILND String based on <var>x</var> and <var>p</var>.</li><li>Append the <emu-xref href="#sec-list-and-record-specification-type"><a href="https://tc39.es/ecma262/#sec-list-and-record-specification-type">Record</a></emu-xref> { <var class="field">[[Type]]</var>: <emu-val>"unknown"</emu-val>, <var class="field">[[Value]]</var>: <var>unknown</var>&nbsp;} to <var>result</var>.</li></ol></li></ol></li><li>Return <var>result</var>.</li></ol></emu-alg>
     </emu-clause>
   </emu-clause>
 </emu-clause><emu-annex id="sec-copyright-and-software-license">
diff --git a/spec.emu b/spec.emu
index 98fb9b01..24b912b0 100644
--- a/spec.emu
+++ b/spec.emu
@@ -75,9 +75,12 @@ location: https://github.com/tc39/proposal-decimal/
           <li>a mathematical value</li>
         </ul></li>
         <li>_q_ is an integer satisfying -6176 ≤ _q_ ≤ 6111,</li>
-        <li>If _v_ is a mathematical value, then v × 10<sup>-_q_</sup> is an integer _n_ such that 0 < _n_ < 10<sup>34</sup></li>
+        <li>If _v_ is a mathematical value, then v × 10<sup>-_q_</sup> is an integer _n_ such that 0 < abs(_n_) < 10<sup>34</sup></li>
       </ul>
     </ul>
+    <emu-note>
+      <p>A Decimal128 value is not an ECMAScript language value.</p>
+    </emu-note>
     <p>The <dfn id="dfn-decimal128-mathematical-value">mathematical value</dfn> of a finite Decimal128 value _x_ = « _v_, _q_ »<sub>𝔻</sub> is defined as follows:</p>
     <ul>
       <li>If _x_ is zero, the mathematical value of _x_ is 0</li>
@@ -87,7 +90,7 @@ location: https://github.com/tc39/proposal-decimal/
     <emu-note>
       <p>The _v_ component of a finite non-zero Decimal128 value « _v_, _q_ »<sub>𝔻</sub> is a rational number.</p>
     </emu-note>
-    <p>Decimal128 values defined in this section are ECMAScript analogues of <emu-xref href="#sec-bibliography">IEEE-754 Decimal128 values</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>Decimal128 values defined in this section are ECMAScript analogues of <emu-xref href="#sec-bibliography">IEEE 754 Decimal128 values</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">rounding mode</dfn> is one of the String values *"ceil"*, *"floor"*, *"trunc"*, *"halfExpand"*, and *"halfEven"*. The <dfn id="dfn-decimal128-default-rounding-mode">default rounding mode</dfn> is the String value *"halfEven"*.</p>
     <emu-table id="table-decimal128-rounding-modes">
       <emu-caption>Rounding modes in Decimal128 compared to IEEE 754 rounding modes</emu-caption>
@@ -160,25 +163,6 @@ location: https://github.com/tc39/proposal-decimal/
   </emu-intro>
   <emu-clause id="sec-decimal-abstract-ops">
     <h1>Abstract Operations</h1>
-    <emu-clause id="sec-decimal128-todecimal128" type="abstract operation">
-      <h1>
-        ToDecimal128 (
-          _argument_ : an ECMAScript language value
-        ): either a normal completion containing a a Decimal128 value or a throw completion
-      </h1>
-      <dl class="header">
-        <dt>description</dt>
-        <dd>It converts a _argument_ to a Decimal128 value.</dd>
-      </dl>
-      <emu-alg>
-        1. Let _toParse_ be *undefined*.
-        1. If _argument_ is a BigInt, set _toParse_ to BigInt::toString(_argument_, 10).
-        1. If _argument_ is a Number, set _toParse_ to Number::toString(_argument_, 10).
-        1. If _argument_ is a String, set _toParse_ to _argument_.
-        1. If _toParse_ is not a String, throw a *TypeError* exception.
-        1. Return <mark>« 42, 42 »</mark>.
-      </emu-alg>
-    </emu-clause>
 
     <emu-clause id="sec-decimal128-decimal128todecimalstring" type="abstract operation">
       <h1>
@@ -191,7 +175,22 @@ location: https://github.com/tc39/proposal-decimal/
         <dd>It renders _argument_ as a decimal (non-exponential) string.</dd>
       </dl>
       <emu-alg>
-        1. Return <mark>*"42"*</mark>.
+        1. If _argument_ is *NaN*<sub>𝔻</sub>, return *"NaN"*.
+        1. If _argument_ is *+∞*<sub>𝔻</sub>, return *"Infinity"*.
+        1. If _argument_ is *-∞*<sub>𝔻</sub>, return *"-Infinity"*.
+        1. Let _v_ be _argument_[0].
+        1. Let _q_ be _argument_[1].
+        1. 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. Let _digits_ be the unique decimal string representation of _n_ without leading zeroes.
+        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. Return the concatenation of _integerPart_, *"."*, and _nonIntegerPart_.
       </emu-alg>
     </emu-clause>
 
@@ -206,7 +205,16 @@ location: https://github.com/tc39/proposal-decimal/
         <dd>It renders _argument_ in exponential notation.</dd>
       </dl>
       <emu-alg>
-        1. Return <mark>*"42E42"*</mark>.
+        1. If _argument_ is *NaN*<sub>𝔻</sub>, return *"NaN"*.
+        1. If _argument_ is *+∞*<sub>𝔻</sub>, return *"Infinity"*.
+        1. If _argument_ is *-∞*<sub>𝔻</sub>, return *"-Infinity"*.
+        1. Let _v_ be _argument_[0].
+        1. Let _q_ be _argument_[1].
+        1. If _v_ is *+0*<sub>𝔻</sub>, return *"0"*.
+        1. If _v_ is *-0*<sub>𝔻</sub>, return *"-0"*.
+        1. Let _coefficientStr_ be the unique decimal string representation of _v_ without leading zeroes.
+        1. Let _exponentStr_ be the unique decimal string representation of _q_ without leading zeroes.
+        1. Return the concatenation of _coefficientStr_, *"e"*, and _exponentStr_.
       </emu-alg>
     </emu-clause>
 
@@ -223,7 +231,7 @@ location: https://github.com/tc39/proposal-decimal/
       <emu-alg>
         1. Let _d_ be _argument_.[[Decimal128Data]].
         1. If _d_ is *NaN*<sub>𝔻</sub>, return *false*.
-        1. If _d_ is *+∞*<sub>𝔻</sub> or *+∞*<sub>𝔻</sub>, return *false*.
+        1. If _d_ is *+∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return *false*.
         1. Let _v_ be _d_[0].
         1. Let _q_ be _d_[1].
         1. If _v_ is an integer and 0 ≤ _q_, return *true*.
@@ -242,31 +250,79 @@ location: https://github.com/tc39/proposal-decimal/
         <dd>It converts a Decimal128 value to a Decimal128 object.</dd>
       </dl>
       <emu-alg>
-        1. Let _O_ be ! OrdinaryCreateFromConstructor(NewTarget, *"%Decimal128.prototype%"*, « [[Decimal128Data]] »).
+        1. Let _O_ be ! OrdinaryCreateFromConstructor(%Decimal128%, *"%Decimal128.prototype%"*, « [[Decimal128Data]] »).
         1. Set _O_.[[Decimal128Data]] to _argument_.
         1. Return _O_.
       </emu-alg>
     </emu-clause>
+
+    <emu-clause id="sec-decimal128-d" type="abstract operation">
+      <h1>
+        EnsureDecimal128Value (
+          _coefficient_ : a mathematical value,
+          _intendedExponent_ : a mathematical value,
+          _roundingMode_: a Decimal128 rounding mode
+        ): either a normal completion containing a Decimal128 value or a throw completion
+      </h1>
+      <dl class="header">
+        <dt>description</dt>
+        <dd>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.</dd>
+      </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_ ».
+          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>
 
   <emu-clause id="sec-the-decimal-constructor">
     <h1>The Decimal128 Constructor</h1>
     <p>The Decimal128 constructor:</p>
     <ul>
-      <li>is <dfn>%Decimal128</dfn>.</li>
+      <li>is <dfn>%Decimal128%</dfn>.</li>
       <li>is the initial value of the the *"Decimal128"* property of the global object.</li>
       <li>creates and initializes a new Decimal128 object when called as a constructor</li>
       <li>may be used as the value of an *extends* clause of a class definition. Subclass constructors that intend to inherit the specified Decimal128 behaviour must include a *super* call to the Decimal128 constructor to create and initialize the subclass instance with a [[Decimal128Data]] internal slot.</li>
     </ul>
     <emu-clause id="sec-the-decimal128-constructor-value">
-      <h1>Decimal128 ( _x_ [ , _options_ ] )</h1>
+      <h1>Decimal128 ( _x_ )</h1>
       <emu-alg>
         1. If NewTarget is *undefined*, throw a *TypeError* exception.
-        1. Let _n_ be ? ToDecimal128(_x_).
+        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 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. Set _O_.[[Decimal128Data]] to _n_.
+        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. 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. 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>
   </emu-clause>
 </emu-clause>
@@ -301,6 +357,9 @@ location: https://github.com/tc39/proposal-decimal/
       1. Set _N_.[[Decimal128Data]] to _n_.
       1. Return _N_.
     </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>
+    </emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.neg">
@@ -320,6 +379,9 @@ location: https://github.com/tc39/proposal-decimal/
       1. Set _N_.[[Decimal128Data]] to _n_.
       1. Return _N_.
     </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>
+    </emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.add">
@@ -340,8 +402,11 @@ location: https://github.com/tc39/proposal-decimal/
         1. If _d2_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
         1. If _d2_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
         1. Return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
-      1. Return <mark>Decimal128ValueToObject(« _d1_[0] + _d2_[0], min(_d1_[1], _d2_[1]) »)</mark>.
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_d1_[0] + _d2_[0], min(_d1_[1], _d2_[1]), *"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>
+    </emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.subtract">
@@ -362,8 +427,11 @@ location: https://github.com/tc39/proposal-decimal/
         1. If _d2_ is *+∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
         1. If _d2_ is *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
         1. Return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
-      1. Return <mark>Decimal128ValueToObject(« d1[0] - d2[0], min(d1[1], d2[1]) »)</mark>.
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(d1[0] - d2[0], min(d1[1], d2[1]), *"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>
+    </emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.multiply">
@@ -387,8 +455,11 @@ location: https://github.com/tc39/proposal-decimal/
         1. If _d2_ is a zero Decimal128 value, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
         1. If _d2_[0] < 0, return Decimal128ValueToObject(*+∞*<sub>𝔻</sub>).
         1. Return Decimal128ValueToObject(*-∞*<sub>𝔻</sub>).
-      1. Return <mark>Decimal128ValueToObject(« _d1_[0] × _d2_[0], min(_d1_[1], _d2_[1]) »)</mark>.
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value (_d1_[0] × _d2_[0], _d1_[1] + _d2_[1], *"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>
+    </emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.divide">
@@ -403,8 +474,11 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d1_ or _d2_ is *NaN*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d1_ is *+∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d2_ is *-∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
-      1. Return <mark>Decimal128ValueToObject(« _d1_[0] / _d2_[0], min(_d1_[1], _d2_[1]) »)</mark>.
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_d1_[0] / _d2_[0], _d1_[1] + _d2_[1], *"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>
+    </emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.remainder">
@@ -419,10 +493,10 @@ location: https://github.com/tc39/proposal-decimal/
       1. If _d1_ or _d2_ is *NaN*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d1_ is *+∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
       1. If _d1_ is *-∞*<sub>𝔻</sub> or *-∞*<sub>𝔻</sub>, return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>).
-      1. Return <mark>Decimal128ValueToObject(« _d1_[0] % _d2_[0], min(_d1_[1], _d2_[1]) »)</mark>.
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(_d1_[0] % _d2_[0], _d1_[1] + _d2_[1], *"halfEven"*)).
     </emu-alg>
     <emu-note>
-      <p>The remainder operation specified here deviates from the IEEE 754 remainder operation. 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>
+      <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>
 
@@ -446,6 +520,9 @@ location: https://github.com/tc39/proposal-decimal/
       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">
@@ -468,6 +545,9 @@ location: https://github.com/tc39/proposal-decimal/
       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">
@@ -500,45 +580,143 @@ location: https://github.com/tc39/proposal-decimal/
       1. Return *+0*<sub>𝔽</sub>.
     </emu-alg>
     <emu-note>
-      <p>This operation compares Decimal128 values 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> and <emu-xref href="#sec-decimal.prototype.equals">equals</emu-xref>.</p>
+      <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>
     </emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal-method-round">
-    <h1>Decimal128.prototype.round ( _numFractionalDigits_ [ , _mode_ ] )</h1>
+    <h1>Decimal128.prototype.round ( _numFractionalDigits_ [ , _roundingMode_ ] )</h1>
     <p>This method performs the following steps when called:</p>
     <emu-alg>
-      1. <mark>Return Decimal128ValueToObject(*NaN*<sub>𝔻</sub>)</mark>.
+      1. If _numFractionalDigits_ is not a Number, throw a *TypeError* exception.
+      1. If _numFractionalDigits_ < 0, throw a *RangeError* exception.
+      1. If _numFractionalDigits_ is not an integer, throw a *RangeError* exception.
+      1. If _roundingMode_ is neither *undefined* nor a String, throw a *TypeError* exception.
+      1. If _roundingMode_ is undefined, set _roundingMode_ to <emu-xref href="#dfn-decimal128-default-rounding-mode">the default rounding mode</emu-xref>.
+      1. If _roundingMode_ is not a rounding mode, throw a *RangeError* exception.
+      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. Let _v_ be _d_[0].
+      1. Let _q_ be _d_[1].
+      1. If _v_ is *+0*<sub>𝔻</sub>, return _O_.
+      1. If _v_ is *-0*<sub>𝔻</sub>, return _O_.
+      1. Let _n_ be the integer such that v × 10<sup>-_q_</sup> = _n_ and 0 < abs(_n_) < 10<sup>34</sup>.
+      1. Return Decimal128ValueToObject(? EnsureDecimal128Value(v × 10<sup>-_numFractionalDigits_</sup>, _q_ + _numFractionalDigits_, _roundingMode_)).
     </emu-alg>
     <emu-note>
-      <p>If _mode_ is neither *undefined* nor a String, throw a *TypeError* exception.</p>
-      <p>If _mode_ is not a <emu-xref href="#dfn-decimal128-rounding-mode">rounding mode</emu-xref>, throw a *RangeError* exception.</p>
+      <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.prototype.tostring">
-    <h1>Decimal128.prototype.toString ( [ _options_ ] )</h1>
+    <h1>Decimal128.prototype.toString ( )</h1>
+    <p>This method performs the following steps when called:</p>
+    <emu-alg>
+      1. Let _O_ be the *this* value.
+      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
+      1. Return Decimal128ToDecimalString(_O_).
+    </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>
+    </emu-note>
+  </emu-clause>
+
+  <emu-clause id="sec-decimal.prototype.toexponential">
+    <h1>Decimal128.prototype.toExponential ( )</h1>
+    <p>This method performs the following steps when called:</p>
+    <emu-alg>
+      1. Let _O_ be the *this* value.
+      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
+      1. Return Decimal128ToExponentialString(_O_).
+    </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>
+    </emu-note>
+  </emu-clause>
+
+  <emu-clause id="sec-decimal.prototype.tofixed">
+    <h1>Decimal128.prototype.toFixed ( [ _numDigits_ ] )</h1>
+    <p>This method performs the following steps when called:</p>
+    <emu-alg>
+      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. If _numDigits_ < 0, throw a *RangeError* exception.
+      1. If _numDigits_ is not an integer, throw a *RangeError* exception.
+      1. Let _O_ be the *this* value.
+      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
+      1. Let _s_ be Decimal128ToDecimalString(_O_).
+      1. If _s_ is *"NaN"*, *"Infinity"*, or *"-Infinity"*, return _s_.
+      1. Let _integerDigits_ be *""*.
+      1. Let _nonIntegerDigits_ be *""*.
+      1. If _s_ contains a *"."*, then
+        1. Set _integerDigits_ to the substring of _s_ up to the first occurrence of *"."* in _s_.
+        1. Set _nonIntegerDigits_ to the substring of _s_ after the first occurrence of *"."* in _s_.
+        1. If _numDigits_ > 0, set _nonIntegerDigits_ to the substring of _nonIntegerDigits_ from 0 to _numDigits_.
+      1. Else,
+        1. Set _integerDigits_ to _s_.
+      1. If _numDigits_ is 0, return _integerDigits_.
+      1. Return the concatenation of _integerDigits_, *"."*, and _nonIntegerDigits_.
+    </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>
+    </emu-note>
+  </emu-clause>
+
+  <emu-clause id="sec-decimal.prototype.toprecision">
+    <h1>Decimal128.prototype.toPrecision ( [ _precision_ ] )</h1>
     <p>This method performs the following steps when called:</p>
     <emu-alg>
-      1. Let _roundingMode_ be ? Get(_options_, *"roundingMode"*).
-      1. If _roundingMode_ is *undefined*, set _roundingMode_ to the <emu-xref href="#dfn-decimal128-default-rounding-mode">default rounding mode</emu-xref>.
-      1. If _roundingMode_ is not a <emu-xref href="#dfn-decimal128-rounding-mode">rounding mode</emu-xref>, throw a *RangeError* exception.
-      1. Let _format_ be ? Get(_options_, *"format*").
-      1. If _format_ is *undefined*, set _format_ to *"decimal"*.
-      1. If _format_ is not in « *"decimal"*, *"exponential"* », then throw a *RangeError* exception.
-      1. If _format_ is *"decimal*", then
-        1. Return Decimal128ToDecimalString(*this*).
-      1. Return Decimal128ToExponentialString(*this*).
+      1. If _precision_ is neither *undefined* nor a Number, throw a *TypeError* exception.
+      1. Let _O_ be the *this* value.
+      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
+      1. If _precision_ is *undefined_, return Decimal128ToDecimalString(_O_).
+      1. If _precision_ is not an integer, throw a *RangeError* exception.
+      1. If _precision_ < 1, throw a *RangeError* exception.
+      1. Let _d_ be _O_.[[Decimal128Data]].
+      1. If _d_ is *NaN*<sub>𝔻</sub>, return *"NaN"*.
+      1. If _d_ is *+∞*<sub>𝔻</sub>, return *"Infinity"*.
+      1. If _d_ is *-∞*<sub>𝔻</sub>, return *"-Infinity"*.
+      1. Let _v_ be _d_[0].
+      1. Let _q_ be _d_[1].
+      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 _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_.
+        1. Let _trailingZeroes_ be the string *"0"* repeated _numTrailingZeroesToAdd_ times.
+        1. Return the concatenation of _integerDigits_, *"."*, _nonIntegerDigits_, and _trailingZeroes_.
+      1. Let _n_ be the integer such that v × 10<sup>-_q_</sup> = _n_ and 0 < abs(_n_) < 10<sup>34</sup>.
+      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_).
     </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>
+    </emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.tobigint">
     <h1>Decimal128.prototype.toBigInt ( )</h1>
     <p>This method performs the following steps when called:</p>
     <emu-alg>
-      1. If IsIntegralDecimal128(*this*) is *false*, throw a *RangeError* exception.
-      1. Return ! ToBigInt(Call (*this*.[[toString]], *this*)).
+      1. Let _O_ be the *this* value.
+      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
+      1. If IsIntegralDecimal128(_O_) is *false*, throw a *RangeError* exception.
+      1. Return ! ToBigInt(Call (_O_.[[toString]], *this*)).
     </emu-alg>
+    <emu-note>
+      <p>This operation follows the specification of the <code>convertToIntegerTiesToEven</code> operation defined in Section 5.4.1 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
+    </emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.tonumber">
@@ -551,12 +729,17 @@ location: https://github.com/tc39/proposal-decimal/
       1. Let _s_ be Decimal128ToDecimalString(_d_).
       1. Return StringToNumber(_s_).
     </emu-alg>
+    <emu-note>
+      <p>This operation follows the specification of the conversion operation defined in Section 5.4.2 of <emu-xref href="#sec-bibliography">IEEE 754-2019</emu-xref>.</p>
+    </emu-note>
   </emu-clause>
 
   <emu-clause id="sec-decimal.prototype.valueof">
     <h1>Decimal128.prototype.valueOf ( _x_ )</h1>
     <p>This method performs the following steps when called:</p>
     <emu-alg>
+      1. Let _O_ be the *this* value.
+      1. Perform ? RequireInternalSlot(_O_, [[Decimal128Data]]).
       1. Throw a *TypeError* exception.
     </emu-alg>
   </emu-clause>
@@ -581,7 +764,7 @@ location: https://github.com/tc39/proposal-decimal/
           1. Else,
             1. Let _n_ be *+0*<sub>𝔽</sub>.
           1. If NewTarget is *undefined*, return _n_.
-          1. Let _O_ be ? OrdinaryCreateFromConstructor(NewTarget, *"%Number.prototype%"*, « [[NumberData]] »).
+          1. Let _O_ be ? OrdinaryCreateFromConstructor(%Decimal128%, *"%Number.prototype%"*, « [[NumberData]] »).
           1. Set _O_.[[NumberData]] to _n_.
           1. Return _O_.
         </emu-alg>