@microsoft/applicationinsights-react-native 4.4.1-nightly.2605-02 → 4.4.1-nightly.2606-01

package/browser/applicationinsights-react-native.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - React Native Plugin, 4.4.1-nightly.2605-02
+ * Application Insights JavaScript SDK - React Native Plugin, 4.4.1-nightly.2606-01
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -18,12 +18,12 @@
     var strShimPrototype = "prototype";
     var ObjClass$1 = Object;
 
-    /*! https://github.com/nevware21/ts-utils v0.13.0 */
+    /*! https://github.com/nevware21/ts-utils v0.15.0 */
     function _pureAssign(func1, func2) {
         return func1 || func2;
     }
     function _pureRef(value, name) {
-        return value[name];
+        return value !== null && value !== undefined ? value[name] : undefined;
     }
     var UNDEF_VALUE = undefined;
     var NULL_VALUE = null;
@@ -42,15 +42,26 @@
     var GET_OWN_PROPERTY_DESCRIPTOR = "getOwnPropertyDescriptor";
     var GET_OWN_PROPERTY_NAMES = "getOwnPropertyNames";
     var GET_OWN_PROPERTY_SYMBOLS = "getOwnPropertySymbols";
-    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"));
-    var NumberCls = ( _pureAssign(Number));
+    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"));
+    var NumberCls = (_pureAssign(Number));
+    (_pureRef(NumberCls, PROTOTYPE));
+    var FuncCls = (_pureAssign(Function));
+    (_pureRef(FuncCls, PROTOTYPE));
+    var DateCls = (_pureAssign(Date));
+    (_pureRef(DateCls, PROTOTYPE));
+    var RegExpCls = (_pureAssign(RegExp));
+    (_pureRef(RegExpCls, PROTOTYPE));
+    var BooleanCls = (_pureAssign(Boolean));
+    (_pureRef(BooleanCls, PROTOTYPE));
+    var ErrorCls = (_pureAssign(Error));
+    (_pureRef(ErrorCls, PROTOTYPE));
     var POLYFILL_TAG = "_polyfill";
     var POLYFILL_TYPE_NAME = "__nw21$polytype__";
     function safe(func, argArray) {
@@ -92,18 +103,21 @@
     function isDefined(arg) {
         return !!arg || arg !== UNDEF_VALUE;
     }
-    var isString = ( _createIs("string"));
-    var isFunction = ( _createIs(FUNCTION));
+    var isString = (_createIs("string"));
+    var isFunction = (_createIs(FUNCTION));
     function isObject(value) {
         if (!value && isNullOrUndefined(value)) {
             return false;
         }
         return !!value && typeof value === OBJECT;
     }
-    var isArray = ( _pureRef(ArrCls, "isArray"));
-    var isNumber = ( _createIs("number"));
-    var isRegExp = ( _createObjIs("RegExp"));
-    var isError = ( _createObjIs("Error"));
+    var isArray = (_pureRef(ArrCls, "isArray"));
+    function isArrayLike(arg) {
+        return !isStrictNullOrUndefined(arg) && !isFunction(arg) && isNumber(arg[LENGTH]) && arg[LENGTH] >= 0;
+    }
+    var isNumber = (_createIs("number"));
+    var isRegExp = (_createObjIs("RegExp"));
+    var isError = (_createObjIs("Error"));
     function isPromiseLike(value) {
         return !!(value && value.then && isFunction(value.then));
     }
@@ -116,7 +130,7 @@
     function _returnFalse() {
         return false;
     }
-    var asString = ( _pureAssign(StrCls));
+    var asString = (_pureAssign(StrCls));
     var ERROR_TYPE = "[object Error]";
     function dumpObj(object, format) {
         var propertyValueDump = EMPTY;
@@ -152,8 +166,8 @@
     function objHasOwnProperty(obj, prop) {
         return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);
     }
-    var _objGetOwnPropertyDescriptor$2 = ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
-    var objHasOwn = ( _pureAssign(( _pureRef(ObjClass, "hasOwn")), polyObjHasOwn));
+    var _objGetOwnPropertyDescriptor$2 = (_pureAssign((_pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
+    var objHasOwn = (_pureAssign((_pureRef(ObjClass, "hasOwn")), polyObjHasOwn));
     function polyObjHasOwn(obj, prop) {
         _throwIfNullOrUndefined(obj);
         return objHasOwnProperty(obj, prop) || !!_objGetOwnPropertyDescriptor$2(obj, prop);
@@ -162,7 +176,7 @@
         if (theObject && (isObject(theObject) || isFunction(theObject))) {
             for (var prop in theObject) {
                 if (objHasOwn(theObject, prop)) {
-                    if (callbackfn[CALL](thisArg || theObject, prop, theObject[prop]) === -1) {
+                    if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? theObject : thisArg, prop, theObject[prop]) === -1) {
                         break;
                     }
                 }
@@ -174,14 +188,14 @@
             var len = theArray[LENGTH] >>> 0;
             for (var idx = 0; idx < len; idx++) {
                 if (idx in theArray) {
-                    if (callbackfn[CALL](thisArg || theArray, theArray[idx], idx, theArray) === -1) {
+                    if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? theArray : thisArg, theArray[idx], idx, theArray) === -1) {
                         break;
                     }
                 }
             }
         }
     }
-    var _unwrapFunction = ( _unwrapFunctionWithPoly);
+    var _unwrapFunction = _unwrapFunctionWithPoly;
     function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
         var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
         return function (thisArg) {
@@ -193,26 +207,43 @@
             throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
         };
     }
+    function _unwrapFunctionNoInstWithPoly(funcName, clsProto, polyFunc) {
+        var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
+        return function (thisArg) {
+            var theFunc = clsFn;
+            if (theFunc || polyFunc) {
+                var theArgs = arguments;
+                return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrSlice[CALL](theArgs, 1) : theArgs);
+            }
+            throwTypeError("\"" + asString(funcName) + "\" not defined for " + dumpObj(thisArg));
+        };
+    }
+    function _unwrapProp(propName) {
+        return function (thisArg) {
+            return thisArg[propName];
+        };
+    }
     function _objPropertyIsEnum(obj, propKey) {
         var desc;
         var fn = ObjClass.getOwnPropertyDescriptor;
         if (!isStrictNullOrUndefined(obj) && fn) {
             desc = safe(fn, [obj, propKey]).v || NULL_VALUE;
         }
-        if (!desc) {
+        if (!desc && !isStrictNullOrUndefined(obj)) {
             desc = safe(function () {
                 for (var key in obj) {
-                    if (key === propKey) {
-                        return { enumerable: true };
+                    if (key == propKey) {
+                        return { enumerable: objHasOwnProperty(obj, key) };
                     }
                 }
             }).v;
         }
         return (desc && desc.enumerable) || false;
     }
-    ( _unwrapFunctionWithPoly("propertyIsEnumerable", NULL_VALUE, _objPropertyIsEnum));
-    var _objGetOwnPropertyDescriptor$1 = ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
-    ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
+    (_unwrapFunctionWithPoly("propertyIsEnumerable", NULL_VALUE, _objPropertyIsEnum));
+    (_unwrapFunctionNoInstWithPoly("propertyIsEnumerable", ObjProto, _objPropertyIsEnum));
+    var _objGetOwnPropertyDescriptor$1 = (_pureAssign((_pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
+    (_pureAssign((_pureRef(ObjClass, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
     var propMap = {
         e: "enumerable",
         c: "configurable",
@@ -239,8 +270,8 @@
         });
         return prop;
     }
-    var objDefineProp = ( _pureRef(ObjClass, "defineProperty"));
-    var objDefineProperties = ( _pureRef(ObjClass, "defineProperties"));
+    var objDefineProp = (_pureRef(ObjClass, "defineProperty"));
+    var objDefineProperties = (_pureRef(ObjClass, "defineProperties"));
     function objDefine(target, key, propDesc) {
         return objDefineProp(target, key, _createProp(propDesc));
     }
@@ -281,9 +312,9 @@
         }
         return value1 === value2;
     }
-    var objIsFrozen = ( _pureAssign(( _pureRef(ObjClass, "isFrozen")), _returnFalse));
-    ( _pureAssign(( _pureRef(ObjClass, "isSealed")), _returnFalse));
-    var _objFreeze = ( _pureRef(ObjClass, "freeze"));
+    var objIsFrozen = (_pureAssign((_pureRef(ObjClass, "isFrozen")), _returnFalse));
+    (_pureAssign((_pureRef(ObjClass, "isSealed")), _returnFalse));
+    var _objFreeze = (_pureRef(ObjClass, "freeze"));
     function _doNothing(value) {
         return value;
     }
@@ -291,8 +322,8 @@
         _throwIfNullOrUndefined(value);
         return value[__PROTO__] || NULL_VALUE;
     }
-    ( _pureRef(ObjClass, "assign"));
-    var objKeys = ( _pureRef(ObjClass, "keys"));
+    (_pureRef(ObjClass, "assign"));
+    var objKeys = (_pureRef(ObjClass, "keys"));
     function _deepFreeze(val, visited) {
         if ((isArray(val) || isObject(val) || isFunction(val)) && !objIsFrozen(val)) {
             for (var lp = 0; lp < visited.length; lp++) {
@@ -311,16 +342,16 @@
     function objDeepFreeze(value) {
         return _objFreeze ? _deepFreeze(value, []) : value;
     }
-    var objFreeze = ( _pureAssign(_objFreeze, _doNothing));
-    ( _pureAssign(( _pureRef(ObjClass, "seal")), _doNothing));
-    var objGetPrototypeOf = ( _pureAssign(( _pureRef(ObjClass, "getPrototypeOf")), _getProto));
-    ( _pureAssign(( _pureRef(ObjClass, "entries")), polyObjEntries));
-    ( _pureAssign(( _pureRef(ObjClass, "values")), polyObjValues));
-    ( _pureAssign(( _pureRef(ObjClass, "is")), polyObjIs));
+    var objFreeze = (_pureAssign(_objFreeze, _doNothing));
+    (_pureAssign((_pureRef(ObjClass, "seal")), _doNothing));
+    var objGetPrototypeOf = (_pureAssign((_pureRef(ObjClass, "getPrototypeOf")), _getProto));
+    (_pureAssign((_pureRef(ObjClass, "entries")), polyObjEntries));
+    (_pureAssign((_pureRef(ObjClass, "values")), polyObjValues));
+    (_pureAssign((_pureRef(ObjClass, "is")), polyObjIs));
     function createEnumKeyMap(values) {
         return _createKeyValueMap(values, 0 , 0 , objFreeze);
     }
-    var _wellKnownSymbolMap = ( createEnumKeyMap({
+    var _wellKnownSymbolMap = (createEnumKeyMap({
         asyncIterator: 0 ,
         hasInstance: 1 ,
         isConcatSpreadable: 2 ,
@@ -360,11 +391,11 @@
         }
         return _globalCfg;
     }
-    ( _pureRef(MathCls, "min"));
-    var mathMax = ( _pureRef(MathCls, "max"));
-    var strSlice = ( _unwrapFunction("slice", StrProto));
-    var strSubstring = ( _unwrapFunction("substring", StrProto));
-    ( _unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr));
+    var mathMin = (_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) {
         _throwIfNullOrUndefined(value);
         if (length < 0) {
@@ -398,7 +429,7 @@
         }
         return target;
     }
-    var objCreate = ( _pureAssign(( _pureRef(ObjClass, "create")), polyObjCreate));
+    var objCreate = (_pureAssign((_pureRef(ObjClass, "create")), polyObjCreate));
     function polyObjCreate(obj, properties) {
         var newObj = null;
         function tempFunc() { }
@@ -430,6 +461,9 @@
     function fnApply(fn, thisArg, argArray) {
         return fn.apply(thisArg, argArray);
     }
+    function fnCall(fn, thisArg) {
+        return fn.apply(thisArg, ArrSlice[CALL](arguments, 2));
+    }
     var _globalLazyTestHooks;
     function _initTestHooks() {
         _globalLazyTestHooks = _getGlobalConfig();
@@ -453,8 +487,8 @@
         });
         return lazyValue;
     }
-    var mathRandom = ( _pureRef(MathCls, "random"));
-    var _uniqueInstanceId = ( getLazy(function () {
+    var mathRandom = (_pureRef(MathCls, "random"));
+    var _uniqueInstanceId = (getLazy(function () {
         var value = (utcNow().toString(36).slice(2));
         while (value.length < 16) {
             value += mathRandom().toString(36).slice(2);
@@ -557,14 +591,14 @@
         return NULL_VALUE;
     }
     function hasWindow() {
-        return !!( getWindow());
+        return !!getWindow();
     }
-    var getWindow = ( _getGlobalInstFn(getInst, [WINDOW]));
-    var getNavigator = ( _getGlobalInstFn(getInst, ["navigator"]));
+    var getWindow = (_getGlobalInstFn(getInst, [WINDOW]));
+    var getNavigator = (_getGlobalInstFn(getInst, ["navigator"]));
     var _symbol;
     var _symbolFor;
     function _initSymbol() {
-        _symbol = ( createCachedValue(safe((getInst), [SYMBOL]).v));
+        _symbol = (createCachedValue(safe((getInst), [SYMBOL]).v));
         return _symbol;
     }
     function _getSymbolKey(key) {
@@ -584,7 +618,7 @@
     }
     function symbolFor(key) {
         !_globalLazyTestHooks && _initTestHooks();
-        _symbolFor = ((!_globalLazyTestHooks.lzy ? _symbolFor : 0) || ( createCachedValue(safe((_getSymbolKey), ["for"]).v)));
+        _symbolFor = ((!_globalLazyTestHooks.lzy ? _symbolFor : 0) || (createCachedValue(safe((_getSymbolKey), ["for"]).v)));
         return (_symbolFor.v || polySymbolFor)(key);
     }
     function isIterator(value) {
@@ -606,7 +640,7 @@
                 try {
                     var count = 0;
                     while (!(iterResult = iter.next()).done) {
-                        if (callbackfn[CALL](thisArg || iter, iterResult.value, count, iter) === -1) {
+                        if (callbackfn[CALL](isStrictNullOrUndefined(thisArg) ? iter : thisArg, iterResult.value, count, iter) === -1) {
                             break;
                         }
                         count++;
@@ -650,11 +684,25 @@
         }
         return target;
     }
-    _unwrapFunction("every", ArrProto);
-    _unwrapFunction("filter", ArrProto);
-    var arrIndexOf = ( _unwrapFunction("indexOf", ArrProto));
-    ( _unwrapFunction("lastIndexOf", ArrProto));
-    var arrMap = ( _unwrapFunction("map", ArrProto));
+    (_unwrapFunction("concat", ArrProto));
+    _unwrapFunctionWithPoly("at", ArrProto, polyArrAt);
+    function polyArrAt(theArray, index) {
+        var result;
+        if (isArrayLike(theArray)) {
+            var len = theArray.length;
+            var idx = index;
+            if (idx < 0) {
+                idx = len + idx;
+            }
+            if (idx >= 0 && idx < len) {
+                result = theArray[idx];
+            }
+        }
+        return result;
+    }
+    var arrIndexOf = (_unwrapFunction("indexOf", ArrProto));
+    (_unwrapFunction("lastIndexOf", ArrProto));
+    var arrMap = (_unwrapFunction("map", ArrProto));
     function arrSlice(theArray, start, end) {
         return ((theArray ? theArray["slice"] : NULL_VALUE) || ArrSlice).apply(theArray, ArrSlice[CALL](arguments, 1));
     }
@@ -669,7 +717,7 @@
     function polyArrFindIndex(theArray, callbackFn, thisArg) {
         var result = -1;
         arrForEach(theArray, function (value, index) {
-            if (callbackFn[CALL](thisArg | theArray, value, index, theArray)) {
+            if (callbackFn[CALL](isStrictNullOrUndefined(thisArg) ? theArray : thisArg, value, index, theArray)) {
                 result = index;
                 return -1;
             }
@@ -685,7 +733,7 @@
         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)) {
+            if (idx in theArray && callbackFn[CALL](isStrictNullOrUndefined(thisArg) ? theArray : thisArg, theArray[idx], idx, theArray)) {
                 result = idx;
                 break;
             }
@@ -703,16 +751,167 @@
         });
         return result;
     }
+    (_unwrapFunctionWithPoly("includes", ArrProto, polyArrIncludes));
+    _unwrapFunction("every", ArrProto);
+    _unwrapFunction("filter", ArrProto);
+    var getLength = (_unwrapProp(LENGTH));
+    _unwrapFunctionWithPoly("fill", ArrProto, polyArrFill);
+    function polyArrFill(theArray, value, start, end) {
+        if (isArrayLike(theArray)) {
+            var len = getLength(theArray);
+            var startIdx = start === UNDEF_VALUE ? 0 : start;
+            var endIdx = end === UNDEF_VALUE ? len : end;
+            if (startIdx < 0) {
+                startIdx = mathMax(len + startIdx, 0);
+            }
+            else {
+                startIdx = mathMin(startIdx, len);
+            }
+            if (endIdx < 0) {
+                endIdx = mathMax(len + endIdx, 0);
+            }
+            else {
+                endIdx = mathMin(endIdx, len);
+            }
+            for (var i = startIdx; i < endIdx; i++) {
+                theArray[i] = value;
+            }
+        }
+        return theArray;
+    }
     _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));
+    _unwrapFunctionWithPoly("flatMap", ArrProto, polyArrFlatMap);
+    function polyArrFlatMap(theArray, callbackFn, thisArg) {
+        _throwIfNullOrUndefined(theArray);
+        if (!isFunction(callbackFn)) {
+            throwTypeError("callbackFn must be a function");
+        }
+        var result = [];
+        var callbackThis = arguments.length > 2 ? thisArg : undefined;
+        arrForEach(theArray, function (theValue, index) {
+            var value = fnCall(callbackFn, callbackThis, theValue, index, theArray);
+            if (isArray(value)) {
+                arrForEach(value, function (mappedValue) {
+                    result.push(mappedValue);
+                });
+            }
+            else {
+                result.push(value);
+            }
+        });
+        return result;
+    }
+    (_pureAssign((_pureRef(ArrCls, "from")), polyArrFrom));
+    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 (throwInfinity && (result === Infinity || result == Infinity)) {
+            throwRangeError("invalid value [" + dumpObj(value) + "]");
+        }
+        return result !== result || result === 0 ? 0 : mathTrunc(result);
+    }
+    function createIterableIterator(ctx) {
+        var iterator = createIterator(ctx);
+        var itSymbol = getKnownSymbol(3 );
+        function _createIterator() {
+            return iterator;
+        }
+        iterator[itSymbol] = _createIterator;
+        return iterator;
+    }
+    function createIterator(ctx) {
+        var isDone = false;
+        function _value() {
+            return ctx.v;
+        }
+        function _next() {
+            if (!isDone) {
+                isDone = (ctx.n ? ctx.n(arguments) : true);
+            }
+            var result = {
+                done: isDone
+            };
+            if (!isDone) {
+                objDefine(result, "value", { g: _value });
+            }
+            return result;
+        }
+        function _return(value) {
+            isDone = true;
+            return {
+                done: true,
+                value: ctx.r && ctx.r(value)
+            };
+        }
+        function _throw(e) {
+            isDone = true;
+            return {
+                done: true,
+                value: ctx.t && ctx.t(e)
+            };
+        }
+        var theIterator = {
+            next: _next
+        };
+        if (ctx.r) {
+            theIterator.return = _return;
+        }
+        if (ctx.t) {
+            theIterator.throw = _throw;
+        }
+        return theIterator;
+    }
+    _unwrapFunctionWithPoly("keys", ArrProto, polyArrKeys);
+    function polyArrKeys(value) {
+        _throwIfNullOrUndefined(value);
+        var idx = -1;
+        var len = mathToInt(value.length);
+        if (len < 0) {
+            len = 0;
+        }
+        return createIterableIterator({
+            n: function () {
+                idx++;
+                var isDone = idx >= len;
+                if (!isDone) {
+                    this.v = idx;
+                }
+                return isDone;
+            }
+        });
+    }
+    (_unwrapFunction("reduce", ArrProto));
+    (_unwrapFunction("reverse", ArrProto));
+    (_unwrapFunction("some", ArrProto));
+    _unwrapFunctionWithPoly("with", ArrProto, polyArrWith);
+    function polyArrWith(theArray, index, value) {
+        var result;
+        if (!isArrayLike(theArray)) {
+            throwRangeError("Invalid array");
+        }
+        var len = getLength(theArray);
+        var idx = index;
+        if (idx < 0) {
+            idx = len + idx;
+        }
+        if (idx < 0 || idx >= len) {
+            throwRangeError("Index out of bounds");
+        }
+        result = arrSlice(theArray);
+        result[idx] = value;
+        return result;
+    }
     var _isProtoArray;
-    var objSetPrototypeOf = ( _pureAssign(( _pureRef(ObjClass, "setPrototypeOf")), _polyObjSetPrototypeOf));
+    var objSetPrototypeOf = (_pureAssign((_pureRef(ObjClass, "setPrototypeOf")), _polyObjSetPrototypeOf));
     function _polyObjSetPrototypeOf(obj, proto) {
         var _a;
         !_isProtoArray && (_isProtoArray = createCachedValue((_a = {}, _a[__PROTO__] = [], _a) instanceof Array));
@@ -757,38 +956,26 @@
             }
         }, theBaseClass);
     }
+    var strReplace = (_unwrapFunction("replace", StrProto));
     function _createTrimFn(exp) {
         return function _doTrim(value) {
             _throwIfNullOrUndefined(value);
-            if (value && value.replace) {
-                value = value.replace(exp, EMPTY);
+            value = asString(value);
+            if (value) {
+                value = strReplace(value, 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 (throwInfinity && (result === Infinity || result == Infinity)) {
-            throwRangeError("invalid value [" + dumpObj(value) + "]");
-        }
-        return result !== result || result === 0 ? 0 : mathTrunc(result);
-    }
-    var strRepeat = ( _unwrapFunctionWithPoly("repeat", StrProto, polyStrRepeat));
+    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 strRepeat = (_unwrapFunctionWithPoly("repeat", StrProto, polyStrRepeat));
     function polyStrRepeat(value, count) {
         _throwIfNullOrUndefined(value);
         count = mathToInt(count, true);
@@ -821,74 +1008,18 @@
         }
         return result;
     }
-    ( _unwrapFunctionWithPoly("padStart", StrProto, polyStrPadStart));
-    ( _unwrapFunctionWithPoly("padEnd", StrProto, polyStrPadEnd));
+    (_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;
-    function isPlainObject(value) {
-        if (!value || typeof value !== OBJECT) {
-            return false;
-        }
-        if (!_gblWindow) {
-            _gblWindow = hasWindow() ? getWindow() : true;
-        }
-        var result = false;
-        if (value !== _gblWindow) {
-            if (!_objCtrFnString) {
-                _fnToString = Function[PROTOTYPE][TO_STRING];
-                _objCtrFnString = _fnToString[CALL](ObjClass);
-            }
-            try {
-                var proto = objGetPrototypeOf(value);
-                result = !proto;
-                if (!result) {
-                    if (objHasOwnProperty(proto, CONSTRUCTOR)) {
-                        proto = proto[CONSTRUCTOR];
-                    }
-                    result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);
-                }
-            }
-            catch (ex) {
-            }
-        }
-        return result;
-    }
-    function polyStrSymSplit(value, splitter, limit) {
-        var splitFn = splitter ? splitter[getKnownSymbol(9 )] : UNDEF_VALUE;
-        return splitFn ? splitFn(value, limit) : [value];
-    }
-    ( _unwrapFunction("split", StrProto));
-    ( _unwrapFunctionWithPoly("split", StrProto, polyStrSymSplit));
-    ( _pureAssign(( _pureRef(NumberCls, "isInteger")), _polyNumberIsInteger));
-    function _polyNumberIsInteger(value) {
-        return isNumber(value) && !isNaN(value) &&
-            isFinite(value) &&
-            mathFloor(value) === value;
-    }
-    ( _pureRef(MathCls, "abs"));
-    ( _pureRef(MathCls, "exp"));
-    ( _pureRef(MathCls, "log"));
-    ( _pureRef(MathCls, "asin"));
-    ( _pureRef(MathCls, "acos"));
-    ( _pureRef(MathCls, "atan"));
-    ( _pureRef(MathCls, "atan2"));
-    ( _pureRef(MathCls, "pow"));
-    ( _pureRef(MathCls, "sqrt"));
-    ( _pureRef(MathCls, "round"));
-    ( _pureRef(MathCls, "sin"));
-    ( _pureRef(MathCls, "cos"));
-    ( _pureRef(MathCls, "tan"));
     var _recursionCheckOwnDescriptors;
     var _recursionCheckOwnSymbols;
-    var _objGetOwnPropertyNames = ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_NAMES)), _returnEmptyArray));
-    var _objGetOwnPropertyDescriptor = ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
+    var _objGetOwnPropertyNames = (_pureAssign((_pureRef(ObjClass, GET_OWN_PROPERTY_NAMES)), _returnEmptyArray));
+    var _objGetOwnPropertyDescriptor = (_pureAssign((_pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
     function polyObjGetOwnPropertyDescriptors(obj) {
         var result = {};
         _throwIfNullOrUndefined(obj);
@@ -935,15 +1066,87 @@
         }
         return result;
     }
-    var objGetOwnPropertyDescriptor = ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
-    ( _pureAssign(( _pureRef(ObjClass, "getOwnPropertyDescriptors")), polyObjGetOwnPropertyDescriptors));
-    ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_NAMES)), _returnEmptyArray));
-    ( _pureAssign(( _pureRef(ObjClass, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
+    var objGetOwnPropertyDescriptor = (_pureAssign((_pureRef(ObjClass, GET_OWN_PROPERTY_DESCRIPTOR)), _returnNothing));
+    (_pureAssign((_pureRef(ObjClass, "getOwnPropertyDescriptors")), polyObjGetOwnPropertyDescriptors));
+    (_pureAssign((_pureRef(ObjClass, GET_OWN_PROPERTY_NAMES)), _returnEmptyArray));
+    (_pureAssign((_pureRef(ObjClass, GET_OWN_PROPERTY_SYMBOLS)), _returnEmptyArray));
+    var _fnToString;
+    var _objCtrFnString;
+    var _gblWindow;
+    function isPlainObject(value) {
+        if (!value || typeof value !== OBJECT) {
+            return false;
+        }
+        if (!_gblWindow) {
+            _gblWindow = hasWindow() ? getWindow() : true;
+        }
+        var result = false;
+        if (value !== _gblWindow) {
+            if (!_objCtrFnString) {
+                _fnToString = Function[PROTOTYPE][TO_STRING];
+                _objCtrFnString = _fnToString[CALL](ObjClass);
+            }
+            try {
+                var proto = objGetPrototypeOf(value);
+                result = !proto;
+                if (!result) {
+                    if (objHasOwnProperty(proto, CONSTRUCTOR)) {
+                        proto = proto[CONSTRUCTOR];
+                    }
+                    result = !!(proto && typeof proto === FUNCTION && _fnToString[CALL](proto) === _objCtrFnString);
+                }
+            }
+            catch (ex) {
+            }
+        }
+        return result;
+    }
+    function polyStrSymSplit(value, splitter, limit) {
+        var splitFn = splitter ? splitter[getKnownSymbol(9 )] : UNDEF_VALUE;
+        return splitFn ? splitFn(value, limit) : [value];
+    }
+    (_unwrapFunction("split", StrProto));
+    (_unwrapFunctionWithPoly("split", StrProto, polyStrSymSplit));
+    (_pureAssign((_pureRef(NumberCls, "isInteger")), _polyNumberIsInteger));
+    function _polyNumberIsInteger(value) {
+        return isNumber(value) && !isNaN(value) &&
+            isFinite(value) &&
+            mathFloor(value) === value;
+    }
+    function createLiteralRegex(matcher) {
+        return new RegExp(strReplace(asString(matcher), /[.*+?^${}()|[\]\\]/g, "\\$&") || "(?:)", "g");
+    }
+    (_pureRef(MathCls, "abs"));
+    (_pureRef(MathCls, "exp"));
+    (_pureRef(MathCls, "log"));
+    (_pureRef(MathCls, "asin"));
+    (_pureRef(MathCls, "acos"));
+    (_pureRef(MathCls, "atan"));
+    (_pureRef(MathCls, "atan2"));
+    (_pureRef(MathCls, "pow"));
+    (_pureRef(MathCls, "sqrt"));
+    (_pureRef(MathCls, "round"));
+    (_pureRef(MathCls, "sin"));
+    (_pureRef(MathCls, "cos"));
+    (_pureRef(MathCls, "tan"));
     function polyObjFromEntries(entries) {
         var result = {};
+        function _defineProtoValue(value) {
+            Object.defineProperty(result, __PROTO__, {
+                value: value,
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        }
         function addEntry(entry) {
             if (isArray(entry) && entry.length >= 2) {
-                result[entry[0]] = entry[1];
+                if (entry[0] === __PROTO__) {
+                    _defineProtoValue(entry[1]);
+                }
+                else {
+                    result[entry[0]] = entry[1];
+                }
             }
         }
         if (isArray(entries)) {
@@ -954,26 +1157,125 @@
         }
         return result;
     }
-    ( _pureAssign(( _pureRef(ObjClass, "fromEntries")), polyObjFromEntries));
-    ( _pureAssign(( _pureRef(ObjClass, "preventExtensions")), _doNothing));
-    ( _pureAssign(( _pureRef(ObjClass, "isExtensible")), _returnFalse));
-    ( _unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith));
+    (_pureAssign((_pureRef(ObjClass, "fromEntries")), polyObjFromEntries));
+    (_pureAssign((_pureRef(ObjClass, "preventExtensions")), _doNothing));
+    (_pureAssign((_pureRef(ObjClass, "isExtensible")), _returnFalse));
+    var strIndexOf = (_unwrapFunction("indexOf", StrProto));
+    (_unwrapFunction("lastIndexOf", StrProto));
+    (_unwrapFunctionWithPoly("at", StrProto, polyStrAt));
+    function polyStrAt(value, index) {
+        _throwIfNullOrUndefined(value);
+        return polyArrAt(asString(value), mathToInt(index));
+    }
+    (_unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith));
     function polyStrEndsWith(value, searchString, length) {
         _throwIfNotString(value);
         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));
+    (_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));
+    (_unwrapFunctionWithPoly("matchAll", StrProto, polyStrMatchAll));
+    function _cloneRegExp(theRegex) {
+        var flags = theRegex.flags;
+        if (flags === undefined) {
+            flags = EMPTY;
+            theRegex.global && (flags += "g");
+            theRegex.ignoreCase && (flags += "i");
+            theRegex.multiline && (flags += "m");
+            theRegex.dotAll && (flags += "s");
+            theRegex.unicode && (flags += "u");
+            theRegex.sticky && (flags += "y");
+        }
+        var result = new RegExp(theRegex.source, flags);
+        result.lastIndex = mathMax(0, theRegex.lastIndex);
+        return result;
+    }
+    function _advanceStringIndex(value, index, unicode) {
+        var newIndex = index + 1;
+        if (unicode) {
+            if (index < value.length) {
+                var first = value.charCodeAt(index);
+                if (first >= 0xD800 && first <= 0xDBFF) {
+                    var second = value.charCodeAt(index + 1);
+                    if (second >= 0xDC00 && second <= 0xDFFF) {
+                        newIndex++;
+                    }
+                }
+            }
+        }
+        return newIndex;
+    }
+    function polyStrMatchAll(value, matcher) {
+        _throwIfNullOrUndefined(value);
+        var result;
+        var matchSym = getKnownSymbol(4 );
+        var isMatcherRegExp = isRegExp(matcher)
+            && (!matcher || isStrictNullOrUndefined(matcher[matchSym]) || matcher[matchSym] !== false);
+        if (isMatcherRegExp && !matcher.global) {
+            throwTypeError("matcher must be a global regular expression");
+        }
+        var theValue = asString(value);
+        var matchAllFn = matcher && matcher[getKnownSymbol(5 )];
+        if (isFunction(matchAllFn)) {
+            result = matchAllFn.call(matcher, theValue);
+        }
+        else {
+            var theRegex_1 = isMatcherRegExp ? _cloneRegExp(matcher) : new RegExp(matcher, "g");
+            var ctx_1 = {
+                n: function () {
+                    var match = theRegex_1.exec(theValue);
+                    if (!match) {
+                        return true;
+                    }
+                    if (match[0] === EMPTY) {
+                        theRegex_1.lastIndex = _advanceStringIndex(theValue, theRegex_1.lastIndex, !!theRegex_1.unicode);
+                    }
+                    ctx_1.v = match;
+                    return false;
+                },
+                v: undefined
+            };
+            result = createIterableIterator(ctx_1);
+        }
+        return result;
+    }
+    (_unwrapFunctionWithPoly("replaceAll", StrProto, polyStrReplaceAll));
+    function polyStrReplaceAll(value, searchValue, replaceValue) {
+        _throwIfNullOrUndefined(value);
+        var matchSymbol = getKnownSymbol(4 );
+        var replaceSymbol = getKnownSymbol(6 );
+        var replaceFn;
+        var matcher;
+        var isRegex = isRegExp(searchValue);
+        var theValue = isString(value) ? value : asString(value);
+        var isSearchNotNull = searchValue || !isStrictNullOrUndefined(searchValue);
+        if (isRegex && isSearchNotNull) {
+            isRegex = searchValue[matchSymbol] !== false;
+        }
+        if (isRegex) {
+            if (!searchValue.global) {
+                throwTypeError("searchValue must be a global regular expression");
+            }
+            matcher = searchValue;
+        }
+        else {
+            replaceFn = isSearchNotNull ? searchValue[replaceSymbol] : null;
+            if (isFunction(replaceFn)) {
+                return replaceFn.call(searchValue, theValue, replaceValue);
+            }
+            var search = isString(searchValue) ? searchValue : asString(searchValue);
+            matcher = createLiteralRegex(search);
+        }
+        return strReplace(theValue, matcher, replaceValue);
+    }
+    (_unwrapFunctionWithPoly("startsWith", StrProto, polyStrStartsWith));
     function polyStrStartsWith(value, searchString, position) {
         _throwIfNotString(value);
         var searchValue = isString(searchString) ? searchString : asString(searchString);
@@ -1124,9 +1426,11 @@
     var DynInstFuncTable = '_dynInstFuncs';
     var DynProxyTag = '_isDynProxy';
     var DynClassName = '_dynClass';
+    var DynBaseProtoFuncs = '_dynBaseFuncs';
     var DynClassNamePrefix = '_dynCls$';
     var DynInstChkTag = '_dynInstChk';
     var DynAllowInstChkTag = DynInstChkTag;
+    var DynResolvedCachePrefix = '_dyn_r$';
     var DynProtoDefaultOptions = '_dfOpts';
     var UnknownValue = '_unknown_';
     var str__Proto = "__proto__";
@@ -1209,6 +1513,25 @@
         }
         return false;
     }
+    function _getBaseProtoFuncs(classProto) {
+        if (objHasOwnProperty(classProto, DynBaseProtoFuncs)) {
+            return classProto[DynBaseProtoFuncs];
+        }
+        var baseFuncSources = objCreate(null);
+        var baseProto = _getObjProto(classProto);
+        var visited = [];
+        while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
+            _forEachProp(baseProto, function (name) {
+                if (!baseFuncSources[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
+                    baseFuncSources[name] = baseProto;
+                }
+            });
+            visited.push(baseProto);
+            baseProto = _getObjProto(baseProto);
+        }
+        classProto[DynBaseProtoFuncs] = baseFuncSources;
+        return baseFuncSources;
+    }
     function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
         function _instFuncProxy(target, funcHost, funcName) {
             var theFunc = funcHost[funcName];
@@ -1226,16 +1549,11 @@
         _forEachProp(instFuncs, function (name) {
             baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
         });
-        var baseProto = _getObjProto(classProto);
-        var visited = [];
-        while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
-            _forEachProp(baseProto, function (name) {
-                if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
-                    baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
-                }
-            });
-            visited.push(baseProto);
-            baseProto = _getObjProto(baseProto);
+        var baseFuncSources = _getBaseProtoFuncs(classProto);
+        for (var name_2 in baseFuncSources) {
+            if (!baseFuncs[name_2]) {
+                baseFuncs[name_2] = _instFuncProxy(thisTarget, baseFuncSources[name_2], name_2);
+            }
         }
         return baseFuncs;
     }
@@ -1249,16 +1567,18 @@
             }
             if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
                 var canAddInst = !objHasOwnProperty(target, funcName);
-                var objProto = _getObjProto(target);
-                var visited = [];
-                while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
-                    var protoFunc = objProto[funcName];
-                    if (protoFunc) {
-                        canAddInst = (protoFunc === currentDynProtoProxy);
-                        break;
+                if (canAddInst) {
+                    var objProto = _getObjProto(target);
+                    var visited = [];
+                    while (objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
+                        var protoFunc = objProto[funcName];
+                        if (protoFunc) {
+                            canAddInst = (protoFunc === currentDynProtoProxy);
+                            break;
+                        }
+                        visited.push(objProto);
+                        objProto = _getObjProto(objProto);
                     }
-                    visited.push(objProto);
-                    objProto = _getObjProto(objProto);
                 }
                 try {
                     if (canAddInst) {
@@ -1285,25 +1605,34 @@
     }
     function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
         function _createDynamicPrototype(proto, funcName) {
+            var cacheKey = DynResolvedCachePrefix + className + "." + funcName;
             var dynProtoProxy = function () {
-                var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
+                var instFuncTable = this[DynInstFuncTable];
+                var instFunc = instFuncTable ? instFuncTable[cacheKey] : undefined;
+                if (!instFunc) {
+                    instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
+                    if (instFuncTable) {
+                        instFuncTable[cacheKey] = instFunc;
+                    }
+                }
                 return instFunc.apply(this, arguments);
             };
             dynProtoProxy[DynProxyTag] = 1;
             return dynProtoProxy;
         }
         if (!_isObjectOrArrayPrototype(proto)) {
-            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || objCreate(null);
-            if (!_isObjectOrArrayPrototype(instFuncTable)) {
-                var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || objCreate(null));
-                if (instFuncTable[DynAllowInstChkTag] !== false) {
-                    instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+            var instFuncTable_1 = target[DynInstFuncTable] = target[DynInstFuncTable] || objCreate(null);
+            if (!_isObjectOrArrayPrototype(instFuncTable_1)) {
+                var instFuncs_1 = instFuncTable_1[className] = (instFuncTable_1[className] || objCreate(null));
+                if (instFuncTable_1[DynAllowInstChkTag] !== false) {
+                    instFuncTable_1[DynAllowInstChkTag] = !!setInstanceFunc;
                 }
                 if (!_isObjectOrArrayPrototype(instFuncs_1)) {
                     _forEachProp(target, function (name) {
                         if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
                             instFuncs_1[name] = target[name];
                             delete target[name];
+                            delete instFuncTable_1[DynResolvedCachePrefix + className + "." + name];
                             if (!objHasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
                                 proto[name] = _createDynamicPrototype(proto, name);
                             }
@@ -1608,7 +1937,7 @@
         return result;
     }
 
-    var version = '3.4.2-nightly3.2605-01';
+    var version = "3.4.3-nightly3.2606-03";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {