You can not select more than 25 topics
			Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
		
		
		
		
		
			
		
			
				
					70 lines
				
				2.7 KiB
			
		
		
			
		
	
	
					70 lines
				
				2.7 KiB
			| 
								 
											3 years ago
										 
									 | 
							
								'use strict';
							 | 
						||
| 
								 | 
							
								var global = require('./_global');
							 | 
						||
| 
								 | 
							
								var has = require('./_has');
							 | 
						||
| 
								 | 
							
								var cof = require('./_cof');
							 | 
						||
| 
								 | 
							
								var inheritIfRequired = require('./_inherit-if-required');
							 | 
						||
| 
								 | 
							
								var toPrimitive = require('./_to-primitive');
							 | 
						||
| 
								 | 
							
								var fails = require('./_fails');
							 | 
						||
| 
								 | 
							
								var gOPN = require('./_object-gopn').f;
							 | 
						||
| 
								 | 
							
								var gOPD = require('./_object-gopd').f;
							 | 
						||
| 
								 | 
							
								var dP = require('./_object-dp').f;
							 | 
						||
| 
								 | 
							
								var $trim = require('./_string-trim').trim;
							 | 
						||
| 
								 | 
							
								var NUMBER = 'Number';
							 | 
						||
| 
								 | 
							
								var $Number = global[NUMBER];
							 | 
						||
| 
								 | 
							
								var Base = $Number;
							 | 
						||
| 
								 | 
							
								var proto = $Number.prototype;
							 | 
						||
| 
								 | 
							
								// Opera ~12 has broken Object#toString
							 | 
						||
| 
								 | 
							
								var BROKEN_COF = cof(require('./_object-create')(proto)) == NUMBER;
							 | 
						||
| 
								 | 
							
								var TRIM = 'trim' in String.prototype;
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								// 7.1.3 ToNumber(argument)
							 | 
						||
| 
								 | 
							
								var toNumber = function (argument) {
							 | 
						||
| 
								 | 
							
								  var it = toPrimitive(argument, false);
							 | 
						||
| 
								 | 
							
								  if (typeof it == 'string' && it.length > 2) {
							 | 
						||
| 
								 | 
							
								    it = TRIM ? it.trim() : $trim(it, 3);
							 | 
						||
| 
								 | 
							
								    var first = it.charCodeAt(0);
							 | 
						||
| 
								 | 
							
								    var third, radix, maxCode;
							 | 
						||
| 
								 | 
							
								    if (first === 43 || first === 45) {
							 | 
						||
| 
								 | 
							
								      third = it.charCodeAt(2);
							 | 
						||
| 
								 | 
							
								      if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
							 | 
						||
| 
								 | 
							
								    } else if (first === 48) {
							 | 
						||
| 
								 | 
							
								      switch (it.charCodeAt(1)) {
							 | 
						||
| 
								 | 
							
								        case 66: case 98: radix = 2; maxCode = 49; break; // fast equal /^0b[01]+$/i
							 | 
						||
| 
								 | 
							
								        case 79: case 111: radix = 8; maxCode = 55; break; // fast equal /^0o[0-7]+$/i
							 | 
						||
| 
								 | 
							
								        default: return +it;
							 | 
						||
| 
								 | 
							
								      }
							 | 
						||
| 
								 | 
							
								      for (var digits = it.slice(2), i = 0, l = digits.length, code; i < l; i++) {
							 | 
						||
| 
								 | 
							
								        code = digits.charCodeAt(i);
							 | 
						||
| 
								 | 
							
								        // parseInt parses a string to a first unavailable symbol
							 | 
						||
| 
								 | 
							
								        // but ToNumber should return NaN if a string contains unavailable symbols
							 | 
						||
| 
								 | 
							
								        if (code < 48 || code > maxCode) return NaN;
							 | 
						||
| 
								 | 
							
								      } return parseInt(digits, radix);
							 | 
						||
| 
								 | 
							
								    }
							 | 
						||
| 
								 | 
							
								  } return +it;
							 | 
						||
| 
								 | 
							
								};
							 | 
						||
| 
								 | 
							
								
							 | 
						||
| 
								 | 
							
								if (!$Number(' 0o1') || !$Number('0b1') || $Number('+0x1')) {
							 | 
						||
| 
								 | 
							
								  $Number = function Number(value) {
							 | 
						||
| 
								 | 
							
								    var it = arguments.length < 1 ? 0 : value;
							 | 
						||
| 
								 | 
							
								    var that = this;
							 | 
						||
| 
								 | 
							
								    return that instanceof $Number
							 | 
						||
| 
								 | 
							
								      // check on 1..constructor(foo) case
							 | 
						||
| 
								 | 
							
								      && (BROKEN_COF ? fails(function () { proto.valueOf.call(that); }) : cof(that) != NUMBER)
							 | 
						||
| 
								 | 
							
								        ? inheritIfRequired(new Base(toNumber(it)), that, $Number) : toNumber(it);
							 | 
						||
| 
								 | 
							
								  };
							 | 
						||
| 
								 | 
							
								  for (var keys = require('./_descriptors') ? gOPN(Base) : (
							 | 
						||
| 
								 | 
							
								    // ES3:
							 | 
						||
| 
								 | 
							
								    'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
							 | 
						||
| 
								 | 
							
								    // ES6 (in case, if modules with ES6 Number statics required before):
							 | 
						||
| 
								 | 
							
								    'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' +
							 | 
						||
| 
								 | 
							
								    'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger'
							 | 
						||
| 
								 | 
							
								  ).split(','), j = 0, key; keys.length > j; j++) {
							 | 
						||
| 
								 | 
							
								    if (has(Base, key = keys[j]) && !has($Number, key)) {
							 | 
						||
| 
								 | 
							
								      dP($Number, key, gOPD(Base, key));
							 | 
						||
| 
								 | 
							
								    }
							 | 
						||
| 
								 | 
							
								  }
							 | 
						||
| 
								 | 
							
								  $Number.prototype = proto;
							 | 
						||
| 
								 | 
							
								  proto.constructor = $Number;
							 | 
						||
| 
								 | 
							
								  require('./_redefine')(global, NUMBER, $Number);
							 | 
						||
| 
								 | 
							
								}
							 |