Use import/export for more functions (instead of js builtins object).

src/js/math.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 var rngstate;  // Initialized to a Uint32Array during genesis.
 
 (function(global, utils) {
 "use strict";
 
 %CheckIsBootstrapping();
 
 // -------------------------------------------------------------------
 // Imports
 
 var GlobalMath = global.Math;
 var GlobalObject = global.Object;
 var InternalArray = utils.InternalArray;
+var NaN = %GetRootNaN();
 var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
 
 //-------------------------------------------------------------------
 
 // ECMA 262 - 15.8.2.1
 function MathAbs(x) {
   x = +x;
   return (x > 0) ? x : 0 - x;
 }
 
@@ skipping 47 matching lines @@
   if (length == 2) {
     arg1 = TO_NUMBER(arg1);
     arg2 = TO_NUMBER(arg2);
     if (arg2 > arg1) return arg2;
     if (arg1 > arg2) return arg1;
     if (arg1 == arg2) {
       // Make sure -0 is considered less than +0.
       return (arg1 === 0 && %_IsMinusZero(arg1)) ? arg2 : arg1;
     }
     // All comparisons failed, one of the arguments must be NaN.
-    return NAN;
+    return NaN;
   }
   var r = -INFINITY;
   for (var i = 0; i < length; i++) {
     var n = %_Arguments(i);
     n = TO_NUMBER(n);
     // Make sure +0 is considered greater than -0.
     if (NUMBER_IS_NAN(n) || n > r || (r === 0 && n === 0 && %_IsMinusZero(r))) {
       r = n;
     }
   }
   return r;
 }
 
 // ECMA 262 - 15.8.2.12
 function MathMin(arg1, arg2) {  // length == 2
   var length = %_ArgumentsLength();
   if (length == 2) {
     arg1 = TO_NUMBER(arg1);
     arg2 = TO_NUMBER(arg2);
     if (arg2 > arg1) return arg1;
     if (arg1 > arg2) return arg2;
     if (arg1 == arg2) {
       // Make sure -0 is considered less than +0.
       return (arg1 === 0 && %_IsMinusZero(arg1)) ? arg1 : arg2;
     }
     // All comparisons failed, one of the arguments must be NaN.
-    return NAN;
+    return NaN;
   }
   var r = INFINITY;
   for (var i = 0; i < length; i++) {
     var n = %_Arguments(i);
     n = TO_NUMBER(n);
     // Make sure -0 is considered less than +0.
     if (NUMBER_IS_NAN(n) || n < r || (r === 0 && n === 0 && %_IsMinusZero(n))) {
       r = n;
     }
   }
@@ skipping 76 matching lines @@
   // Idempotent for NaN, +/-0 and +/-Infinity.
   if (x === 0 || !NUMBER_IS_FINITE(x)) return x;
   if (x > 0) return MathLog(x + %_MathSqrt(x * x + 1));
   // This is to prevent numerical errors caused by large negative x.
   return -MathLog(-x + %_MathSqrt(x * x + 1));
 }
 
 // ES6 draft 09-27-13, section 20.2.2.3.
 function MathAcosh(x) {
   x = TO_NUMBER(x);
-  if (x < 1) return NAN;
+  if (x < 1) return NaN;
   // Idempotent for NaN and +Infinity.
   if (!NUMBER_IS_FINITE(x)) return x;
   return MathLog(x + %_MathSqrt(x + 1) * %_MathSqrt(x - 1));
 }
 
 // ES6 draft 09-27-13, section 20.2.2.7.
 function MathAtanh(x) {
   x = TO_NUMBER(x);
   // Idempotent for +/-0.
   if (x === 0) return x;
   // Returns NaN for NaN and +/- Infinity.
-  if (!NUMBER_IS_FINITE(x)) return NAN;
+  if (!NUMBER_IS_FINITE(x)) return NaN;
   return 0.5 * MathLog((1 + x) / (1 - x));
 }
 
 // ES6 draft 09-27-13, section 20.2.2.17.
 function MathHypot(x, y) {  // Function length is 2.
   // We may want to introduce fast paths for two arguments and when
   // normalization to avoid overflow is not necessary.  For now, we
   // simply assume the general case.
   var length = %_ArgumentsLength();
   var args = new InternalArray(length);
@@ skipping 125 matching lines @@
 utils.Export(function(to) {
   to.MathAbs = MathAbs;
   to.MathExp = MathExp;
   to.MathFloor = MathFloorJS;
   to.IntRandom = MathRandomRaw;
   to.MathMax = MathMax;
   to.MathMin = MathMin;
 });
 
 })