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

package/dist/es5/ms.post.js

@@ -1,5 +1,5 @@
 /*!
- * 1DS JS SDK POST plugin, 4.1.1-nightly3.2403-02
+ * 1DS JS SDK POST plugin, 4.1.1-nightly3.2403-04
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -1134,6 +1134,7 @@
     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";
@@ -1141,10 +1142,19 @@
     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) {
@@ -1162,6 +1172,60 @@
         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"
     ];
@@ -1409,7 +1473,7 @@
     }
 
     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";
@@ -1418,72 +1482,20 @@
     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";
@@ -1563,54 +1575,413 @@
         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;
@@ -1670,7 +2041,7 @@
         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);
@@ -1708,11 +2079,11 @@
     }
     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);
             },
@@ -2333,226 +2704,27 @@
             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";
@@ -2949,7 +3121,7 @@
                 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;
                         }
@@ -3148,76 +3320,507 @@
                             _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";
@@ -3240,16 +3843,16 @@
     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) {
@@ -3267,13 +3870,13 @@
                 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) {
@@ -3512,12 +4115,9 @@
     var _DYN_PROCESS_TELEMETRY_ST0 = "processTelemetryStart";
 
     var _a$1;
-    var Version = '4.1.1-nightly3.2403-02';
+    var Version = '4.1.1-nightly3.2403-04';
     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 ,
@@ -3686,39 +4286,11 @@
     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";
@@ -3730,7 +4302,6 @@
     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";
@@ -3772,6 +4343,7 @@
     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";
@@ -3779,15 +4351,9 @@
     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";
@@ -3796,23 +4362,24 @@
     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";
@@ -3937,7 +4504,7 @@
                 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 ](","));
@@ -4276,14 +4843,6 @@
     _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) {
@@ -4313,17 +4872,6 @@
             }
         }
     }
-    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) {
@@ -4374,6 +4922,7 @@
             var _isInitialized;
             var _timeoutWrapper;
             var _excludeCsMetaData;
+            var _sendPostMgr;
             dynamicProto(HttpManager, this, function (_self) {
                 _initDefaults();
                 var _sendCredentials = true;
@@ -4410,7 +4959,7 @@
                             _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;
@@ -4420,16 +4969,20 @@
                             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 ];
@@ -4438,7 +4991,7 @@
                                 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");
@@ -4446,7 +4999,7 @@
                                 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)));
@@ -4472,72 +5025,65 @@
                     };
                 };
                 _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;
@@ -4572,123 +5118,26 @@
                     _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 {
@@ -4698,53 +5147,51 @@
                         _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) {
@@ -4808,7 +5255,7 @@
                     _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 ;
@@ -5017,7 +5464,7 @@
                                     };
                                     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 ]);
                                         }
@@ -5038,7 +5485,7 @@
                                             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 ]
                                         };
@@ -5094,7 +5541,7 @@
                             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 || [];
@@ -5147,7 +5594,7 @@
                 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 ) {
@@ -5186,26 +5633,6 @@
                         _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();
@@ -5321,7 +5748,7 @@
         excludeCsMetaData: undefValue
     });
     function isOverrideFn(httpXHROverride) {
-        return httpXHROverride && httpXHROverride[_DYN_SEND_POST ];
+        return httpXHROverride && httpXHROverride.sendPOST;
     }
     var PostChannel = /** @class */ (function (_super) {
         __extendsFn(PostChannel, _super);
@@ -5329,7 +5756,7 @@
             var _this = _super.call(this) || this;
             _this.identifier = "PostChannel";
             _this.priority = 1011;
-            _this.version = '4.1.1-nightly3.2403-02';
+            _this.version = '4.1.1-nightly3.2403-04';
             var _postConfig;
             var _isTeardownCalled = false;
             var _flushCallbackQueue = [];
@@ -5380,16 +5807,16 @@
                                 _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();
@@ -5426,24 +5853,31 @@
                     _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 );
@@ -5536,7 +5970,7 @@
                                 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;
                             }
                         }
@@ -5570,7 +6004,7 @@
                 }
                 _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) {
@@ -5709,7 +6143,7 @@
                         }
                     }
                 }
-                _self[_DYN__BACK_OFF_TRANSMISSI13 ] = function () {
+                _self[_DYN__BACK_OFF_TRANSMISSI12 ] = function () {
                     if (_currentBackoffCount < MaxBackoffCount) {
                         _currentBackoffCount++;
                         _clearScheduledTimer();