| 'use strict'; |
| var fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic'); |
| 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 MAX_UINT32 = 0xFFFFFFFF; |
| |
| // babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError |
| var SUPPORTS_Y = !fails(function () { return !RegExp(MAX_UINT32, 'y'); }); |
| |
| // @@split logic |
| fixRegExpWellKnownSymbolLogic('split', 2, 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 |
| ) { |
| // based on es5-shim implementation, need to rework it |
| internalSplit = function (separator, limit) { |
| 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, lim); |
| } |
| var output = []; |
| var flags = (separator.ignoreCase ? 'i' : '') + |
| (separator.multiline ? 'm' : '') + |
| (separator.unicode ? 'u' : '') + |
| (separator.sticky ? 'y' : ''); |
| var lastLastIndex = 0; |
| // Make `global` and avoid `lastIndex` issues by working with a copy |
| var separatorCopy = new RegExp(separator.source, flags + 'g'); |
| var match, lastIndex, lastLength; |
| while (match = regexpExec.call(separatorCopy, string)) { |
| 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; |
| lastLastIndex = lastIndex; |
| if (output.length >= lim) break; |
| } |
| if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop |
| } |
| if (lastLastIndex === string.length) { |
| if (lastLength || !separatorCopy.test('')) output.push(''); |
| } else output.push(string.slice(lastLastIndex)); |
| return output.length > lim ? output.slice(0, lim) : output; |
| }; |
| // Chakra, V8 |
| } else if ('0'.split(undefined, 0).length) { |
| internalSplit = function (separator, limit) { |
| return separator === undefined && limit === 0 ? [] : nativeSplit.call(this, separator, limit); |
| }; |
| } else internalSplit = nativeSplit; |
| |
| return [ |
| // `String.prototype.split` method |
| // https://tc39.github.io/ecma262/#sec-string.prototype.split |
| function split(separator, limit) { |
| var O = requireObjectCoercible(this); |
| var splitter = separator == undefined ? undefined : separator[SPLIT]; |
| return splitter !== undefined |
| ? splitter.call(separator, O, limit) |
| : internalSplit.call(String(O), separator, limit); |
| }, |
| // `RegExp.prototype[@@split]` method |
| // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split |
| // |
| // 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); |
| if (res.done) return res.value; |
| |
| var rx = anObject(regexp); |
| var S = String(this); |
| var C = speciesConstructor(rx, RegExp); |
| |
| var unicodeMatching = rx.unicode; |
| var flags = (rx.ignoreCase ? 'i' : '') + |
| (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 ? MAX_UINT32 : limit >>> 0; |
| if (lim === 0) return []; |
| if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : []; |
| var p = 0; |
| var q = 0; |
| var A = []; |
| while (q < S.length) { |
| splitter.lastIndex = SUPPORTS_Y ? q : 0; |
| var z = callRegExpExec(splitter, SUPPORTS_Y ? S : S.slice(q)); |
| var e; |
| if ( |
| z === null || |
| (e = min(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p |
| ) { |
| q = advanceStringIndex(S, q, unicodeMatching); |
| } else { |
| A.push(S.slice(p, q)); |
| if (A.length === lim) return A; |
| for (var i = 1; i <= z.length - 1; i++) { |
| A.push(z[i]); |
| if (A.length === lim) return A; |
| } |
| q = p = e; |
| } |
| } |
| A.push(S.slice(p)); |
| return A; |
| } |
| ]; |
| }, !SUPPORTS_Y); |