@microsoft/applicationinsights-common 3.1.1-nightly3.2403-02 → 3.1.1-nightly3.2403-04

package/browser/es5/applicationinsights-common.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Common, 3.1.1-nightly3.2403-02
+ * Application Insights JavaScript SDK - Common, 3.1.1-nightly3.2403-04
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -7,8 +7,8 @@
     typeof exports === "object" && typeof module !== undef ? factory(exports) :
     typeof define === "function" && define.amd ? define(["exports"], factory) :
     (function(global){
-        var nsKey, key, nm, theExports = {}, modName = "es5_applicationinsights_common_3_1_1_nightly3_2403_02", msMod="__ms$mod__";
-        var mods={}, modDetail=mods[modName]={}, ver="3.1.1-nightly3.2403-02";
+        var nsKey, key, nm, theExports = {}, modName = "es5_applicationinsights_common_3_1_1_nightly3_2403_04", msMod="__ms$mod__";
+        var mods={}, modDetail=mods[modName]={}, ver="3.1.1-nightly3.2403-04";
         var baseNs=global, nsKey="Microsoft", baseNs=baseNs[nsKey]=(baseNs[nsKey]||{});
         // Versioned namespace "Microsoft.ApplicationInsights3"
         var exportNs=baseNs, nsKey="ApplicationInsights3", exportNs=exportNs[nsKey]=(exportNs[nsKey]||{});
@@ -108,12 +108,7 @@ function isObject(value) {
     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;
 
@@ -185,10 +180,6 @@ function createEnum(values) {
     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) {
@@ -202,22 +193,6 @@ function createTypeMap(values) {
     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";
@@ -320,7 +295,6 @@ function _globalSymbolRegistry() {
     }
     return _polySymbols;
 }
-var _wellKnownSymbolCache;
 /*#__NO_SIDE_EFFECTS__*/
 function polyNewSymbol(description) {
     var theSymbol = {
@@ -342,16 +316,6 @@ function polySymbolFor(key) {
     }
     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",
@@ -429,7 +393,6 @@ var _cachedGlobal;
 var _cachedWindow;
 var _cachedDocument;
 var _cachedNavigator;
-var _isNode;
 /*#__NO_SIDE_EFFECTS__*/
 function lazySafeGetInst(name) {
     return getLazy(function () { return safe((getInst), [name]).v || UNDEF_VALUE; });
@@ -477,10 +440,6 @@ function getNavigator() {
     (!_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;
@@ -491,23 +450,6 @@ function _initSymbol() {
     }
 }
 /*#__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();
@@ -539,8 +481,6 @@ var arrIndexOf = ( /*#__PURE__*/_unwrapFunction(INDEX_OF, ArrProto));
 
 var arrMap = ( /*#__PURE__*/_unwrapFunction("map", ArrProto));
 
-var arrSlice = ( /*#__PURE__*/_unwrapFunction(SLICE, ArrProto));
-
 var arrReduce = ( /*#__PURE__*/_unwrapFunction("reduce", ArrProto));
 
 var objCreate = ObjClass$1["create"] || polyObjCreate;
@@ -1126,408 +1066,35 @@ function dynamicProto(theClass, target, delegateFunc, options) {
 }
 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;
@@ -1553,7 +1120,7 @@ function isIE() {
     var nav = getNavigator();
     if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
         _navUserAgentCheck = nav[_DYN_USER_AGENT ];
-        var userAgent = (_navUserAgentCheck || STR_EMPTY$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;
@@ -1564,38 +1131,6 @@ function isBeaconsSupported(useCached) {
     }
     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++) {
@@ -1626,34 +1161,264 @@ function findNamedServerTiming(name) {
     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;
@@ -1689,7 +1454,7 @@ function newId(maxLength) {
     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);
@@ -1727,11 +1492,11 @@ function _getCache(data, target) {
 }
 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);
         },
@@ -2264,314 +2029,116 @@ function _createAndUseHandler(state, configHandler) {
     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 +=
@@ -2648,9 +2215,9 @@ function parseTraceParent(value, selectIdx) {
         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;
@@ -2715,16 +2282,16 @@ var elmNodeData = createElmNodeData("events");
 var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
 function _normalizeNamespace(name) {
     if (name && name[_DYN_REPLACE ]) {
-        return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY$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) {
@@ -2742,13 +2309,13 @@ function _getEvtNamespace(eventName, evtNamespace) {
             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) {
@@ -2898,17 +2465,12 @@ var RequestHeaders = createValueMap({
 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";
@@ -2919,7 +2481,6 @@ var _DYN_GET_UTCDATE = "getUTCDate";
 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";
@@ -3285,54 +2846,6 @@ function createDistributedTraceContextFromTrace(telemetryTrace, parentCtx) {
         }
     };
 }
-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 ,
@@ -3839,7 +3352,7 @@ function parseConnectionString(connectionString) {
     }, {});
     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;
@@ -3861,7 +3374,7 @@ var Envelope = /** @class */ (function () {
         _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 ,
@@ -4018,8 +3531,8 @@ function _getStackFromErrorObj(errorObj) {
             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);
@@ -4510,7 +4023,7 @@ var RemoteDependencyData = /** @class */ (function () {
         _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);
@@ -4725,7 +4238,7 @@ function createTelemetryItem(item, baseType, envelopeName, logger, customPropert
         _a);
     if (!isNullOrUndefined(customProperties)) {
         objForEachKey(customProperties, function (prop, value) {
-            telemetryItem[_DYN_DATA ][prop] = value;
+            telemetryItem.data[prop] = value;
         });
     }
     return telemetryItem;
@@ -4749,360 +4262,6 @@ var Extensions = {
 };
 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)) {
@@ -5263,7 +4422,6 @@ exports.PropertiesPluginIdentifier = PropertiesPluginIdentifier;
 exports.RemoteDependencyData = RemoteDependencyData;
 exports.RequestHeaders = RequestHeaders;
 exports.SampleRate = SampleRate;
-exports.SenderPostManager = SenderPostManager;
 exports.SeverityLevel = SeverityLevel;
 exports.TelemetryItemCreator = TelemetryItemCreator;
 exports.ThrottleMgr = ThrottleMgr;
@@ -5292,11 +4450,8 @@ exports.dateTimeUtilsDuration = dateTimeUtilsDuration;
 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;
@@ -5306,9 +4461,7 @@ exports.isValidTraceId = isValidTraceId;
 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;