@microsoft/1ds-post-js 4.1.1-nightly3.2403-03 → 4.1.1

package/bundle/es5/ms.post.js

@@ -1,5 +1,5 @@
 /*!
- * 1DS JS SDK POST plugin, 4.1.1-nightly3.2403-03
+ * 1DS JS SDK POST plugin, 4.1.1
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -8,8 +8,8 @@
     typeof exports === "object" && typeof module !== undef ? factory(exports) :
     typeof define === "function" && define.amd ? define(["exports"], factory) :
     (function(global){
-        var nsKey, key, nm, theExports = {}, modName = "es5_ms_post_4_1_1_nightly3_2403_03", msMod="__ms$mod__";
-        var mods={}, modDetail=mods[modName]={}, ver="4.1.1-nightly3.2403-03";
+        var nsKey, key, nm, theExports = {}, modName = "es5_ms_post_4_1_1", msMod="__ms$mod__";
+        var mods={}, modDetail=mods[modName]={}, ver="4.1.1";
         // Versioned namespace "oneDS4"
         var exportNs=global, nsKey="oneDS4", exportNs=exportNs[nsKey]=(exportNs[nsKey]||{});
         // Global namespace "oneDS"
@@ -1155,6 +1155,7 @@ var _DYN__DO_TEARDOWN = "_doTeardown";
 var _DYN_UPDATE = "update";
 var _DYN_GET_NEXT = "getNext";
 var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
+var _DYN_PROTOCOL = "protocol";
 var _DYN_USER_AGENT = "userAgent";
 var _DYN_SPLIT$1 = "split";
 var _DYN_NODE_TYPE = "nodeType";
@@ -1162,10 +1163,19 @@ var _DYN_REPLACE = "replace";
 var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
 var _DYN_TYPE = "type";
 var _DYN_HANDLER = "handler";
+var _DYN_STATUS = "status";
+var _DYN_GET_RESPONSE_HEADER = "getResponseHeader";
+var _DYN_GET_ALL_RESPONSE_HEA5 = "getAllResponseHeaders";
 var _DYN_IS_CHILD_EVT = "isChildEvt";
+var _DYN_DATA$1 = "data";
 var _DYN_GET_CTX = "getCtx";
 var _DYN_SET_CTX = "setCtx";
 var _DYN_COMPLETE = "complete";
+var _DYN_URL_STRING$1 = "urlString";
+var _DYN_SEND_POST = "sendPOST";
+var _DYN_HEADERS$1 = "headers";
+var _DYN_TIMEOUT = "timeout";
+var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
 
 var aggregationErrorType;
 function throwAggregationError(message, sourceErrors) {
@@ -1183,6 +1193,60 @@ function throwAggregationError(message, sourceErrors) {
     throw new aggregationErrorType(theMessage, sourceErrors || []);
 }
 
+function doAwaitResponse(value, cb) {
+    return doAwait(value, function (value) {
+        return cb ? cb({
+            value: value,
+            rejected: false
+        }) : value;
+    }, function (reason) {
+        return cb ? cb({
+            rejected: true,
+            reason: reason
+        }) : reason;
+    });
+}
+function doAwait(value, resolveFn, rejectFn, finallyFn) {
+    var result = value;
+    if (isPromiseLike(value)) {
+        if (resolveFn || rejectFn) {
+            result = value.then(resolveFn, rejectFn);
+        }
+    }
+    else {
+        if (resolveFn) {
+            result = resolveFn(value);
+        }
+    }
+    if (finallyFn) {
+        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 STRING_STATES = [
     "pending", "resolving", "resolved", "rejected"
 ];
@@ -1430,7 +1494,7 @@ function createPromise(executor, timeout) {
 }
 
 var UNDEFINED_VALUE = undefined;
-var STR_EMPTY$2 = "";
+var STR_EMPTY$3 = "";
 var STR_CORE = "core";
 var STR_DISABLED = "disabled";
 var STR_EXTENSION_CONFIG = "extensionConfig";
@@ -1439,72 +1503,20 @@ var STR_PRIORITY = "priority";
 var STR_GET_PERF_MGR = "getPerfMgr";
 var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
 
-var rCamelCase = /-([a-z])/g;
-var rNormalizeInvalid = /([^\w\d_$])/g;
-var rLeadingNumeric = /^(\d+[\w\d_$])/;
-function isNotNullOrUndefined(value) {
-    return !isNullOrUndefined(value);
-}
-function normalizeJsName(name) {
-    var value = name;
-    if (value && isString(value)) {
-        value = value[_DYN_REPLACE ](rCamelCase, function (_all, letter) {
-            return letter.toUpperCase();
-        });
-        value = value[_DYN_REPLACE ](rNormalizeInvalid, "_");
-        value = value[_DYN_REPLACE ](rLeadingNumeric, function (_all, match) {
-            return "_" + match;
-        });
-    }
-    return value;
-}
-function strContains(value, search) {
-    if (value && search) {
-        return strIndexOf(value, search) !== -1;
-    }
-    return false;
-}
-function _createProxyFunction(source, funcName) {
-    var srcFunc = null;
-    var src = null;
-    if (isFunction(source)) {
-        srcFunc = source;
-    }
-    else {
-        src = source;
-    }
-    return function () {
-        var originalArguments = arguments;
-        if (srcFunc) {
-            src = srcFunc();
-        }
-        if (src) {
-            return src[funcName][_DYN_APPLY ](src, originalArguments);
-        }
-    };
-}
-function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
-    if (target && name && source) {
-        if (overwriteTarget !== false || isUndefined(target[name])) {
-            target[name] = _createProxyFunction(source, theFunc);
-        }
-    }
-}
-function proxyFunctions(target, source, functionsToProxy, overwriteTarget) {
-    if (target && source && isObject(target) && isArray(functionsToProxy)) {
-        arrForEach(functionsToProxy, function (theFuncName) {
-            if (isString(theFuncName)) {
-                proxyFunctionAs(target, theFuncName, source, theFuncName, overwriteTarget);
-            }
-        });
+var _aiNamespace = null;
+function _getExtensionNamespace() {
+    var target = getInst("Microsoft");
+    if (target) {
+        _aiNamespace = target["ApplicationInsights"];
     }
-    return target;
+    return _aiNamespace;
 }
-function optimizeObject(theObject) {
-    if (theObject && objAssign) {
-        theObject = ObjClass$1(objAssign({}, theObject));
+function getDebugExt(config) {
+    var ns = _aiNamespace;
+    if (!ns && config.disableDbgExt !== true) {
+        ns = _aiNamespace || _getExtensionNamespace();
     }
-    return theObject;
+    return ns ? ns["ChromeDbgExt"] : null;
 }
 
 var strLocation = "location";
@@ -1584,54 +1596,413 @@ function isReactNative() {
     if (nav && nav.product) {
         return nav.product === strReactNative;
     }
-    return false;
-}
-function isIE() {
-    var nav = getNavigator();
-    if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
-        _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-        var userAgent = (_navUserAgentCheck || STR_EMPTY$2)[_DYN_TO_LOWER_CASE$1 ]();
-        _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
+    return false;
+}
+function isIE() {
+    var nav = getNavigator();
+    if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
+        _navUserAgentCheck = nav[_DYN_USER_AGENT ];
+        var userAgent = (_navUserAgentCheck || STR_EMPTY$3)[_DYN_TO_LOWER_CASE$1 ]();
+        _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
+    }
+    return _isTrident;
+}
+function isBeaconsSupported(useCached) {
+    if (_beaconsSupported === null || useCached === false) {
+        _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
+    }
+    return _beaconsSupported;
+}
+function isFetchSupported(withKeepAlive) {
+    var isSupported = false;
+    try {
+        isSupported = !!getInst("fetch");
+        var request = getInst("Request");
+        if (isSupported && withKeepAlive && request) {
+            isSupported = _hasProperty(request, "keepalive");
+        }
+    }
+    catch (e) {
+    }
+    return isSupported;
+}
+function useXDomainRequest() {
+    if (_useXDomainRequest === null) {
+        _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
+        if (_useXDomainRequest && isXhrSupported()) {
+            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getInst(strXMLHttpRequest), "withCredentials");
+        }
+    }
+    return _useXDomainRequest;
+}
+function isXhrSupported() {
+    var isSupported = false;
+    try {
+        var xmlHttpRequest = getInst(strXMLHttpRequest);
+        isSupported = !!xmlHttpRequest;
+    }
+    catch (e) {
+    }
+    return isSupported;
+}
+
+var _a$3;
+var STR_WARN_TO_CONSOLE = "warnToConsole";
+var AiNonUserActionablePrefix = "AI (Internal): ";
+var AiUserActionablePrefix = "AI: ";
+var AIInternalMessagePrefix = "AITR_";
+var defaultValues$1 = {
+    loggingLevelConsole: 0,
+    loggingLevelTelemetry: 1,
+    maxMessageLimit: 25,
+    enableDebug: false
+};
+var _logFuncs = (_a$3 = {},
+    _a$3[0 ] = null,
+    _a$3[1 ] = "errorToConsole",
+    _a$3[2 ] = STR_WARN_TO_CONSOLE,
+    _a$3[3 ] = "debugToConsole",
+    _a$3);
+function _sanitizeDiagnosticText(text) {
+    if (text) {
+        return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY$3) + "\"";
+    }
+    return STR_EMPTY$3;
+}
+function _logToConsole(func, message) {
+    var theConsole = getConsole();
+    if (!!theConsole) {
+        var logFunc = "log";
+        if (theConsole[func]) {
+            logFunc = func;
+        }
+        if (isFunction(theConsole[logFunc])) {
+            theConsole[logFunc](message);
+        }
+    }
+}
+var _InternalLogMessage = /** @class */ (function () {
+    function _InternalLogMessage(msgId, msg, isUserAct, properties) {
+        if (isUserAct === void 0) { isUserAct = false; }
+        var _self = this;
+        _self[_DYN_MESSAGE_ID ] = msgId;
+        _self[_DYN_MESSAGE ] =
+            (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
+                msgId;
+        var strProps = STR_EMPTY$3;
+        if (hasJSON()) {
+            strProps = getJSON().stringify(properties);
+        }
+        var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$3) +
+            (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$3);
+        _self[_DYN_MESSAGE ] += diagnosticText;
+    }
+    _InternalLogMessage.dataType = "MessageData";
+    return _InternalLogMessage;
+}());
+function safeGetLogger(core, config) {
+    return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
+}
+var DiagnosticLogger = /** @class */ (function () {
+    function DiagnosticLogger(config) {
+        this.identifier = "DiagnosticLogger";
+        this.queue = [];
+        var _messageCount = 0;
+        var _messageLogged = {};
+        var _loggingLevelConsole;
+        var _loggingLevelTelemetry;
+        var _maxInternalMessageLimit;
+        var _enableDebug;
+        var _unloadHandler;
+        dynamicProto(DiagnosticLogger, this, function (_self) {
+            _unloadHandler = _setDefaultsFromConfig(config || {});
+            _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
+            _self[_DYN_THROW_INTERNAL ] = function (severity, msgId, msg, properties, isUserAct) {
+                if (isUserAct === void 0) { isUserAct = false; }
+                var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
+                if (_enableDebug) {
+                    throw dumpObj(message);
+                }
+                else {
+                    var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;
+                    if (!isUndefined(message[_DYN_MESSAGE ])) {
+                        if (isUserAct) {
+                            var messageKey = +message[_DYN_MESSAGE_ID ];
+                            if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
+                                _self[logFunc](message[_DYN_MESSAGE ]);
+                                _messageLogged[messageKey] = true;
+                            }
+                        }
+                        else {
+                            if (_loggingLevelConsole >= severity) {
+                                _self[logFunc](message[_DYN_MESSAGE ]);
+                            }
+                        }
+                        _logInternalMessage(severity, message);
+                    }
+                    else {
+                        _debugExtMsg("throw" + (severity === 1  ? "Critical" : "Warning"), message);
+                    }
+                }
+            };
+            _self.debugToConsole = function (message) {
+                _logToConsole("debug", message);
+                _debugExtMsg("warning", message);
+            };
+            _self[_DYN_WARN_TO_CONSOLE ] = function (message) {
+                _logToConsole("warn", message);
+                _debugExtMsg("warning", message);
+            };
+            _self.errorToConsole = function (message) {
+                _logToConsole("error", message);
+                _debugExtMsg("error", message);
+            };
+            _self.resetInternalMessageCount = function () {
+                _messageCount = 0;
+                _messageLogged = {};
+            };
+            _self[_DYN_LOG_INTERNAL_MESSAGE ] = _logInternalMessage;
+            _self[_DYN_UNLOAD ] = function (isAsync) {
+                _unloadHandler && _unloadHandler.rm();
+                _unloadHandler = null;
+            };
+            function _logInternalMessage(severity, message) {
+                if (_areInternalMessagesThrottled()) {
+                    return;
+                }
+                var logMessage = true;
+                var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID ];
+                if (_messageLogged[messageKey]) {
+                    logMessage = false;
+                }
+                else {
+                    _messageLogged[messageKey] = true;
+                }
+                if (logMessage) {
+                    if (severity <= _loggingLevelTelemetry) {
+                        _self.queue[_DYN_PUSH$1 ](message);
+                        _messageCount++;
+                        _debugExtMsg((severity === 1  ? "error" : "warn"), message);
+                    }
+                    if (_messageCount === _maxInternalMessageLimit) {
+                        var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
+                        var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
+                        _self.queue[_DYN_PUSH$1 ](throttleMessage);
+                        if (severity === 1 ) {
+                            _self.errorToConsole(throttleLimitMessage);
+                        }
+                        else {
+                            _self[_DYN_WARN_TO_CONSOLE ](throttleLimitMessage);
+                        }
+                    }
+                }
+            }
+            function _setDefaultsFromConfig(config) {
+                return onConfigChange(createDynamicConfig(config, defaultValues$1, _self).cfg, function (details) {
+                    var config = details.cfg;
+                    _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
+                    _loggingLevelTelemetry = config.loggingLevelTelemetry;
+                    _maxInternalMessageLimit = config.maxMessageLimit;
+                    _enableDebug = config.enableDebug;
+                });
+            }
+            function _areInternalMessagesThrottled() {
+                return _messageCount >= _maxInternalMessageLimit;
+            }
+            function _debugExtMsg(name, data) {
+                var dbgExt = getDebugExt(config || {});
+                if (dbgExt && dbgExt[_DYN_DIAG_LOG ]) {
+                    dbgExt[_DYN_DIAG_LOG ](name, data);
+                }
+            }
+        });
+    }
+    DiagnosticLogger.__ieDyn=1;
+    return DiagnosticLogger;
+}());
+function _getLogger(logger) {
+    return (logger || new DiagnosticLogger());
+}
+function _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {
+    if (isUserAct === void 0) { isUserAct = false; }
+    _getLogger(logger)[_DYN_THROW_INTERNAL ](severity, msgId, msg, properties, isUserAct);
+}
+function _warnToConsole(logger, message) {
+    _getLogger(logger)[_DYN_WARN_TO_CONSOLE ](message);
+}
+
+var rCamelCase = /-([a-z])/g;
+var rNormalizeInvalid = /([^\w\d_$])/g;
+var rLeadingNumeric = /^(\d+[\w\d_$])/;
+function isNotNullOrUndefined(value) {
+    return !isNullOrUndefined(value);
+}
+function normalizeJsName(name) {
+    var value = name;
+    if (value && isString(value)) {
+        value = value[_DYN_REPLACE ](rCamelCase, function (_all, letter) {
+            return letter.toUpperCase();
+        });
+        value = value[_DYN_REPLACE ](rNormalizeInvalid, "_");
+        value = value[_DYN_REPLACE ](rLeadingNumeric, function (_all, match) {
+            return "_" + match;
+        });
+    }
+    return value;
+}
+function strContains(value, search) {
+    if (value && search) {
+        return strIndexOf(value, search) !== -1;
+    }
+    return false;
+}
+function _createProxyFunction(source, funcName) {
+    var srcFunc = null;
+    var src = null;
+    if (isFunction(source)) {
+        srcFunc = source;
+    }
+    else {
+        src = source;
+    }
+    return function () {
+        var originalArguments = arguments;
+        if (srcFunc) {
+            src = srcFunc();
+        }
+        if (src) {
+            return src[funcName][_DYN_APPLY ](src, originalArguments);
+        }
+    };
+}
+function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
+    if (target && name && source) {
+        if (overwriteTarget !== false || isUndefined(target[name])) {
+            target[name] = _createProxyFunction(source, theFunc);
+        }
+    }
+}
+function proxyFunctions(target, source, functionsToProxy, overwriteTarget) {
+    if (target && source && isObject(target) && isArray(functionsToProxy)) {
+        arrForEach(functionsToProxy, function (theFuncName) {
+            if (isString(theFuncName)) {
+                proxyFunctionAs(target, theFuncName, source, theFuncName, overwriteTarget);
+            }
+        });
+    }
+    return target;
+}
+function optimizeObject(theObject) {
+    if (theObject && objAssign) {
+        theObject = ObjClass$1(objAssign({}, theObject));
+    }
+    return theObject;
+}
+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[_DYN_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;
+}
+var strDisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
+var strWithCredentials = "withCredentials";
+var strTimeout = "timeout";
+function openXhr(method, urlString, withCredentials, disabled, isSync, timeout) {
+    if (disabled === void 0) { disabled = false; }
+    if (isSync === void 0) { isSync = false; }
+    function _wrapSetXhrProp(xhr, prop, value) {
+        try {
+            xhr[prop] = value;
+        }
+        catch (e) {
+        }
+    }
+    var xhr = new XMLHttpRequest();
+    if (disabled) {
+        _wrapSetXhrProp(xhr, strDisabledPropertyName, disabled);
+    }
+    if (withCredentials) {
+        _wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
+    }
+    xhr.open(method, urlString, !isSync);
+    if (withCredentials) {
+        _wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
+    }
+    if (!isSync && timeout) {
+        _wrapSetXhrProp(xhr, strTimeout, timeout);
     }
-    return _isTrident;
+    return xhr;
 }
-function isBeaconsSupported(useCached) {
-    if (_beaconsSupported === null || useCached === false) {
-        _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
+function convertAllHeadersToMap(headersString) {
+    var headers = {};
+    if (isString(headersString)) {
+        var headersArray = strTrim(headersString)[_DYN_SPLIT$1 ](/[\r\n]+/);
+        arrForEach(headersArray, function (headerEntry) {
+            if (headerEntry) {
+                var idx = headerEntry.indexOf(": ");
+                if (idx !== -1) {
+                    var header = strTrim(headerEntry.substring(0, idx))[_DYN_TO_LOWER_CASE$1 ]();
+                    var value = strTrim(headerEntry.substring(idx + 1));
+                    headers[header] = value;
+                }
+                else {
+                    headers[strTrim(headerEntry)] = 1;
+                }
+            }
+        });
     }
-    return _beaconsSupported;
+    return headers;
 }
-function isFetchSupported(withKeepAlive) {
-    var isSupported = false;
-    try {
-        isSupported = !!getInst("fetch");
-        var request = getInst("Request");
-        if (isSupported && withKeepAlive && request) {
-            isSupported = _hasProperty(request, "keepalive");
+function _appendHeader(theHeaders, xhr, name) {
+    if (!theHeaders[name] && xhr && xhr[_DYN_GET_RESPONSE_HEADER ]) {
+        var value = xhr[_DYN_GET_RESPONSE_HEADER ](name);
+        if (value) {
+            theHeaders[name] = strTrim(value);
         }
     }
-    catch (e) {
-    }
-    return isSupported;
+    return theHeaders;
 }
-function useXDomainRequest() {
-    if (_useXDomainRequest === null) {
-        _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
-        if (_useXDomainRequest && isXhrSupported()) {
-            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getInst(strXMLHttpRequest), "withCredentials");
+var STR_KILL_DURATION_HEADER$1 = "kill-duration";
+var STR_KILL_DURATION_SECONDS_HEADER = "kill-duration-seconds";
+var STR_TIME_DELTA_HEADER$1 = "time-delta-millis";
+function _getAllResponseHeaders(xhr, isOneDs) {
+    var theHeaders = {};
+    if (!xhr[_DYN_GET_ALL_RESPONSE_HEA5 ]) {
+        if (!!isOneDs) {
+            theHeaders = _appendHeader(theHeaders, xhr, STR_TIME_DELTA_HEADER$1);
+            theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_HEADER$1);
+            theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_SECONDS_HEADER);
         }
     }
-    return _useXDomainRequest;
-}
-function isXhrSupported() {
-    var isSupported = false;
-    try {
-        var xmlHttpRequest = getInst(strXMLHttpRequest);
-        isSupported = !!xmlHttpRequest;
-    }
-    catch (e) {
+    else {
+        theHeaders = convertAllHeadersToMap(xhr[_DYN_GET_ALL_RESPONSE_HEA5 ]());
     }
-    return isSupported;
+    return theHeaders;
 }
 
 var UInt32Mask = 0x100000000;
@@ -1691,7 +2062,7 @@ function newId(maxLength) {
     var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     var number = random32() >>> 0;
     var chars = 0;
-    var result = STR_EMPTY$2;
+    var result = STR_EMPTY$3;
     while (result[_DYN_LENGTH$2 ] < maxLength) {
         chars++;
         result += base64chars.charAt(number & 0x3F);
@@ -1729,11 +2100,11 @@ function _getCache(data, target) {
 }
 function createUniqueNamespace(name, includeVersion) {
     if (includeVersion === void 0) { includeVersion = false; }
-    return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY$2) + instanceName);
+    return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY$3) + instanceName);
 }
 function createElmNodeData(name) {
     var data = {
-        id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$2) + "." + version),
+        id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$3) + "." + version),
         accept: function (target) {
             return _canAcceptData(target);
         },
@@ -2354,226 +2725,27 @@ function _logInvalidAccess(logger, message) {
         logger[_DYN_THROW_INTERNAL ](2 , 108 , message);
     }
     else {
-        throwInvalidAccess(message);
-    }
-}
-function createDynamicConfig(config, defaultConfig, logger, inPlace) {
-    var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
-    if (defaultConfig) {
-        dynamicHandler[_DYN_SET_DF ](dynamicHandler.cfg, defaultConfig);
-    }
-    return dynamicHandler;
-}
-function onConfigChange(config, configHandler, logger) {
-    var handler = config[CFG_HANDLER_LINK] || config;
-    if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
-        return handler[_DYN_WATCH ](configHandler);
-    }
-    _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
-    return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
-}
-
-var _aiNamespace = null;
-function _getExtensionNamespace() {
-    var target = getInst("Microsoft");
-    if (target) {
-        _aiNamespace = target["ApplicationInsights"];
-    }
-    return _aiNamespace;
-}
-function getDebugExt(config) {
-    var ns = _aiNamespace;
-    if (!ns && config.disableDbgExt !== true) {
-        ns = _aiNamespace || _getExtensionNamespace();
-    }
-    return ns ? ns["ChromeDbgExt"] : null;
-}
-
-var _a$3;
-var STR_WARN_TO_CONSOLE = "warnToConsole";
-var AiNonUserActionablePrefix = "AI (Internal): ";
-var AiUserActionablePrefix = "AI: ";
-var AIInternalMessagePrefix = "AITR_";
-var defaultValues$1 = {
-    loggingLevelConsole: 0,
-    loggingLevelTelemetry: 1,
-    maxMessageLimit: 25,
-    enableDebug: false
-};
-var _logFuncs = (_a$3 = {},
-    _a$3[0 ] = null,
-    _a$3[1 ] = "errorToConsole",
-    _a$3[2 ] = STR_WARN_TO_CONSOLE,
-    _a$3[3 ] = "debugToConsole",
-    _a$3);
-function _sanitizeDiagnosticText(text) {
-    if (text) {
-        return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY$2) + "\"";
-    }
-    return STR_EMPTY$2;
-}
-function _logToConsole(func, message) {
-    var theConsole = getConsole();
-    if (!!theConsole) {
-        var logFunc = "log";
-        if (theConsole[func]) {
-            logFunc = func;
-        }
-        if (isFunction(theConsole[logFunc])) {
-            theConsole[logFunc](message);
-        }
-    }
-}
-var _InternalLogMessage = /** @class */ (function () {
-    function _InternalLogMessage(msgId, msg, isUserAct, properties) {
-        if (isUserAct === void 0) { isUserAct = false; }
-        var _self = this;
-        _self[_DYN_MESSAGE_ID ] = msgId;
-        _self[_DYN_MESSAGE ] =
-            (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
-                msgId;
-        var strProps = STR_EMPTY$2;
-        if (hasJSON()) {
-            strProps = getJSON().stringify(properties);
-        }
-        var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$2) +
-            (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$2);
-        _self[_DYN_MESSAGE ] += diagnosticText;
-    }
-    _InternalLogMessage.dataType = "MessageData";
-    return _InternalLogMessage;
-}());
-function safeGetLogger(core, config) {
-    return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
-}
-var DiagnosticLogger = /** @class */ (function () {
-    function DiagnosticLogger(config) {
-        this.identifier = "DiagnosticLogger";
-        this.queue = [];
-        var _messageCount = 0;
-        var _messageLogged = {};
-        var _loggingLevelConsole;
-        var _loggingLevelTelemetry;
-        var _maxInternalMessageLimit;
-        var _enableDebug;
-        var _unloadHandler;
-        dynamicProto(DiagnosticLogger, this, function (_self) {
-            _unloadHandler = _setDefaultsFromConfig(config || {});
-            _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
-            _self[_DYN_THROW_INTERNAL ] = function (severity, msgId, msg, properties, isUserAct) {
-                if (isUserAct === void 0) { isUserAct = false; }
-                var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
-                if (_enableDebug) {
-                    throw dumpObj(message);
-                }
-                else {
-                    var logFunc = _logFuncs[severity] || STR_WARN_TO_CONSOLE;
-                    if (!isUndefined(message[_DYN_MESSAGE ])) {
-                        if (isUserAct) {
-                            var messageKey = +message[_DYN_MESSAGE_ID ];
-                            if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
-                                _self[logFunc](message[_DYN_MESSAGE ]);
-                                _messageLogged[messageKey] = true;
-                            }
-                        }
-                        else {
-                            if (_loggingLevelConsole >= severity) {
-                                _self[logFunc](message[_DYN_MESSAGE ]);
-                            }
-                        }
-                        _logInternalMessage(severity, message);
-                    }
-                    else {
-                        _debugExtMsg("throw" + (severity === 1  ? "Critical" : "Warning"), message);
-                    }
-                }
-            };
-            _self.debugToConsole = function (message) {
-                _logToConsole("debug", message);
-                _debugExtMsg("warning", message);
-            };
-            _self[_DYN_WARN_TO_CONSOLE ] = function (message) {
-                _logToConsole("warn", message);
-                _debugExtMsg("warning", message);
-            };
-            _self.errorToConsole = function (message) {
-                _logToConsole("error", message);
-                _debugExtMsg("error", message);
-            };
-            _self.resetInternalMessageCount = function () {
-                _messageCount = 0;
-                _messageLogged = {};
-            };
-            _self[_DYN_LOG_INTERNAL_MESSAGE ] = _logInternalMessage;
-            _self[_DYN_UNLOAD ] = function (isAsync) {
-                _unloadHandler && _unloadHandler.rm();
-                _unloadHandler = null;
-            };
-            function _logInternalMessage(severity, message) {
-                if (_areInternalMessagesThrottled()) {
-                    return;
-                }
-                var logMessage = true;
-                var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID ];
-                if (_messageLogged[messageKey]) {
-                    logMessage = false;
-                }
-                else {
-                    _messageLogged[messageKey] = true;
-                }
-                if (logMessage) {
-                    if (severity <= _loggingLevelTelemetry) {
-                        _self.queue[_DYN_PUSH$1 ](message);
-                        _messageCount++;
-                        _debugExtMsg((severity === 1  ? "error" : "warn"), message);
-                    }
-                    if (_messageCount === _maxInternalMessageLimit) {
-                        var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
-                        var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
-                        _self.queue[_DYN_PUSH$1 ](throttleMessage);
-                        if (severity === 1 ) {
-                            _self.errorToConsole(throttleLimitMessage);
-                        }
-                        else {
-                            _self[_DYN_WARN_TO_CONSOLE ](throttleLimitMessage);
-                        }
-                    }
-                }
-            }
-            function _setDefaultsFromConfig(config) {
-                return onConfigChange(createDynamicConfig(config, defaultValues$1, _self).cfg, function (details) {
-                    var config = details.cfg;
-                    _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
-                    _loggingLevelTelemetry = config.loggingLevelTelemetry;
-                    _maxInternalMessageLimit = config.maxMessageLimit;
-                    _enableDebug = config.enableDebug;
-                });
-            }
-            function _areInternalMessagesThrottled() {
-                return _messageCount >= _maxInternalMessageLimit;
-            }
-            function _debugExtMsg(name, data) {
-                var dbgExt = getDebugExt(config || {});
-                if (dbgExt && dbgExt[_DYN_DIAG_LOG ]) {
-                    dbgExt[_DYN_DIAG_LOG ](name, data);
-                }
-            }
-        });
-    }
-    DiagnosticLogger.__ieDyn=1;
-    return DiagnosticLogger;
-}());
-function _getLogger(logger) {
-    return (logger || new DiagnosticLogger());
+        throwInvalidAccess(message);
+    }
 }
-function _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {
-    if (isUserAct === void 0) { isUserAct = false; }
-    _getLogger(logger)[_DYN_THROW_INTERNAL ](severity, msgId, msg, properties, isUserAct);
+function createDynamicConfig(config, defaultConfig, logger, inPlace) {
+    var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
+    if (defaultConfig) {
+        dynamicHandler[_DYN_SET_DF ](dynamicHandler.cfg, defaultConfig);
+    }
+    return dynamicHandler;
 }
-function _warnToConsole(logger, message) {
-    _getLogger(logger)[_DYN_WARN_TO_CONSOLE ](message);
+function onConfigChange(config, configHandler, logger) {
+    var handler = config[CFG_HANDLER_LINK] || config;
+    if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+        return handler[_DYN_WATCH ](configHandler);
+    }
+    _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
+    return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
 }
 
+var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
+
 var strExecutionContextKey = "ctx";
 var strParentContextKey = "ParentContextKey";
 var strChildrenContextKey = "ChildrenContextKey";
@@ -2970,7 +3142,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$2;
+                    var nextId = nextProxy ? nextProxy._id : STR_EMPTY$3;
                     if (nextId) {
                         hasRunContext[nextId] = false;
                     }
@@ -3169,76 +3341,507 @@ var BaseTelemetryPlugin = /** @class */ (function () {
                         _setDefaults(theUpdateCtx.getCfg(), theUpdateCtx.core(), theUpdateCtx[_DYN_GET_NEXT ]());
                     }
                 }
-                if (!_self._doUpdate || _self._doUpdate(theUpdateCtx, theUpdateState, _updateCallback) !== true) {
-                    _updateCallback();
+                if (!_self._doUpdate || _self._doUpdate(theUpdateCtx, theUpdateState, _updateCallback) !== true) {
+                    _updateCallback();
+                }
+                else {
+                    result = true;
+                }
+                return result;
+            };
+            proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
+            proxyFunctionAs(_self, "_addHook", function () { return _hookContainer; }, "add");
+            objDefine(_self, "_unloadHooks", { g: function () { return _hookContainer; } });
+        });
+        _self[_DYN_DIAG_LOG ] = function (itemCtx) {
+            return _getTelCtx(itemCtx)[_DYN_DIAG_LOG ]();
+        };
+        _self[_DYN_IS_INITIALIZED ] = function () {
+            return _isinitialized;
+        };
+        _self.setInitialized = function (isInitialized) {
+            _isinitialized = isInitialized;
+        };
+        _self[_DYN_SET_NEXT_PLUGIN ] = function (next) {
+            _nextPlugin = next;
+        };
+        _self[_DYN_PROCESS_NEXT ] = function (env, itemCtx) {
+            if (itemCtx) {
+                itemCtx[_DYN_PROCESS_NEXT ](env);
+            }
+            else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY ])) {
+                _nextPlugin[STR_PROCESS_TELEMETRY ](env, null);
+            }
+        };
+        _self._getTelCtx = _getTelCtx;
+        function _getTelCtx(currentCtx) {
+            if (currentCtx === void 0) { currentCtx = null; }
+            var itemCtx = currentCtx;
+            if (!itemCtx) {
+                var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self[STR_CORE ]);
+                if (_nextPlugin && _nextPlugin[strGetPlugin]) {
+                    itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin[strGetPlugin]);
+                }
+                else {
+                    itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin);
+                }
+            }
+            return itemCtx;
+        }
+        function _setDefaults(config, core, pluginChain) {
+            createDynamicConfig(config, defaultValues, safeGetLogger(core));
+            if (!pluginChain && core) {
+                pluginChain = core[_DYN_GET_PROCESS_TEL_CONT0 ]()[_DYN_GET_NEXT ]();
+            }
+            var nextPlugin = _nextPlugin;
+            if (_nextPlugin && _nextPlugin[strGetPlugin]) {
+                nextPlugin = _nextPlugin[strGetPlugin]();
+            }
+            _self[STR_CORE ] = core;
+            _rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
+        }
+        function _initDefaults() {
+            _isinitialized = false;
+            _self[STR_CORE ] = null;
+            _rootCtx = null;
+            _nextPlugin = null;
+            _hookContainer = createUnloadHookContainer();
+            _unloadHandlerContainer = createUnloadHandlerContainer();
+        }
+    }
+    BaseTelemetryPlugin.__ieDyn=1;
+    return BaseTelemetryPlugin;
+}());
+
+var STR_EMPTY$2 = "";
+var STR_NO_RESPONSE_BODY$1 = "NoResponseBody";
+var _noResponseQs$1 = "&" + STR_NO_RESPONSE_BODY$1 + "=true";
+var STR_POST_METHOD = "POST";
+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;
+        var _disableFetchKeepAlive;
+        var _addNoResponse;
+        var _timeoutWrapper;
+        dynamicProto(SenderPostManager, this, function (_self, _base) {
+            var _sendCredentials = true;
+            _initDefaults();
+            _self[_DYN_INITIALIZE$1 ] = 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;
+                    _timeoutWrapper = config.timeWrapper;
+                    _addNoResponse = !!config.addNoResponse;
+                    _disableFetchKeepAlive = !!config.disableFetchKeepAlive;
+                    _fallbackInst = { sendPOST: _xhrSender };
+                    if (!_isOneDs) {
+                        _sendCredentials = false;
+                    }
+                    if (_disableCredentials) {
+                        var location_1 = getLocation();
+                        if (location_1 && location_1.protocol && location_1.protocol[_DYN_TO_LOWER_CASE$1 ]() === "file:") {
+                            _sendCredentials = false;
+                        }
+                    }
+                    return true;
+                }
+                catch (e) {
+                }
+                return false;
+            };
+            _self.getSyncFetchPayload = function () {
+                return _syncFetchPayload;
+            };
+            _self.getSenderInst = function (transports, sync) {
+                if (transports && transports[_DYN_LENGTH$2 ]) {
+                    return _getSenderInterface(transports, sync);
+                }
+                return null;
+            };
+            _self.getFallbackInst = function () {
+                return _fallbackInst;
+            };
+            _self[_DYN__DO_TEARDOWN ] = 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 _a;
+                var transportType = 0 ;
+                var sendPostFunc = null;
+                var lp = 0;
+                while (sendPostFunc == null && lp < transports[_DYN_LENGTH$2 ]) {
+                    transportType = transports[lp];
+                    if (!_disableXhr && transportType === 1 ) {
+                        if (useXDomainRequest()) {
+                            sendPostFunc = _xdrSender;
+                        }
+                        else if (isXhrSupported()) {
+                            sendPostFunc = _xhrSender;
+                        }
+                    }
+                    else if (transportType === 2  && isFetchSupported(syncSupport) && (!syncSupport || !_disableFetchKeepAlive)) {
+                        sendPostFunc = _doFetchSender;
+                    }
+                    else if (transportType === 3  && isBeaconsSupported() && (syncSupport ? !_disableBeaconSync : !_disableBeacon)) {
+                        sendPostFunc = _beaconSender;
+                    }
+                    lp++;
+                }
+                if (sendPostFunc) {
+                    return _a = {
+                            _transport: transportType,
+                            _isSync: syncSupport
+                        },
+                        _a[_DYN_SEND_POST ] = sendPostFunc,
+                        _a;
+                }
+                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$1 ];
+                if (!url) {
+                    _onNoPayloadUrl(oncomplete);
+                    return true;
+                }
+                url = payload[_DYN_URL_STRING$1 ] + (_addNoResponse ? _noResponseQs$1 : STR_EMPTY$2);
+                var data = payload[_DYN_DATA$1 ];
+                var plainTextBatch = _isOneDs ? data : 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 ];
+                try {
+                    if (data) {
+                        if (!_doBeaconSend(payload, oncomplete)) {
+                            var onRetry = _onCompleteFuncs && _onCompleteFuncs.beaconOnRetry;
+                            if (onRetry && isFunction(onRetry)) {
+                                onRetry(payload, oncomplete, _doBeaconSend);
+                            }
+                            else {
+                                _fallbackInst && _fallbackInst[_DYN_SEND_POST ](payload, oncomplete, true);
+                                _throwInternal(_diagLog, 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                            }
+                        }
+                        else {
+                            _onSuccess(STR_EMPTY$2, oncomplete);
+                        }
+                    }
+                }
+                catch (e) {
+                    _isOneDs && _warnToConsole(_diagLog, "Failed to send telemetry using sendBeacon API. Ex:" + dumpObj(e));
+                    _doOnComplete(oncomplete, _isOneDs ? 0 : 400, {}, STR_EMPTY$2);
+                }
+                return;
+            }
+            function _xhrSender(payload, oncomplete, sync) {
+                var thePromise;
+                var resolveFunc;
+                var rejectFunc;
+                var headers = payload[_DYN_HEADERS$1 ] || {};
+                if (!sync && _enableSendPromise) {
+                    thePromise = createPromise(function (resolve, reject) {
+                        resolveFunc = resolve;
+                        rejectFunc = reject;
+                    });
+                }
+                if (_isOneDs && sync && payload.disableXhrSync) {
+                    sync = false;
+                }
+                var endPointUrl = payload[_DYN_URL_STRING$1 ];
+                if (!endPointUrl) {
+                    _onNoPayloadUrl(oncomplete);
+                    resolveFunc && resolveFunc(false);
+                    return;
+                }
+                var xhr = openXhr(STR_POST_METHOD, endPointUrl, _sendCredentials, true, sync, payload[_DYN_TIMEOUT ]);
+                xhr[_DYN_SET_REQUEST_HEADER ]("Content-type", "application/json");
+                arrForEach(objKeys(headers), function (headerName) {
+                    xhr[_DYN_SET_REQUEST_HEADER ](headerName, headers[headerName]);
+                });
+                xhr.onreadystatechange = function () {
+                    if (!_isOneDs) {
+                        _doOnReadyFunc(xhr);
+                        if (xhr.readyState === 4) {
+                            resolveFunc && resolveFunc(true);
+                        }
+                    }
+                };
+                xhr.onload = function () {
+                    if (_isOneDs) {
+                        _doOnReadyFunc(xhr);
+                    }
+                };
+                function _doOnReadyFunc(xhr) {
+                    var onReadyFunc = _onCompleteFuncs && _onCompleteFuncs.xhrOnComplete;
+                    var onReadyFuncExist = onReadyFunc && isFunction(onReadyFunc);
+                    if (onReadyFuncExist) {
+                        onReadyFunc(xhr, oncomplete, payload);
+                    }
+                    else {
+                        var response = getResponseText(xhr);
+                        _doOnComplete(oncomplete, xhr[_DYN_STATUS ], _getAllResponseHeaders(xhr, _isOneDs), response);
+                    }
+                }
+                xhr.onerror = function (event) {
+                    _doOnComplete(oncomplete, _isOneDs ? xhr[_DYN_STATUS ] : 400, _getAllResponseHeaders(xhr, _isOneDs), _isOneDs ? STR_EMPTY$2 : formatErrorMessageXhr(xhr));
+                    rejectFunc && rejectFunc(event);
+                };
+                xhr.ontimeout = function () {
+                    _doOnComplete(oncomplete, _isOneDs ? xhr[_DYN_STATUS ] : 500, _getAllResponseHeaders(xhr, _isOneDs), _isOneDs ? STR_EMPTY$2 : 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$1 ];
+                var batch = payload[_DYN_DATA$1 ];
+                var plainTextBatch = _isOneDs ? batch : new Blob([batch], { type: "application/json" });
+                var thePromise;
+                var resolveFunc;
+                var rejectFunc;
+                var requestHeaders = new Headers();
+                var batchLength = batch[_DYN_LENGTH$2 ];
+                var ignoreResponse = false;
+                var responseHandled = false;
+                var headers = payload[_DYN_HEADERS$1 ] || {};
+                var init = (_a = {
+                        method: STR_POST_METHOD,
+                        body: plainTextBatch
+                    },
+                    _a[DisabledPropertyName] = true
+                ,
+                    _a);
+                if (payload.headers && objKeys(payload.headers)[_DYN_LENGTH$2 ] > 0) {
+                    arrForEach(objKeys(headers), function (headerName) {
+                        requestHeaders.append(headerName, headers[headerName]);
+                    });
+                    init[_DYN_HEADERS$1 ] = requestHeaders;
+                }
+                if (_sendCredentials && _isOneDs) {
+                    init.credentials = "include";
+                }
+                if (sync) {
+                    init.keepalive = true;
+                    _syncFetchPayload += batchLength;
+                    if (_isOneDs) {
+                        if (payload["_sendReason"] === 2 ) {
+                            ignoreResponse = true;
+                            if (_addNoResponse) {
+                                endPointUrl += _noResponseQs$1;
+                            }
+                        }
+                    }
+                    else {
+                        ignoreResponse = true;
+                    }
+                }
+                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;
+                }
+                function _handleError(res) {
+                    _doOnComplete(oncomplete, _isOneDs ? 0 : 400, {}, _isOneDs ? STR_EMPTY$2 : res);
+                }
+                function _onFetchComplete(response, payload, value) {
+                    var status = response[_DYN_STATUS ];
+                    var onCompleteFunc = _onCompleteFuncs.fetchOnComplete;
+                    if (onCompleteFunc && isFunction(onCompleteFunc)) {
+                        onCompleteFunc(response, oncomplete, value || STR_EMPTY$2, payload);
+                    }
+                    else {
+                        _doOnComplete(oncomplete, status, {}, value || STR_EMPTY$2);
+                    }
+                }
+                try {
+                    doAwaitResponse(fetch(_isOneDs ? endPointUrl : request, _isOneDs ? init : null), function (result) {
+                        if (sync) {
+                            _syncFetchPayload -= batchLength;
+                            batchLength = 0;
+                        }
+                        if (!responseHandled) {
+                            responseHandled = true;
+                            if (!result.rejected) {
+                                var response_1 = result.value;
+                                try {
+                                    if (!_isOneDs && !response_1.ok) {
+                                        _handleError(response_1.statusText);
+                                        resolveFunc && resolveFunc(false);
+                                    }
+                                    else {
+                                        if (_isOneDs && !response_1.body) {
+                                            _onFetchComplete(response_1, null, STR_EMPTY$2);
+                                            resolveFunc && resolveFunc(true);
+                                        }
+                                        else {
+                                            doAwaitResponse(response_1.text(), function (resp) {
+                                                _onFetchComplete(response_1, payload, resp.value);
+                                                resolveFunc && resolveFunc(true);
+                                            });
+                                        }
+                                    }
+                                }
+                                catch (e) {
+                                    _handleError(dumpObj(e));
+                                    rejectFunc && rejectFunc(e);
+                                }
+                            }
+                            else {
+                                _handleError(result.reason && result.reason[_DYN_MESSAGE ]);
+                                rejectFunc && rejectFunc(result.reason);
+                            }
+                        }
+                    });
+                }
+                catch (e) {
+                    if (!responseHandled) {
+                        _handleError(dumpObj(e));
+                        rejectFunc && rejectFunc(e);
+                    }
+                }
+                if (ignoreResponse && !responseHandled) {
+                    responseHandled = true;
+                    _doOnComplete(oncomplete, 200, {});
+                    resolveFunc && resolveFunc(true);
+                }
+                if (_isOneDs && !responseHandled && payload[_DYN_TIMEOUT ] > 0) {
+                    _timeoutWrapper && _timeoutWrapper.set(function () {
+                        if (!responseHandled) {
+                            responseHandled = true;
+                            _doOnComplete(oncomplete, 500, {});
+                            resolveFunc && resolveFunc(true);
+                        }
+                    }, payload[_DYN_TIMEOUT ]);
+                }
+                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, {}, _isOneDs ? STR_EMPTY$2 : formatErrorMessageXdr(xdr));
+                };
+                xdr.ontimeout = function () {
+                    _doOnComplete(oncomplete, 500, {});
+                };
+                xdr.onprogress = function () { };
+                var hostingProtocol = _window && _window.location && _window.location[_DYN_PROTOCOL ] || "";
+                var endpoint = payload[_DYN_URL_STRING$1 ];
+                if (!endpoint) {
+                    _onNoPayloadUrl(oncomplete);
+                    return;
+                }
+                if (!_isOneDs && 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;
                 }
-                else {
-                    result = true;
+                var endpointUrl = _isOneDs ? endpoint : endpoint[_DYN_REPLACE ](/^(https?:)/, "");
+                xdr.open(STR_POST_METHOD, endpointUrl);
+                if (payload[_DYN_TIMEOUT ]) {
+                    xdr[_DYN_TIMEOUT ] = payload[_DYN_TIMEOUT ];
                 }
-                return result;
-            };
-            proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
-            proxyFunctionAs(_self, "_addHook", function () { return _hookContainer; }, "add");
-            objDefine(_self, "_unloadHooks", { g: function () { return _hookContainer; } });
-        });
-        _self[_DYN_DIAG_LOG ] = function (itemCtx) {
-            return _getTelCtx(itemCtx)[_DYN_DIAG_LOG ]();
-        };
-        _self[_DYN_IS_INITIALIZED ] = function () {
-            return _isinitialized;
-        };
-        _self.setInitialized = function (isInitialized) {
-            _isinitialized = isInitialized;
-        };
-        _self[_DYN_SET_NEXT_PLUGIN ] = function (next) {
-            _nextPlugin = next;
-        };
-        _self[_DYN_PROCESS_NEXT ] = function (env, itemCtx) {
-            if (itemCtx) {
-                itemCtx[_DYN_PROCESS_NEXT ](env);
-            }
-            else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY ])) {
-                _nextPlugin[STR_PROCESS_TELEMETRY ](env, null);
-            }
-        };
-        _self._getTelCtx = _getTelCtx;
-        function _getTelCtx(currentCtx) {
-            if (currentCtx === void 0) { currentCtx = null; }
-            var itemCtx = currentCtx;
-            if (!itemCtx) {
-                var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self[STR_CORE ]);
-                if (_nextPlugin && _nextPlugin[strGetPlugin]) {
-                    itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin[strGetPlugin]);
+                xdr.send(data);
+                if (_isOneDs && sync) {
+                    _timeoutWrapper && _timeoutWrapper.set(function () {
+                        xdr.send(data);
+                    }, 0);
                 }
                 else {
-                    itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin);
+                    xdr.send(data);
                 }
             }
-            return itemCtx;
-        }
-        function _setDefaults(config, core, pluginChain) {
-            createDynamicConfig(config, defaultValues, safeGetLogger(core));
-            if (!pluginChain && core) {
-                pluginChain = core[_DYN_GET_PROCESS_TEL_CONT0 ]()[_DYN_GET_NEXT ]();
-            }
-            var nextPlugin = _nextPlugin;
-            if (_nextPlugin && _nextPlugin[strGetPlugin]) {
-                nextPlugin = _nextPlugin[strGetPlugin]();
+            function _initDefaults() {
+                _syncFetchPayload = 0;
+                _isInitialized = false;
+                _enableSendPromise = false;
+                _diagLog = null;
+                _isOneDs = null;
+                _onCompleteFuncs = null;
+                _disableCredentials = null;
+                _fallbackInst = null;
+                _disableXhr = false;
+                _disableBeacon = false;
+                _disableBeaconSync = false;
+                _disableFetchKeepAlive = false;
+                _addNoResponse = false;
+                _timeoutWrapper = null;
             }
-            _self[STR_CORE ] = core;
-            _rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
-        }
-        function _initDefaults() {
-            _isinitialized = false;
-            _self[STR_CORE ] = null;
-            _rootCtx = null;
-            _nextPlugin = null;
-            _hookContainer = createUnloadHookContainer();
-            _unloadHandlerContainer = createUnloadHandlerContainer();
-        }
+        });
     }
-    BaseTelemetryPlugin.__ieDyn=1;
-    return BaseTelemetryPlugin;
+    SenderPostManager.__ieDyn=1;
+    return SenderPostManager;
 }());
 
 var strOnPrefix = "on";
@@ -3261,16 +3864,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$2);
+        return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY$3);
     }
     return name;
 }
 function _getEvtNamespace(eventName, evtNamespace) {
     var _a;
     if (evtNamespace) {
-        var theNamespace_1 = STR_EMPTY$2;
+        var theNamespace_1 = STR_EMPTY$3;
         if (isArray(evtNamespace)) {
-            theNamespace_1 = STR_EMPTY$2;
+            theNamespace_1 = STR_EMPTY$3;
             arrForEach(evtNamespace, function (name) {
                 name = _normalizeNamespace(name);
                 if (name) {
@@ -3288,13 +3891,13 @@ function _getEvtNamespace(eventName, evtNamespace) {
             if (theNamespace_1[0] !== ".") {
                 theNamespace_1 = "." + theNamespace_1;
             }
-            eventName = (eventName || STR_EMPTY$2) + theNamespace_1;
+            eventName = (eventName || STR_EMPTY$3) + theNamespace_1;
         }
     }
-    var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY$2) || []);
+    var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY$3) || []);
     return _a = {},
         _a[_DYN_TYPE ] = parsedEvent[1],
-        _a.ns = ((parsedEvent[2] || STR_EMPTY$2).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$2)[_DYN_SPLIT$1 ](".").sort()).join("."),
+        _a.ns = ((parsedEvent[2] || STR_EMPTY$3).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$3)[_DYN_SPLIT$1 ](".").sort()).join("."),
         _a;
 }
 function _getRegisteredEvents(target, evtName, addDefault) {
@@ -3533,12 +4136,9 @@ var _DYN_LENGTH$1 = "length";
 var _DYN_PROCESS_TELEMETRY_ST0 = "processTelemetryStart";
 
 var _a$1;
-var Version = '4.1.1-nightly3.2403-03';
+var Version = '4.1.1';
 var FullVersionString = "1DS-Web-JS-" + Version;
 var ObjHasOwnProperty = ObjProto$1.hasOwnProperty;
-var strDisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
-var strWithCredentials = "withCredentials";
-var strTimeout = "timeout";
 var _fieldTypeEventPropMap = (_a$1 = {},
     _a$1[0 ] = 0 ,
     _a$1[2 ] = 6 ,
@@ -3707,39 +4307,11 @@ function getFieldValueType(value) {
 function isChromium() {
     return !!getInst("chrome");
 }
-function openXhr(method, urlString, withCredentials, disabled, isSync, timeout) {
-    if (disabled === void 0) { disabled = false; }
-    if (isSync === void 0) { isSync = false; }
-    function _wrapSetXhrProp(xhr, prop, value) {
-        try {
-            xhr[prop] = value;
-        }
-        catch (e) {
-        }
-    }
-    var xhr = new XMLHttpRequest();
-    if (disabled) {
-        _wrapSetXhrProp(xhr, strDisabledPropertyName, disabled);
-    }
-    if (withCredentials) {
-        _wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
-    }
-    xhr.open(method, urlString, !isSync);
-    if (withCredentials) {
-        _wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
-    }
-    if (!isSync && timeout) {
-        _wrapSetXhrProp(xhr, strTimeout, timeout);
-    }
-    return xhr;
-}
 function isGreaterThanZero(value) {
     return value > 0;
 }
 
 var STR_EMPTY = "";
-var STR_POST_METHOD = "POST";
-var STR_DISABLED_PROPERTY_NAME = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
 var STR_DROPPED = "drop";
 var STR_SENDING = "send";
 var STR_REQUEUE = "requeue";
@@ -3751,7 +4323,6 @@ var STR_CACHE_CONTROL = "cache-control";
 var STR_CONTENT_TYPE_HEADER = "content-type";
 var STR_KILL_TOKENS_HEADER = "kill-tokens";
 var STR_KILL_DURATION_HEADER = "kill-duration";
-var STR_KILL_DURATION_SECONDS_HEADER = "kill-duration-seconds";
 var STR_TIME_DELTA_HEADER = "time-delta-millis";
 var STR_CLIENT_VERSION = "client-version";
 var STR_CLIENT_ID = "client-id";
@@ -3793,6 +4364,7 @@ var _DYN_STRINGIFY_OBJECTS = "stringifyObjects";
 var _DYN_ENABLE_COMPOUND_KEY = "enableCompoundKey";
 var _DYN_DISABLE_XHR_SYNC = "disableXhrSync";
 var _DYN_DISABLE_FETCH_KEEP_A6 = "disableFetchKeepAlive";
+var _DYN_ADD_NO_RESPONSE = "addNoResponse";
 var _DYN_EXCLUDE_CS_META_DATA = "excludeCsMetaData";
 var _DYN_USE_SEND_BEACON = "useSendBeacon";
 var _DYN_ALWAYS_USE_XHR_OVERR7 = "alwaysUseXhrOverride";
@@ -3800,15 +4372,9 @@ var _DYN_UNLOAD_TRANSPORTS = "unloadTransports";
 var _DYN_SERIALIZE_OFFLINE_EV8 = "serializeOfflineEvt";
 var _DYN_GET_OFFLINE_REQUEST_9 = "getOfflineRequestDetails";
 var _DYN_CREATE_PAYLOAD = "createPayload";
-var _DYN_URL_STRING = "urlString";
-var _DYN_TIMEOUT = "timeout";
-var _DYN_ONTIMEOUT = "ontimeout";
-var _DYN_DATA = "data";
-var _DYN__SEND_REASON = "_sendReason";
 var _DYN_HEADERS = "headers";
-var _DYN_GET_RESPONSE_HEADER = "getResponseHeader";
-var _DYN_GET_ALL_RESPONSE_HEA10 = "getAllResponseHeaders";
 var _DYN__THE_PAYLOAD = "_thePayload";
+var _DYN_URL_STRING = "urlString";
 var _DYN_BATCHES = "batches";
 var _DYN_SEND_TYPE = "sendType";
 var _DYN_ADD_HEADER = "addHeader";
@@ -3817,23 +4383,24 @@ var _DYN_SEND_QUEUED_REQUESTS = "sendQueuedRequests";
 var _DYN_IS_COMPLETELY_IDLE = "isCompletelyIdle";
 var _DYN_SET_UNLOADING = "setUnloading";
 var _DYN_IS_TENANT_KILLED = "isTenantKilled";
-var _DYN_SEND_SYNCHRONOUS_BAT11 = "sendSynchronousBatch";
+var _DYN_SEND_SYNCHRONOUS_BAT10 = "sendSynchronousBatch";
 var _DYN__TRANSPORT = "_transport";
 var _DYN_GET_WPARAM = "getWParam";
 var _DYN_IS_BEACON = "isBeacon";
 var _DYN_TIMINGS = "timings";
 var _DYN_IS_TEARDOWN = "isTeardown";
 var _DYN_IS_SYNC = "isSync";
-var _DYN_SEND_POST = "sendPOST";
-var _DYN_SET_KILL_SWITCH_TENA12 = "setKillSwitchTenants";
-var _DYN__BACK_OFF_TRANSMISSI13 = "_backOffTransmission";
+var _DYN_DATA = "data";
+var _DYN__SEND_REASON = "_sendReason";
+var _DYN_SET_KILL_SWITCH_TENA11 = "setKillSwitchTenants";
+var _DYN__BACK_OFF_TRANSMISSI12 = "_backOffTransmission";
 var _DYN_IDENTIFIER = "identifier";
 var _DYN_DISABLE_OPTIMIZE_OBJ = "disableOptimizeObj";
-var _DYN_IGNORE_MC1_MS0_COOKI14 = "ignoreMc1Ms0CookieProcessing";
+var _DYN_IGNORE_MC1_MS0_COOKI13 = "ignoreMc1Ms0CookieProcessing";
 var _DYN_EVENTS_LIMIT_IN_MEM = "eventsLimitInMem";
-var _DYN_AUTO_FLUSH_EVENTS_LI15 = "autoFlushEventsLimit";
-var _DYN_DISABLE_AUTO_BATCH_F16 = "disableAutoBatchFlushLimit";
-var _DYN_OVERRIDE_INSTRUMENTA17 = "overrideInstrumentationKey";
+var _DYN_AUTO_FLUSH_EVENTS_LI14 = "autoFlushEventsLimit";
+var _DYN_DISABLE_AUTO_BATCH_F15 = "disableAutoBatchFlushLimit";
+var _DYN_OVERRIDE_INSTRUMENTA16 = "overrideInstrumentationKey";
 var _DYN_DISABLE_TELEMETRY = "disableTelemetry";
 var _DYN_BASE_DATA = "baseData";
 var _DYN_SEND_ATTEMPT = "sendAttempt";
@@ -3958,7 +4525,7 @@ var KillSwitch = /** @class */ (function () {
             return result;
         }
         dynamicProto(KillSwitch, this, function (_self) {
-            _self[_DYN_SET_KILL_SWITCH_TENA12 ] = function (killTokens, killDuration) {
+            _self[_DYN_SET_KILL_SWITCH_TENA11 ] = function (killTokens, killDuration) {
                 if (killTokens && killDuration) {
                     try {
                         var killedTokens = _normalizeTenants(killTokens[_DYN_SPLIT ](","));
@@ -4297,14 +4864,6 @@ _addCollectorHeaderQsMapping(STR_API_KEY, STR_API_KEY);
 _addCollectorHeaderQsMapping(STR_TIME_DELTA_TO_APPLY, STR_TIME_DELTA_TO_APPLY);
 _addCollectorHeaderQsMapping(STR_UPLOAD_TIME, STR_UPLOAD_TIME);
 _addCollectorHeaderQsMapping(STR_AUTH_XTOKEN, STR_AUTH_XTOKEN);
-function _getResponseText(xhr) {
-    try {
-        return xhr.responseText;
-    }
-    catch (e) {
-    }
-    return STR_EMPTY;
-}
 function _hasHeader(headers, header) {
     var hasHeader = false;
     if (headers && header) {
@@ -4334,17 +4893,6 @@ function _addRequestDetails(details, name, value, useHeaders) {
         }
     }
 }
-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;
-}
 function _addQueryStringParameter(qsParams, name, value) {
     for (var i = 0; i < qsParams[_DYN_LENGTH ]; i++) {
         if (qsParams[i].name === name) {
@@ -4395,6 +4943,7 @@ var HttpManager = /** @class */ (function () {
         var _isInitialized;
         var _timeoutWrapper;
         var _excludeCsMetaData;
+        var _sendPostMgr;
         dynamicProto(HttpManager, this, function (_self) {
             _initDefaults();
             var _sendCredentials = true;
@@ -4431,7 +4980,7 @@ var HttpManager = /** @class */ (function () {
                         _xhrTimeout = channelConfig.xhrTimeout;
                         _disableXhrSync = !!channelConfig[_DYN_DISABLE_XHR_SYNC ];
                         _disableFetchKeepAlive = !!channelConfig[_DYN_DISABLE_FETCH_KEEP_A6 ];
-                        _addNoResponse = channelConfig.addNoResponse !== false;
+                        _addNoResponse = channelConfig[_DYN_ADD_NO_RESPONSE ] !== false;
                         _excludeCsMetaData = !!channelConfig[_DYN_EXCLUDE_CS_META_DATA ];
                         if (!!core.getPlugin("LocalStorage")) {
                             _disableFetchKeepAlive = true;
@@ -4441,16 +4990,20 @@ var HttpManager = /** @class */ (function () {
                         if (!isNullOrUndefined(channelConfig[_DYN_USE_SEND_BEACON ])) {
                             _useBeacons = !!channelConfig[_DYN_USE_SEND_BEACON ];
                         }
+                        var sendPostConfig = _getSendPostMgrConfig();
+                        if (!_sendPostMgr) {
+                            _sendPostMgr = new SenderPostManager();
+                            _sendPostMgr[_DYN_INITIALIZE ](sendPostConfig, _logger);
+                        }
+                        else {
+                            _sendPostMgr.SetConfig(sendPostConfig);
+                        }
                         var syncHttpInterface = httpInterface;
                         var beaconHttpInterface = channelConfig[_DYN_ALWAYS_USE_XHR_OVERR7 ] ? httpInterface : null;
                         var fetchSyncHttpInterface = channelConfig[_DYN_ALWAYS_USE_XHR_OVERR7 ] ? httpInterface : null;
                         var beaconUnloadTransports = [3 , 2 ];
                         if (!httpInterface) {
                             _customHttpInterface = false;
-                            var location_1 = getLocation();
-                            if (location_1 && location_1.protocol && location_1.protocol[_DYN_TO_LOWER_CASE ]() === "file:") {
-                                _sendCredentials = false;
-                            }
                             var theTransports = [];
                             if (isReactNative()) {
                                 theTransports = [2 , 1 ];
@@ -4459,7 +5012,7 @@ var HttpManager = /** @class */ (function () {
                             else {
                                 theTransports = [1 , 2 , 3 ];
                             }
-                            theTransports = _prependTransports(theTransports, channelConfig.transports);
+                            theTransports = prependTransports(theTransports, channelConfig.transports);
                             httpInterface = _getSenderInterface(theTransports, false);
                             if (!httpInterface) {
                                 _warnToConsole(_logger, "No available transport to send events");
@@ -4467,7 +5020,7 @@ var HttpManager = /** @class */ (function () {
                             syncHttpInterface = _getSenderInterface(theTransports, true);
                         }
                         if (!beaconHttpInterface) {
-                            beaconUnloadTransports = _prependTransports(beaconUnloadTransports, channelConfig[_DYN_UNLOAD_TRANSPORTS ]);
+                            beaconUnloadTransports = prependTransports(beaconUnloadTransports, channelConfig[_DYN_UNLOAD_TRANSPORTS ]);
                             beaconHttpInterface = _getSenderInterface(beaconUnloadTransports, true);
                         }
                         _canHaveReducedPayload = !_customHttpInterface && ((_useBeacons && isBeaconsSupported()) || (!_disableFetchKeepAlive && isFetchSupported(true)));
@@ -4493,72 +5046,65 @@ var HttpManager = /** @class */ (function () {
                 };
             };
             _self[_DYN_SERIALIZE_OFFLINE_EV8 ] = function (evt) {
-                return _serializer.getEventBlob(evt);
+                try {
+                    if (_serializer) {
+                        return _serializer.getEventBlob(evt);
+                    }
+                }
+                catch (e) {
+                }
+                return STR_EMPTY;
             };
             _self[_DYN_GET_OFFLINE_REQUEST_9 ] = function () {
-                var payload = _serializer[_DYN_CREATE_PAYLOAD ](0, false, false, false, 1 , 0 );
-                return _buildRequestDetails(payload, _useHeaders);
+                try {
+                    var payload = _serializer && _serializer[_DYN_CREATE_PAYLOAD ](0, false, false, false, 1 , 0 );
+                    return _buildRequestDetails(payload, _useHeaders);
+                }
+                catch (e) {
+                }
+                return null;
             };
             function _getSenderInterface(transports, syncSupport) {
-                var transportType = 0 ;
-                var sendPostFunc = null;
-                var lp = 0;
-                while (sendPostFunc == null && lp < transports[_DYN_LENGTH ]) {
-                    transportType = transports[lp];
-                    if (transportType === 1 ) {
-                        if (useXDomainRequest()) {
-                            sendPostFunc = _xdrSendPost;
-                        }
-                        else if (isXhrSupported()) {
-                            sendPostFunc = _xhrSendPost;
-                        }
-                    }
-                    else if (transportType === 2  && isFetchSupported(syncSupport) && (!syncSupport || (syncSupport && !_disableFetchKeepAlive))) {
-                        sendPostFunc = _fetchSendPost;
-                    }
-                    else if (_useBeacons && transportType === 3  && isBeaconsSupported()) {
-                        sendPostFunc = _beaconSendPost;
-                    }
-                    lp++;
+                try {
+                    return _sendPostMgr && _sendPostMgr.getSenderInst(transports, syncSupport);
                 }
-                if (sendPostFunc) {
-                    return {
-                        _transport: transportType,
-                        _isSync: syncSupport,
-                        sendPOST: sendPostFunc
-                    };
+                catch (e) {
                 }
                 return null;
             }
             _self["_getDbgPlgTargets"] = function () {
                 return [_sendInterfaces[0 ], _killSwitch, _serializer, _sendInterfaces];
             };
-            function _xdrSendPost(payload, oncomplete, sync) {
-                var xdr = new XDomainRequest();
-                xdr.open(STR_POST_METHOD, payload[_DYN_URL_STRING ]);
-                if (payload[_DYN_TIMEOUT ]) {
-                    xdr[_DYN_TIMEOUT ] = payload[_DYN_TIMEOUT ];
-                }
-                xdr.onload = function () {
-                    var response = _getResponseText(xdr);
-                    _doOnComplete(oncomplete, 200, {}, response);
-                    _handleCollectorResponse(response);
-                };
-                xdr.onerror = function () {
-                    _doOnComplete(oncomplete, 400, {});
-                };
-                xdr[_DYN_ONTIMEOUT ] = function () {
-                    _doOnComplete(oncomplete, 500, {});
-                };
-                xdr.onprogress = function () { };
-                if (sync) {
-                    xdr.send(payload[_DYN_DATA ]);
+            function _getSendPostMgrConfig() {
+                try {
+                    var onCompleteFuncs = {
+                        xdrOnComplete: _xdrOncomplete,
+                        fetchOnComplete: _fetchOnComplete,
+                        xhrOnComplete: _xhrOnComplete,
+                        beaconOnRetry: _onBeaconRetry
+                    };
+                    var config = {
+                        enableSendPromise: false,
+                        isOneDs: true,
+                        disableCredentials: !_sendCredentials,
+                        disableXhr: false,
+                        disableBeacon: !_useBeacons,
+                        disableBeaconSync: !_useBeacons,
+                        disableFetchKeepAlive: _disableFetchKeepAlive,
+                        timeWrapper: _timeoutWrapper,
+                        addNoResponse: _addNoResponse,
+                        senderOnCompleteCallBack: onCompleteFuncs
+                    };
+                    return config;
                 }
-                else {
-                    _timeoutWrapper.set(function () {
-                        xdr.send(payload[_DYN_DATA ]);
-                    }, 0);
+                catch (e) {
                 }
+                return null;
+            }
+            function _xdrOncomplete(xdr, oncomplete, payload) {
+                var response = getResponseText(xdr);
+                _doOnComplete(oncomplete, 200, {}, response);
+                _handleCollectorResponse(response);
             }
             function _initDefaults() {
                 var undefValue;
@@ -4593,123 +5139,26 @@ var HttpManager = /** @class */ (function () {
                 _isInitialized = false;
                 _timeoutWrapper = createTimeoutWrapper();
                 _excludeCsMetaData = false;
+                _sendPostMgr = null;
             }
-            function _fetchSendPost(payload, oncomplete, sync) {
-                var _a;
-                var theUrl = payload[_DYN_URL_STRING ];
-                var ignoreResponse = false;
-                var responseHandled = false;
-                var requestInit = (_a = {
-                        body: payload[_DYN_DATA ],
-                        method: STR_POST_METHOD
-                    },
-                    _a[STR_DISABLED_PROPERTY_NAME] = true,
-                    _a);
-                if (sync) {
-                    requestInit.keepalive = true;
-                    if (payload[_DYN__SEND_REASON ] === 2 ) {
-                        ignoreResponse = true;
-                        if (_addNoResponse) {
-                            theUrl += _noResponseQs;
-                        }
-                    }
-                }
-                if (_sendCredentials) {
-                    requestInit.credentials = "include";
-                }
-                if (payload.headers && objKeys(payload.headers)[_DYN_LENGTH ] > 0) {
-                    requestInit[_DYN_HEADERS ] = payload[_DYN_HEADERS ];
-                }
+            function _fetchOnComplete(response, onComplete, resValue, payload) {
                 var handleResponse = function (status, headerMap, responseText) {
-                    if (!responseHandled) {
-                        responseHandled = true;
-                        _doOnComplete(oncomplete, status, headerMap, responseText);
-                        _handleCollectorResponse(responseText);
-                    }
+                    _doOnComplete(onComplete, status, headerMap, responseText);
+                    _handleCollectorResponse(responseText);
                 };
-                var handleError = function () {
-                    if (!responseHandled) {
-                        responseHandled = true;
-                        _doOnComplete(oncomplete, 0, {});
-                    }
-                };
-                fetch(theUrl, requestInit).then(function (response) {
-                    var headerMap = {};
-                    var responseText = STR_EMPTY;
-                    var headers = response[_DYN_HEADERS ];
-                    if (headers) {
-                        headers["forEach"](function (value, name) {
-                            headerMap[name] = value;
-                        });
-                    }
-                    if (response.body) {
-                        response.text().then(function (text) {
-                            responseText = text;
-                            handleResponse(response.status, headerMap, responseText);
-                        }, handleError);
-                    }
-                    else {
-                        handleResponse(response.status, headerMap, "");
-                    }
-                }).catch(handleError);
-                if (ignoreResponse && !responseHandled) {
-                    responseHandled = true;
-                    _doOnComplete(oncomplete, 200, {});
-                }
-                if (!responseHandled && payload[_DYN_TIMEOUT ] > 0) {
-                    _timeoutWrapper.set(function () {
-                        if (!responseHandled) {
-                            responseHandled = true;
-                            _doOnComplete(oncomplete, 500, {});
-                        }
-                    }, payload[_DYN_TIMEOUT ]);
+                var headerMap = {};
+                var headers = response[_DYN_HEADERS ];
+                if (headers) {
+                    headers["forEach"](function (value, name) {
+                        headerMap[name] = value;
+                    });
                 }
+                handleResponse(response.status, headerMap, resValue || STR_EMPTY);
             }
-            function _xhrSendPost(payload, oncomplete, sync) {
-                var theUrl = payload[_DYN_URL_STRING ];
-                function _appendHeader(theHeaders, xhr, name) {
-                    if (!theHeaders[name] && xhr && xhr[_DYN_GET_RESPONSE_HEADER ]) {
-                        var value = xhr[_DYN_GET_RESPONSE_HEADER ](name);
-                        if (value) {
-                            theHeaders[name] = strTrim(value);
-                        }
-                    }
-                    return theHeaders;
-                }
-                function _getAllResponseHeaders(xhr) {
-                    var theHeaders = {};
-                    if (!xhr[_DYN_GET_ALL_RESPONSE_HEA10 ]) {
-                        theHeaders = _appendHeader(theHeaders, xhr, STR_TIME_DELTA_HEADER);
-                        theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_HEADER);
-                        theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_SECONDS_HEADER);
-                    }
-                    else {
-                        theHeaders = _convertAllHeadersToMap(xhr[_DYN_GET_ALL_RESPONSE_HEA10 ]());
-                    }
-                    return theHeaders;
-                }
-                function xhrComplete(xhr, responseTxt) {
-                    _doOnComplete(oncomplete, xhr.status, _getAllResponseHeaders(xhr), responseTxt);
-                }
-                if (sync && payload[_DYN_DISABLE_XHR_SYNC ]) {
-                    sync = false;
-                }
-                var xhrRequest = openXhr(STR_POST_METHOD, theUrl, _sendCredentials, true, sync, payload[_DYN_TIMEOUT ]);
-                objForEachKey(payload[_DYN_HEADERS ], function (name, value) {
-                    xhrRequest.setRequestHeader(name, value);
-                });
-                xhrRequest.onload = function () {
-                    var response = _getResponseText(xhrRequest);
-                    xhrComplete(xhrRequest, response);
-                    _handleCollectorResponse(response);
-                };
-                xhrRequest.onerror = function () {
-                    xhrComplete(xhrRequest);
-                };
-                xhrRequest[_DYN_ONTIMEOUT ] = function () {
-                    xhrComplete(xhrRequest);
-                };
-                xhrRequest.send(payload[_DYN_DATA ]);
+            function _xhrOnComplete(request, oncomplete, payload) {
+                var response = getResponseText(request);
+                _doOnComplete(oncomplete, request.status, _getAllResponseHeaders(request, true), response);
+                _handleCollectorResponse(response);
             }
             function _doOnComplete(oncomplete, status, headers, response) {
                 try {
@@ -4719,53 +5168,51 @@ var HttpManager = /** @class */ (function () {
                     _throwInternal(_logger, 2 , 518 , dumpObj(e));
                 }
             }
-            function _beaconSendPost(payload, oncomplete, sync) {
+            function _onBeaconRetry(payload, onComplete, canSend) {
                 var internalPayloadData = payload;
                 var status = 200;
                 var thePayload = internalPayloadData[_DYN__THE_PAYLOAD ];
                 var theUrl = payload[_DYN_URL_STRING ] + (_addNoResponse ? _noResponseQs : STR_EMPTY);
                 try {
                     var nav_1 = getNavigator();
-                    if (!nav_1.sendBeacon(theUrl, payload[_DYN_DATA ])) {
-                        if (thePayload) {
-                            var persistStorage = !!_core.getPlugin("LocalStorage");
-                            var droppedBatches_1 = [];
-                            var sentBatches_1 = [];
-                            arrForEach(thePayload[_DYN_BATCHES ], function (theBatch) {
-                                if (droppedBatches_1 && theBatch && theBatch[_DYN_COUNT ]() > 0) {
-                                    var theEvents = theBatch[_DYN_EVENTS ]();
-                                    for (var lp = 0; lp < theEvents[_DYN_LENGTH ]; lp++) {
-                                        if (!nav_1.sendBeacon(theUrl, _serializer.getEventBlob(theEvents[lp]))) {
-                                            droppedBatches_1[_DYN_PUSH ](theBatch[_DYN_SPLIT ](lp));
-                                            break;
-                                        }
-                                        else {
-                                            sentBatches_1[_DYN_PUSH ](theBatch[lp]);
-                                        }
+                    if (thePayload) {
+                        var persistStorage = !!_core.getPlugin("LocalStorage");
+                        var droppedBatches_1 = [];
+                        var sentBatches_1 = [];
+                        arrForEach(thePayload[_DYN_BATCHES ], function (theBatch) {
+                            if (droppedBatches_1 && theBatch && theBatch[_DYN_COUNT ]() > 0) {
+                                var theEvents = theBatch[_DYN_EVENTS ]();
+                                for (var lp = 0; lp < theEvents[_DYN_LENGTH ]; lp++) {
+                                    if (!nav_1.sendBeacon(theUrl, _serializer.getEventBlob(theEvents[lp]))) {
+                                        droppedBatches_1[_DYN_PUSH ](theBatch[_DYN_SPLIT ](lp));
+                                        break;
+                                    }
+                                    else {
+                                        sentBatches_1[_DYN_PUSH ](theBatch[lp]);
                                     }
                                 }
-                                else {
-                                    droppedBatches_1[_DYN_PUSH ](theBatch[_DYN_SPLIT ](0));
-                                }
-                            });
-                            if (sentBatches_1[_DYN_LENGTH ] > 0) {
-                                thePayload.sentEvts = sentBatches_1;
                             }
-                            if (!persistStorage) {
-                                _sendBatchesNotification(droppedBatches_1, 8003 , thePayload[_DYN_SEND_TYPE ], true);
+                            else {
+                                droppedBatches_1[_DYN_PUSH ](theBatch[_DYN_SPLIT ](0));
                             }
+                        });
+                        if (sentBatches_1[_DYN_LENGTH ] > 0) {
+                            thePayload.sentEvts = sentBatches_1;
                         }
-                        else {
-                            status = 0;
+                        if (!persistStorage) {
+                            _sendBatchesNotification(droppedBatches_1, 8003 , thePayload[_DYN_SEND_TYPE ], true);
                         }
                     }
+                    else {
+                        status = 0;
+                    }
                 }
                 catch (ex) {
                     _warnToConsole(_logger, "Failed to send telemetry using sendBeacon API. Ex:" + dumpObj(ex));
                     status = 0;
                 }
                 finally {
-                    _doOnComplete(oncomplete, status, {}, STR_EMPTY);
+                    _doOnComplete(onComplete, status, {}, STR_EMPTY);
                 }
             }
             function _isBeaconPayload(sendType) {
@@ -4829,7 +5276,7 @@ var HttpManager = /** @class */ (function () {
                 _paused = false;
                 _self[_DYN_SEND_QUEUED_REQUESTS ](0 , 4 );
             };
-            _self[_DYN_SEND_SYNCHRONOUS_BAT11 ] = function (batch, sendType, sendReason) {
+            _self[_DYN_SEND_SYNCHRONOUS_BAT10 ] = function (batch, sendType, sendReason) {
                 if (batch && batch[_DYN_COUNT ]() > 0) {
                     if (isNullOrUndefined(sendType)) {
                         sendType = 1 ;
@@ -5038,7 +5485,7 @@ var HttpManager = /** @class */ (function () {
                                 };
                                 var isSync = thePayload[_DYN_IS_TEARDOWN ] || thePayload[_DYN_IS_SYNC ];
                                 try {
-                                    sendInterface_1[_DYN_SEND_POST ](payload, onComplete, isSync);
+                                    sendInterface_1.sendPOST(payload, onComplete, isSync);
                                     if (_sendListener) {
                                         _sendListener(orgPayloadData, payload, isSync, thePayload[_DYN_IS_BEACON ]);
                                     }
@@ -5059,7 +5506,7 @@ var HttpManager = /** @class */ (function () {
                                         data: orgPayloadData[_DYN_DATA ],
                                         urlString: orgPayloadData[_DYN_URL_STRING ],
                                         headers: extend({}, orgPayloadData[_DYN_HEADERS ]),
-                                        timeout: orgPayloadData[_DYN_TIMEOUT ],
+                                        timeout: orgPayloadData.timeout,
                                         disableXhrSync: orgPayloadData[_DYN_DISABLE_XHR_SYNC ],
                                         disableFetchKeepAlive: orgPayloadData[_DYN_DISABLE_FETCH_KEEP_A6 ]
                                     };
@@ -5115,7 +5562,7 @@ var HttpManager = /** @class */ (function () {
                         if (headers) {
                             _clockSkewManager[_DYN_SET_CLOCK_SKEW ](headers[STR_TIME_DELTA_HEADER]);
                             var killDuration = headers[STR_KILL_DURATION_HEADER] || headers["kill-duration-seconds"];
-                            arrForEach(_killSwitch[_DYN_SET_KILL_SWITCH_TENA12 ](headers[STR_KILL_TOKENS_HEADER], killDuration), function (killToken) {
+                            arrForEach(_killSwitch[_DYN_SET_KILL_SWITCH_TENA11 ](headers[STR_KILL_TOKENS_HEADER], killDuration), function (killToken) {
                                 arrForEach(thePayload[_DYN_BATCHES ], function (theBatch) {
                                     if (theBatch[_DYN_I_KEY ]() === killToken) {
                                         droppedBatches = droppedBatches || [];
@@ -5168,7 +5615,7 @@ var HttpManager = /** @class */ (function () {
             function _handleRequestFinished(thePayload, batchReason, sendReason, backOffTrans) {
                 try {
                     if (backOffTrans) {
-                        _postManager[_DYN__BACK_OFF_TRANSMISSI13 ]();
+                        _postManager[_DYN__BACK_OFF_TRANSMISSI12 ]();
                     }
                     var theBatches = thePayload[_DYN_BATCHES ];
                     if (batchReason === 200 ) {
@@ -5207,26 +5654,6 @@ var HttpManager = /** @class */ (function () {
                     _timeoutWrapper.set(cb, interval);
                 }
             }
-            function _convertAllHeadersToMap(headersString) {
-                var headers = {};
-                if (isString(headersString)) {
-                    var headersArray = strTrim(headersString)[_DYN_SPLIT ](/[\r\n]+/);
-                    arrForEach(headersArray, function (headerEntry) {
-                        if (headerEntry) {
-                            var idx = headerEntry.indexOf(": ");
-                            if (idx !== -1) {
-                                var header = strTrim(headerEntry.substring(0, idx))[_DYN_TO_LOWER_CASE ]();
-                                var value = strTrim(headerEntry.substring(idx + 1));
-                                headers[header] = value;
-                            }
-                            else {
-                                headers[strTrim(headerEntry)] = 1;
-                            }
-                        }
-                    });
-                }
-                return headers;
-            }
             function _getMsfpc(thePayload) {
                 for (var lp = 0; lp < thePayload.batches[_DYN_LENGTH ]; lp++) {
                     var msfpc = thePayload[_DYN_BATCHES ][lp].Msfpc();
@@ -5342,7 +5769,7 @@ var defaultPostChannelConfig = objDeepFreeze({
     excludeCsMetaData: undefValue
 });
 function isOverrideFn(httpXHROverride) {
-    return httpXHROverride && httpXHROverride[_DYN_SEND_POST ];
+    return httpXHROverride && httpXHROverride.sendPOST;
 }
 var PostChannel = /** @class */ (function (_super) {
     __extendsFn(PostChannel, _super);
@@ -5350,7 +5777,7 @@ var PostChannel = /** @class */ (function (_super) {
         var _this = _super.call(this) || this;
         _this.identifier = "PostChannel";
         _this.priority = 1011;
-        _this.version = '4.1.1-nightly3.2403-03';
+        _this.version = '4.1.1';
         var _postConfig;
         var _isTeardownCalled = false;
         var _flushCallbackQueue = [];
@@ -5401,16 +5828,16 @@ var PostChannel = /** @class */ (function (_super) {
                             _postConfig = ctx.getExtCfg(_self[_DYN_IDENTIFIER ], defaultPostChannelConfig);
                             _timeoutWrapper = createTimeoutWrapper(_postConfig[_DYN_SET_TIMEOUT_OVERRIDE ], _postConfig[_DYN_CLEAR_TIMEOUT_OVERRI3 ]);
                             _optimizeObject = !_postConfig[_DYN_DISABLE_OPTIMIZE_OBJ ] && isChromium();
-                            _ignoreMc1Ms0CookieProcessing = _postConfig[_DYN_IGNORE_MC1_MS0_COOKI14 ];
+                            _ignoreMc1Ms0CookieProcessing = _postConfig[_DYN_IGNORE_MC1_MS0_COOKI13 ];
                             _hookWParam(core);
                             _queueSizeLimit = _postConfig[_DYN_EVENTS_LIMIT_IN_MEM ];
                             _immediateQueueSizeLimit = _postConfig.immediateEventLimit;
-                            _autoFlushEventsLimit = _postConfig[_DYN_AUTO_FLUSH_EVENTS_LI15 ];
+                            _autoFlushEventsLimit = _postConfig[_DYN_AUTO_FLUSH_EVENTS_LI14 ];
                             _maxEventSendAttempts = _postConfig.maxEventRetryAttempts;
                             _maxUnloadEventSendAttempts = _postConfig.maxUnloadEventRetryAttempts;
-                            _disableAutoBatchFlushLimit = _postConfig[_DYN_DISABLE_AUTO_BATCH_F16 ];
+                            _disableAutoBatchFlushLimit = _postConfig[_DYN_DISABLE_AUTO_BATCH_F15 ];
                             _setAutoLimits();
-                            _overrideInstrumentationKey = _postConfig[_DYN_OVERRIDE_INSTRUMENTA17 ];
+                            _overrideInstrumentationKey = _postConfig[_DYN_OVERRIDE_INSTRUMENTA16 ];
                             _disableTelemetry = !!_postConfig[_DYN_DISABLE_TELEMETRY ];
                             if (_unloadHandlersAdded) {
                                 _removeUnloadHandlers();
@@ -5447,24 +5874,31 @@ var PostChannel = /** @class */ (function (_super) {
                 _self.processNext(event, itemCtx);
             };
             _self.getOfflineSupport = function () {
-                var details = _httpManager[_DYN_GET_OFFLINE_REQUEST_9 ]();
-                return {
-                    getUrl: function () {
-                        return details.url;
-                    },
-                    serialize: _serialize,
-                    batch: _batch,
-                    shouldProcess: function (evt) {
-                        return !_disableTelemetry;
-                    },
-                    createPayload: function (evt) {
+                try {
+                    var details_1 = _httpManager && _httpManager[_DYN_GET_OFFLINE_REQUEST_9 ]();
+                    if (details_1) {
                         return {
-                            urlString: details.url,
-                            headers: details[_DYN_HDRS ],
-                            data: evt
+                            getUrl: function () {
+                                return details_1.url;
+                            },
+                            serialize: _serialize,
+                            batch: _batch,
+                            shouldProcess: function (evt) {
+                                return !_disableTelemetry;
+                            },
+                            createPayload: function (evt) {
+                                return {
+                                    urlString: details_1.url,
+                                    headers: details_1[_DYN_HDRS ],
+                                    data: evt
+                                };
+                            }
                         };
                     }
-                };
+                }
+                catch (e) {
+                }
+                return null;
             };
             _self._doTeardown = function (unloadCtx, unloadState) {
                 _releaseAllQueues(2 , 2 );
@@ -5557,7 +5991,7 @@ var PostChannel = /** @class */ (function (_super) {
                             if (_optimizeObject) {
                                 event = optimizeObject(event);
                             }
-                            _httpManager[_DYN_SEND_SYNCHRONOUS_BAT11 ](EventBatch.create(event[_DYN_I_KEY ], [event]), event[_DYN_SYNC ] === true ? 1  : event[_DYN_SYNC ], 3 );
+                            _httpManager[_DYN_SEND_SYNCHRONOUS_BAT10 ](EventBatch.create(event[_DYN_I_KEY ], [event]), event[_DYN_SYNC ] === true ? 1  : event[_DYN_SYNC ], 3 );
                             return;
                         }
                     }
@@ -5591,7 +6025,7 @@ var PostChannel = /** @class */ (function (_super) {
             }
             _self.setEventQueueLimits = function (eventLimit, autoFlushLimit) {
                 _postConfig[_DYN_EVENTS_LIMIT_IN_MEM ] = _queueSizeLimit = isGreaterThanZero(eventLimit) ? eventLimit : MaxEventsLimitInMem;
-                _postConfig[_DYN_AUTO_FLUSH_EVENTS_LI15 ] = _autoFlushEventsLimit = isGreaterThanZero(autoFlushLimit) ? autoFlushLimit : 0;
+                _postConfig[_DYN_AUTO_FLUSH_EVENTS_LI14 ] = _autoFlushEventsLimit = isGreaterThanZero(autoFlushLimit) ? autoFlushLimit : 0;
                 _setAutoLimits();
                 var doFlush = _queueSize > eventLimit;
                 if (!doFlush && _autoFlushBatchLimit > 0) {
@@ -5730,7 +6164,7 @@ var PostChannel = /** @class */ (function (_super) {
                     }
                 }
             }
-            _self[_DYN__BACK_OFF_TRANSMISSI13 ] = function () {
+            _self[_DYN__BACK_OFF_TRANSMISSI12 ] = function () {
                 if (_currentBackoffCount < MaxBackoffCount) {
                     _currentBackoffCount++;
                     _clearScheduledTimer();