core-js 3.0.0-beta.6 → 3.0.0

package/modules/es.reflect.apply.js

@@ -12,8 +12,10 @@ var OPTIONAL_ARGUMENTS_LIST = !require('../internals/fails')(function () {
 // https://tc39.github.io/ecma262/#sec-reflect.apply
 require('../internals/export')({ target: 'Reflect', stat: true, forced: OPTIONAL_ARGUMENTS_LIST }, {
   apply: function apply(target, thisArgument, argumentsList) {
-    var T = aFunction(target);
-    var L = anObject(argumentsList);
-    return nativeApply ? nativeApply(T, thisArgument, L) : functionApply.call(T, thisArgument, L);
+    aFunction(target);
+    anObject(argumentsList);
+    return nativeApply
+      ? nativeApply(target, thisArgument, argumentsList)
+      : functionApply.call(target, thisArgument, argumentsList);
   }
 });

package/modules/es.reflect.get.js

@@ -12,9 +12,9 @@ function get(target, propertyKey /* , receiver */) {
   if (anObject(target) === receiver) return target[propertyKey];
   if (descriptor = getOwnPropertyDescriptorModule.f(target, propertyKey)) return has(descriptor, 'value')
     ? descriptor.value
-    : descriptor.get !== undefined
-      ? descriptor.get.call(receiver)
-      : undefined;
+    : descriptor.get === undefined
+      ? undefined
+      : descriptor.get.call(receiver);
   if (isObject(prototype = getPrototypeOf(target))) return get(prototype, propertyKey, receiver);
 }
 

package/modules/es.reflect.prevent-extensions.js

@@ -1,6 +1,6 @@
-var FREEZING = require('../internals/freezing');
+var getBuiltIn = require('../internals/get-built-in');
 var anObject = require('../internals/an-object');
-var objectPreventExtensions = Object.preventExtensions;
+var FREEZING = require('../internals/freezing');
 
 // `Reflect.preventExtensions` method
 // https://tc39.github.io/ecma262/#sec-reflect.preventextensions
@@ -8,6 +8,7 @@ require('../internals/export')({ target: 'Reflect', stat: true, sham: !FREEZING
   preventExtensions: function preventExtensions(target) {
     anObject(target);
     try {
+      var objectPreventExtensions = getBuiltIn('Object', 'preventExtensions');
       if (objectPreventExtensions) objectPreventExtensions(target);
       return true;
     } catch (e) {

package/modules/es.regexp.constructor.js

@@ -17,13 +17,15 @@ var re2 = /a/g;
 // "new" should create a new object, old webkit bug
 var CORRECT_NEW = new NativeRegExp(re1) !== re1;
 
-// `RegExp` constructor
-// https://tc39.github.io/ecma262/#sec-regexp-constructor
-if (isForced('RegExp', DESCRIPTORS && (!CORRECT_NEW || fails(function () {
+var FORCED = isForced('RegExp', DESCRIPTORS && (!CORRECT_NEW || fails(function () {
   re2[MATCH] = false;
   // RegExp constructor can alter flags and IsRegExp works correct with @@match
   return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i';
-})))) {
+})));
+
+// `RegExp` constructor
+// https://tc39.github.io/ecma262/#sec-regexp-constructor
+if (FORCED) {
   var RegExpWrapper = function RegExp(pattern, flags) {
     var thisIsRegExp = this instanceof RegExpWrapper;
     var patternIsRegExp = isRegExp(pattern);
@@ -43,7 +45,9 @@ if (isForced('RegExp', DESCRIPTORS && (!CORRECT_NEW || fails(function () {
       set: function (it) { NativeRegExp[key] = it; }
     });
   };
-  for (var keys = getOwnPropertyNames(NativeRegExp), i = 0; keys.length > i;) proxy(keys[i++]);
+  var keys = getOwnPropertyNames(NativeRegExp);
+  var i = 0;
+  while (i < keys.length) proxy(keys[i++]);
   RegExpPrototype.constructor = RegExpWrapper;
   RegExpWrapper.prototype = RegExpPrototype;
   redefine(global, 'RegExp', RegExpWrapper);

package/modules/es.regexp.exec.js

@@ -2,10 +2,6 @@
 
 var regexpExec = require('../internals/regexp-exec');
 
-require('../internals/export')({
-  target: 'RegExp',
-  proto: true,
-  forced: regexpExec !== /./.exec
-}, {
+require('../internals/export')({ target: 'RegExp', proto: true, forced: /./.exec !== regexpExec }, {
   exec: regexpExec
 });

package/modules/es.string.anchor.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('anchor');
+
 // `String.prototype.anchor` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.anchor
-require('../internals/string-html')('anchor', function (createHTML) {
-  return function anchor(name) {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  anchor: function anchor(name) {
     return createHTML(this, 'a', 'name', name);
-  };
+  }
 });

package/modules/es.string.big.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('big');
+
 // `String.prototype.big` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.big
-require('../internals/string-html')('big', function (createHTML) {
-  return function big() {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  big: function big() {
     return createHTML(this, 'big', '', '');
-  };
+  }
 });

package/modules/es.string.blink.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('blink');
+
 // `String.prototype.blink` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.blink
-require('../internals/string-html')('blink', function (createHTML) {
-  return function blink() {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  blink: function blink() {
     return createHTML(this, 'blink', '', '');
-  };
+  }
 });

package/modules/es.string.bold.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('bold');
+
 // `String.prototype.bold` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.bold
-require('../internals/string-html')('bold', function (createHTML) {
-  return function bold() {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  bold: function bold() {
     return createHTML(this, 'b', '', '');
-  };
+  }
 });

package/modules/es.string.code-point-at.js

@@ -1,5 +1,5 @@
 'use strict';
-var internalCodePointAt = require('../internals/string-at')(false);
+var internalCodePointAt = require('../internals/string-at');
 
 // `String.prototype.codePointAt` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat

package/modules/es.string.fixed.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('fixed');
+
 // `String.prototype.fixed` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.fixed
-require('../internals/string-html')('fixed', function (createHTML) {
-  return function fixed() {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  fixed: function fixed() {
     return createHTML(this, 'tt', '', '');
-  };
+  }
 });

package/modules/es.string.fontcolor.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('fontcolor');
+
 // `String.prototype.fontcolor` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.fontcolor
-require('../internals/string-html')('fontcolor', function (createHTML) {
-  return function fontcolor(color) {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  fontcolor: function fontcolor(color) {
     return createHTML(this, 'font', 'color', color);
-  };
+  }
 });

package/modules/es.string.fontsize.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('fontsize');
+
 // `String.prototype.fontsize` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.fontsize
-require('../internals/string-html')('fontsize', function (createHTML) {
-  return function fontsize(size) {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  fontsize: function fontsize(size) {
     return createHTML(this, 'font', 'size', size);
-  };
+  }
 });

package/modules/es.string.italics.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('italics');
+
 // `String.prototype.italics` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.italics
-require('../internals/string-html')('italics', function (createHTML) {
-  return function italics() {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  italics: function italics() {
     return createHTML(this, 'i', '', '');
-  };
+  }
 });

package/modules/es.string.iterator.js

@@ -1,5 +1,5 @@
 'use strict';
-var at = require('../internals/string-at')(true);
+var codePointAt = require('../internals/string-at');
 var InternalStateModule = require('../internals/internal-state');
 var defineIterator = require('../internals/define-iterator');
 var STRING_ITERATOR = 'String Iterator';
@@ -22,7 +22,7 @@ defineIterator(String, 'String', function (iterated) {
   var index = state.index;
   var point;
   if (index >= string.length) return { value: undefined, done: true };
-  point = at(string, index);
+  point = codePointAt(string, index, true);
   state.index += point.length;
   return { value: point, done: false };
 });

package/modules/es.string.link.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('link');
+
 // `String.prototype.link` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.link
-require('../internals/string-html')('link', function (createHTML) {
-  return function link(url) {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  link: function link(url) {
     return createHTML(this, 'a', 'href', url);
-  };
+  }
 });

package/modules/es.string.match.js

@@ -2,6 +2,7 @@
 
 var anObject = require('../internals/an-object');
 var toLength = require('../internals/to-length');
+var requireObjectCoercible = require('../internals/require-object-coercible');
 var advanceStringIndex = require('../internals/advance-string-index');
 var regExpExec = require('../internals/regexp-exec-abstract');
 
@@ -9,12 +10,12 @@ var regExpExec = require('../internals/regexp-exec-abstract');
 require('../internals/fix-regexp-well-known-symbol-logic')(
   'match',
   1,
-  function (defined, MATCH, nativeMatch, maybeCallNative) {
+  function (MATCH, nativeMatch, maybeCallNative) {
     return [
       // `String.prototype.match` method
       // https://tc39.github.io/ecma262/#sec-string.prototype.match
       function match(regexp) {
-        var O = defined(this);
+        var O = requireObjectCoercible(this);
         var matcher = regexp == undefined ? undefined : regexp[MATCH];
         return matcher !== undefined ? matcher.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));
       },

package/modules/es.string.replace.js

@@ -4,6 +4,7 @@ var anObject = require('../internals/an-object');
 var toObject = require('../internals/to-object');
 var toLength = require('../internals/to-length');
 var toInteger = require('../internals/to-integer');
+var requireObjectCoercible = require('../internals/require-object-coercible');
 var advanceStringIndex = require('../internals/advance-string-index');
 var regExpExec = require('../internals/regexp-exec-abstract');
 var max = Math.max;
@@ -20,12 +21,12 @@ var maybeToString = function (it) {
 require('../internals/fix-regexp-well-known-symbol-logic')(
   'replace',
   2,
-  function (defined, REPLACE, nativeReplace, maybeCallNative) {
+  function (REPLACE, nativeReplace, maybeCallNative) {
     return [
       // `String.prototype.replace` method
       // https://tc39.github.io/ecma262/#sec-string.prototype.replace
       function replace(searchValue, replaceValue) {
-        var O = defined(this);
+        var O = requireObjectCoercible(this);
         var replacer = searchValue == undefined ? undefined : searchValue[REPLACE];
         return replacer !== undefined
           ? replacer.call(searchValue, O, replaceValue)
@@ -112,12 +113,12 @@ require('../internals/fix-regexp-well-known-symbol-logic')(
             break;
           default: // \d\d?
             var n = +ch;
-            if (n === 0) return ch;
+            if (n === 0) return match;
             if (n > m) {
               var f = floor(n / 10);
-              if (f === 0) return ch;
+              if (f === 0) return match;
               if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1);
-              return ch;
+              return match;
             }
             capture = captures[n - 1];
         }

package/modules/es.string.search.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var anObject = require('../internals/an-object');
+var requireObjectCoercible = require('../internals/require-object-coercible');
 var sameValue = require('../internals/same-value');
 var regExpExec = require('../internals/regexp-exec-abstract');
 
@@ -8,12 +9,12 @@ var regExpExec = require('../internals/regexp-exec-abstract');
 require('../internals/fix-regexp-well-known-symbol-logic')(
   'search',
   1,
-  function (defined, SEARCH, nativeSearch, maybeCallNative) {
+  function (SEARCH, nativeSearch, maybeCallNative) {
     return [
       // `String.prototype.search` method
       // https://tc39.github.io/ecma262/#sec-string.prototype.search
       function search(regexp) {
-        var O = defined(this);
+        var O = requireObjectCoercible(this);
         var searcher = regexp == undefined ? undefined : regexp[SEARCH];
         return searcher !== undefined ? searcher.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O));
       },

package/modules/es.string.small.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('small');
+
 // `String.prototype.small` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.small
-require('../internals/string-html')('small', function (createHTML) {
-  return function small() {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  small: function small() {
     return createHTML(this, 'small', '', '');
-  };
+  }
 });

package/modules/es.string.split.js

@@ -2,39 +2,43 @@
 
 var isRegExp = require('../internals/is-regexp');
 var anObject = require('../internals/an-object');
+var requireObjectCoercible = require('../internals/require-object-coercible');
 var speciesConstructor = require('../internals/species-constructor');
 var advanceStringIndex = require('../internals/advance-string-index');
 var toLength = require('../internals/to-length');
 var callRegExpExec = require('../internals/regexp-exec-abstract');
 var regexpExec = require('../internals/regexp-exec');
+var fails = require('../internals/fails');
 var arrayPush = [].push;
 var min = Math.min;
-var LENGTH = 'length';
+var MAX_UINT32 = 0xffffffff;
 
-// eslint-disable-next-line no-empty
-var SUPPORTS_Y = !!(function () { try { return new RegExp('x', 'y'); } catch (e) {} })();
+// babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError
+var SUPPORTS_Y = !fails(function () { return !RegExp(MAX_UINT32, 'y'); });
 
 // @@split logic
 require('../internals/fix-regexp-well-known-symbol-logic')(
   'split',
   2,
-  function (defined, SPLIT, nativeSplit, maybeCallNative) {
+  function (SPLIT, nativeSplit, maybeCallNative) {
     var internalSplit;
     if (
       'abbc'.split(/(b)*/)[1] == 'c' ||
-      'test'.split(/(?:)/, -1)[LENGTH] != 4 ||
-      'ab'.split(/(?:ab)*/)[LENGTH] != 2 ||
-      '.'.split(/(.?)(.?)/)[LENGTH] != 4 ||
-      '.'.split(/()()/)[LENGTH] > 1 ||
-      ''.split(/.?/)[LENGTH]
+      'test'.split(/(?:)/, -1).length != 4 ||
+      'ab'.split(/(?:ab)*/).length != 2 ||
+      '.'.split(/(.?)(.?)/).length != 4 ||
+      '.'.split(/()()/).length > 1 ||
+      ''.split(/.?/).length
     ) {
       // based on es5-shim implementation, need to rework it
       internalSplit = function (separator, limit) {
-        var string = String(this);
-        if (separator === undefined && limit === 0) return [];
+        var string = String(requireObjectCoercible(this));
+        var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
+        if (lim === 0) return [];
+        if (separator === undefined) return [string];
         // If `separator` is not a regex, use native split
         if (!isRegExp(separator)) {
-          return nativeSplit.call(string, separator, limit !== undefined ? limit >>> 0 : 4294967295);
+          return nativeSplit.call(string, separator, lim);
         }
         var output = [];
         var flags = (separator.ignoreCase ? 'i' : '') +
@@ -42,7 +46,6 @@ require('../internals/fix-regexp-well-known-symbol-logic')(
                     (separator.unicode ? 'u' : '') +
                     (separator.sticky ? 'y' : '');
         var lastLastIndex = 0;
-        var splitLimit = limit === undefined ? 4294967295 : limit >>> 0;
         // Make `global` and avoid `lastIndex` issues by working with a copy
         var separatorCopy = new RegExp(separator.source, flags + 'g');
         var match, lastIndex, lastLength;
@@ -50,20 +53,20 @@ require('../internals/fix-regexp-well-known-symbol-logic')(
           lastIndex = separatorCopy.lastIndex;
           if (lastIndex > lastLastIndex) {
             output.push(string.slice(lastLastIndex, match.index));
-            if (match[LENGTH] > 1 && match.index < string[LENGTH]) arrayPush.apply(output, match.slice(1));
-            lastLength = match[0][LENGTH];
+            if (match.length > 1 && match.index < string.length) arrayPush.apply(output, match.slice(1));
+            lastLength = match[0].length;
             lastLastIndex = lastIndex;
-            if (output[LENGTH] >= splitLimit) break;
+            if (output.length >= lim) break;
           }
           if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop
         }
-        if (lastLastIndex === string[LENGTH]) {
+        if (lastLastIndex === string.length) {
           if (lastLength || !separatorCopy.test('')) output.push('');
         } else output.push(string.slice(lastLastIndex));
-        return output[LENGTH] > splitLimit ? output.slice(0, splitLimit) : output;
+        return output.length > lim ? output.slice(0, lim) : output;
       };
     // Chakra, V8
-    } else if ('0'.split(undefined, 0)[LENGTH]) {
+    } else if ('0'.split(undefined, 0).length) {
       internalSplit = function (separator, limit) {
         return separator === undefined && limit === 0 ? [] : nativeSplit.call(this, separator, limit);
       };
@@ -73,7 +76,7 @@ require('../internals/fix-regexp-well-known-symbol-logic')(
       // `String.prototype.split` method
       // https://tc39.github.io/ecma262/#sec-string.prototype.split
       function split(separator, limit) {
-        var O = defined(this);
+        var O = requireObjectCoercible(this);
         var splitter = separator == undefined ? undefined : separator[SPLIT];
         return splitter !== undefined
           ? splitter.call(separator, O, limit)
@@ -94,14 +97,14 @@ require('../internals/fix-regexp-well-known-symbol-logic')(
 
         var unicodeMatching = rx.unicode;
         var flags = (rx.ignoreCase ? 'i' : '') +
-                      (rx.multiline ? 'm' : '') +
-                      (rx.unicode ? 'u' : '') +
-                      (SUPPORTS_Y ? 'y' : 'g');
+                    (rx.multiline ? 'm' : '') +
+                    (rx.unicode ? 'u' : '') +
+                    (SUPPORTS_Y ? 'y' : 'g');
 
         // ^(? + rx + ) is needed, in combination with some S slicing, to
         // simulate the 'y' flag.
         var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags);
-        var lim = limit === undefined ? 0xffffffff : limit >>> 0;
+        var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
         if (lim === 0) return [];
         if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : [];
         var p = 0;

package/modules/es.string.strike.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('strike');
+
 // `String.prototype.strike` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.strike
-require('../internals/string-html')('strike', function (createHTML) {
-  return function strike() {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  strike: function strike() {
     return createHTML(this, 'strike', '', '');
-  };
+  }
 });

package/modules/es.string.sub.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('sub');
+
 // `String.prototype.sub` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.sub
-require('../internals/string-html')('sub', function (createHTML) {
-  return function sub() {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  sub: function sub() {
     return createHTML(this, 'sub', '', '');
-  };
+  }
 });

package/modules/es.string.sup.js

@@ -1,8 +1,11 @@
 'use strict';
+var createHTML = require('../internals/create-html');
+var FORCED = require('../internals/forced-string-html-method')('sup');
+
 // `String.prototype.sup` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.sup
-require('../internals/string-html')('sup', function (createHTML) {
-  return function sup() {
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  sup: function sup() {
     return createHTML(this, 'sup', '', '');
-  };
+  }
 });

package/modules/es.string.trim-end.js

@@ -0,0 +1,14 @@
+'use strict';
+var internalStringTrim = require('../internals/string-trim');
+var FORCED = require('../internals/forced-string-trim-method')('trimEnd');
+
+var trimEnd = FORCED ? function trimEnd() {
+  return internalStringTrim(this, 2);
+} : ''.trimEnd;
+
+// `String.prototype.{ trimEnd, trimRight }` methods
+// https://github.com/tc39/ecmascript-string-left-right-trim
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  trimEnd: trimEnd,
+  trimRight: trimEnd
+});

package/modules/es.string.trim-start.js

@@ -0,0 +1,14 @@
+'use strict';
+var internalStringTrim = require('../internals/string-trim');
+var FORCED = require('../internals/forced-string-trim-method')('trimStart');
+
+var trimStart = FORCED ? function trimStart() {
+  return internalStringTrim(this, 1);
+} : ''.trimStart;
+
+// `String.prototype.{ trimStart, trimLeft }` methods
+// https://github.com/tc39/ecmascript-string-left-right-trim
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  trimStart: trimStart,
+  trimLeft: trimStart
+});

package/modules/es.string.trim.js

@@ -1,8 +1,11 @@
 'use strict';
+var internalStringTrim = require('../internals/string-trim');
+var FORCED = require('../internals/forced-string-trim-method')('trim');
+
 // `String.prototype.trim` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.trim
-require('../internals/string-trim')('trim', function (internalTrim) {
-  return function trim() {
-    return internalTrim(this, 3);
-  };
+require('../internals/export')({ target: 'String', proto: true, forced: FORCED }, {
+  trim: function trim() {
+    return internalStringTrim(this, 3);
+  }
 });