@microsoft/applicationinsights-channel-js 3.1.1-nightly3.2403-01 → 3.1.1-nightly3.2403-03

package/browser/es5/applicationinsights-channel-js.3.cjs.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Channel, 3.1.1-nightly3.2403-01
+ * Application Insights JavaScript SDK - Channel, 3.1.1-nightly3.2403-03
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 'use strict';
@@ -1123,7 +1123,7 @@ var _DYN_PUSH$2 = "push";
 var _DYN_SPLICE = "splice";
 var _DYN_HDLR = "hdlr";
 var _DYN_CANCEL = "cancel";
-var _DYN_INITIALIZE = "initialize";
+var _DYN_INITIALIZE$1 = "initialize";
 var _DYN_IDENTIFIER = "identifier";
 var _DYN_IS_INITIALIZED = "isInitialized";
 var _DYN_GET_PLUGIN = "getPlugin";
@@ -1472,7 +1472,7 @@ function createPromise(executor, timeout) {
 }
 
 var UNDEFINED_VALUE$1 = undefined;
-var STR_EMPTY = "";
+var STR_EMPTY$1 = "";
 var STR_CORE = "core";
 var STR_DISABLED = "disabled";
 var STR_EXTENSION_CONFIG = "extensionConfig";
@@ -1513,7 +1513,7 @@ function getExceptionName(object) {
     if (isError(object)) {
         return object[_DYN_NAME$2 ];
     }
-    return STR_EMPTY;
+    return STR_EMPTY$1;
 }
 function setValue(target, field, value, valChk, srcChk) {
     var theValue = value;
@@ -1617,6 +1617,7 @@ function objExtend(obj1, obj2, obj3, obj4, obj5, obj6) {
 }
 
 var strDocumentMode = "documentMode";
+var strLocation = "location";
 var strConsole = "console";
 var strJSON = "JSON";
 var strCrypto = "crypto";
@@ -1626,6 +1627,7 @@ var strTrident = "trident/";
 var strXMLHttpRequest = "XMLHttpRequest";
 var _isTrident = null;
 var _navUserAgentCheck = null;
+var _enableMocks = false;
 var _useXDomainRequest = null;
 var _beaconsSupported = null;
 function _hasProperty(theClass, property) {
@@ -1653,6 +1655,18 @@ function _hasProperty(theClass, property) {
     }
     return supported;
 }
+function getLocation(checkForMock) {
+    if (checkForMock && _enableMocks) {
+        var mockLocation = getInst("__mockLocation");
+        if (mockLocation) {
+            return mockLocation;
+        }
+    }
+    if (typeof location === strShimObject && location) {
+        return location;
+    }
+    return getInst(strLocation);
+}
 function getConsole() {
     if (typeof console !== strShimUndefined) {
         return console;
@@ -1678,7 +1692,7 @@ function isIE() {
     var nav = getNavigator();
     if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
         _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-        var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
+        var userAgent = (_navUserAgentCheck || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ]();
         _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
     }
     return _isTrident;
@@ -1687,9 +1701,9 @@ function getIEVersion(userAgentStr) {
     if (userAgentStr === void 0) { userAgentStr = null; }
     if (!userAgentStr) {
         var navigator_1 = getNavigator() || {};
-        userAgentStr = navigator_1 ? (navigator_1.userAgent || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]() : STR_EMPTY;
+        userAgentStr = navigator_1 ? (navigator_1.userAgent || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ]() : STR_EMPTY$1;
     }
-    var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
+    var ua = (userAgentStr || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ]();
     if (strContains(ua, strMsie)) {
         var doc = getDocument() || {};
         return Math.max(parseInt(ua[_DYN_SPLIT$1 ](strMsie)[1]), (doc[strDocumentMode] || 0));
@@ -1798,7 +1812,7 @@ function newId(maxLength) {
     var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     var number = random32() >>> 0;
     var chars = 0;
-    var result = STR_EMPTY;
+    var result = STR_EMPTY$1;
     while (result[_DYN_LENGTH$2 ] < maxLength) {
         chars++;
         result += base64chars.charAt(number & 0x3F);
@@ -1836,11 +1850,11 @@ function _getCache(data, target) {
 }
 function createUniqueNamespace(name, includeVersion) {
     if (includeVersion === void 0) { includeVersion = false; }
-    return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
+    return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY$1) + instanceName);
 }
 function createElmNodeData(name) {
     var data = {
-        id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
+        id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$1) + "." + version),
         accept: function (target) {
             return _canAcceptData(target);
         },
@@ -2545,9 +2559,9 @@ var _logFuncs = (_a$2 = {},
     _a$2);
 function _sanitizeDiagnosticText(text) {
     if (text) {
-        return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
+        return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY$1) + "\"";
     }
-    return STR_EMPTY;
+    return STR_EMPTY$1;
 }
 function _logToConsole(func, message) {
     var theConsole = getConsole();
@@ -2569,12 +2583,12 @@ var _InternalLogMessage = /** @class */ (function () {
         _self[_DYN_MESSAGE$1 ] =
             (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
                 msgId;
-        var strProps = STR_EMPTY;
+        var strProps = STR_EMPTY$1;
         if (hasJSON()) {
             strProps = getJSON().stringify(properties);
         }
-        var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +
-            (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
+        var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$1) +
+            (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$1);
         _self[_DYN_MESSAGE$1 ] += diagnosticText;
     }
     _InternalLogMessage.dataType = "MessageData";
@@ -3107,7 +3121,7 @@ function createTelemetryPluginProxy(plugin, config, core) {
             doPerf(itemCtx[STR_CORE ](), function () { return identifier + ":" + name; }, function () {
                 hasRunContext[chainId] = true;
                 try {
-                    var nextId = nextProxy ? nextProxy._id : STR_EMPTY;
+                    var nextId = nextProxy ? nextProxy._id : STR_EMPTY$1;
                     if (nextId) {
                         hasRunContext[nextId] = false;
                     }
@@ -3252,7 +3266,7 @@ var BaseTelemetryPlugin = /** @class */ (function () {
         var _hookContainer;
         _initDefaults();
         dynamicProto(BaseTelemetryPlugin, _self, function (_self) {
-            _self[_DYN_INITIALIZE ] = function (config, core, extensions, pluginChain) {
+            _self[_DYN_INITIALIZE$1 ] = function (config, core, extensions, pluginChain) {
                 _setDefaults(config, core, pluginChain);
                 _isinitialized = true;
             };
@@ -3393,16 +3407,16 @@ var elmNodeData = createElmNodeData("events");
 var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
 function _normalizeNamespace(name) {
     if (name && name[_DYN_REPLACE ]) {
-        return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY);
+        return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY$1);
     }
     return name;
 }
 function _getEvtNamespace(eventName, evtNamespace) {
     var _a;
     if (evtNamespace) {
-        var theNamespace_1 = STR_EMPTY;
+        var theNamespace_1 = STR_EMPTY$1;
         if (isArray(evtNamespace)) {
-            theNamespace_1 = STR_EMPTY;
+            theNamespace_1 = STR_EMPTY$1;
             arrForEach(evtNamespace, function (name) {
                 name = _normalizeNamespace(name);
                 if (name) {
@@ -3420,13 +3434,13 @@ function _getEvtNamespace(eventName, evtNamespace) {
             if (theNamespace_1[0] !== ".") {
                 theNamespace_1 = "." + theNamespace_1;
             }
-            eventName = (eventName || STR_EMPTY) + theNamespace_1;
+            eventName = (eventName || STR_EMPTY$1) + theNamespace_1;
         }
     }
-    var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);
+    var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY$1) || []);
     return _a = {},
         _a[_DYN_TYPE ] = parsedEvent[1],
-        _a.ns = ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT$1 ](".").sort()).join("."),
+        _a.ns = ((parsedEvent[2] || STR_EMPTY$1).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$1)[_DYN_SPLIT$1 ](".").sort()).join("."),
         _a;
 }
 function _getRegisteredEvents(target, evtName, addDefault) {
@@ -3575,14 +3589,20 @@ var RequestHeaders = createValueMap({
 var _DYN_SPLIT = "split";
 var _DYN_LENGTH$1 = "length";
 var _DYN_TO_LOWER_CASE = "toLowerCase";
+var _DYN_LOCATION = "location";
 var _DYN_TO_STRING$1 = "toString";
 var _DYN_PUSH$1 = "push";
+var _DYN_URL_STRING = "urlString";
+var _DYN_DATA$1 = "data";
+var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
+var _DYN_REASON = "reason";
+var _DYN_MESSAGE = "message";
 var _DYN_REMOVE_ITEM = "removeItem";
 var _DYN_NAME$1 = "name";
-var _DYN_MESSAGE = "message";
 var _DYN_COUNT$1 = "count";
 var _DYN_STRINGIFY$1 = "stringify";
 var _DYN_PATHNAME = "pathname";
+var _DYN_ITEMS_RECEIVED$1 = "itemsReceived";
 var _DYN_EXCEPTIONS = "exceptions";
 var _DYN_PARSED_STACK = "parsedStack";
 var _DYN_PROPERTIES = "properties";
@@ -3804,6 +3824,54 @@ function AjaxHelperParseDependencyPath(logger, absoluteUrl, method, commandName)
         data: data
     };
 }
+function getResponseText(xhr) {
+    try {
+        return xhr.responseText;
+    }
+    catch (e) {
+    }
+    return null;
+}
+function formatErrorMessageXdr(xdr, message) {
+    if (xdr) {
+        return "XDomainRequest,Response:" + getResponseText(xdr) || "";
+    }
+    return message;
+}
+function formatErrorMessageXhr(xhr, message) {
+    if (xhr) {
+        return "XMLHttpRequest,Status:" + xhr.status + ",Response:" + getResponseText(xhr) || xhr.response || "";
+    }
+    return message;
+}
+function prependTransports(theTransports, newTransports) {
+    if (newTransports) {
+        if (isNumber(newTransports)) {
+            theTransports = [newTransports].concat(theTransports);
+        }
+        else if (isArray(newTransports)) {
+            theTransports = newTransports.concat(theTransports);
+        }
+    }
+    return theTransports;
+}
+function parseResponse(response, diagLog) {
+    try {
+        if (response && response !== "") {
+            var result = getJSON().parse(response);
+            if (result && result[_DYN_ITEMS_RECEIVED$1 ] && result[_DYN_ITEMS_RECEIVED$1 ] >= result.itemsAccepted &&
+                result.itemsReceived - result.itemsAccepted === result.errors[_DYN_LENGTH$1 ]) {
+                return result;
+            }
+        }
+    }
+    catch (e) {
+        _throwInternal(diagLog, 1 , 43 , "Cannot parse the response. " + getExceptionName(e), {
+            response: response
+        });
+    }
+    return null;
+}
 
 var StorageType = createEnumStyle({
     LocalStorage: 0 ,
@@ -3882,7 +3950,7 @@ var Envelope = /** @class */ (function () {
         _self.sampleRate = 100.0;
         _self.tags = {};
         _self[_DYN_NAME$1 ] = dataSanitizeString(logger, name) || strNotSpecified;
-        _self.data = data;
+        _self[_DYN_DATA$1 ] = data;
         _self.time = toISOString(new Date());
         _self.aiDataContract = {
             time: 1 ,
@@ -4039,8 +4107,8 @@ function _getStackFromErrorObj(errorObj) {
             else if (getWindow() && getWindow()["opera"] && errorObj[strMessage]) {
                 details = _getOperaStack(errorObj[_DYN_MESSAGE ]);
             }
-            else if (errorObj["reason"] && errorObj.reason[strStack]) {
-                details = _convertStackObj(errorObj.reason[strStack]);
+            else if (errorObj["reason"] && errorObj[_DYN_REASON ][strStack]) {
+                details = _convertStackObj(errorObj[_DYN_REASON ][strStack]);
             }
             else if (isString(errorObj)) {
                 details = _convertStackObj(errorObj);
@@ -4511,7 +4579,7 @@ var RemoteDependencyData = /** @class */ (function () {
         _self.resultCode = resultCode + "";
         _self.type = dataSanitizeString(logger, requestAPI);
         var dependencyFields = AjaxHelperParseDependencyPath(logger, absoluteUrl, method, commandName);
-        _self.data = dataSanitizeUrl(logger, commandName) || dependencyFields.data;
+        _self[_DYN_DATA$1 ] = dataSanitizeUrl(logger, commandName) || dependencyFields[_DYN_DATA$1 ];
         _self.target = dataSanitizeString(logger, dependencyFields.target);
         if (correlationContext) {
             _self.target = "".concat(_self.target, " | ").concat(correlationContext);
@@ -4677,6 +4745,360 @@ var ContextTagKeys = /** @class */ (function (_super) {
 
 var CtxTagKeys = new ContextTagKeys();
 
+var STR_EMPTY = "";
+var SenderPostManager = /** @class */ (function () {
+    function SenderPostManager() {
+        var _syncFetchPayload = 0;
+        var _enableSendPromise;
+        var _isInitialized;
+        var _diagLog;
+        var _isOneDs;
+        var _onCompleteFuncs;
+        var _disableCredentials;
+        var _fallbackInst;
+        var _disableXhr;
+        var _disableBeacon;
+        var _disableBeaconSync;
+        dynamicProto(SenderPostManager, this, function (_self, _base) {
+            var _sendCredentials = true;
+            _initDefaults();
+            _self.initialize = function (config, diagLog) {
+                _diagLog = diagLog;
+                if (_isInitialized) {
+                    _throwInternal(_diagLog, 1 , 28 , "Sender is already initialized");
+                }
+                _self.SetConfig(config);
+                _isInitialized = true;
+            };
+            _self["_getDbgPlgTargets"] = function () {
+                return [_isInitialized, _isOneDs, _disableCredentials, _enableSendPromise];
+            };
+            _self.SetConfig = function (config) {
+                try {
+                    _onCompleteFuncs = config.senderOnCompleteCallBack || {};
+                    _disableCredentials = !!config.disableCredentials;
+                    _isOneDs = !!config.isOneDs;
+                    _enableSendPromise = !!config.enableSendPromise;
+                    _disableXhr = !!config.disableXhr;
+                    _disableBeacon = !!config.disableBeacon;
+                    _disableBeaconSync = !!config.disableBeaconSync;
+                    _fallbackInst = { sendPOST: _xhrSender };
+                    if (_disableCredentials) {
+                        var location_1 = getLocation();
+                        if (location_1 && location_1.protocol && location_1.protocol[_DYN_TO_LOWER_CASE ]() === "file:") {
+                            _sendCredentials = false;
+                        }
+                    }
+                    return true;
+                }
+                catch (e) {
+                }
+                return false;
+            };
+            _self.getSyncFetchPayload = function () {
+                return _syncFetchPayload;
+            };
+            _self.getXhrInst = function (transports, sync) {
+                if (transports && transports[_DYN_LENGTH$1 ]) {
+                    return _getSenderInterface(transports, sync);
+                }
+                return null;
+            };
+            _self.getFallbackInst = function () {
+                return _fallbackInst;
+            };
+            _self._doTeardown = function (unloadCtx, unloadState) {
+                _initDefaults();
+            };
+            function _onSuccess(res, onComplete) {
+                _doOnComplete(onComplete, 200, {}, res);
+            }
+            function _onError(message, onComplete) {
+                _throwInternal(_diagLog, 2 , 26 , "Failed to send telemetry.", { message: message });
+                _doOnComplete(onComplete, 400, {});
+            }
+            function _onNoPayloadUrl(onComplete) {
+                _onError("No endpoint url is provided for the batch", onComplete);
+            }
+            function _getSenderInterface(transports, syncSupport) {
+                var transportType = null;
+                var sendPostFunc = null;
+                var lp = 0;
+                while (sendPostFunc == null && lp < transports[_DYN_LENGTH$1 ]) {
+                    transportType = transports[lp];
+                    if (!_disableXhr && transportType === 1 ) {
+                        if (useXDomainRequest()) {
+                            sendPostFunc = _xdrSender;
+                        }
+                        else if (isXhrSupported()) {
+                            sendPostFunc = _xhrSender;
+                        }
+                    }
+                    else if (transportType === 2  && isFetchSupported(syncSupport)) {
+                        sendPostFunc = _doFetchSender;
+                    }
+                    else if (transportType === 3  && isBeaconsSupported() && (syncSupport ? !_disableBeaconSync : !_disableBeacon)) {
+                        sendPostFunc = _beaconSender;
+                    }
+                    lp++;
+                }
+                if (sendPostFunc) {
+                    return {
+                        sendPOST: sendPostFunc
+                    };
+                }
+                return null;
+            }
+            function _doOnComplete(oncomplete, status, headers, response) {
+                try {
+                    oncomplete && oncomplete(status, headers, response);
+                }
+                catch (e) {
+                }
+            }
+            function _doBeaconSend(payload, oncomplete) {
+                var nav = getNavigator();
+                var url = payload[_DYN_URL_STRING ];
+                if (!url) {
+                    _onNoPayloadUrl(oncomplete);
+                    return true;
+                }
+                var data = payload[_DYN_DATA$1 ];
+                var plainTextBatch = new Blob([data], { type: "text/plain;charset=UTF-8" });
+                var queued = nav.sendBeacon(url, plainTextBatch);
+                return queued;
+            }
+            function _beaconSender(payload, oncomplete, sync) {
+                var data = payload[_DYN_DATA$1 ];
+                if (data) {
+                    if (!_doBeaconSend(payload, oncomplete)) {
+                        var onRetry = _onCompleteFuncs && _onCompleteFuncs.beaconOnRetry;
+                        if (onRetry && isFunction(onRetry)) {
+                            onRetry(payload, oncomplete, _doBeaconSend);
+                        }
+                        else {
+                            _fallbackInst && _fallbackInst.sendPOST(payload, oncomplete, true);
+                            _throwInternal(_diagLog, 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                        }
+                    }
+                    else {
+                        _onSuccess(null, oncomplete);
+                    }
+                }
+                return;
+            }
+            function _xhrSender(payload, oncomplete, sync) {
+                var thePromise;
+                var resolveFunc;
+                var rejectFunc;
+                var headers = payload.headers || {};
+                if (!sync && _enableSendPromise) {
+                    thePromise = createPromise(function (resolve, reject) {
+                        resolveFunc = resolve;
+                        rejectFunc = reject;
+                    });
+                }
+                var xhr = new XMLHttpRequest();
+                var endPointUrl = payload[_DYN_URL_STRING ];
+                if (!endPointUrl) {
+                    _onNoPayloadUrl(oncomplete);
+                    resolveFunc && resolveFunc(false);
+                    return;
+                }
+                try {
+                    xhr[DisabledPropertyName] = true;
+                }
+                catch (e) {
+                }
+                xhr.open("POST", endPointUrl, !sync);
+                xhr[_DYN_SET_REQUEST_HEADER ]("Content-type", "application/json");
+                if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
+                    xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[6 ], RequestHeaders[7 ]);
+                }
+                arrForEach(objKeys(headers), function (headerName) {
+                    xhr[_DYN_SET_REQUEST_HEADER ](headerName, headers[headerName]);
+                });
+                xhr.onreadystatechange = function () {
+                    var response = getResponseText(xhr);
+                    var onReadyFunc = _onCompleteFuncs && _onCompleteFuncs.xhrOnComplete;
+                    var onReadyFuncExist = onReadyFunc && isFunction(onReadyFunc);
+                    if (onReadyFuncExist) {
+                        onReadyFunc(xhr, oncomplete, payload);
+                    }
+                    if (xhr.readyState === 4) {
+                        if (!onReadyFuncExist) {
+                            _doOnComplete(oncomplete, xhr.status, {}, response);
+                        }
+                        resolveFunc && resolveFunc(true);
+                    }
+                };
+                xhr.onerror = function (event) {
+                    _doOnComplete(oncomplete, 400, {}, formatErrorMessageXhr(xhr));
+                    rejectFunc && rejectFunc(event);
+                };
+                xhr.ontimeout = function () {
+                    _doOnComplete(oncomplete, 500, {}, formatErrorMessageXhr(xhr));
+                    resolveFunc && resolveFunc(false);
+                };
+                xhr.send(payload[_DYN_DATA$1 ]);
+                return thePromise;
+            }
+            function _doFetchSender(payload, oncomplete, sync) {
+                var _a;
+                var endPointUrl = payload[_DYN_URL_STRING ];
+                var batch = payload[_DYN_DATA$1 ];
+                var plainTextBatch = new Blob([batch], { type: "application/json" });
+                var thePromise;
+                var resolveFunc;
+                var rejectFunc;
+                var requestHeaders = new Headers();
+                var batchLength = batch[_DYN_LENGTH$1 ];
+                var ignoreResponse = false;
+                var responseHandled = false;
+                var headers = payload.headers || {};
+                if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
+                    requestHeaders.append(RequestHeaders[6 ], RequestHeaders[7 ]);
+                }
+                arrForEach(objKeys(headers), function (headerName) {
+                    requestHeaders.append(headerName, headers[headerName]);
+                });
+                var init = (_a = {
+                        method: "POST",
+                        headers: requestHeaders,
+                        body: plainTextBatch
+                    },
+                    _a[DisabledPropertyName] = true
+                ,
+                    _a);
+                if (_sendCredentials && _isOneDs) {
+                    init.credentials = "include";
+                }
+                if (sync) {
+                    init.keepalive = true;
+                    ignoreResponse = true;
+                    _syncFetchPayload += batchLength;
+                }
+                var request = new Request(endPointUrl, init);
+                try {
+                    request[DisabledPropertyName] = true;
+                }
+                catch (e) {
+                }
+                if (!sync && _enableSendPromise) {
+                    thePromise = createPromise(function (resolve, reject) {
+                        resolveFunc = resolve;
+                        rejectFunc = reject;
+                    });
+                }
+                if (!endPointUrl) {
+                    _onNoPayloadUrl(oncomplete);
+                    resolveFunc && resolveFunc(false);
+                    return;
+                }
+                try {
+                    doAwaitResponse(fetch(request), function (result) {
+                        if (sync) {
+                            _syncFetchPayload -= batchLength;
+                            batchLength = 0;
+                        }
+                        if (!responseHandled) {
+                            responseHandled = true;
+                            if (!result.rejected) {
+                                var response_1 = result.value;
+                                if (!response_1.ok) {
+                                    _doOnComplete(oncomplete, 400, {}, response_1.statusText);
+                                    resolveFunc && resolveFunc(false);
+                                }
+                                else {
+                                    doAwaitResponse(response_1.text(), function (resp) {
+                                        var status = response_1.status;
+                                        var onCompleteFunc = _onCompleteFuncs.fetchOnComplete;
+                                        if (onCompleteFunc && isFunction(onCompleteFunc)) {
+                                            onCompleteFunc(response_1, oncomplete, resp.value || STR_EMPTY, payload);
+                                        }
+                                        else {
+                                            _doOnComplete(oncomplete, status, {}, resp.value || STR_EMPTY);
+                                        }
+                                        resolveFunc && resolveFunc(true);
+                                    });
+                                }
+                            }
+                            else {
+                                _doOnComplete(oncomplete, 400, {}, result[_DYN_REASON ] && result[_DYN_REASON ][_DYN_MESSAGE ]);
+                                rejectFunc && rejectFunc(result[_DYN_REASON ]);
+                            }
+                        }
+                    });
+                }
+                catch (e) {
+                    if (!responseHandled) {
+                        _doOnComplete(oncomplete, 400, {}, dumpObj(e));
+                        rejectFunc && rejectFunc(e);
+                    }
+                }
+                if (ignoreResponse && !responseHandled) {
+                    responseHandled = true;
+                    _doOnComplete(oncomplete, 200, {});
+                    resolveFunc && resolveFunc(true);
+                }
+                return thePromise;
+            }
+            function _xdrSender(payload, oncomplete, sync) {
+                var _window = getWindow();
+                var xdr = new XDomainRequest();
+                var data = payload[_DYN_DATA$1 ];
+                xdr.onload = function () {
+                    var response = getResponseText(xdr);
+                    var onloadFunc = _onCompleteFuncs && _onCompleteFuncs.xdrOnComplete;
+                    if (onloadFunc && isFunction(onloadFunc)) {
+                        onloadFunc(xdr, oncomplete, payload);
+                    }
+                    else {
+                        _doOnComplete(oncomplete, 200, {}, response);
+                    }
+                };
+                xdr.onerror = function () {
+                    _doOnComplete(oncomplete, 400, {}, formatErrorMessageXdr(xdr));
+                };
+                xdr.ontimeout = function () {
+                    _doOnComplete(oncomplete, 500, {});
+                };
+                xdr.onprogress = function () { };
+                var hostingProtocol = _window && _window[_DYN_LOCATION ] && _window[_DYN_LOCATION ].protocol || "";
+                var endpoint = payload[_DYN_URL_STRING ];
+                if (!endpoint) {
+                    _onNoPayloadUrl(oncomplete);
+                    return;
+                }
+                if (endpoint.lastIndexOf(hostingProtocol, 0) !== 0) {
+                    var msg = "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.";
+                    _throwInternal(_diagLog, 2 , 40 , ". " + msg);
+                    _onError(msg, oncomplete);
+                    return;
+                }
+                var endpointUrl = endpoint.replace(/^(https?:)/, "");
+                xdr.open("POST", endpointUrl);
+                xdr.send(data);
+            }
+            function _initDefaults() {
+                _syncFetchPayload = 0;
+                _isInitialized = false;
+                _enableSendPromise = false;
+                _diagLog = null;
+                _isOneDs = null;
+                _onCompleteFuncs = null;
+                _disableCredentials = null;
+                _fallbackInst = null;
+                _disableXhr = false;
+                _disableBeacon = false;
+                _disableBeaconSync = false;
+            }
+        });
+    }
+    SenderPostManager.__ieDyn=1;
+    return SenderPostManager;
+}());
+
 function _disableEvents(target, evtNamespace) {
     eventOff(target, null, null, evtNamespace);
 }
@@ -4815,43 +5237,42 @@ var _DYN_EVENTS_LIMIT_IN_MEM = "eventsLimitInMem";
 var _DYN_PUSH = "push";
 var _DYN_EMIT_LINE_DELIMITED_0 = "emitLineDelimitedJson";
 var _DYN_CLEAR = "clear";
-var _DYN_BATCH_PAYLOADS = "batchPayloads";
 var _DYN_CREATE_NEW = "createNew";
 var _DYN_MARK_AS_SENT = "markAsSent";
 var _DYN_CLEAR_SENT = "clearSent";
 var _DYN_BUFFER_OVERRIDE = "bufferOverride";
 var _DYN__BUFFER__KEY = "BUFFER_KEY";
 var _DYN__SENT__BUFFER__KEY = "SENT_BUFFER_KEY";
-var _DYN_CONCAT = "concat";
 var _DYN__MAX__BUFFER__SIZE = "MAX_BUFFER_SIZE";
-var _DYN_SEND_POST = "sendPOST";
 var _DYN_TRIGGER_SEND = "triggerSend";
 var _DYN_DIAG_LOG = "diagLog";
+var _DYN_INITIALIZE = "initialize";
 var _DYN__SENDER = "_sender";
 var _DYN_CUSTOM_HEADERS = "customHeaders";
 var _DYN_MAX_BATCH_SIZE_IN_BY1 = "maxBatchSizeInBytes";
 var _DYN_ONUNLOAD_DISABLE_BEA2 = "onunloadDisableBeacon";
 var _DYN_IS_BEACON_API_DISABL3 = "isBeaconApiDisabled";
 var _DYN_ALWAYS_USE_XHR_OVERR4 = "alwaysUseXhrOverride";
+var _DYN_DISABLE_XHR = "disableXhr";
 var _DYN_ENABLE_SESSION_STORA5 = "enableSessionStorageBuffer";
 var _DYN__BUFFER = "_buffer";
 var _DYN_ONUNLOAD_DISABLE_FET6 = "onunloadDisableFetch";
 var _DYN_DISABLE_SEND_BEACON_7 = "disableSendBeaconSplit";
 var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
+var _DYN_ENABLE_SEND_PROMISE = "enableSendPromise";
+var _DYN_GET_XHR_INST = "getXhrInst";
 var _DYN_UNLOAD_TRANSPORTS = "unloadTransports";
 var _DYN_CONVERT_UNDEFINED = "convertUndefined";
 var _DYN_MAX_BATCH_INTERVAL = "maxBatchInterval";
 var _DYN_SERIALIZE = "serialize";
-var _DYN__XHR_READY_STATE_CHA8 = "_xhrReadyStateChange";
 var _DYN__ON_ERROR = "_onError";
 var _DYN__ON_PARTIAL_SUCCESS = "_onPartialSuccess";
 var _DYN__ON_SUCCESS = "_onSuccess";
 var _DYN_ITEMS_ACCEPTED = "itemsAccepted";
 var _DYN_ITEMS_RECEIVED = "itemsReceived";
+var _DYN_ORI_PAYLOAD = "oriPayload";
 var _DYN_BASE_TYPE = "baseType";
 var _DYN_SAMPLE_RATE = "sampleRate";
-var _DYN_ORI_PAYLOAD = "oriPayload";
-var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
 var _DYN_EVENTS_SEND_REQUEST = "eventsSendRequest";
 var _DYN_GET_SAMPLING_SCORE = "getSamplingScore";
 var _DYN_GET_HASH_CODE_SCORE = "getHashCodeScore";
@@ -4965,7 +5386,7 @@ function EnvelopeCreatorInit(logger, telemetryItem) {
     }
 }
 var EnvelopeCreator = {
-    Version: '3.1.1-nightly3.2403-01'
+    Version: '3.1.1-nightly3.2403-03'
 };
 function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
     EnvelopeCreatorInit(logger, telemetryItem);
@@ -5156,7 +5577,7 @@ var BaseSendBuffer = /** @class */ (function () {
             _self.getItems = function () {
                 return _buffer.slice(0);
             };
-            _self[_DYN_BATCH_PAYLOADS ] = function (payload) {
+            _self.batchPayloads = function (payload) {
                 if (payload && payload[_DYN_LENGTH ] > 0) {
                     var batch = config[_DYN_EMIT_LINE_DELIMITED_0 ] ?
                         payload.join("\n") :
@@ -5206,7 +5627,7 @@ var SessionStorageSendBuffer = /** @class */ (function (_super) {
         dynamicProto(SessionStorageSendBuffer, _this, function (_self, _base) {
             var bufferItems = _getBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY ]);
             var notDeliveredItems = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ]);
-            var buffer = _self._set(bufferItems[_DYN_CONCAT ](notDeliveredItems));
+            var buffer = _self._set(bufferItems.concat(notDeliveredItems));
             if (buffer[_DYN_LENGTH ] > SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ]) {
                 buffer[_DYN_LENGTH ] = SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ];
             }
@@ -5233,7 +5654,7 @@ var SessionStorageSendBuffer = /** @class */ (function (_super) {
                 _setBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY ], _self._set(_removePayloadsFromBuffer(payload, _self[_DYN__GET ]())));
                 var sentElements = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ]);
                 if (sentElements instanceof Array && payload instanceof Array) {
-                    sentElements = sentElements[_DYN_CONCAT ](payload);
+                    sentElements = sentElements.concat(payload);
                     if (sentElements[_DYN_LENGTH ] > SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ]) {
                         _throwInternal(logger, 1 , 67 , "Sent buffer reached its maximum size: " + sentElements[_DYN_LENGTH ], true);
                         sentElements[_DYN_LENGTH ] = SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ];
@@ -5466,7 +5887,7 @@ var HashCodeScoreGenerator = /** @class */ (function () {
             return 0;
         }
         while (input[_DYN_LENGTH ] < MIN_INPUT_LENGTH) {
-            input = input[_DYN_CONCAT ](input);
+            input = input.concat(input);
         }
         var hash = 5381;
         for (var i = 0; i < input[_DYN_LENGTH ]; ++i) {
@@ -5546,18 +5967,7 @@ function _getResponseText(xhr) {
     return null;
 }
 function isOverrideFn(httpXHROverride) {
-    return httpXHROverride && httpXHROverride[_DYN_SEND_POST ];
-}
-function _prependTransports(theTransports, newTransports) {
-    if (newTransports) {
-        if (isNumber(newTransports)) {
-            theTransports = [newTransports][_DYN_CONCAT ](theTransports);
-        }
-        else if (isArray(newTransports)) {
-            theTransports = newTransports[_DYN_CONCAT ](theTransports);
-        }
-    }
-    return theTransports;
+    return httpXHROverride && httpXHROverride.sendPOST;
 }
 var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
         endpointUrl: cfgDfValidate(isTruthy, DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH)
@@ -5570,7 +5980,7 @@ var defaultAppInsightsChannelConfig = objDeepFreeze((_a = {
     _a.isRetryDisabled = cfgDfBoolean(),
     _a[_DYN_IS_BEACON_API_DISABL3 ] = cfgDfBoolean(true),
     _a[_DYN_DISABLE_SEND_BEACON_7 ] = cfgDfBoolean(true),
-    _a.disableXhr = cfgDfBoolean(),
+    _a[_DYN_DISABLE_XHR ] = cfgDfBoolean(),
     _a[_DYN_ONUNLOAD_DISABLE_FET6 ] = cfgDfBoolean(),
     _a[_DYN_ONUNLOAD_DISABLE_BEA2 ] = cfgDfBoolean(),
     _a[_DYN_INSTRUMENTATION_KEY ] = UNDEFINED_VALUE,
@@ -5635,6 +6045,7 @@ var Sender = /** @class */ (function (_super) {
         var _xhrSend;
         var _fallbackSend;
         var _disableBeaconSplit;
+        var _sendPostMgr;
         dynamicProto(Sender, _this, function (_self, _base) {
             _initDefaults();
             _self.pause = function () {
@@ -5679,11 +6090,11 @@ var Sender = /** @class */ (function (_super) {
             _self.addHeader = function (name, value) {
                 _headers[name] = value;
             };
-            _self.initialize = function (config, core, extensions, pluginChain) {
+            _self[_DYN_INITIALIZE ] = function (config, core, extensions, pluginChain) {
                 if (_self.isInitialized()) {
                     _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 28 , "Sender is already initialized");
                 }
-                _base.initialize(config, core, extensions, pluginChain);
+                _base[_DYN_INITIALIZE ](config, core, extensions, pluginChain);
                 var identifier = _self.identifier;
                 _serializer = new Serializer(core.logger);
                 _consecutiveErrors = 0;
@@ -5718,7 +6129,7 @@ var Sender = /** @class */ (function (_super) {
                     _beaconOnUnloadSupported = senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2 ] === false && isBeaconsSupported();
                     _beaconNormalSupported = senderConfig[_DYN_IS_BEACON_API_DISABL3 ] === false && isBeaconsSupported();
                     _alwaysUseCustomSend = senderConfig[_DYN_ALWAYS_USE_XHR_OVERR4 ];
-                    _disableXhr = !!senderConfig.disableXhr;
+                    _disableXhr = !!senderConfig[_DYN_DISABLE_XHR ];
                     var bufferOverride = senderConfig[_DYN_BUFFER_OVERRIDE ];
                     var canUseSessionStorage = !!senderConfig[_DYN_ENABLE_SESSION_STORA5 ] &&
                         (!!bufferOverride || utlCanUseSessionStorage());
@@ -5760,13 +6171,21 @@ var Sender = /** @class */ (function (_super) {
                     else {
                         _customHeaders = null;
                     }
-                    _enableSendPromise = senderConfig.enableSendPromise;
+                    _enableSendPromise = senderConfig[_DYN_ENABLE_SEND_PROMISE ];
+                    var sendPostConfig = _getSendPostMgrConfig();
+                    if (!_sendPostMgr) {
+                        _sendPostMgr = new SenderPostManager();
+                        _sendPostMgr[_DYN_INITIALIZE ](sendPostConfig, diagLog);
+                    }
+                    else {
+                        _sendPostMgr.SetConfig(sendPostConfig);
+                    }
                     var customInterface = senderConfig.httpXHROverride;
                     var httpInterface = null;
                     var syncInterface = null;
-                    var theTransports = _prependTransports([3 , 1 , 2 ], senderConfig.transports);
-                    httpInterface = _getSenderInterface(theTransports, false);
-                    var xhrInterface = { sendPOST: _xhrSender };
+                    var theTransports = prependTransports([3 , 1 , 2 ], senderConfig.transports);
+                    httpInterface = _sendPostMgr && _sendPostMgr[_DYN_GET_XHR_INST ](theTransports, false);
+                    var xhrInterface = _sendPostMgr && _sendPostMgr.getFallbackInst();
                     _xhrSend = function (payload, isAsync) {
                         return _doSend(xhrInterface, payload, isAsync);
                     };
@@ -5780,11 +6199,11 @@ var Sender = /** @class */ (function (_super) {
                     if (_fetchKeepAlive) {
                         _syncUnloadSender = _fetchKeepAliveSender;
                     }
-                    var syncTransports = _prependTransports([3 , 1 ], senderConfig[_DYN_UNLOAD_TRANSPORTS ]);
+                    var syncTransports = prependTransports([3 , 1 ], senderConfig[_DYN_UNLOAD_TRANSPORTS ]);
                     if (!_fetchKeepAlive) {
                         syncTransports = syncTransports.filter(function (transport) { return transport !== 2 ; });
                     }
-                    syncInterface = _getSenderInterface(syncTransports, true);
+                    syncInterface = _sendPostMgr && _sendPostMgr[_DYN_GET_XHR_INST ](syncTransports, true);
                     syncInterface = _alwaysUseCustomSend ? customInterface : (syncInterface || customInterface);
                     if ((_alwaysUseCustomSend || senderConfig[_DYN_UNLOAD_TRANSPORTS ] || !_syncUnloadSender) && syncInterface) {
                         _syncUnloadSender = function (payload, isAsync) {
@@ -5826,10 +6245,8 @@ var Sender = /** @class */ (function (_super) {
             _self.isCompletelyIdle = function () {
                 return !_paused && _syncFetchPayload === 0 && _self._buffer[_DYN_COUNT ]() === 0;
             };
-            _self[_DYN__XHR_READY_STATE_CHA8 ] = function (xhr, payload, countOfItemsInPayload) {
-                if (xhr.readyState === 4) {
-                    _checkResponsStatus(xhr.status, payload, xhr.responseURL, countOfItemsInPayload, _formatErrorMessageXhr(xhr), _getResponseText(xhr) || xhr.response);
-                }
+            _self._xhrReadyStateChange = function (xhr, payload, countOfItemsInPayload) {
+                return _xhrReadyStateChange(xhr, payload, countOfItemsInPayload);
             };
             _self[_DYN_TRIGGER_SEND ] = function (async, forcedSender, sendReason) {
                 if (async === void 0) { async = true; }
@@ -5905,7 +6322,7 @@ var Sender = /** @class */ (function (_super) {
                     _self[_DYN__ON_SUCCESS ](payload, results[_DYN_ITEMS_ACCEPTED ]);
                 }
                 if (failed[_DYN_LENGTH ] > 0) {
-                    _self[_DYN__ON_ERROR ](failed, _formatErrorMessageXhr(null, ["partial success", results[_DYN_ITEMS_ACCEPTED ], "of", results.itemsReceived].join(" ")));
+                    _self[_DYN__ON_ERROR ](failed, formatErrorMessageXhr(null, ["partial success", results[_DYN_ITEMS_ACCEPTED ], "of", results.itemsReceived].join(" ")));
                 }
                 if (retry[_DYN_LENGTH ] > 0) {
                     _resendPayload(retry);
@@ -5918,22 +6335,89 @@ var Sender = /** @class */ (function (_super) {
                 _self._buffer && _self._buffer[_DYN_CLEAR_SENT ](payload);
             };
             _self._xdrOnLoad = function (xdr, payload) {
+                return _xdrOnLoad(xdr, payload);
+            };
+            function _xdrOnLoad(xdr, payload) {
                 var responseText = _getResponseText(xdr);
                 if (xdr && (responseText + "" === "200" || responseText === "")) {
                     _consecutiveErrors = 0;
                     _self[_DYN__ON_SUCCESS ](payload, 0);
                 }
                 else {
-                    var results = _parseResponse(responseText);
+                    var results = parseResponse(responseText);
                     if (results && results.itemsReceived && results.itemsReceived > results[_DYN_ITEMS_ACCEPTED ]
                         && !_isRetryDisabled) {
                         _self[_DYN__ON_PARTIAL_SUCCESS ](payload, results);
                     }
                     else {
-                        _self[_DYN__ON_ERROR ](payload, _formatErrorMessageXdr(xdr));
+                        _self[_DYN__ON_ERROR ](payload, formatErrorMessageXdr(xdr));
                     }
                 }
-            };
+            }
+            function _getSendPostMgrConfig() {
+                var _a;
+                try {
+                    var onCompleteFuncs = {
+                        xdrOnComplete: function (xdr, oncomplete, payload) {
+                            var data = _getPayloadArr(payload);
+                            if (!data) {
+                                return;
+                            }
+                            return _xdrOnLoad(xdr, data);
+                        },
+                        fetchOnComplete: function (response, onComplete, resValue, payload) {
+                            var data = _getPayloadArr(payload);
+                            if (!data) {
+                                return;
+                            }
+                            return _checkResponsStatus(response.status, data, response.url, data[_DYN_LENGTH ], response.statusText, resValue || "");
+                        },
+                        xhrOnComplete: function (request, oncomplete, payload) {
+                            var data = _getPayloadArr(payload);
+                            if (!data) {
+                                return;
+                            }
+                            return _xhrReadyStateChange(request, data, data[_DYN_LENGTH ]);
+                        },
+                        beaconOnRetry: function (data, onComplete, canSend) {
+                            return _onBeaconRetry(data, onComplete, canSend);
+                        }
+                    };
+                    var config = (_a = {},
+                        _a[_DYN_ENABLE_SEND_PROMISE ] = _enableSendPromise,
+                        _a.isOneDs = false,
+                        _a.disableCredentials = false,
+                        _a[_DYN_DISABLE_XHR ] = _disableXhr,
+                        _a.disableBeacon = !_beaconNormalSupported,
+                        _a.disableBeaconSync = !_beaconOnUnloadSupported,
+                        _a.senderOnCompleteCallBack = onCompleteFuncs,
+                        _a);
+                    return config;
+                }
+                catch (e) {
+                }
+                return null;
+            }
+            function _xhrReadyStateChange(xhr, payload, countOfItemsInPayload) {
+                if (xhr.readyState === 4) {
+                    _checkResponsStatus(xhr.status, payload, xhr.responseURL, countOfItemsInPayload, formatErrorMessageXhr(xhr), _getResponseText(xhr) || xhr.response);
+                }
+            }
+            function _getPayloadArr(payload) {
+                try {
+                    if (payload) {
+                        var internalPayload = payload;
+                        var arr = internalPayload[_DYN_ORI_PAYLOAD ];
+                        if (arr && arr[_DYN_LENGTH ]) {
+                            return arr;
+                        }
+                        return null;
+                    }
+                }
+                catch (e) {
+                }
+                return null;
+            }
             function _validate(telemetryItem, diagLogger) {
                 if (_disableTelemetry) {
                     return false;
@@ -6029,36 +6513,6 @@ var Sender = /** @class */ (function (_super) {
             function _isSampledIn(envelope) {
                 return _self._sample.isSampledIn(envelope);
             }
-            function _getSenderInterface(transports, syncSupport) {
-                var _a;
-                var transportType = null;
-                var sendPostFunc = null;
-                var lp = 0;
-                while (sendPostFunc == null && lp < transports[_DYN_LENGTH ]) {
-                    transportType = transports[lp];
-                    if (!_disableXhr && transportType === 1 ) {
-                        if (useXDomainRequest()) {
-                            sendPostFunc = _xdrSender;
-                        }
-                        else if (isXhrSupported()) {
-                            sendPostFunc = _xhrSender;
-                        }
-                    }
-                    else if (transportType === 2  && isFetchSupported(syncSupport)) {
-                        sendPostFunc = _fetchSender;
-                    }
-                    else if (transportType === 3  && (syncSupport ? _beaconOnUnloadSupported : _beaconNormalSupported)) {
-                        sendPostFunc = _beaconSender;
-                    }
-                    lp++;
-                }
-                if (sendPostFunc) {
-                    return _a = {},
-                        _a[_DYN_SEND_POST ] = sendPostFunc,
-                        _a;
-                }
-                return null;
-            }
             function _getOnComplete(payload, status, headers, response) {
                 if (status === 200 && payload) {
                     _self._onSuccess(payload, payload[_DYN_LENGTH ]);
@@ -6073,7 +6527,7 @@ var Sender = /** @class */ (function (_super) {
                     return _getOnComplete(payload, status, headers, response);
                 };
                 var payloadData = _getPayload(payload);
-                var sendPostFunc = sendInterface && sendInterface[_DYN_SEND_POST ];
+                var sendPostFunc = sendInterface && sendInterface.sendPOST;
                 if (sendPostFunc && payloadData) {
                     if (markAsSent) {
                         _self._buffer[_DYN_MARK_AS_SENT ](payload);
@@ -6085,7 +6539,7 @@ var Sender = /** @class */ (function (_super) {
             function _getPayload(payload) {
                 var _a;
                 if (isArray(payload) && payload[_DYN_LENGTH ] > 0) {
-                    var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
+                    var batch = _self[_DYN__BUFFER ].batchPayloads(payload);
                     var payloadData = (_a = {},
                         _a[_DYN_DATA ] = batch,
                         _a.urlString = _endpointUrl,
@@ -6098,9 +6552,6 @@ var Sender = /** @class */ (function (_super) {
                 }
                 return null;
             }
-            function _fetchSender(payload, oncomplete, sync) {
-                return _doFetchSender(payload, oncomplete, false);
-            }
             function _checkMaxSize(incomingPayload) {
                 var incomingSize = incomingPayload ? incomingPayload[_DYN_LENGTH ] : 0;
                 if ((_self[_DYN__BUFFER ].size() + incomingSize) > _maxBatchSizeInBytes) {
@@ -6114,7 +6565,7 @@ var Sender = /** @class */ (function (_super) {
             function _checkResponsStatus(status, payload, responseUrl, countOfItemsInPayload, errorMessage, res) {
                 var response = null;
                 if (!_self._appId) {
-                    response = _parseResponse(res);
+                    response = parseResponse(res);
                     if (response && response.appId) {
                         _self._appId = response.appId;
                     }
@@ -6146,7 +6597,7 @@ var Sender = /** @class */ (function (_super) {
                     _checkAndUpdateEndPointUrl(responseUrl);
                     if (status === 206) {
                         if (!response) {
-                            response = _parseResponse(res);
+                            response = parseResponse(res);
                         }
                         if (response && !_isRetryDisabled) {
                             _self[_DYN__ON_PARTIAL_SUCCESS ](payload, response);
@@ -6174,223 +6625,61 @@ var Sender = /** @class */ (function (_super) {
                 }
                 return false;
             }
-            function _doOnComplete(oncomplete, status, headers, response) {
-                try {
-                    oncomplete(status, headers, response);
-                }
-                catch (e) {
-                }
-            }
             function _doUnloadSend(payload, isAsync) {
                 if (_syncUnloadSender) {
                     _syncUnloadSender(payload, false);
                 }
                 else {
-                    var payloadData = _getPayload(payload);
-                    _self._buffer[_DYN_MARK_AS_SENT ](payload);
-                    _beaconSender(payloadData);
+                    var beaconInst = _sendPostMgr && _sendPostMgr[_DYN_GET_XHR_INST ]([3 ], true);
+                    return _doSend(beaconInst, payload, isAsync);
                 }
             }
-            function _doBeaconSend(payload, oncomplete) {
-                var nav = getNavigator();
-                var url = _endpointUrl;
-                var buffer = _self[_DYN__BUFFER ];
-                var batch = buffer[_DYN_BATCH_PAYLOADS ](payload);
-                var plainTextBatch = new Blob([batch], { type: "text/plain;charset=UTF-8" });
-                var queued = nav.sendBeacon(url, plainTextBatch);
-                if (queued) {
-                    _self._onSuccess(payload, payload[_DYN_LENGTH ]);
-                }
-                return queued;
-            }
-            function _beaconSender(payload, oncomplete, sync) {
+            function _onBeaconRetry(payload, onComplete, canSend) {
                 var internalPayload = payload;
                 var data = internalPayload && internalPayload[_DYN_ORI_PAYLOAD ];
-                if (isArray(data) && data[_DYN_LENGTH ] > 0) {
-                    if (!_doBeaconSend(data)) {
-                        if (!_disableBeaconSplit) {
-                            var droppedPayload = [];
-                            for (var lp = 0; lp < data[_DYN_LENGTH ]; lp++) {
-                                var thePayload = data[lp];
-                                if (!_doBeaconSend([thePayload])) {
-                                    droppedPayload[_DYN_PUSH ](thePayload);
-                                }
-                            }
-                            if (droppedPayload[_DYN_LENGTH ] > 0) {
-                                _fallbackSend && _fallbackSend(droppedPayload, true);
-                                _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
-                            }
+                if (!_disableBeaconSplit) {
+                    var droppedPayload = [];
+                    for (var lp = 0; lp < data[_DYN_LENGTH ]; lp++) {
+                        var thePayload = data[lp];
+                        var arr = [thePayload];
+                        var item = _getPayload(arr);
+                        if (!canSend(item, onComplete)) {
+                            droppedPayload[_DYN_PUSH ](thePayload);
                         }
                         else {
-                            _fallbackSend && _fallbackSend(data, true);
-                            _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                            _self._onSuccess(arr, arr[_DYN_LENGTH ]);
                         }
                     }
-                }
-            }
-            function _xhrSender(payload, oncomplete, sync) {
-                var internalPayload = payload;
-                var thePromise;
-                var resolveFunc;
-                var rejectFunc;
-                var xhr = new XMLHttpRequest();
-                var endPointUrl = _endpointUrl;
-                try {
-                    xhr[DisabledPropertyName] = true;
-                }
-                catch (e) {
-                }
-                xhr.open("POST", endPointUrl, !sync);
-                xhr[_DYN_SET_REQUEST_HEADER ]("Content-type", "application/json");
-                if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
-                    xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[6 ], RequestHeaders[7 ]);
-                }
-                arrForEach(objKeys(_headers), function (headerName) {
-                    xhr[_DYN_SET_REQUEST_HEADER ](headerName, _headers[headerName]);
-                });
-                xhr.onreadystatechange = function () {
-                    var oriPayload = internalPayload[_DYN_ORI_PAYLOAD ];
-                    _self._xhrReadyStateChange(xhr, oriPayload, oriPayload[_DYN_LENGTH ]);
-                    if (xhr.readyState === 4) {
-                        resolveFunc && resolveFunc(true);
+                    if (droppedPayload[_DYN_LENGTH ] > 0) {
+                        _fallbackSend && _fallbackSend(droppedPayload, true);
+                        _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
                     }
-                };
-                xhr.onerror = function (event) {
-                    _doOnComplete(oncomplete, 400, {}, _formatErrorMessageXhr(xhr));
-                    rejectFunc && rejectFunc(event);
-                };
-                if (!sync && _enableSendPromise) {
-                    thePromise = createPromise(function (resolve, reject) {
-                        resolveFunc = resolve;
-                        rejectFunc = reject;
-                    });
                 }
-                xhr.send(payload[_DYN_DATA ]);
-                return thePromise;
+                else {
+                    _fallbackSend && _fallbackSend(data, true);
+                    _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                }
             }
             function _fetchKeepAliveSender(payload, isAsync) {
-                var onComplete = function (status, headers, response) {
-                    return _getOnComplete(payload, status, headers, response);
-                };
+                var transport = null;
                 if (isArray(payload)) {
                     var payloadSize = payload[_DYN_LENGTH ];
                     for (var lp = 0; lp < payload[_DYN_LENGTH ]; lp++) {
                         payloadSize += payload[lp][_DYN_LENGTH ];
                     }
-                    var payloadData = _getPayload(payload);
-                    _self._buffer[_DYN_MARK_AS_SENT ](payload);
-                    if ((_syncFetchPayload + payloadSize) <= FetchSyncRequestSizeLimitBytes) {
-                        _doFetchSender(payloadData, onComplete, true);
+                    var syncFetchPayload = _sendPostMgr.getSyncFetchPayload();
+                    if ((syncFetchPayload + payloadSize) <= FetchSyncRequestSizeLimitBytes) {
+                        transport = 2 ;
                     }
                     else if (isBeaconsSupported()) {
-                        _beaconSender(payloadData);
+                        transport = 3 ;
                     }
                     else {
-                        _fallbackSend && _fallbackSend(payload, true);
+                        transport = 1 ;
                         _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with xhrSender.");
                     }
-                }
-            }
-            function _doFetchSender(payload, oncomplete, sync) {
-                var _a;
-                var endPointUrl = _endpointUrl;
-                var internalPayload = payload;
-                var batch = internalPayload[_DYN_DATA ];
-                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;
-                var responseHandled = false;
-                if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
-                    requestHeaders.append(RequestHeaders[6 ], RequestHeaders[7 ]);
-                }
-                arrForEach(objKeys(_headers), function (headerName) {
-                    requestHeaders.append(headerName, _headers[headerName]);
-                });
-                var init = (_a = {
-                        method: "POST",
-                        headers: requestHeaders,
-                        body: plainTextBatch
-                    },
-                    _a[DisabledPropertyName] = true
-                ,
-                    _a);
-                if (sync) {
-                    init.keepalive = true;
-                    ignoreResponse = true;
-                    _syncFetchPayload += batchLength;
-                }
-                var request = new Request(endPointUrl, init);
-                try {
-                    request[DisabledPropertyName] = true;
-                }
-                catch (e) {
-                }
-                if (!sync && _enableSendPromise) {
-                    thePromise = createPromise(function (resolve, reject) {
-                        resolveFunc = resolve;
-                        rejectFunc = reject;
-                    });
-                }
-                try {
-                    doAwaitResponse(fetch(request), function (result) {
-                        if (sync) {
-                            _syncFetchPayload -= batchLength;
-                            batchLength = 0;
-                        }
-                        if (!responseHandled) {
-                            responseHandled = true;
-                            if (!result.rejected) {
-                                var response_1 = result.value;
-                                if (!response_1.ok) {
-                                    _doOnComplete(oncomplete, 400, {}, response_1.statusText);
-                                    resolveFunc && resolveFunc(false);
-                                }
-                                else {
-                                    doAwaitResponse(response_1.text(), function (resp) {
-                                        var oriPayload = internalPayload[_DYN_ORI_PAYLOAD ];
-                                        _checkResponsStatus(response_1.status, oriPayload, response_1.url, oriPayload[_DYN_LENGTH ], response_1.statusText, resp.value || "");
-                                        resolveFunc && resolveFunc(true);
-                                    });
-                                }
-                            }
-                            else {
-                                _doOnComplete(oncomplete, 400, {}, result.reason && result.reason.message);
-                                rejectFunc && rejectFunc(result.reason);
-                            }
-                        }
-                    });
-                }
-                catch (e) {
-                    if (!responseHandled) {
-                        _doOnComplete(oncomplete, 400, {}, dumpObj(e));
-                        rejectFunc && rejectFunc(e);
-                    }
-                }
-                if (ignoreResponse && !responseHandled) {
-                    responseHandled = true;
-                    _doOnComplete(oncomplete, 200, {});
-                    resolveFunc && resolveFunc(true);
-                }
-                return thePromise;
-            }
-            function _parseResponse(response) {
-                try {
-                    if (response && response !== "") {
-                        var result = getJSON().parse(response);
-                        if (result && result.itemsReceived && result.itemsReceived >= result[_DYN_ITEMS_ACCEPTED ] &&
-                            result.itemsReceived - result.itemsAccepted === result.errors[_DYN_LENGTH ]) {
-                            return result;
-                        }
-                    }
-                }
-                catch (e) {
-                    _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 43 , "Cannot parse the response. " + getExceptionName(e), {
-                        response: response
-                    });
+                    var inst = _sendPostMgr && _sendPostMgr[_DYN_GET_XHR_INST ]([transport], true);
+                    return _doSend(inst, payload, isAsync);
                 }
                 return null;
             }
@@ -6449,41 +6738,6 @@ var Sender = /** @class */ (function (_super) {
                     || statusCode === 503
                     || statusCode === 504;
             }
-            function _formatErrorMessageXhr(xhr, message) {
-                if (xhr) {
-                    return "XMLHttpRequest,Status:" + xhr.status + ",Response:" + _getResponseText(xhr) || xhr.response || "";
-                }
-                return message;
-            }
-            function _xdrSender(payload, oncomplete, sync) {
-                var internalPayload = payload;
-                var _window = getWindow();
-                var xdr = new XDomainRequest();
-                var data = internalPayload[_DYN_DATA ];
-                xdr.onload = function () {
-                    var oriPayload = internalPayload[_DYN_ORI_PAYLOAD ];
-                    _self._xdrOnLoad(xdr, oriPayload);
-                };
-                xdr.onerror = function () {
-                    _doOnComplete(oncomplete, 400, {}, _formatErrorMessageXdr(xdr));
-                };
-                var hostingProtocol = _window && _window.location && _window.location.protocol || "";
-                if (_endpointUrl.lastIndexOf(hostingProtocol, 0) !== 0) {
-                    _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " +
-                        "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.");
-                    _self._buffer[_DYN_CLEAR ]();
-                    return;
-                }
-                var endpointUrl = _endpointUrl.replace(/^(https?:)/, "");
-                xdr.open("POST", endpointUrl);
-                xdr.send(data);
-            }
-            function _formatErrorMessageXdr(xdr, message) {
-                if (xdr) {
-                    return "XDomainRequest,Response:" + _getResponseText(xdr) || "";
-                }
-                return message;
-            }
             function _getNotifyMgr() {
                 var func = "getNotifyMgr";
                 if (_self.core[func]) {
@@ -6544,6 +6798,7 @@ var Sender = /** @class */ (function (_super) {
                 _disableBeaconSplit = false;
                 _xhrSend = null;
                 _fallbackSend = null;
+                _sendPostMgr = null;
                 objDefine(_self, "_senderConfig", {
                     g: function () {
                         return objExtend({}, defaultAppInsightsChannelConfig);