94 lines
3.4 KiB
JavaScript
94 lines
3.4 KiB
JavaScript
|
'use strict';
|
||
|
|
var hide = require('../internals/hide');
|
||
|
|
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/;
|
||
|
|
re.exec = function () { execCalled = true; return null; };
|
||
|
|
|
||
|
|
if (KEY === 'split') {
|
||
|
|
// 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[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) hide(RegExp.prototype[SYMBOL], 'sham', true);
|
||
|
|
}
|
||
|
|
};
|