@microsoft/applicationinsights-react-native 4.1.2-nightly.2404-13 → 4.1.2-nightly.2405-04

package/browser/applicationinsights-react-native.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - React Native Plugin, 4.1.2-nightly.2404-13
+ * Application Insights JavaScript SDK - React Native Plugin, 4.1.2-nightly.2405-04
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -18,6 +18,13 @@
     var strShimPrototype = "prototype";
     var ObjClass$1 = Object;
 
+    /*! https://github.com/nevware21/ts-utils v0.11.2 */
+    function _pureAssign(func1, func2) {
+        return func1 || func2;
+    }
+    function _pureRef(value, name) {
+        return value[name];
+    }
     var UNDEF_VALUE = undefined;
     var NULL_VALUE = null;
     var EMPTY = "";
@@ -33,14 +40,14 @@
     var NAME = "name";
     var CALL = "call";
     var TO_STRING = "toString";
-    var ObjClass = Object;
-    var ObjProto = ObjClass[PROTOTYPE];
-    var StrCls = String;
-    var StrProto = StrCls[PROTOTYPE];
-    var ArrCls = Array;
-    var ArrProto = ArrCls[PROTOTYPE];
-    var ArrSlice = ArrProto["slice"];
-
+    var ObjClass = ( _pureAssign(Object));
+    var ObjProto = ( _pureRef(ObjClass, PROTOTYPE));
+    var StrCls = ( _pureAssign(String));
+    var StrProto = ( _pureRef(StrCls, PROTOTYPE));
+    var MathCls = ( _pureAssign(Math));
+    var ArrCls = ( _pureAssign(Array));
+    var ArrProto = ( _pureRef(ArrCls, PROTOTYPE));
+    var ArrSlice = ( _pureRef(ArrProto, "slice"));
     function safe(func, argArray) {
         try {
             return {
@@ -51,7 +58,6 @@
             return { e: e };
         }
     }
-
     function _createIs(theType) {
         return function (value) {
             return typeof value === theType;
@@ -64,7 +70,7 @@
         };
     }
     function objToString(value) {
-        return ObjProto.toString.call(value);
+        return ObjProto[TO_STRING].call(value);
     }
     function isUndefined(value) {
         return typeof value === UNDEFINED || value === UNDEFINED;
@@ -86,23 +92,20 @@
         }
         return !!value && typeof value === OBJECT;
     }
-    var isArray = ArrCls.isArray;
+    var isArray = ( _pureRef(ArrCls, "isArray"));
+    var isRegExp = ( _createObjIs("RegExp"));
     var isError = ( _createObjIs("Error"));
     function isPromiseLike(value) {
         return !!(value && value.then && isFunction(value.then));
     }
-
-    var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
-
+    var objGetOwnPropertyDescriptor = ( _pureRef(ObjClass, "getOwnPropertyDescriptor"));
     function objHasOwnProperty(obj, prop) {
         return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);
     }
-
-    var objHasOwn = ObjClass["hasOwn"] || polyObjHasOwn;
+    var objHasOwn = ( _pureAssign(( _pureRef(ObjClass, "hasOwn")), polyObjHasOwn));
     function polyObjHasOwn(obj, prop) {
         return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
     }
-
     function objForEachKey(theObject, callbackfn, thisArg) {
         if (theObject && isObject(theObject)) {
             for (var prop in theObject) {
@@ -114,7 +117,6 @@
             }
         }
     }
-
     function _createKeyValueMap(values, keyType, valueType, completeFn) {
         var theMap = {};
         objForEachKey(values, function (key, value) {
@@ -123,11 +125,29 @@
         });
         return completeFn(theMap);
     }
-
+    var asString = ( _pureAssign(StrCls));
+    var ERROR_TYPE = "[object Error]";
+    function dumpObj(object, format) {
+        var propertyValueDump = EMPTY;
+        var objType = ObjProto[TO_STRING][CALL](object);
+        if (objType === ERROR_TYPE) {
+            object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };
+        }
+        try {
+            propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? ((typeof format === "number") ? format : 4) : UNDEF_VALUE);
+            propertyValueDump = (propertyValueDump && propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ")) || asString(object);
+        }
+        catch (e) {
+            propertyValueDump = " - " + dumpObj(e, format);
+        }
+        return objType + ": " + propertyValueDump;
+    }
     function throwTypeError(message) {
         throw new TypeError(message);
     }
-
+    function throwRangeError(message) {
+        throw new RangeError(message);
+    }
     function polyObjEntries(value) {
         var result = [];
         objForEachKey(value, function (key, value) {
@@ -135,23 +155,15 @@
         });
         return result;
     }
-    function polyObjValues(value) {
-        var result = [];
-        objForEachKey(value, function (key, value) {
-            result.push(value);
-        });
-        return result;
-    }
-
-    var _objFreeze = ObjClass["freeze"];
+    var _objFreeze = ( _pureRef(ObjClass, "freeze"));
     function _doNothing(value) {
         return value;
     }
     function _getProto(value) {
         return value[__PROTO__] || NULL_VALUE;
     }
-    ObjClass["assign"];
-    var objKeys = ObjClass.keys;
+    ( _pureRef(ObjClass, "assign"));
+    var objKeys = ( _pureRef(ObjClass, "keys"));
     function objDeepFreeze(value) {
         if (_objFreeze) {
             objForEachKey(value, function (key, value) {
@@ -162,16 +174,13 @@
         }
         return objFreeze(value);
     }
-    var objFreeze = _objFreeze || _doNothing;
-    ObjClass["seal"] || _doNothing;
-    var objGetPrototypeOf = ObjClass["getPrototypeOf"] || _getProto;
-    ObjClass.entries || polyObjEntries;
-    ObjClass.values || polyObjValues;
-
+    var objFreeze = ( _pureAssign(_objFreeze, _doNothing));
+    ( _pureAssign(( _pureRef(ObjClass, "seal")), _doNothing));
+    var objGetPrototypeOf = ( _pureAssign(( _pureRef(ObjClass, "getPrototypeOf")), _getProto));
+    ( _pureAssign(( _pureRef(ObjClass, "entries")), polyObjEntries));
     function createEnumKeyMap(values) {
         return _createKeyValueMap(values, 0 , 0 , objDeepFreeze);
     }
-
     var _wellKnownSymbolMap =  createEnumKeyMap({
         asyncIterator: 0 ,
         hasInstance: 1 ,
@@ -187,9 +196,6 @@
         toStringTag: 11 ,
         unscopables: 12
     });
-
-    var asString = StrCls;
-
     var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
     var _globalCfg;
     function _getGlobalValue() {
@@ -215,25 +221,7 @@
         }
         return _globalCfg;
     }
-
-    var ERROR_TYPE = "[object Error]";
-    function dumpObj(object, format) {
-        var propertyValueDump = EMPTY;
-        var objType = ObjProto[TO_STRING][CALL](object);
-        if (objType === ERROR_TYPE) {
-            object = { stack: asString(object.stack), message: asString(object.message), name: asString(object.name) };
-        }
-        try {
-            propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? ((typeof format === "number") ? format : 4) : UNDEF_VALUE);
-            propertyValueDump = (propertyValueDump && propertyValueDump.replace(/"(\w+)"\s*:\s{0,1}/g, "$1: ")) || asString(object);
-        }
-        catch (e) {
-            propertyValueDump = " - " + dumpObj(e, format);
-        }
-        return objType + ": " + propertyValueDump;
-    }
-
-    var _unwrapFunction =  _unwrapFunctionWithPoly;
+    var _unwrapFunction = ( _unwrapFunctionWithPoly);
     function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
         var clsFn = clsProto && clsProto[funcName];
         return function (thisArg) {
@@ -245,7 +233,27 @@
             throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
         };
     }
-
+    ( _pureRef(MathCls, "min"));
+    var mathMax = ( _pureRef(MathCls, "max"));
+    var strSlice = ( _unwrapFunction("slice", StrProto));
+    var strSubstring = ( _unwrapFunction("substring", StrProto));
+    ( _unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr));
+    function polyStrSubstr(value, start, length) {
+        if (isNullOrUndefined(value)) {
+            throwTypeError("Invalid " + dumpObj(value));
+        }
+        if (length < 0) {
+            return EMPTY;
+        }
+        start = start || 0;
+        if (start < 0) {
+            start = mathMax(start + value[LENGTH], 0);
+        }
+        if (isUndefined(length)) {
+            return strSlice(value, start);
+        }
+        return strSlice(value, start, start + length);
+    }
     var UNIQUE_REGISTRY_ID = "_urid";
     var _polySymbols;
     function _globalSymbolRegistry() {
@@ -284,7 +292,6 @@
         }
         return result;
     }
-
     var propMap = {
         e: "enumerable",
         c: "configurable",
@@ -311,48 +318,20 @@
         });
         return prop;
     }
-    var objDefineProp = ObjClass["defineProperty"];
+    var objDefineProp = ( _pureRef(ObjClass, "defineProperty"));
+    ( _pureRef(ObjClass, "defineProperties"));
     function objDefine(target, key, propDesc) {
         return objDefineProp(target, key, _createProp(propDesc));
     }
-
     var _globalLazyTestHooks;
     function _initTestHooks() {
         _globalLazyTestHooks = _getGlobalConfig();
     }
-    function getLazy(cb) {
-        var lazyValue = {};
-        !_globalLazyTestHooks && _initTestHooks();
-        lazyValue.b = _globalLazyTestHooks.lzy;
-        objDefineProp(lazyValue, "v", {
-            configurable: true,
-            get: function () {
-                var result = cb();
-                if (!_globalLazyTestHooks.lzy) {
-                    objDefineProp(lazyValue, "v", {
-                        value: result
-                    });
-                }
-                lazyValue.b = _globalLazyTestHooks.lzy;
-                return result;
-            }
-        });
-        return lazyValue;
-    }
-
-    function safeGetLazy(cb, defValue) {
-        return getLazy(function () {
-            var result = safe(cb);
-            return result.e ? defValue : result.v;
-        });
-    }
-
     function createCachedValue(value) {
         return objDefineProp({
             toJSON: function () { return value; }
         }, "v", { value: value });
     }
-
     var WINDOW = "window";
     var _cachedGlobal;
     function _getGlobalInstFn(getFn, theArgs) {
@@ -363,9 +342,6 @@
             return cachedValue.v;
         };
     }
-    function lazySafeGetInst(name) {
-        return getLazy(function () { return safe((getInst), [name]).v || UNDEF_VALUE; });
-    }
     function getGlobal(useCached) {
         !_globalLazyTestHooks && _initTestHooks();
         (!_cachedGlobal || useCached === false || _globalLazyTestHooks.lzy) && (_cachedGlobal = createCachedValue(safe(_getGlobalValue).v || NULL_VALUE));
@@ -382,54 +358,59 @@
         return NULL_VALUE;
     }
     function hasWindow() {
-        return !!getWindow();
+        return !!( getWindow());
     }
     var getWindow = ( _getGlobalInstFn(getInst, [WINDOW]));
     var getNavigator = ( _getGlobalInstFn(getInst, ["navigator"]));
-
     var _symbol;
     var _symbolFor;
     function _initSymbol() {
-        if (!_symbol || !_symbol.b) {
-            _symbol = lazySafeGetInst(SYMBOL);
-            _symbolFor = safeGetLazy(function () { return (_symbol.v ? _symbol.v["for"] : UNDEF_VALUE); }, UNDEF_VALUE);
-            safeGetLazy(function () { return (_symbol.v ? _symbol.v["keyFor"] : UNDEF_VALUE); }, UNDEF_VALUE);
-        }
+        _symbol = ( createCachedValue(safe((getInst), [SYMBOL]).v));
+        return _symbol;
+    }
+    function _getSymbolKey(key) {
+        var gblSym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
+        return (gblSym.v ? gblSym.v[key] : UNDEF_VALUE);
+    }
+    function hasSymbol() {
+        return !!( getSymbol());
+    }
+    function getSymbol() {
+        !_globalLazyTestHooks && _initTestHooks();
+        return ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol()).v;
     }
     function getKnownSymbol(name, noPoly) {
         var knownName = _wellKnownSymbolMap[name];
         !_globalLazyTestHooks && _initTestHooks();
-        (!_symbol || _globalLazyTestHooks.lzy) && _initSymbol();
-        return _symbol.v ? _symbol.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
+        var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
+        return sym.v ? sym.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
     }
     function newSymbol(description, noPoly) {
         !_globalLazyTestHooks && _initTestHooks();
-        (!_symbol || _globalLazyTestHooks.lzy) && _initSymbol();
-        return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : NULL_VALUE);
+        var sym = ((!_globalLazyTestHooks.lzy ? _symbol : 0) || _initSymbol());
+        return sym.v ? sym.v(description) : (!noPoly ? polyNewSymbol(description) : NULL_VALUE);
     }
     function symbolFor(key) {
         !_globalLazyTestHooks && _initTestHooks();
-        (!_symbolFor || !_symbol || _globalLazyTestHooks.lzy) && _initSymbol();
+        _symbolFor = ((!_globalLazyTestHooks.lzy ? _symbolFor : 0) || ( createCachedValue(safe((_getSymbolKey), ["for"]).v)));
         return (_symbolFor.v || polySymbolFor)(key);
     }
-
     function isIterator(value) {
         return !!value && isFunction(value.next);
     }
     function isIterable(value) {
         return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
     }
-
-    var _iterSymbol;
+    var _iterSymbol$1;
     function iterForOf(iter, callbackfn, thisArg) {
         if (iter) {
             if (!isIterator(iter)) {
-                !_iterSymbol && (_iterSymbol = createCachedValue(getKnownSymbol(3 )));
-                iter = iter[_iterSymbol.v] ? iter[_iterSymbol.v]() : null;
+                !_iterSymbol$1 && (_iterSymbol$1 = createCachedValue(getKnownSymbol(3 )));
+                iter = iter[_iterSymbol$1.v] ? iter[_iterSymbol$1.v]() : null;
             }
             if (isIterator(iter)) {
-                var err = void 0;
-                var iterResult = void 0;
+                var err = UNDEF_VALUE;
+                var iterResult = UNDEF_VALUE;
                 try {
                     var count = 0;
                     while (!(iterResult = iter.next()).done) {
@@ -442,7 +423,7 @@
                 catch (failed) {
                     err = { e: failed };
                     if (iter.throw) {
-                        iterResult = null;
+                        iterResult = NULL_VALUE;
                         iter.throw(err);
                     }
                 }
@@ -461,11 +442,9 @@
             }
         }
     }
-
     function fnApply(fn, thisArg, argArray) {
         return fn.apply(thisArg, argArray);
     }
-
     function arrAppend(target, elms) {
         if (!isUndefined(elms) && target) {
             if (isArray(elms)) {
@@ -482,7 +461,8 @@
         }
         return target;
     }
-
+    _unwrapFunction("every", ArrProto);
+    _unwrapFunction("filter", ArrProto);
     function arrForEach(theArray, callbackfn, thisArg) {
         if (theArray) {
             var len = theArray[LENGTH] >>> 0;
@@ -495,11 +475,66 @@
             }
         }
     }
-
     var arrIndexOf = ( _unwrapFunction("indexOf", ArrProto));
     ( _unwrapFunction("lastIndexOf", ArrProto));
-
-    var objCreate = ObjClass["create"] || polyObjCreate;
+    var arrMap = ( _unwrapFunction("map", ArrProto));
+    function arrSlice(theArray, start, end) {
+        return ((theArray && theArray["slice"]) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));
+    }
+    function polyArrIncludes(theArray, searchElement, fromIndex) {
+        return arrIndexOf(theArray, searchElement, fromIndex) !== -1;
+    }
+    function polyArrFind(theArray, callbackFn, thisArg) {
+        var result;
+        var idx = polyArrFindIndex(theArray, callbackFn, thisArg);
+        return idx !== -1 ? theArray[idx] : result;
+    }
+    function polyArrFindIndex(theArray, callbackFn, thisArg) {
+        var result = -1;
+        arrForEach(theArray, function (value, index) {
+            if (callbackFn[CALL](thisArg | theArray, value, index, theArray)) {
+                result = index;
+                return -1;
+            }
+        });
+        return result;
+    }
+    function polyArrFindLast(theArray, callbackFn, thisArg) {
+        var result;
+        var idx = polyArrFindLastIndex(theArray, callbackFn, thisArg);
+        return idx !== -1 ? theArray[idx] : result;
+    }
+    function polyArrFindLastIndex(theArray, callbackFn, thisArg) {
+        var result = -1;
+        var len = theArray[LENGTH] >>> 0;
+        for (var idx = len - 1; idx >= 0; idx--) {
+            if (idx in theArray && callbackFn[CALL](thisArg | theArray, theArray[idx], idx, theArray)) {
+                result = idx;
+                break;
+            }
+        }
+        return result;
+    }
+    function polyArrFrom(theValue, mapFn, thisArg) {
+        if (isArray(theValue)) {
+            var result_1 = arrSlice(theValue);
+            return mapFn ? arrMap(result_1, mapFn, thisArg) : result_1;
+        }
+        var result = [];
+        iterForOf(theValue, function (value, cnt) {
+            return result.push(mapFn ? mapFn[CALL](thisArg, value, cnt) : value);
+        });
+        return result;
+    }
+    _unwrapFunctionWithPoly("find", ArrProto, polyArrFind);
+    _unwrapFunctionWithPoly("findIndex", ArrProto, polyArrFindIndex);
+    _unwrapFunctionWithPoly("findLast", ArrProto, polyArrFindLast);
+    _unwrapFunctionWithPoly("findLastIndex", ArrProto, polyArrFindLastIndex);
+    ( _pureAssign(( _pureRef(ArrCls, "from")), polyArrFrom));
+    ( _unwrapFunctionWithPoly("includes", ArrProto, polyArrIncludes));
+    ( _unwrapFunction("reduce", ArrProto));
+    ( _unwrapFunction("some", ArrProto));
+    var objCreate = ( _pureAssign(( _pureRef(ObjClass, "create")), polyObjCreate));
     function polyObjCreate(obj) {
         if (!obj) {
             return {};
@@ -512,25 +547,21 @@
         tempFunc[PROTOTYPE] = obj;
         return new tempFunc();
     }
-
     var _isProtoArray;
     function objSetPrototypeOf(obj, proto) {
         var fn = ObjClass["setPrototypeOf"] ||
             function (d, b) {
-                !_isProtoArray && (_isProtoArray = getLazy(function () {
-                    var _a;
-                    return ((_a = {}, _a[__PROTO__] = [], _a) instanceof Array);
-                }));
+                var _a;
+                !_isProtoArray && (_isProtoArray = createCachedValue((_a = {}, _a[__PROTO__] = [], _a) instanceof Array));
                 _isProtoArray.v ? d[__PROTO__] = b : objForEachKey(b, function (key, value) { return d[key] = value; });
             };
         return fn(obj, proto);
     }
-
     function _createCustomError(name, d, b) {
         safe(objDefine, [d, NAME, { v: name, c: true, e: false }]);
         d = objSetPrototypeOf(d, b);
         function __() {
-            this.constructor = d;
+            this[CONSTRUCTOR] = d;
             safe(objDefine, [this, NAME, { v: name, c: true, e: false }]);
         }
         d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
@@ -564,14 +595,88 @@
             }
         }, theBaseClass);
     }
-
     function utcNow() {
         return (Date.now || polyUtcNow)();
     }
     function polyUtcNow() {
         return new Date().getTime();
     }
-
+    function _createTrimFn(exp) {
+        return function _doTrim(value) {
+            if (isNullOrUndefined(value)) {
+                throwTypeError("strTrim called [" + dumpObj(value) + "]");
+            }
+            if (value && value.replace) {
+                value = value.replace(exp, EMPTY);
+            }
+            return value;
+        };
+    }
+    var polyStrTrim = ( _createTrimFn(/^\s+|(?=\s)\s+$/g));
+    var polyStrTrimStart = ( _createTrimFn(/^\s+/g));
+    var polyStrTrimEnd = ( _createTrimFn(/(?=\s)\s+$/g));
+    ( _unwrapFunctionWithPoly("trim", StrProto, polyStrTrim));
+    ( _unwrapFunctionWithPoly("trimStart", StrProto, polyStrTrimStart));
+    ( _unwrapFunctionWithPoly("trimEnd", StrProto, polyStrTrimEnd));
+    ( _unwrapFunction("toUpperCase", StrProto));
+    ( _unwrapFunction("toLowerCase", StrProto));
+    var mathFloor = ( _pureRef(MathCls, "floor"));
+    var mathCeil = ( _pureRef(MathCls, "ceil"));
+    var mathTrunc = ( _pureAssign(( _pureRef(MathCls, "trunc")), polyMathTrunc));
+    function polyMathTrunc(value) {
+        var theValue = +value;
+        return (theValue > 0 ? mathFloor : mathCeil)(theValue);
+    }
+    function mathToInt(value, throwInfinity) {
+        var result = +value;
+        if (result == Infinity && throwInfinity) {
+            throwRangeError("invalid value [" + dumpObj(value) + "]");
+        }
+        return result !== result || result === 0 ? 0 : mathTrunc(result);
+    }
+    var strRepeat = ( _unwrapFunctionWithPoly("repeat", StrProto, polyStrRepeat));
+    function polyStrRepeat(value, count) {
+        if (isNullOrUndefined(value)) {
+            throwTypeError("can't convert [" + dumpObj(value) + "]");
+        }
+        count = mathToInt(count, true);
+        if (count < 0) {
+            throwRangeError("invalid count must be >= 0 && < Infinity");
+        }
+        var pad = isString(value) ? value : asString(value);
+        var result = EMPTY;
+        for (; count > 0; (count >>>= 1) && (pad += pad)) {
+            if (count & 1) {
+                result += pad;
+            }
+        }
+        return result;
+    }
+    function _padValue(value, targetLength, padString) {
+        var result = EMPTY;
+        targetLength = mathToInt(targetLength, true);
+        targetLength >>= 0;
+        var len = value[LENGTH];
+        if (len < targetLength) {
+            result = isNullOrUndefined(padString) ? " " : asString(padString);
+            targetLength = targetLength - len;
+            if (targetLength > result[LENGTH]) {
+                result = strRepeat(result, mathCeil(targetLength / result[LENGTH]));
+            }
+            if (result[LENGTH] > targetLength) {
+                result = strSubstring(result, 0, targetLength);
+            }
+        }
+        return result;
+    }
+    ( _unwrapFunctionWithPoly("padStart", StrProto, polyStrPadStart));
+    ( _unwrapFunctionWithPoly("padEnd", StrProto, polyStrPadEnd));
+    function polyStrPadStart(value, targetLength, padString) {
+        return _padValue(value, targetLength, padString) + value;
+    }
+    function polyStrPadEnd(value, targetLength, padString) {
+        return value + _padValue(value, targetLength, padString);
+    }
     var _fnToString;
     var _objCtrFnString;
     var _gblWindow;
@@ -603,10 +708,39 @@
         }
         return result;
     }
-
+    function polyStrSymSplit(value, splitter, limit) {
+        var splitFn = splitter && splitter[getKnownSymbol(9 )];
+        return splitFn ? splitFn(value, limit) : [value];
+    }
+    ( _unwrapFunction("split", StrProto));
+    ( _unwrapFunctionWithPoly("split", StrProto, !hasSymbol() ? polyStrSymSplit : null));
+    ( _unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith));
+    function polyStrEndsWith(value, searchString, length) {
+        if (!isString(value)) {
+            throwTypeError("'" + dumpObj(value) + "' is not a string");
+        }
+        var searchValue = isString(searchString) ? searchString : asString(searchString);
+        var end = !isUndefined(length) && length < value[LENGTH] ? length : value[LENGTH];
+        return strSubstring(value, end - searchValue[LENGTH], end) === searchValue;
+    }
     var strIndexOf = ( _unwrapFunction("indexOf", StrProto));
     ( _unwrapFunction("lastIndexOf", StrProto));
-
+    ( _unwrapFunctionWithPoly("includes", StrProto, polyStrIncludes));
+    function polyStrIncludes(value, searchString, position) {
+        if (isRegExp(searchString)) {
+            throwTypeError("'searchString' must not be a regular expression" + dumpObj(searchString));
+        }
+        return strIndexOf(value, asString(searchString), position) !== -1;
+    }
+    ( _unwrapFunctionWithPoly("startsWith", StrProto, polyStrStartsWith));
+    function polyStrStartsWith(value, searchString, position) {
+        if (!isString(value)) {
+            throwTypeError("'" + dumpObj(value) + "' is not a string");
+        }
+        var searchValue = isString(searchString) ? searchString : asString(searchString);
+        var pos = position > 0 ? position : 0;
+        return strSubstring(value, pos, pos + searchValue[LENGTH]) === searchValue;
+    }
     var REF = "ref";
     var UNREF = "unref";
     var HAS_REF = "hasRef";
@@ -662,7 +796,6 @@
             }
         };
     }
-
     function _createTimeoutWith(startTimer, overrideFn, theArgs) {
         var isArr = isArray(overrideFn);
         var len = isArr ? overrideFn.length : 0;
@@ -1210,7 +1343,7 @@
         return result;
     }
 
-    var version = "3.0.5";
+    var version = '3.2.0';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {