| 'use strict'; |
| var createNonEnumerableProperty = require('../internals/create-non-enumerable-property'); |
| var redefine = require('../internals/redefine'); |
| var fails = require('../internals/fails'); |
| var wellKnownSymbol = require('../internals/well-known-symbol'); |
| var regexpExec = require('../internals/regexp-exec'); |
| |
| var SPECIES = wellKnownSymbol('species'); |
| |
| 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'; |
| }); |
| |
| // 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 () { |
| 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) { |
| var SYMBOL = wellKnownSymbol(KEY); |
| |
| var DELEGATES_TO_SYMBOL = !fails(function () { |
| // String methods call symbol-named RegEp methods |
| var O = {}; |
| O[SYMBOL] = function () { return 7; }; |
| return ''[KEY](O) != 7; |
| }); |
| |
| var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () { |
| // Symbol-named RegExp methods call .exec |
| var execCalled = false; |
| var re = /a/; |
| |
| if (KEY === 'split') { |
| // We can't use real regex here since it causes deoptimization |
| // and serious performance degradation in V8 |
| // https://github.com/zloirock/core-js/issues/306 |
| re = {}; |
| // RegExp[@@split] doesn't call the regex's exec method, but first creates |
| // a new one. We need to return the patched regex when creating the new one. |
| re.constructor = {}; |
| re.constructor[SPECIES] = function () { return re; }; |
| re.flags = ''; |
| re[SYMBOL] = /./[SYMBOL]; |
| } |
| |
| re.exec = function () { execCalled = true; return null; }; |
| |
| re[SYMBOL](''); |
| return !execCalled; |
| }); |
| |
| if ( |
| !DELEGATES_TO_SYMBOL || |
| !DELEGATES_TO_EXEC || |
| (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) || |
| (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC) |
| ) { |
| var nativeRegExpMethod = /./[SYMBOL]; |
| var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { |
| if (regexp.exec === regexpExec) { |
| if (DELEGATES_TO_SYMBOL && !forceStringMethod) { |
| // The native String method already delegates to @@method (this |
| // polyfilled function), leasing to infinite recursion. |
| // We avoid it by directly calling the native @@method method. |
| return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) }; |
| } |
| return { done: true, value: nativeMethod.call(str, regexp, arg2) }; |
| } |
| return { done: false }; |
| }); |
| var stringMethod = methods[0]; |
| var regexMethod = methods[1]; |
| |
| redefine(String.prototype, KEY, stringMethod); |
| redefine(RegExp.prototype, 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); } |
| ); |
| if (sham) createNonEnumerableProperty(RegExp.prototype[SYMBOL], 'sham', true); |
| } |
| }; |