@microsoft/applicationinsights-web-basic 3.0.1-nightly3.2304-38 → 3.0.1-nightly3.2304-44

package/browser/es5/{aib.3.0.1-nightly3.2304-38.cjs.js → aib.3.0.1-nightly3.2304-44.cjs.js}

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript Web SDK - Basic, 3.0.1-nightly3.2304-38
+ * Application Insights JavaScript Web SDK - Basic, 3.0.1-nightly3.2304-44
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 'use strict';
@@ -30,7 +30,7 @@ var MathCls = Math;
 var ArrCls = Array;
 var ArrProto = ArrCls[PROTOTYPE];
 
-function _safeGet(cb, defValue) {
+function safeGet(cb, defValue) {
     var result = defValue;
     try {
         result = cb();
@@ -87,8 +87,11 @@ var isDate = _createObjIs("Date");
 var isNumber = _createIs(NUMBER);
 var isBoolean = _createIs(BOOLEAN);
 var isError = _createObjIs("Error");
+function isPromiseLike(value) {
+    return !!value && isFunction(value.then);
+}
 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;
@@ -240,6 +243,11 @@ function _unwrapFunction(funcName, target, polyFunc) {
         throwTypeError("'" + asString(funcName) + "' not defined for " + dumpObj(thisArg));
     };
 }
+function _unwrapProp(propName) {
+    return function (thisArg) {
+        return thisArg[propName];
+    };
+}
 
 var mathMax = MathCls.max;
 
@@ -363,8 +371,8 @@ function getLazy(cb) {
     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";
@@ -372,11 +380,12 @@ var _cachedGlobal;
 var _cachedWindow;
 var _cachedDocument;
 var _cachedNavigator;
-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) {
@@ -393,35 +402,42 @@ function hasDocument() {
     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 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);
 }
+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;
@@ -749,6 +765,8 @@ function deepExtend(target, obj1, obj2, obj3, obj4, obj5, obj6) {
     return _doExtend(objDeepCopy(target) || {}, arrSlice(arguments));
 }
 
+var getLength = _unwrapProp(LENGTH);
+
 var _objCreate = ObjClass$1["create"];
 var objCreate = _objCreate || polyObjCreate;
 function polyObjCreate(obj) {
@@ -1198,6 +1216,7 @@ var _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
 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";
@@ -1218,7 +1237,6 @@ var _DYN_REPLACE = "replace";
 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";
@@ -1243,6 +1261,360 @@ function throwAggregationError(message, sourceErrors) {
     throw new aggregationErrorType(theMessage, sourceErrors || []);
 }
 
+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$1 = undefined;
 var STR_EMPTY = "";
 var STR_CHANNELS = "channels";
@@ -1632,7 +2004,7 @@ function newId(maxLength) {
     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) {
@@ -2227,7 +2599,30 @@ function onConfigChange(config, configHandler, logger) {
         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;
@@ -2360,8 +2755,9 @@ var DiagnosticLogger = /** @class */ (function () {
         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; }
@@ -2404,6 +2800,10 @@ var DiagnosticLogger = /** @class */ (function () {
                 _messageLogged = {};
             };
             _self[_DYN_LOG_INTERNAL_MESSAGE ] = _logInternalMessage;
+            _self[_DYN_UNLOAD ] = function (isAsync) {
+                _unloadHandler && _unloadHandler.rm();
+                _unloadHandler = null;
+            };
             function _logInternalMessage(severity, message) {
                 if (_areInternalMessagesThrottled()) {
                     return;
@@ -2436,8 +2836,7 @@ var DiagnosticLogger = /** @class */ (function () {
                 }
             }
             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;
@@ -2535,15 +2934,17 @@ function _isCfgEnabled(rootConfig, cookieMgrConfig) {
     return isCfgEnabled;
 }
 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 ] || "/";
@@ -2553,92 +2954,97 @@ function createCookieMgr(rootConfig, logger) {
         _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;
-        },
-        get: function (name) {
-            var value = STR_EMPTY;
-            if (_isMgrEnabled(cookieMgr) && !_isIgnoredCookie(cookieMgrConfig, name)) {
-                value = _getCookieFn(name);
+                return result;
             }
-            return value;
         },
-        del: function (name, path) {
-            var result = false;
-            if (_isMgrEnabled(cookieMgr)) {
-                result = cookieMgr.purge(name, path);
-            }
-            return result;
+        _a[_DYN_UNLOAD ] = function (isAsync) {
+            unloadHandler && unloadHandler.rm();
+            unloadHandler = null;
         },
-        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;
 }
@@ -2755,40 +3161,45 @@ var NotificationManager = /** @class */ (function () {
     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$1 ](listener);
+                _listeners[_DYN_PUSH$1 ](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);
                             }
@@ -2799,6 +3210,34 @@ var NotificationManager = /** @class */ (function () {
                     }
                 }
             };
+            _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$1 ](asyncUnload);
+                    }
+                });
+                if (waiting) {
+                    return createPromise(function (resolve) {
+                        return doAwaitResponse(createAllPromise(waiting), function () {
+                            _finishUnload();
+                            resolve();
+                        });
+                    });
+                }
+                else {
+                    _finishUnload();
+                }
+            };
         });
     }
     NotificationManager.__ieDyn=1;
@@ -3228,7 +3667,7 @@ function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
     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) {
@@ -3795,6 +4234,7 @@ var AppInsightsCore = /** @class */ (function () {
     function AppInsightsCore() {
         var _configHandler;
         var _isInitialized;
+        var _logger;
         var _eventQueue;
         var _notificationManager;
         var _perfManager;
@@ -3848,8 +4288,7 @@ var AppInsightsCore = /** @class */ (function () {
                 _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$1 ].apply(_configExtensions, __spreadArrayFn(__spreadArrayFn([], extensions, false), cfgExtensions));
@@ -3861,10 +4300,10 @@ var AppInsightsCore = /** @class */ (function () {
                 if (_channels[_DYN_LENGTH$2 ] > 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();
@@ -3903,10 +4342,8 @@ var AppInsightsCore = /** @class */ (function () {
             _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;
             };
@@ -3920,14 +4357,15 @@ var AppInsightsCore = /** @class */ (function () {
             };
             _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) {
@@ -3965,7 +4403,7 @@ var AppInsightsCore = /** @class */ (function () {
             };
             function _startLogPoller(alwaysStart) {
                 if ((!_internalLogPoller || !_internalLogPoller[_DYN_ENABLED ]) && !_forceStopInternalLogPoller) {
-                    var shouldStart = alwaysStart || (_self.logger && _self.logger.queue[_DYN_LENGTH$2 ] > 0);
+                    var shouldStart = alwaysStart || (_logger && _logger.queue[_DYN_LENGTH$2 ] > 0);
                     if (shouldStart) {
                         if (!_internalLogPollerListening) {
                             _internalLogPollerListening = true;
@@ -3995,7 +4433,7 @@ var AppInsightsCore = /** @class */ (function () {
                 _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) {
@@ -4010,11 +4448,19 @@ var AppInsightsCore = /** @class */ (function () {
                     _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;
@@ -4025,6 +4471,7 @@ var AppInsightsCore = /** @class */ (function () {
                 }
                 _flushInternalLogs();
                 if (!_flushChannels(isAsync, _doUnload, 6 , cbTimeout)) ;
+                return result;
             };
             _self[_DYN_GET_PLUGIN ] = _getPlugin;
             _self.addPlugin = function (plugin, replaceExisting, isAsync, addCb) {
@@ -4186,6 +4633,22 @@ var AppInsightsCore = /** @class */ (function () {
                         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 ] || [];
@@ -4193,9 +4656,11 @@ var AppInsightsCore = /** @class */ (function () {
                 arrAppend(cfgExtensions, _extensions);
                 _telemetryInitializerPlugin = new TelemetryInitializerPlugin();
                 _eventQueue = [];
+                runTargetUnload(_notificationManager, false);
                 _notificationManager = null;
                 _perfManager = null;
                 _cfgPerfManager = null;
+                runTargetUnload(_cookieManager, false);
                 _cookieManager = null;
                 _pluginChain = null;
                 _configExtensions = [];
@@ -4347,9 +4812,9 @@ var AppInsightsCore = /** @class */ (function () {
                 }
             }
             function _flushInternalLogs() {
-                if (_self[_DYN_LOGGER ] && _self[_DYN_LOGGER ].queue) {
-                    var queue = _self[_DYN_LOGGER ].queue.slice(0);
-                    _self.logger.queue[_DYN_LENGTH$2 ] = 0;
+                if (_logger && _logger.queue) {
+                    var queue = _logger.queue.slice(0);
+                    _logger.queue[_DYN_LENGTH$2 ] = 0;
                     arrForEach(queue, function (logMessage) {
                         var _a;
                         var item = (_a = {},
@@ -5010,7 +5475,7 @@ var Envelope = /** @class */ (function () {
     return Envelope;
 }());
 
-var Event = /** @class */ (function () {
+var Event$1 = /** @class */ (function () {
     function Event(logger, name, properties, measurements) {
         this.aiDataContract = {
             ver: 1 ,
@@ -5958,7 +6423,7 @@ function EnvelopeCreatorInit(logger, telemetryItem) {
     }
 }
 var EnvelopeCreator = {
-    Version: "3.0.1-nightly3.2304-38"
+    Version: "3.0.1-nightly3.2304-44"
 };
 function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
     EnvelopeCreatorInit(logger, telemetryItem);
@@ -5982,10 +6447,10 @@ function EventEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
     EnvelopeCreatorInit(logger, telemetryItem);
     var customProperties = {};
     var customMeasurements = {};
-    if (telemetryItem[strBaseType] !== Event[_DYN_DATA_TYPE ]) {
+    if (telemetryItem[strBaseType] !== Event$1[_DYN_DATA_TYPE ]) {
         customProperties["baseTypeSource"] = telemetryItem[strBaseType];
     }
-    if (telemetryItem[strBaseType] === Event[_DYN_DATA_TYPE ]) {
+    if (telemetryItem[strBaseType] === Event$1[_DYN_DATA_TYPE ]) {
         customProperties = telemetryItem[strBaseData][strProperties] || {};
         customMeasurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS ] || {};
     }
@@ -5999,9 +6464,9 @@ function EventEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         _convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
     }
     var eventName = telemetryItem[strBaseData][_DYN_NAME ];
-    var eventData = new Event(logger, eventName, customProperties, customMeasurements);
-    var data = new Data(Event[_DYN_DATA_TYPE ], eventData);
-    return _createEnvelope(logger, Event[_DYN_ENVELOPE_TYPE ], telemetryItem, data);
+    var eventData = new Event$1(logger, eventName, customProperties, customMeasurements);
+    var data = new Data(Event$1[_DYN_DATA_TYPE ], eventData);
+    return _createEnvelope(logger, Event$1[_DYN_ENVELOPE_TYPE ], telemetryItem, data);
 }
 function ExceptionEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
     EnvelopeCreatorInit(logger, telemetryItem);
@@ -6644,7 +7109,7 @@ function _chkSampling(value) {
     return !isNaN(value) && value > 0 && value <= 100;
 }
 var EnvelopeTypeCreator = (_b = {},
-    _b[Event.dataType] = EventEnvelopeCreator,
+    _b[Event$1.dataType] = EventEnvelopeCreator,
     _b[Trace.dataType] = TraceEnvelopeCreator,
     _b[PageView.dataType] = PageViewEnvelopeCreator,
     _b[PageViewPerformance.dataType] = PageViewPerformanceEnvelopeCreator,
@@ -6683,6 +7148,7 @@ var Sender = /** @class */ (function (_super) {
         var _sessionStorageUsed;
         var _bufferOverrideUsed;
         var _namePrefix;
+        var _enableSendPromise;
         dynamicProto(Sender, _this, function (_self, _base) {
             _initDefaults();
             _self.pause = function () {
@@ -6702,7 +7168,7 @@ var Sender = /** @class */ (function (_super) {
                 if (!_paused) {
                     _clearScheduledTimer();
                     try {
-                        _self[_DYN_TRIGGER_SEND ](isAsync, null, sendReason || 1 );
+                        return _self[_DYN_TRIGGER_SEND ](isAsync, null, sendReason || 1 );
                     }
                     catch (e) {
                         _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 22 , "flush failed, telemetry will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
@@ -6713,14 +7179,14 @@ var Sender = /** @class */ (function (_super) {
                 if (!_paused) {
                     if (_beaconSupported) {
                         try {
-                            _self[_DYN_TRIGGER_SEND ](true, _doUnloadSend, 2 );
+                            return _self[_DYN_TRIGGER_SEND ](true, _doUnloadSend, 2 );
                         }
                         catch (e) {
                             _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 20 , "failed to flush with beacon sender on page unload, telemetry will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
                         }
                     }
                     else {
-                        _self.flush();
+                        _self.flush(false);
                     }
                 }
             };
@@ -6799,6 +7265,7 @@ var Sender = /** @class */ (function (_super) {
                     else {
                         _customHeaders = null;
                     }
+                    _enableSendPromise = senderConfig.enableSendPromise;
                     var sendPostFunc = null;
                     if (!senderConfig[_DYN_DISABLE_XHR ] && useXDomainRequest()) {
                         sendPostFunc = _xdrSender;
@@ -6906,6 +7373,7 @@ var Sender = /** @class */ (function (_super) {
             };
             _self[_DYN_TRIGGER_SEND ] = function (async, forcedSender, sendReason) {
                 if (async === void 0) { async = true; }
+                var result;
                 if (!_paused) {
                     try {
                         var buffer = _self[_DYN__BUFFER ];
@@ -6914,10 +7382,10 @@ var Sender = /** @class */ (function (_super) {
                                 var payload = buffer.getItems();
                                 _notifySendRequest(sendReason || 0 , async);
                                 if (forcedSender) {
-                                    forcedSender.call(_this, payload, async);
+                                    result = forcedSender.call(_this, payload, async);
                                 }
                                 else {
-                                    _self[_DYN__SENDER ](payload, async);
+                                    result = _self[_DYN__SENDER ](payload, async);
                                 }
                             }
                         }
@@ -6933,10 +7401,11 @@ var Sender = /** @class */ (function (_super) {
                         }
                     }
                 }
+                return result;
             };
             _self._doTeardown = function (unloadCtx, unloadState) {
                 _self.onunloadFlush();
-                _offlineListener.unload();
+                runTargetUnload(_offlineListener, false);
                 _initDefaults();
             };
             _self[_DYN__ON_ERROR ] = function (payload, message, event) {
@@ -7105,6 +7574,9 @@ var Sender = /** @class */ (function (_super) {
                 }
             }
             function _xhrSender(payload, isAsync) {
+                var thePromise;
+                var resolveFunc;
+                var rejectFunc;
                 var xhr = new XMLHttpRequest();
                 var endPointUrl = _endpointUrl;
                 try {
@@ -7120,11 +7592,26 @@ var Sender = /** @class */ (function (_super) {
                 arrForEach(objKeys(_headers), function (headerName) {
                     xhr[_DYN_SET_REQUEST_HEADER ](headerName, _headers[headerName]);
                 });
-                xhr.onreadystatechange = function () { return _self._xhrReadyStateChange(xhr, payload, payload[_DYN_LENGTH ]); };
-                xhr.onerror = function (event) { return _self[_DYN__ON_ERROR ](payload, _formatErrorMessageXhr(xhr), event); };
+                xhr.onreadystatechange = function () {
+                    _self._xhrReadyStateChange(xhr, payload, payload[_DYN_LENGTH ]);
+                    if (xhr.readyState === 4) {
+                        resolveFunc && resolveFunc(true);
+                    }
+                };
+                xhr.onerror = function (event) {
+                    _self[_DYN__ON_ERROR ](payload, _formatErrorMessageXhr(xhr), event);
+                    rejectFunc && rejectFunc(event);
+                };
+                if (isAsync && _enableSendPromise) {
+                    thePromise = createPromise(function (resolve, reject) {
+                        resolveFunc = resolve;
+                        rejectFunc = reject;
+                    });
+                }
                 var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
                 xhr.send(batch);
                 _self._buffer[_DYN_MARK_AS_SENT ](payload);
+                return thePromise;
             }
             function _fetchKeepAliveSender(payload, isAsync) {
                 if (isArray(payload)) {
@@ -7145,13 +7632,16 @@ var Sender = /** @class */ (function (_super) {
                 }
             }
             function _fetchSender(payload, isAsync) {
-                _doFetchSender(payload, true);
+                return _doFetchSender(payload, true);
             }
             function _doFetchSender(payload, isAsync) {
                 var _a;
                 var endPointUrl = _endpointUrl;
                 var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
                 var plainTextBatch = new Blob([batch], { type: "application/json" });
+                var thePromise;
+                var resolveFunc;
+                var rejectFunc;
                 var requestHeaders = new Headers();
                 var batchLength = batch[_DYN_LENGTH ];
                 var ignoreResponse = false;
@@ -7182,43 +7672,52 @@ var Sender = /** @class */ (function (_super) {
                 catch (e) {
                 }
                 _self._buffer[_DYN_MARK_AS_SENT ](payload);
+                if (isAsync && _enableSendPromise) {
+                    thePromise = createPromise(function (resolve, reject) {
+                        resolveFunc = resolve;
+                        rejectFunc = reject;
+                    });
+                }
                 try {
-                    fetch(request).then(function (response) {
+                    doAwaitResponse(fetch(request), function (result) {
                         if (!isAsync) {
                             _syncFetchPayload -= batchLength;
                             batchLength = 0;
                         }
                         if (!responseHandled) {
                             responseHandled = true;
-                            if (!response.ok) {
-                                _self[_DYN__ON_ERROR ](payload, response.statusText);
+                            if (!result.rejected) {
+                                var response_1 = result.value;
+                                if (!response_1.ok) {
+                                    _self[_DYN__ON_ERROR ](payload, response_1.statusText);
+                                    resolveFunc && resolveFunc(false);
+                                }
+                                else {
+                                    doAwaitResponse(response_1.text(), function (resp) {
+                                        _checkResponsStatus(response_1.status, payload, response_1.url, payload[_DYN_LENGTH ], response_1.statusText, resp.value || "");
+                                        resolveFunc && resolveFunc(true);
+                                    });
+                                }
                             }
                             else {
-                                response.text().then(function (text) {
-                                    _checkResponsStatus(response.status, payload, response.url, payload[_DYN_LENGTH ], response.statusText, text);
-                                });
+                                _self[_DYN__ON_ERROR ](payload, result.reason && result.reason.message);
+                                rejectFunc && rejectFunc(result.reason);
                             }
                         }
-                    }).catch(function (error) {
-                        if (!isAsync) {
-                            _syncFetchPayload -= batchLength;
-                            batchLength = 0;
-                        }
-                        if (!responseHandled) {
-                            responseHandled = true;
-                            _self[_DYN__ON_ERROR ](payload, error.message);
-                        }
                     });
                 }
                 catch (e) {
                     if (!responseHandled) {
                         _self[_DYN__ON_ERROR ](payload, dumpObj(e));
+                        rejectFunc && rejectFunc(e);
                     }
                 }
                 if (ignoreResponse && !responseHandled) {
                     responseHandled = true;
                     _self._onSuccess(payload, payload[_DYN_LENGTH ]);
+                    resolveFunc && resolveFunc(true);
                 }
+                return thePromise;
             }
             function _parseResponse(response) {
                 try {
@@ -7464,4 +7963,4 @@ exports.arrForEach = arrForEach;
 exports.isNullOrUndefined = isNullOrUndefined;
 exports.proxyFunctions = proxyFunctions;
 exports.throwError = throwError;
-//# sourceMappingURL=aib.3.0.1-nightly3.2304-38.cjs.js.map
+//# sourceMappingURL=aib.3.0.1-nightly3.2304-44.cjs.js.map