@microsoft/applicationinsights-react-native 4.3.7-nightly.2504-04 → 4.3.7-nightly.2504-05

package/browser/applicationinsights-react-native.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - React Native Plugin, 4.3.7-nightly.2504-04
+ * Application Insights JavaScript SDK - React Native Plugin, 4.3.7-nightly.2504-05
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -18,7 +18,7 @@
     var strShimPrototype = "prototype";
     var ObjClass$1 = Object;
 
-    /*! https://github.com/nevware21/ts-utils v0.11.8 */
+    /*! https://github.com/nevware21/ts-utils v0.12.1 */
     function _pureAssign(func1, func2) {
         return func1 || func2;
     }
@@ -35,11 +35,12 @@
     var UNDEFINED = "undefined";
     var CONSTRUCTOR = "constructor";
     var SYMBOL = "Symbol";
-    var POLYFILL_TAG = "_polyfill";
     var LENGTH = "length";
     var NAME = "name";
     var CALL = "call";
     var TO_STRING = "toString";
+    var GETTER_NAME = "__lookupGetter__";
+    var SETTER_NAME = "__lookupSetter__";
     var ObjClass = ( _pureAssign(Object));
     var ObjProto = ( _pureRef(ObjClass, PROTOTYPE));
     var StrCls = ( _pureAssign(String));
@@ -48,6 +49,9 @@
     var ArrCls = ( _pureAssign(Array));
     var ArrProto = ( _pureRef(ArrCls, PROTOTYPE));
     var ArrSlice = ( _pureRef(ArrProto, "slice"));
+    var NumberCls = ( _pureAssign(Number));
+    var POLYFILL_TAG = "_polyfill";
+    var POLYFILL_TYPE_NAME = "__nw21$polytype__";
     function safe(func, argArray) {
         try {
             return {
@@ -76,13 +80,13 @@
         return typeof value === UNDEFINED || value === UNDEFINED;
     }
     function isStrictUndefined(arg) {
-        return !isDefined(arg);
+        return arg === UNDEF_VALUE;
     }
     function isNullOrUndefined(value) {
         return value === NULL_VALUE || isUndefined(value);
     }
     function isStrictNullOrUndefined(value) {
-        return value === NULL_VALUE || !isDefined(value);
+        return value === NULL_VALUE || value === UNDEF_VALUE;
     }
     function isDefined(arg) {
         return !!arg || arg !== UNDEF_VALUE;
@@ -96,21 +100,129 @@
         return !!value && typeof value === OBJECT;
     }
     var isArray = ( _pureRef(ArrCls, "isArray"));
+    var isNumber = ( _createIs("number"));
     var isRegExp = ( _createObjIs("RegExp"));
     var isError = ( _createObjIs("Error"));
     function isPromiseLike(value) {
         return !!(value && value.then && isFunction(value.then));
     }
-    var objGetOwnPropertyDescriptor = ( _pureRef(ObjClass, "getOwnPropertyDescriptor"));
+    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: ") : NULL_VALUE) || 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 _throwIfNullOrUndefined(obj) {
+        if (isStrictNullOrUndefined(obj)) {
+            throwTypeError("Cannot convert undefined or null to object");
+        }
+    }
+    function _throwIfNotString(value) {
+        if (!isString(value)) {
+            throwTypeError("'" + dumpObj(value) + "' is not a string");
+        }
+    }
     function objHasOwnProperty(obj, prop) {
         return !!obj && ObjProto.hasOwnProperty[CALL](obj, prop);
     }
-    var objHasOwn = ( _pureAssign(( _pureRef(ObjClass, "hasOwn")), polyObjHasOwn));
+    var _unwrapFunction = ( _unwrapFunctionWithPoly);
+    function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
+        var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
+        return function (thisArg) {
+            var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || 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 _objPropertyIsEnum(obj, propKey) {
+        var desc;
+        var fn = ObjClass.getOwnPropertyDescriptor;
+        if (!isStrictNullOrUndefined(obj) && fn) {
+            desc = safe(fn, [obj, propKey]).v || NULL_VALUE;
+        }
+        if (!desc) {
+            desc = safe(function () {
+                for (var key in obj) {
+                    if (key === propKey) {
+                        return { enumerable: true };
+                    }
+                }
+            }).v;
+        }
+        return (desc && desc.enumerable) || false;
+    }
+    var objPropertyIsEnumerable = ( _unwrapFunctionWithPoly("propertyIsEnumerable", NULL_VALUE, _objPropertyIsEnum));
+    function _isPropertyWritable(obj, prop) {
+        var result = false;
+        if (!(isString(obj) && (prop === LENGTH || isNumber(prop) || (isString(prop) && !isNaN(Number(prop)))))) {
+            var originalValue = obj[prop];
+            try {
+                obj[prop] = originalValue;
+                result = true;
+            }
+            catch (e) {
+            }
+        }
+        return result;
+    }
+    function polyObjGetOwnPropertyDescriptor(obj, prop) {
+        var descriptor;
+        _throwIfNullOrUndefined(obj);
+        var isLength = (prop === LENGTH && (isArray(obj) || isString(obj)));
+        if (isLength || objHasOwnProperty(obj, prop)) {
+            descriptor = {
+                configurable: !isLength,
+                enumerable: !isLength ? objPropertyIsEnumerable(obj, prop) : false
+            };
+            var isData = true;
+            if (GETTER_NAME in ObjProto && SETTER_NAME in ObjProto) {
+                var getter = obj[GETTER_NAME](prop);
+                var setter = obj[SETTER_NAME](prop);
+                if (getter || setter) {
+                    isData = false;
+                    if (getter) {
+                        descriptor.get = getter;
+                    }
+                    if (setter) {
+                        descriptor.set = setter;
+                    }
+                }
+            }
+            if (isData) {
+                descriptor.value = obj[prop];
+                descriptor.writable = _isPropertyWritable(obj, prop);
+            }
+        }
+        return descriptor;
+    }
+    var objGetOwnPropertyDescriptor = ( _pureAssign(( _pureRef(ObjClass, "getOwnPropertyDescriptor")), polyObjGetOwnPropertyDescriptor));
     function polyObjHasOwn(obj, prop) {
+        _throwIfNullOrUndefined(obj);
         return objHasOwnProperty(obj, prop) || !!objGetOwnPropertyDescriptor(obj, prop);
     }
+    var objHasOwn = ( _pureAssign(( _pureRef(ObjClass, "hasOwn")), polyObjHasOwn));
     function objForEachKey(theObject, callbackfn, thisArg) {
-        if (theObject && isObject(theObject)) {
+        if (theObject && (isObject(theObject) || isFunction(theObject))) {
             for (var prop in theObject) {
                 if (objHasOwn(theObject, prop)) {
                     if (callbackfn[CALL](thisArg || theObject, prop, theObject[prop]) === -1) {
@@ -120,6 +232,19 @@
             }
         }
     }
+    ( _pureAssign(( _pureRef(ObjClass, "getOwnPropertySymbols")), function () { return []; }));
+    function arrForEach(theArray, callbackfn, thisArg) {
+        if (theArray) {
+            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) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
     var propMap = {
         e: "enumerable",
         c: "configurable",
@@ -147,7 +272,7 @@
         return prop;
     }
     var objDefineProp = ( _pureRef(ObjClass, "defineProperty"));
-    ( _pureRef(ObjClass, "defineProperties"));
+    var objDefineProperties = ( _pureRef(ObjClass, "defineProperties"));
     function objDefine(target, key, propDesc) {
         return objDefineProp(target, key, _createProp(propDesc));
     }
@@ -166,59 +291,95 @@
             writable: false
         });
     }
-    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: ") : NULL_VALUE) || asString(object);
+    function polyObjEntries(value) {
+        var result = [];
+        objForEachKey(value, function (key, value) {
+            result.push([key, value]);
+        });
+        return result;
+    }
+    function polyObjIs(value1, value2) {
+        if (value1 !== value1) {
+            return value2 !== value2;
         }
-        catch (e) {
-            propertyValueDump = " - " + dumpObj(e, format);
+        if (value1 === 0 && value2 === 0) {
+            return 1 / value1 === 1 / value2;
         }
-        return objType + ": " + propertyValueDump;
-    }
-    function throwTypeError(message) {
-        throw new TypeError(message);
-    }
-    function throwRangeError(message) {
-        throw new RangeError(message);
+        return value1 === value2;
     }
-    function polyObjEntries(value) {
+    function polyObjValues(value) {
         var result = [];
         objForEachKey(value, function (key, value) {
-            result.push([key, value]);
+            result.push(value);
         });
         return result;
     }
+    function polyObjIsFrozen(obj) {
+        if (isStrictNullOrUndefined(obj) || (!isObject(obj) && !isFunction(obj))) {
+            return true;
+        }
+        if (isFunction(obj)) {
+            return false;
+        }
+        for (var prop in obj) {
+            var desc = objGetOwnPropertyDescriptor(obj, prop);
+            if (desc && (desc.configurable || (desc.writable !== false && "value" in desc))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function polyObjIsSealed(obj) {
+        if (isStrictNullOrUndefined(obj) || (!isObject(obj) && !isFunction(obj))) {
+            return true;
+        }
+        if (isFunction(obj)) {
+            return false;
+        }
+        for (var prop in obj) {
+            var desc = objGetOwnPropertyDescriptor(obj, prop);
+            if (desc && desc.configurable) {
+                return false;
+            }
+        }
+        return true;
+    }
+    var objIsFrozen = ( _pureAssign(( _pureRef(ObjClass, "isFrozen")), polyObjIsFrozen));
+    ( _pureAssign(( _pureRef(ObjClass, "isSealed")), polyObjIsSealed));
     var _objFreeze = ( _pureRef(ObjClass, "freeze"));
     function _doNothing(value) {
         return value;
     }
     function _getProto(value) {
+        _throwIfNullOrUndefined(value);
         return value[__PROTO__] || NULL_VALUE;
     }
     ( _pureRef(ObjClass, "assign"));
     var objKeys = ( _pureRef(ObjClass, "keys"));
-    function objDeepFreeze(value) {
-        if (_objFreeze) {
-            objForEachKey(value, function (key, value) {
-                if (isArray(value) || isObject(value)) {
-                    objDeepFreeze(value);
+    function _deepFreeze(val, visited) {
+        if ((isArray(val) || isObject(val) || isFunction(val)) && !objIsFrozen(val)) {
+            for (var lp = 0; lp < visited.length; lp++) {
+                if (visited[lp] === val) {
+                    return val;
                 }
+            }
+            visited.push(val);
+            objForEachKey(val, function (_key, propValue) {
+                _deepFreeze(propValue, visited);
             });
+            objFreeze(val);
         }
-        return objFreeze(value);
+        return val;
+    }
+    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));
     function createEnumKeyMap(values) {
         return _createKeyValueMap(values, 0 , 0 , objFreeze);
     }
@@ -262,27 +423,13 @@
         }
         return _globalCfg;
     }
-    var _unwrapFunction = ( _unwrapFunctionWithPoly);
-    function _unwrapFunctionWithPoly(funcName, clsProto, polyFunc) {
-        var clsFn = clsProto ? clsProto[funcName] : NULL_VALUE;
-        return function (thisArg) {
-            var theFunc = (thisArg ? thisArg[funcName] : NULL_VALUE) || 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));
-        };
-    }
     ( _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));
-        }
+        _throwIfNullOrUndefined(value);
         if (length < 0) {
             return EMPTY;
         }
@@ -295,8 +442,104 @@
         }
         return strSlice(value, start, start + length);
     }
+    function _tagAsPolyfill(target, polyfillTypeName) {
+        if (target) {
+            safe(function () {
+                target[POLYFILL_TAG] = true;
+                target[POLYFILL_TYPE_NAME] = polyfillTypeName;
+            });
+            safe(objDefine, [target, POLYFILL_TAG, {
+                    v: true,
+                    w: false,
+                    e: false
+                }]);
+            safe(objDefine, [target, POLYFILL_TYPE_NAME, {
+                    v: polyfillTypeName,
+                    w: false,
+                    e: false
+                }]);
+        }
+        return target;
+    }
+    function createCachedValue(value) {
+        return objDefineProp({
+            toJSON: function () { return value; }
+        }, "v", { value: value });
+    }
+    var _isProtoArray;
+    var objSetPrototypeOf = ( _pureAssign(( _pureRef(ObjClass, "setPrototypeOf")), _polyObjSetPrototypeOf));
+    function _polyObjSetPrototypeOf(obj, proto) {
+        var _a;
+        !_isProtoArray && (_isProtoArray = createCachedValue((_a = {}, _a[__PROTO__] = [], _a) instanceof Array));
+        _isProtoArray.v ? obj[__PROTO__] = proto : objForEachKey(proto, function (key, value) { return obj[key] = value; });
+        return obj;
+    }
+    var objCreate = ( _pureAssign(( _pureRef(ObjClass, "create")), polyObjCreate));
+    function polyObjCreate(obj, properties) {
+        var newObj;
+        function tempFunc() { }
+        if (!isStrictNullOrUndefined(obj)) {
+            var type = typeof obj;
+            if (type !== OBJECT && type !== FUNCTION) {
+                throwTypeError("Prototype must be an Object or function: " + dumpObj(obj));
+            }
+            tempFunc[PROTOTYPE] = obj;
+            safe(function () {
+                tempFunc[__PROTO__] = obj;
+            });
+            newObj = new tempFunc();
+        }
+        else {
+            newObj = {};
+        }
+        safe(_polyObjSetPrototypeOf, [newObj, obj]);
+        if (properties) {
+            safe(objDefineProperties, [newObj, properties]);
+        }
+        return newObj;
+    }
+    function utcNow() {
+        return (Date.now || polyUtcNow)();
+    }
+    function polyUtcNow() {
+        return new Date().getTime();
+    }
+    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;
+    }
+    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);
+        }
+        value = value.substring(0, 16);
+        return value;
+    }));
     var UNIQUE_REGISTRY_ID = "_urid";
+    var POLY_SYM = "$nw21sym";
     var _polySymbols;
+    var _polyId = 0;
     function _globalSymbolRegistry() {
         if (!_polySymbols) {
             var gblCfg = _getGlobalConfig();
@@ -306,12 +549,35 @@
     }
     var _wellKnownSymbolCache;
     function polyNewSymbol(description) {
-        var theSymbol = {
-            description: asString(description),
-            toString: function () { return SYMBOL + "(" + description + ")"; }
-        };
-        theSymbol[POLYFILL_TAG] = true;
-        return theSymbol;
+        var uniqueId = "_" + _polyId++ + "_" + _uniqueInstanceId.v;
+        var symString = SYMBOL + "(" + description + ")";
+        var theSymbol = objCreate(null);
+        objDefine(theSymbol, "description", {
+            v: asString(description),
+            e: false,
+            w: false
+        });
+        objDefine(theSymbol, TO_STRING, {
+            v: function () { return symString + POLY_SYM + uniqueId; },
+            e: false,
+            w: false
+        });
+        objDefine(theSymbol, "valueOf", {
+            v: function () { return theSymbol; },
+            e: false,
+            w: false
+        });
+        objDefine(theSymbol, "v", {
+            v: symString,
+            e: false,
+            w: false
+        });
+        objDefine(theSymbol, "_uid", {
+            v: uniqueId,
+            e: false,
+            w: false
+        });
+        return _tagAsPolyfill(theSymbol, "symbol");
     }
     function polySymbolFor(key) {
         var registry = _globalSymbolRegistry();
@@ -333,15 +599,6 @@
         }
         return result;
     }
-    var _globalLazyTestHooks;
-    function _initTestHooks() {
-        _globalLazyTestHooks = _getGlobalConfig();
-    }
-    function createCachedValue(value) {
-        return objDefineProp({
-            toJSON: function () { return value; }
-        }, "v", { value: value });
-    }
     var WINDOW = "window";
     var _cachedGlobal;
     function _getGlobalInstFn(getFn, theArgs) {
@@ -487,18 +744,6 @@
     }
     _unwrapFunction("every", ArrProto);
     _unwrapFunction("filter", ArrProto);
-    function arrForEach(theArray, callbackfn, thisArg) {
-        if (theArray) {
-            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) {
-                        break;
-                    }
-                }
-            }
-        }
-    }
     var arrIndexOf = ( _unwrapFunction("indexOf", ArrProto));
     ( _unwrapFunction("lastIndexOf", ArrProto));
     var arrMap = ( _unwrapFunction("map", ArrProto));
@@ -558,29 +803,6 @@
     ( _unwrapFunctionWithPoly("includes", ArrProto, polyArrIncludes));
     ( _unwrapFunction("reduce", ArrProto));
     ( _unwrapFunction("some", ArrProto));
-    var objCreate = ( _pureAssign(( _pureRef(ObjClass, "create")), polyObjCreate));
-    function polyObjCreate(obj) {
-        if (!obj) {
-            return {};
-        }
-        var type = typeof obj;
-        if (type !== OBJECT && type !== FUNCTION) {
-            throwTypeError("Prototype must be an Object or function: " + dumpObj(obj));
-        }
-        function tempFunc() { }
-        tempFunc[PROTOTYPE] = obj;
-        return new tempFunc();
-    }
-    var _isProtoArray;
-    function objSetPrototypeOf(obj, proto) {
-        var fn = ObjClass["setPrototypeOf"] ||
-            function (d, b) {
-                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);
@@ -619,17 +841,9 @@
             }
         }, 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) + "]");
-            }
+            _throwIfNullOrUndefined(value);
             if (value && value.replace) {
                 value = value.replace(exp, EMPTY);
             }
@@ -660,9 +874,7 @@
     }
     var strRepeat = ( _unwrapFunctionWithPoly("repeat", StrProto, polyStrRepeat));
     function polyStrRepeat(value, count) {
-        if (isNullOrUndefined(value)) {
-            throwTypeError("can't convert [" + dumpObj(value) + "]");
-        }
+        _throwIfNullOrUndefined(value);
         count = mathToInt(count, true);
         if (count < 0) {
             throwRangeError("invalid count must be >= 0 && < Infinity");
@@ -732,18 +944,130 @@
         }
         return result;
     }
-    ( _pureRef(MathCls, "round"));
     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, !hasSymbol() ? polyStrSymSplit : NULL_VALUE));
+    ( _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"));
+    function polyObjGetOwnPropertyNames(obj) {
+        var result = [];
+        _throwIfNullOrUndefined(obj);
+        for (var key in obj) {
+            if (ObjProto.hasOwnProperty.call(obj, key)) {
+                result.push(key);
+            }
+        }
+        if (isArray(obj) || isString(obj)) {
+            if (arrIndexOf(result, LENGTH) === -1) {
+                result.push(LENGTH);
+            }
+        }
+        return result;
+    }
+    var objGetOwnPropertyNames = ( _pureAssign(( _pureRef(ObjClass, "getOwnPropertyNames")), polyObjGetOwnPropertyNames));
+    var recursionCheckOwnDescriptors;
+    function polyObjGetOwnPropertyDescriptors(obj) {
+        var result = {};
+        _throwIfNullOrUndefined(obj);
+        if (!recursionCheckOwnDescriptors) {
+            try {
+                recursionCheckOwnDescriptors = true;
+                arrForEach(objGetOwnPropertyNames(obj), function (propName) {
+                    var descriptor = polyObjGetOwnPropertyDescriptor(obj, propName);
+                    if (descriptor !== undefined) {
+                        result[propName] = descriptor;
+                    }
+                });
+                arrForEach(polyObjGetOwnPropertySymbols(obj), function (sym) {
+                    var descriptor = polyObjGetOwnPropertyDescriptor(obj, sym);
+                    if (descriptor !== undefined) {
+                        result[sym] = descriptor;
+                    }
+                });
+            }
+            finally {
+                recursionCheckOwnDescriptors = false;
+            }
+        }
+        return result;
+    }
+    var recursionCheckOwnSymbols;
+    function polyObjGetOwnPropertySymbols(obj) {
+        var result = [];
+        var objHasOwn = ObjClass.hasOwn || polyObjHasOwn;
+        if (!recursionCheckOwnSymbols) {
+            try {
+                recursionCheckOwnSymbols = true;
+                var symEnum = 0 ;
+                while (symEnum <= 12 ) {
+                    var sym = getKnownSymbol(symEnum);
+                    if (sym && objHasOwn(obj, sym)) {
+                        result.push(sym);
+                    }
+                    symEnum++;
+                }
+            }
+            finally {
+                recursionCheckOwnSymbols = false;
+            }
+        }
+        return result;
+    }
+    ( _pureAssign(( _pureRef(ObjClass, "getOwnPropertyDescriptors")), polyObjGetOwnPropertyDescriptors));
+    function polyObjFromEntries(entries) {
+        var result = {};
+        function addEntry(entry) {
+            if (isArray(entry) && entry.length >= 2) {
+                result[entry[0]] = entry[1];
+            }
+        }
+        if (isArray(entries)) {
+            arrForEach(entries, addEntry);
+        }
+        else if (isIterable(entries)) {
+            iterForOf(entries, addEntry);
+        }
+        return result;
+    }
+    ( _pureAssign(( _pureRef(ObjClass, "fromEntries")), polyObjFromEntries));
+    function polyObjIsExtensible(obj) {
+        if (isStrictNullOrUndefined(obj) || (!isObject(obj) && !isFunction(obj))) {
+            return false;
+        }
+        return true;
+    }
+    function polyObjPreventExtensions(obj) {
+        _throwIfNullOrUndefined(obj);
+        if (!isObject(obj) && !isFunction(obj)) {
+            throwTypeError("objPreventExtensions can only be called on Objects");
+        }
+        return obj;
+    }
+    ( _pureAssign(( _pureRef(ObjClass, "preventExtensions")), polyObjPreventExtensions));
+    ( _pureAssign(( _pureRef(ObjClass, "isExtensible")), polyObjIsExtensible));
     ( _unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith));
     function polyStrEndsWith(value, searchString, length) {
-        if (!isString(value)) {
-            throwTypeError("'" + dumpObj(value) + "' is not a string");
-        }
+        _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;
@@ -759,9 +1083,7 @@
     }
     ( _unwrapFunctionWithPoly("startsWith", StrProto, polyStrStartsWith));
     function polyStrStartsWith(value, searchString, position) {
-        if (!isString(value)) {
-            throwTypeError("'" + dumpObj(value) + "' is not a string");
-        }
+        _throwIfNotString(value);
         var searchValue = isString(searchString) ? searchString : asString(searchString);
         var pos = position > 0 ? position : 0;
         return strSubstring(value, pos, pos + searchValue[LENGTH]) === searchValue;
@@ -1358,7 +1680,7 @@
         return result;
     }
 
-    var version = '3.3.7-nightly3.2504-08';
+    var version = '3.3.7-nightly3.2504-11';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {