core-js 3.1.3 → 3.3.0

package/modules/es.promise.finally.js

@@ -1,8 +1,11 @@
 'use strict';
 var $ = require('../internals/export');
+var IS_PURE = require('../internals/is-pure');
+var NativePromise = require('../internals/native-promise-constructor');
 var getBuiltIn = require('../internals/get-built-in');
 var speciesConstructor = require('../internals/species-constructor');
 var promiseResolve = require('../internals/promise-resolve');
+var redefine = require('../internals/redefine');
 
 // `Promise.prototype.finally` method
 // https://tc39.github.io/ecma262/#sec-promise.prototype.finally
@@ -20,3 +23,8 @@ $({ target: 'Promise', proto: true, real: true }, {
     );
   }
 });
+
+// patch native Promise.prototype for native async functions
+if (!IS_PURE && typeof NativePromise == 'function' && !NativePromise.prototype['finally']) {
+  redefine(NativePromise.prototype, 'finally', getBuiltIn('Promise').prototype['finally']);
+}

package/modules/es.promise.js

@@ -3,6 +3,8 @@ var $ = require('../internals/export');
 var IS_PURE = require('../internals/is-pure');
 var global = require('../internals/global');
 var path = require('../internals/path');
+var NativePromise = require('../internals/native-promise-constructor');
+var redefine = require('../internals/redefine');
 var redefineAll = require('../internals/redefine-all');
 var setToStringTag = require('../internals/set-to-string-tag');
 var setSpecies = require('../internals/set-species');
@@ -29,7 +31,7 @@ var PROMISE = 'Promise';
 var getInternalState = InternalStateModule.get;
 var setInternalState = InternalStateModule.set;
 var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
-var PromiseConstructor = global[PROMISE];
+var PromiseConstructor = NativePromise;
 var TypeError = global.TypeError;
 var document = global.document;
 var process = global.process;
@@ -47,7 +49,7 @@ var FULFILLED = 1;
 var REJECTED = 2;
 var HANDLED = 1;
 var UNHANDLED = 2;
-var Internal, OwnPromiseCapability, PromiseWrapper;
+var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
 
 var FORCED = isForced(PROMISE, function () {
   // correct subclassing with @@species support
@@ -84,8 +86,10 @@ var notify = function (promise, state, isReject) {
   microtask(function () {
     var value = state.value;
     var ok = state.state == FULFILLED;
-    var i = 0;
-    var run = function (reaction) {
+    var index = 0;
+    // variable length - can't use forEach
+    while (chain.length > index) {
+      var reaction = chain[index++];
       var handler = ok ? reaction.ok : reaction.fail;
       var resolve = reaction.resolve;
       var reject = reaction.reject;
@@ -100,7 +104,7 @@ var notify = function (promise, state, isReject) {
           if (handler === true) result = value;
           else {
             if (domain) domain.enter();
-            result = handler(value); // may throw
+            result = handler(value); // can throw
             if (domain) {
               domain.exit();
               exited = true;
@@ -116,8 +120,7 @@ var notify = function (promise, state, isReject) {
         if (domain && !exited) domain.exit();
         reject(error);
       }
-    };
-    while (chain.length > i) run(chain[i++]); // variable length - can't use forEach
+    }
     state.reactions = [];
     state.notified = false;
     if (isReject && !state.rejection) onUnhandled(promise, state);
@@ -271,13 +274,26 @@ if (FORCED) {
       : newGenericPromiseCapability(C);
   };
 
-  // wrap fetch result
-  if (!IS_PURE && typeof $fetch == 'function') $({ global: true, enumerable: true, forced: true }, {
-    // eslint-disable-next-line no-unused-vars
-    fetch: function fetch(input) {
-      return promiseResolve(PromiseConstructor, $fetch.apply(global, arguments));
-    }
-  });
+  if (!IS_PURE && typeof NativePromise == 'function') {
+    nativeThen = NativePromise.prototype.then;
+
+    // wrap native Promise#then for native async functions
+    redefine(NativePromise.prototype, 'then', function then(onFulfilled, onRejected) {
+      var that = this;
+      return new PromiseConstructor(function (resolve, reject) {
+        nativeThen.call(that, resolve, reject);
+      }).then(onFulfilled, onRejected);
+    // https://github.com/zloirock/core-js/issues/640
+    }, { unsafe: true });
+
+    // wrap fetch result
+    if (typeof $fetch == 'function') $({ global: true, enumerable: true, forced: true }, {
+      // eslint-disable-next-line no-unused-vars
+      fetch: function fetch(input) {
+        return promiseResolve(PromiseConstructor, $fetch.apply(global, arguments));
+      }
+    });
+  }
 }
 
 $({ global: true, wrap: true, forced: FORCED }, {

package/modules/es.reflect.apply.js

@@ -1,10 +1,10 @@
 var $ = require('../internals/export');
-var global = require('../internals/global');
+var getBuiltIn = require('../internals/get-built-in');
 var aFunction = require('../internals/a-function');
 var anObject = require('../internals/an-object');
 var fails = require('../internals/fails');
 
-var nativeApply = (global.Reflect || {}).apply;
+var nativeApply = getBuiltIn('Reflect', 'apply');
 var functionApply = Function.apply;
 
 // MS Edge argumentsList argument is optional

package/modules/es.reflect.construct.js

@@ -1,13 +1,13 @@
 var $ = require('../internals/export');
-var global = require('../internals/global');
-var create = require('../internals/object-create');
+var getBuiltIn = require('../internals/get-built-in');
 var aFunction = require('../internals/a-function');
 var anObject = require('../internals/an-object');
 var isObject = require('../internals/is-object');
-var fails = require('../internals/fails');
+var create = require('../internals/object-create');
 var bind = require('../internals/function-bind');
+var fails = require('../internals/fails');
 
-var nativeConstruct = (global.Reflect || {}).construct;
+var nativeConstruct = getBuiltIn('Reflect', 'construct');
 
 // `Reflect.construct` method
 // https://tc39.github.io/ecma262/#sec-reflect.construct

package/modules/es.reflect.define-property.js

@@ -1,9 +1,9 @@
 var $ = require('../internals/export');
-var fails = require('../internals/fails');
-var definePropertyModule = require('../internals/object-define-property');
+var DESCRIPTORS = require('../internals/descriptors');
 var anObject = require('../internals/an-object');
 var toPrimitive = require('../internals/to-primitive');
-var DESCRIPTORS = require('../internals/descriptors');
+var definePropertyModule = require('../internals/object-define-property');
+var fails = require('../internals/fails');
 
 // MS Edge has broken Reflect.defineProperty - throwing instead of returning false
 var ERROR_INSTEAD_OF_FALSE = fails(function () {
@@ -16,10 +16,10 @@ var ERROR_INSTEAD_OF_FALSE = fails(function () {
 $({ target: 'Reflect', stat: true, forced: ERROR_INSTEAD_OF_FALSE, sham: !DESCRIPTORS }, {
   defineProperty: function defineProperty(target, propertyKey, attributes) {
     anObject(target);
-    propertyKey = toPrimitive(propertyKey, true);
+    var key = toPrimitive(propertyKey, true);
     anObject(attributes);
     try {
-      definePropertyModule.f(target, propertyKey, attributes);
+      definePropertyModule.f(target, key, attributes);
       return true;
     } catch (error) {
       return false;

package/modules/es.reflect.delete-property.js

@@ -1,6 +1,6 @@
 var $ = require('../internals/export');
-var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
 var anObject = require('../internals/an-object');
+var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;
 
 // `Reflect.deleteProperty` method
 // https://tc39.github.io/ecma262/#sec-reflect.deleteproperty

package/modules/es.reflect.get-own-property-descriptor.js

@@ -1,7 +1,7 @@
 var $ = require('../internals/export');
-var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
-var anObject = require('../internals/an-object');
 var DESCRIPTORS = require('../internals/descriptors');
+var anObject = require('../internals/an-object');
+var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
 
 // `Reflect.getOwnPropertyDescriptor` method
 // https://tc39.github.io/ecma262/#sec-reflect.getownpropertydescriptor

package/modules/es.reflect.get-prototype-of.js

@@ -1,6 +1,6 @@
 var $ = require('../internals/export');
-var objectGetPrototypeOf = require('../internals/object-get-prototype-of');
 var anObject = require('../internals/an-object');
+var objectGetPrototypeOf = require('../internals/object-get-prototype-of');
 var CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');
 
 // `Reflect.getPrototypeOf` method

package/modules/es.reflect.get.js

@@ -1,9 +1,9 @@
 var $ = require('../internals/export');
-var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
-var getPrototypeOf = require('../internals/object-get-prototype-of');
-var has = require('../internals/has');
 var isObject = require('../internals/is-object');
 var anObject = require('../internals/an-object');
+var has = require('../internals/has');
+var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
+var getPrototypeOf = require('../internals/object-get-prototype-of');
 
 // `Reflect.get` method
 // https://tc39.github.io/ecma262/#sec-reflect.get

package/modules/es.reflect.set-prototype-of.js

@@ -1,12 +1,14 @@
 var $ = require('../internals/export');
+var anObject = require('../internals/an-object');
+var aPossiblePrototype = require('../internals/a-possible-prototype');
 var objectSetPrototypeOf = require('../internals/object-set-prototype-of');
-var validateSetPrototypeOfArguments = require('../internals/validate-set-prototype-of-arguments');
 
 // `Reflect.setPrototypeOf` method
 // https://tc39.github.io/ecma262/#sec-reflect.setprototypeof
 if (objectSetPrototypeOf) $({ target: 'Reflect', stat: true }, {
   setPrototypeOf: function setPrototypeOf(target, proto) {
-    validateSetPrototypeOfArguments(target, proto);
+    anObject(target);
+    aPossiblePrototype(proto);
     try {
       objectSetPrototypeOf(target, proto);
       return true;

package/modules/es.reflect.set.js

@@ -1,11 +1,11 @@
 var $ = require('../internals/export');
+var anObject = require('../internals/an-object');
+var isObject = require('../internals/is-object');
+var has = require('../internals/has');
 var definePropertyModule = require('../internals/object-define-property');
 var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');
 var getPrototypeOf = require('../internals/object-get-prototype-of');
-var has = require('../internals/has');
 var createPropertyDescriptor = require('../internals/create-property-descriptor');
-var anObject = require('../internals/an-object');
-var isObject = require('../internals/is-object');
 
 // `Reflect.set` method
 // https://tc39.github.io/ecma262/#sec-reflect.set

package/modules/es.regexp.constructor.js

@@ -20,7 +20,7 @@ var re2 = /a/g;
 // "new" should create a new object, old webkit bug
 var CORRECT_NEW = new NativeRegExp(re1) !== re1;
 
-var FORCED = isForced('RegExp', DESCRIPTORS && (!CORRECT_NEW || fails(function () {
+var FORCED = DESCRIPTORS && isForced('RegExp', (!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';
@@ -49,8 +49,8 @@ if (FORCED) {
     });
   };
   var keys = getOwnPropertyNames(NativeRegExp);
-  var i = 0;
-  while (i < keys.length) proxy(keys[i++]);
+  var index = 0;
+  while (keys.length > index) proxy(keys[index++]);
   RegExpPrototype.constructor = RegExpWrapper;
   RegExpWrapper.prototype = RegExpPrototype;
   redefine(global, 'RegExp', RegExpWrapper);

package/modules/es.regexp.to-string.js

@@ -5,8 +5,8 @@ var fails = require('../internals/fails');
 var flags = require('../internals/regexp-flags');
 
 var TO_STRING = 'toString';
-var nativeToString = /./[TO_STRING];
 var RegExpPrototype = RegExp.prototype;
+var nativeToString = RegExpPrototype[TO_STRING];
 
 var NOT_GENERIC = fails(function () { return nativeToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
 // FF44- RegExp#toString has a wrong name

package/modules/es.set.js

@@ -5,5 +5,5 @@ var collectionStrong = require('../internals/collection-strong');
 // `Set` constructor
 // https://tc39.github.io/ecma262/#sec-set-objects
 module.exports = collection('Set', function (get) {
-  return function Set() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
+  return function Set() { return get(this, arguments.length ? arguments[0] : undefined); };
 }, collectionStrong);

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

@@ -1,11 +1,11 @@
 'use strict';
 var $ = require('../internals/export');
-var internalCodePointAt = require('../internals/string-at');
+var codeAt = require('../internals/string-multibyte').codeAt;
 
 // `String.prototype.codePointAt` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat
 $({ target: 'String', proto: true }, {
   codePointAt: function codePointAt(pos) {
-    return internalCodePointAt(this, pos);
+    return codeAt(this, pos);
   }
 });

package/modules/es.string.ends-with.js

@@ -1,18 +1,19 @@
 'use strict';
 var $ = require('../internals/export');
 var toLength = require('../internals/to-length');
-var validateArguments = require('../internals/validate-string-method-arguments');
+var notARegExp = require('../internals/not-a-regexp');
+var requireObjectCoercible = require('../internals/require-object-coercible');
 var correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');
 
-var ENDS_WITH = 'endsWith';
-var nativeEndsWith = ''[ENDS_WITH];
+var nativeEndsWith = ''.endsWith;
 var min = Math.min;
 
 // `String.prototype.endsWith` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.endswith
-$({ target: 'String', proto: true, forced: !correctIsRegExpLogic(ENDS_WITH) }, {
+$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('endsWith') }, {
   endsWith: function endsWith(searchString /* , endPosition = @length */) {
-    var that = validateArguments(this, searchString, ENDS_WITH);
+    var that = String(requireObjectCoercible(this));
+    notARegExp(searchString);
     var endPosition = arguments.length > 1 ? arguments[1] : undefined;
     var len = toLength(that.length);
     var end = endPosition === undefined ? len : min(toLength(endPosition), len);

package/modules/es.string.includes.js

@@ -1,13 +1,14 @@
 'use strict';
 var $ = require('../internals/export');
-var validateArguments = require('../internals/validate-string-method-arguments');
+var notARegExp = require('../internals/not-a-regexp');
+var requireObjectCoercible = require('../internals/require-object-coercible');
 var correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');
 
 // `String.prototype.includes` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.includes
 $({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, {
   includes: function includes(searchString /* , position = 0 */) {
-    return !!~validateArguments(this, searchString, 'includes')
-      .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);
+    return !!~String(requireObjectCoercible(this))
+      .indexOf(notARegExp(searchString), arguments.length > 1 ? arguments[1] : undefined);
   }
 });

package/modules/es.string.iterator.js

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

package/modules/es.string.match-all.js

@@ -6,8 +6,10 @@ var toLength = require('../internals/to-length');
 var aFunction = require('../internals/a-function');
 var anObject = require('../internals/an-object');
 var classof = require('../internals/classof');
-var getFlags = require('../internals/regexp-flags');
-var hide = require('../internals/hide');
+var isRegExp = require('../internals/is-regexp');
+var getRegExpFlags = require('../internals/regexp-flags');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var fails = require('../internals/fails');
 var wellKnownSymbol = require('../internals/well-known-symbol');
 var speciesConstructor = require('../internals/species-constructor');
 var advanceStringIndex = require('../internals/advance-string-index');
@@ -21,6 +23,11 @@ var setInternalState = InternalStateModule.set;
 var getInternalState = InternalStateModule.getterFor(REGEXP_STRING_ITERATOR);
 var RegExpPrototype = RegExp.prototype;
 var regExpBuiltinExec = RegExpPrototype.exec;
+var nativeMatchAll = ''.matchAll;
+
+var WORKS_WITH_NON_GLOBAL_REGEX = !!nativeMatchAll && !fails(function () {
+  'a'.matchAll(/./);
+});
 
 var regExpExec = function (R, S) {
   var exec = R.exec;
@@ -64,7 +71,7 @@ var $matchAll = function (string) {
   C = speciesConstructor(R, RegExp);
   flagsValue = R.flags;
   if (flagsValue === undefined && R instanceof RegExp && !('flags' in RegExpPrototype)) {
-    flagsValue = getFlags.call(R);
+    flagsValue = getRegExpFlags.call(R);
   }
   flags = flagsValue === undefined ? '' : String(flagsValue);
   matcher = new C(C === RegExp ? R.source : R, flags);
@@ -76,19 +83,27 @@ var $matchAll = function (string) {
 
 // `String.prototype.matchAll` method
 // https://github.com/tc39/proposal-string-matchall
-$({ target: 'String', proto: true }, {
+$({ target: 'String', proto: true, forced: WORKS_WITH_NON_GLOBAL_REGEX }, {
   matchAll: function matchAll(regexp) {
     var O = requireObjectCoercible(this);
-    var S, matcher, rx;
+    var flags, S, matcher, rx;
     if (regexp != null) {
+      if (isRegExp(regexp)) {
+        flags = String(requireObjectCoercible('flags' in RegExpPrototype
+          ? regexp.flags
+          : getRegExpFlags.call(regexp)
+        ));
+        if (!~flags.indexOf('g')) throw TypeError('`.matchAll` does not allow non-global regexes');
+      }
+      if (WORKS_WITH_NON_GLOBAL_REGEX) return nativeMatchAll.apply(O, arguments);
       matcher = regexp[MATCH_ALL];
       if (matcher === undefined && IS_PURE && classof(regexp) == 'RegExp') matcher = $matchAll;
       if (matcher != null) return aFunction(matcher).call(regexp, O);
-    }
+    } else if (WORKS_WITH_NON_GLOBAL_REGEX) return nativeMatchAll.apply(O, arguments);
     S = String(O);
     rx = new RegExp(regexp, 'g');
     return IS_PURE ? $matchAll.call(rx, S) : rx[MATCH_ALL](S);
   }
 });
 
-IS_PURE || MATCH_ALL in RegExpPrototype || hide(RegExpPrototype, MATCH_ALL, $matchAll);
+IS_PURE || MATCH_ALL in RegExpPrototype || createNonEnumerableProperty(RegExpPrototype, MATCH_ALL, $matchAll);

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

@@ -1,12 +1,12 @@
 'use strict';
 var $ = require('../internals/export');
-var internalStringPad = require('../internals/string-pad');
+var $padEnd = require('../internals/string-pad').end;
 var WEBKIT_BUG = require('../internals/webkit-string-pad-bug');
 
 // `String.prototype.padEnd` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.padend
 $({ target: 'String', proto: true, forced: WEBKIT_BUG }, {
   padEnd: function padEnd(maxLength /* , fillString = ' ' */) {
-    return internalStringPad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false);
+    return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
   }
 });

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

@@ -1,12 +1,12 @@
 'use strict';
 var $ = require('../internals/export');
-var internalStringPad = require('../internals/string-pad');
+var $padStart = require('../internals/string-pad').start;
 var WEBKIT_BUG = require('../internals/webkit-string-pad-bug');
 
 // `String.prototype.padStart` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.padstart
 $({ target: 'String', proto: true, forced: WEBKIT_BUG }, {
   padStart: function padStart(maxLength /* , fillString = ' ' */) {
-    return internalStringPad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true);
+    return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
   }
 });

package/modules/es.string.starts-with.js

@@ -1,18 +1,20 @@
 'use strict';
 var $ = require('../internals/export');
 var toLength = require('../internals/to-length');
-var validateArguments = require('../internals/validate-string-method-arguments');
+var notARegExp = require('../internals/not-a-regexp');
+var requireObjectCoercible = require('../internals/require-object-coercible');
 var correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');
 
-var STARTS_WITH = 'startsWith';
-var nativeStartsWith = ''[STARTS_WITH];
+var nativeStartsWith = ''.startsWith;
+var min = Math.min;
 
 // `String.prototype.startsWith` method
 // https://tc39.github.io/ecma262/#sec-string.prototype.startswith
-$({ target: 'String', proto: true, forced: !correctIsRegExpLogic(STARTS_WITH) }, {
+$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('startsWith') }, {
   startsWith: function startsWith(searchString /* , position = 0 */) {
-    var that = validateArguments(this, searchString, STARTS_WITH);
-    var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length));
+    var that = String(requireObjectCoercible(this));
+    notARegExp(searchString);
+    var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));
     var search = String(searchString);
     return nativeStartsWith
       ? nativeStartsWith.call(that, search, index)

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

@@ -1,12 +1,12 @@
 'use strict';
 var $ = require('../internals/export');
-var internalStringTrim = require('../internals/string-trim');
+var $trimEnd = require('../internals/string-trim').end;
 var forcedStringTrimMethod = require('../internals/forced-string-trim-method');
 
 var FORCED = forcedStringTrimMethod('trimEnd');
 
 var trimEnd = FORCED ? function trimEnd() {
-  return internalStringTrim(this, 2);
+  return $trimEnd(this);
 } : ''.trimEnd;
 
 // `String.prototype.{ trimEnd, trimRight }` methods

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

@@ -1,12 +1,12 @@
 'use strict';
 var $ = require('../internals/export');
-var internalStringTrim = require('../internals/string-trim');
+var $trimStart = require('../internals/string-trim').start;
 var forcedStringTrimMethod = require('../internals/forced-string-trim-method');
 
 var FORCED = forcedStringTrimMethod('trimStart');
 
 var trimStart = FORCED ? function trimStart() {
-  return internalStringTrim(this, 1);
+  return $trimStart(this);
 } : ''.trimStart;
 
 // `String.prototype.{ trimStart, trimLeft }` methods

package/modules/es.string.trim.js

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