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

package/dist/es5/applicationinsights-common.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Common, 3.1.1-nightly3.2403-01
+ * Application Insights JavaScript SDK - Common, 3.1.1-nightly3.2403-03
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -86,7 +86,12 @@
         return !!value && typeof value === OBJECT;
     }
     var isArray = ArrCls.isArray;
+    var isNumber = ( /*#__PURE__*/_createIs(NUMBER));
     var isError = ( /*#__PURE__*/_createObjIs("Error"));
+    /*#__NO_SIDE_EFFECTS__*/
+    function isPromiseLike(value) {
+        return !!(value && value.then && isFunction(value.then));
+    }
 
     var objGetOwnPropertyDescriptor = ObjClass$1.getOwnPropertyDescriptor;
 
@@ -158,6 +163,10 @@
         return _createKeyValueMap(values, 1 , 0 , objDeepFreeze);
     }
     /*#__NO_SIDE_EFFECTS__*/
+    function createEnumKeyMap(values) {
+        return _createKeyValueMap(values, 0 , 0 , objDeepFreeze);
+    }
+    /*#__NO_SIDE_EFFECTS__*/
     function createSimpleMap(values) {
         var mapClass = {};
         objForEachKey(values, function (key, value) {
@@ -171,6 +180,22 @@
         return createSimpleMap(values);
     }
 
+    var _wellKnownSymbolMap = /*#__PURE__*/ createEnumKeyMap({
+        asyncIterator: 0 ,
+        hasInstance: 1 ,
+        isConcatSpreadable: 2 ,
+        iterator: 3 ,
+        match: 4 ,
+        matchAll: 5 ,
+        replace: 6 ,
+        search: 7 ,
+        species: 8 ,
+        split: 9 ,
+        toPrimitive: 10 ,
+        toStringTag: 11 ,
+        unscopables: 12
+    });
+
     var asString = StrCls;
 
     var GLOBAL_CONFIG_KEY = "__tsUtils$gblCfg";
@@ -273,6 +298,7 @@
         }
         return _polySymbols;
     }
+    var _wellKnownSymbolCache;
     /*#__NO_SIDE_EFFECTS__*/
     function polyNewSymbol(description) {
         var theSymbol = {
@@ -294,6 +320,16 @@
         }
         return registry.k[key];
     }
+    /*#__NO_SIDE_EFFECTS__*/
+    function polyGetKnownSymbol(name) {
+        !_wellKnownSymbolCache && (_wellKnownSymbolCache = {});
+        var result;
+        var knownName = _wellKnownSymbolMap[name];
+        if (knownName) {
+            result = _wellKnownSymbolCache[knownName] = _wellKnownSymbolCache[knownName] || polyNewSymbol(SYMBOL + "." + knownName);
+        }
+        return result;
+    }
 
     var propMap = {
         e: "enumerable",
@@ -371,6 +407,7 @@
     var _cachedWindow;
     var _cachedDocument;
     var _cachedNavigator;
+    var _isNode;
     /*#__NO_SIDE_EFFECTS__*/
     function lazySafeGetInst(name) {
         return getLazy(function () { return safe((getInst), [name]).v || UNDEF_VALUE; });
@@ -418,6 +455,10 @@
         (!_cachedNavigator || _globalLazyTestHooks.lzy) && (_cachedNavigator = createCachedValue(safe((getInst), ["navigator"]).v));
         return _cachedNavigator.v;
     }
+    function isNode() {
+        !_isNode && (_isNode = createCachedValue(!!safe(function () { return (process && (process.versions || {}).node); }).v));
+        return _isNode.v;
+    }
 
     var _symbol;
     var _symbolFor;
@@ -428,6 +469,23 @@
         }
     }
     /*#__NO_SIDE_EFFECTS__*/
+    function hasSymbol() {
+        return !!getSymbol();
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function getSymbol() {
+        !_globalLazyTestHooks && _initTestHooks();
+        (!_symbol || _globalLazyTestHooks.lzy) && _initSymbol();
+        return _symbol.v;
+    }
+    /*#__NO_SIDE_EFFECTS__*/
+    function getKnownSymbol(name, noPoly) {
+        var knownName = _wellKnownSymbolMap[name];
+        !_globalLazyTestHooks && _initTestHooks();
+        (!_symbol || _globalLazyTestHooks.lzy) && _initSymbol();
+        return _symbol.v ? _symbol.v[knownName || name] : (!noPoly ? polyGetKnownSymbol(name) : UNDEF_VALUE);
+    }
+    /*#__NO_SIDE_EFFECTS__*/
     function newSymbol(description, noPoly) {
         !_globalLazyTestHooks && _initTestHooks();
         (!_symbol || _globalLazyTestHooks.lzy) && _initSymbol();
@@ -459,6 +517,8 @@
 
     var arrMap = ( /*#__PURE__*/_unwrapFunction("map", ArrProto));
 
+    var arrSlice = ( /*#__PURE__*/_unwrapFunction(SLICE, ArrProto));
+
     var arrReduce = ( /*#__PURE__*/_unwrapFunction("reduce", ArrProto));
 
     var objCreate = ObjClass$1["create"] || polyObjCreate;
@@ -1044,8 +1104,308 @@
     }
     dynamicProto[DynProtoDefaultOptions] = _gblInst.o;
 
+    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"
+    ];
+
+    var DISPATCH_EVENT = "dispatchEvent";
+    var _hasInitEvent;
+    function emitEvent(target, evtName, populateEvent, useNewEvent) {
+        var doc = getDocument();
+        !_hasInitEvent && (_hasInitEvent = safeGetLazy(function () {
+            var evt;
+            if (doc && doc.createEvent) {
+                evt = doc.createEvent("Event");
+            }
+            return (!!evt && evt.initEvent);
+        }, null));
+        var theEvt = _hasInitEvent.v ? doc.createEvent("Event") : (useNewEvent ? new Event(evtName) : {});
+        populateEvent && populateEvent(theEvt);
+        if (_hasInitEvent.v) {
+            theEvt.initEvent(evtName, false, true);
+        }
+        if (theEvt && target[DISPATCH_EVENT]) {
+            target[DISPATCH_EVENT](theEvt);
+        }
+        else {
+            var handler = target["on" + evtName];
+            if (handler) {
+                handler(theEvt);
+            }
+            else {
+                var theConsole = getInst("console");
+                theConsole && (theConsole["error"] || theConsole["log"])(evtName, dumpObj(theEvt));
+            }
+        }
+    }
+
+    var STR_PROMISE = "Promise";
+
+    var NODE_UNHANDLED_REJECTION = "unhandledRejection";
+    var UNHANDLED_REJECTION = NODE_UNHANDLED_REJECTION.toLowerCase();
+    var _unhandledRejectionTimeout = 10;
+    var _hasPromiseRejectionEvent;
+    function dumpFnObj(value) {
+        if (isFunction(value)) {
+            return value.toString();
+        }
+        return dumpObj(value);
+    }
+    function _createPromise(newPromise, processor, executor) {
+        var additionalArgs = arrSlice(arguments, 3);
+        var _state = 0 ;
+        var _hasResolved = false;
+        var _settledValue;
+        var _queue = [];
+        var _handled = false;
+        var _unHandledRejectionHandler = null;
+        var _thePromise;
+        !_hasPromiseRejectionEvent && (_hasPromiseRejectionEvent = lazySafeGetInst(STR_PROMISE + "RejectionEvent"));
+        var _then = function (onResolved, onRejected) {
+            try {
+                _handled = true;
+                _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
+                _unHandledRejectionHandler = null;
+                var thenPromise = newPromise(function (resolve, reject) {
+                    _queue.push(function () {
+                        try {
+                            var handler = _state === 2  ? onResolved : onRejected;
+                            var value = isUndefined(handler) ? _settledValue : (isFunction(handler) ? handler(_settledValue) : handler);
+                            if (isPromiseLike(value)) {
+                                value.then(resolve, reject);
+                            }
+                            else if (handler) {
+                                resolve(value);
+                            }
+                            else if (_state === 3 ) {
+                                reject(value);
+                            }
+                            else {
+                                resolve(value);
+                            }
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    });
+                    if (_hasResolved) {
+                        _processQueue();
+                    }
+                }, additionalArgs);
+                return thenPromise;
+            }
+            finally {
+            }
+        };
+        var _catch = function (onRejected) {
+            return _then(undefined, onRejected);
+        };
+        var _finally = function (onFinally) {
+            var thenFinally = onFinally;
+            var catchFinally = onFinally;
+            if (isFunction(onFinally)) {
+                thenFinally = function (value) {
+                    onFinally && onFinally();
+                    return value;
+                };
+                catchFinally = function (reason) {
+                    onFinally && onFinally();
+                    throw reason;
+                };
+            }
+            return _then(thenFinally, catchFinally);
+        };
+        var _strState = function () {
+            return STRING_STATES[_state];
+        };
+        var _processQueue = function () {
+            if (_queue.length > 0) {
+                var pending = _queue.slice();
+                _queue = [];
+                _handled = true;
+                processor(pending);
+                _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
+                _unHandledRejectionHandler = null;
+            }
+        };
+        var _createSettleIfFn = function (newState, allowState) {
+            return function (theValue) {
+                if (_state === allowState) {
+                    if (newState === 2  && isPromiseLike(theValue)) {
+                        _state = 1 ;
+                        theValue.then(_createSettleIfFn(2 , 1 ), _createSettleIfFn(3 , 1 ));
+                        return;
+                    }
+                    _state = newState;
+                    _hasResolved = true;
+                    _settledValue = theValue;
+                    _processQueue();
+                    if (!_handled && newState === 3  && !_unHandledRejectionHandler) {
+                        _unHandledRejectionHandler = scheduleTimeout(_notifyUnhandledRejection, _unhandledRejectionTimeout);
+                    }
+                }
+            };
+        };
+        var _notifyUnhandledRejection = function () {
+            if (!_handled) {
+                if (isNode()) {
+                    process.emit(NODE_UNHANDLED_REJECTION, _settledValue, _thePromise);
+                }
+                else {
+                    var gbl = getWindow() || getGlobal();
+                    emitEvent(gbl, UNHANDLED_REJECTION, function (theEvt) {
+                        objDefine(theEvt, "promise", { g: function () { return _thePromise; } });
+                        theEvt.reason = _settledValue;
+                        return theEvt;
+                    }, !!_hasPromiseRejectionEvent.v);
+                }
+            }
+        };
+        _thePromise = {
+            then: _then,
+            "catch": _catch,
+            finally: _finally
+        };
+        objDefineProp(_thePromise, "state", {
+            get: _strState
+        });
+        if (hasSymbol()) {
+            _thePromise[getKnownSymbol(11 )] = "IPromise";
+        }
+        var _toString = function () {
+            return "IPromise" + ("") + " " + _strState() + (_hasResolved ? (" - " + dumpFnObj(_settledValue)) : "");
+        };
+        _thePromise.toString = _toString;
+        (function _initialize() {
+            if (!isFunction(executor)) {
+                throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpFnObj(executor));
+            }
+            var _rejectFn = _createSettleIfFn(3 , 0 );
+            try {
+                executor.call(_thePromise, _createSettleIfFn(2 , 0 ), _rejectFn);
+            }
+            catch (e) {
+                _rejectFn(e);
+            }
+        })();
+        return _thePromise;
+    }
+
+    var _processPendingItems = function (pending) {
+        arrForEach(pending, function (fn) {
+            try {
+                fn();
+            }
+            catch (e) {
+            }
+        });
+    };
+    function timeoutItemProcessor(timeout) {
+        var callbackTimeout = isNumber(timeout) ? timeout : 0;
+        return function (pending) {
+            scheduleTimeout(function () {
+                _processPendingItems(pending);
+            }, callbackTimeout);
+        };
+    }
+
+    function createAsyncPromise(executor, timeout) {
+        return _createPromise(createAsyncPromise, timeoutItemProcessor(timeout), executor, timeout);
+    }
+
+    var _isPromiseSupported;
+    function createNativePromise(executor, timeout) {
+        !_isPromiseSupported && (_isPromiseSupported = lazySafeGetInst(STR_PROMISE));
+        var PrmCls = _isPromiseSupported.v;
+        if (!PrmCls) {
+            return createAsyncPromise(executor);
+        }
+        if (!isFunction(executor)) {
+            throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpObj(executor));
+        }
+        var _state = 0 ;
+        function _strState() {
+            return STRING_STATES[_state];
+        }
+        var thePromise = new PrmCls(function (resolve, reject) {
+            function _resolve(value) {
+                _state = 2 ;
+                resolve(value);
+            }
+            function _reject(reason) {
+                _state = 3 ;
+                reject(reason);
+            }
+            executor(_resolve, _reject);
+        });
+        objDefineProp(thePromise, "state", {
+            get: _strState
+        });
+        return thePromise;
+    }
+
+    var _promiseCreator;
+    function createPromise(executor, timeout) {
+        !_promiseCreator && (_promiseCreator = getLazy(function () { return createNativePromise; }));
+        return _promiseCreator.v.call(this, executor, timeout);
+    }
+
     var UNDEFINED_VALUE = undefined;
-    var STR_EMPTY = "";
+    var STR_EMPTY$1 = "";
     var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
 
     var rCamelCase = /-([a-z])/g;
@@ -1080,7 +1440,7 @@
         if (isError(object)) {
             return object[_DYN_NAME$1 ];
         }
-        return STR_EMPTY;
+        return STR_EMPTY$1;
     }
     function createClassFromInterface(defaults) {
         return /** @class */ (function () {
@@ -1096,15 +1456,56 @@
         }());
     }
 
+    var strLocation = "location";
     var strConsole = "console";
     var strJSON = "JSON";
     var strCrypto = "crypto";
     var strMsCrypto = "msCrypto";
     var strMsie = "msie";
     var strTrident = "trident/";
+    var strXMLHttpRequest = "XMLHttpRequest";
     var _isTrident = null;
     var _navUserAgentCheck = null;
+    var _enableMocks = false;
+    var _useXDomainRequest = null;
     var _beaconsSupported = null;
+    function _hasProperty(theClass, property) {
+        var supported = false;
+        if (theClass) {
+            try {
+                supported = property in theClass;
+                if (!supported) {
+                    var proto = theClass[strShimPrototype];
+                    if (proto) {
+                        supported = property in proto;
+                    }
+                }
+            }
+            catch (e) {
+            }
+            if (!supported) {
+                try {
+                    var tmp = new theClass();
+                    supported = !isUndefined(tmp[property]);
+                }
+                catch (e) {
+                }
+            }
+        }
+        return supported;
+    }
+    function getLocation(checkForMock) {
+        if (checkForMock && _enableMocks) {
+            var mockLocation = getInst("__mockLocation");
+            if (mockLocation) {
+                return mockLocation;
+            }
+        }
+        if (typeof location === strShimObject && location) {
+            return location;
+        }
+        return getInst(strLocation);
+    }
     function getConsole() {
         if (typeof console !== strShimUndefined) {
             return console;
@@ -1130,7 +1531,7 @@
         var nav = getNavigator();
         if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
             _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-            var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
+            var userAgent = (_navUserAgentCheck || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ]();
             _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
         }
         return _isTrident;
@@ -1141,6 +1542,38 @@
         }
         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;
+    }
     function _getNamedValue(values, name) {
         if (values) {
             for (var i = 0; i < values[_DYN_LENGTH$1 ]; i++) {
@@ -1234,7 +1667,7 @@
         var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
         var number = random32() >>> 0;
         var chars = 0;
-        var result = STR_EMPTY;
+        var result = STR_EMPTY$1;
         while (result[_DYN_LENGTH$1 ] < maxLength) {
             chars++;
             result += base64chars.charAt(number & 0x3F);
@@ -1272,11 +1705,11 @@
     }
     function createUniqueNamespace(name, includeVersion) {
         if (includeVersion === void 0) { includeVersion = false; }
-        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
+        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY$1) + instanceName);
     }
     function createElmNodeData(name) {
         var data = {
-            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
+            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$1) + "." + version),
             accept: function (target) {
                 return _canAcceptData(target);
             },
@@ -1951,9 +2384,9 @@
         _a);
     function _sanitizeDiagnosticText(text) {
         if (text) {
-            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
+            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY$1) + "\"";
         }
-        return STR_EMPTY;
+        return STR_EMPTY$1;
     }
     function _logToConsole(func, message) {
         var theConsole = getConsole();
@@ -1975,12 +2408,12 @@
             _self[_DYN_MESSAGE$1 ] =
                 (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
                     msgId;
-            var strProps = STR_EMPTY;
+            var strProps = STR_EMPTY$1;
             if (hasJSON()) {
                 strProps = getJSON().stringify(properties);
             }
-            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +
-                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
+            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$1) +
+                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$1);
             _self[_DYN_MESSAGE$1 ] += diagnosticText;
         }
         _InternalLogMessage.dataType = "MessageData";
@@ -2116,7 +2549,7 @@
 
     function generateW3CId() {
         var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
-        var oct = STR_EMPTY, tmp;
+        var oct = STR_EMPTY$1, tmp;
         for (var a = 0; a < 4; a++) {
             tmp = random32();
             oct +=
@@ -2193,9 +2626,9 @@
             return null;
         }
         return _a = {
-                version: (match[1] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
-                traceId: (match[2] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ](),
-                spanId: (match[3] || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]()
+                version: (match[1] || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ](),
+                traceId: (match[2] || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ](),
+                spanId: (match[3] || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ]()
             },
             _a[_DYN_TRACE_FLAGS ] = parseInt(match[4], 16),
             _a;
@@ -2260,16 +2693,16 @@
     var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
     function _normalizeNamespace(name) {
         if (name && name[_DYN_REPLACE ]) {
-            return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY);
+            return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY$1);
         }
         return name;
     }
     function _getEvtNamespace(eventName, evtNamespace) {
         var _a;
         if (evtNamespace) {
-            var theNamespace_1 = STR_EMPTY;
+            var theNamespace_1 = STR_EMPTY$1;
             if (isArray(evtNamespace)) {
-                theNamespace_1 = STR_EMPTY;
+                theNamespace_1 = STR_EMPTY$1;
                 arrForEach(evtNamespace, function (name) {
                     name = _normalizeNamespace(name);
                     if (name) {
@@ -2287,13 +2720,13 @@
                 if (theNamespace_1[0] !== ".") {
                     theNamespace_1 = "." + theNamespace_1;
                 }
-                eventName = (eventName || STR_EMPTY) + theNamespace_1;
+                eventName = (eventName || STR_EMPTY$1) + theNamespace_1;
             }
         }
-        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);
+        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY$1) || []);
         return _a = {},
             _a[_DYN_TYPE ] = parsedEvent[1],
-            _a.ns = ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT$1 ](".").sort()).join("."),
+            _a.ns = ((parsedEvent[2] || STR_EMPTY$1).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$1)[_DYN_SPLIT$1 ](".").sort()).join("."),
             _a;
     }
     function _getRegisteredEvents(target, evtName, addDefault) {
@@ -2443,12 +2876,17 @@
     var _DYN_SPLIT = "split";
     var _DYN_LENGTH = "length";
     var _DYN_TO_LOWER_CASE = "toLowerCase";
+    var _DYN_LOCATION = "location";
     var _DYN_INGESTIONENDPOINT = "ingestionendpoint";
     var _DYN_TO_STRING = "toString";
     var _DYN_PUSH = "push";
+    var _DYN_URL_STRING = "urlString";
+    var _DYN_DATA = "data";
+    var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
+    var _DYN_REASON = "reason";
+    var _DYN_MESSAGE = "message";
     var _DYN_REMOVE_ITEM = "removeItem";
     var _DYN_NAME = "name";
-    var _DYN_MESSAGE = "message";
     var _DYN_COUNT = "count";
     var _DYN_PRE_TRIGGER_DATE = "preTriggerDate";
     var _DYN_DISABLED = "disabled";
@@ -2459,6 +2897,7 @@
     var _DYN_STRINGIFY = "stringify";
     var _DYN_PATHNAME = "pathname";
     var _DYN_CORRELATION_HEADER_E0 = "correlationHeaderExcludePatterns";
+    var _DYN_ITEMS_RECEIVED = "itemsReceived";
     var _DYN_EXTENSION_CONFIG = "extensionConfig";
     var _DYN_EXCEPTIONS = "exceptions";
     var _DYN_PARSED_STACK = "parsedStack";
@@ -2824,6 +3263,54 @@
             }
         };
     }
+    function getResponseText(xhr) {
+        try {
+            return xhr.responseText;
+        }
+        catch (e) {
+        }
+        return null;
+    }
+    function formatErrorMessageXdr(xdr, message) {
+        if (xdr) {
+            return "XDomainRequest,Response:" + getResponseText(xdr) || "";
+        }
+        return message;
+    }
+    function formatErrorMessageXhr(xhr, message) {
+        if (xhr) {
+            return "XMLHttpRequest,Status:" + xhr.status + ",Response:" + getResponseText(xhr) || xhr.response || "";
+        }
+        return message;
+    }
+    function prependTransports(theTransports, newTransports) {
+        if (newTransports) {
+            if (isNumber(newTransports)) {
+                theTransports = [newTransports].concat(theTransports);
+            }
+            else if (isArray(newTransports)) {
+                theTransports = newTransports.concat(theTransports);
+            }
+        }
+        return theTransports;
+    }
+    function parseResponse(response, diagLog) {
+        try {
+            if (response && response !== "") {
+                var result = getJSON().parse(response);
+                if (result && result[_DYN_ITEMS_RECEIVED ] && result[_DYN_ITEMS_RECEIVED ] >= result.itemsAccepted &&
+                    result.itemsReceived - result.itemsAccepted === result.errors[_DYN_LENGTH ]) {
+                    return result;
+                }
+            }
+        }
+        catch (e) {
+            _throwInternal(diagLog, 1 , 43 , "Cannot parse the response. " + getExceptionName(e), {
+                response: response
+            });
+        }
+        return null;
+    }
 
     var StorageType = createEnumStyle({
         LocalStorage: 0 ,
@@ -3330,7 +3817,7 @@
         }, {});
         if (objKeys(result)[_DYN_LENGTH ] > 0) {
             if (result.endpointsuffix) {
-                var locationPrefix = result.location ? result.location + "." : "";
+                var locationPrefix = result[_DYN_LOCATION ] ? result[_DYN_LOCATION ] + "." : "";
                 result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ] || ("https://" + locationPrefix + "dc." + result.endpointsuffix);
             }
             result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ] || DEFAULT_BREEZE_ENDPOINT;
@@ -3352,7 +3839,7 @@
             _self.sampleRate = 100.0;
             _self.tags = {};
             _self[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
-            _self.data = data;
+            _self[_DYN_DATA ] = data;
             _self.time = toISOString(new Date());
             _self.aiDataContract = {
                 time: 1 ,
@@ -3509,8 +3996,8 @@
                 else if (getWindow() && getWindow()["opera"] && errorObj[strMessage]) {
                     details = _getOperaStack(errorObj[_DYN_MESSAGE ]);
                 }
-                else if (errorObj["reason"] && errorObj.reason[strStack]) {
-                    details = _convertStackObj(errorObj.reason[strStack]);
+                else if (errorObj["reason"] && errorObj[_DYN_REASON ][strStack]) {
+                    details = _convertStackObj(errorObj[_DYN_REASON ][strStack]);
                 }
                 else if (isString(errorObj)) {
                     details = _convertStackObj(errorObj);
@@ -4001,7 +4488,7 @@
             _self.resultCode = resultCode + "";
             _self.type = dataSanitizeString(logger, requestAPI);
             var dependencyFields = AjaxHelperParseDependencyPath(logger, absoluteUrl, method, commandName);
-            _self.data = dataSanitizeUrl(logger, commandName) || dependencyFields.data;
+            _self[_DYN_DATA ] = dataSanitizeUrl(logger, commandName) || dependencyFields[_DYN_DATA ];
             _self.target = dataSanitizeString(logger, dependencyFields.target);
             if (correlationContext) {
                 _self.target = "".concat(_self.target, " | ").concat(correlationContext);
@@ -4216,7 +4703,7 @@
             _a);
         if (!isNullOrUndefined(customProperties)) {
             objForEachKey(customProperties, function (prop, value) {
-                telemetryItem.data[prop] = value;
+                telemetryItem[_DYN_DATA ][prop] = value;
             });
         }
         return telemetryItem;
@@ -4240,6 +4727,360 @@
     };
     var CtxTagKeys = new ContextTagKeys();
 
+    var STR_EMPTY = "";
+    var SenderPostManager = /** @class */ (function () {
+        function SenderPostManager() {
+            var _syncFetchPayload = 0;
+            var _enableSendPromise;
+            var _isInitialized;
+            var _diagLog;
+            var _isOneDs;
+            var _onCompleteFuncs;
+            var _disableCredentials;
+            var _fallbackInst;
+            var _disableXhr;
+            var _disableBeacon;
+            var _disableBeaconSync;
+            dynamicProto(SenderPostManager, this, function (_self, _base) {
+                var _sendCredentials = true;
+                _initDefaults();
+                _self.initialize = function (config, diagLog) {
+                    _diagLog = diagLog;
+                    if (_isInitialized) {
+                        _throwInternal(_diagLog, 1 , 28 , "Sender is already initialized");
+                    }
+                    _self.SetConfig(config);
+                    _isInitialized = true;
+                };
+                _self["_getDbgPlgTargets"] = function () {
+                    return [_isInitialized, _isOneDs, _disableCredentials, _enableSendPromise];
+                };
+                _self.SetConfig = function (config) {
+                    try {
+                        _onCompleteFuncs = config.senderOnCompleteCallBack || {};
+                        _disableCredentials = !!config.disableCredentials;
+                        _isOneDs = !!config.isOneDs;
+                        _enableSendPromise = !!config.enableSendPromise;
+                        _disableXhr = !!config.disableXhr;
+                        _disableBeacon = !!config.disableBeacon;
+                        _disableBeaconSync = !!config.disableBeaconSync;
+                        _fallbackInst = { sendPOST: _xhrSender };
+                        if (_disableCredentials) {
+                            var location_1 = getLocation();
+                            if (location_1 && location_1.protocol && location_1.protocol[_DYN_TO_LOWER_CASE ]() === "file:") {
+                                _sendCredentials = false;
+                            }
+                        }
+                        return true;
+                    }
+                    catch (e) {
+                    }
+                    return false;
+                };
+                _self.getSyncFetchPayload = function () {
+                    return _syncFetchPayload;
+                };
+                _self.getXhrInst = function (transports, sync) {
+                    if (transports && transports[_DYN_LENGTH ]) {
+                        return _getSenderInterface(transports, sync);
+                    }
+                    return null;
+                };
+                _self.getFallbackInst = function () {
+                    return _fallbackInst;
+                };
+                _self._doTeardown = function (unloadCtx, unloadState) {
+                    _initDefaults();
+                };
+                function _onSuccess(res, onComplete) {
+                    _doOnComplete(onComplete, 200, {}, res);
+                }
+                function _onError(message, onComplete) {
+                    _throwInternal(_diagLog, 2 , 26 , "Failed to send telemetry.", { message: message });
+                    _doOnComplete(onComplete, 400, {});
+                }
+                function _onNoPayloadUrl(onComplete) {
+                    _onError("No endpoint url is provided for the batch", onComplete);
+                }
+                function _getSenderInterface(transports, syncSupport) {
+                    var transportType = null;
+                    var sendPostFunc = null;
+                    var lp = 0;
+                    while (sendPostFunc == null && lp < transports[_DYN_LENGTH ]) {
+                        transportType = transports[lp];
+                        if (!_disableXhr && transportType === 1 ) {
+                            if (useXDomainRequest()) {
+                                sendPostFunc = _xdrSender;
+                            }
+                            else if (isXhrSupported()) {
+                                sendPostFunc = _xhrSender;
+                            }
+                        }
+                        else if (transportType === 2  && isFetchSupported(syncSupport)) {
+                            sendPostFunc = _doFetchSender;
+                        }
+                        else if (transportType === 3  && isBeaconsSupported() && (syncSupport ? !_disableBeaconSync : !_disableBeacon)) {
+                            sendPostFunc = _beaconSender;
+                        }
+                        lp++;
+                    }
+                    if (sendPostFunc) {
+                        return {
+                            sendPOST: sendPostFunc
+                        };
+                    }
+                    return null;
+                }
+                function _doOnComplete(oncomplete, status, headers, response) {
+                    try {
+                        oncomplete && oncomplete(status, headers, response);
+                    }
+                    catch (e) {
+                    }
+                }
+                function _doBeaconSend(payload, oncomplete) {
+                    var nav = getNavigator();
+                    var url = payload[_DYN_URL_STRING ];
+                    if (!url) {
+                        _onNoPayloadUrl(oncomplete);
+                        return true;
+                    }
+                    var data = payload[_DYN_DATA ];
+                    var plainTextBatch = new Blob([data], { type: "text/plain;charset=UTF-8" });
+                    var queued = nav.sendBeacon(url, plainTextBatch);
+                    return queued;
+                }
+                function _beaconSender(payload, oncomplete, sync) {
+                    var data = payload[_DYN_DATA ];
+                    if (data) {
+                        if (!_doBeaconSend(payload, oncomplete)) {
+                            var onRetry = _onCompleteFuncs && _onCompleteFuncs.beaconOnRetry;
+                            if (onRetry && isFunction(onRetry)) {
+                                onRetry(payload, oncomplete, _doBeaconSend);
+                            }
+                            else {
+                                _fallbackInst && _fallbackInst.sendPOST(payload, oncomplete, true);
+                                _throwInternal(_diagLog, 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                            }
+                        }
+                        else {
+                            _onSuccess(null, oncomplete);
+                        }
+                    }
+                    return;
+                }
+                function _xhrSender(payload, oncomplete, sync) {
+                    var thePromise;
+                    var resolveFunc;
+                    var rejectFunc;
+                    var headers = payload.headers || {};
+                    if (!sync && _enableSendPromise) {
+                        thePromise = createPromise(function (resolve, reject) {
+                            resolveFunc = resolve;
+                            rejectFunc = reject;
+                        });
+                    }
+                    var xhr = new XMLHttpRequest();
+                    var endPointUrl = payload[_DYN_URL_STRING ];
+                    if (!endPointUrl) {
+                        _onNoPayloadUrl(oncomplete);
+                        resolveFunc && resolveFunc(false);
+                        return;
+                    }
+                    try {
+                        xhr[DisabledPropertyName] = true;
+                    }
+                    catch (e) {
+                    }
+                    xhr.open("POST", endPointUrl, !sync);
+                    xhr[_DYN_SET_REQUEST_HEADER ]("Content-type", "application/json");
+                    if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
+                        xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[6 ], RequestHeaders[7 ]);
+                    }
+                    arrForEach(objKeys(headers), function (headerName) {
+                        xhr[_DYN_SET_REQUEST_HEADER ](headerName, headers[headerName]);
+                    });
+                    xhr.onreadystatechange = function () {
+                        var response = getResponseText(xhr);
+                        var onReadyFunc = _onCompleteFuncs && _onCompleteFuncs.xhrOnComplete;
+                        var onReadyFuncExist = onReadyFunc && isFunction(onReadyFunc);
+                        if (onReadyFuncExist) {
+                            onReadyFunc(xhr, oncomplete, payload);
+                        }
+                        if (xhr.readyState === 4) {
+                            if (!onReadyFuncExist) {
+                                _doOnComplete(oncomplete, xhr.status, {}, response);
+                            }
+                            resolveFunc && resolveFunc(true);
+                        }
+                    };
+                    xhr.onerror = function (event) {
+                        _doOnComplete(oncomplete, 400, {}, formatErrorMessageXhr(xhr));
+                        rejectFunc && rejectFunc(event);
+                    };
+                    xhr.ontimeout = function () {
+                        _doOnComplete(oncomplete, 500, {}, formatErrorMessageXhr(xhr));
+                        resolveFunc && resolveFunc(false);
+                    };
+                    xhr.send(payload[_DYN_DATA ]);
+                    return thePromise;
+                }
+                function _doFetchSender(payload, oncomplete, sync) {
+                    var _a;
+                    var endPointUrl = payload[_DYN_URL_STRING ];
+                    var batch = payload[_DYN_DATA ];
+                    var plainTextBatch = new Blob([batch], { type: "application/json" });
+                    var thePromise;
+                    var resolveFunc;
+                    var rejectFunc;
+                    var requestHeaders = new Headers();
+                    var batchLength = batch[_DYN_LENGTH ];
+                    var ignoreResponse = false;
+                    var responseHandled = false;
+                    var headers = payload.headers || {};
+                    if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
+                        requestHeaders.append(RequestHeaders[6 ], RequestHeaders[7 ]);
+                    }
+                    arrForEach(objKeys(headers), function (headerName) {
+                        requestHeaders.append(headerName, headers[headerName]);
+                    });
+                    var init = (_a = {
+                            method: "POST",
+                            headers: requestHeaders,
+                            body: plainTextBatch
+                        },
+                        _a[DisabledPropertyName] = true
+                    ,
+                        _a);
+                    if (_sendCredentials && _isOneDs) {
+                        init.credentials = "include";
+                    }
+                    if (sync) {
+                        init.keepalive = true;
+                        ignoreResponse = true;
+                        _syncFetchPayload += batchLength;
+                    }
+                    var request = new Request(endPointUrl, init);
+                    try {
+                        request[DisabledPropertyName] = true;
+                    }
+                    catch (e) {
+                    }
+                    if (!sync && _enableSendPromise) {
+                        thePromise = createPromise(function (resolve, reject) {
+                            resolveFunc = resolve;
+                            rejectFunc = reject;
+                        });
+                    }
+                    if (!endPointUrl) {
+                        _onNoPayloadUrl(oncomplete);
+                        resolveFunc && resolveFunc(false);
+                        return;
+                    }
+                    try {
+                        doAwaitResponse(fetch(request), function (result) {
+                            if (sync) {
+                                _syncFetchPayload -= batchLength;
+                                batchLength = 0;
+                            }
+                            if (!responseHandled) {
+                                responseHandled = true;
+                                if (!result.rejected) {
+                                    var response_1 = result.value;
+                                    if (!response_1.ok) {
+                                        _doOnComplete(oncomplete, 400, {}, response_1.statusText);
+                                        resolveFunc && resolveFunc(false);
+                                    }
+                                    else {
+                                        doAwaitResponse(response_1.text(), function (resp) {
+                                            var status = response_1.status;
+                                            var onCompleteFunc = _onCompleteFuncs.fetchOnComplete;
+                                            if (onCompleteFunc && isFunction(onCompleteFunc)) {
+                                                onCompleteFunc(response_1, oncomplete, resp.value || STR_EMPTY, payload);
+                                            }
+                                            else {
+                                                _doOnComplete(oncomplete, status, {}, resp.value || STR_EMPTY);
+                                            }
+                                            resolveFunc && resolveFunc(true);
+                                        });
+                                    }
+                                }
+                                else {
+                                    _doOnComplete(oncomplete, 400, {}, result[_DYN_REASON ] && result[_DYN_REASON ][_DYN_MESSAGE ]);
+                                    rejectFunc && rejectFunc(result[_DYN_REASON ]);
+                                }
+                            }
+                        });
+                    }
+                    catch (e) {
+                        if (!responseHandled) {
+                            _doOnComplete(oncomplete, 400, {}, dumpObj(e));
+                            rejectFunc && rejectFunc(e);
+                        }
+                    }
+                    if (ignoreResponse && !responseHandled) {
+                        responseHandled = true;
+                        _doOnComplete(oncomplete, 200, {});
+                        resolveFunc && resolveFunc(true);
+                    }
+                    return thePromise;
+                }
+                function _xdrSender(payload, oncomplete, sync) {
+                    var _window = getWindow();
+                    var xdr = new XDomainRequest();
+                    var data = payload[_DYN_DATA ];
+                    xdr.onload = function () {
+                        var response = getResponseText(xdr);
+                        var onloadFunc = _onCompleteFuncs && _onCompleteFuncs.xdrOnComplete;
+                        if (onloadFunc && isFunction(onloadFunc)) {
+                            onloadFunc(xdr, oncomplete, payload);
+                        }
+                        else {
+                            _doOnComplete(oncomplete, 200, {}, response);
+                        }
+                    };
+                    xdr.onerror = function () {
+                        _doOnComplete(oncomplete, 400, {}, formatErrorMessageXdr(xdr));
+                    };
+                    xdr.ontimeout = function () {
+                        _doOnComplete(oncomplete, 500, {});
+                    };
+                    xdr.onprogress = function () { };
+                    var hostingProtocol = _window && _window[_DYN_LOCATION ] && _window[_DYN_LOCATION ].protocol || "";
+                    var endpoint = payload[_DYN_URL_STRING ];
+                    if (!endpoint) {
+                        _onNoPayloadUrl(oncomplete);
+                        return;
+                    }
+                    if (endpoint.lastIndexOf(hostingProtocol, 0) !== 0) {
+                        var msg = "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.";
+                        _throwInternal(_diagLog, 2 , 40 , ". " + msg);
+                        _onError(msg, oncomplete);
+                        return;
+                    }
+                    var endpointUrl = endpoint.replace(/^(https?:)/, "");
+                    xdr.open("POST", endpointUrl);
+                    xdr.send(data);
+                }
+                function _initDefaults() {
+                    _syncFetchPayload = 0;
+                    _isInitialized = false;
+                    _enableSendPromise = false;
+                    _diagLog = null;
+                    _isOneDs = null;
+                    _onCompleteFuncs = null;
+                    _disableCredentials = null;
+                    _fallbackInst = null;
+                    _disableXhr = false;
+                    _disableBeacon = false;
+                    _disableBeaconSync = false;
+                }
+            });
+        }
+        SenderPostManager.__ieDyn=1;
+        return SenderPostManager;
+    }());
+
     function createDomEvent(eventName) {
         var event = null;
         if (isFunction(Event)) {
@@ -4400,6 +5241,7 @@
     exports.RemoteDependencyData = RemoteDependencyData;
     exports.RequestHeaders = RequestHeaders;
     exports.SampleRate = SampleRate;
+    exports.SenderPostManager = SenderPostManager;
     exports.SeverityLevel = SeverityLevel;
     exports.TelemetryItemCreator = TelemetryItemCreator;
     exports.ThrottleMgr = ThrottleMgr;
@@ -4428,8 +5270,11 @@
     exports.dateTimeUtilsNow = dateTimeUtilsNow;
     exports.dsPadNumber = dsPadNumber;
     exports.findW3cTraceParent = findW3cTraceParent;
+    exports.formatErrorMessageXdr = formatErrorMessageXdr;
+    exports.formatErrorMessageXhr = formatErrorMessageXhr;
     exports.formatTraceParent = formatTraceParent;
     exports.getExtensionByName = getExtensionByName;
+    exports.getResponseText = getResponseText;
     exports.isBeaconApiSupported = isBeaconsSupported;
     exports.isCrossOriginError = isCrossOriginError;
     exports.isInternalApplicationInsightsEndpoint = isInternalApplicationInsightsEndpoint;
@@ -4439,7 +5284,9 @@
     exports.isValidTraceParent = isValidTraceParent;
     exports.msToTimeSpan = msToTimeSpan;
     exports.parseConnectionString = parseConnectionString;
+    exports.parseResponse = parseResponse;
     exports.parseTraceParent = parseTraceParent;
+    exports.prependTransports = prependTransports;
     exports.strNotSpecified = strNotSpecified;
     exports.stringToBoolOrDefault = stringToBoolOrDefault;
     exports.urlGetAbsoluteUrl = urlGetAbsoluteUrl;