@microsoft/applicationinsights-dependencies-js 2.8.5-nightly.2206-04 → 2.8.5-nightly.2207-02

package/browser/applicationinsights-dependencies-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Dependencies Plugin, 2.8.5-nightly.2206-04
+ * Application Insights JavaScript SDK - Dependencies Plugin, 2.8.5-nightly.2207-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -98,14 +98,307 @@
         d[strShimPrototype] = b === null ? objCreateFn(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
     }
 
-    var strEmpty$1 = "";
-    var strSetNextPlugin = "setNextPlugin";
-    var strIsInitialized = "isInitialized";
-    var strTeardown = "teardown";
-    var strCore = "core";
-    var strUpdate = "update";
-    var strDisabled = "disabled";
-    var strDoTeardown = "_doTeardown";
+    /*!
+     * Microsoft Dynamic Proto Utility, 1.1.6
+     * Copyright (c) Microsoft and contributors. All rights reserved.
+     */
+    var Constructor = 'constructor';
+    var Prototype = 'prototype';
+    var strFunction = 'function';
+    var DynInstFuncTable = '_dynInstFuncs';
+    var DynProxyTag = '_isDynProxy';
+    var DynClassName = '_dynClass';
+    var DynClassNamePrefix = '_dynCls$';
+    var DynInstChkTag = '_dynInstChk';
+    var DynAllowInstChkTag = DynInstChkTag;
+    var DynProtoDefaultOptions = '_dfOpts';
+    var UnknownValue = '_unknown_';
+    var str__Proto$1 = "__proto__";
+    var DynProtoBaseProto = "_dyn" + str__Proto$1;
+    var DynProtoCurrent = "_dynInstProto";
+    var strUseBaseInst = 'useBaseInst';
+    var strSetInstFuncs = 'setInstFuncs';
+    var Obj = Object;
+    var _objGetPrototypeOf$1 = Obj["getPrototypeOf"];
+    var _objGetOwnProps = Obj["getOwnPropertyNames"];
+    var _dynamicNames = 0;
+    function _hasOwnProperty(obj, prop) {
+        return obj && Obj[Prototype].hasOwnProperty.call(obj, prop);
+    }
+    function _isObjectOrArrayPrototype(target) {
+        return target && (target === Obj[Prototype] || target === Array[Prototype]);
+    }
+    function _isObjectArrayOrFunctionPrototype(target) {
+        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
+    }
+    function _getObjProto$1(target) {
+        var newProto;
+        if (target) {
+            if (_objGetPrototypeOf$1) {
+                return _objGetPrototypeOf$1(target);
+            }
+            var curProto = target[str__Proto$1] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
+            newProto = target[DynProtoBaseProto] || curProto;
+            if (!_hasOwnProperty(target, DynProtoBaseProto)) {
+                delete target[DynProtoCurrent];
+                newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
+                target[DynProtoCurrent] = curProto;
+            }
+        }
+        return newProto;
+    }
+    function _forEachProp(target, func) {
+        var props = [];
+        if (_objGetOwnProps) {
+            props = _objGetOwnProps(target);
+        }
+        else {
+            for (var name_1 in target) {
+                if (typeof name_1 === "string" && _hasOwnProperty(target, name_1)) {
+                    props.push(name_1);
+                }
+            }
+        }
+        if (props && props.length > 0) {
+            for (var lp = 0; lp < props.length; lp++) {
+                func(props[lp]);
+            }
+        }
+    }
+    function _isDynamicCandidate(target, funcName, skipOwn) {
+        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || _hasOwnProperty(target, funcName)));
+    }
+    function _throwTypeError(message) {
+        throw new TypeError("DynamicProto: " + message);
+    }
+    function _getInstanceFuncs(thisTarget) {
+        var instFuncs = {};
+        _forEachProp(thisTarget, function (name) {
+            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
+                instFuncs[name] = thisTarget[name];
+            }
+        });
+        return instFuncs;
+    }
+    function _hasVisited(values, value) {
+        for (var lp = values.length - 1; lp >= 0; lp--) {
+            if (values[lp] === value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
+        function _instFuncProxy(target, funcHost, funcName) {
+            var theFunc = funcHost[funcName];
+            if (theFunc[DynProxyTag] && useBaseInst) {
+                var instFuncTable = target[DynInstFuncTable] || {};
+                if (instFuncTable[DynAllowInstChkTag] !== false) {
+                    theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
+                }
+            }
+            return function () {
+                return theFunc.apply(target, arguments);
+            };
+        }
+        var baseFuncs = {};
+        _forEachProp(instFuncs, function (name) {
+            baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
+        });
+        var baseProto = _getObjProto$1(classProto);
+        var visited = [];
+        while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
+            _forEachProp(baseProto, function (name) {
+                if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf$1)) {
+                    baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
+                }
+            });
+            visited.push(baseProto);
+            baseProto = _getObjProto$1(baseProto);
+        }
+        return baseFuncs;
+    }
+    function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
+        var instFunc = null;
+        if (target && _hasOwnProperty(proto, DynClassName)) {
+            var instFuncTable = target[DynInstFuncTable] || {};
+            instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
+            if (!instFunc) {
+                _throwTypeError("Missing [" + funcName + "] " + strFunction);
+            }
+            if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
+                var canAddInst = !_hasOwnProperty(target, funcName);
+                var objProto = _getObjProto$1(target);
+                var visited = [];
+                while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
+                    var protoFunc = objProto[funcName];
+                    if (protoFunc) {
+                        canAddInst = (protoFunc === currentDynProtoProxy);
+                        break;
+                    }
+                    visited.push(objProto);
+                    objProto = _getObjProto$1(objProto);
+                }
+                try {
+                    if (canAddInst) {
+                        target[funcName] = instFunc;
+                    }
+                    instFunc[DynInstChkTag] = 1;
+                }
+                catch (e) {
+                    instFuncTable[DynAllowInstChkTag] = false;
+                }
+            }
+        }
+        return instFunc;
+    }
+    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
+        var protoFunc = proto[funcName];
+        if (protoFunc === currentDynProtoProxy) {
+            protoFunc = _getObjProto$1(proto)[funcName];
+        }
+        if (typeof protoFunc !== strFunction) {
+            _throwTypeError("[" + funcName + "] is not a " + strFunction);
+        }
+        return protoFunc;
+    }
+    function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
+        function _createDynamicPrototype(proto, funcName) {
+            var dynProtoProxy = function () {
+                var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
+                return instFunc.apply(this, arguments);
+            };
+            dynProtoProxy[DynProxyTag] = 1;
+            return dynProtoProxy;
+        }
+        if (!_isObjectOrArrayPrototype(proto)) {
+            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
+            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
+            if (instFuncTable[DynAllowInstChkTag] !== false) {
+                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
+            }
+            _forEachProp(target, function (name) {
+                if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
+                    instFuncs_1[name] = target[name];
+                    delete target[name];
+                    if (!_hasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
+                        proto[name] = _createDynamicPrototype(proto, name);
+                    }
+                }
+            });
+        }
+    }
+    function _checkPrototype(classProto, thisTarget) {
+        if (_objGetPrototypeOf$1) {
+            var visited = [];
+            var thisProto = _getObjProto$1(thisTarget);
+            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
+                if (thisProto === classProto) {
+                    return true;
+                }
+                visited.push(thisProto);
+                thisProto = _getObjProto$1(thisProto);
+            }
+            return false;
+        }
+        return true;
+    }
+    function _getObjName(target, unknownValue) {
+        if (_hasOwnProperty(target, Prototype)) {
+            return target.name || unknownValue || UnknownValue;
+        }
+        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+    }
+    function dynamicProto(theClass, target, delegateFunc, options) {
+        if (!_hasOwnProperty(theClass, Prototype)) {
+            _throwTypeError("theClass is an invalid class definition.");
+        }
+        var classProto = theClass[Prototype];
+        if (!_checkPrototype(classProto, target)) {
+            _throwTypeError("[" + _getObjName(theClass) + "] is not in class hierarchy of [" + _getObjName(target) + "]");
+        }
+        var className = null;
+        if (_hasOwnProperty(classProto, DynClassName)) {
+            className = classProto[DynClassName];
+        }
+        else {
+            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _dynamicNames;
+            _dynamicNames++;
+            classProto[DynClassName] = className;
+        }
+        var perfOptions = dynamicProto[DynProtoDefaultOptions];
+        var useBaseInst = !!perfOptions[strUseBaseInst];
+        if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
+            useBaseInst = !!options[strUseBaseInst];
+        }
+        var instFuncs = _getInstanceFuncs(target);
+        var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
+        delegateFunc(target, baseFuncs);
+        var setInstanceFunc = !!_objGetPrototypeOf$1 && !!perfOptions[strSetInstFuncs];
+        if (setInstanceFunc && options) {
+            setInstanceFunc = !!options[strSetInstFuncs];
+        }
+        _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
+    }
+    var perfDefaults = {
+        setInstFuncs: true,
+        useBaseInst: true
+    };
+    dynamicProto[DynProtoDefaultOptions] = perfDefaults;
+
+    var _DYN_INITIALIZE = "initialize";
+    var _DYN_NAME$2 = "name";
+    var _DYN_IDENTIFIER = "identifier";
+    var _DYN_PUSH = "push";
+    var _DYN_IS_INITIALIZED = "isInitialized";
+    var _DYN_CONFIG = "config";
+    var _DYN_LOGGER = "logger";
+    var _DYN_LENGTH$2 = "length";
+    var _DYN_TIME = "time";
+    var _DYN_PROCESS_NEXT = "processNext";
+    var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
+    var _DYN_GET_PLUGIN = "getPlugin";
+    var _DYN_SPLICE = "splice";
+    var _DYN_TEARDOWN = "teardown";
+    var _DYN_MESSAGE_ID = "messageId";
+    var _DYN_MESSAGE = "message";
+    var _DYN_IS_ASYNC = "isAsync";
+    var _DYN__DO_TEARDOWN = "_doTeardown";
+    var _DYN_UPDATE = "update";
+    var _DYN_GET_NEXT = "getNext";
+    var _DYN_DIAG_LOG = "diagLog";
+    var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
+    var _DYN_CREATE_NEW = "createNew";
+    var _DYN_INDEX_OF$1 = "indexOf";
+    var _DYN_USER_AGENT = "userAgent";
+    var _DYN_SPLIT$1 = "split";
+    var _DYN_REPLACE = "replace";
+    var _DYN_SUBSTR = "substr";
+    var _DYN_NODE_TYPE = "nodeType";
+    var _DYN_APPLY = "apply";
+    var _DYN_ENABLE_DEBUG_EXCEPTI4 = "enableDebugExceptions";
+    var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
+    var _DYN_TO_LOWER_CASE$2 = "toLowerCase";
+    var _DYN_CALL = "call";
+    var _DYN_TYPE = "type";
+    var _DYN_HANDLER = "handler";
+    var _DYN_IS_CHILD_EVT = "isChildEvt";
+    var _DYN_GET_CTX = "getCtx";
+    var _DYN_SET_CTX = "setCtx";
+    var _DYN_COMPLETE = "complete";
+    var _DYN_TRACE_ID$1 = "traceId";
+    var _DYN_TRACE_FLAGS$1 = "traceFlags";
+    var _DYN_VERSION = "version";
+
+    var STR_EMPTY = "";
+    var STR_CORE = "core";
+    var STR_DISABLED = "disabled";
+    var STR_EXTENSION_CONFIG = "extensionConfig";
+    var STR_PROCESS_TELEMETRY = "processTelemetry";
+    var STR_PRIORITY = "priority";
+    var STR_ERROR_TO_CONSOLE = "errorToConsole";
+    var STR_WARN_TO_CONSOLE = "warnToConsole";
+    var STR_GET_PERF_MGR = "getPerfMgr";
 
     var strToISOString = "toISOString";
     var cStrEndsWith = "endsWith";
@@ -113,7 +406,7 @@
     var strIndexOf = "indexOf";
     var cStrTrim = "trim";
     var strToString = "toString";
-    var str__Proto$1 = "__proto__";
+    var str__Proto = "__proto__";
     var strConstructor = "constructor";
     var _objDefineProperty$1 = ObjDefineProperty;
     var _objFreeze = ObjClass.freeze;
@@ -128,17 +421,17 @@
     var _isArray = Array.isArray;
     var _objToString = ObjProto[strToString];
     var _fnToString = ObjHasOwnProperty[strToString];
-    var _objFunctionString = _fnToString.call(ObjClass);
+    var _objFunctionString = _fnToString[_DYN_CALL ](ObjClass);
     var rCamelCase = /-([a-z])/g;
     var rNormalizeInvalid = /([^\w\d_$])/g;
     var rLeadingNumeric = /^(\d+[\w\d_$])/;
-    var _objGetPrototypeOf$1 = Object["getPrototypeOf"];
-    function _getObjProto$1(target) {
+    var _objGetPrototypeOf = Object["getPrototypeOf"];
+    function _getObjProto(target) {
         if (target) {
-            if (_objGetPrototypeOf$1) {
-                return _objGetPrototypeOf$1(target);
+            if (_objGetPrototypeOf) {
+                return _objGetPrototypeOf(target);
             }
-            var newProto = target[str__Proto$1] || target[strShimPrototype] || target[strConstructor];
+            var newProto = target[str__Proto] || target[strShimPrototype] || target[strConstructor];
             if (newProto) {
                 return newProto;
             }
@@ -152,7 +445,7 @@
         return (value === null || isUndefined(value));
     }
     function hasOwnProperty(obj, prop) {
-        return !!(obj && ObjHasOwnProperty.call(obj, prop));
+        return !!(obj && ObjHasOwnProperty[_DYN_CALL ](obj, prop));
     }
     function isObject(value) {
         return !!(value && typeof value === strShimObject);
@@ -163,11 +456,11 @@
     function normalizeJsName(name) {
         var value = name;
         if (value && isString(value)) {
-            value = value.replace(rCamelCase, function (_all, letter) {
+            value = value[_DYN_REPLACE ](rCamelCase, function (_all, letter) {
                 return letter.toUpperCase();
             });
-            value = value.replace(rNormalizeInvalid, "_");
-            value = value.replace(rLeadingNumeric, function (_all, match) {
+            value = value[_DYN_REPLACE ](rNormalizeInvalid, "_");
+            value = value[_DYN_REPLACE ](rLeadingNumeric, function (_all, match) {
                 return "_" + match;
             });
         }
@@ -176,24 +469,24 @@
     function objForEachKey(target, callbackfn) {
         if (target) {
             for (var prop in target) {
-                if (ObjHasOwnProperty.call(target, prop)) {
-                    callbackfn.call(target, prop, target[prop]);
+                if (ObjHasOwnProperty[_DYN_CALL ](target, prop)) {
+                    callbackfn[_DYN_CALL ](target, prop, target[prop]);
                 }
             }
         }
     }
     function strContains(value, search) {
         if (value && search) {
-            return value.indexOf(search) !== -1;
+            return value[_DYN_INDEX_OF$1 ](search) !== -1;
         }
         return false;
     }
     var isArray = _isArray || _isArrayPoly;
     function _isArrayPoly(obj) {
-        return !!(obj && _objToString.call(obj) === "[object Array]");
+        return !!(obj && _objToString[_DYN_CALL ](obj) === "[object Array]");
     }
     function isError(obj) {
-        return !!(obj && _objToString.call(obj) === "[object Error]");
+        return !!(obj && _objToString[_DYN_CALL ](obj) === "[object Error]");
     }
     function isString(value) {
         return typeof value === "string";
@@ -207,15 +500,15 @@
     function isPlainObject(value) {
         var result = false;
         if (value && typeof value === "object") {
-            var proto = _objGetPrototypeOf$1 ? _objGetPrototypeOf$1(value) : _getObjProto$1(value);
+            var proto = _objGetPrototypeOf ? _objGetPrototypeOf(value) : _getObjProto(value);
             if (!proto) {
                 result = true;
             }
             else {
-                if (proto[strConstructor] && ObjHasOwnProperty.call(proto, strConstructor)) {
+                if (proto[strConstructor] && ObjHasOwnProperty[_DYN_CALL ](proto, strConstructor)) {
                     proto = proto[strConstructor];
                 }
-                result = typeof proto === strShimFunction && _fnToString.call(proto) === _objFunctionString;
+                result = typeof proto === strShimFunction && _fnToString[_DYN_CALL ](proto) === _objFunctionString;
             }
         }
         return result;
@@ -229,7 +522,7 @@
         if (date && date.getUTCFullYear) {
             var pad = function (num) {
                 var r = String(num);
-                if (r.length === 1) {
+                if (r[_DYN_LENGTH$2 ] === 1) {
                     r = "0" + r;
                 }
                 return r;
@@ -245,11 +538,11 @@
         }
     }
     function arrForEach(arr, callbackfn, thisArg) {
-        var len = arr.length;
+        var len = arr[_DYN_LENGTH$2 ];
         try {
             for (var idx = 0; idx < len; idx++) {
                 if (idx in arr) {
-                    if (callbackfn.call(thisArg || arr, arr[idx], idx, arr) === -1) {
+                    if (callbackfn[_DYN_CALL ](thisArg || arr, arr[idx], idx, arr) === -1) {
                         break;
                     }
                 }
@@ -263,7 +556,7 @@
             if (arr[strIndexOf]) {
                 return arr[strIndexOf](searchElement, fromIndex);
             }
-            var len = arr.length;
+            var len = arr[_DYN_LENGTH$2 ];
             var from = fromIndex || 0;
             try {
                 for (var lp = Math.max(from >= 0 ? from : len - Math.abs(from), 0); lp < len; lp++) {
@@ -279,7 +572,7 @@
     }
     function strTrim(str) {
         if (str) {
-            str = (_strTrim && str[cStrTrim]) ? str[cStrTrim]() : (str.replace ? str.replace(/^\s+|\s+$/g, "") : str);
+            str = (_strTrim && str[cStrTrim]) ? str[cStrTrim]() : (str[_DYN_REPLACE ] ? str[_DYN_REPLACE ](/^\s+|\s+$/g, STR_EMPTY) : str);
         }
         return str;
     }
@@ -303,15 +596,15 @@
         }
         var result = [];
         for (var prop in obj) {
-            if (obj && ObjHasOwnProperty.call(obj, prop)) {
-                result.push(prop);
+            if (obj && ObjHasOwnProperty[_DYN_CALL ](obj, prop)) {
+                result[_DYN_PUSH ](prop);
             }
         }
         if (_objKeysHasDontEnumBug) {
-            var dontEnumsLength = _objKeysDontEnums.length;
+            var dontEnumsLength = _objKeysDontEnums[_DYN_LENGTH$2 ];
             for (var lp = 0; lp < dontEnumsLength; lp++) {
-                if (obj && ObjHasOwnProperty.call(obj, _objKeysDontEnums[lp])) {
-                    result.push(_objKeysDontEnums[lp]);
+                if (obj && ObjHasOwnProperty[_DYN_CALL ](obj, _objKeysDontEnums[lp])) {
+                    result[_DYN_PUSH ](_objKeysDontEnums[lp]);
                 }
             }
         }
@@ -327,382 +620,137 @@
                 if (getProp) {
                     descriptor.get = getProp;
                 }
-                if (setProp) {
-                    descriptor.set = setProp;
-                }
-                _objDefineProperty$1(target, prop, descriptor);
-                return true;
-            }
-            catch (e) {
-            }
-        }
-        return false;
-    }
-    function _doNothing(value) {
-        return value;
-    }
-    function deepFreeze(obj) {
-        if (_objFreeze) {
-            objForEachKey(obj, function (name, value) {
-                if (isArray(value) || isObject(value)) {
-                    _objFreeze(value);
-                }
-            });
-        }
-        return objFreeze(obj);
-    }
-    var objFreeze = _objFreeze || _doNothing;
-    function dateNow() {
-        var dt = Date;
-        return dt.now ? dt.now() : new dt().getTime();
-    }
-    function getExceptionName(object) {
-        if (isError(object)) {
-            return object.name;
-        }
-        return strEmpty$1;
-    }
-    function setValue(target, field, value, valChk, srcChk) {
-        var theValue = value;
-        if (target) {
-            theValue = target[field];
-            if (theValue !== value && (!srcChk || srcChk(theValue)) && (!valChk || valChk(value))) {
-                theValue = value;
-                target[field] = theValue;
-            }
-        }
-        return theValue;
-    }
-    function throwError(message) {
-        throw new Error(message);
-    }
-    function _createProxyFunction(source, funcName) {
-        var srcFunc = null;
-        var src = null;
-        if (isFunction(source)) {
-            srcFunc = source;
-        }
-        else {
-            src = source;
-        }
-        return function () {
-            var originalArguments = arguments;
-            if (srcFunc) {
-                src = srcFunc();
-            }
-            if (src) {
-                return src[funcName].apply(src, originalArguments);
-            }
-        };
-    }
-    function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
-        if (target && name && source) {
-            if (overwriteTarget !== false || isUndefined(target[name])) {
-                target[name] = _createProxyFunction(source, theFunc);
-            }
-        }
-    }
-    function objExtend(obj1, obj2, obj3, obj4, obj5, obj6) {
-        var theArgs = arguments;
-        var extended = theArgs[0] || {};
-        var argLen = theArgs.length;
-        var deep = false;
-        var idx = 1;
-        if (argLen > 0 && isBoolean(extended)) {
-            deep = extended;
-            extended = theArgs[idx] || {};
-            idx++;
-        }
-        if (!isObject(extended)) {
-            extended = {};
-        }
-        for (; idx < argLen; idx++) {
-            var arg = theArgs[idx];
-            var isArgArray = isArray(arg);
-            var isArgObj = isObject(arg);
-            for (var prop in arg) {
-                var propOk = (isArgArray && (prop in arg)) || (isArgObj && (ObjHasOwnProperty.call(arg, prop)));
-                if (!propOk) {
-                    continue;
-                }
-                var newValue = arg[prop];
-                var isNewArray = void 0;
-                if (deep && newValue && ((isNewArray = isArray(newValue)) || isPlainObject(newValue))) {
-                    var clone = extended[prop];
-                    if (isNewArray) {
-                        if (!isArray(clone)) {
-                            clone = [];
-                        }
-                    }
-                    else if (!isPlainObject(clone)) {
-                        clone = {};
-                    }
-                    newValue = objExtend(deep, clone, newValue);
-                }
-                if (newValue !== undefined) {
-                    extended[prop] = newValue;
-                }
-            }
-        }
-        return extended;
-    }
-
-    function createValueMap(values) {
-        var mapClass = {};
-        objForEachKey(values, function (field, value) {
-            mapClass[field] = value[1];
-            mapClass[value[0]] = value[1];
-        });
-        return deepFreeze(mapClass);
-    }
-
-    /*!
-     * Microsoft Dynamic Proto Utility, 1.1.6
-     * Copyright (c) Microsoft and contributors. All rights reserved.
-     */
-    var Constructor = 'constructor';
-    var Prototype = 'prototype';
-    var strFunction = 'function';
-    var DynInstFuncTable = '_dynInstFuncs';
-    var DynProxyTag = '_isDynProxy';
-    var DynClassName = '_dynClass';
-    var DynClassNamePrefix = '_dynCls$';
-    var DynInstChkTag = '_dynInstChk';
-    var DynAllowInstChkTag = DynInstChkTag;
-    var DynProtoDefaultOptions = '_dfOpts';
-    var UnknownValue = '_unknown_';
-    var str__Proto = "__proto__";
-    var DynProtoBaseProto = "_dyn" + str__Proto;
-    var DynProtoCurrent = "_dynInstProto";
-    var strUseBaseInst = 'useBaseInst';
-    var strSetInstFuncs = 'setInstFuncs';
-    var Obj = Object;
-    var _objGetPrototypeOf = Obj["getPrototypeOf"];
-    var _objGetOwnProps = Obj["getOwnPropertyNames"];
-    var _dynamicNames = 0;
-    function _hasOwnProperty(obj, prop) {
-        return obj && Obj[Prototype].hasOwnProperty.call(obj, prop);
-    }
-    function _isObjectOrArrayPrototype(target) {
-        return target && (target === Obj[Prototype] || target === Array[Prototype]);
-    }
-    function _isObjectArrayOrFunctionPrototype(target) {
-        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
-    }
-    function _getObjProto(target) {
-        var newProto;
-        if (target) {
-            if (_objGetPrototypeOf) {
-                return _objGetPrototypeOf(target);
-            }
-            var curProto = target[str__Proto] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
-            newProto = target[DynProtoBaseProto] || curProto;
-            if (!_hasOwnProperty(target, DynProtoBaseProto)) {
-                delete target[DynProtoCurrent];
-                newProto = target[DynProtoBaseProto] = target[DynProtoCurrent] || target[DynProtoBaseProto];
-                target[DynProtoCurrent] = curProto;
-            }
-        }
-        return newProto;
-    }
-    function _forEachProp(target, func) {
-        var props = [];
-        if (_objGetOwnProps) {
-            props = _objGetOwnProps(target);
-        }
-        else {
-            for (var name_1 in target) {
-                if (typeof name_1 === "string" && _hasOwnProperty(target, name_1)) {
-                    props.push(name_1);
-                }
-            }
-        }
-        if (props && props.length > 0) {
-            for (var lp = 0; lp < props.length; lp++) {
-                func(props[lp]);
-            }
-        }
-    }
-    function _isDynamicCandidate(target, funcName, skipOwn) {
-        return (funcName !== Constructor && typeof target[funcName] === strFunction && (skipOwn || _hasOwnProperty(target, funcName)));
-    }
-    function _throwTypeError(message) {
-        throw new TypeError("DynamicProto: " + message);
-    }
-    function _getInstanceFuncs(thisTarget) {
-        var instFuncs = {};
-        _forEachProp(thisTarget, function (name) {
-            if (!instFuncs[name] && _isDynamicCandidate(thisTarget, name, false)) {
-                instFuncs[name] = thisTarget[name];
-            }
-        });
-        return instFuncs;
-    }
-    function _hasVisited(values, value) {
-        for (var lp = values.length - 1; lp >= 0; lp--) {
-            if (values[lp] === value) {
-                return true;
-            }
-        }
-        return false;
-    }
-    function _getBaseFuncs(classProto, thisTarget, instFuncs, useBaseInst) {
-        function _instFuncProxy(target, funcHost, funcName) {
-            var theFunc = funcHost[funcName];
-            if (theFunc[DynProxyTag] && useBaseInst) {
-                var instFuncTable = target[DynInstFuncTable] || {};
-                if (instFuncTable[DynAllowInstChkTag] !== false) {
-                    theFunc = (instFuncTable[funcHost[DynClassName]] || {})[funcName] || theFunc;
-                }
-            }
-            return function () {
-                return theFunc.apply(target, arguments);
-            };
-        }
-        var baseFuncs = {};
-        _forEachProp(instFuncs, function (name) {
-            baseFuncs[name] = _instFuncProxy(thisTarget, instFuncs, name);
-        });
-        var baseProto = _getObjProto(classProto);
-        var visited = [];
-        while (baseProto && !_isObjectArrayOrFunctionPrototype(baseProto) && !_hasVisited(visited, baseProto)) {
-            _forEachProp(baseProto, function (name) {
-                if (!baseFuncs[name] && _isDynamicCandidate(baseProto, name, !_objGetPrototypeOf)) {
-                    baseFuncs[name] = _instFuncProxy(thisTarget, baseProto, name);
-                }
-            });
-            visited.push(baseProto);
-            baseProto = _getObjProto(baseProto);
-        }
-        return baseFuncs;
-    }
-    function _getInstFunc(target, funcName, proto, currentDynProtoProxy) {
-        var instFunc = null;
-        if (target && _hasOwnProperty(proto, DynClassName)) {
-            var instFuncTable = target[DynInstFuncTable] || {};
-            instFunc = (instFuncTable[proto[DynClassName]] || {})[funcName];
-            if (!instFunc) {
-                _throwTypeError("Missing [" + funcName + "] " + strFunction);
-            }
-            if (!instFunc[DynInstChkTag] && instFuncTable[DynAllowInstChkTag] !== false) {
-                var canAddInst = !_hasOwnProperty(target, funcName);
-                var objProto = _getObjProto(target);
-                var visited = [];
-                while (canAddInst && objProto && !_isObjectArrayOrFunctionPrototype(objProto) && !_hasVisited(visited, objProto)) {
-                    var protoFunc = objProto[funcName];
-                    if (protoFunc) {
-                        canAddInst = (protoFunc === currentDynProtoProxy);
-                        break;
-                    }
-                    visited.push(objProto);
-                    objProto = _getObjProto(objProto);
-                }
-                try {
-                    if (canAddInst) {
-                        target[funcName] = instFunc;
-                    }
-                    instFunc[DynInstChkTag] = 1;
-                }
-                catch (e) {
-                    instFuncTable[DynAllowInstChkTag] = false;
+                if (setProp) {
+                    descriptor.set = setProp;
                 }
+                _objDefineProperty$1(target, prop, descriptor);
+                return true;
+            }
+            catch (e) {
             }
         }
-        return instFunc;
+        return false;
     }
-    function _getProtoFunc(funcName, proto, currentDynProtoProxy) {
-        var protoFunc = proto[funcName];
-        if (protoFunc === currentDynProtoProxy) {
-            protoFunc = _getObjProto(proto)[funcName];
-        }
-        if (typeof protoFunc !== strFunction) {
-            _throwTypeError("[" + funcName + "] is not a " + strFunction);
-        }
-        return protoFunc;
+    function _doNothing(value) {
+        return value;
     }
-    function _populatePrototype(proto, className, target, baseInstFuncs, setInstanceFunc) {
-        function _createDynamicPrototype(proto, funcName) {
-            var dynProtoProxy = function () {
-                var instFunc = _getInstFunc(this, funcName, proto, dynProtoProxy) || _getProtoFunc(funcName, proto, dynProtoProxy);
-                return instFunc.apply(this, arguments);
-            };
-            dynProtoProxy[DynProxyTag] = 1;
-            return dynProtoProxy;
-        }
-        if (!_isObjectOrArrayPrototype(proto)) {
-            var instFuncTable = target[DynInstFuncTable] = target[DynInstFuncTable] || {};
-            var instFuncs_1 = instFuncTable[className] = (instFuncTable[className] || {});
-            if (instFuncTable[DynAllowInstChkTag] !== false) {
-                instFuncTable[DynAllowInstChkTag] = !!setInstanceFunc;
-            }
-            _forEachProp(target, function (name) {
-                if (_isDynamicCandidate(target, name, false) && target[name] !== baseInstFuncs[name]) {
-                    instFuncs_1[name] = target[name];
-                    delete target[name];
-                    if (!_hasOwnProperty(proto, name) || (proto[name] && !proto[name][DynProxyTag])) {
-                        proto[name] = _createDynamicPrototype(proto, name);
-                    }
+    function deepFreeze(obj) {
+        if (_objFreeze) {
+            objForEachKey(obj, function (name, value) {
+                if (isArray(value) || isObject(value)) {
+                    _objFreeze(value);
                 }
             });
         }
+        return objFreeze(obj);
     }
-    function _checkPrototype(classProto, thisTarget) {
-        if (_objGetPrototypeOf) {
-            var visited = [];
-            var thisProto = _getObjProto(thisTarget);
-            while (thisProto && !_isObjectArrayOrFunctionPrototype(thisProto) && !_hasVisited(visited, thisProto)) {
-                if (thisProto === classProto) {
-                    return true;
-                }
-                visited.push(thisProto);
-                thisProto = _getObjProto(thisProto);
-            }
-            return false;
+    var objFreeze = _objFreeze || _doNothing;
+    function dateNow() {
+        var dt = Date;
+        return dt.now ? dt.now() : new dt().getTime();
+    }
+    function getExceptionName(object) {
+        if (isError(object)) {
+            return object[_DYN_NAME$2 ];
         }
-        return true;
+        return STR_EMPTY;
     }
-    function _getObjName(target, unknownValue) {
-        if (_hasOwnProperty(target, Prototype)) {
-            return target.name || unknownValue || UnknownValue;
+    function setValue(target, field, value, valChk, srcChk) {
+        var theValue = value;
+        if (target) {
+            theValue = target[field];
+            if (theValue !== value && (!srcChk || srcChk(theValue)) && (!valChk || valChk(value))) {
+                theValue = value;
+                target[field] = theValue;
+            }
         }
-        return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
+        return theValue;
     }
-    function dynamicProto(theClass, target, delegateFunc, options) {
-        if (!_hasOwnProperty(theClass, Prototype)) {
-            _throwTypeError("theClass is an invalid class definition.");
+    function getCfgValue(theValue, defaultValue) {
+        return !isNullOrUndefined(theValue) ? theValue : defaultValue;
+    }
+    function throwError(message) {
+        throw new Error(message);
+    }
+    function _createProxyFunction(source, funcName) {
+        var srcFunc = null;
+        var src = null;
+        if (isFunction(source)) {
+            srcFunc = source;
         }
-        var classProto = theClass[Prototype];
-        if (!_checkPrototype(classProto, target)) {
-            _throwTypeError("[" + _getObjName(theClass) + "] is not in class hierarchy of [" + _getObjName(target) + "]");
+        else {
+            src = source;
         }
-        var className = null;
-        if (_hasOwnProperty(classProto, DynClassName)) {
-            className = classProto[DynClassName];
+        return function () {
+            var originalArguments = arguments;
+            if (srcFunc) {
+                src = srcFunc();
+            }
+            if (src) {
+                return src[funcName][_DYN_APPLY ](src, originalArguments);
+            }
+        };
+    }
+    function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
+        if (target && name && source) {
+            if (overwriteTarget !== false || isUndefined(target[name])) {
+                target[name] = _createProxyFunction(source, theFunc);
+            }
         }
-        else {
-            className = DynClassNamePrefix + _getObjName(theClass, "_") + "$" + _dynamicNames;
-            _dynamicNames++;
-            classProto[DynClassName] = className;
+    }
+    function objExtend(obj1, obj2, obj3, obj4, obj5, obj6) {
+        var theArgs = arguments;
+        var extended = theArgs[0] || {};
+        var argLen = theArgs[_DYN_LENGTH$2 ];
+        var deep = false;
+        var idx = 1;
+        if (argLen > 0 && isBoolean(extended)) {
+            deep = extended;
+            extended = theArgs[idx] || {};
+            idx++;
         }
-        var perfOptions = dynamicProto[DynProtoDefaultOptions];
-        var useBaseInst = !!perfOptions[strUseBaseInst];
-        if (useBaseInst && options && options[strUseBaseInst] !== undefined) {
-            useBaseInst = !!options[strUseBaseInst];
+        if (!isObject(extended)) {
+            extended = {};
         }
-        var instFuncs = _getInstanceFuncs(target);
-        var baseFuncs = _getBaseFuncs(classProto, target, instFuncs, useBaseInst);
-        delegateFunc(target, baseFuncs);
-        var setInstanceFunc = !!_objGetPrototypeOf && !!perfOptions[strSetInstFuncs];
-        if (setInstanceFunc && options) {
-            setInstanceFunc = !!options[strSetInstFuncs];
+        for (; idx < argLen; idx++) {
+            var arg = theArgs[idx];
+            var isArgArray = isArray(arg);
+            var isArgObj = isObject(arg);
+            for (var prop in arg) {
+                var propOk = (isArgArray && (prop in arg)) || (isArgObj && (ObjHasOwnProperty[_DYN_CALL ](arg, prop)));
+                if (!propOk) {
+                    continue;
+                }
+                var newValue = arg[prop];
+                var isNewArray = void 0;
+                if (deep && newValue && ((isNewArray = isArray(newValue)) || isPlainObject(newValue))) {
+                    var clone = extended[prop];
+                    if (isNewArray) {
+                        if (!isArray(clone)) {
+                            clone = [];
+                        }
+                    }
+                    else if (!isPlainObject(clone)) {
+                        clone = {};
+                    }
+                    newValue = objExtend(deep, clone, newValue);
+                }
+                if (newValue !== undefined) {
+                    extended[prop] = newValue;
+                }
+            }
         }
-        _populatePrototype(classProto, className, target, instFuncs, setInstanceFunc !== false);
+        return extended;
+    }
+
+    function createValueMap(values) {
+        var mapClass = {};
+        objForEachKey(values, function (field, value) {
+            mapClass[field] = value[1];
+            mapClass[value[0]] = value[1];
+        });
+        return deepFreeze(mapClass);
     }
-    var perfDefaults = {
-        setInstFuncs: true,
-        useBaseInst: true
-    };
-    dynamicProto[DynProtoDefaultOptions] = perfDefaults;
 
     var strWindow = "window";
     var strDocument = "document";
@@ -789,9 +837,9 @@
     }
     function isIE() {
         var nav = getNavigator();
-        if (nav && (nav.userAgent !== _navUserAgentCheck || _isTrident === null)) {
-            _navUserAgentCheck = nav.userAgent;
-            var userAgent = (_navUserAgentCheck || strEmpty$1).toLowerCase();
+        if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
+            _navUserAgentCheck = nav[_DYN_USER_AGENT ];
+            var userAgent = (_navUserAgentCheck || STR_EMPTY)[_DYN_TO_LOWER_CASE$2 ]();
             _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
         }
         return _isTrident;
@@ -800,15 +848,15 @@
         if (userAgentStr === void 0) { userAgentStr = null; }
         if (!userAgentStr) {
             var navigator_1 = getNavigator() || {};
-            userAgentStr = navigator_1 ? (navigator_1.userAgent || strEmpty$1).toLowerCase() : strEmpty$1;
+            userAgentStr = navigator_1 ? (navigator_1[_DYN_USER_AGENT ] || STR_EMPTY)[_DYN_TO_LOWER_CASE$2 ]() : STR_EMPTY;
         }
-        var ua = (userAgentStr || strEmpty$1).toLowerCase();
+        var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE$2 ]();
         if (strContains(ua, strMsie)) {
             var doc = getDocument() || {};
-            return Math.max(parseInt(ua.split(strMsie)[1]), (doc[strDocumentMode] || 0));
+            return Math.max(parseInt(ua[_DYN_SPLIT$1 ](strMsie)[1]), (doc[strDocumentMode] || 0));
         }
         else if (strContains(ua, strTrident)) {
-            var tridentVer = parseInt(ua.split(strTrident)[1]);
+            var tridentVer = parseInt(ua[_DYN_SPLIT$1 ](strTrident)[1]);
             if (tridentVer) {
                 return tridentVer + 4;
             }
@@ -816,10 +864,10 @@
         return null;
     }
     function dumpObj(object) {
-        var objectTypeDump = Object[strShimPrototype].toString.call(object);
-        var propertyValueDump = strEmpty$1;
+        var objectTypeDump = Object[strShimPrototype].toString[_DYN_CALL ](object);
+        var propertyValueDump = STR_EMPTY;
         if (objectTypeDump === "[object Error]") {
-            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
+            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object[_DYN_NAME$2 ] + "'";
         }
         else if (hasJSON()) {
             propertyValueDump = getJSON().stringify(object);
@@ -856,13 +904,11 @@
     var AiNonUserActionablePrefix = "AI (Internal): ";
     var AiUserActionablePrefix = "AI: ";
     var AIInternalMessagePrefix = "AITR_";
-    var strErrorToConsole = "errorToConsole";
-    var strWarnToConsole = "warnToConsole";
     function _sanitizeDiagnosticText(text) {
         if (text) {
-            return "\"" + text.replace(/\"/g, strEmpty$1) + "\"";
+            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY) + "\"";
         }
-        return strEmpty$1;
+        return STR_EMPTY;
     }
     function _logToConsole(func, message) {
         var theConsole = getConsole();
@@ -880,23 +926,23 @@
         function _InternalLogMessage(msgId, msg, isUserAct, properties) {
             if (isUserAct === void 0) { isUserAct = false; }
             var _self = this;
-            _self.messageId = msgId;
-            _self.message =
+            _self[_DYN_MESSAGE_ID ] = msgId;
+            _self[_DYN_MESSAGE ] =
                 (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
                     msgId;
-            var strProps = strEmpty$1;
+            var strProps = STR_EMPTY;
             if (hasJSON()) {
                 strProps = getJSON().stringify(properties);
             }
-            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : strEmpty$1) +
-                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : strEmpty$1);
-            _self.message += diagnosticText;
+            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY) +
+                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
+            _self[_DYN_MESSAGE ] += diagnosticText;
         }
         _InternalLogMessage.dataType = "MessageData";
         return _InternalLogMessage;
     }());
     function safeGetLogger(core, config) {
-        return (core || {}).logger || new DiagnosticLogger(config);
+        return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
     }
     var DiagnosticLogger = /** @class */ (function () {
         function DiagnosticLogger(config) {
@@ -904,48 +950,49 @@
             this.queue = [];
             var _messageCount = 0;
             var _messageLogged = {};
+            var _loggingLevelConsole;
+            var _loggingLevelTelemetry;
+            var _maxInternalMessageLimit;
+            var _enableDebugExceptions;
             dynamicProto(DiagnosticLogger, this, function (_self) {
-                if (isNullOrUndefined(config)) {
-                    config = {};
-                }
-                _self.consoleLoggingLevel = function () { return _getConfigValue("loggingLevelConsole", 0); };
-                _self.telemetryLoggingLevel = function () { return _getConfigValue("loggingLevelTelemetry", 1); };
-                _self.maxInternalMessageLimit = function () { return _getConfigValue("maxMessageLimit", 25); };
-                _self.enableDebugExceptions = function () { return _getConfigValue("enableDebugExceptions", false); };
+                _setDefaultsFromConfig(config || {});
+                _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
+                _self.telemetryLoggingLevel = function () { return _loggingLevelTelemetry; };
+                _self.maxInternalMessageLimit = function () { return _maxInternalMessageLimit; };
+                _self[_DYN_ENABLE_DEBUG_EXCEPTI4 ] = function () { return _enableDebugExceptions; };
                 _self.throwInternal = function (severity, msgId, msg, properties, isUserAct) {
                     if (isUserAct === void 0) { isUserAct = false; }
                     var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
-                    if (_self.enableDebugExceptions()) {
+                    if (_enableDebugExceptions) {
                         throw dumpObj(message);
                     }
                     else {
-                        var logFunc = severity === 1  ? strErrorToConsole : strWarnToConsole;
-                        if (!isUndefined(message.message)) {
-                            var logLevel = _self.consoleLoggingLevel();
+                        var logFunc = severity === 1  ? STR_ERROR_TO_CONSOLE : STR_WARN_TO_CONSOLE;
+                        if (!isUndefined(message[_DYN_MESSAGE ])) {
                             if (isUserAct) {
-                                var messageKey = +message.messageId;
-                                if (!_messageLogged[messageKey] && logLevel >= severity) {
-                                    _self[logFunc](message.message);
+                                var messageKey = +message[_DYN_MESSAGE_ID ];
+                                if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
+                                    _self[logFunc](message[_DYN_MESSAGE ]);
                                     _messageLogged[messageKey] = true;
                                 }
                             }
                             else {
-                                if (logLevel >= severity) {
-                                    _self[logFunc](message.message);
+                                if (_loggingLevelConsole >= severity) {
+                                    _self[logFunc](message[_DYN_MESSAGE ]);
                                 }
                             }
-                            _self.logInternalMessage(severity, message);
+                            _logInternalMessage(severity, message);
                         }
                         else {
                             _debugExtMsg("throw" + (severity === 1  ? "Critical" : "Warning"), message);
                         }
                     }
                 };
-                _self.warnToConsole = function (message) {
+                _self[STR_WARN_TO_CONSOLE ] = function (message) {
                     _logToConsole("warn", message);
                     _debugExtMsg("warning", message);
                 };
-                _self.errorToConsole = function (message) {
+                _self[STR_ERROR_TO_CONSOLE ] = function (message) {
                     _logToConsole("error", message);
                     _debugExtMsg("error", message);
                 };
@@ -953,12 +1000,13 @@
                     _messageCount = 0;
                     _messageLogged = {};
                 };
-                _self.logInternalMessage = function (severity, message) {
+                _self[_DYN_LOG_INTERNAL_MESSAGE ] = _logInternalMessage;
+                function _logInternalMessage(severity, message) {
                     if (_areInternalMessagesThrottled()) {
                         return;
                     }
                     var logMessage = true;
-                    var messageKey = AIInternalMessagePrefix + message.messageId;
+                    var messageKey = AIInternalMessagePrefix + message[_DYN_MESSAGE_ID ];
                     if (_messageLogged[messageKey]) {
                         logMessage = false;
                     }
@@ -966,38 +1014,37 @@
                         _messageLogged[messageKey] = true;
                     }
                     if (logMessage) {
-                        if (severity <= _self.telemetryLoggingLevel()) {
-                            _self.queue.push(message);
+                        if (severity <= _loggingLevelTelemetry) {
+                            _self.queue[_DYN_PUSH ](message);
                             _messageCount++;
                             _debugExtMsg((severity === 1  ? "error" : "warn"), message);
                         }
-                        if (_messageCount === _self.maxInternalMessageLimit()) {
+                        if (_messageCount === _maxInternalMessageLimit) {
                             var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
                             var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
-                            _self.queue.push(throttleMessage);
+                            _self.queue[_DYN_PUSH ](throttleMessage);
                             if (severity === 1 ) {
-                                _self.errorToConsole(throttleLimitMessage);
+                                _self[STR_ERROR_TO_CONSOLE ](throttleLimitMessage);
                             }
                             else {
-                                _self.warnToConsole(throttleLimitMessage);
+                                _self[STR_WARN_TO_CONSOLE ](throttleLimitMessage);
                             }
                         }
                     }
-                };
-                function _getConfigValue(name, defValue) {
-                    var value = config[name];
-                    if (!isNullOrUndefined(value)) {
-                        return value;
-                    }
-                    return defValue;
+                }
+                function _setDefaultsFromConfig(config) {
+                    _loggingLevelConsole = getCfgValue(config.loggingLevelConsole, 0);
+                    _loggingLevelTelemetry = getCfgValue(config.loggingLevelTelemetry, 1);
+                    _maxInternalMessageLimit = getCfgValue(config.maxMessageLimit, 25);
+                    _enableDebugExceptions = getCfgValue(config[_DYN_ENABLE_DEBUG_EXCEPTI4 ], false);
                 }
                 function _areInternalMessagesThrottled() {
-                    return _messageCount >= _self.maxInternalMessageLimit();
+                    return _messageCount >= _maxInternalMessageLimit;
                 }
                 function _debugExtMsg(name, data) {
-                    var dbgExt = getDebugExt(config);
-                    if (dbgExt && dbgExt.diagLog) {
-                        dbgExt.diagLog(name, data);
+                    var dbgExt = getDebugExt(config || {});
+                    if (dbgExt && dbgExt[_DYN_DIAG_LOG ]) {
+                        dbgExt[_DYN_DIAG_LOG ](name, data);
                     }
                 }
             });
@@ -1005,20 +1052,25 @@
         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; }
-        (logger || new DiagnosticLogger()).throwInternal(severity, msgId, msg, properties, isUserAct);
+        _getLogger(logger).throwInternal(severity, msgId, msg, properties, isUserAct);
     }
 
     var strExecutionContextKey = "ctx";
+    var strParentContextKey = "ParentContextKey";
+    var strChildrenContextKey = "ChildrenContextKey";
     var PerfEvent = /** @class */ (function () {
         function PerfEvent(name, payloadDetails, isAsync) {
             var _self = this;
             var accessorDefined = false;
             _self.start = dateNow();
-            _self.name = name;
-            _self.isAsync = isAsync;
-            _self.isChildEvt = function () { return false; };
+            _self[_DYN_NAME$2 ] = name;
+            _self[_DYN_IS_ASYNC ] = isAsync;
+            _self[_DYN_IS_CHILD_EVT ] = function () { return false; };
             if (isFunction(payloadDetails)) {
                 var theDetails_1;
                 accessorDefined = objDefineAccessors(_self, "payload", function () {
@@ -1029,24 +1081,24 @@
                     return theDetails_1;
                 });
             }
-            _self.getCtx = function (key) {
+            _self[_DYN_GET_CTX ] = function (key) {
                 if (key) {
-                    if (key === PerfEvent.ParentContextKey || key === PerfEvent.ChildrenContextKey) {
+                    if (key === PerfEvent[strParentContextKey] || key === PerfEvent[strChildrenContextKey]) {
                         return _self[key];
                     }
                     return (_self[strExecutionContextKey] || {})[key];
                 }
                 return null;
             };
-            _self.setCtx = function (key, value) {
+            _self[_DYN_SET_CTX ] = function (key, value) {
                 if (key) {
-                    if (key === PerfEvent.ParentContextKey) {
+                    if (key === PerfEvent[strParentContextKey]) {
                         if (!_self[key]) {
-                            _self.isChildEvt = function () { return true; };
+                            _self[_DYN_IS_CHILD_EVT ] = function () { return true; };
                         }
                         _self[key] = value;
                     }
-                    else if (key === PerfEvent.ChildrenContextKey) {
+                    else if (key === PerfEvent[strChildrenContextKey]) {
                         _self[key] = value;
                     }
                     else {
@@ -1055,20 +1107,20 @@
                     }
                 }
             };
-            _self.complete = function () {
+            _self[_DYN_COMPLETE ] = function () {
                 var childTime = 0;
-                var childEvts = _self.getCtx(PerfEvent.ChildrenContextKey);
+                var childEvts = _self[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
                 if (isArray(childEvts)) {
-                    for (var lp = 0; lp < childEvts.length; lp++) {
+                    for (var lp = 0; lp < childEvts[_DYN_LENGTH$2 ]; lp++) {
                         var childEvt = childEvts[lp];
                         if (childEvt) {
-                            childTime += childEvt.time;
+                            childTime += childEvt[_DYN_TIME ];
                         }
                     }
                 }
-                _self.time = dateNow() - _self.start;
-                _self.exTime = _self.time - childTime;
-                _self.complete = function () { };
+                _self[_DYN_TIME ] = dateNow() - _self.start;
+                _self.exTime = _self[_DYN_TIME ] - childTime;
+                _self[_DYN_COMPLETE ] = function () { };
                 if (!accessorDefined && isFunction(payloadDetails)) {
                     _self.payload = payloadDetails();
                 }
@@ -1082,40 +1134,40 @@
     function doPerf(mgrSource, getSource, func, details, isAsync) {
         if (mgrSource) {
             var perfMgr = mgrSource;
-            if (isFunction(perfMgr["getPerfMgr"])) {
-                perfMgr = perfMgr["getPerfMgr"]();
+            if (perfMgr[STR_GET_PERF_MGR]) {
+                perfMgr = perfMgr[STR_GET_PERF_MGR]();
             }
             if (perfMgr) {
                 var perfEvt = void 0;
-                var currentActive = perfMgr.getCtx(doPerfActiveKey);
+                var currentActive = perfMgr[_DYN_GET_CTX ](doPerfActiveKey);
                 try {
                     perfEvt = perfMgr.create(getSource(), details, isAsync);
                     if (perfEvt) {
-                        if (currentActive && perfEvt.setCtx) {
-                            perfEvt.setCtx(PerfEvent.ParentContextKey, currentActive);
-                            if (currentActive.getCtx && currentActive.setCtx) {
-                                var children = currentActive.getCtx(PerfEvent.ChildrenContextKey);
+                        if (currentActive && perfEvt[_DYN_SET_CTX ]) {
+                            perfEvt[_DYN_SET_CTX ](PerfEvent[strParentContextKey], currentActive);
+                            if (currentActive[_DYN_GET_CTX ] && currentActive[_DYN_SET_CTX ]) {
+                                var children = currentActive[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
                                 if (!children) {
                                     children = [];
-                                    currentActive.setCtx(PerfEvent.ChildrenContextKey, children);
+                                    currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
                                 }
-                                children.push(perfEvt);
+                                children[_DYN_PUSH ](perfEvt);
                             }
                         }
-                        perfMgr.setCtx(doPerfActiveKey, perfEvt);
+                        perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
                         return func(perfEvt);
                     }
                 }
                 catch (ex) {
-                    if (perfEvt && perfEvt.setCtx) {
-                        perfEvt.setCtx("exception", ex);
+                    if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
+                        perfEvt[_DYN_SET_CTX ]("exception", ex);
                     }
                 }
                 finally {
                     if (perfEvt) {
                         perfMgr.fire(perfEvt);
                     }
-                    perfMgr.setCtx(doPerfActiveKey, currentActive);
+                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
                 }
             }
         }
@@ -1177,8 +1229,8 @@
         var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
         var number = random32() >>> 0;
         var chars = 0;
-        var result = strEmpty$1;
-        while (result.length < maxLength) {
+        var result = STR_EMPTY;
+        while (result[_DYN_LENGTH$2 ] < maxLength) {
             chars++;
             result += base64chars.charAt(number & 0x3F);
             number >>>= 6;
@@ -1191,7 +1243,7 @@
     }
 
     var _objDefineProperty = ObjDefineProperty;
-    var version = "2.8.5-nightly.2206-04";
+    var version = "2.8.5-nightly.2207-02";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _createAccessor(target, prop, value) {
@@ -1210,7 +1262,7 @@
         return false;
     }
     function _canAcceptData(target) {
-        return target.nodeType === 1 || target.nodeType === 9 || !(+target.nodeType);
+        return target[_DYN_NODE_TYPE ] === 1 || target[_DYN_NODE_TYPE ] === 9 || !(+target[_DYN_NODE_TYPE ]);
     }
     function _getCache(data, target) {
         var theCache = target[data.id];
@@ -1230,11 +1282,11 @@
     }
     function createUniqueNamespace(name, includeVersion) {
         if (includeVersion === void 0) { includeVersion = false; }
-        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : "") + instanceName);
+        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
     }
     function createElmNodeData(name) {
         var data = {
-            id: createUniqueNamespace("_aiData-" + (name || "") + "." + version),
+            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
             accept: function (target) {
                 return _canAcceptData(target);
             },
@@ -1274,16 +1326,17 @@
     var elmNodeData = createElmNodeData("events");
     var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
     function _normalizeNamespace(name) {
-        if (name && name.replace) {
-            return name.replace(/^\s*\.*|\.*\s*$/g, "");
+        if (name && name[_DYN_REPLACE ]) {
+            return name.replace(/^\s*\.*|\.*\s*$/g, STR_EMPTY);
         }
         return name;
     }
     function _getEvtNamespace(eventName, evtNamespace) {
+        var _a;
         if (evtNamespace) {
-            var theNamespace_1 = "";
+            var theNamespace_1 = STR_EMPTY;
             if (isArray(evtNamespace)) {
-                theNamespace_1 = "";
+                theNamespace_1 = STR_EMPTY;
                 arrForEach(evtNamespace, function (name) {
                     name = _normalizeNamespace(name);
                     if (name) {
@@ -1301,14 +1354,14 @@
                 if (theNamespace_1[0] !== ".") {
                     theNamespace_1 = "." + theNamespace_1;
                 }
-                eventName = (eventName || "") + theNamespace_1;
+                eventName = (eventName || STR_EMPTY) + theNamespace_1;
             }
         }
-        var parsedEvent = (eventNamespace.exec(eventName || "") || []);
-        return {
-            type: parsedEvent[1],
-            ns: ((parsedEvent[2] || "").replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, "").split(".").sort()).join(".")
-        };
+        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);
+        return _a = {},
+            _a[_DYN_TYPE ] = parsedEvent[1],
+            _a.ns = ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT$1 ](".").sort()).join("."),
+            _a;
     }
     function _getRegisteredEvents(target, evtName, addDefault) {
         if (addDefault === void 0) { addDefault = true; }
@@ -1321,13 +1374,13 @@
     }
     function _doAttach(obj, evtName, handlerRef, useCapture) {
         var result = false;
-        if (obj && evtName && evtName.type && handlerRef) {
+        if (obj && evtName && evtName[_DYN_TYPE ] && handlerRef) {
             if (obj[strAddEventHelper]) {
-                obj[strAddEventHelper](evtName.type, handlerRef, useCapture);
+                obj[strAddEventHelper](evtName[_DYN_TYPE ], handlerRef, useCapture);
                 result = true;
             }
             else if (obj[strAttachEvent]) {
-                obj[strAttachEvent](strOnPrefix + evtName.type, handlerRef);
+                obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
                 result = true;
             }
         }
@@ -1342,7 +1395,7 @@
             else {
                 newNamespaces = [theNamespace, namespaces];
             }
-            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns).split(".");
+            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT$1 ](".");
         }
         else {
             newNamespaces = theNamespace;
@@ -1350,6 +1403,7 @@
         return newNamespaces;
     }
     function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
+        var _a;
         if (useCapture === void 0) { useCapture = false; }
         var result = false;
         if (target) {
@@ -1357,13 +1411,14 @@
                 var evtName = _getEvtNamespace(eventName, evtNamespace);
                 result = _doAttach(target, evtName, handlerRef, useCapture);
                 if (result && elmNodeData.accept(target)) {
-                    var registeredEvent = {
-                        guid: _guid++,
-                        evtName: evtName,
-                        handler: handlerRef,
-                        capture: useCapture
-                    };
-                    _getRegisteredEvents(target, evtName.type).push(registeredEvent);
+                    var registeredEvent = (_a = {
+                            guid: _guid++,
+                            evtName: evtName
+                        },
+                        _a[_DYN_HANDLER ] = handlerRef,
+                        _a.capture = useCapture,
+                        _a);
+                    _getRegisteredEvents(target, evtName.type)[_DYN_PUSH ](registeredEvent);
                 }
             }
             catch (e) {
@@ -1374,7 +1429,7 @@
 
     function generateW3CId() {
         var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
-        var oct = strEmpty$1, tmp;
+        var oct = STR_EMPTY, tmp;
         for (var a = 0; a < 4; a++) {
             tmp = random32();
             oct +=
@@ -1388,7 +1443,7 @@
                     hexValues[tmp >> 28 & 0xF];
         }
         var clockSequenceHi = hexValues[8 + (random32() & 0x03) | 0];
-        return oct.substr(0, 8) + oct.substr(9, 4) + "4" + oct.substr(13, 3) + clockSequenceHi + oct.substr(16, 3) + oct.substr(19, 12);
+        return oct[_DYN_SUBSTR ](0, 8) + oct[_DYN_SUBSTR ](9, 4) + "4" + oct[_DYN_SUBSTR ](13, 3) + clockSequenceHi + oct[_DYN_SUBSTR ](16, 3) + oct[_DYN_SUBSTR ](19, 12);
     }
 
     var DEFAULT_VERSION = "00";
@@ -1396,7 +1451,7 @@
     var INVALID_TRACE_ID = "00000000000000000000000000000000";
     var INVALID_SPAN_ID = "0000000000000000";
     function _isValid(value, len, invalidValue) {
-        if (value && value.length === len && value !== invalidValue) {
+        if (value && value[_DYN_LENGTH$2 ] === len && value !== invalidValue) {
             return !!value.match(/^[\da-f]*$/);
         }
         return false;
@@ -1412,18 +1467,19 @@
             value = 0x01;
         }
         var result = value.toString(16);
-        while (result.length < 2) {
+        while (result[_DYN_LENGTH$2 ] < 2) {
             result = "0" + result;
         }
         return result;
     }
     function createTraceParent(traceId, spanId, flags, version) {
-        return {
-            version: _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
-            traceId: isValidTraceId(traceId) ? traceId : generateW3CId(),
-            spanId: isValidSpanId(spanId) ? spanId : generateW3CId().substr(0, 16),
-            traceFlags: flags >= 0 && flags <= 0xFF ? flags : 1
-        };
+        var _a;
+        return _a = {},
+            _a[_DYN_VERSION ] = _isValid(version, 2, INVALID_VERSION) ? version : DEFAULT_VERSION,
+            _a[_DYN_TRACE_ID$1 ] = isValidTraceId(traceId) ? traceId : generateW3CId(),
+            _a.spanId = isValidSpanId(spanId) ? spanId : generateW3CId()[_DYN_SUBSTR ](0, 16),
+            _a.traceFlags = flags >= 0 && flags <= 0xFF ? flags : 1,
+            _a;
     }
     function isValidTraceId(value) {
         return _isValid(value, 32, INVALID_TRACE_ID);
@@ -1433,11 +1489,11 @@
     }
     function formatTraceParent(value) {
         if (value) {
-            var flags = _formatFlags(value.traceFlags);
+            var flags = _formatFlags(value[_DYN_TRACE_FLAGS$1 ]);
             if (!_isValid(flags, 2)) {
                 flags = "01";
             }
-            var version = value.version || DEFAULT_VERSION;
+            var version = value[_DYN_VERSION ] || DEFAULT_VERSION;
             if (version !== "00" && version !== "ff") {
                 version = DEFAULT_VERSION;
             }
@@ -1457,12 +1513,12 @@
     var _chainId = 0;
     function _getNextProxyStart(proxy, core, startAt) {
         while (proxy) {
-            if (proxy.getPlugin() === startAt) {
+            if (proxy[_DYN_GET_PLUGIN ]() === startAt) {
                 return proxy;
             }
-            proxy = proxy.getNext();
+            proxy = proxy[_DYN_GET_NEXT ]();
         }
-        return createTelemetryProxyChain([startAt], core.config || {}, core);
+        return createTelemetryProxyChain([startAt], core[_DYN_CONFIG ] || {}, core);
     }
     function _createInternalContext(telemetryChain, config, core, startAt) {
         var _nextProxy = null;
@@ -1503,7 +1559,7 @@
                 args[_i - 2] = arguments[_i];
             }
             if (onComplete) {
-                _onComplete.push({
+                _onComplete[_DYN_PUSH ]({
                     func: onComplete,
                     self: !isUndefined(that) ? that : context.ctx,
                     args: args
@@ -1512,16 +1568,16 @@
         }
         function _moveNext() {
             var nextProxy = _nextProxy;
-            _nextProxy = nextProxy ? nextProxy.getNext() : null;
+            _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT ]() : null;
             if (!nextProxy) {
                 var onComplete = _onComplete;
-                if (onComplete && onComplete.length > 0) {
+                if (onComplete && onComplete[_DYN_LENGTH$2 ] > 0) {
                     arrForEach(onComplete, function (completeDetails) {
                         try {
-                            completeDetails.func.call(completeDetails.self, completeDetails.args);
+                            completeDetails.func[_DYN_CALL ](completeDetails.self, completeDetails.args);
                         }
                         catch (e) {
-                            _throwInternal(core.logger, 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
+                            _throwInternal(core[_DYN_LOGGER ], 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
                         }
                     });
                     _onComplete = [];
@@ -1534,7 +1590,7 @@
             if (mergeDefault === void 0) { mergeDefault = 0 ; }
             var theConfig;
             if (config) {
-                var extConfig = config.extensionConfig;
+                var extConfig = config[STR_EXTENSION_CONFIG ];
                 if (extConfig && identifier) {
                     theConfig = extConfig[identifier];
                 }
@@ -1575,7 +1631,7 @@
         function _iterateChain(cb) {
             var nextPlugin;
             while (!!(nextPlugin = context._next())) {
-                var plugin = nextPlugin.getPlugin();
+                var plugin = nextPlugin[_DYN_GET_PLUGIN ]();
                 if (plugin) {
                     cb(plugin);
                 }
@@ -1588,7 +1644,7 @@
         var context = internalContext.ctx;
         function _processNext(env) {
             var nextPlugin = internalContext._next();
-            nextPlugin && nextPlugin.processTelemetry(env, context);
+            nextPlugin && nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
             return !nextPlugin;
         }
         function _createNew(plugins, startAt) {
@@ -1596,14 +1652,14 @@
             if (isArray(plugins)) {
                 plugins = createTelemetryProxyChain(plugins, config, core, startAt);
             }
-            return createProcessTelemetryContext(plugins || context.getNext(), config, core, startAt);
+            return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config, core, startAt);
         }
-        context.processNext = _processNext;
-        context.createNew = _createNew;
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
         return context;
     }
     function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
-        var config = core.config || {};
+        var config = core[_DYN_CONFIG ] || {};
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(unloadState) {
@@ -1616,20 +1672,20 @@
             if (isArray(plugins)) {
                 plugins = createTelemetryProxyChain(plugins, config, core, startAt);
             }
-            return createProcessTelemetryUnloadContext(plugins || context.getNext(), core, startAt);
+            return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
         }
-        context.processNext = _processNext;
-        context.createNew = _createNew;
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
         return context;
     }
     function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
-        var config = core.config || {};
+        var config = core[_DYN_CONFIG ] || {};
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(updateState) {
             return context.iterate(function (plugin) {
-                if (isFunction(plugin.update)) {
-                    plugin.update(context, updateState);
+                if (isFunction(plugin[_DYN_UPDATE ])) {
+                    plugin[_DYN_UPDATE ](context, updateState);
                 }
             });
         }
@@ -1638,22 +1694,22 @@
             if (isArray(plugins)) {
                 plugins = createTelemetryProxyChain(plugins, config, core, startAt);
             }
-            return createProcessTelemetryUpdateContext(plugins || context.getNext(), core, startAt);
+            return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
         }
-        context.processNext = _processNext;
-        context.createNew = _createNew;
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
         return context;
     }
     function createTelemetryProxyChain(plugins, config, core, startAt) {
         var firstProxy = null;
         var add = startAt ? false : true;
-        if (isArray(plugins) && plugins.length > 0) {
+        if (isArray(plugins) && plugins[_DYN_LENGTH$2 ] > 0) {
             var lastProxy_1 = null;
             arrForEach(plugins, function (thePlugin) {
                 if (!add && startAt === thePlugin) {
                     add = true;
                 }
-                if (add && thePlugin && isFunction(thePlugin.processTelemetry)) {
+                if (add && thePlugin && isFunction(thePlugin[STR_PROCESS_TELEMETRY ])) {
                     var newProxy = createTelemetryPluginProxy(thePlugin, config, core);
                     if (!firstProxy) {
                         firstProxy = newProxy;
@@ -1672,11 +1728,11 @@
     }
     function createTelemetryPluginProxy(plugin, config, core) {
         var nextProxy = null;
-        var hasProcessTelemetry = isFunction(plugin.processTelemetry);
-        var hasSetNext = isFunction(plugin.setNextPlugin);
+        var hasProcessTelemetry = isFunction(plugin[STR_PROCESS_TELEMETRY ]);
+        var hasSetNext = isFunction(plugin[_DYN_SET_NEXT_PLUGIN ]);
         var chainId;
         if (plugin) {
-            chainId = plugin.identifier + "-" + plugin.priority + "-" + _chainId++;
+            chainId = plugin[_DYN_IDENTIFIER ] + "-" + plugin[STR_PRIORITY ] + "-" + _chainId++;
         }
         else {
             chainId = "Unknown-0-" + _chainId++;
@@ -1708,17 +1764,17 @@
         }
         function _processChain(itemCtx, processPluginFn, name, details, isAsync) {
             var hasRun = false;
-            var identifier = plugin ? plugin.identifier : strTelemetryPluginChain;
+            var identifier = plugin ? plugin[_DYN_IDENTIFIER ] : strTelemetryPluginChain;
             var hasRunContext = itemCtx[strHasRunFlags];
             if (!hasRunContext) {
                 hasRunContext = itemCtx[strHasRunFlags] = {};
             }
             itemCtx.setNext(nextProxy);
             if (plugin) {
-                doPerf(itemCtx[strCore](), function () { return identifier + ":" + name; }, function () {
+                doPerf(itemCtx[STR_CORE ](), function () { return identifier + ":" + name; }, function () {
                     hasRunContext[chainId] = true;
                     try {
-                        var nextId = nextProxy ? nextProxy._id : strEmpty$1;
+                        var nextId = nextProxy ? nextProxy._id : STR_EMPTY;
                         if (nextId) {
                             hasRunContext[nextId] = false;
                         }
@@ -1730,7 +1786,7 @@
                             hasRun = true;
                         }
                         if (!nextProxy || !hasNextRun) {
-                            _throwInternal(itemCtx.diagLog(), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
+                            _throwInternal(itemCtx[_DYN_DIAG_LOG ](), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
                         }
                     }
                 }, details, isAsync);
@@ -1744,17 +1800,17 @@
                     return false;
                 }
                 var pluginState = _getPluginState(plugin);
-                if (pluginState.teardown || pluginState[strDisabled]) {
+                if (pluginState[_DYN_TEARDOWN ] || pluginState[STR_DISABLED]) {
                     return false;
                 }
                 if (hasSetNext) {
-                    plugin.setNextPlugin(nextProxy);
+                    plugin[_DYN_SET_NEXT_PLUGIN ](nextProxy);
                 }
-                plugin.processTelemetry(env, itemCtx);
+                plugin[STR_PROCESS_TELEMETRY ](env, itemCtx);
                 return true;
             }
             if (!_processChain(itemCtx, _callProcessTelemetry, "processTelemetry", function () { return ({ item: env }); }, !(env.sync))) {
-                itemCtx.processNext(env);
+                itemCtx[_DYN_PROCESS_NEXT ](env);
             }
         }
         function _unloadPlugin(unloadCtx, unloadState) {
@@ -1762,20 +1818,20 @@
                 var hasRun = false;
                 if (plugin) {
                     var pluginState = _getPluginState(plugin);
-                    var pluginCore = plugin[strCore] || pluginState.core;
-                    if (plugin && (!pluginCore || pluginCore === unloadCtx[strCore]()) && !pluginState[strTeardown]) {
-                        pluginState[strCore] = null;
-                        pluginState[strTeardown] = true;
-                        pluginState[strIsInitialized] = false;
-                        if (plugin[strTeardown] && plugin[strTeardown](unloadCtx, unloadState) === true) {
+                    var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE ];
+                    if (plugin && (!pluginCore || pluginCore === unloadCtx.core()) && !pluginState[_DYN_TEARDOWN ]) {
+                        pluginState[STR_CORE ] = null;
+                        pluginState[_DYN_TEARDOWN ] = true;
+                        pluginState[_DYN_IS_INITIALIZED ] = false;
+                        if (plugin[_DYN_TEARDOWN ] && plugin[_DYN_TEARDOWN ](unloadCtx, unloadState) === true) {
                             hasRun = true;
                         }
                     }
                 }
                 return hasRun;
             }
-            if (!_processChain(unloadCtx, _callTeardown, "unload", function () { }, unloadState.isAsync)) {
-                unloadCtx.processNext(unloadState);
+            if (!_processChain(unloadCtx, _callTeardown, "unload", function () { }, unloadState[_DYN_IS_ASYNC ])) {
+                unloadCtx[_DYN_PROCESS_NEXT ](unloadState);
             }
         }
         function _updatePlugin(updateCtx, updateState) {
@@ -1783,9 +1839,9 @@
                 var hasRun = false;
                 if (plugin) {
                     var pluginState = _getPluginState(plugin);
-                    var pluginCore = plugin[strCore] || pluginState.core;
-                    if (plugin && (!pluginCore || pluginCore === updateCtx[strCore]()) && !pluginState[strTeardown]) {
-                        if (plugin[strUpdate] && plugin[strUpdate](updateCtx, updateState) === true) {
+                    var pluginCore = plugin[STR_CORE] || pluginState[STR_CORE ];
+                    if (plugin && (!pluginCore || pluginCore === updateCtx.core()) && !pluginState[_DYN_TEARDOWN ]) {
+                        if (plugin[_DYN_UPDATE ] && plugin[_DYN_UPDATE ](updateCtx, updateState) === true) {
                             hasRun = true;
                         }
                     }
@@ -1793,19 +1849,17 @@
                 return hasRun;
             }
             if (!_processChain(updateCtx, _callUpdate, "update", function () { }, false)) {
-                updateCtx.processNext(updateState);
+                updateCtx[_DYN_PROCESS_NEXT ](updateState);
             }
         }
         return objFreeze(proxyChain);
     }
 
-    var strExtensionConfig = "extensionConfig";
-
     function createUnloadHandlerContainer() {
         var handlers = [];
         function _addHandler(handler) {
             if (handler) {
-                handlers.push(handler);
+                handlers[_DYN_PUSH ](handler);
             }
         }
         function _runHandlers(unloadCtx, unloadState) {
@@ -1814,7 +1868,7 @@
                     handler(unloadCtx, unloadState);
                 }
                 catch (e) {
-                    _throwInternal(unloadCtx.diagLog(), 2 , 73 , "Unexpected error calling unload handler - " + dumpObj(e));
+                    _throwInternal(unloadCtx[_DYN_DIAG_LOG ](), 2 , 73 , "Unexpected error calling unload handler - " + dumpObj(e));
                 }
             });
             handlers = [];
@@ -1836,37 +1890,40 @@
             var _hooks;
             _initDefaults();
             dynamicProto(BaseTelemetryPlugin, _self, function (_self) {
-                _self.initialize = function (config, core, extensions, pluginChain) {
+                _self[_DYN_INITIALIZE ] = function (config, core, extensions, pluginChain) {
                     _setDefaults(config, core, pluginChain);
                     _isinitialized = true;
                 };
-                _self.teardown = function (unloadCtx, unloadState) {
-                    var core = _self.core;
-                    if (!core || (unloadCtx && core !== unloadCtx.core())) {
+                _self[_DYN_TEARDOWN ] = function (unloadCtx, unloadState) {
+                    var _a;
+                    var core = _self[STR_CORE ];
+                    if (!core || (unloadCtx && core !== unloadCtx[STR_CORE ]())) {
                         return;
                     }
                     var result;
                     var unloadDone = false;
                     var theUnloadCtx = unloadCtx || createProcessTelemetryUnloadContext(null, core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
-                    var theUnloadState = unloadState || {
-                        reason: 0 ,
-                        isAsync: false
-                    };
+                    var theUnloadState = unloadState || (_a = {
+                            reason: 0
+                        },
+                        _a[_DYN_IS_ASYNC ] = false,
+                        _a);
                     function _unloadCallback() {
                         if (!unloadDone) {
                             unloadDone = true;
                             _unloadHandlerContainer.run(theUnloadCtx, unloadState);
-                            arrForEach(_hooks, function (fn) {
+                            var oldHooks = _hooks;
+                            _hooks = [];
+                            arrForEach(oldHooks, function (fn) {
                                 fn.rm();
                             });
-                            _hooks = [];
                             if (result === true) {
-                                theUnloadCtx.processNext(theUnloadState);
+                                theUnloadCtx[_DYN_PROCESS_NEXT ](theUnloadState);
                             }
                             _initDefaults();
                         }
                     }
-                    if (!_self[strDoTeardown] || _self[strDoTeardown](theUnloadCtx, theUnloadState, _unloadCallback) !== true) {
+                    if (!_self[_DYN__DO_TEARDOWN ] || _self[_DYN__DO_TEARDOWN ](theUnloadCtx, theUnloadState, _unloadCallback) !== true) {
                         _unloadCallback();
                     }
                     else {
@@ -1874,9 +1931,9 @@
                     }
                     return result;
                 };
-                _self.update = function (updateCtx, updateState) {
-                    var core = _self.core;
-                    if (!core || (updateCtx && core !== updateCtx.core())) {
+                _self[_DYN_UPDATE ] = function (updateCtx, updateState) {
+                    var core = _self[STR_CORE ];
+                    if (!core || (updateCtx && core !== updateCtx[STR_CORE ]())) {
                         return;
                     }
                     var result;
@@ -1888,7 +1945,7 @@
                     function _updateCallback() {
                         if (!updateDone) {
                             updateDone = true;
-                            _setDefaults(theUpdateCtx.getCfg(), theUpdateCtx.core(), theUpdateCtx.getNext());
+                            _setDefaults(theUpdateCtx.getCfg(), theUpdateCtx.core(), theUpdateCtx[_DYN_GET_NEXT ]());
                         }
                     }
                     if (!_self._doUpdate || _self._doUpdate(theUpdateCtx, theUpdateState, _updateCallback) !== true) {
@@ -1905,30 +1962,30 @@
                             _hooks = _hooks.concat(hooks);
                         }
                         else {
-                            _hooks.push(hooks);
+                            _hooks[_DYN_PUSH ](hooks);
                         }
                     }
                 };
                 proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
             });
-            _self.diagLog = function (itemCtx) {
-                return _getTelCtx(itemCtx).diagLog();
+            _self[_DYN_DIAG_LOG ] = function (itemCtx) {
+                return _getTelCtx(itemCtx)[_DYN_DIAG_LOG ]();
             };
-            _self[strIsInitialized] = function () {
+            _self[_DYN_IS_INITIALIZED ] = function () {
                 return _isinitialized;
             };
             _self.setInitialized = function (isInitialized) {
                 _isinitialized = isInitialized;
             };
-            _self[strSetNextPlugin] = function (next) {
+            _self[_DYN_SET_NEXT_PLUGIN ] = function (next) {
                 _nextPlugin = next;
             };
-            _self.processNext = function (env, itemCtx) {
+            _self[_DYN_PROCESS_NEXT ] = function (env, itemCtx) {
                 if (itemCtx) {
-                    itemCtx.processNext(env);
+                    itemCtx[_DYN_PROCESS_NEXT ](env);
                 }
-                else if (_nextPlugin && isFunction(_nextPlugin.processTelemetry)) {
-                    _nextPlugin.processTelemetry(env, null);
+                else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY ])) {
+                    _nextPlugin[STR_PROCESS_TELEMETRY ](env, null);
                 }
             };
             _self._getTelCtx = _getTelCtx;
@@ -1936,33 +1993,33 @@
                 if (currentCtx === void 0) { currentCtx = null; }
                 var itemCtx = currentCtx;
                 if (!itemCtx) {
-                    var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self.core);
+                    var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self[STR_CORE ]);
                     if (_nextPlugin && _nextPlugin[strGetPlugin]) {
-                        itemCtx = rootCtx.createNew(null, _nextPlugin[strGetPlugin]);
+                        itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin[strGetPlugin]);
                     }
                     else {
-                        itemCtx = rootCtx.createNew(null, _nextPlugin);
+                        itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin);
                     }
                 }
                 return itemCtx;
             }
             function _setDefaults(config, core, pluginChain) {
                 if (config) {
-                    setValue(config, strExtensionConfig, [], null, isNullOrUndefined);
+                    setValue(config, STR_EXTENSION_CONFIG, [], null, isNullOrUndefined);
                 }
                 if (!pluginChain && core) {
-                    pluginChain = core.getProcessTelContext().getNext();
+                    pluginChain = core[_DYN_GET_PROCESS_TEL_CONT0 ]()[_DYN_GET_NEXT ]();
                 }
                 var nextPlugin = _nextPlugin;
                 if (_nextPlugin && _nextPlugin[strGetPlugin]) {
                     nextPlugin = _nextPlugin[strGetPlugin]();
                 }
-                _self.core = core;
+                _self[STR_CORE ] = core;
                 _rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
             }
             function _initDefaults() {
                 _isinitialized = false;
-                _self.core = null;
+                _self[STR_CORE ] = null;
                 _rootCtx = null;
                 _nextPlugin = null;
                 _hooks = [];
@@ -1979,7 +2036,7 @@
     ];
     function _arrLoop(arr, fn) {
         if (arr) {
-            for (var lp = 0; lp < arr.length; lp++) {
+            for (var lp = 0; lp < arr[_DYN_LENGTH$2 ]; lp++) {
                 if (fn(arr[lp], lp)) {
                     break;
                 }
@@ -1997,7 +2054,7 @@
                         return ctx;
                     };
                     try {
-                        cb.apply(callDetails.inst, cbArgs);
+                        cb[_DYN_APPLY ](callDetails.inst, cbArgs);
                     }
                     catch (err) {
                         var orgEx = callDetails.err;
@@ -2005,7 +2062,7 @@
                             var hookErrorCb = cbks[cbNames[2 ]];
                             if (hookErrorCb) {
                                 callDetails.err = err;
-                                hookErrorCb.apply(callDetails.inst, cbArgs);
+                                hookErrorCb[_DYN_APPLY ](callDetails.inst, cbArgs);
                             }
                         }
                         catch (e) {
@@ -2020,21 +2077,22 @@
     }
     function _createFunctionHook(aiHook) {
         return function () {
+            var _a;
             var funcThis = this;
             var orgArgs = arguments;
             var hooks = aiHook.h;
-            var funcArgs = {
-                name: aiHook.n,
-                inst: funcThis,
-                ctx: null,
-                set: _replaceArg
-            };
+            var funcArgs = (_a = {},
+                _a[_DYN_NAME$2 ] = aiHook.n,
+                _a.inst = funcThis,
+                _a.ctx = null,
+                _a.set = _replaceArg,
+                _a);
             var hookCtx = [];
             var cbArgs = _createArgs([funcArgs], orgArgs);
             funcArgs.evt = getGlobalInst("event");
             function _createArgs(target, theArgs) {
                 _arrLoop(theArgs, function (arg) {
-                    target.push(arg);
+                    target[_DYN_PUSH ](arg);
                 });
                 return target;
             }
@@ -2047,7 +2105,7 @@
             var theFunc = aiHook.f;
             if (theFunc) {
                 try {
-                    funcArgs.rslt = theFunc.apply(funcThis, orgArgs);
+                    funcArgs.rslt = theFunc[_DYN_APPLY ](funcThis, orgArgs);
                 }
                 catch (err) {
                     funcArgs.err = err;
@@ -2066,7 +2124,7 @@
                 owner = target;
             }
             else if (checkPrototype) {
-                owner = _getOwner(_getObjProto$1(target), name, false);
+                owner = _getOwner(_getObjProto(target), name, false);
             }
         }
         return owner;
@@ -2097,14 +2155,14 @@
                 var id = this.id;
                 _arrLoop(aiHook.h, function (hook, idx) {
                     if (hook.id === id) {
-                        aiHook.h.splice(idx, 1);
+                        aiHook.h[_DYN_SPLICE ](idx, 1);
                         return 1;
                     }
                 });
             }
         };
         aiHook.i++;
-        aiHook.h.push(theHook);
+        aiHook.h[_DYN_PUSH ](theHook);
         return theHook;
     }
     function InstrumentFunc(target, funcName, callbacks, checkPrototype) {
@@ -2121,6 +2179,48 @@
         return null;
     }
 
+    var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
+    var DEFAULT_BREEZE_ENDPOINT = "https://dc.services.visualstudio.com";
+    var DEFAULT_BREEZE_PATH = "/v2/track";
+    var strNotSpecified = "not_specified";
+    var strIkey = "iKey";
+
+    var _DYN_SPLIT = "split";
+    var _DYN_LENGTH$1 = "length";
+    var _DYN_TO_LOWER_CASE$1 = "toLowerCase";
+    var _DYN_TO_STRING = "toString";
+    var _DYN_NAME$1 = "name";
+    var _DYN_PATHNAME = "pathname";
+    var _DYN_CORRELATION_HEADER_E0 = "correlationHeaderExcludePatterns";
+    var _DYN_INDEX_OF = "indexOf";
+    var _DYN_PROPERTIES = "properties";
+    var _DYN_MEASUREMENTS = "measurements";
+    var _DYN_STRINGIFY = "stringify";
+    var _DYN_DURATION = "duration";
+    var _DYN_SUBSTRING = "substring";
+    var _DYN_SANITIZE_KEY_AND_ADD2 = "sanitizeKeyAndAddUniqueness";
+    var _DYN_SANITIZE_EXCEPTION = "sanitizeException";
+    var _DYN_SANITIZE_PROPERTIES = "sanitizeProperties";
+    var _DYN_SANITIZE_MEASUREMENT3 = "sanitizeMeasurements";
+
+    var strEmpty = "";
+    function msToTimeSpan(totalms) {
+        if (isNaN(totalms) || totalms < 0) {
+            totalms = 0;
+        }
+        totalms = Math.round(totalms);
+        var ms = strEmpty + totalms % 1000;
+        var sec = strEmpty + Math.floor(totalms / 1000) % 60;
+        var min = strEmpty + Math.floor(totalms / (1000 * 60)) % 60;
+        var hour = strEmpty + Math.floor(totalms / (1000 * 60 * 60)) % 24;
+        var days = Math.floor(totalms / (1000 * 60 * 60 * 24));
+        ms = ms[_DYN_LENGTH$1 ] === 1 ? "00" + ms : ms[_DYN_LENGTH$1 ] === 2 ? "0" + ms : ms;
+        sec = sec[_DYN_LENGTH$1 ] < 2 ? "0" + sec : sec;
+        min = min[_DYN_LENGTH$1 ] < 2 ? "0" + min : min;
+        hour = hour[_DYN_LENGTH$1 ] < 2 ? "0" + hour : hour;
+        return (days > 0 ? days + "." : strEmpty) + hour + ":" + min + ":" + sec + "." + ms;
+    }
+
     var RequestHeaders = createValueMap({
         requestContextHeader: [0 , "Request-Context"],
         requestContextTargetKey: [1 , "appId"],
@@ -2133,15 +2233,16 @@
         requestContextHeaderLowerCase: [8 , "request-context"]
     });
 
+    var _a;
     function dataSanitizeKeyAndAddUniqueness(logger, key, map) {
-        var origLength = key.length;
+        var origLength = key[_DYN_LENGTH$1 ];
         var field = dataSanitizeKey(logger, key);
-        if (field.length !== origLength) {
+        if (field[_DYN_LENGTH$1 ] !== origLength) {
             var i = 0;
             var uniqueField = field;
             while (map[uniqueField] !== undefined) {
                 i++;
-                uniqueField = field.substring(0, 150  - 3) + dsPadNumber(i);
+                uniqueField = field[_DYN_SUBSTRING ](0, 150  - 3) + dsPadNumber(i);
             }
             field = uniqueField;
         }
@@ -2150,9 +2251,9 @@
     function dataSanitizeKey(logger, name) {
         var nameTrunc;
         if (name) {
-            name = strTrim(name.toString());
-            if (name.length > 150 ) {
-                nameTrunc = name.substring(0, 150 );
+            name = strTrim(name[_DYN_TO_STRING ]());
+            if (name[_DYN_LENGTH$1 ] > 150 ) {
+                nameTrunc = name[_DYN_SUBSTRING ](0, 150 );
                 _throwInternal(logger, 2 , 57 , "name is too long.  It has been truncated to " + 150  + " characters.", { name: name }, true);
             }
         }
@@ -2164,8 +2265,8 @@
         if (value) {
             maxLength = maxLength ? maxLength : 1024 ;
             value = strTrim(value);
-            if (value.toString().length > maxLength) {
-                valueTrunc = value.toString().substring(0, maxLength);
+            if (value.toString()[_DYN_LENGTH$1 ] > maxLength) {
+                valueTrunc = value[_DYN_TO_STRING ]()[_DYN_SUBSTRING ](0, maxLength);
                 _throwInternal(logger, 2 , 61 , "string value is too long. It has been truncated to " + maxLength + " characters.", { value: value }, true);
             }
         }
@@ -2174,13 +2275,34 @@
     function dataSanitizeUrl(logger, url) {
         return dataSanitizeInput(logger, url, 2048 , 66 );
     }
+    function dataSanitizeMessage(logger, message) {
+        var messageTrunc;
+        if (message) {
+            if (message[_DYN_LENGTH$1 ] > 32768 ) {
+                messageTrunc = message[_DYN_SUBSTRING ](0, 32768 );
+                _throwInternal(logger, 2 , 56 , "message is too long, it has been truncated to " + 32768  + " characters.", { message: message }, true);
+            }
+        }
+        return messageTrunc || message;
+    }
+    function dataSanitizeException(logger, exception) {
+        var exceptionTrunc;
+        if (exception) {
+            var value = "" + exception;
+            if (value[_DYN_LENGTH$1 ] > 32768 ) {
+                exceptionTrunc = value[_DYN_SUBSTRING ](0, 32768 );
+                _throwInternal(logger, 2 , 52 , "exception is too long, it has been truncated to " + 32768  + " characters.", { exception: exception }, true);
+            }
+        }
+        return exceptionTrunc || exception;
+    }
     function dataSanitizeProperties(logger, properties) {
         if (properties) {
             var tempProps_1 = {};
             objForEachKey(properties, function (prop, value) {
                 if (isObject(value) && hasJSON()) {
                     try {
-                        value = getJSON().stringify(value);
+                        value = getJSON()[_DYN_STRINGIFY ](value);
                     }
                     catch (e) {
                         _throwInternal(logger, 2 , 49 , "custom property is not valid", { exception: e }, true);
@@ -2205,12 +2327,15 @@
         }
         return measurements;
     }
+    function dataSanitizeId(logger, id) {
+        return id ? dataSanitizeInput(logger, id, 128 , 69 )[_DYN_TO_STRING ]() : id;
+    }
     function dataSanitizeInput(logger, input, maxLength, _msgId) {
         var inputTrunc;
         if (input) {
             input = strTrim(input);
-            if (input.length > maxLength) {
-                inputTrunc = input.substring(0, maxLength);
+            if (input[_DYN_LENGTH$1 ] > maxLength) {
+                inputTrunc = input[_DYN_SUBSTRING ](0, maxLength);
                 _throwInternal(logger, 2 , _msgId, "input is too long, it has been truncated to " + maxLength + " characters.", { data: input }, true);
             }
         }
@@ -2218,30 +2343,30 @@
     }
     function dsPadNumber(num) {
         var s = "00" + num;
-        return s.substr(s.length - 3);
-    }
-
-    var strEmpty = "";
-    function msToTimeSpan(totalms) {
-        if (isNaN(totalms) || totalms < 0) {
-            totalms = 0;
-        }
-        totalms = Math.round(totalms);
-        var ms = strEmpty + totalms % 1000;
-        var sec = strEmpty + Math.floor(totalms / 1000) % 60;
-        var min = strEmpty + Math.floor(totalms / (1000 * 60)) % 60;
-        var hour = strEmpty + Math.floor(totalms / (1000 * 60 * 60)) % 24;
-        var days = Math.floor(totalms / (1000 * 60 * 60 * 24));
-        ms = ms.length === 1 ? "00" + ms : ms.length === 2 ? "0" + ms : ms;
-        sec = sec.length < 2 ? "0" + sec : sec;
-        min = min.length < 2 ? "0" + min : min;
-        hour = hour.length < 2 ? "0" + hour : hour;
-        return (days > 0 ? days + "." : strEmpty) + hour + ":" + min + ":" + sec + "." + ms;
-    }
-
-    var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
-    var strNotSpecified = "not_specified";
-    var strIkey = "iKey";
+        return s.substr(s[_DYN_LENGTH$1 ] - 3);
+    }
+    (_a = {
+            MAX_NAME_LENGTH: 150 ,
+            MAX_ID_LENGTH: 128 ,
+            MAX_PROPERTY_LENGTH: 8192 ,
+            MAX_STRING_LENGTH: 1024 ,
+            MAX_URL_LENGTH: 2048 ,
+            MAX_MESSAGE_LENGTH: 32768 ,
+            MAX_EXCEPTION_LENGTH: 32768
+        },
+        _a[_DYN_SANITIZE_KEY_AND_ADD2 ] = dataSanitizeKeyAndAddUniqueness,
+        _a.sanitizeKey = dataSanitizeKey,
+        _a.sanitizeString = dataSanitizeString,
+        _a.sanitizeUrl = dataSanitizeUrl,
+        _a.sanitizeMessage = dataSanitizeMessage,
+        _a[_DYN_SANITIZE_EXCEPTION ] = dataSanitizeException,
+        _a[_DYN_SANITIZE_PROPERTIES ] = dataSanitizeProperties,
+        _a[_DYN_SANITIZE_MEASUREMENT3 ] = dataSanitizeMeasurements,
+        _a.sanitizeId = dataSanitizeId,
+        _a.sanitizeInput = dataSanitizeInput,
+        _a.padNumber = dsPadNumber,
+        _a.trim = strTrim,
+        _a);
 
     var _document = getDocument() || {};
     var _htmlAnchorIdx = 0;
@@ -2258,7 +2383,7 @@
         }
         tempAnchor.href = url;
         anchorIdx++;
-        if (anchorIdx >= anchorCache.length) {
+        if (anchorIdx >= anchorCache[_DYN_LENGTH$1 ]) {
             anchorIdx = 0;
         }
         _htmlAnchorIdx = anchorIdx;
@@ -2282,7 +2407,7 @@
         var fullHost = urlParseFullHost(url, inclPort) || "";
         if (fullHost) {
             var match = fullHost.match(/(www[0-9]?\.)?(.[^/:]+)(\:[\d]+)?/i);
-            if (match != null && match.length > 3 && isString(match[2]) && match[2].length > 0) {
+            if (match != null && match[_DYN_LENGTH$1 ] > 3 && isString(match[2]) && match[2][_DYN_LENGTH$1 ] > 0) {
                 return match[2] + (match[3] || "");
             }
         }
@@ -2292,10 +2417,10 @@
         var result = null;
         if (url) {
             var match = url.match(/(\w*):\/\/(.[^/:]+)(\:[\d]+)?/i);
-            if (match != null && match.length > 2 && isString(match[2]) && match[2].length > 0) {
+            if (match != null && match[_DYN_LENGTH$1 ] > 2 && isString(match[2]) && match[2][_DYN_LENGTH$1 ] > 0) {
                 result = match[2] || "";
-                if (inclPort && match.length > 2) {
-                    var protocol = (match[1] || "").toLowerCase();
+                if (inclPort && match[_DYN_LENGTH$1 ] > 2) {
+                    var protocol = (match[1] || "")[_DYN_TO_LOWER_CASE$1 ]();
                     var port = match[3] || "";
                     if (protocol === "http" && port === ":80") {
                         port = "";
@@ -2311,12 +2436,12 @@
     }
 
     var _internalEndpoints = [
-        "https://dc.services.visualstudio.com/v2/track",
-        "https://breeze.aimon.applicationinsights.io/v2/track",
-        "https://dc-int.services.visualstudio.com/v2/track"
+        DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH,
+        "https://breeze.aimon.applicationinsights.io" + DEFAULT_BREEZE_PATH,
+        "https://dc-int.services.visualstudio.com" + DEFAULT_BREEZE_PATH
     ];
     function isInternalApplicationInsightsEndpoint(endpointUrl) {
-        return arrIndexOf(_internalEndpoints, endpointUrl.toLowerCase()) !== -1;
+        return arrIndexOf(_internalEndpoints, endpointUrl[_DYN_TO_LOWER_CASE$1 ]()) !== -1;
     }
     var CorrelationIdHelper = {
         correlationIdPrefix: "cid-v1:",
@@ -2324,16 +2449,16 @@
             if (!requestUrl || (config && config.disableCorrelationHeaders)) {
                 return false;
             }
-            if (config && config.correlationHeaderExcludePatterns) {
-                for (var i = 0; i < config.correlationHeaderExcludePatterns.length; i++) {
-                    if (config.correlationHeaderExcludePatterns[i].test(requestUrl)) {
+            if (config && config[_DYN_CORRELATION_HEADER_E0 ]) {
+                for (var i = 0; i < config.correlationHeaderExcludePatterns[_DYN_LENGTH$1 ]; i++) {
+                    if (config[_DYN_CORRELATION_HEADER_E0 ][i].test(requestUrl)) {
                         return false;
                     }
                 }
             }
-            var requestHost = urlParseUrl(requestUrl).host.toLowerCase();
-            if (requestHost && (requestHost.indexOf(":443") !== -1 || requestHost.indexOf(":80") !== -1)) {
-                requestHost = (urlParseFullHost(requestUrl, true) || "").toLowerCase();
+            var requestHost = urlParseUrl(requestUrl).host[_DYN_TO_LOWER_CASE$1 ]();
+            if (requestHost && (requestHost[_DYN_INDEX_OF ](":443") !== -1 || requestHost[_DYN_INDEX_OF ](":80") !== -1)) {
+                requestHost = (urlParseFullHost(requestUrl, true) || "")[_DYN_TO_LOWER_CASE$1 ]();
             }
             if ((!config || !config.enableCorsCorrelation) && (requestHost && requestHost !== currentHost)) {
                 return false;
@@ -2350,16 +2475,16 @@
                 }
             }
             var excludedDomains = config && config.correlationHeaderExcludedDomains;
-            if (!excludedDomains || excludedDomains.length === 0) {
+            if (!excludedDomains || excludedDomains[_DYN_LENGTH$1 ] === 0) {
                 return true;
             }
-            for (var i = 0; i < excludedDomains.length; i++) {
+            for (var i = 0; i < excludedDomains[_DYN_LENGTH$1 ]; i++) {
                 var regex = new RegExp(excludedDomains[i].toLowerCase().replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*/g, ".*"));
                 if (regex.test(requestHost)) {
                     return false;
                 }
             }
-            return requestHost && requestHost.length > 0;
+            return requestHost && requestHost[_DYN_LENGTH$1 ] > 0;
         },
         getCorrelationContext: function (responseHeader) {
             if (responseHeader) {
@@ -2371,10 +2496,10 @@
         },
         getCorrelationContextValue: function (responseHeader, key) {
             if (responseHeader) {
-                var keyValues = responseHeader.split(",");
-                for (var i = 0; i < keyValues.length; ++i) {
-                    var keyValue = keyValues[i].split("=");
-                    if (keyValue.length === 2 && keyValue[0] === key) {
+                var keyValues = responseHeader[_DYN_SPLIT ](",");
+                for (var i = 0; i < keyValues[_DYN_LENGTH$1 ]; ++i) {
+                    var keyValue = keyValues[i][_DYN_SPLIT ]("=");
+                    if (keyValue[_DYN_LENGTH$1 ] === 2 && keyValue[0] === key) {
                         return keyValue[1];
                     }
                 }
@@ -2383,16 +2508,16 @@
     };
     function AjaxHelperParseDependencyPath(logger, absoluteUrl, method, commandName) {
         var target, name = commandName, data = commandName;
-        if (absoluteUrl && absoluteUrl.length > 0) {
+        if (absoluteUrl && absoluteUrl[_DYN_LENGTH$1 ] > 0) {
             var parsedUrl = urlParseUrl(absoluteUrl);
             target = parsedUrl.host;
             if (!name) {
-                if (parsedUrl.pathname != null) {
-                    var pathName = (parsedUrl.pathname.length === 0) ? "/" : parsedUrl.pathname;
+                if (parsedUrl[_DYN_PATHNAME ] != null) {
+                    var pathName = (parsedUrl.pathname[_DYN_LENGTH$1 ] === 0) ? "/" : parsedUrl[_DYN_PATHNAME ];
                     if (pathName.charAt(0) !== "/") {
                         pathName = "/" + pathName;
                     }
-                    data = parsedUrl.pathname;
+                    data = parsedUrl[_DYN_PATHNAME ];
                     name = dataSanitizeString(logger, method ? method + " " + pathName : pathName);
                 }
                 else {
@@ -2431,11 +2556,11 @@
         var trace = telemetryTrace || {};
         return {
             getName: function () {
-                return trace.name;
+                return trace[_DYN_NAME$1 ];
             },
             setName: function (newValue) {
                 parentCtx && parentCtx.setName(newValue);
-                trace.name = newValue;
+                trace[_DYN_NAME$1 ] = newValue;
             },
             getTraceId: function () {
                 return trace.traceID;
@@ -2494,7 +2619,7 @@
             var _self = this;
             _self.ver = 2;
             _self.id = id;
-            _self.duration = msToTimeSpan(value);
+            _self[_DYN_DURATION ] = msToTimeSpan(value);
             _self.success = success;
             _self.resultCode = resultCode + "";
             _self.type = dataSanitizeString(logger, requestAPI);
@@ -2504,9 +2629,9 @@
             if (correlationContext) {
                 _self.target = "".concat(_self.target, " | ").concat(correlationContext);
             }
-            _self.name = dataSanitizeString(logger, dependencyFields.name);
-            _self.properties = dataSanitizeProperties(logger, properties);
-            _self.measurements = dataSanitizeMeasurements(logger, measurements);
+            _self[_DYN_NAME$1 ] = dataSanitizeString(logger, dependencyFields[_DYN_NAME$1 ]);
+            _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+            _self[_DYN_MEASUREMENTS ] = dataSanitizeMeasurements(logger, measurements);
         }
         RemoteDependencyData.envelopeType = "Microsoft.ApplicationInsights.{0}.RemoteDependency";
         RemoteDependencyData.dataType = "RemoteDependencyData";
@@ -2514,6 +2639,7 @@
     }());
 
     function createTelemetryItem(item, baseType, envelopeName, logger, customProperties, systemProperties) {
+        var _a;
         envelopeName = dataSanitizeString(logger, envelopeName) || strNotSpecified;
         if (isNullOrUndefined(item) ||
             isNullOrUndefined(baseType) ||
@@ -2525,16 +2651,17 @@
             iKey = item[strIkey];
             delete item[strIkey];
         }
-        var telemetryItem = {
-            name: envelopeName,
-            time: toISOString(new Date()),
-            iKey: iKey,
-            ext: systemProperties ? systemProperties : {},
-            tags: [],
-            data: {},
-            baseType: baseType,
-            baseData: item
-        };
+        var telemetryItem = (_a = {},
+            _a[_DYN_NAME$1 ] = envelopeName,
+            _a.time = toISOString(new Date()),
+            _a.iKey = iKey,
+            _a.ext = systemProperties ? systemProperties : {},
+            _a.tags = [],
+            _a.data = {},
+            _a.baseType = baseType,
+            _a.baseData = item
+        ,
+            _a);
         if (!isNullOrUndefined(customProperties)) {
             objForEachKey(customProperties, function (prop, value) {
                 telemetryItem.data[prop] = value;
@@ -2545,7 +2672,60 @@
 
     var PropertiesPluginIdentifier = "AppInsightsPropertiesPlugin";
 
-    var strProperties = "properties";
+    var STR_DURATION = "duration";
+    var STR_PROPERTIES = "properties";
+
+    var _DYN_REQUEST_URL = "requestUrl";
+    var _DYN_INST = "inst";
+    var _DYN_LENGTH = "length";
+    var _DYN_TRACE_ID = "traceID";
+    var _DYN_SPAN_ID = "spanID";
+    var _DYN_TRACE_FLAGS = "traceFlags";
+    var _DYN_CORE = "core";
+    var _DYN_GET_DEFAULT_CONFIG = "getDefaultConfig";
+    var _DYN_INCLUDE_CORRELATION_0 = "includeCorrelationHeaders";
+    var _DYN_CAN_INCLUDE_CORRELAT1 = "canIncludeCorrelationHeader";
+    var _DYN_GET_ABSOLUTE_URL = "getAbsoluteUrl";
+    var _DYN_HEADERS = "headers";
+    var _DYN_REQUEST_HEADERS = "requestHeaders";
+    var _DYN_APP_ID = "appId";
+    var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
+    var _DYN_DISTRIBUTED_TRACING_2 = "distributedTracingMode";
+    var _DYN_START_TIME = "startTime";
+    var _DYN_TO_LOWER_CASE = "toLowerCase";
+    var _DYN_ENABLE_REQUEST_HEADE3 = "enableRequestHeaderTracking";
+    var _DYN_ENABLE_AJAX_ERROR_ST4 = "enableAjaxErrorStatusText";
+    var _DYN_ENABLE_AJAX_PERF_TRA5 = "enableAjaxPerfTracking";
+    var _DYN_MAX_AJAX_CALLS_PER_V6 = "maxAjaxCallsPerView";
+    var _DYN_ENABLE_RESPONSE_HEAD7 = "enableResponseHeaderTracking";
+    var _DYN_EXCLUDE_REQUEST_FROM8 = "excludeRequestFromAutoTrackingPatterns";
+    var _DYN_ADD_REQUEST_CONTEXT = "addRequestContext";
+    var _DYN_DISABLE_AJAX_TRACKIN9 = "disableAjaxTracking";
+    var _DYN_DISABLE_FETCH_TRACKI10 = "disableFetchTracking";
+    var _DYN_STATUS = "status";
+    var _DYN_STATUS_TEXT = "statusText";
+    var _DYN_HEADER_MAP = "headerMap";
+    var _DYN_OPEN_DONE = "openDone";
+    var _DYN_SEND_DONE = "sendDone";
+    var _DYN_REQUEST_SENT_TIME = "requestSentTime";
+    var _DYN_ABORT_DONE = "abortDone";
+    var _DYN_METHOD = "method";
+    var _DYN_ERROR_STATUS_TEXT = "errorStatusText";
+    var _DYN_STATE_CHANGE_ATTACHE11 = "stateChangeAttached";
+    var _DYN_RESPONSE_TEXT = "responseText";
+    var _DYN_RESPONSE_FINISHED_TI12 = "responseFinishedTime";
+    var _DYN__CREATE_TRACK_ITEM = "CreateTrackItem";
+    var _DYN_RESPONSE = "response";
+    var _DYN_GET_ALL_RESPONSE_HEA13 = "getAllResponseHeaders";
+    var _DYN_GET_CORRELATION_CONT14 = "getCorrelationContext";
+    var _DYN_PERF_MARK = "perfMark";
+    var _DYN_AJAX_PERF_LOOKUP_DEL15 = "ajaxPerfLookupDelay";
+    var _DYN_NAME = "name";
+    var _DYN_PERF_TIMING = "perfTiming";
+    var _DYN_AJAX_DIAGNOSTICS_MES16 = "ajaxDiagnosticsMessage";
+    var _DYN_CORRELATION_CONTEXT = "correlationContext";
+    var _DYN_AJAX_TOTAL_DURATION = "ajaxTotalDuration";
+
     function _calcPerfDuration(resourceEntry, start, end) {
         var result = 0;
         var from = resourceEntry[start];
@@ -2574,8 +2754,8 @@
         return result;
     }
     function _populatePerfData(ajaxData, dependency) {
-        var resourceEntry = ajaxData.perfTiming;
-        var props = dependency[strProperties] || {};
+        var resourceEntry = ajaxData[_DYN_PERF_TIMING ];
+        var props = dependency[STR_PROPERTIES ] || {};
         var propsSet = 0;
         var strName = "name";
         var strStart = "Start";
@@ -2585,7 +2765,6 @@
         var strRedirect = "redirect";
         var strRequest = "request";
         var strResponse = "response";
-        var strDuration = "duration";
         var strStartTime = "startTime";
         var strDomainLookupStart = strDomainLookup + strStart;
         var strDomainLookupEnd = strDomainLookup + strEnd;
@@ -2609,11 +2788,11 @@
             propsSet |= _setPerfDuration(props, strResponse, resourceEntry, strResponseStart, strResponseEnd);
             propsSet |= _setPerfDuration(props, "networkConnect", resourceEntry, strStartTime, strConnectEnd);
             propsSet |= _setPerfDuration(props, "sentRequest", resourceEntry, strRequestStart, strResponseEnd);
-            var duration = resourceEntry[strDuration];
+            var duration = resourceEntry[STR_DURATION ];
             if (!duration) {
                 duration = _calcPerfDuration(resourceEntry, strStartTime, strResponseEnd) || 0;
             }
-            propsSet |= _setPerfValue(props, strDuration, duration);
+            propsSet |= _setPerfValue(props, STR_DURATION, duration);
             propsSet |= _setPerfValue(props, "perfTotal", duration);
             var serverTiming = resourceEntry[strServerTiming];
             if (serverTiming) {
@@ -2640,22 +2819,22 @@
             propsSet |= _setPerfValue(props, strDecodedBodySize, resourceEntry[strDecodedBodySize]);
         }
         else {
-            if (ajaxData.perfMark) {
+            if (ajaxData[_DYN_PERF_MARK ]) {
                 propsSet |= _setPerfValue(props, "missing", ajaxData.perfAttempts);
             }
         }
         if (propsSet) {
-            dependency[strProperties] = props;
+            dependency[STR_PROPERTIES ] = props;
         }
     }
     var XHRMonitoringState = /** @class */ (function () {
         function XHRMonitoringState() {
             var self = this;
-            self.openDone = false;
+            self[_DYN_OPEN_DONE ] = false;
             self.setRequestHeaderDone = false;
-            self.sendDone = false;
-            self.abortDone = false;
-            self.stateChangeAttached = false;
+            self[_DYN_SEND_DONE ] = false;
+            self[_DYN_ABORT_DONE ] = false;
+            self[_DYN_STATE_CHANGE_ATTACHE11 ] = false;
         }
         return XHRMonitoringState;
     }());
@@ -2664,86 +2843,86 @@
             var self = this;
             var _logger = logger;
             var strResponseText = "responseText";
-            self.perfMark = null;
+            self[_DYN_PERF_MARK ] = null;
             self.completed = false;
             self.requestHeadersSize = null;
-            self.requestHeaders = null;
+            self[_DYN_REQUEST_HEADERS ] = null;
             self.responseReceivingDuration = null;
             self.callbackDuration = null;
-            self.ajaxTotalDuration = null;
+            self[_DYN_AJAX_TOTAL_DURATION ] = null;
             self.aborted = 0;
             self.pageUrl = null;
-            self.requestUrl = null;
+            self[_DYN_REQUEST_URL ] = null;
             self.requestSize = 0;
-            self.method = null;
-            self.status = null;
-            self.requestSentTime = null;
+            self[_DYN_METHOD ] = null;
+            self[_DYN_STATUS ] = null;
+            self[_DYN_REQUEST_SENT_TIME ] = null;
             self.responseStartedTime = null;
-            self.responseFinishedTime = null;
+            self[_DYN_RESPONSE_FINISHED_TI12 ] = null;
             self.callbackFinishedTime = null;
             self.endTime = null;
             self.xhrMonitoringState = new XHRMonitoringState();
             self.clientFailure = 0;
-            self.traceID = traceID;
-            self.spanID = spanID;
+            self[_DYN_TRACE_ID ] = traceID;
+            self[_DYN_SPAN_ID ] = spanID;
             dynamicProto(ajaxRecord, self, function (self) {
                 self.getAbsoluteUrl = function () {
-                    return self.requestUrl ? urlGetAbsoluteUrl(self.requestUrl) : null;
+                    return self[_DYN_REQUEST_URL ] ? urlGetAbsoluteUrl(self[_DYN_REQUEST_URL ]) : null;
                 };
                 self.getPathName = function () {
-                    return self.requestUrl ? dataSanitizeUrl(_logger, urlGetCompleteUrl(self.method, self.requestUrl)) : null;
+                    return self[_DYN_REQUEST_URL ] ? dataSanitizeUrl(_logger, urlGetCompleteUrl(self[_DYN_METHOD ], self[_DYN_REQUEST_URL ])) : null;
                 };
-                self.CreateTrackItem = function (ajaxType, enableRequestHeaderTracking, getResponse) {
+                self[_DYN__CREATE_TRACK_ITEM ] = function (ajaxType, enableRequestHeaderTracking, getResponse) {
                     var _a;
                     self.ajaxTotalDuration = Math.round(dateTimeUtilsDuration(self.requestSentTime, self.responseFinishedTime) * 1000) / 1000;
-                    if (self.ajaxTotalDuration < 0) {
+                    if (self[_DYN_AJAX_TOTAL_DURATION ] < 0) {
                         return null;
                     }
                     var dependency = (_a = {
-                            id: "|" + self.traceID + "." + self.spanID,
-                            target: self.getAbsoluteUrl(),
-                            name: self.getPathName(),
-                            type: ajaxType,
-                            startTime: null,
-                            duration: self.ajaxTotalDuration,
-                            success: (+(self.status)) >= 200 && (+(self.status)) < 400,
-                            responseCode: (+(self.status)),
-                            method: self.method
+                            id: "|" + self[_DYN_TRACE_ID ] + "." + self[_DYN_SPAN_ID ],
+                            target: self[_DYN_GET_ABSOLUTE_URL ]()
                         },
-                        _a[strProperties] = { HttpMethod: self.method },
+                        _a[_DYN_NAME ] = self.getPathName(),
+                        _a.type = ajaxType,
+                        _a[_DYN_START_TIME ] = null,
+                        _a.duration = self[_DYN_AJAX_TOTAL_DURATION ],
+                        _a.success = (+(self[_DYN_STATUS ])) >= 200 && (+(self[_DYN_STATUS ])) < 400,
+                        _a.responseCode = (+(self[_DYN_STATUS ])),
+                        _a.method = self[_DYN_METHOD ],
+                        _a[STR_PROPERTIES] = { HttpMethod: self[_DYN_METHOD ] },
                         _a);
-                    if (self.requestSentTime) {
-                        dependency.startTime = new Date();
-                        dependency.startTime.setTime(self.requestSentTime);
+                    if (self[_DYN_REQUEST_SENT_TIME ]) {
+                        dependency[_DYN_START_TIME ] = new Date();
+                        dependency[_DYN_START_TIME ].setTime(self[_DYN_REQUEST_SENT_TIME ]);
                     }
                     _populatePerfData(self, dependency);
                     if (enableRequestHeaderTracking) {
-                        if (objKeys(self.requestHeaders).length > 0) {
-                            dependency[strProperties] = dependency[strProperties] || {};
-                            dependency[strProperties].requestHeaders = self.requestHeaders;
+                        if (objKeys(self.requestHeaders)[_DYN_LENGTH ] > 0) {
+                            var props = dependency[STR_PROPERTIES ] = dependency[STR_PROPERTIES ] || {};
+                            props[_DYN_REQUEST_HEADERS ] = self[_DYN_REQUEST_HEADERS ];
                         }
                     }
                     if (getResponse) {
                         var response = getResponse();
                         if (response) {
-                            var correlationContext = response.correlationContext;
+                            var correlationContext = response[_DYN_CORRELATION_CONTEXT ];
                             if (correlationContext) {
                                 dependency.correlationContext =  correlationContext;
                             }
-                            if (response.headerMap) {
-                                if (objKeys(response.headerMap).length > 0) {
-                                    dependency[strProperties] = dependency[strProperties] || {};
-                                    dependency[strProperties].responseHeaders = response.headerMap;
+                            if (response[_DYN_HEADER_MAP ]) {
+                                if (objKeys(response.headerMap)[_DYN_LENGTH ] > 0) {
+                                    var props = dependency[STR_PROPERTIES ] = dependency[STR_PROPERTIES ] || {};
+                                    props.responseHeaders = response[_DYN_HEADER_MAP ];
                                 }
                             }
-                            if (self.errorStatusText && self.status >= 400) {
+                            if (self.errorStatusText && self[_DYN_STATUS ] >= 400) {
                                 var responseType = response.type;
-                                dependency[strProperties] = dependency[strProperties] || {};
+                                var props = dependency[STR_PROPERTIES ] = dependency[STR_PROPERTIES ] || {};
                                 if (responseType === "" || responseType === "text") {
-                                    dependency[strProperties][strResponseText] = response[strResponseText] ? response.statusText + " - " + response[strResponseText] : response.statusText;
+                                    props.responseText = response.responseText ? response[_DYN_STATUS_TEXT ] + " - " + response[strResponseText] : response[_DYN_STATUS_TEXT ];
                                 }
                                 if (responseType === "json") {
-                                    dependency[strProperties][strResponseText] = response.response ? response.statusText + " - " + JSON.stringify(response.response) : response.statusText;
+                                    props.responseText = response.response ? response[_DYN_STATUS_TEXT ] + " - " + JSON.stringify(response[_DYN_RESPONSE ]) : response[_DYN_STATUS_TEXT ];
                                 }
                             }
                         }
@@ -2806,8 +2985,8 @@
         try {
             if (!isNullOrUndefined(xhr) &&
                 !isNullOrUndefined(xhr[strAjaxData]) &&
-                !isNullOrUndefined(xhr[strAjaxData].requestUrl)) {
-                result += "(url: '" + xhr[strAjaxData].requestUrl + "')";
+                !isNullOrUndefined(xhr[strAjaxData][_DYN_REQUEST_URL ])) {
+                result += "(url: '" + xhr[strAjaxData][_DYN_REQUEST_URL ] + "')";
             }
         }
         catch (e) {
@@ -2823,7 +3002,7 @@
     function _createErrorCallbackFunc(ajaxMonitorInstance, internalMessage, message) {
         return function (args) {
             _throwInternalCritical(ajaxMonitorInstance, internalMessage, message, {
-                ajaxDiagnosticsMessage: _getFailedAjaxDiagnosticsMessage(args.inst),
+                ajaxDiagnosticsMessage: _getFailedAjaxDiagnosticsMessage(args[_DYN_INST ]),
                 exception: dumpObj(args.err)
             });
         };
@@ -2835,17 +3014,18 @@
         return -1;
     }
     function _processDependencyListeners(listeners, core, ajaxData, xhr, input, init) {
-        var initializersCount = listeners.length;
+        var _a;
+        var initializersCount = listeners[_DYN_LENGTH ];
         if (initializersCount > 0) {
-            var details = {
-                core: core,
-                xhr: xhr,
-                input: input,
-                init: init,
-                traceId: ajaxData.traceID,
-                spanId: ajaxData.spanID,
-                traceFlags: ajaxData.traceFlags
-            };
+            var details = (_a = {},
+                _a[_DYN_CORE ] = core,
+                _a.xhr = xhr,
+                _a.input = input,
+                _a.init = init,
+                _a.traceId = ajaxData[_DYN_TRACE_ID ],
+                _a.spanId = ajaxData[_DYN_SPAN_ID ],
+                _a.traceFlags = ajaxData[_DYN_TRACE_FLAGS ],
+                _a);
             for (var i = 0; i < initializersCount; ++i) {
                 var dependencyListener = listeners[i];
                 if (dependencyListener && dependencyListener.fn) {
@@ -2853,16 +3033,22 @@
                         dependencyListener.fn.call(null, details);
                     }
                     catch (e) {
-                        var core_1 = details.core;
+                        var core_1 = details[_DYN_CORE ];
                         _throwInternal(core_1 && core_1.logger, 1 , 64 , "Dependency listener [#" + i + "] failed: " + getExceptionName(e), { exception: dumpObj(e) }, true);
                     }
                 }
             }
-            ajaxData.traceID = details.traceId;
-            ajaxData.spanID = details.spanId;
-            ajaxData.traceFlags = details.traceFlags;
+            ajaxData[_DYN_TRACE_ID ] = details.traceId;
+            ajaxData[_DYN_SPAN_ID ] = details.spanId;
+            ajaxData[_DYN_TRACE_FLAGS ] = details[_DYN_TRACE_FLAGS ];
         }
     }
+    var DfltAjaxCorrelationHeaderExDomains = deepFreeze([
+        "*.blob.core.windows.net",
+        "*.blob.core.chinacloudapi.cn",
+        "*.blob.core.cloudapi.de",
+        "*.blob.core.usgovcloudapi.net"
+    ]);
     var AjaxMonitor = /** @class */ (function (_super) {
         __extendsFn(AjaxMonitor, _super);
         function AjaxMonitor() {
@@ -2910,68 +3096,69 @@
                 _self.trackDependencyData = function (dependency, properties) {
                     _self[strTrackDependencyDataInternal](dependency, properties);
                 };
-                _self.includeCorrelationHeaders = function (ajaxData, input, init, xhr) {
+                _self[_DYN_INCLUDE_CORRELATION_0 ] = function (ajaxData, input, init, xhr) {
                     var currentWindowHost = _self["_currentWindowHost"] || _currentWindowHost;
-                    _processDependencyListeners(_dependencyListeners, _self.core, ajaxData, xhr, input, init);
+                    _processDependencyListeners(_dependencyListeners, _self[_DYN_CORE ], ajaxData, xhr, input, init);
                     if (input) {
-                        if (CorrelationIdHelper.canIncludeCorrelationHeader(_config, ajaxData.getAbsoluteUrl(), currentWindowHost)) {
+                        if (CorrelationIdHelper[_DYN_CAN_INCLUDE_CORRELAT1 ](_config, ajaxData[_DYN_GET_ABSOLUTE_URL ](), currentWindowHost)) {
                             if (!init) {
                                 init = {};
                             }
-                            init.headers = new Headers(init.headers || (input instanceof Request ? (input.headers || {}) : {}));
+                            var headers = new Headers(init[_DYN_HEADERS ] || (input instanceof Request ? (input[_DYN_HEADERS ] || {}) : {}));
                             if (_isUsingAIHeaders) {
-                                var id = "|" + ajaxData.traceID + "." + ajaxData.spanID;
-                                init.headers.set(RequestHeaders[3 ], id);
+                                var id = "|" + ajaxData[_DYN_TRACE_ID ] + "." + ajaxData[_DYN_SPAN_ID ];
+                                headers.set(RequestHeaders[3 ], id);
                                 if (_enableRequestHeaderTracking) {
-                                    ajaxData.requestHeaders[RequestHeaders[3 ]] = id;
+                                    ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[3 ]] = id;
                                 }
                             }
-                            var appId = _config.appId || (_context && _context.appId());
+                            var appId = _config[_DYN_APP_ID ] || (_context && _context[_DYN_APP_ID ]());
                             if (appId) {
-                                init.headers.set(RequestHeaders[0 ], RequestHeaders[2 ] + appId);
+                                headers.set(RequestHeaders[0 ], RequestHeaders[2 ] + appId);
                                 if (_enableRequestHeaderTracking) {
-                                    ajaxData.requestHeaders[RequestHeaders[0 ]] = RequestHeaders[2 ] + appId;
+                                    ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[0 ]] = RequestHeaders[2 ] + appId;
                                 }
                             }
                             if (_isUsingW3CHeaders) {
-                                var traceFlags = ajaxData.traceFlags;
+                                var traceFlags = ajaxData[_DYN_TRACE_FLAGS ];
                                 if (isNullOrUndefined(traceFlags)) {
                                     traceFlags = 0x01;
                                 }
-                                var traceParent = formatTraceParent(createTraceParent(ajaxData.traceID, ajaxData.spanID, traceFlags));
-                                init.headers.set(RequestHeaders[4 ], traceParent);
+                                var traceParent = formatTraceParent(createTraceParent(ajaxData[_DYN_TRACE_ID ], ajaxData[_DYN_SPAN_ID ], traceFlags));
+                                headers.set(RequestHeaders[4 ], traceParent);
                                 if (_enableRequestHeaderTracking) {
-                                    ajaxData.requestHeaders[RequestHeaders[4 ]] = traceParent;
+                                    ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[4 ]] = traceParent;
                                 }
                             }
+                            init[_DYN_HEADERS ] = headers;
                         }
                         return init;
                     }
                     else if (xhr) {
-                        if (CorrelationIdHelper.canIncludeCorrelationHeader(_config, ajaxData.getAbsoluteUrl(), currentWindowHost)) {
+                        if (CorrelationIdHelper[_DYN_CAN_INCLUDE_CORRELAT1 ](_config, ajaxData[_DYN_GET_ABSOLUTE_URL ](), currentWindowHost)) {
                             if (_isUsingAIHeaders) {
-                                var id = "|" + ajaxData.traceID + "." + ajaxData.spanID;
-                                xhr.setRequestHeader(RequestHeaders[3 ], id);
+                                var id = "|" + ajaxData[_DYN_TRACE_ID ] + "." + ajaxData[_DYN_SPAN_ID ];
+                                xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[3 ], id);
                                 if (_enableRequestHeaderTracking) {
-                                    ajaxData.requestHeaders[RequestHeaders[3 ]] = id;
+                                    ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[3 ]] = id;
                                 }
                             }
-                            var appId = _config.appId || (_context && _context.appId());
+                            var appId = _config[_DYN_APP_ID ] || (_context && _context[_DYN_APP_ID ]());
                             if (appId) {
-                                xhr.setRequestHeader(RequestHeaders[0 ], RequestHeaders[2 ] + appId);
+                                xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[0 ], RequestHeaders[2 ] + appId);
                                 if (_enableRequestHeaderTracking) {
-                                    ajaxData.requestHeaders[RequestHeaders[0 ]] = RequestHeaders[2 ] + appId;
+                                    ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[0 ]] = RequestHeaders[2 ] + appId;
                                 }
                             }
                             if (_isUsingW3CHeaders) {
-                                var traceFlags = ajaxData.traceFlags;
+                                var traceFlags = ajaxData[_DYN_TRACE_FLAGS ];
                                 if (isNullOrUndefined(traceFlags)) {
                                     traceFlags = 0x01;
                                 }
-                                var traceParent = formatTraceParent(createTraceParent(ajaxData.traceID, ajaxData.spanID, traceFlags));
-                                xhr.setRequestHeader(RequestHeaders[4 ], traceParent);
+                                var traceParent = formatTraceParent(createTraceParent(ajaxData[_DYN_TRACE_ID ], ajaxData[_DYN_SPAN_ID ], traceFlags));
+                                xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[4 ], traceParent);
                                 if (_enableRequestHeaderTracking) {
-                                    ajaxData.requestHeaders[RequestHeaders[4 ]] = traceParent;
+                                    ajaxData[_DYN_REQUEST_HEADERS ][RequestHeaders[4 ]] = traceParent;
                                 }
                             }
                         }
@@ -2981,16 +3168,16 @@
                 };
                 _self[strTrackDependencyDataInternal] = function (dependency, properties, systemProperties) {
                     if (_maxAjaxCallsPerView === -1 || _trackAjaxAttempts < _maxAjaxCallsPerView) {
-                        if ((_config.distributedTracingMode === 2
-                            || _config.distributedTracingMode === 1 )
-                            && typeof dependency.id === "string" && dependency.id[dependency.id.length - 1] !== ".") {
+                        if ((_config[_DYN_DISTRIBUTED_TRACING_2 ] === 2
+                            || _config[_DYN_DISTRIBUTED_TRACING_2 ] === 1 )
+                            && typeof dependency.id === "string" && dependency.id[dependency.id[_DYN_LENGTH ] - 1] !== ".") {
                             dependency.id += ".";
                         }
-                        if (isNullOrUndefined(dependency.startTime)) {
-                            dependency.startTime = new Date();
+                        if (isNullOrUndefined(dependency[_DYN_START_TIME ])) {
+                            dependency[_DYN_START_TIME ] = new Date();
                         }
                         var item = createTelemetryItem(dependency, RemoteDependencyData.dataType, RemoteDependencyData.envelopeType, _self[strDiagLog](), properties, systemProperties);
-                        _self.core.track(item);
+                        _self[_DYN_CORE ].track(item);
                     }
                     else if (_trackAjaxAttempts === _maxAjaxCallsPerView) {
                         _throwInternalCritical(_self, 55 , "Maximum ajax per page view limit reached, ajax monitoring is paused until the next trackPageView(). In order to increase the limit set the maxAjaxCallsPerView configuration parameter.", true);
@@ -3019,7 +3206,7 @@
                     var location = getLocation();
                     _fetchInitialized = false;
                     _xhrInitialized = false;
-                    _currentWindowHost = location && location.host && location.host.toLowerCase();
+                    _currentWindowHost = location && location.host && location.host[_DYN_TO_LOWER_CASE ]();
                     _config = AjaxMonitor.getEmptyConfig();
                     _enableRequestHeaderTracking = false;
                     _enableAjaxErrorStatusText = false;
@@ -3041,36 +3228,36 @@
                     _dependencyListeners = [];
                 }
                 function _populateDefaults(config) {
-                    var ctx = createProcessTelemetryContext(null, config, _self.core);
+                    var ctx = createProcessTelemetryContext(null, config, _self[_DYN_CORE ]);
                     _config = AjaxMonitor.getEmptyConfig();
-                    var defaultConfig = AjaxMonitor.getDefaultConfig();
+                    var defaultConfig = AjaxMonitor[_DYN_GET_DEFAULT_CONFIG ]();
                     objForEachKey(defaultConfig, function (field, value) {
                         _config[field] = ctx.getConfig(AjaxMonitor.identifier, field, value);
                     });
-                    var distributedTracingMode = _config.distributedTracingMode;
-                    _enableRequestHeaderTracking = _config.enableRequestHeaderTracking;
-                    _enableAjaxErrorStatusText = _config.enableAjaxErrorStatusText;
-                    _enableAjaxPerfTracking = _config.enableAjaxPerfTracking;
-                    _maxAjaxCallsPerView = _config.maxAjaxCallsPerView;
-                    _enableResponseHeaderTracking = _config.enableResponseHeaderTracking;
-                    _excludeRequestFromAutoTrackingPatterns = _config.excludeRequestFromAutoTrackingPatterns;
-                    _addRequestContext = _config.addRequestContext;
+                    var distributedTracingMode = _config[_DYN_DISTRIBUTED_TRACING_2 ];
+                    _enableRequestHeaderTracking = _config[_DYN_ENABLE_REQUEST_HEADE3 ];
+                    _enableAjaxErrorStatusText = _config[_DYN_ENABLE_AJAX_ERROR_ST4 ];
+                    _enableAjaxPerfTracking = _config[_DYN_ENABLE_AJAX_PERF_TRA5 ];
+                    _maxAjaxCallsPerView = _config[_DYN_MAX_AJAX_CALLS_PER_V6 ];
+                    _enableResponseHeaderTracking = _config[_DYN_ENABLE_RESPONSE_HEAD7 ];
+                    _excludeRequestFromAutoTrackingPatterns = _config[_DYN_EXCLUDE_REQUEST_FROM8 ];
+                    _addRequestContext = _config[_DYN_ADD_REQUEST_CONTEXT ];
                     _isUsingAIHeaders = distributedTracingMode === 0  || distributedTracingMode === 1 ;
                     _isUsingW3CHeaders = distributedTracingMode === 1  || distributedTracingMode === 2 ;
                     if (_enableAjaxPerfTracking) {
                         var iKey = config.instrumentationKey || "unkwn";
-                        if (iKey.length > 5) {
-                            _markPrefix = AJAX_MONITOR_PREFIX + iKey.substring(iKey.length - 5) + ".";
+                        if (iKey[_DYN_LENGTH ] > 5) {
+                            _markPrefix = AJAX_MONITOR_PREFIX + iKey.substring(iKey[_DYN_LENGTH ] - 5) + ".";
                         }
                         else {
                             _markPrefix = AJAX_MONITOR_PREFIX + iKey + ".";
                         }
                     }
-                    _disableAjaxTracking = !!_config.disableAjaxTracking;
-                    _disableFetchTracking = !!_config.disableFetchTracking;
+                    _disableAjaxTracking = !!_config[_DYN_DISABLE_AJAX_TRACKIN9 ];
+                    _disableFetchTracking = !!_config[_DYN_DISABLE_FETCH_TRACKI10 ];
                 }
                 function _populateContext() {
-                    var propExt = _self.core.getPlugin(PropertiesPluginIdentifier);
+                    var propExt = _self[_DYN_CORE ].getPlugin(PropertiesPluginIdentifier);
                     if (propExt) {
                         _context = propExt.plugin.context;
                     }
@@ -3079,7 +3266,7 @@
                     var rlt = true;
                     if (header || _config.ignoreHeaders) {
                         arrForEach(_config.ignoreHeaders, (function (key) {
-                            if (key.toLowerCase() === header.toLowerCase()) {
+                            if (key[_DYN_TO_LOWER_CASE ]() === header[_DYN_TO_LOWER_CASE ]()) {
                                 rlt = false;
                                 return -1;
                             }
@@ -3104,7 +3291,7 @@
                                     !(isPolyfill && _xhrInitialized)) {
                                     var ctx = callDetails.ctx();
                                     fetchData = _createFetchRecord(input, init);
-                                    var newInit = _self.includeCorrelationHeaders(fetchData, input, init);
+                                    var newInit = _self[_DYN_INCLUDE_CORRELATION_0 ](fetchData, input, init);
                                     if (newInit !== init) {
                                         callDetails.set(1, newInit);
                                     }
@@ -3116,12 +3303,14 @@
                                     var fetchData_1 = callDetails.ctx().data;
                                     if (fetchData_1) {
                                         callDetails.rslt = callDetails.rslt.then(function (response) {
-                                            _reportFetchMetrics(callDetails, (response || {}).status, input, response, fetchData_1, function () {
-                                                var ajaxResponse = {
-                                                    statusText: response.statusText,
-                                                    headerMap: null,
-                                                    correlationContext: _getFetchCorrelationContext(response)
-                                                };
+                                            _reportFetchMetrics(callDetails, (response || {})[_DYN_STATUS ], input, response, fetchData_1, function () {
+                                                var _a;
+                                                var ajaxResponse = (_a = {
+                                                        statusText: response[_DYN_STATUS_TEXT ]
+                                                    },
+                                                    _a[_DYN_HEADER_MAP ] = null,
+                                                    _a[_DYN_CORRELATION_CONTEXT ] = _getFetchCorrelationContext(response),
+                                                    _a);
                                                 if (_enableResponseHeaderTracking) {
                                                     var responseHeaderMap_1 = {};
                                                     response.headers.forEach(function (value, name) {
@@ -3129,7 +3318,7 @@
                                                             responseHeaderMap_1[name] = value;
                                                         }
                                                     });
-                                                    ajaxResponse.headerMap = responseHeaderMap_1;
+                                                    ajaxResponse[_DYN_HEADER_MAP ] = responseHeaderMap_1;
                                                 }
                                                 return ajaxResponse;
                                             });
@@ -3166,10 +3355,10 @@
                             ns: _evtNamespace,
                             req: function (args, method, url, async) {
                                 if (!_disableAjaxTracking) {
-                                    var xhr = args.inst;
+                                    var xhr = args[_DYN_INST ];
                                     var ajaxData = xhr[strAjaxData];
                                     if (!_isDisabledRequest(xhr, url) && _isMonitoredXhrInstance(xhr, true)) {
-                                        if (!ajaxData || !ajaxData.xhrMonitoringState.openDone) {
+                                        if (!ajaxData || !ajaxData.xhrMonitoringState[_DYN_OPEN_DONE ]) {
                                             _openHandler(xhr, method, url, async);
                                         }
                                         _attachToOnReadyStateChange(xhr);
@@ -3182,13 +3371,13 @@
                             ns: _evtNamespace,
                             req: function (args, context) {
                                 if (!_disableAjaxTracking) {
-                                    var xhr = args.inst;
+                                    var xhr = args[_DYN_INST ];
                                     var ajaxData = xhr[strAjaxData];
-                                    if (_isMonitoredXhrInstance(xhr) && !ajaxData.xhrMonitoringState.sendDone) {
+                                    if (_isMonitoredXhrInstance(xhr) && !ajaxData.xhrMonitoringState[_DYN_SEND_DONE ]) {
                                         _createMarkId("xhr", ajaxData);
-                                        ajaxData.requestSentTime = dateTimeUtilsNow();
-                                        _self.includeCorrelationHeaders(ajaxData, undefined, undefined, xhr);
-                                        ajaxData.xhrMonitoringState.sendDone = true;
+                                        ajaxData[_DYN_REQUEST_SENT_TIME ] = dateTimeUtilsNow();
+                                        _self[_DYN_INCLUDE_CORRELATION_0 ](ajaxData, undefined, undefined, xhr);
+                                        ajaxData.xhrMonitoringState[_DYN_SEND_DONE ] = true;
                                     }
                                 }
                             },
@@ -3198,11 +3387,11 @@
                             ns: _evtNamespace,
                             req: function (args) {
                                 if (!_disableAjaxTracking) {
-                                    var xhr = args.inst;
+                                    var xhr = args[_DYN_INST ];
                                     var ajaxData = xhr[strAjaxData];
-                                    if (_isMonitoredXhrInstance(xhr) && !ajaxData.xhrMonitoringState.abortDone) {
+                                    if (_isMonitoredXhrInstance(xhr) && !ajaxData.xhrMonitoringState[_DYN_ABORT_DONE ]) {
                                         ajaxData.aborted = 1;
-                                        ajaxData.xhrMonitoringState.abortDone = true;
+                                        ajaxData.xhrMonitoringState[_DYN_ABORT_DONE ] = true;
                                     }
                                 }
                             },
@@ -3212,9 +3401,9 @@
                             ns: _evtNamespace,
                             req: function (args, header, value) {
                                 if (!_disableAjaxTracking && _enableRequestHeaderTracking) {
-                                    var xhr = args.inst;
+                                    var xhr = args[_DYN_INST ];
                                     if (_isMonitoredXhrInstance(xhr) && _canIncludeHeaders(header)) {
-                                        xhr[strAjaxData].requestHeaders[header] = value;
+                                        xhr[strAjaxData][_DYN_REQUEST_HEADERS ][header] = value;
                                     }
                                 }
                             },
@@ -3225,7 +3414,7 @@
                 }
                 function _isDisabledRequest(xhr, request, init) {
                     var isDisabled = false;
-                    var theUrl = ((!isString(request) ? (request || {}).url || "" : request) || "").toLowerCase();
+                    var theUrl = ((!isString(request) ? (request || {}).url || "" : request) || "")[_DYN_TO_LOWER_CASE ]();
                     arrForEach(_excludeRequestFromAutoTrackingPatterns, function (regex) {
                         var theRegex = regex;
                         if (isString(regex)) {
@@ -3279,8 +3468,8 @@
                 }
                 function _getDistributedTraceCtx() {
                     var distributedTraceCtx = null;
-                    if (_self.core && _self.core.getTraceCtx) {
-                        distributedTraceCtx = _self.core.getTraceCtx(false);
+                    if (_self[_DYN_CORE ] && _self[_DYN_CORE ].getTraceCtx) {
+                        distributedTraceCtx = _self[_DYN_CORE ].getTraceCtx(false);
                     }
                     if (!distributedTraceCtx && _context && _context.telemetryTrace) {
                         distributedTraceCtx = createDistributedTraceContextFromTrace(_context.telemetryTrace);
@@ -3292,17 +3481,18 @@
                     var traceID = (distributedTraceCtx && distributedTraceCtx.getTraceId()) || generateW3CId();
                     var spanID = generateW3CId().substr(0, 16);
                     var ajaxData = new ajaxRecord(traceID, spanID, _self[strDiagLog]());
-                    ajaxData.traceFlags = distributedTraceCtx && distributedTraceCtx.getTraceFlags();
-                    ajaxData.method = method;
-                    ajaxData.requestUrl = url;
-                    ajaxData.xhrMonitoringState.openDone = true;
-                    ajaxData.requestHeaders = {};
+                    ajaxData[_DYN_TRACE_FLAGS ] = distributedTraceCtx && distributedTraceCtx.getTraceFlags();
+                    ajaxData[_DYN_METHOD ] = method;
+                    ajaxData[_DYN_REQUEST_URL ] = url;
+                    ajaxData.xhrMonitoringState[_DYN_OPEN_DONE ] = true;
+                    ajaxData[_DYN_REQUEST_HEADERS ] = {};
                     ajaxData.async = async;
-                    ajaxData.errorStatusText = _enableAjaxErrorStatusText;
+                    ajaxData[_DYN_ERROR_STATUS_TEXT ] = _enableAjaxErrorStatusText;
                     xhr[strAjaxData] = ajaxData;
                 }
                 function _attachToOnReadyStateChange(xhr) {
-                    xhr[strAjaxData].xhrMonitoringState.stateChangeAttached = eventOn(xhr, "readystatechange", function () {
+                    xhr[strAjaxData].xhrMonitoringState[_DYN_STATE_CHANGE_ATTACHE11 ] = eventOn(xhr, "readystatechange", function () {
+                        var _a;
                         try {
                             if (xhr && xhr.readyState === 4 && _isMonitoredXhrInstance(xhr)) {
                                 _onAjaxComplete(xhr);
@@ -3310,11 +3500,11 @@
                         }
                         catch (e) {
                             var exceptionText = dumpObj(e);
-                            if (!exceptionText || _indexOf(exceptionText.toLowerCase(), "c00c023f") === -1) {
-                                _throwInternalCritical(_self, 16 , "Failed to monitor XMLHttpRequest 'readystatechange' event handler, monitoring data for this ajax call may be incorrect.", {
-                                    ajaxDiagnosticsMessage: _getFailedAjaxDiagnosticsMessage(xhr),
-                                    exception: exceptionText
-                                });
+                            if (!exceptionText || _indexOf(exceptionText[_DYN_TO_LOWER_CASE ](), "c00c023f") === -1) {
+                                _throwInternalCritical(_self, 16 , "Failed to monitor XMLHttpRequest 'readystatechange' event handler, monitoring data for this ajax call may be incorrect.", (_a = {},
+                                    _a[_DYN_AJAX_DIAGNOSTICS_MES16 ] = _getFailedAjaxDiagnosticsMessage(xhr),
+                                    _a.exception = exceptionText,
+                                    _a));
                             }
                         }
                     }, _evtNamespace);
@@ -3323,7 +3513,7 @@
                     try {
                         var responseType = xhr.responseType;
                         if (responseType === "" || responseType === "text") {
-                            return xhr.responseText;
+                            return xhr[_DYN_RESPONSE_TEXT ];
                         }
                     }
                     catch (e) {
@@ -3332,8 +3522,8 @@
                 }
                 function _onAjaxComplete(xhr) {
                     var ajaxData = xhr[strAjaxData];
-                    ajaxData.responseFinishedTime = dateTimeUtilsNow();
-                    ajaxData.status = xhr.status;
+                    ajaxData[_DYN_RESPONSE_FINISHED_TI12 ] = dateTimeUtilsNow();
+                    ajaxData[_DYN_STATUS ] = xhr[_DYN_STATUS ];
                     function _reportXhrError(e, failedProps) {
                         var errorProps = failedProps || {};
                         errorProps["ajaxDiagnosticsMessage"] = _getFailedAjaxDiagnosticsMessage(xhr);
@@ -3344,17 +3534,19 @@
                     }
                     _findPerfResourceEntry("xmlhttprequest", ajaxData, function () {
                         try {
-                            var dependency = ajaxData.CreateTrackItem("Ajax", _enableRequestHeaderTracking, function () {
-                                var ajaxResponse = {
-                                    statusText: xhr.statusText,
-                                    headerMap: null,
-                                    correlationContext: _getAjaxCorrelationContext(xhr),
-                                    type: xhr.responseType,
-                                    responseText: _getResponseText(xhr),
-                                    response: xhr.response
-                                };
+                            var dependency = ajaxData[_DYN__CREATE_TRACK_ITEM ]("Ajax", _enableRequestHeaderTracking, function () {
+                                var _a;
+                                var ajaxResponse = (_a = {
+                                        statusText: xhr[_DYN_STATUS_TEXT ]
+                                    },
+                                    _a[_DYN_HEADER_MAP ] = null,
+                                    _a[_DYN_CORRELATION_CONTEXT ] = _getAjaxCorrelationContext(xhr),
+                                    _a.type = xhr.responseType,
+                                    _a[_DYN_RESPONSE_TEXT ] = _getResponseText(xhr),
+                                    _a.response = xhr[_DYN_RESPONSE ],
+                                    _a);
                                 if (_enableResponseHeaderTracking) {
-                                    var headers = xhr.getAllResponseHeaders();
+                                    var headers = xhr[_DYN_GET_ALL_RESPONSE_HEA13 ]();
                                     if (headers) {
                                         var arr = strTrim(headers).split(/[\r\n]+/);
                                         var responseHeaderMap_2 = {};
@@ -3366,7 +3558,7 @@
                                                 responseHeaderMap_2[header] = value;
                                             }
                                         });
-                                        ajaxResponse.headerMap = responseHeaderMap_2;
+                                        ajaxResponse[_DYN_HEADER_MAP ] = responseHeaderMap_2;
                                     }
                                 }
                                 return ajaxResponse;
@@ -3374,7 +3566,7 @@
                             var properties = void 0;
                             try {
                                 if (!!_addRequestContext) {
-                                    properties = _addRequestContext({ status: xhr.status, xhr: xhr });
+                                    properties = _addRequestContext({ status: xhr[_DYN_STATUS ], xhr: xhr });
                                 }
                             }
                             catch (e) {
@@ -3382,14 +3574,14 @@
                             }
                             if (dependency) {
                                 if (properties !== undefined) {
-                                    dependency.properties = __assignFn(__assignFn({}, dependency.properties), properties);
+                                    dependency[STR_PROPERTIES ] = __assignFn(__assignFn({}, dependency.properties), properties);
                                 }
                                 _self[strTrackDependencyDataInternal](dependency);
                             }
                             else {
                                 _reportXhrError(null, {
-                                    requestSentTime: ajaxData.requestSentTime,
-                                    responseFinishedTime: ajaxData.responseFinishedTime
+                                    requestSentTime: ajaxData[_DYN_REQUEST_SENT_TIME ],
+                                    responseFinishedTime: ajaxData[_DYN_RESPONSE_FINISHED_TI12 ]
                                 });
                             }
                         }
@@ -3405,43 +3597,44 @@
                     });
                 }
                 function _getAjaxCorrelationContext(xhr) {
+                    var _a;
                     try {
-                        var responseHeadersString = xhr.getAllResponseHeaders();
+                        var responseHeadersString = xhr[_DYN_GET_ALL_RESPONSE_HEA13 ]();
                         if (responseHeadersString !== null) {
-                            var index = _indexOf(responseHeadersString.toLowerCase(), RequestHeaders[8 ]);
+                            var index = _indexOf(responseHeadersString[_DYN_TO_LOWER_CASE ](), RequestHeaders[8 ]);
                             if (index !== -1) {
                                 var responseHeader = xhr.getResponseHeader(RequestHeaders[0 ]);
-                                return CorrelationIdHelper.getCorrelationContext(responseHeader);
+                                return CorrelationIdHelper[_DYN_GET_CORRELATION_CONT14 ](responseHeader);
                             }
                         }
                     }
                     catch (e) {
-                        _throwInternalWarning(_self, 18 , "Failed to get Request-Context correlation header as it may be not included in the response or not accessible.", {
-                            ajaxDiagnosticsMessage: _getFailedAjaxDiagnosticsMessage(xhr),
-                            exception: dumpObj(e)
-                        });
+                        _throwInternalWarning(_self, 18 , "Failed to get Request-Context correlation header as it may be not included in the response or not accessible.", (_a = {},
+                            _a[_DYN_AJAX_DIAGNOSTICS_MES16 ] = _getFailedAjaxDiagnosticsMessage(xhr),
+                            _a.exception = dumpObj(e),
+                            _a));
                     }
                 }
                 function _createMarkId(type, ajaxData) {
-                    if (ajaxData.requestUrl && _markPrefix && _enableAjaxPerfTracking) {
+                    if (ajaxData[_DYN_REQUEST_URL ] && _markPrefix && _enableAjaxPerfTracking) {
                         var performance_1 = getPerformance();
                         if (performance_1 && isFunction(performance_1.mark)) {
                             _markCount++;
                             var markId = _markPrefix + type + "#" + _markCount;
                             performance_1.mark(markId);
                             var entries = performance_1.getEntriesByName(markId);
-                            if (entries && entries.length === 1) {
-                                ajaxData.perfMark = entries[0];
+                            if (entries && entries[_DYN_LENGTH ] === 1) {
+                                ajaxData[_DYN_PERF_MARK ] = entries[0];
                             }
                         }
                     }
                 }
                 function _findPerfResourceEntry(initiatorType, ajaxData, trackCallback, reportError) {
-                    var perfMark = ajaxData.perfMark;
+                    var perfMark = ajaxData[_DYN_PERF_MARK ];
                     var performance = getPerformance();
                     var maxAttempts = _config.maxAjaxPerfLookupAttempts;
-                    var retryDelay = _config.ajaxPerfLookupDelay;
-                    var requestUrl = ajaxData.requestUrl;
+                    var retryDelay = _config[_DYN_AJAX_PERF_LOOKUP_DEL15 ];
+                    var requestUrl = ajaxData[_DYN_REQUEST_URL ];
                     var attempt = 0;
                     (function locateResourceTiming() {
                         try {
@@ -3449,31 +3642,31 @@
                                 attempt++;
                                 var perfTiming = null;
                                 var entries = performance.getEntries();
-                                for (var lp = entries.length - 1; lp >= 0; lp--) {
+                                for (var lp = entries[_DYN_LENGTH ] - 1; lp >= 0; lp--) {
                                     var entry = entries[lp];
                                     if (entry) {
                                         if (entry.entryType === "resource") {
                                             if (entry.initiatorType === initiatorType &&
-                                                (_indexOf(entry.name, requestUrl) !== -1 || _indexOf(requestUrl, entry.name) !== -1)) {
+                                                (_indexOf(entry[_DYN_NAME ], requestUrl) !== -1 || _indexOf(requestUrl, entry[_DYN_NAME ]) !== -1)) {
                                                 perfTiming = entry;
                                             }
                                         }
-                                        else if (entry.entryType === "mark" && entry.name === perfMark.name) {
-                                            ajaxData.perfTiming = perfTiming;
+                                        else if (entry.entryType === "mark" && entry[_DYN_NAME ] === perfMark[_DYN_NAME ]) {
+                                            ajaxData[_DYN_PERF_TIMING ] = perfTiming;
                                             break;
                                         }
-                                        if (entry.startTime < perfMark.startTime - 1000) {
+                                        if (entry[_DYN_START_TIME ] < perfMark[_DYN_START_TIME ] - 1000) {
                                             break;
                                         }
                                     }
                                 }
                             }
                             if (!perfMark ||
-                                ajaxData.perfTiming ||
+                                ajaxData[_DYN_PERF_TIMING ] ||
                                 attempt >= maxAttempts ||
                                 ajaxData.async === false) {
                                 if (perfMark && isFunction(performance.clearMarks)) {
-                                    performance.clearMarks(perfMark.name);
+                                    performance.clearMarks(perfMark[_DYN_NAME ]);
                                 }
                                 ajaxData.perfAttempts = attempt;
                                 trackCallback();
@@ -3492,33 +3685,33 @@
                     var traceID = (distributedTraceCtx && distributedTraceCtx.getTraceId()) || generateW3CId();
                     var spanID = generateW3CId().substr(0, 16);
                     var ajaxData = new ajaxRecord(traceID, spanID, _self[strDiagLog]());
-                    ajaxData.traceFlags = distributedTraceCtx && distributedTraceCtx.getTraceFlags();
-                    ajaxData.requestSentTime = dateTimeUtilsNow();
-                    ajaxData.errorStatusText = _enableAjaxErrorStatusText;
+                    ajaxData[_DYN_TRACE_FLAGS ] = distributedTraceCtx && distributedTraceCtx.getTraceFlags();
+                    ajaxData[_DYN_REQUEST_SENT_TIME ] = dateTimeUtilsNow();
+                    ajaxData[_DYN_ERROR_STATUS_TEXT ] = _enableAjaxErrorStatusText;
                     if (input instanceof Request) {
-                        ajaxData.requestUrl = input ? input.url : "";
+                        ajaxData[_DYN_REQUEST_URL ] = input ? input.url : "";
                     }
                     else {
-                        ajaxData.requestUrl = input;
+                        ajaxData[_DYN_REQUEST_URL ] = input;
                     }
                     var method = "GET";
-                    if (init && init.method) {
-                        method = init.method;
+                    if (init && init[_DYN_METHOD ]) {
+                        method = init[_DYN_METHOD ];
                     }
                     else if (input && input instanceof Request) {
-                        method = input.method;
+                        method = input[_DYN_METHOD ];
                     }
-                    ajaxData.method = method;
+                    ajaxData[_DYN_METHOD ] = method;
                     var requestHeaders = {};
                     if (_enableRequestHeaderTracking) {
-                        var headers = new Headers((init ? init.headers : 0) || (input instanceof Request ? (input.headers || {}) : {}));
+                        var headers = new Headers((init ? init[_DYN_HEADERS ] : 0) || (input instanceof Request ? (input[_DYN_HEADERS ] || {}) : {}));
                         headers.forEach(function (value, key) {
                             if (_canIncludeHeaders(key)) {
                                 requestHeaders[key] = value;
                             }
                         });
                     }
-                    ajaxData.requestHeaders = requestHeaders;
+                    ajaxData[_DYN_REQUEST_HEADERS ] = requestHeaders;
                     _createMarkId("fetch", ajaxData);
                     return ajaxData;
                 }
@@ -3551,10 +3744,10 @@
                         }
                         _throwInternalWarning(_self, msgId, "Failed to calculate the duration of the fetch call, monitoring data for this fetch call won't be sent.", errorProps);
                     }
-                    ajaxData.responseFinishedTime = dateTimeUtilsNow();
-                    ajaxData.status = status;
+                    ajaxData[_DYN_RESPONSE_FINISHED_TI12 ] = dateTimeUtilsNow();
+                    ajaxData[_DYN_STATUS ] = status;
                     _findPerfResourceEntry("fetch", ajaxData, function () {
-                        var dependency = ajaxData.CreateTrackItem("Fetch", _enableRequestHeaderTracking, getResponse);
+                        var dependency = ajaxData[_DYN__CREATE_TRACK_ITEM ]("Fetch", _enableRequestHeaderTracking, getResponse);
                         var properties;
                         try {
                             if (!!_addRequestContext) {
@@ -3566,14 +3759,14 @@
                         }
                         if (dependency) {
                             if (properties !== undefined) {
-                                dependency.properties = __assignFn(__assignFn({}, dependency.properties), properties);
+                                dependency[STR_PROPERTIES ] = __assignFn(__assignFn({}, dependency.properties), properties);
                             }
                             _self[strTrackDependencyDataInternal](dependency);
                         }
                         else {
                             _reportFetchError(14 , null, {
-                                requestSentTime: ajaxData.requestSentTime,
-                                responseFinishedTime: ajaxData.responseFinishedTime
+                                requestSentTime: ajaxData[_DYN_REQUEST_SENT_TIME ],
+                                responseFinishedTime: ajaxData[_DYN_RESPONSE_FINISHED_TI12 ]
                             });
                         }
                     }, function (e) {
@@ -3581,10 +3774,10 @@
                     });
                 }
                 function _getFetchCorrelationContext(response) {
-                    if (response && response.headers) {
+                    if (response && response[_DYN_HEADERS ]) {
                         try {
-                            var responseHeader = response.headers.get(RequestHeaders[0 ]);
-                            return CorrelationIdHelper.getCorrelationContext(responseHeader);
+                            var responseHeader = response[_DYN_HEADERS ].get(RequestHeaders[0 ]);
+                            return CorrelationIdHelper[_DYN_GET_CORRELATION_CONT14 ](responseHeader);
                         }
                         catch (e) {
                             _throwInternalWarning(_self, 18 , "Failed to get Request-Context correlation header as it may be not included in the response or not accessible.", {
@@ -3598,40 +3791,36 @@
             return _this;
         }
         AjaxMonitor.getDefaultConfig = function () {
-            var config = {
-                maxAjaxCallsPerView: 500,
-                disableAjaxTracking: false,
-                disableFetchTracking: false,
-                excludeRequestFromAutoTrackingPatterns: undefined,
-                disableCorrelationHeaders: false,
-                distributedTracingMode: 1 ,
-                correlationHeaderExcludedDomains: [
-                    "*.blob.core.windows.net",
-                    "*.blob.core.chinacloudapi.cn",
-                    "*.blob.core.cloudapi.de",
-                    "*.blob.core.usgovcloudapi.net"
-                ],
-                correlationHeaderDomains: undefined,
-                correlationHeaderExcludePatterns: undefined,
-                appId: undefined,
-                enableCorsCorrelation: false,
-                enableRequestHeaderTracking: false,
-                enableResponseHeaderTracking: false,
-                enableAjaxErrorStatusText: false,
-                enableAjaxPerfTracking: false,
-                maxAjaxPerfLookupAttempts: 3,
-                ajaxPerfLookupDelay: 25,
-                ignoreHeaders: [
+            var _a;
+            var config = (_a = {},
+                _a[_DYN_MAX_AJAX_CALLS_PER_V6 ] = 500,
+                _a[_DYN_DISABLE_AJAX_TRACKIN9 ] = false,
+                _a[_DYN_DISABLE_FETCH_TRACKI10 ] = false,
+                _a[_DYN_EXCLUDE_REQUEST_FROM8 ] = undefined,
+                _a.disableCorrelationHeaders = false,
+                _a.distributedTracingMode = 1 ,
+                _a.correlationHeaderExcludedDomains = DfltAjaxCorrelationHeaderExDomains,
+                _a.correlationHeaderDomains = undefined,
+                _a.correlationHeaderExcludePatterns = undefined,
+                _a[_DYN_APP_ID ] = undefined,
+                _a.enableCorsCorrelation = false,
+                _a[_DYN_ENABLE_REQUEST_HEADE3 ] = false,
+                _a[_DYN_ENABLE_RESPONSE_HEAD7 ] = false,
+                _a[_DYN_ENABLE_AJAX_ERROR_ST4 ] = false,
+                _a[_DYN_ENABLE_AJAX_PERF_TRA5 ] = false,
+                _a.maxAjaxPerfLookupAttempts = 3,
+                _a[_DYN_AJAX_PERF_LOOKUP_DEL15 ] = 25,
+                _a.ignoreHeaders = [
                     "Authorization",
                     "X-API-Key",
                     "WWW-Authenticate"
                 ],
-                addRequestContext: undefined
-            };
+                _a[_DYN_ADD_REQUEST_CONTEXT ] = undefined,
+                _a);
             return config;
         };
         AjaxMonitor.getEmptyConfig = function () {
-            var emptyConfig = this.getDefaultConfig();
+            var emptyConfig = this[_DYN_GET_DEFAULT_CONFIG ]();
             objForEachKey(emptyConfig, function (value) {
                 emptyConfig[value] = undefined;
             });
@@ -3645,6 +3834,7 @@
     }(BaseTelemetryPlugin));
 
     exports.AjaxPlugin = AjaxMonitor;
+    exports.DfltAjaxCorrelationHeaderExDomains = DfltAjaxCorrelationHeaderExDomains;
     exports.ajaxRecord = ajaxRecord;
 
     (function(obj, prop, descriptor) { /* ai_es3_polyfil defineProperty */ var func = Object["defineProperty"]; if (func) { try { return func(obj, prop, descriptor); } catch(e) { /* IE8 defines defineProperty, but will throw */ } } if (descriptor && typeof descriptor.value !== undefined) { obj[prop] = descriptor.value; } return obj; })(exports, '__esModule', { value: true });