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

package/dist/es5/applicationinsights-common.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Common, 3.1.1-nightly3.2403-03
+ * Application Insights JavaScript SDK - Common, 3.1.1
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -86,12 +86,7 @@
         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;
 
@@ -163,10 +158,6 @@
         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) {
@@ -180,22 +171,6 @@
         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";
@@ -298,7 +273,6 @@
         }
         return _polySymbols;
     }
-    var _wellKnownSymbolCache;
     /*#__NO_SIDE_EFFECTS__*/
     function polyNewSymbol(description) {
         var theSymbol = {
@@ -320,16 +294,6 @@
         }
         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",
@@ -407,7 +371,6 @@
     var _cachedWindow;
     var _cachedDocument;
     var _cachedNavigator;
-    var _isNode;
     /*#__NO_SIDE_EFFECTS__*/
     function lazySafeGetInst(name) {
         return getLazy(function () { return safe((getInst), [name]).v || UNDEF_VALUE; });
@@ -455,10 +418,6 @@
         (!_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;
@@ -469,23 +428,6 @@
         }
     }
     /*#__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();
@@ -517,8 +459,6 @@
 
     var arrMap = ( /*#__PURE__*/_unwrapFunction("map", ArrProto));
 
-    var arrSlice = ( /*#__PURE__*/_unwrapFunction(SLICE, ArrProto));
-
     var arrReduce = ( /*#__PURE__*/_unwrapFunction("reduce", ArrProto));
 
     var objCreate = ObjClass$1["create"] || polyObjCreate;
@@ -1104,408 +1044,35 @@
     }
     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$1 = "";
+    var STR_EMPTY = "";
     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;
+    var _aiNamespace = null;
+    function _getExtensionNamespace() {
+        var target = getInst("Microsoft");
+        if (target) {
+            _aiNamespace = target["ApplicationInsights"];
         }
-        return false;
-    }
-    function toISOString(date) {
-        return date && date.toISOString() || "";
+        return _aiNamespace;
     }
-    function getExceptionName(object) {
-        if (isError(object)) {
-            return object[_DYN_NAME$1 ];
+    function getDebugExt(config) {
+        var ns = _aiNamespace;
+        if (!ns && config.disableDbgExt !== true) {
+            ns = _aiNamespace || _getExtensionNamespace();
         }
-        return STR_EMPTY$1;
-    }
-    function createClassFromInterface(defaults) {
-        return /** @class */ (function () {
-            function class_1() {
-                var _this = this;
-                if (defaults) {
-                    objForEachKey(defaults, function (field, value) {
-                        _this[field] = value;
-                    });
-                }
-            }
-            return class_1;
-        }());
+        return ns ? ns["ChromeDbgExt"] : null;
     }
 
-    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;
@@ -1531,7 +1098,7 @@
         var nav = getNavigator();
         if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
             _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-            var userAgent = (_navUserAgentCheck || STR_EMPTY$1)[_DYN_TO_LOWER_CASE$1 ]();
+            var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
             _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
         }
         return _isTrident;
@@ -1542,38 +1109,6 @@
         }
         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++) {
@@ -1604,34 +1139,264 @@
         return value;
     }
 
-    var UInt32Mask = 0x100000000;
-    var MaxUInt32 = 0xffffffff;
-    var SEED1 = 123456789;
-    var SEED2 = 987654321;
-    var _mwcSeeded = false;
-    var _mwcW = SEED1;
-    var _mwcZ = SEED2;
-    function _mwcSeed(seedValue) {
-        if (seedValue < 0) {
-            seedValue >>>= 0;
-        }
-        _mwcW = (SEED1 + seedValue) & MaxUInt32;
-        _mwcZ = (SEED2 - seedValue) & MaxUInt32;
-        _mwcSeeded = true;
-    }
-    function _autoSeedMwc() {
-        try {
-            var now = utcNow() & 0x7fffffff;
-            _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
-        }
-        catch (e) {
+    var _a;
+    var STR_WARN_TO_CONSOLE = "warnToConsole";
+    var AiNonUserActionablePrefix = "AI (Internal): ";
+    var AiUserActionablePrefix = "AI: ";
+    var AIInternalMessagePrefix = "AITR_";
+    var defaultValues = {
+        loggingLevelConsole: 0,
+        loggingLevelTelemetry: 1,
+        maxMessageLimit: 25,
+        enableDebug: false
+    };
+    var _logFuncs = (_a = {},
+        _a[0 ] = null,
+        _a[1 ] = "errorToConsole",
+        _a[2 ] = STR_WARN_TO_CONSOLE,
+        _a[3 ] = "debugToConsole",
+        _a);
+    function _sanitizeDiagnosticText(text) {
+        if (text) {
+            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
         }
+        return STR_EMPTY;
     }
-    function randomValue(maxValue) {
-        if (maxValue > 0) {
-            return Math.floor((random32() / MaxUInt32) * (maxValue + 1)) >>> 0;
-        }
-        return 0;
+    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$1 ] =
+                (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
+                    msgId;
+            var strProps = STR_EMPTY;
+            if (hasJSON()) {
+                strProps = getJSON().stringify(properties);
+            }
+            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +
+                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
+            _self[_DYN_MESSAGE$1 ] += 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$1 ])) {
+                            if (isUserAct) {
+                                var messageKey = +message[_DYN_MESSAGE_ID ];
+                                if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
+                                    _self[logFunc](message[_DYN_MESSAGE$1 ]);
+                                    _messageLogged[messageKey] = true;
+                                }
+                            }
+                            else {
+                                if (_loggingLevelConsole >= severity) {
+                                    _self[logFunc](message[_DYN_MESSAGE$1 ]);
+                                }
+                            }
+                            _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, _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);
+    }
+
+    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 toISOString(date) {
+        return date && date.toISOString() || "";
+    }
+    function getExceptionName(object) {
+        if (isError(object)) {
+            return object[_DYN_NAME$1 ];
+        }
+        return STR_EMPTY;
+    }
+    function createClassFromInterface(defaults) {
+        return /** @class */ (function () {
+            function class_1() {
+                var _this = this;
+                if (defaults) {
+                    objForEachKey(defaults, function (field, value) {
+                        _this[field] = value;
+                    });
+                }
+            }
+            return class_1;
+        }());
+    }
+
+    var UInt32Mask = 0x100000000;
+    var MaxUInt32 = 0xffffffff;
+    var SEED1 = 123456789;
+    var SEED2 = 987654321;
+    var _mwcSeeded = false;
+    var _mwcW = SEED1;
+    var _mwcZ = SEED2;
+    function _mwcSeed(seedValue) {
+        if (seedValue < 0) {
+            seedValue >>>= 0;
+        }
+        _mwcW = (SEED1 + seedValue) & MaxUInt32;
+        _mwcZ = (SEED2 - seedValue) & MaxUInt32;
+        _mwcSeeded = true;
+    }
+    function _autoSeedMwc() {
+        try {
+            var now = utcNow() & 0x7fffffff;
+            _mwcSeed(((Math.random() * UInt32Mask) ^ now) + now);
+        }
+        catch (e) {
+        }
+    }
+    function randomValue(maxValue) {
+        if (maxValue > 0) {
+            return Math.floor((random32() / MaxUInt32) * (maxValue + 1)) >>> 0;
+        }
+        return 0;
     }
     function random32(signed) {
         var value = 0;
@@ -1667,7 +1432,7 @@
         var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
         var number = random32() >>> 0;
         var chars = 0;
-        var result = STR_EMPTY$1;
+        var result = STR_EMPTY;
         while (result[_DYN_LENGTH$1 ] < maxLength) {
             chars++;
             result += base64chars.charAt(number & 0x3F);
@@ -1705,11 +1470,11 @@
     }
     function createUniqueNamespace(name, includeVersion) {
         if (includeVersion === void 0) { includeVersion = false; }
-        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY$1) + instanceName);
+        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
     }
     function createElmNodeData(name) {
         var data = {
-            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$1) + "." + version),
+            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
             accept: function (target) {
                 return _canAcceptData(target);
             },
@@ -2242,314 +2007,116 @@
         state.use(handler, configHandler);
         return handler;
     }
-    function _createDynamicHandler(logger, target, inPlace) {
-        var _a;
-        var dynamicHandler = getDynamicConfigHandler(target);
-        if (dynamicHandler) {
-            return dynamicHandler;
-        }
-        var uid = createUniqueNamespace("dyncfg", true);
-        var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
-        var theState;
-        function _notifyWatchers() {
-            theState[_DYN_NOTIFY ]();
-        }
-        function _setValue(target, name, value) {
-            try {
-                target = _setDynamicProperty(theState, target, name, value);
-            }
-            catch (e) {
-                _throwDynamicError(logger, name, "Setting value", e);
-            }
-            return target[name];
-        }
-        function _watch(configHandler) {
-            return _createAndUseHandler(theState, configHandler);
-        }
-        function _block(configHandler, allowUpdate) {
-            theState.use(null, function (details) {
-                var prevUpd = theState.upd;
-                try {
-                    if (!isUndefined(allowUpdate)) {
-                        theState.upd = allowUpdate;
-                    }
-                    configHandler(details);
-                }
-                finally {
-                    theState.upd = prevUpd;
-                }
-            });
-        }
-        function _ref(target, name) {
-            var _a;
-            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[0 ] = true, _a))[name];
-        }
-        function _rdOnly(target, name) {
-            var _a;
-            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[1 ] = true, _a))[name];
-        }
-        function _blkPropValue(target, name) {
-            var _a;
-            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[2 ] = true, _a))[name];
-        }
-        function _applyDefaults(theConfig, defaultValues) {
-            if (defaultValues) {
-                objForEachKey(defaultValues, function (name, value) {
-                    _applyDefaultValue(cfgHandler, theConfig, name, value);
-                });
-            }
-            return theConfig;
-        }
-        var cfgHandler = (_a = {
-                uid: null,
-                cfg: newTarget
-            },
-            _a[_DYN_LOGGER ] = logger,
-            _a[_DYN_NOTIFY ] = _notifyWatchers,
-            _a.set = _setValue,
-            _a[_DYN_SET_DF ] = _applyDefaults,
-            _a[_DYN_WATCH ] = _watch,
-            _a.ref = _ref,
-            _a[_DYN_RD_ONLY ] = _rdOnly,
-            _a[_DYN_BLK_VAL ] = _blkPropValue,
-            _a._block = _block,
-            _a);
-        objDefine(cfgHandler, "uid", {
-            c: false,
-            e: false,
-            w: false,
-            v: uid
-        });
-        theState = _createState(cfgHandler);
-        _makeDynamicObject(theState, newTarget, "config", "Creating");
-        return cfgHandler;
-    }
-    function _logInvalidAccess(logger, message) {
-        if (logger) {
-            logger[_DYN_WARN_TO_CONSOLE ](message);
-            logger[_DYN_THROW_INTERNAL ](2 , 108 , message);
-        }
-        else {
-            throwInvalidAccess(message);
-        }
-    }
-    function createDynamicConfig(config, defaultConfig, logger, inPlace) {
-        var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
-        if (defaultConfig) {
-            dynamicHandler[_DYN_SET_DF ](dynamicHandler.cfg, defaultConfig);
-        }
-        return dynamicHandler;
-    }
-    function onConfigChange(config, configHandler, logger) {
-        var handler = config[CFG_HANDLER_LINK] || config;
-        if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
-            return handler[_DYN_WATCH ](configHandler);
-        }
-        _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
-        return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
-    }
-
-    var _aiNamespace = null;
-    function _getExtensionNamespace() {
-        var target = getInst("Microsoft");
-        if (target) {
-            _aiNamespace = target["ApplicationInsights"];
-        }
-        return _aiNamespace;
-    }
-    function getDebugExt(config) {
-        var ns = _aiNamespace;
-        if (!ns && config.disableDbgExt !== true) {
-            ns = _aiNamespace || _getExtensionNamespace();
-        }
-        return ns ? ns["ChromeDbgExt"] : null;
-    }
-
-    var _a;
-    var STR_WARN_TO_CONSOLE = "warnToConsole";
-    var AiNonUserActionablePrefix = "AI (Internal): ";
-    var AiUserActionablePrefix = "AI: ";
-    var AIInternalMessagePrefix = "AITR_";
-    var defaultValues = {
-        loggingLevelConsole: 0,
-        loggingLevelTelemetry: 1,
-        maxMessageLimit: 25,
-        enableDebug: false
-    };
-    var _logFuncs = (_a = {},
-        _a[0 ] = null,
-        _a[1 ] = "errorToConsole",
-        _a[2 ] = STR_WARN_TO_CONSOLE,
-        _a[3 ] = "debugToConsole",
-        _a);
-    function _sanitizeDiagnosticText(text) {
-        if (text) {
-            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY$1) + "\"";
-        }
-        return STR_EMPTY$1;
-    }
-    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$1 ] =
-                (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
-                    msgId;
-            var strProps = STR_EMPTY$1;
-            if (hasJSON()) {
-                strProps = getJSON().stringify(properties);
-            }
-            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$1) +
-                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$1);
-            _self[_DYN_MESSAGE$1 ] += 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$1 ])) {
-                            if (isUserAct) {
-                                var messageKey = +message[_DYN_MESSAGE_ID ];
-                                if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
-                                    _self[logFunc](message[_DYN_MESSAGE$1 ]);
-                                    _messageLogged[messageKey] = true;
-                                }
-                            }
-                            else {
-                                if (_loggingLevelConsole >= severity) {
-                                    _self[logFunc](message[_DYN_MESSAGE$1 ]);
-                                }
-                            }
-                            _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 _createDynamicHandler(logger, target, inPlace) {
+        var _a;
+        var dynamicHandler = getDynamicConfigHandler(target);
+        if (dynamicHandler) {
+            return dynamicHandler;
+        }
+        var uid = createUniqueNamespace("dyncfg", true);
+        var newTarget = (target && inPlace !== false) ? target : _cfgDeepCopy(target);
+        var theState;
+        function _notifyWatchers() {
+            theState[_DYN_NOTIFY ]();
+        }
+        function _setValue(target, name, value) {
+            try {
+                target = _setDynamicProperty(theState, target, name, value);
+            }
+            catch (e) {
+                _throwDynamicError(logger, name, "Setting value", e);
+            }
+            return target[name];
+        }
+        function _watch(configHandler) {
+            return _createAndUseHandler(theState, configHandler);
+        }
+        function _block(configHandler, allowUpdate) {
+            theState.use(null, function (details) {
+                var prevUpd = theState.upd;
+                try {
+                    if (!isUndefined(allowUpdate)) {
+                        theState.upd = allowUpdate;
                     }
+                    configHandler(details);
                 }
-                function _setDefaultsFromConfig(config) {
-                    return onConfigChange(createDynamicConfig(config, defaultValues, _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);
-                    }
+                finally {
+                    theState.upd = prevUpd;
                 }
             });
         }
-        DiagnosticLogger.__ieDyn=1;
-        return DiagnosticLogger;
-    }());
-    function _getLogger(logger) {
-        return (logger || new DiagnosticLogger());
+        function _ref(target, name) {
+            var _a;
+            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[0 ] = true, _a))[name];
+        }
+        function _rdOnly(target, name) {
+            var _a;
+            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[1 ] = true, _a))[name];
+        }
+        function _blkPropValue(target, name) {
+            var _a;
+            return _setDynamicPropertyState(theState, target, name, (_a = {}, _a[2 ] = true, _a))[name];
+        }
+        function _applyDefaults(theConfig, defaultValues) {
+            if (defaultValues) {
+                objForEachKey(defaultValues, function (name, value) {
+                    _applyDefaultValue(cfgHandler, theConfig, name, value);
+                });
+            }
+            return theConfig;
+        }
+        var cfgHandler = (_a = {
+                uid: null,
+                cfg: newTarget
+            },
+            _a[_DYN_LOGGER ] = logger,
+            _a[_DYN_NOTIFY ] = _notifyWatchers,
+            _a.set = _setValue,
+            _a[_DYN_SET_DF ] = _applyDefaults,
+            _a[_DYN_WATCH ] = _watch,
+            _a.ref = _ref,
+            _a[_DYN_RD_ONLY ] = _rdOnly,
+            _a[_DYN_BLK_VAL ] = _blkPropValue,
+            _a._block = _block,
+            _a);
+        objDefine(cfgHandler, "uid", {
+            c: false,
+            e: false,
+            w: false,
+            v: uid
+        });
+        theState = _createState(cfgHandler);
+        _makeDynamicObject(theState, newTarget, "config", "Creating");
+        return cfgHandler;
     }
-    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 _logInvalidAccess(logger, message) {
+        if (logger) {
+            logger[_DYN_WARN_TO_CONSOLE ](message);
+            logger[_DYN_THROW_INTERNAL ](2 , 108 , message);
+        }
+        else {
+            throwInvalidAccess(message);
+        }
+    }
+    function createDynamicConfig(config, defaultConfig, logger, inPlace) {
+        var dynamicHandler = _createDynamicHandler(logger, config || {}, inPlace);
+        if (defaultConfig) {
+            dynamicHandler[_DYN_SET_DF ](dynamicHandler.cfg, defaultConfig);
+        }
+        return dynamicHandler;
+    }
+    function onConfigChange(config, configHandler, logger) {
+        var handler = config[CFG_HANDLER_LINK] || config;
+        if (handler.cfg && (handler.cfg === config || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+            return handler[_DYN_WATCH ](configHandler);
+        }
+        _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
+        return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
     }
 
     function generateW3CId() {
         var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
-        var oct = STR_EMPTY$1, tmp;
+        var oct = STR_EMPTY, tmp;
         for (var a = 0; a < 4; a++) {
             tmp = random32();
             oct +=
@@ -2626,9 +2193,9 @@
             return null;
         }
         return _a = {
-                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 ]()
+                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 ]()
             },
             _a[_DYN_TRACE_FLAGS ] = parseInt(match[4], 16),
             _a;
@@ -2693,16 +2260,16 @@
     var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
     function _normalizeNamespace(name) {
         if (name && name[_DYN_REPLACE ]) {
-            return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY$1);
+            return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY);
         }
         return name;
     }
     function _getEvtNamespace(eventName, evtNamespace) {
         var _a;
         if (evtNamespace) {
-            var theNamespace_1 = STR_EMPTY$1;
+            var theNamespace_1 = STR_EMPTY;
             if (isArray(evtNamespace)) {
-                theNamespace_1 = STR_EMPTY$1;
+                theNamespace_1 = STR_EMPTY;
                 arrForEach(evtNamespace, function (name) {
                     name = _normalizeNamespace(name);
                     if (name) {
@@ -2720,13 +2287,13 @@
                 if (theNamespace_1[0] !== ".") {
                     theNamespace_1 = "." + theNamespace_1;
                 }
-                eventName = (eventName || STR_EMPTY$1) + theNamespace_1;
+                eventName = (eventName || STR_EMPTY) + theNamespace_1;
             }
         }
-        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY$1) || []);
+        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);
         return _a = {},
             _a[_DYN_TYPE ] = parsedEvent[1],
-            _a.ns = ((parsedEvent[2] || STR_EMPTY$1).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$1)[_DYN_SPLIT$1 ](".").sort()).join("."),
+            _a.ns = ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT$1 ](".").sort()).join("."),
             _a;
     }
     function _getRegisteredEvents(target, evtName, addDefault) {
@@ -2876,17 +2443,12 @@
     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";
@@ -2897,7 +2459,6 @@
     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";
@@ -3263,54 +2824,6 @@
             }
         };
     }
-    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 ,
@@ -3817,7 +3330,7 @@
         }, {});
         if (objKeys(result)[_DYN_LENGTH ] > 0) {
             if (result.endpointsuffix) {
-                var locationPrefix = result[_DYN_LOCATION ] ? result[_DYN_LOCATION ] + "." : "";
+                var locationPrefix = result.location ? result.location + "." : "";
                 result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ] || ("https://" + locationPrefix + "dc." + result.endpointsuffix);
             }
             result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ] || DEFAULT_BREEZE_ENDPOINT;
@@ -3839,7 +3352,7 @@
             _self.sampleRate = 100.0;
             _self.tags = {};
             _self[_DYN_NAME ] = dataSanitizeString(logger, name) || strNotSpecified;
-            _self[_DYN_DATA ] = data;
+            _self.data = data;
             _self.time = toISOString(new Date());
             _self.aiDataContract = {
                 time: 1 ,
@@ -3996,8 +3509,8 @@
                 else if (getWindow() && getWindow()["opera"] && errorObj[strMessage]) {
                     details = _getOperaStack(errorObj[_DYN_MESSAGE ]);
                 }
-                else if (errorObj["reason"] && errorObj[_DYN_REASON ][strStack]) {
-                    details = _convertStackObj(errorObj[_DYN_REASON ][strStack]);
+                else if (errorObj["reason"] && errorObj.reason[strStack]) {
+                    details = _convertStackObj(errorObj.reason[strStack]);
                 }
                 else if (isString(errorObj)) {
                     details = _convertStackObj(errorObj);
@@ -4488,7 +4001,7 @@
             _self.resultCode = resultCode + "";
             _self.type = dataSanitizeString(logger, requestAPI);
             var dependencyFields = AjaxHelperParseDependencyPath(logger, absoluteUrl, method, commandName);
-            _self[_DYN_DATA ] = dataSanitizeUrl(logger, commandName) || dependencyFields[_DYN_DATA ];
+            _self.data = dataSanitizeUrl(logger, commandName) || dependencyFields.data;
             _self.target = dataSanitizeString(logger, dependencyFields.target);
             if (correlationContext) {
                 _self.target = "".concat(_self.target, " | ").concat(correlationContext);
@@ -4703,7 +4216,7 @@
             _a);
         if (!isNullOrUndefined(customProperties)) {
             objForEachKey(customProperties, function (prop, value) {
-                telemetryItem[_DYN_DATA ][prop] = value;
+                telemetryItem.data[prop] = value;
             });
         }
         return telemetryItem;
@@ -4727,360 +4240,6 @@
     };
     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)) {
@@ -5241,7 +4400,6 @@
     exports.RemoteDependencyData = RemoteDependencyData;
     exports.RequestHeaders = RequestHeaders;
     exports.SampleRate = SampleRate;
-    exports.SenderPostManager = SenderPostManager;
     exports.SeverityLevel = SeverityLevel;
     exports.TelemetryItemCreator = TelemetryItemCreator;
     exports.ThrottleMgr = ThrottleMgr;
@@ -5270,11 +4428,8 @@
     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;
@@ -5284,9 +4439,7 @@
     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;