@microsoft/applicationinsights-core-js 3.0.1-nightly3.2304-38 → 3.0.1-nightly3.2304-44

package/browser/es5/applicationinsights-core-js.gbl.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Core, 3.0.1-nightly3.2304-38
+ * Application Insights JavaScript SDK - Core, 3.0.1-nightly3.2304-44
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 this.Microsoft = this.Microsoft || {};
@@ -34,7 +34,7 @@ this.Microsoft = this.Microsoft || {};
     var ArrCls = Array;
     var ArrProto = ArrCls[PROTOTYPE];
 
-    function _safeGet(cb, defValue) {
+    function safeGet(cb, defValue) {
         var result = defValue;
         try {
             result = cb();
@@ -94,11 +94,14 @@ this.Microsoft = this.Microsoft || {};
     var isNumber = _createIs(NUMBER);
     var isBoolean = _createIs(BOOLEAN);
     var isError = _createObjIs("Error");
+    function isPromiseLike(value) {
+        return !!value && isFunction(value.then);
+    }
     function isNotTruthy(value) {
-        return !value || !_safeGet(function () { return (value && (0 + value)); }, value);
+        return !value || !safeGet(function () { return (value && (0 + value)); }, value);
     }
     function isTruthy(value) {
-        return !(!value || _safeGet(function () { return !(value && (0 + value)); }, !value));
+        return !(!value || safeGet(function () { return !(value && (0 + value)); }, !value));
     }
 
     var objGetOwnPropertyDescriptor = ObjClass$1.getOwnPropertyDescriptor;
@@ -251,6 +254,11 @@ this.Microsoft = this.Microsoft || {};
             throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
         };
     }
+    function _unwrapProp(propName) {
+        return function (thisArg) {
+            return thisArg[propName];
+        };
+    }
 
     var mathMax = MathCls.max;
 
@@ -398,8 +406,8 @@ this.Microsoft = this.Microsoft || {};
         return lazyValue;
     }
 
-    function _lazySafeGet(cb, defValue) {
-        return getLazy(function () { return _safeGet(cb, defValue); });
+    function safeGetLazy(cb, defValue) {
+        return getLazy(function () { return safeGet(cb, defValue); });
     }
 
     var WINDOW = "window";
@@ -408,11 +416,12 @@ this.Microsoft = this.Microsoft || {};
     var _cachedDocument;
     var _cachedNavigator;
     var _cachedHistory;
-    function _lazySafeGetInst(name) {
-        return _lazySafeGet(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
+    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 = _lazySafeGet(_getGlobalValue, null));
+        (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = safeGetLazy(_getGlobalValue, null));
         return _cachedGlobal.v;
     }
     function getInst(name, useCached) {
@@ -429,43 +438,50 @@ this.Microsoft = this.Microsoft || {};
         return !!getDocument();
     }
     function getDocument() {
-        (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = _lazySafeGetInst("document"));
+        (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = lazySafeGetInst("document"));
         return _cachedDocument.v;
     }
     function hasWindow() {
         return !!getWindow();
     }
     function getWindow() {
-        (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = _lazySafeGetInst(WINDOW));
+        (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = lazySafeGetInst(WINDOW));
         return _cachedWindow.v;
     }
     function hasNavigator() {
         return !!getNavigator();
     }
     function getNavigator() {
-        (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = _lazySafeGetInst("navigator"));
+        (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = lazySafeGetInst("navigator"));
         return _cachedNavigator.v;
     }
     function hasHistory() {
         return !!getHistory();
     }
     function getHistory() {
-        (!_cachedHistory || (_globalLazyTestHooks.lzy && !_cachedHistory.b)) && (_cachedHistory = _lazySafeGetInst("history"));
+        (!_cachedHistory || (_globalLazyTestHooks.lzy && !_cachedHistory.b)) && (_cachedHistory = lazySafeGetInst("history"));
         return _cachedHistory.v;
     }
+    function isNode() {
+        !_isNode && (_isNode = safeGetLazy(function () { return !!(process && (process.versions || {}).node); }, false));
+        return _isNode.v;
+    }
 
     var _symbol;
     var _symbolFor;
     var _symbolKeyFor;
     function _getSymbolValue(name) {
-        return _lazySafeGet(function () {
+        return safeGetLazy(function () {
             return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
         }, UNDEF_VALUE);
     }
     var isSymbol = _createIs("symbol");
+    function hasSymbol() {
+        return !!getSymbol();
+    }
     function getSymbol() {
         var resetCache = !_symbol || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_symbol.b);
-        resetCache && (_symbol = _lazySafeGetInst(SYMBOL));
+        resetCache && (_symbol = lazySafeGetInst(SYMBOL));
         (!_symbolFor || resetCache) && (_symbolFor = _getSymbolValue("for"));
         (!_symbolKeyFor || resetCache) && (_symbolKeyFor = _getSymbolValue("keyFor"));
         return _symbol.v;
@@ -793,9 +809,11 @@ this.Microsoft = this.Microsoft || {};
         return _doExtend(objDeepCopy(target) || {}, arrSlice(arguments));
     }
 
+    var getLength = _unwrapProp(LENGTH);
+
     var _perf;
     function getPerformance() {
-        (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = _lazySafeGetInst("performance"));
+        (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = lazySafeGetInst("performance"));
         return _perf.v;
     }
     function perfNow() {
@@ -965,6 +983,7 @@ this.Microsoft = this.Microsoft || {};
     var _DYN_REMOVE_NOTIFICATION_2 = "removeNotificationListener";
     var _DYN_ENABLED = "enabled";
     var _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
+    var _DYN_UNLOAD = "unload";
     var _DYN_ON_COMPLETE = "onComplete";
     var _DYN_VERSION = "version";
     var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
@@ -985,7 +1004,6 @@ this.Microsoft = this.Microsoft || {};
     var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
     var _DYN_TYPE = "type";
     var _DYN_HANDLER = "handler";
-    var _DYN_LISTENERS = "listeners";
     var _DYN_IS_CHILD_EVT = "isChildEvt";
     var _DYN_GET_CTX = "getCtx";
     var _DYN_SET_CTX = "setCtx";
@@ -1296,6 +1314,360 @@ this.Microsoft = this.Microsoft || {};
     }
     dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
 
+    function doAwaitResponse(value, cb) {
+        return doAwait(value, function (value) {
+            cb && cb({
+                value: value,
+                rejected: false
+            });
+        }, function (reason) {
+            cb && cb({
+                rejected: true,
+                reason: reason
+            });
+        });
+    }
+    function doAwait(value, resolveFn, rejectFn, finallyFn) {
+        var result = value;
+        if (isPromiseLike(value)) {
+            if (resolveFn || rejectFn) {
+                result = value.then(resolveFn, rejectFn);
+            }
+        }
+        else {
+            resolveFn && resolveFn(value);
+        }
+        if (finallyFn) {
+            result = doFinally(result, finallyFn);
+        }
+        return result;
+    }
+    function doFinally(value, finallyFn) {
+        var result = value;
+        if (finallyFn) {
+            if (isPromiseLike(value)) {
+                if (value.finally) {
+                    result = value.finally(finallyFn);
+                }
+                else {
+                    result = value.then(function (value) {
+                        finallyFn();
+                        return value;
+                    }, function (reason) {
+                        finallyFn();
+                        throw reason;
+                    });
+                }
+            }
+            else {
+                finallyFn();
+            }
+        }
+        return result;
+    }
+
+    var _theLogger = null;
+    function _debugLog(id, message) {
+        if (_theLogger) {
+            _theLogger(id, message);
+        }
+    }
+
+    var STRING_STATES = [
+        "pending", "resolving", "resolved", "rejected"
+    ];
+
+    var DISPATCH_EVENT = "dispatchEvent";
+    var _hasInitEvent;
+    function emitEvent(target, evtName, populateEvent, useNewEvent) {
+        var doc = getDocument();
+        !_hasInitEvent && (_hasInitEvent = safeGetLazy(function () {
+            var evt;
+            if (doc && doc.createEvent) {
+                evt = doc.createEvent("Event");
+            }
+            return (!!evt && evt.initEvent);
+        }, null));
+        var theEvt = _hasInitEvent.v ? doc.createEvent("Event") : (useNewEvent ? new Event(evtName) : {});
+        populateEvent && populateEvent(theEvt);
+        if (_hasInitEvent.v) {
+            theEvt.initEvent(evtName, false, true);
+        }
+        if (theEvt && target[DISPATCH_EVENT]) {
+            target[DISPATCH_EVENT](theEvt);
+        }
+        else {
+            var handler = target["on" + evtName];
+            if (handler) {
+                handler(theEvt);
+            }
+            else {
+                var theConsole = getInst("console");
+                theConsole && (theConsole["error"] || theConsole["log"])(evtName, dumpObj(theEvt));
+            }
+        }
+    }
+
+    var STR_PROMISE = "Promise";
+
+    var NODE_UNHANDLED_REJECTION = "unhandledRejection";
+    var UNHANDLED_REJECTION = NODE_UNHANDLED_REJECTION.toLowerCase();
+    var _unhandledRejectionTimeout = 10;
+    var _hasPromiseRejectionEvent;
+    function dumpFnObj(value) {
+        if (isFunction(value)) {
+            return value.toString();
+        }
+        return dumpObj(value);
+    }
+    function _createPromise(newPromise, processor, executor) {
+        var additionalArgs = arrSlice(arguments, 3);
+        var _state = 0 ;
+        var _hasResolved = false;
+        var _settledValue;
+        var _queue = [];
+        var _handled = false;
+        var _unHandledRejectionHandler = null;
+        var _thePromise;
+        !_hasPromiseRejectionEvent && (_hasPromiseRejectionEvent = lazySafeGetInst(STR_PROMISE + "RejectionEvent"));
+        var _then = function (onResolved, onRejected) {
+            try {
+                _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);
+                            }
+                            else if (handler) {
+                                resolve(value);
+                            }
+                            else if (_state === 3 ) {
+                                reject(value);
+                            }
+                            else {
+                                resolve(value);
+                            }
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    });
+                    _debugLog(_toString(), "Added to Queue " + _queue.length);
+                    if (_hasResolved) {
+                        _processQueue();
+                    }
+                }, additionalArgs);
+                _debugLog(_toString(), "Created -> " + thenPromise.toString());
+                return thenPromise;
+            }
+            finally {
+            }
+        };
+        var _catch = function (onRejected) {
+            return _then(undefined, onRejected);
+        };
+        var _finally = function (onFinally) {
+            var thenFinally = onFinally;
+            var catchFinally = onFinally;
+            if (isFunction(onFinally)) {
+                thenFinally = function (value) {
+                    onFinally && onFinally();
+                    return value;
+                };
+                catchFinally = function (reason) {
+                    onFinally && onFinally();
+                    throw reason;
+                };
+            }
+            return _then(thenFinally, catchFinally);
+        };
+        var _strState = function () {
+            return STRING_STATES[_state];
+        };
+        var _processQueue = function () {
+            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;
+                        return theEvt;
+                    }, !!_hasPromiseRejectionEvent.v);
+                }
+            }
+        };
+        _thePromise = {
+            then: _then,
+            "catch": _catch,
+            finally: _finally
+        };
+        objDefineProp(_thePromise, "state", {
+            get: _strState
+        });
+        if (hasSymbol()) {
+            _thePromise[getKnownSymbol(11 )] = "IPromise";
+        }
+        var _toString = function () {
+            return "IPromise" + ("") + " " + _strState() + (_hasResolved ? (" - " + dumpFnObj(_settledValue)) : "");
+        };
+        _thePromise.toString = _toString;
+        (function _initialize() {
+            if (!isFunction(executor)) {
+                throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpFnObj(executor));
+            }
+            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) {
+        return function (input) {
+            var additionalArgs = arrSlice(arguments, 1);
+            return newPromise(function (resolve, reject) {
+                try {
+                    var values_1 = [];
+                    var pending_1 = 1;
+                    arrForEach(input, function (item, idx) {
+                        if (item) {
+                            pending_1++;
+                            doAwait(item, function (value) {
+                                values_1[idx] = value;
+                                if (--pending_1 === 0) {
+                                    resolve(values_1);
+                                }
+                            }, reject);
+                        }
+                    });
+                    pending_1--;
+                    if (pending_1 === 0) {
+                        resolve(values_1);
+                    }
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }, additionalArgs);
+        };
+    }
+
+    var _processPendingItems = function (pending) {
+        arrForEach(pending, function (fn) {
+            try {
+                fn();
+            }
+            catch (e) {
+            }
+        });
+    };
+    function timeoutItemProcessor(timeout) {
+        var callbackTimeout = isNumber(timeout) ? timeout : 0;
+        return function (pending) {
+            scheduleTimeout(function () {
+                _processPendingItems(pending);
+            }, callbackTimeout);
+        };
+    }
+
+    function createAsyncPromise(executor, timeout) {
+        return _createPromise(createAsyncPromise, timeoutItemProcessor(timeout), executor, timeout);
+    }
+
+    var _isPromiseSupported;
+    function createNativePromise(executor, timeout) {
+        !_isPromiseSupported && (_isPromiseSupported = lazySafeGetInst(STR_PROMISE));
+        var PrmCls = _isPromiseSupported.v;
+        if (!PrmCls) {
+            return createAsyncPromise(executor);
+        }
+        if (!isFunction(executor)) {
+            throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpObj(executor));
+        }
+        var _state = 0 ;
+        function _strState() {
+            return STRING_STATES[_state];
+        }
+        var thePromise = new PrmCls(function (resolve, reject) {
+            function _resolve(value) {
+                _state = 2 ;
+                resolve(value);
+            }
+            function _reject(reason) {
+                _state = 3 ;
+                reject(reason);
+            }
+            executor(_resolve, _reject);
+        });
+        objDefineProp(thePromise, "state", {
+            get: _strState
+        });
+        return thePromise;
+    }
+
+    var _promiseCreator;
+    function createPromise(executor, timeout) {
+        !_promiseCreator && (_promiseCreator = getLazy(function () { return createNativePromise; }));
+        return _promiseCreator.v.call(this, executor, timeout);
+    }
+    var createAllPromise = _createAllPromise(createPromise);
+
     var UNDEFINED_VALUE = undefined;
     var STR_EMPTY = "";
     var STR_CHANNELS = "channels";
@@ -1783,7 +2155,7 @@ this.Microsoft = this.Microsoft || {};
         return result;
     }
 
-    var version = "3.0.1-nightly3.2304-38";
+    var version = "3.0.1-nightly3.2304-44";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -2398,7 +2770,30 @@ this.Microsoft = this.Microsoft || {};
             return handler[_DYN_WATCH ](configHandler);
         }
         _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
-        createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
+        return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
+    }
+
+    function runTargetUnload(target, isAsync) {
+        if (target && target[_DYN_UNLOAD ]) {
+            return target[_DYN_UNLOAD ](isAsync);
+        }
+    }
+    function doUnloadAll(targets, isAsync, done) {
+        var result;
+        if (!done) {
+            result = createPromise(function (resolved) {
+                done = resolved;
+            });
+        }
+        if (targets && getLength(targets) > 0) {
+            doAwaitResponse(runTargetUnload(targets[0], isAsync), function () {
+                doUnloadAll(arrSlice(targets, 1), isAsync, done);
+            });
+        }
+        else {
+            done();
+        }
+        return result;
     }
 
     var ChannelControllerPriority = 500;
@@ -2549,8 +2944,9 @@ this.Microsoft = this.Microsoft || {};
             var _loggingLevelTelemetry;
             var _maxInternalMessageLimit;
             var _enableDebug;
+            var _unloadHandler;
             dynamicProto(DiagnosticLogger, this, function (_self) {
-                _setDefaultsFromConfig(config || {});
+                _unloadHandler = _setDefaultsFromConfig(config || {});
                 _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
                 _self[_DYN_THROW_INTERNAL ] = function (severity, msgId, msg, properties, isUserAct) {
                     if (isUserAct === void 0) { isUserAct = false; }
@@ -2593,6 +2989,10 @@ this.Microsoft = this.Microsoft || {};
                     _messageLogged = {};
                 };
                 _self[_DYN_LOG_INTERNAL_MESSAGE ] = _logInternalMessage;
+                _self[_DYN_UNLOAD ] = function (isAsync) {
+                    _unloadHandler && _unloadHandler.rm();
+                    _unloadHandler = null;
+                };
                 function _logInternalMessage(severity, message) {
                     if (_areInternalMessagesThrottled()) {
                         return;
@@ -2625,8 +3025,7 @@ this.Microsoft = this.Microsoft || {};
                     }
                 }
                 function _setDefaultsFromConfig(config) {
-                    var handler = createDynamicConfig(config, defaultValues$2, _self);
-                    handler[_DYN_WATCH ](function (details) {
+                    return onConfigChange(createDynamicConfig(config, defaultValues$2, _self).cfg, function (details) {
                         var config = details.cfg;
                         _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
                         _loggingLevelTelemetry = config.loggingLevelTelemetry;
@@ -2754,15 +3153,17 @@ this.Microsoft = this.Microsoft || {};
         return cookieMgr;
     }
     function createCookieMgr(rootConfig, logger) {
+        var _a;
         var cookieMgrConfig;
         var _path;
         var _domain;
+        var unloadHandler;
         var _enabled;
         var _getCookieFn;
         var _setCookieFn;
         var _delCookieFn;
         rootConfig = createDynamicConfig(rootConfig || _globalCookieConfig, null, logger).cfg;
-        onConfigChange(rootConfig, function (details) {
+        unloadHandler = onConfigChange(rootConfig, function (details) {
             details[_DYN_SET_DF ](details.cfg, rootDefaultConfig);
             cookieMgrConfig = details.ref(details.cfg, "cookieCfg");
             _path = cookieMgrConfig[STR_PATH ] || "/";
@@ -2772,92 +3173,97 @@ this.Microsoft = this.Microsoft || {};
             _setCookieFn = cookieMgrConfig.setCookie || _setCookieValue;
             _delCookieFn = cookieMgrConfig.delCookie || _setCookieValue;
         }, logger);
-        var cookieMgr = {
-            isEnabled: function () {
-                var enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false && _enabled && areCookiesSupported(logger);
-                var gblManager = _globalCookieConfig[strConfigCookieMgr];
-                if (enabled && gblManager && cookieMgr !== gblManager) {
-                    enabled = _isMgrEnabled(gblManager);
-                }
-                return enabled;
-            },
-            setEnabled: function (value) {
-                _enabled = value !== false;
-                cookieMgrConfig[_DYN_ENABLED ] = value;
-            },
-            set: function (name, value, maxAgeSec, domain, path) {
-                var result = false;
-                if (_isMgrEnabled(cookieMgr) && !_isBlockedCookie(cookieMgrConfig, name)) {
-                    var values = {};
-                    var theValue = strTrim(value || STR_EMPTY);
-                    var idx = strIndexOf(theValue, ";");
-                    if (idx !== -1) {
-                        theValue = strTrim(strLeft(value, idx));
-                        values = _extractParts(strSubstring(value, idx + 1));
-                    }
-                    setValue(values, STR_DOMAIN, domain || _domain, isTruthy, isUndefined);
-                    if (!isNullOrUndefined(maxAgeSec)) {
-                        var _isIE = isIE();
-                        if (isUndefined(values[strExpires])) {
-                            var nowMs = utcNow();
-                            var expireMs = nowMs + (maxAgeSec * 1000);
-                            if (expireMs > 0) {
-                                var expiry = new Date();
-                                expiry.setTime(expireMs);
-                                setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY, isTruthy);
+        var cookieMgr = (_a = {
+                isEnabled: function () {
+                    var enabled = _isCfgEnabled(rootConfig, cookieMgrConfig) !== false && _enabled && areCookiesSupported(logger);
+                    var gblManager = _globalCookieConfig[strConfigCookieMgr];
+                    if (enabled && gblManager && cookieMgr !== gblManager) {
+                        enabled = _isMgrEnabled(gblManager);
+                    }
+                    return enabled;
+                },
+                setEnabled: function (value) {
+                    _enabled = value !== false;
+                    cookieMgrConfig[_DYN_ENABLED ] = value;
+                },
+                set: function (name, value, maxAgeSec, domain, path) {
+                    var result = false;
+                    if (_isMgrEnabled(cookieMgr) && !_isBlockedCookie(cookieMgrConfig, name)) {
+                        var values = {};
+                        var theValue = strTrim(value || STR_EMPTY);
+                        var idx = strIndexOf(theValue, ";");
+                        if (idx !== -1) {
+                            theValue = strTrim(strLeft(value, idx));
+                            values = _extractParts(strSubstring(value, idx + 1));
+                        }
+                        setValue(values, STR_DOMAIN, domain || _domain, isTruthy, isUndefined);
+                        if (!isNullOrUndefined(maxAgeSec)) {
+                            var _isIE = isIE();
+                            if (isUndefined(values[strExpires])) {
+                                var nowMs = utcNow();
+                                var expireMs = nowMs + (maxAgeSec * 1000);
+                                if (expireMs > 0) {
+                                    var expiry = new Date();
+                                    expiry.setTime(expireMs);
+                                    setValue(values, strExpires, _formatDate(expiry, !_isIE ? strToUTCString : strToGMTString) || _formatDate(expiry, _isIE ? strToGMTString : strToUTCString) || STR_EMPTY, isTruthy);
+                                }
+                            }
+                            if (!_isIE) {
+                                setValue(values, "max-age", STR_EMPTY + maxAgeSec, null, isUndefined);
                             }
                         }
-                        if (!_isIE) {
-                            setValue(values, "max-age", STR_EMPTY + maxAgeSec, null, isUndefined);
+                        var location_1 = getLocation();
+                        if (location_1 && location_1.protocol === "https:") {
+                            setValue(values, "secure", null, null, isUndefined);
+                            if (_allowUaSameSite === null) {
+                                _allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT ]);
+                            }
+                            if (_allowUaSameSite) {
+                                setValue(values, "SameSite", "None", null, isUndefined);
+                            }
                         }
+                        setValue(values, STR_PATH, path || _path, null, isUndefined);
+                        _setCookieFn(name, _formatCookieValue(theValue, values));
+                        result = true;
                     }
-                    var location_1 = getLocation();
-                    if (location_1 && location_1.protocol === "https:") {
-                        setValue(values, "secure", null, null, isUndefined);
-                        if (_allowUaSameSite === null) {
-                            _allowUaSameSite = !uaDisallowsSameSiteNone((getNavigator() || {})[_DYN_USER_AGENT ]);
-                        }
-                        if (_allowUaSameSite) {
-                            setValue(values, "SameSite", "None", null, isUndefined);
+                    return result;
+                },
+                get: function (name) {
+                    var value = STR_EMPTY;
+                    if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
+                        value = _getCookieFn(name);
+                    }
+                    return value;
+                },
+                del: function (name, path) {
+                    var result = false;
+                    if (_isMgrEnabled(cookieMgr)) {
+                        result = cookieMgr.purge(name, path);
+                    }
+                    return result;
+                },
+                purge: function (name, path) {
+                    var _a;
+                    var result = false;
+                    if (areCookiesSupported(logger)) {
+                        var values = (_a = {},
+                            _a[STR_PATH] = path ? path : "/",
+                            _a[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT",
+                            _a);
+                        if (!isIE()) {
+                            values["max-age"] = "0";
                         }
+                        _delCookieFn(name, _formatCookieValue(STR_EMPTY, values));
+                        result = true;
                     }
-                    setValue(values, STR_PATH, path || _path, null, isUndefined);
-                    _setCookieFn(name, _formatCookieValue(theValue, values));
-                    result = true;
+                    return result;
                 }
-                return result;
             },
-            get: function (name) {
-                var value = STR_EMPTY;
-                if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
-                    value = _getCookieFn(name);
-                }
-                return value;
+            _a[_DYN_UNLOAD ] = function (isAsync) {
+                unloadHandler && unloadHandler.rm();
+                unloadHandler = null;
             },
-            del: function (name, path) {
-                var result = false;
-                if (_isMgrEnabled(cookieMgr)) {
-                    result = cookieMgr.purge(name, path);
-                }
-                return result;
-            },
-            purge: function (name, path) {
-                var _a;
-                var result = false;
-                if (areCookiesSupported(logger)) {
-                    var values = (_a = {},
-                        _a[STR_PATH] = path ? path : "/",
-                        _a[strExpires] = "Thu, 01 Jan 1970 00:00:01 GMT",
-                        _a);
-                    if (!isIE()) {
-                        values["max-age"] = "0";
-                    }
-                    _delCookieFn(name, _formatCookieValue(STR_EMPTY, values));
-                    result = true;
-                }
-                return result;
-            }
-        };
+            _a);
         cookieMgr[strConfigCookieMgr] = cookieMgr;
         return cookieMgr;
     }
@@ -2974,40 +3380,45 @@ this.Microsoft = this.Microsoft || {};
         function NotificationManager(config) {
             this.listeners = [];
             var perfEvtsSendAll;
+            var unloadHandler;
+            var _listeners = [];
             var cfgHandler = createDynamicConfig(config, defaultValues$1);
-            cfgHandler[_DYN_WATCH ](function (details) {
+            unloadHandler = cfgHandler[_DYN_WATCH ](function (details) {
                 perfEvtsSendAll = !!details.cfg.perfEvtsSendAll;
             });
             dynamicProto(NotificationManager, this, function (_self) {
+                objDefine(_self, "listeners", {
+                    g: function () { return _listeners; }
+                });
                 _self[_DYN_ADD_NOTIFICATION_LIS1 ] = function (listener) {
-                    _self.listeners[_DYN_PUSH ](listener);
+                    _listeners[_DYN_PUSH ](listener);
                 };
                 _self[_DYN_REMOVE_NOTIFICATION_2 ] = function (listener) {
-                    var index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
+                    var index = arrIndexOf(_listeners, listener);
                     while (index > -1) {
-                        _self.listeners[_DYN_SPLICE ](index, 1);
-                        index = arrIndexOf(_self[_DYN_LISTENERS ], listener);
+                        _listeners[_DYN_SPLICE ](index, 1);
+                        index = arrIndexOf(_listeners, listener);
                     }
                 };
                 _self[STR_EVENTS_SENT ] = function (events) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SENT, true, function (listener) {
+                    _runListeners(_listeners, STR_EVENTS_SENT, true, function (listener) {
                         listener[STR_EVENTS_SENT ](events);
                     });
                 };
                 _self[STR_EVENTS_DISCARDED ] = function (events, reason) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_DISCARDED, true, function (listener) {
+                    _runListeners(_listeners, STR_EVENTS_DISCARDED, true, function (listener) {
                         listener[STR_EVENTS_DISCARDED ](events, reason);
                     });
                 };
                 _self[STR_EVENTS_SEND_REQUEST ] = function (sendReason, isAsync) {
-                    _runListeners(_self[_DYN_LISTENERS ], STR_EVENTS_SEND_REQUEST, isAsync, function (listener) {
+                    _runListeners(_listeners, STR_EVENTS_SEND_REQUEST, isAsync, function (listener) {
                         listener[STR_EVENTS_SEND_REQUEST ](sendReason, isAsync);
                     });
                 };
                 _self[STR_PERF_EVENT ] = function (perfEvent) {
                     if (perfEvent) {
                         if (perfEvtsSendAll || !perfEvent[_DYN_IS_CHILD_EVT ]()) {
-                            _runListeners(_self[_DYN_LISTENERS ], STR_PERF_EVENT, false, function (listener) {
+                            _runListeners(_listeners, STR_PERF_EVENT, false, function (listener) {
                                 if (perfEvent[_DYN_IS_ASYNC ]) {
                                     scheduleTimeout(function () { return listener[STR_PERF_EVENT ](perfEvent); }, 0);
                                 }
@@ -3018,6 +3429,34 @@ this.Microsoft = this.Microsoft || {};
                         }
                     }
                 };
+                _self[_DYN_UNLOAD ] = function (isAsync) {
+                    var _finishUnload = function () {
+                        unloadHandler && unloadHandler.rm();
+                        unloadHandler = null;
+                        _listeners = [];
+                    };
+                    var waiting;
+                    _runListeners(_listeners, "unload", false, function (listener) {
+                        var asyncUnload = listener[_DYN_UNLOAD ](isAsync);
+                        if (asyncUnload) {
+                            if (!waiting) {
+                                waiting = [];
+                            }
+                            waiting[_DYN_PUSH ](asyncUnload);
+                        }
+                    });
+                    if (waiting) {
+                        return createPromise(function (resolve) {
+                            return doAwaitResponse(createAllPromise(waiting), function () {
+                                _finishUnload();
+                                resolve();
+                            });
+                        });
+                    }
+                    else {
+                        _finishUnload();
+                    }
+                };
             });
         }
         NotificationManager.__ieDyn=1;
@@ -3584,7 +4023,7 @@ this.Microsoft = this.Microsoft || {};
         var context = internalContext.ctx;
         function _processNext(unloadState) {
             var nextPlugin = internalContext._next();
-            nextPlugin && nextPlugin.unload(context, unloadState);
+            nextPlugin && nextPlugin[_DYN_UNLOAD ](context, unloadState);
             return !nextPlugin;
         }
         function _createNew(plugins, startAt) {
@@ -4159,6 +4598,7 @@ this.Microsoft = this.Microsoft || {};
         function AppInsightsCore() {
             var _configHandler;
             var _isInitialized;
+            var _logger;
             var _eventQueue;
             var _notificationManager;
             var _perfManager;
@@ -4212,8 +4652,7 @@ this.Microsoft = this.Microsoft || {};
                     _notificationManager = notificationManager;
                     _initDebugListener();
                     _initPerfManager();
-                    _self[_DYN_LOGGER ] = logger || new DiagnosticLogger(config);
-                    _configHandler[_DYN_LOGGER ] = _self[_DYN_LOGGER ];
+                    _self[_DYN_LOGGER ] = logger;
                     var cfgExtensions = config[STR_EXTENSIONS ];
                     _configExtensions = [];
                     _configExtensions[_DYN_PUSH ].apply(_configExtensions, __spreadArrayFn(__spreadArrayFn([], extensions, false), cfgExtensions));
@@ -4225,10 +4664,10 @@ this.Microsoft = this.Microsoft || {};
                     if (_channels[_DYN_LENGTH ] > 1) {
                         var teeController = _self[_DYN_GET_PLUGIN ]("TeeChannelController");
                         if (!teeController || !teeController.plugin) {
-                            _throwInternal(_self[_DYN_LOGGER ], 1 , 28 , "TeeChannel required");
+                            _throwInternal(_logger, 1 , 28 , "TeeChannel required");
                         }
                     }
-                    _registerDelayedCfgListener(config, _cfgListeners, _self[_DYN_LOGGER ]);
+                    _registerDelayedCfgListener(config, _cfgListeners, _logger);
                     _cfgListeners = null;
                     _isInitialized = true;
                     _self.releaseQueue();
@@ -4267,10 +4706,8 @@ this.Microsoft = this.Microsoft || {};
                 _self[_DYN_GET_PROCESS_TEL_CONT0 ] = _createTelCtx;
                 _self[_DYN_GET_NOTIFY_MGR ] = function () {
                     if (!_notificationManager) {
-                        _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
-                            _notificationManager = new NotificationManager(details.cfg);
-                            _self[strNotificationManager] = _notificationManager;
-                        }));
+                        _notificationManager = new NotificationManager(_configHandler.cfg);
+                        _self[strNotificationManager] = _notificationManager;
                     }
                     return _notificationManager;
                 };
@@ -4284,14 +4721,15 @@ this.Microsoft = this.Microsoft || {};
                 };
                 _self.getCookieMgr = function () {
                     if (!_cookieManager) {
-                        _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
-                            _cookieManager = createCookieMgr(details.cfg, _self[_DYN_LOGGER ]);
-                        }));
+                        _cookieManager = createCookieMgr(_configHandler.cfg, _self[_DYN_LOGGER ]);
                     }
                     return _cookieManager;
                 };
                 _self.setCookieMgr = function (cookieMgr) {
-                    _cookieManager = cookieMgr;
+                    if (_cookieManager !== cookieMgr) {
+                        runTargetUnload(_cookieManager, false);
+                        _cookieManager = cookieMgr;
+                    }
                 };
                 _self[STR_GET_PERF_MGR ] = function () {
                     if (!_perfManager && !_cfgPerfManager) {
@@ -4329,7 +4767,7 @@ this.Microsoft = this.Microsoft || {};
                 };
                 function _startLogPoller(alwaysStart) {
                     if ((!_internalLogPoller || !_internalLogPoller[_DYN_ENABLED ]) && !_forceStopInternalLogPoller) {
-                        var shouldStart = alwaysStart || (_self.logger && _self.logger.queue[_DYN_LENGTH ] > 0);
+                        var shouldStart = alwaysStart || (_logger && _logger.queue[_DYN_LENGTH ] > 0);
                         if (shouldStart) {
                             if (!_internalLogPollerListening) {
                                 _internalLogPollerListening = true;
@@ -4359,7 +4797,7 @@ this.Microsoft = this.Microsoft || {};
                     _flushInternalLogs();
                 };
                 proxyFunctions(_self, function () { return _telemetryInitializerPlugin; }, ["addTelemetryInitializer"]);
-                _self.unload = function (isAsync, unloadComplete, cbTimeout) {
+                _self[_DYN_UNLOAD ] = function (isAsync, unloadComplete, cbTimeout) {
                     var _a;
                     if (isAsync === void 0) { isAsync = true; }
                     if (!_isInitialized) {
@@ -4374,11 +4812,19 @@ this.Microsoft = this.Microsoft || {};
                         _a[_DYN_IS_ASYNC ] = isAsync,
                         _a.flushComplete = false,
                         _a);
+                    var result;
+                    if (isAsync && !unloadComplete) {
+                        result = createPromise(function (resolve) {
+                            unloadComplete = resolve;
+                        });
+                    }
                     var processUnloadCtx = createProcessTelemetryUnloadContext(_getPluginChain(), _self);
                     processUnloadCtx[_DYN_ON_COMPLETE ](function () {
                         _hookContainer.run(_self[_DYN_LOGGER ]);
-                        _initDefaults();
-                        unloadComplete && unloadComplete(unloadState);
+                        doUnloadAll([_cookieManager, _notificationManager, _logger], isAsync, function () {
+                            _initDefaults();
+                            unloadComplete && unloadComplete(unloadState);
+                        });
                     }, _self);
                     function _doUnload(flushComplete) {
                         unloadState.flushComplete = flushComplete;
@@ -4389,6 +4835,7 @@ this.Microsoft = this.Microsoft || {};
                     }
                     _flushInternalLogs();
                     if (!_flushChannels(isAsync, _doUnload, 6 , cbTimeout)) ;
+                    return result;
                 };
                 _self[_DYN_GET_PLUGIN ] = _getPlugin;
                 _self.addPlugin = function (plugin, replaceExisting, isAsync, addCb) {
@@ -4550,6 +4997,22 @@ this.Microsoft = this.Microsoft || {};
                             return _pluginVersionString || STR_EMPTY;
                         }
                     });
+                    objDefine(_self, "logger", {
+                        g: function () {
+                            if (!_logger) {
+                                _logger = new DiagnosticLogger(_configHandler.cfg);
+                                _configHandler[_DYN_LOGGER ] = _logger;
+                            }
+                            return _logger;
+                        },
+                        s: function (newLogger) {
+                            _configHandler[_DYN_LOGGER ] = newLogger;
+                            if (_logger !== newLogger) {
+                                runTargetUnload(_logger, false);
+                                _logger = newLogger;
+                            }
+                        }
+                    });
                     _self[_DYN_LOGGER ] = new DiagnosticLogger(_configHandler.cfg);
                     _extensions = [];
                     var cfgExtensions = _self.config[STR_EXTENSIONS ] || [];
@@ -4557,9 +5020,11 @@ this.Microsoft = this.Microsoft || {};
                     arrAppend(cfgExtensions, _extensions);
                     _telemetryInitializerPlugin = new TelemetryInitializerPlugin();
                     _eventQueue = [];
+                    runTargetUnload(_notificationManager, false);
                     _notificationManager = null;
                     _perfManager = null;
                     _cfgPerfManager = null;
+                    runTargetUnload(_cookieManager, false);
                     _cookieManager = null;
                     _pluginChain = null;
                     _configExtensions = [];
@@ -4711,9 +5176,9 @@ this.Microsoft = this.Microsoft || {};
                     }
                 }
                 function _flushInternalLogs() {
-                    if (_self[_DYN_LOGGER ] && _self[_DYN_LOGGER ].queue) {
-                        var queue = _self[_DYN_LOGGER ].queue.slice(0);
-                        _self.logger.queue[_DYN_LENGTH ] = 0;
+                    if (_logger && _logger.queue) {
+                        var queue = _logger.queue.slice(0);
+                        _logger.queue[_DYN_LENGTH ] = 0;
                         arrForEach(queue, function (logMessage) {
                             var _a;
                             var item = (_a = {},
@@ -5375,6 +5840,7 @@ this.Microsoft = this.Microsoft || {};
     exports.deepFreeze = objDeepFreeze;
     exports.detachEvent = detachEvent;
     exports.doPerf = doPerf;
+    exports.doUnloadAll = doUnloadAll;
     exports.dumpObj = dumpObj;
     exports.eventOff = eventOff;
     exports.eventOn = eventOn;
@@ -5463,6 +5929,7 @@ this.Microsoft = this.Microsoft || {};
     exports.removePageHideEventListener = removePageHideEventListener;
     exports.removePageShowEventListener = removePageShowEventListener;
     exports.removePageUnloadEventListener = removePageUnloadEventListener;
+    exports.runTargetUnload = runTargetUnload;
     exports.safeGetCookieMgr = safeGetCookieMgr;
     exports.safeGetLogger = safeGetLogger;
     exports.setEnableEnvMocks = setEnableEnvMocks;