@microsoft/applicationinsights-core-js 3.0.3-nightly3.2305-14 → 3.0.3-nightly3.2307-24

package/dist/es5/applicationinsights-core-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Core, 3.0.3-nightly3.2305-14
+ * Application Insights JavaScript SDK - Core, 3.0.3-nightly3.2307-24
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -11,12 +11,14 @@
     var MinChannelPriorty = 100;
 
     var UNDEF_VALUE = undefined;
+    var NULL_VALUE = null;
     var EMPTY = "";
     var BOOLEAN = "boolean";
     var FUNCTION = "function";
     var NUMBER = "number";
     var OBJECT = "object";
     var PROTOTYPE = "prototype";
+    var __PROTO__ = "__proto__";
     var STRING = "string";
     var UNDEFINED = "undefined";
     var CONSTRUCTOR = "constructor";
@@ -68,21 +70,17 @@
         return typeof value === UNDEFINED || value === UNDEFINED;
     }
     function isNullOrUndefined(value) {
-        return value === null || isUndefined(value);
+        return value === NULL_VALUE || isUndefined(value);
     }
     function isStrictNullOrUndefined(value) {
-        return value === null || !isDefined(value);
+        return value === NULL_VALUE || !isDefined(value);
     }
     function isDefined(arg) {
         return !!arg || arg !== UNDEF_VALUE;
     }
-    function isPrimitive(value) {
-        var theType = typeof value;
-        if (value && theType === OBJECT) {
-            return false;
-        }
-        return value === null || PRIMITIVE_TYPES.indexOf(theType) !== -1;
-    }
+    var isPrimitiveType = function (theType) {
+        return theType !== OBJECT && PRIMITIVE_TYPES.indexOf(theType) !== -1;
+    };
     var isString = _createIs(STRING);
     var isFunction = _createIs(FUNCTION);
     function isObject(value) {
@@ -147,9 +145,10 @@
 
     var _objFreeze = ObjClass$1["freeze"];
     var _doNothing = function (value) { return value; };
+    var _getProto = function (value) { return value[__PROTO__] || NULL_VALUE; };
     var objAssign = ObjClass$1["assign"];
     function objKeys(value) {
-        if (!isObject(value) || value === null) {
+        if (!isObject(value) || value === NULL_VALUE) {
             throwTypeError("objKeys called on non-object");
         }
         return ObjClass$1.keys(value);
@@ -166,7 +165,7 @@
     }
     var objFreeze = _objFreeze || _doNothing;
     var objSeal = ObjClass$1["seal"] || _doNothing;
-    var objGetPrototypeOf = ObjClass$1["getPrototypeOf"] || _doNothing;
+    var objGetPrototypeOf = ObjClass$1["getPrototypeOf"] || _getProto;
 
     function createEnum(values) {
         return _createKeyValueMap(values, 1 , 0 , objDeepFreeze);
@@ -237,7 +236,7 @@
         }
         else {
             try {
-                propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
+                propertyValueDump = JSON.stringify(object, NULL_VALUE, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
             }
             catch (e) {
                 propertyValueDump = " - " + dumpObj(e, format);
@@ -246,16 +245,36 @@
         return objToString(object) + ": " + propertyValueDump;
     }
 
-    function _unwrapFunction(funcName, target, polyFunc) {
+    var _arrSlice = ArrProto[SLICE];
+    var _throwMissingFunction = function (funcName, thisArg) {
+        throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+    };
+    var _unwrapInstFunction = function (funcName) {
+        return function (thisArg) {
+            return thisArg[funcName].apply(thisArg, _arrSlice.call(arguments, 1));
+        };
+    };
+    var _unwrapFunction = function (funcName, clsProto) {
+        var clsFn = clsProto && clsProto[funcName];
+        return function (thisArg) {
+            var theFunc = (thisArg && thisArg[funcName]) || clsFn;
+            if (theFunc) {
+                return theFunc.apply(thisArg, _arrSlice.call(arguments, 1));
+            }
+            _throwMissingFunction(funcName, thisArg);
+        };
+    };
+    var _unwrapFunctionWithPoly = function (funcName, clsProto, polyFunc) {
+        var clsFn = clsProto && clsProto[funcName];
         return function (thisArg) {
-            var theFunc = (thisArg && thisArg[funcName]) || (target && target[funcName]);
+            var theFunc = (thisArg && thisArg[funcName]) || clsFn;
             if (theFunc || polyFunc) {
                 var theArgs = arguments;
-                return (theFunc || polyFunc).apply(thisArg, theFunc ? ArrProto[SLICE].call(theArgs, 1) : theArgs);
+                return (theFunc || polyFunc).apply(thisArg, theFunc ? _arrSlice.call(theArgs, 1) : theArgs);
             }
-            throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
+            _throwMissingFunction(funcName, thisArg);
         };
-    }
+    };
     function _unwrapProp(propName) {
         return function (thisArg) {
             return thisArg[propName];
@@ -267,7 +286,7 @@
     var strSlice = _unwrapFunction(SLICE, StrProto);
 
     var strSubstring = _unwrapFunction("substring", StrProto);
-    var strSubstr = _unwrapFunction("substr", StrProto, polyStrSubstr);
+    var strSubstr = _unwrapFunctionWithPoly("substr", StrProto, polyStrSubstr);
     function polyStrSubstr(value, start, length) {
         if (isNullOrUndefined(value)) {
             throwTypeError("'polyStrSubstr called with invalid " + dumpObj(value));
@@ -288,7 +307,7 @@
         return strSubstring(value, 0, count);
     }
 
-    var strStartsWith = _unwrapFunction("startsWith", StrProto, polyStrStartsWith);
+    var strStartsWith = _unwrapFunctionWithPoly("startsWith", StrProto, polyStrStartsWith);
     function polyStrStartsWith(value, searchString, position) {
         if (!isString(value)) {
             throwTypeError("'" + dumpObj(value) + "' is not a string");
@@ -381,7 +400,7 @@
     var _globalLazyTestHooks;
     var _fetchLazyTestHooks = function () {
         _globalLazyTestHooks = _getGlobalConfig();
-        _fetchLazyTestHooks = null;
+        _fetchLazyTestHooks = NULL_VALUE;
     };
     function getLazy(cb) {
         var lazyValue = {};
@@ -419,55 +438,45 @@
     var _cachedNavigator;
     var _cachedHistory;
     var _isNode;
-    function lazySafeGetInst(name) {
-        return safeGetLazy(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
-    }
-    function getGlobal(useCached) {
-        (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = safeGetLazy(_getGlobalValue, null));
+    var lazySafeGetInst = function (name) { return safeGetLazy(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE); };
+    var getGlobal = function (useCached) {
+        (!_cachedGlobal || useCached === false || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = safeGetLazy(_getGlobalValue, NULL_VALUE));
         return _cachedGlobal.v;
-    }
-    function getInst(name, useCached) {
-        var gbl = getGlobal(useCached);
+    };
+    var getInst = function (name, useCached) {
+        var gbl = (!_cachedGlobal || useCached === false) ? getGlobal(useCached) : _cachedGlobal.v;
         if (gbl && gbl[name]) {
             return gbl[name];
         }
         if (name === WINDOW && _cachedWindow) {
             return _cachedWindow.v;
         }
-        return null;
-    }
-    function hasDocument() {
-        return !!getDocument();
-    }
-    function getDocument() {
-        (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = lazySafeGetInst("document"));
+        return NULL_VALUE;
+    };
+    var hasDocument = function () { return !!getDocument(); };
+    var getDocument = function () {
+        (!_cachedDocument || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = lazySafeGetInst("document"));
         return _cachedDocument.v;
-    }
-    function hasWindow() {
-        return !!getWindow();
-    }
-    function getWindow() {
-        (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = lazySafeGetInst(WINDOW));
+    };
+    var hasWindow = function () { return !!getWindow(); };
+    var getWindow = function () {
+        (!_cachedWindow || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = lazySafeGetInst(WINDOW));
         return _cachedWindow.v;
-    }
-    function hasNavigator() {
-        return !!getNavigator();
-    }
-    function getNavigator() {
-        (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = lazySafeGetInst("navigator"));
+    };
+    var hasNavigator = function () { return !!getNavigator(); };
+    var getNavigator = function () {
+        (!_cachedNavigator || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = lazySafeGetInst("navigator"));
         return _cachedNavigator.v;
-    }
-    function hasHistory() {
-        return !!getHistory();
-    }
-    function getHistory() {
-        (!_cachedHistory || (_globalLazyTestHooks.lzy && !_cachedHistory.b)) && (_cachedHistory = lazySafeGetInst("history"));
+    };
+    var hasHistory = function () { return !!getHistory(); };
+    var getHistory = function () {
+        (!_cachedHistory || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_cachedHistory.b)) && (_cachedHistory = lazySafeGetInst("history"));
         return _cachedHistory.v;
-    }
-    function isNode() {
+    };
+    var isNode = function () {
         !_isNode && (_isNode = safeGetLazy(function () { return !!(process && (process.versions || {}).node); }, false));
         return _isNode.v;
-    }
+    };
 
     var _symbol;
     var _symbolFor;
@@ -495,7 +504,7 @@
     }
     function newSymbol(description, noPoly) {
         (!_symbol || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
-        return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : null);
+        return _symbol.v ? _symbol.v(description) : (!noPoly ? polyNewSymbol(description) : NULL_VALUE);
     }
     function symbolFor(key) {
         (!_symbolFor || (_globalLazyTestHooks.lzy && !_symbol.b)) && getSymbol();
@@ -509,36 +518,54 @@
         return !isStrictNullOrUndefined(value) && isFunction(value[getKnownSymbol(3 )]);
     }
 
+    var _iterSymbol;
     function iterForOf(iter, callbackfn, thisArg) {
         if (iter) {
             if (!isIterator(iter)) {
-                var itSymbol = getKnownSymbol(3 );
-                iter = iter[itSymbol] ? iter[itSymbol]() : null;
+                !_iterSymbol && (_iterSymbol = getLazy(function () { return getKnownSymbol(3 ); }));
+                iter = iter[_iterSymbol.v] ? iter[_iterSymbol.v]() : null;
             }
             if (isIterator(iter)) {
+                var err = void 0;
+                var iterResult = void 0;
                 try {
                     var count = 0;
-                    var value = iter.next();
-                    while (!value[DONE]) {
-                        if (callbackfn.call(thisArg || iter, value[VALUE], count, iter) === -1) {
+                    while (!(iterResult = iter.next())[DONE]) {
+                        if (callbackfn.call(thisArg || iter, iterResult[VALUE], count, iter) === -1) {
                             break;
                         }
                         count++;
-                        value = iter.next();
                     }
-                    iter.return && iter.return(value);
                 }
-                catch (e) {
-                    iter.throw && iter.throw(e);
+                catch (failed) {
+                    err = { e: failed };
+                    if (iter.throw) {
+                        iterResult = null;
+                        iter.throw(err);
+                    }
+                }
+                finally {
+                    try {
+                        if (iterResult && !iterResult[DONE]) {
+                            iter.return && iter.return(iterResult);
+                        }
+                    }
+                    finally {
+                        if (err) {
+                            throw err.e;
+                        }
+                    }
                 }
             }
         }
     }
 
+    var fnApply = _unwrapInstFunction("apply");
+
     function arrAppend(target, elms) {
         if (!isUndefined(elms) && target) {
             if (isArray(elms)) {
-                target.push.apply(target, elms);
+                fnApply(target.push, target, elms);
             }
             else if (isIterator(elms) || isIterable(elms)) {
                 iterForOf(elms, function (elm) {
@@ -569,55 +596,87 @@
 
     var arrMap = _unwrapFunction("map", ArrProto);
 
+    var arrSlice = _unwrapFunction(SLICE, ArrProto);
+
+    var fnCall = _unwrapInstFunction("call");
+
     var arrReduce = _unwrapFunction("reduce", ArrProto);
 
-    var arrSlice = _unwrapFunction(SLICE, ArrProto);
+    var _objCreate = ObjClass$1["create"];
+    var objCreate = _objCreate || polyObjCreate;
+    function polyObjCreate(obj) {
+        if (!obj) {
+            return {};
+        }
+        var type = typeof obj;
+        if (type !== OBJECT && type !== FUNCTION) {
+            throw new TypeError("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$1["setPrototypeOf"] ||
-            ({ __proto__: [] } instanceof Array && function (d, b) {
-                d.__proto__ = b;
-            }) ||
             function (d, b) {
-                objForEachKey(b, function (key, value) { return d[key] = value; });
+                !_isProtoArray && (_isProtoArray = getLazy(function () {
+                    var _a;
+                    return ((_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, baseClass) {
-        objSetPrototypeOf(d, baseClass);
+    var _createCustomError = function (name, d, b) {
+        _safeDefineName(d, name);
+        d = objSetPrototypeOf(d, b);
         function __() {
             this.constructor = d;
-            this[NAME] = name;
+            _safeDefineName(this, name);
         }
-        __[PROTOTYPE] = baseClass[PROTOTYPE];
-        d[PROTOTYPE] = new __();
+        d[PROTOTYPE] = b === NULL_VALUE ? objCreate(b) : (__[PROTOTYPE] = b[PROTOTYPE], new __());
         return d;
-    }
+    };
     var _safeSetName = function (baseClass, name) {
         try {
-            baseClass[PROTOTYPE][NAME] = name;
+            name && (baseClass[NAME] = name);
         }
         catch (e) {
         }
     };
-    function createCustomError(name, constructCb) {
-        var baseClass = Error;
-        var orgName = baseClass[PROTOTYPE][NAME];
-        var customError = _createCustomError(name, function () {
+    var _safeDefineName = function (target, name) {
+        try {
+            objDefine(target, NAME, { v: name, c: true, e: false });
+        }
+        catch (e) {
+        }
+    };
+    function createCustomError(name, constructCb, errorBase) {
+        var theBaseClass = errorBase || Error;
+        var orgName = theBaseClass[PROTOTYPE][NAME];
+        var captureFn = Error.captureStackTrace;
+        return _createCustomError(name, function () {
             var _this = this;
             try {
-                _safeSetName(baseClass, name);
-                _this = baseClass.apply(_this, arguments) || _this;
-                _this[NAME] = name;
-                constructCb && constructCb(_this, arguments);
+                _safeSetName(theBaseClass, name);
+                var _self = fnApply(theBaseClass, _this, arrSlice(arguments)) || _this;
+                if (_self !== _this) {
+                    var orgProto = objGetPrototypeOf(_this);
+                    if (orgProto !== objGetPrototypeOf(_self)) {
+                        objSetPrototypeOf(_self, orgProto);
+                    }
+                }
+                captureFn && captureFn(_self, _this[CONSTRUCTOR]);
+                constructCb && constructCb(_self, arguments);
+                return _self;
             }
             finally {
-                _safeSetName(baseClass, orgName);
+                _safeSetName(theBaseClass, orgName);
             }
-            return _this;
-        }, baseClass);
-        return customError;
+        }, theBaseClass);
     }
 
     function utcNow() {
@@ -640,7 +699,7 @@
     }
     var polyStrTrim = _createTrimFn(/^\s+|(?=\s)\s+$/g);
 
-    var strTrim = _unwrapFunction("trim", StrProto, polyStrTrim);
+    var strTrim = _unwrapFunctionWithPoly("trim", StrProto, polyStrTrim);
 
     var _fnToString;
     var _objCtrFnString;
@@ -656,7 +715,7 @@
         if (value !== _gblWindow) {
             if (!_objCtrFnString) {
                 _fnToString = Function[PROTOTYPE].toString;
-                _objCtrFnString = _fnToString.call(ObjClass$1);
+                _objCtrFnString = fnCall(_fnToString, ObjClass$1);
             }
             try {
                 var proto = objGetPrototypeOf(value);
@@ -674,11 +733,10 @@
         return result;
     }
 
-    function _defaultDeepCopyHandler(details) {
-        var target = details.result = {};
-        details.copyTo(target, details.value);
+    var _defaultDeepCopyHandler = function (details) {
+        details.value && plainObjDeepCopyHandler(details);
         return true;
-    }
+    };
     var defaultDeepCopyHandlers = [
         arrayDeepCopyHandler,
         plainObjDeepCopyHandler,
@@ -708,9 +766,19 @@
             src: ctx.src,
             path: newPath
         };
+        var theType = typeof value;
+        var isPlain = false;
+        var isPrim = false;
+        if (value && theType === OBJECT) {
+            isPlain = isPlainObject(value);
+        }
+        else {
+            isPrim = value === NULL_VALUE || isPrimitiveType(theType);
+        }
         var details = {
-            type: typeof value,
-            isPrim: isPrimitive(value),
+            type: theType,
+            isPrim: isPrim,
+            isPlain: isPlain,
             value: value,
             result: value,
             path: newPath,
@@ -734,12 +802,12 @@
                 });
                 var idx = 0;
                 var handler = userHandler;
-                while (!(handler || (idx < defaultDeepCopyHandlers.length ? defaultDeepCopyHandlers[idx++] : _defaultDeepCopyHandler)).call(ctx, details)) {
-                    handler = null;
+                while (!fnCall(handler || (idx < defaultDeepCopyHandlers.length ? defaultDeepCopyHandlers[idx++] : _defaultDeepCopyHandler), ctx, details)) {
+                    handler = NULL_VALUE;
                 }
             });
         }
-        if (userHandler && userHandler.call(ctx, details)) {
+        if (userHandler && fnCall(userHandler, ctx, details)) {
             return details.result;
         }
         return value;
@@ -793,7 +861,7 @@
     }
     function plainObjDeepCopyHandler(details) {
         var value = details.value;
-        if (isPlainObject(value)) {
+        if (value && details.isPlain) {
             var target = details.result = {};
             details.copyTo(target, value);
             return true;
@@ -815,7 +883,7 @@
 
     var _perf;
     function getPerformance() {
-        (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = lazySafeGetInst("performance"));
+        (!_perf || (!_perf.b && _globalLazyTestHooks && _globalLazyTestHooks.lzy)) && (_perf = lazySafeGetInst("performance"));
         return _perf.v;
     }
     function perfNow() {
@@ -826,22 +894,7 @@
         return utcNow();
     }
 
-    var _objCreate = ObjClass$1["create"];
-    var objCreate = _objCreate || polyObjCreate;
-    function polyObjCreate(obj) {
-        if (!obj) {
-            return {};
-        }
-        var type = typeof obj;
-        if (type !== OBJECT && type !== FUNCTION) {
-            throw new TypeError("Prototype must be an Object or function: " + dumpObj(obj));
-        }
-        function tempFunc() { }
-        tempFunc[PROTOTYPE] = obj;
-        return new tempFunc();
-    }
-
-    var strEndsWith = _unwrapFunction("endsWith", StrProto, polyStrEndsWith);
+    var strEndsWith = _unwrapFunctionWithPoly("endsWith", StrProto, polyStrEndsWith);
     function polyStrEndsWith(value, searchString, length) {
         if (!isString(value)) {
             throwTypeError("'" + dumpObj(value) + "' is not a string");
@@ -862,7 +915,7 @@
     function _createTimerHandler(startTimer, refreshFn, cancelFn) {
         var _a;
         var ref = true;
-        var timerId = startTimer ? refreshFn(null) : null;
+        var timerId = startTimer ? refreshFn(NULL_VALUE) : NULL_VALUE;
         var theTimerHandler;
         var _unref = function () {
             ref = false;
@@ -889,7 +942,7 @@
         };
         var _cancel = function () {
             timerId && cancelFn(timerId);
-            timerId = null;
+            timerId = NULL_VALUE;
         };
         var _setEnabled = function (value) {
             !value && timerId && _cancel();
@@ -911,7 +964,7 @@
         return {
             h: theTimerHandler,
             dn: function () {
-                timerId = null;
+                timerId = NULL_VALUE;
             }
         };
     }
@@ -924,7 +977,7 @@
         var timerFn = theArgs[0];
         theArgs[0] = function () {
             handler.dn();
-            timerFn.apply(self, arguments);
+            fnApply(timerFn, self, arrSlice(arguments));
         };
         var handler = _createTimerHandler(startTimer, function (timerId) {
             if (timerId) {
@@ -932,11 +985,11 @@
                     timerId.refresh();
                     return timerId;
                 }
-                clearFn.call(self, timerId);
+                fnApply(clearFn, self, [timerId]);
             }
-            return setFn.apply(self, theArgs);
+            return fnApply(setFn, self, theArgs);
         }, function (timerId) {
-            clearFn.call(self, timerId);
+            fnApply(clearFn, self, [timerId]);
         });
         return handler.h;
     }
@@ -1371,13 +1424,6 @@
         return result;
     }
 
-    var _theLogger = null;
-    function _debugLog(id, message) {
-        if (_theLogger) {
-            _theLogger(id, message);
-        }
-    }
-
     var STRING_STATES = [
         "pending", "resolving", "resolved", "rejected"
     ];
@@ -1440,14 +1486,11 @@
                 _handled = true;
                 _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
                 _unHandledRejectionHandler = null;
-                _debugLog(_toString(), "then(" + dumpFnObj(onResolved) + ", " + dumpFnObj(onResolved) + ")");
                 var thenPromise = newPromise(function (resolve, reject) {
                     _queue.push(function () {
                         try {
-                            _debugLog(_toString(), "Handling settled value " + dumpFnObj(_settledValue));
                             var handler = _state === 2  ? onResolved : onRejected;
                             var value = isUndefined(handler) ? _settledValue : (isFunction(handler) ? handler(_settledValue) : handler);
-                            _debugLog(_toString(), "Handling Result " + dumpFnObj(value));
                             if (isPromiseLike(value)) {
                                 value.then(resolve, reject);
                             }
@@ -1465,12 +1508,10 @@
                             reject(e);
                         }
                     });
-                    _debugLog(_toString(), "Added to Queue " + _queue.length);
                     if (_hasResolved) {
                         _processQueue();
                     }
                 }, additionalArgs);
-                _debugLog(_toString(), "Created -> " + thenPromise.toString());
                 return thenPromise;
             }
             finally {
@@ -1501,49 +1542,37 @@
             if (_queue.length > 0) {
                 var pending = _queue.slice();
                 _queue = [];
-                _debugLog(_toString(), "Processing queue " + pending.length);
                 _handled = true;
                 processor(pending);
-                _debugLog(_toString(), "Processing done");
                 _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
                 _unHandledRejectionHandler = null;
             }
-            else {
-                _debugLog(_toString(), "Empty Processing queue ");
-            }
         };
         var _createSettleIfFn = function (newState, allowState) {
             return function (theValue) {
                 if (_state === allowState) {
                     if (newState === 2  && isPromiseLike(theValue)) {
                         _state = 1 ;
-                        _debugLog(_toString(), "Resolving");
                         theValue.then(_createSettleIfFn(2 , 1 ), _createSettleIfFn(3 , 1 ));
                         return;
                     }
                     _state = newState;
                     _hasResolved = true;
                     _settledValue = theValue;
-                    _debugLog(_toString(), _strState());
                     _processQueue();
                     if (!_handled && newState === 3  && !_unHandledRejectionHandler) {
                         _unHandledRejectionHandler = scheduleTimeout(_notifyUnhandledRejection, _unhandledRejectionTimeout);
                     }
                 }
-                else {
-                    _debugLog(_toString(), "Already " + _strState());
-                }
             };
         };
         var _notifyUnhandledRejection = function () {
             if (!_handled) {
                 if (isNode()) {
-                    _debugLog(_toString(), "Emitting " + NODE_UNHANDLED_REJECTION);
                     process.emit(NODE_UNHANDLED_REJECTION, _settledValue, _thePromise);
                 }
                 else {
                     var gbl = getWindow() || getGlobal();
-                    _debugLog(_toString(), "Emitting " + UNHANDLED_REJECTION);
                     emitEvent(gbl, UNHANDLED_REJECTION, function (theEvt) {
                         objDefine(theEvt, "promise", { g: function () { return _thePromise; } });
                         theEvt.reason = _settledValue;
@@ -1573,14 +1602,12 @@
             }
             var _rejectFn = _createSettleIfFn(3 , 0 );
             try {
-                _debugLog(_toString(), "Executing");
                 executor.call(_thePromise, _createSettleIfFn(2 , 0 ), _rejectFn);
             }
             catch (e) {
                 _rejectFn(e);
             }
         })();
-        _debugLog(_toString(), "Returning");
         return _thePromise;
     }
     function _createAllPromise(newPromise) {
@@ -2006,8 +2033,8 @@
         var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE ]();
         return (strIndexOf(ua, "safari") >= 0);
     }
-    function isBeaconsSupported() {
-        if (_beaconsSupported === null) {
+    function isBeaconsSupported(useCached) {
+        if (_beaconsSupported === null || useCached === false) {
             _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
         }
         return _beaconsSupported;
@@ -2073,6 +2100,40 @@
         }
         return value;
     }
+    function dispatchEvent(target, evnt) {
+        if (target && target.dispatchEvent && evnt) {
+            target.dispatchEvent(evnt);
+            return true;
+        }
+        return false;
+    }
+    function createCustomDomEvent(eventName, details) {
+        var event = null;
+        var detail = { detail: details || null };
+        if (isFunction(CustomEvent)) {
+            event = new CustomEvent(eventName, detail);
+        }
+        else {
+            var doc = getDocument();
+            if (doc && doc.createEvent) {
+                event = doc.createEvent("CustomEvent");
+                event.initCustomEvent(eventName, true, true, detail);
+            }
+        }
+        return event;
+    }
+    function sendCustomEvent(evtName, cfg, customDetails) {
+        var global = getGlobal();
+        if (global && global.CustomEvent) {
+            try {
+                var details = { cfg: cfg || null, customDetails: customDetails || null };
+                return dispatchEvent(global, createCustomDomEvent(evtName, details));
+            }
+            catch (e) {
+            }
+        }
+        return false;
+    }
 
     var UInt32Mask = 0x100000000;
     var MaxUInt32 = 0xffffffff;
@@ -2158,7 +2219,7 @@
         return result;
     }
 
-    var version = "3.0.3-nightly3.2305-14";
+    var version = '3.0.3-nightly3.2307-24';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -5912,6 +5973,7 @@
     exports.cfgDfValidate = cfgDfValidate;
     exports.createClassFromInterface = createClassFromInterface;
     exports.createCookieMgr = createCookieMgr;
+    exports.createCustomDomEvent = createCustomDomEvent;
     exports.createDynamicConfig = createDynamicConfig;
     exports.createEnumStyle = createEnumStyle;
     exports.createProcessTelemetryContext = createProcessTelemetryContext;
@@ -5923,6 +5985,7 @@
     exports.dateNow = utcNow;
     exports.deepFreeze = objDeepFreeze;
     exports.detachEvent = detachEvent;
+    exports.dispatchEvent = dispatchEvent;
     exports.doPerf = doPerf;
     exports.doUnloadAll = doUnloadAll;
     exports.dumpObj = dumpObj;
@@ -6016,6 +6079,7 @@
     exports.runTargetUnload = runTargetUnload;
     exports.safeGetCookieMgr = safeGetCookieMgr;
     exports.safeGetLogger = safeGetLogger;
+    exports.sendCustomEvent = sendCustomEvent;
     exports.setEnableEnvMocks = setEnableEnvMocks;
     exports.setGblPerfMgr = setGblPerfMgr;
     exports.setValue = setValue;