core-js 3.14.0 → 3.15.0

package/es/date/get-year.js

@@ -0,0 +1,4 @@
+require('../../modules/es.date.get-year');
+var entryUnbind = require('../../internals/entry-unbind');
+
+module.exports = entryUnbind('Date', 'getYear');

package/es/date/index.js

@@ -1,6 +1,9 @@
+require('../../modules/es.date.get-year');
 require('../../modules/es.date.now');
-require('../../modules/es.date.to-json');
+require('../../modules/es.date.set-year');
+require('../../modules/es.date.to-gmt-string');
 require('../../modules/es.date.to-iso-string');
+require('../../modules/es.date.to-json');
 require('../../modules/es.date.to-string');
 require('../../modules/es.date.to-primitive');
 var path = require('../../internals/path');

package/es/date/set-year.js

@@ -0,0 +1,4 @@
+require('../../modules/es.date.set-year');
+var entryUnbind = require('../../internals/entry-unbind');
+
+module.exports = entryUnbind('Date', 'setYear');

package/es/date/to-gmt-string.js

@@ -0,0 +1,4 @@
+require('../../modules/es.date.to-gmt-string');
+var entryUnbind = require('../../internals/entry-unbind');
+
+module.exports = entryUnbind('Date', 'toGMTString');

package/es/escape.js

@@ -0,0 +1,4 @@
+require('../modules/es.escape');
+var global = require('../internals/global');
+
+module.exports = global.escape;

package/es/index.js

@@ -47,11 +47,15 @@ require('../modules/es.array-buffer.constructor');
 require('../modules/es.array-buffer.is-view');
 require('../modules/es.array-buffer.slice');
 require('../modules/es.data-view');
+require('../modules/es.date.get-year');
 require('../modules/es.date.now');
+require('../modules/es.date.set-year');
+require('../modules/es.date.to-gmt-string');
 require('../modules/es.date.to-iso-string');
 require('../modules/es.date.to-json');
 require('../modules/es.date.to-primitive');
 require('../modules/es.date.to-string');
+require('../modules/es.escape');
 require('../modules/es.function.bind');
 require('../modules/es.function.has-instance');
 require('../modules/es.function.name');
@@ -135,6 +139,7 @@ require('../modules/es.reflect.set');
 require('../modules/es.reflect.set-prototype-of');
 require('../modules/es.reflect.to-string-tag');
 require('../modules/es.regexp.constructor');
+require('../modules/es.regexp.dot-all');
 require('../modules/es.regexp.exec');
 require('../modules/es.regexp.flags');
 require('../modules/es.regexp.sticky');
@@ -157,6 +162,7 @@ require('../modules/es.string.replace-all');
 require('../modules/es.string.search');
 require('../modules/es.string.split');
 require('../modules/es.string.starts-with');
+require('../modules/es.string.substr');
 require('../modules/es.string.trim');
 require('../modules/es.string.trim-end');
 require('../modules/es.string.trim-start');
@@ -207,6 +213,7 @@ require('../modules/es.typed-array.sort');
 require('../modules/es.typed-array.subarray');
 require('../modules/es.typed-array.to-locale-string');
 require('../modules/es.typed-array.to-string');
+require('../modules/es.unescape');
 require('../modules/es.weak-map');
 require('../modules/es.weak-set');
 

package/es/regexp/dot-all.js

@@ -0,0 +1,7 @@
+require('../../modules/es.regexp.constructor');
+require('../../modules/es.regexp.dot-all');
+require('../../modules/es.regexp.exec');
+
+module.exports = function (it) {
+  return it.dotAll;
+};

package/es/regexp/index.js

@@ -1,5 +1,6 @@
 require('../../modules/es.regexp.constructor');
 require('../../modules/es.regexp.to-string');
+require('../../modules/es.regexp.dot-all');
 require('../../modules/es.regexp.exec');
 require('../../modules/es.regexp.flags');
 require('../../modules/es.regexp.sticky');

package/es/regexp/sticky.js

@@ -1,3 +1,5 @@
+require('../../modules/es.regexp.constructor');
+require('../../modules/es.regexp.exec');
 require('../../modules/es.regexp.sticky');
 
 module.exports = function (it) {

package/es/string/index.js

@@ -14,6 +14,7 @@ require('../../modules/es.string.replace-all');
 require('../../modules/es.string.search');
 require('../../modules/es.string.split');
 require('../../modules/es.string.starts-with');
+require('../../modules/es.string.substr');
 require('../../modules/es.string.trim');
 require('../../modules/es.string.trim-start');
 require('../../modules/es.string.trim-end');

package/es/string/substr.js

@@ -0,0 +1,4 @@
+require('../../modules/es.string.substr');
+var entryUnbind = require('../../internals/entry-unbind');
+
+module.exports = entryUnbind('String', 'substr');

package/es/string/virtual/index.js

@@ -11,6 +11,7 @@ require('../../../modules/es.string.replace-all');
 require('../../../modules/es.string.search');
 require('../../../modules/es.string.split');
 require('../../../modules/es.string.starts-with');
+require('../../../modules/es.string.substr');
 require('../../../modules/es.string.trim');
 require('../../../modules/es.string.trim-start');
 require('../../../modules/es.string.trim-end');

package/es/string/virtual/substr.js

@@ -0,0 +1,4 @@
+require('../../../modules/es.string.substr');
+var entryVirtual = require('../../../internals/entry-virtual');
+
+module.exports = entryVirtual('String').substr;

package/es/unescape.js

@@ -0,0 +1,4 @@
+require('../modules/es.unescape');
+var global = require('../internals/global');
+
+module.exports = global.unescape;

package/features/date/get-year.js

@@ -0,0 +1,3 @@
+var parent = require('../../stable/date/get-year');
+
+module.exports = parent;

package/features/date/set-year.js

@@ -0,0 +1,3 @@
+var parent = require('../../stable/date/set-year');
+
+module.exports = parent;

package/features/date/to-gmt-string.js

@@ -0,0 +1,3 @@
+var parent = require('../../stable/date/to-gmt-string');
+
+module.exports = parent;

package/features/escape.js

@@ -0,0 +1,3 @@
+var parent = require('../stable/escape');
+
+module.exports = parent;

package/features/index.js

@@ -47,11 +47,15 @@ require('../modules/es.array-buffer.constructor');
 require('../modules/es.array-buffer.is-view');
 require('../modules/es.array-buffer.slice');
 require('../modules/es.data-view');
+require('../modules/es.date.get-year');
 require('../modules/es.date.now');
+require('../modules/es.date.set-year');
+require('../modules/es.date.to-gmt-string');
 require('../modules/es.date.to-iso-string');
 require('../modules/es.date.to-json');
 require('../modules/es.date.to-primitive');
 require('../modules/es.date.to-string');
+require('../modules/es.escape');
 require('../modules/es.function.bind');
 require('../modules/es.function.has-instance');
 require('../modules/es.function.name');
@@ -135,6 +139,7 @@ require('../modules/es.reflect.set');
 require('../modules/es.reflect.set-prototype-of');
 require('../modules/es.reflect.to-string-tag');
 require('../modules/es.regexp.constructor');
+require('../modules/es.regexp.dot-all');
 require('../modules/es.regexp.exec');
 require('../modules/es.regexp.flags');
 require('../modules/es.regexp.sticky');
@@ -157,6 +162,7 @@ require('../modules/es.string.replace-all');
 require('../modules/es.string.search');
 require('../modules/es.string.split');
 require('../modules/es.string.starts-with');
+require('../modules/es.string.substr');
 require('../modules/es.string.trim');
 require('../modules/es.string.trim-end');
 require('../modules/es.string.trim-start');
@@ -207,6 +213,7 @@ require('../modules/es.typed-array.sort');
 require('../modules/es.typed-array.subarray');
 require('../modules/es.typed-array.to-locale-string');
 require('../modules/es.typed-array.to-string');
+require('../modules/es.unescape');
 require('../modules/es.weak-map');
 require('../modules/es.weak-set');
 require('../modules/esnext.aggregate-error');

package/features/regexp/dot-all.js

@@ -0,0 +1,3 @@
+var parent = require('../../stable/regexp/dot-all');
+
+module.exports = parent;

package/features/string/substr.js

@@ -0,0 +1,3 @@
+var parent = require('../../stable/string/substr');
+
+module.exports = parent;

package/features/string/virtual/substr.js

@@ -0,0 +1,3 @@
+var parent = require('../../../stable/string/virtual/substr');
+
+module.exports = parent;

package/features/unescape.js

@@ -0,0 +1,3 @@
+var parent = require('../stable/unescape');
+
+module.exports = parent;

package/internals/fix-regexp-well-known-symbol-logic.js

@@ -10,47 +10,7 @@ var createNonEnumerableProperty = require('../internals/create-non-enumerable-pr
 var SPECIES = wellKnownSymbol('species');
 var RegExpPrototype = RegExp.prototype;
 
-var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
-  // #replace needs built-in support for named groups.
-  // #match works fine because it just return the exec results, even if it has
-  // a "grops" property.
-  var re = /./;
-  re.exec = function () {
-    var result = [];
-    result.groups = { a: '7' };
-    return result;
-  };
-  return ''.replace(re, '$<a>') !== '7';
-});
-
-// IE <= 11 replaces $0 with the whole match, as if it was $&
-// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
-var REPLACE_KEEPS_$0 = (function () {
-  // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing
-  return 'a'.replace(/./, '$0') === '$0';
-})();
-
-var REPLACE = wellKnownSymbol('replace');
-// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string
-var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
-  if (/./[REPLACE]) {
-    return /./[REPLACE]('a', '$0') === '';
-  }
-  return false;
-})();
-
-// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
-// Weex JS has frozen built-in prototypes, so use try / catch wrapper
-var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
-  // eslint-disable-next-line regexp/no-empty-group -- required for testing
-  var re = /(?:)/;
-  var originalExec = re.exec;
-  re.exec = function () { return originalExec.apply(this, arguments); };
-  var result = 'ab'.split(re);
-  return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
-});
-
-module.exports = function (KEY, length, exec, sham) {
+module.exports = function (KEY, exec, FORCED, SHAM) {
   var SYMBOL = wellKnownSymbol(KEY);
 
   var DELEGATES_TO_SYMBOL = !fails(function () {
@@ -87,12 +47,7 @@ module.exports = function (KEY, length, exec, sham) {
   if (
     !DELEGATES_TO_SYMBOL ||
     !DELEGATES_TO_EXEC ||
-    (KEY === 'replace' && !(
-      REPLACE_SUPPORTS_NAMED_GROUPS &&
-      REPLACE_KEEPS_$0 &&
-      !REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE
-    )) ||
-    (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)
+    FORCED
   ) {
     var nativeRegExpMethod = /./[SYMBOL];
     var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
@@ -107,23 +62,11 @@ module.exports = function (KEY, length, exec, sham) {
         return { done: true, value: nativeMethod.call(str, regexp, arg2) };
       }
       return { done: false };
-    }, {
-      REPLACE_KEEPS_$0: REPLACE_KEEPS_$0,
-      REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE: REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE
     });
-    var stringMethod = methods[0];
-    var regexMethod = methods[1];
 
-    redefine(String.prototype, KEY, stringMethod);
-    redefine(RegExpPrototype, SYMBOL, length == 2
-      // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)
-      // 21.2.5.11 RegExp.prototype[@@split](string, limit)
-      ? function (string, arg) { return regexMethod.call(string, this, arg); }
-      // 21.2.5.6 RegExp.prototype[@@match](string)
-      // 21.2.5.9 RegExp.prototype[@@search](string)
-      : function (string) { return regexMethod.call(string, this); }
-    );
+    redefine(String.prototype, KEY, methods[0]);
+    redefine(RegExpPrototype, SYMBOL, methods[1]);
   }
 
-  if (sham) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
+  if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
 };

package/internals/regexp-exec.js

@@ -1,9 +1,13 @@
 'use strict';
 /* eslint-disable regexp/no-assertion-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
 /* eslint-disable regexp/no-useless-quantifier -- testing */
-var regexpFlags = require('./regexp-flags');
-var stickyHelpers = require('./regexp-sticky-helpers');
-var shared = require('./shared');
+var regexpFlags = require('../internals/regexp-flags');
+var stickyHelpers = require('../internals/regexp-sticky-helpers');
+var shared = require('../internals/shared');
+var create = require('../internals/object-create');
+var getInternalState = require('../internals/internal-state').get;
+var UNSUPPORTED_DOT_ALL = require('../internals/regexp-unsupported-dot-all');
+var UNSUPPORTED_NCG = require('../internals/regexp-unsupported-ncg');
 
 var nativeExec = RegExp.prototype.exec;
 var nativeReplace = shared('native-string-replace', String.prototype.replace);
@@ -23,12 +27,24 @@ var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y || stickyHelpers.BROKEN_CARET;
 // nonparticipating capturing group, copied from es5-shim's String#split patch.
 var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
 
-var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y;
+var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
 
 if (PATCH) {
+  // eslint-disable-next-line max-statements -- TODO
   patchedExec = function exec(str) {
     var re = this;
-    var lastIndex, reCopy, match, i;
+    var state = getInternalState(re);
+    var raw = state.raw;
+    var result, reCopy, lastIndex, match, i, object, group;
+
+    if (raw) {
+      raw.lastIndex = re.lastIndex;
+      result = patchedExec.call(raw, str);
+      re.lastIndex = raw.lastIndex;
+      return result;
+    }
+
+    var groups = state.groups;
     var sticky = UNSUPPORTED_Y && re.sticky;
     var flags = regexpFlags.call(re);
     var source = re.source;
@@ -80,6 +96,14 @@ if (PATCH) {
       });
     }
 
+    if (match && groups) {
+      match.groups = object = create(null);
+      for (i = 0; i < groups.length; i++) {
+        group = groups[i];
+        object[group[0]] = match[group[1]];
+      }
+    }
+
     return match;
   };
 }

package/internals/regexp-sticky-helpers.js

@@ -1,15 +1,11 @@
-'use strict';
-
-var fails = require('./fails');
+var fails = require('../internals/fails');
 
 // babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError,
-// so we use an intermediate function.
-function RE(s, f) {
+var RE = function (s, f) {
   return RegExp(s, f);
-}
+};
 
 exports.UNSUPPORTED_Y = fails(function () {
-  // babel-minify transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
   var re = RE('a', 'y');
   re.lastIndex = 2;
   return re.exec('abcd') != null;

package/internals/regexp-unsupported-dot-all.js

@@ -0,0 +1,7 @@
+var fails = require('./fails');
+
+module.exports = fails(function () {
+  // babel-minify transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
+  var re = RegExp('.', (typeof '').charAt(0));
+  return !(re.dotAll && re.exec('\n') && re.flags === 's');
+});

package/internals/regexp-unsupported-ncg.js

@@ -0,0 +1,8 @@
+var fails = require('./fails');
+
+module.exports = fails(function () {
+  // babel-minify transpiles RegExp('.', 'g') -> /./g and it causes SyntaxError
+  var re = RegExp('(?<a>b)', (typeof '').charAt(5));
+  return re.exec('b').groups.a !== 'b' ||
+    'b'.replace(re, '$<a>c') !== 'bc';
+});

package/internals/shared.js

@@ -4,7 +4,7 @@ var store = require('../internals/shared-store');
 (module.exports = function (key, value) {
   return store[key] || (store[key] = value !== undefined ? value : {});
 })('versions', []).push({
-  version: '3.14.0',
+  version: '3.15.0',
   mode: IS_PURE ? 'pure' : 'global',
   copyright: '© 2021 Denis Pushkarev (zloirock.ru)'
 });

package/modules/es.date.get-year.js

@@ -0,0 +1,12 @@
+'use strict';
+var $ = require('../internals/export');
+
+var getFullYear = Date.prototype.getFullYear;
+
+// `Date.prototype.getYear` method
+// https://tc39.es/ecma262/#sec-date.prototype.getyear
+$({ target: 'Date', proto: true }, {
+  getYear: function getYear() {
+    return getFullYear.call(this) - 1900;
+  }
+});

package/modules/es.date.set-year.js

@@ -0,0 +1,18 @@
+'use strict';
+var $ = require('../internals/export');
+var toInteger = require('../internals/to-integer');
+
+var getTime = Date.prototype.getTime;
+var setFullYear = Date.prototype.setFullYear;
+
+// `Date.prototype.setYear` method
+// https://tc39.es/ecma262/#sec-date.prototype.setyear
+$({ target: 'Date', proto: true }, {
+  setYear: function setYear(year) {
+    // validate
+    getTime.call(this);
+    var yi = toInteger(year);
+    var yyyy = 0 <= yi && yi <= 99 ? yi + 1900 : yi;
+    return setFullYear.call(this, yyyy);
+  }
+});

package/modules/es.date.to-gmt-string.js

@@ -0,0 +1,7 @@
+var $ = require('../internals/export');
+
+// `Date.prototype.toGMTString` method
+// https://tc39.es/ecma262/#sec-date.prototype.togmtstring
+$({ target: 'Date', proto: true }, {
+  toGMTString: Date.prototype.toUTCString
+});

package/modules/es.escape.js

@@ -0,0 +1,35 @@
+'use strict';
+var $ = require('../internals/export');
+
+var raw = /[\w*+\-./@]/;
+
+var hex = function (code, length) {
+  var result = code.toString(16);
+  while (result.length < length) result = '0' + result;
+  return result;
+};
+
+// `escape` method
+// https://tc39.es/ecma262/#sec-escape-string
+$({ global: true }, {
+  escape: function escape(string) {
+    var str = String(string);
+    var result = '';
+    var length = str.length;
+    var index = 0;
+    var chr, code;
+    while (index < length) {
+      chr = str.charAt(index++);
+      if (raw.test(chr)) {
+        result += chr;
+      } else {
+        code = chr.charCodeAt(0);
+        if (code < 256) {
+          result += '%' + hex(code, 2);
+        } else {
+          result += '%u' + hex(code, 4).toUpperCase();
+        }
+      }
+    } return result;
+  }
+});

package/modules/es.regexp.constructor.js

@@ -2,6 +2,7 @@ var DESCRIPTORS = require('../internals/descriptors');
 var global = require('../internals/global');
 var isForced = require('../internals/is-forced');
 var inheritIfRequired = require('../internals/inherit-if-required');
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
 var defineProperty = require('../internals/object-define-property').f;
 var getOwnPropertyNames = require('../internals/object-get-own-property-names').f;
 var isRegExp = require('../internals/is-regexp');
@@ -9,13 +10,18 @@ var getFlags = require('../internals/regexp-flags');
 var stickyHelpers = require('../internals/regexp-sticky-helpers');
 var redefine = require('../internals/redefine');
 var fails = require('../internals/fails');
+var has = require('../internals/has');
 var enforceInternalState = require('../internals/internal-state').enforce;
 var setSpecies = require('../internals/set-species');
 var wellKnownSymbol = require('../internals/well-known-symbol');
+var UNSUPPORTED_DOT_ALL = require('../internals/regexp-unsupported-dot-all');
+var UNSUPPORTED_NCG = require('../internals/regexp-unsupported-ncg');
 
 var MATCH = wellKnownSymbol('match');
 var NativeRegExp = global.RegExp;
 var RegExpPrototype = NativeRegExp.prototype;
+// TODO: Use only propper RegExpIdentifierName
+var IS_NCG = /^\?<[^\s\d!#%&*+<=>@^][^\s!#%&*+<=>@^]*>/;
 var re1 = /a/g;
 var re2 = /a/g;
 
@@ -24,20 +30,90 @@ var CORRECT_NEW = new NativeRegExp(re1) !== re1;
 
 var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
 
-var FORCED = DESCRIPTORS && isForced('RegExp', (!CORRECT_NEW || UNSUPPORTED_Y || 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';
-})));
+var BASE_FORCED = DESCRIPTORS &&
+  (!CORRECT_NEW || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG || 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';
+  }));
+
+var handleDotAll = function (string) {
+  var length = string.length;
+  var index = 0;
+  var result = '';
+  var brackets = false;
+  var chr;
+  for (; index <= length; index++) {
+    chr = string.charAt(index);
+    if (chr === '\\') {
+      result += chr + string.charAt(++index);
+      continue;
+    }
+    if (!brackets && chr === '.') {
+      result += '[\\s\\S]';
+    } else {
+      if (chr === '[') {
+        brackets = true;
+      } else if (chr === ']') {
+        brackets = false;
+      } result += chr;
+    }
+  } return result;
+};
+
+var handleNCG = function (string) {
+  var length = string.length;
+  var index = 0;
+  var result = '';
+  var named = [];
+  var names = {};
+  var brackets = false;
+  var ncg = false;
+  var groupid = 0;
+  var groupname = '';
+  var chr;
+  for (; index <= length; index++) {
+    chr = string.charAt(index);
+    if (chr === '\\') {
+      chr = chr + string.charAt(++index);
+    } else if (chr === ']') {
+      brackets = false;
+    } else if (!brackets) switch (true) {
+      case chr === '[':
+        brackets = true;
+        break;
+      case chr === '(':
+        if (IS_NCG.test(string.slice(index + 1))) {
+          index += 2;
+          ncg = true;
+        }
+        result += chr;
+        groupid++;
+        continue;
+      case chr === '>' && ncg:
+        if (groupname === '' || has(names, groupname)) {
+          throw new SyntaxError('Invalid capture group name');
+        }
+        names[groupname] = true;
+        named.push([groupname, groupid]);
+        ncg = false;
+        groupname = '';
+        continue;
+    }
+    if (ncg) groupname += chr;
+    else result += chr;
+  } return [result, named];
+};
 
 // `RegExp` constructor
 // https://tc39.es/ecma262/#sec-regexp-constructor
-if (FORCED) {
+if (isForced('RegExp', BASE_FORCED)) {
   var RegExpWrapper = function RegExp(pattern, flags) {
     var thisIsRegExp = this instanceof RegExpWrapper;
     var patternIsRegExp = isRegExp(pattern);
     var flagsAreUndefined = flags === undefined;
-    var sticky;
+    var groups = [];
+    var rawPattern, rawFlags, dotAll, sticky, handled, result, state;
 
     if (!thisIsRegExp && patternIsRegExp && pattern.constructor === RegExpWrapper && flagsAreUndefined) {
       return pattern;
@@ -50,24 +126,52 @@ if (FORCED) {
       pattern = pattern.source;
     }
 
-    if (UNSUPPORTED_Y) {
+    pattern = pattern === undefined ? '' : String(pattern);
+    flags = flags === undefined ? '' : String(flags);
+    rawPattern = pattern;
+
+    if (UNSUPPORTED_DOT_ALL && 'dotAll' in re1) {
+      dotAll = !!flags && flags.indexOf('s') > -1;
+      if (dotAll) flags = flags.replace(/s/g, '');
+    }
+
+    rawFlags = flags;
+
+    if (UNSUPPORTED_Y && 'sticky' in re1) {
       sticky = !!flags && flags.indexOf('y') > -1;
       if (sticky) flags = flags.replace(/y/g, '');
     }
 
-    var result = inheritIfRequired(
+    if (UNSUPPORTED_NCG) {
+      handled = handleNCG(pattern);
+      pattern = handled[0];
+      groups = handled[1];
+    }
+
+    result = inheritIfRequired(
       CORRECT_NEW ? new NativeRegExp(pattern, flags) : NativeRegExp(pattern, flags),
       thisIsRegExp ? this : RegExpPrototype,
       RegExpWrapper
     );
 
-    if (UNSUPPORTED_Y && sticky) {
-      var state = enforceInternalState(result);
-      state.sticky = true;
+    if (dotAll || sticky || groups.length) {
+      state = enforceInternalState(result);
+      if (dotAll) {
+        state.dotAll = true;
+        state.raw = RegExpWrapper(handleDotAll(pattern), rawFlags);
+      }
+      if (sticky) state.sticky = true;
+      if (groups.length) state.groups = groups;
     }
 
+    if (pattern !== rawPattern) try {
+      // fails in old engines, but we have no alternatives for unsupported regex syntax
+      createNonEnumerableProperty(result, 'source', rawPattern === '' ? '(?:)' : rawPattern);
+    } catch (error) { /* empty */ }
+
     return result;
   };
+
   var proxy = function (key) {
     key in RegExpWrapper || defineProperty(RegExpWrapper, key, {
       configurable: true,
@@ -75,9 +179,11 @@ if (FORCED) {
       set: function (it) { NativeRegExp[key] = it; }
     });
   };
-  var keys = getOwnPropertyNames(NativeRegExp);
-  var index = 0;
-  while (keys.length > index) proxy(keys[index++]);
+
+  for (var keys = getOwnPropertyNames(NativeRegExp), index = 0; keys.length > index;) {
+    proxy(keys[index++]);
+  }
+
   RegExpPrototype.constructor = RegExpWrapper;
   RegExpWrapper.prototype = RegExpPrototype;
   redefine(global, 'RegExp', RegExpWrapper);

package/modules/es.regexp.dot-all.js

@@ -0,0 +1,22 @@
+var DESCRIPTORS = require('../internals/descriptors');
+var UNSUPPORTED_DOT_ALL = require('../internals/regexp-unsupported-dot-all');
+var defineProperty = require('../internals/object-define-property').f;
+var getInternalState = require('../internals/internal-state').get;
+var RegExpPrototype = RegExp.prototype;
+
+// `RegExp.prototype.dotAll` getter
+// https://tc39.es/ecma262/#sec-get-regexp.prototype.dotall
+if (DESCRIPTORS && UNSUPPORTED_DOT_ALL) {
+  defineProperty(RegExpPrototype, 'dotAll', {
+    configurable: true,
+    get: function () {
+      if (this === RegExpPrototype) return undefined;
+      // We can't use InternalStateModule.getterFor because
+      // we don't add metadata for regexps created by a literal.
+      if (this instanceof RegExp) {
+        return !!getInternalState(this).dotAll;
+      }
+      throw TypeError('Incompatible receiver, RegExp required');
+    }
+  });
+}

package/modules/es.regexp.flags.js

@@ -1,14 +1,16 @@
 var DESCRIPTORS = require('../internals/descriptors');
 var objectDefinePropertyModule = require('../internals/object-define-property');
 var regExpFlags = require('../internals/regexp-flags');
-var UNSUPPORTED_Y = require('../internals/regexp-sticky-helpers').UNSUPPORTED_Y;
+var fails = require('../internals/fails');
+
+var FORCED = DESCRIPTORS && fails(function () {
+  // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+  return Object.getOwnPropertyDescriptor(RegExp.prototype, 'flags').get.call({ dotAll: true, sticky: true }) !== 'sy';
+});
 
 // `RegExp.prototype.flags` getter
 // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
-// eslint-disable-next-line es/no-regexp-prototype-flags -- required for testing
-if (DESCRIPTORS && (/./g.flags != 'g' || UNSUPPORTED_Y)) {
-  objectDefinePropertyModule.f(RegExp.prototype, 'flags', {
-    configurable: true,
-    get: regExpFlags
-  });
-}
+if (FORCED) objectDefinePropertyModule.f(RegExp.prototype, 'flags', {
+  configurable: true,
+  get: regExpFlags
+});

package/modules/es.regexp.sticky.js

@@ -7,7 +7,7 @@ var RegExpPrototype = RegExp.prototype;
 // `RegExp.prototype.sticky` getter
 // https://tc39.es/ecma262/#sec-get-regexp.prototype.sticky
 if (DESCRIPTORS && UNSUPPORTED_Y) {
-  defineProperty(RegExp.prototype, 'sticky', {
+  defineProperty(RegExpPrototype, 'sticky', {
     configurable: true,
     get: function () {
       if (this === RegExpPrototype) return undefined;

package/modules/es.string.match.js

@@ -7,7 +7,7 @@ var advanceStringIndex = require('../internals/advance-string-index');
 var regExpExec = require('../internals/regexp-exec-abstract');
 
 // @@match logic
-fixRegExpWellKnownSymbolLogic('match', 1, function (MATCH, nativeMatch, maybeCallNative) {
+fixRegExpWellKnownSymbolLogic('match', function (MATCH, nativeMatch, maybeCallNative) {
   return [
     // `String.prototype.match` method
     // https://tc39.es/ecma262/#sec-string.prototype.match
@@ -18,12 +18,12 @@ fixRegExpWellKnownSymbolLogic('match', 1, function (MATCH, nativeMatch, maybeCal
     },
     // `RegExp.prototype[@@match]` method
     // https://tc39.es/ecma262/#sec-regexp.prototype-@@match
-    function (regexp) {
-      var res = maybeCallNative(nativeMatch, regexp, this);
+    function (string) {
+      var res = maybeCallNative(nativeMatch, this, string);
       if (res.done) return res.value;
 
-      var rx = anObject(regexp);
-      var S = String(this);
+      var rx = anObject(this);
+      var S = String(string);
 
       if (!rx.global) return regExpExec(rx, S);
 

package/modules/es.string.replace.js

@@ -1,5 +1,6 @@
 'use strict';
 var fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');
+var fails = require('../internals/fails');
 var anObject = require('../internals/an-object');
 var toLength = require('../internals/to-length');
 var toInteger = require('../internals/to-integer');
@@ -7,7 +8,9 @@ var requireObjectCoercible = require('../internals/require-object-coercible');
 var advanceStringIndex = require('../internals/advance-string-index');
 var getSubstitution = require('../internals/get-substitution');
 var regExpExec = require('../internals/regexp-exec-abstract');
+var wellKnownSymbol = require('../internals/well-known-symbol');
 
+var REPLACE = wellKnownSymbol('replace');
 var max = Math.max;
 var min = Math.min;
 
@@ -15,10 +18,33 @@ var maybeToString = function (it) {
   return it === undefined ? it : String(it);
 };
 
+// IE <= 11 replaces $0 with the whole match, as if it was $&
+// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
+var REPLACE_KEEPS_$0 = (function () {
+  // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing
+  return 'a'.replace(/./, '$0') === '$0';
+})();
+
+// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string
+var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
+  if (/./[REPLACE]) {
+    return /./[REPLACE]('a', '$0') === '';
+  }
+  return false;
+})();
+
+var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
+  var re = /./;
+  re.exec = function () {
+    var result = [];
+    result.groups = { a: '7' };
+    return result;
+  };
+  return ''.replace(re, '$<a>') !== '7';
+});
+
 // @@replace logic
-fixRegExpWellKnownSymbolLogic('replace', 2, function (REPLACE, nativeReplace, maybeCallNative, reason) {
-  var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = reason.REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE;
-  var REPLACE_KEEPS_$0 = reason.REPLACE_KEEPS_$0;
+fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {
   var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
 
   return [
@@ -33,17 +59,18 @@ fixRegExpWellKnownSymbolLogic('replace', 2, function (REPLACE, nativeReplace, ma
     },
     // `RegExp.prototype[@@replace]` method
     // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
-    function (regexp, replaceValue) {
+    function (string, replaceValue) {
       if (
-        (!REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE && REPLACE_KEEPS_$0) ||
-        (typeof replaceValue === 'string' && replaceValue.indexOf(UNSAFE_SUBSTITUTE) === -1)
+        typeof replaceValue === 'string' &&
+        replaceValue.indexOf(UNSAFE_SUBSTITUTE) === -1 &&
+        replaceValue.indexOf('$<') === -1
       ) {
-        var res = maybeCallNative(nativeReplace, regexp, this, replaceValue);
+        var res = maybeCallNative(nativeReplace, this, string, replaceValue);
         if (res.done) return res.value;
       }
 
-      var rx = anObject(regexp);
-      var S = String(this);
+      var rx = anObject(this);
+      var S = String(string);
 
       var functionalReplace = typeof replaceValue === 'function';
       if (!functionalReplace) replaceValue = String(replaceValue);
@@ -95,4 +122,4 @@ fixRegExpWellKnownSymbolLogic('replace', 2, function (REPLACE, nativeReplace, ma
       return accumulatedResult + S.slice(nextSourcePosition);
     }
   ];
-});
+}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);

package/modules/es.string.search.js

@@ -6,7 +6,7 @@ var sameValue = require('../internals/same-value');
 var regExpExec = require('../internals/regexp-exec-abstract');
 
 // @@search logic
-fixRegExpWellKnownSymbolLogic('search', 1, function (SEARCH, nativeSearch, maybeCallNative) {
+fixRegExpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCallNative) {
   return [
     // `String.prototype.search` method
     // https://tc39.es/ecma262/#sec-string.prototype.search
@@ -17,12 +17,12 @@ fixRegExpWellKnownSymbolLogic('search', 1, function (SEARCH, nativeSearch, maybe
     },
     // `RegExp.prototype[@@search]` method
     // https://tc39.es/ecma262/#sec-regexp.prototype-@@search
-    function (regexp) {
-      var res = maybeCallNative(nativeSearch, regexp, this);
+    function (string) {
+      var res = maybeCallNative(nativeSearch, this, string);
       if (res.done) return res.value;
 
-      var rx = anObject(regexp);
-      var S = String(this);
+      var rx = anObject(this);
+      var S = String(string);
 
       var previousLastIndex = rx.lastIndex;
       if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0;

package/modules/es.string.split.js

@@ -9,14 +9,26 @@ var toLength = require('../internals/to-length');
 var callRegExpExec = require('../internals/regexp-exec-abstract');
 var regexpExec = require('../internals/regexp-exec');
 var stickyHelpers = require('../internals/regexp-sticky-helpers');
+var fails = require('../internals/fails');
 
 var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
 var arrayPush = [].push;
 var min = Math.min;
 var MAX_UINT32 = 0xFFFFFFFF;
 
+// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
+// Weex JS has frozen built-in prototypes, so use try / catch wrapper
+var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
+  // eslint-disable-next-line regexp/no-empty-group -- required for testing
+  var re = /(?:)/;
+  var originalExec = re.exec;
+  re.exec = function () { return originalExec.apply(this, arguments); };
+  var result = 'ab'.split(re);
+  return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
+});
+
 // @@split logic
-fixRegExpWellKnownSymbolLogic('split', 2, function (SPLIT, nativeSplit, maybeCallNative) {
+fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) {
   var internalSplit;
   if (
     'abbc'.split(/(b)*/)[1] == 'c' ||
@@ -85,12 +97,12 @@ fixRegExpWellKnownSymbolLogic('split', 2, function (SPLIT, nativeSplit, maybeCal
     //
     // NOTE: This cannot be properly polyfilled in engines that don't support
     // the 'y' flag.
-    function (regexp, limit) {
-      var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== nativeSplit);
+    function (string, limit) {
+      var res = maybeCallNative(internalSplit, this, string, limit, internalSplit !== nativeSplit);
       if (res.done) return res.value;
 
-      var rx = anObject(regexp);
-      var S = String(this);
+      var rx = anObject(this);
+      var S = String(string);
       var C = speciesConstructor(rx, RegExp);
 
       var unicodeMatching = rx.unicode;
@@ -131,4 +143,4 @@ fixRegExpWellKnownSymbolLogic('split', 2, function (SPLIT, nativeSplit, maybeCal
       return A;
     }
   ];
-}, UNSUPPORTED_Y);
+}, !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);

package/modules/es.string.substr.js

@@ -0,0 +1,25 @@
+'use strict';
+var $ = require('../internals/export');
+var requireObjectCoercible = require('../internals/require-object-coercible');
+var toInteger = require('../internals/to-integer');
+
+var slice = ''.slice;
+var max = Math.max;
+var min = Math.min;
+
+// `String.prototype.substr` method
+// https://tc39.es/ecma262/#sec-string.prototype.substr
+$({ target: 'String', proto: true }, {
+  substr: function substr(start, length) {
+    var that = String(requireObjectCoercible(this));
+    var size = that.length;
+    var intStart = toInteger(start);
+    var intLength, intEnd;
+    if (intStart === Infinity) intStart = 0;
+    if (intStart < 0) intStart = max(size + intStart, 0);
+    intLength = length === undefined ? size : toInteger(length);
+    if (intLength <= 0 || intLength === Infinity) return '';
+    intEnd = min(intStart + intLength, size);
+    return intStart >= intEnd ? '' : slice.call(that, intStart, intEnd);
+  }
+});

package/modules/es.unescape.js

@@ -0,0 +1,39 @@
+'use strict';
+var $ = require('../internals/export');
+
+var fromCharCode = String.fromCharCode;
+var hex2 = /^[\da-f]{2}$/i;
+var hex4 = /^[\da-f]{4}$/i;
+
+// `unescape` method
+// https://tc39.es/ecma262/#sec-unescape-string
+$({ global: true }, {
+  unescape: function unescape(string) {
+    var str = String(string);
+    var result = '';
+    var length = str.length;
+    var index = 0;
+    var chr, slice;
+    while (index < length) {
+      chr = str.charAt(index++);
+      if (chr === '%') {
+        if (str.charAt(index) === 'u') {
+          slice = str.slice(index + 1, index + 5);
+          if (hex4.test(slice)) {
+            result += fromCharCode(parseInt(slice, 16));
+            index += 5;
+            continue;
+          }
+        } else {
+          slice = str.slice(index, index + 2);
+          if (hex2.test(slice)) {
+            result += fromCharCode(parseInt(slice, 16));
+            index += 2;
+            continue;
+          }
+        }
+      }
+      result += chr;
+    } return result;
+  }
+});

package/modules/web.url.js

@@ -34,13 +34,13 @@ var ALPHA = /[A-Za-z]/;
 // eslint-disable-next-line regexp/no-obscure-range -- safe
 var ALPHANUMERIC = /[\d+-.A-Za-z]/;
 var DIGIT = /\d/;
-var HEX_START = /^(0x|0X)/;
+var HEX_START = /^0x/i;
 var OCT = /^[0-7]+$/;
 var DEC = /^\d+$/;
 var HEX = /^[\dA-Fa-f]+$/;
 /* eslint-disable no-control-regex -- safe */
-var FORBIDDEN_HOST_CODE_POINT = /[\0\t\n\r #%/:?@[\\]]/;
-var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\0\t\n\r #/:?@[\\]]/;
+var FORBIDDEN_HOST_CODE_POINT = /[\0\t\n\r #%/:<>?@[\\\]^|]/;
+var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\0\t\n\r #/:<>?@[\\\]^|]/;
 var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u001F ]+|[\u0000-\u001F ]+$/g;
 var TAB_AND_NEW_LINE = /[\t\n\r]/g;
 /* eslint-enable no-control-regex -- safe */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "core-js",
   "description": "Standard library",
-  "version": "3.14.0",
+  "version": "3.15.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/zloirock/core-js.git",
@@ -55,5 +55,5 @@
   "scripts": {
     "postinstall": "node -e \"try{require('./postinstall')}catch(e){}\""
   },
-  "gitHead": "e386f3de7760ee2910d07efb9d35029aa5dda93b"
+  "gitHead": "4f7f304e7472127efc4749323c56819312fb327f"
 }

package/stable/date/get-year.js

@@ -0,0 +1,3 @@
+var parent = require('../../es/date/get-year');
+
+module.exports = parent;

package/stable/date/set-year.js

@@ -0,0 +1,3 @@
+var parent = require('../../es/date/set-year');
+
+module.exports = parent;

package/stable/date/to-gmt-string.js

@@ -0,0 +1,3 @@
+var parent = require('../../es/date/to-gmt-string');
+
+module.exports = parent;

package/stable/escape.js

@@ -0,0 +1,3 @@
+var parent = require('../es/escape');
+
+module.exports = parent;

package/stable/index.js

@@ -47,11 +47,15 @@ require('../modules/es.array-buffer.constructor');
 require('../modules/es.array-buffer.is-view');
 require('../modules/es.array-buffer.slice');
 require('../modules/es.data-view');
+require('../modules/es.date.get-year');
 require('../modules/es.date.now');
+require('../modules/es.date.set-year');
+require('../modules/es.date.to-gmt-string');
 require('../modules/es.date.to-iso-string');
 require('../modules/es.date.to-json');
 require('../modules/es.date.to-primitive');
 require('../modules/es.date.to-string');
+require('../modules/es.escape');
 require('../modules/es.function.bind');
 require('../modules/es.function.has-instance');
 require('../modules/es.function.name');
@@ -135,6 +139,7 @@ require('../modules/es.reflect.set');
 require('../modules/es.reflect.set-prototype-of');
 require('../modules/es.reflect.to-string-tag');
 require('../modules/es.regexp.constructor');
+require('../modules/es.regexp.dot-all');
 require('../modules/es.regexp.exec');
 require('../modules/es.regexp.flags');
 require('../modules/es.regexp.sticky');
@@ -157,6 +162,7 @@ require('../modules/es.string.replace-all');
 require('../modules/es.string.search');
 require('../modules/es.string.split');
 require('../modules/es.string.starts-with');
+require('../modules/es.string.substr');
 require('../modules/es.string.trim');
 require('../modules/es.string.trim-end');
 require('../modules/es.string.trim-start');
@@ -207,6 +213,7 @@ require('../modules/es.typed-array.sort');
 require('../modules/es.typed-array.subarray');
 require('../modules/es.typed-array.to-locale-string');
 require('../modules/es.typed-array.to-string');
+require('../modules/es.unescape');
 require('../modules/es.weak-map');
 require('../modules/es.weak-set');
 require('../modules/web.dom-collections.for-each');

package/stable/regexp/dot-all.js

@@ -0,0 +1,3 @@
+var parent = require('../../es/regexp/dot-all');
+
+module.exports = parent;

package/stable/string/substr.js

@@ -0,0 +1,3 @@
+var parent = require('../../es/string/substr');
+
+module.exports = parent;

package/stable/string/virtual/substr.js

@@ -0,0 +1,3 @@
+var parent = require('../../../es/string/virtual/substr');
+
+module.exports = parent;

package/stable/unescape.js

@@ -0,0 +1,3 @@
+var parent = require('../es/unescape');
+
+module.exports = parent;