@microsoft/applicationinsights-channel-js 2.8.5-nightly.2206-02 → 2.8.5-nightly.2206-06

package/browser/applicationinsights-channel-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Channel, 2.8.5-nightly.2206-02
+ * Application Insights JavaScript SDK - Channel, 2.8.5-nightly.2206-06
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -98,21 +98,310 @@
         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$1 = "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$1 = "message";
+    var _DYN_IS_ASYNC = "isAsync";
+    var _DYN__DO_TEARDOWN = "_doTeardown";
+    var _DYN_UPDATE = "update";
+    var _DYN_GET_NEXT = "getNext";
+    var _DYN_DIAG_LOG$1 = "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_NODE_TYPE = "nodeType";
+    var _DYN_APPLY = "apply";
+    var _DYN_ENABLE_DEBUG_EXCEPTI4 = "enableDebugExceptions";
+    var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
+    var _DYN_TO_LOWER_CASE$1 = "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 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 strIndexOf = "indexOf";
     var strMap = "map";
     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;
@@ -124,17 +413,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;
             }
@@ -156,11 +445,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;
             });
         }
@@ -169,24 +458,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";
@@ -200,15 +489,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;
@@ -222,7 +511,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;
@@ -238,11 +527,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;
                     }
                 }
@@ -256,7 +545,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++) {
@@ -276,13 +565,13 @@
             if (arr[strMap]) {
                 return arr[strMap](callbackfn, thisArg);
             }
-            var len = arr.length;
+            var len = arr[_DYN_LENGTH$2 ];
             var _this = thisArg || arr;
             results = new Array(len);
             try {
                 for (var lp = 0; lp < len; lp++) {
                     if (lp in arr) {
-                        results[lp] = callbackfn.call(_this, arr[lp], arr);
+                        results[lp] = callbackfn[_DYN_CALL ](_this, arr[lp], arr);
                     }
                 }
             }
@@ -293,7 +582,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;
     }
@@ -317,15 +606,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$1 ](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$1 ](_objKeysDontEnums[lp]);
                 }
             }
         }
@@ -372,9 +661,9 @@
     }
     function getExceptionName(object) {
         if (isError(object)) {
-            return object.name;
+            return object[_DYN_NAME$2 ];
         }
-        return strEmpty$1;
+        return STR_EMPTY;
     }
     function setValue(target, field, value, valChk, srcChk) {
         var theValue = value;
@@ -387,6 +676,9 @@
         }
         return theValue;
     }
+    function getCfgValue(theValue, defaultValue) {
+        return !isNullOrUndefined(theValue) ? theValue : defaultValue;
+    }
     function isTruthy(value) {
         return !!value;
     }
@@ -405,7 +697,7 @@
                 src = srcFunc();
             }
             if (src) {
-                return src[funcName].apply(src, originalArguments);
+                return src[funcName][_DYN_APPLY ](src, originalArguments);
             }
         };
     }
@@ -438,7 +730,7 @@
     function objExtend(obj1, obj2, obj3, obj4, obj5, obj6) {
         var theArgs = arguments;
         var extended = theArgs[0] || {};
-        var argLen = theArgs.length;
+        var argLen = theArgs[_DYN_LENGTH$2 ];
         var deep = false;
         var idx = 1;
         if (argLen > 0 && isBoolean(extended)) {
@@ -454,7 +746,7 @@
             var isArgArray = isArray(arg);
             var isArgObj = isObject(arg);
             for (var prop in arg) {
-                var propOk = (isArgArray && (prop in arg)) || (isArgObj && (ObjHasOwnProperty.call(arg, prop)));
+                var propOk = (isArgArray && (prop in arg)) || (isArgObj && (ObjHasOwnProperty[_DYN_CALL ](arg, prop)));
                 if (!propOk) {
                     continue;
                 }
@@ -497,254 +789,6 @@
         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;
-                }
-            }
-        }
-        return instFunc;
-    }
-    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 _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) {
-            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;
-        }
-        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 && !!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 strWindow = "window";
     var strDocument = "document";
     var strDocumentMode = "documentMode";
@@ -845,9 +889,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$1 ]();
             _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
         }
         return _isTrident;
@@ -856,15 +900,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$1 ]() : STR_EMPTY;
         }
-        var ua = (userAgentStr || strEmpty$1).toLowerCase();
+        var ua = (userAgentStr || STR_EMPTY)[_DYN_TO_LOWER_CASE$1 ]();
         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;
             }
@@ -872,10 +916,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);
@@ -940,13 +984,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();
@@ -964,23 +1006,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$1 ] =
                 (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$1 ] += 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) {
@@ -988,48 +1030,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$1 ])) {
                             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$1 ]);
                                     _messageLogged[messageKey] = true;
                                 }
                             }
                             else {
-                                if (logLevel >= severity) {
-                                    _self[logFunc](message.message);
+                                if (_loggingLevelConsole >= severity) {
+                                    _self[logFunc](message[_DYN_MESSAGE$1 ]);
                                 }
                             }
-                            _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);
                 };
@@ -1037,12 +1080,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;
                     }
@@ -1050,42 +1094,42 @@
                         _messageLogged[messageKey] = true;
                     }
                     if (logMessage) {
-                        if (severity <= _self.telemetryLoggingLevel()) {
-                            _self.queue.push(message);
+                        if (severity <= _loggingLevelTelemetry) {
+                            _self.queue[_DYN_PUSH$1 ](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$1 ](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$1 ]) {
+                        dbgExt[_DYN_DIAG_LOG$1 ](name, data);
                     }
                 }
             });
         }
+        DiagnosticLogger.__ieDyn=1;
         return DiagnosticLogger;
     }());
     function _getLogger(logger) {
@@ -1093,21 +1137,23 @@
     }
     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);
     }
     function _warnToConsole(logger, message) {
-        _getLogger(logger).warnToConsole(message);
+        _getLogger(logger)[STR_WARN_TO_CONSOLE ](message);
     }
 
     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 () {
@@ -1118,24 +1164,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 {
@@ -1144,20 +1190,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();
                 }
@@ -1171,40 +1217,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$1 ](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);
                 }
             }
         }
@@ -1266,8 +1312,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;
@@ -1280,7 +1326,7 @@
     }
 
     var _objDefineProperty = ObjDefineProperty;
-    var version = "2.8.5-nightly.2206-02";
+    var version = "2.8.5-nightly.2206-06";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _createAccessor(target, prop, value) {
@@ -1299,7 +1345,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];
@@ -1319,11 +1365,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);
             },
@@ -1365,16 +1411,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) {
@@ -1392,14 +1439,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; }
@@ -1411,53 +1458,53 @@
         return registeredEvents;
     }
     function _doDetach(obj, evtName, handlerRef, useCapture) {
-        if (obj && evtName && evtName.type) {
+        if (obj && evtName && evtName[_DYN_TYPE ]) {
             if (obj[strRemoveEventListener]) {
-                obj[strRemoveEventListener](evtName.type, handlerRef, useCapture);
+                obj[strRemoveEventListener](evtName[_DYN_TYPE ], handlerRef, useCapture);
             }
             else if (obj[strDetachEvent]) {
-                obj[strDetachEvent](strOnPrefix + evtName.type, handlerRef);
+                obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
             }
         }
     }
     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;
             }
         }
         return result;
     }
     function _doUnregister(target, events, evtName, unRegFn) {
-        var idx = events.length;
+        var idx = events[_DYN_LENGTH$2 ];
         while (idx--) {
             var theEvent = events[idx];
             if (theEvent) {
                 if (!evtName.ns || evtName.ns === theEvent.evtName.ns) {
                     if (!unRegFn || unRegFn(theEvent)) {
-                        _doDetach(target, theEvent.evtName, theEvent.handler, theEvent.capture);
-                        events.splice(idx, 1);
+                        _doDetach(target, theEvent.evtName, theEvent[_DYN_HANDLER ], theEvent.capture);
+                        events[_DYN_SPLICE ](idx, 1);
                     }
                 }
             }
         }
     }
     function _unregisterEvents(target, evtName, unRegFn) {
-        if (evtName.type) {
-            _doUnregister(target, _getRegisteredEvents(target, evtName.type), evtName, unRegFn);
+        if (evtName[_DYN_TYPE ]) {
+            _doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE ]), evtName, unRegFn);
         }
         else {
             var eventCache = elmNodeData.get(target, strEvents, {});
             objForEachKey(eventCache, function (evtType, events) {
                 _doUnregister(target, events, evtName, unRegFn);
             });
-            if (objKeys(eventCache).length === 0) {
+            if (objKeys(eventCache)[_DYN_LENGTH$2 ] === 0) {
                 elmNodeData.kill(target, strEvents);
             }
         }
@@ -1471,7 +1518,7 @@
             else {
                 newNamespaces = [theNamespace, namespaces];
             }
-            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns).split(".");
+            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT$1 ](".");
         }
         else {
             newNamespaces = theNamespace;
@@ -1479,6 +1526,7 @@
         return newNamespaces;
     }
     function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
+        var _a;
         if (useCapture === void 0) { useCapture = false; }
         var result = false;
         if (target) {
@@ -1486,13 +1534,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$1 ](registeredEvent);
                 }
             }
             catch (e) {
@@ -1507,7 +1556,7 @@
                 var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
                 var found_1 = false;
                 _unregisterEvents(target, evtName_1, function (regEvent) {
-                    if ((evtName_1.ns && !handlerRef) || regEvent.handler === handlerRef) {
+                    if ((evtName_1.ns && !handlerRef) || regEvent[_DYN_HANDLER ] === handlerRef) {
                         found_1 = true;
                         return true;
                     }
@@ -1533,12 +1582,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;
@@ -1579,7 +1628,7 @@
                 args[_i - 2] = arguments[_i];
             }
             if (onComplete) {
-                _onComplete.push({
+                _onComplete[_DYN_PUSH$1 ]({
                     func: onComplete,
                     self: !isUndefined(that) ? that : context.ctx,
                     args: args
@@ -1588,16 +1637,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 = [];
@@ -1610,7 +1659,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];
                 }
@@ -1651,7 +1700,7 @@
         function _iterateChain(cb) {
             var nextPlugin;
             while (!!(nextPlugin = context._next())) {
-                var plugin = nextPlugin.getPlugin();
+                var plugin = nextPlugin[_DYN_GET_PLUGIN ]();
                 if (plugin) {
                     cb(plugin);
                 }
@@ -1664,7 +1713,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) {
@@ -1672,14 +1721,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) {
@@ -1692,20 +1741,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);
                 }
             });
         }
@@ -1714,22 +1763,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;
@@ -1748,11 +1797,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++;
@@ -1784,17 +1833,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;
                         }
@@ -1806,7 +1855,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 ](), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
                         }
                     }
                 }, details, isAsync);
@@ -1820,17 +1869,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) {
@@ -1838,20 +1887,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) {
@@ -1859,9 +1908,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;
                         }
                     }
@@ -1869,19 +1918,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$1 ](handler);
             }
         }
         function _runHandlers(unloadCtx, unloadState) {
@@ -1890,7 +1937,7 @@
                     handler(unloadCtx, unloadState);
                 }
                 catch (e) {
-                    _throwInternal(unloadCtx.diagLog(), 2 , 73 , "Unexpected error calling unload handler - " + dumpObj(e));
+                    _throwInternal(unloadCtx[_DYN_DIAG_LOG$1 ](), 2 , 73 , "Unexpected error calling unload handler - " + dumpObj(e));
                 }
             });
             handlers = [];
@@ -1912,37 +1959,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 {
@@ -1950,9 +2000,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;
@@ -1964,7 +2014,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) {
@@ -1981,30 +2031,30 @@
                             _hooks = _hooks.concat(hooks);
                         }
                         else {
-                            _hooks.push(hooks);
+                            _hooks[_DYN_PUSH$1 ](hooks);
                         }
                     }
                 };
                 proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
             });
-            _self.diagLog = function (itemCtx) {
-                return _getTelCtx(itemCtx).diagLog();
+            _self[_DYN_DIAG_LOG$1 ] = function (itemCtx) {
+                return _getTelCtx(itemCtx)[_DYN_DIAG_LOG$1 ]();
             };
-            _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;
@@ -2012,63 +2062,194 @@
                 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 = [];
                 _unloadHandlerContainer = createUnloadHandlerContainer();
             }
         }
+        BaseTelemetryPlugin.__ieDyn=1;
         return BaseTelemetryPlugin;
     }());
 
-    var RequestHeaders = createValueMap({
-        requestContextHeader: [0 , "Request-Context"],
-        requestContextTargetKey: [1 , "appId"],
-        requestContextAppIdFormat: [2 , "appId=cid-v1:"],
-        requestIdHeader: [3 , "Request-Id"],
-        traceParentHeader: [4 , "traceparent"],
-        traceStateHeader: [5 , "tracestate"],
-        sdkContextHeader: [6 , "Sdk-Context"],
-        sdkContextHeaderAppIdRequest: [7 , "appId"],
-        requestContextHeaderLowerCase: [8 , "request-context"]
-    });
-
-    function dataSanitizeKeyAndAddUniqueness(logger, key, map) {
-        var origLength = key.length;
-        var field = dataSanitizeKey(logger, key);
-        if (field.length !== origLength) {
+    var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
+    var SampleRate = "sampleRate";
+    var ProcessLegacy = "ProcessLegacy";
+    var HttpMethod = "http.method";
+    var DEFAULT_BREEZE_ENDPOINT = "https://dc.services.visualstudio.com";
+    var DEFAULT_BREEZE_PATH = "/v2/track";
+    var strNotSpecified = "not_specified";
+
+    var _DYN_SPLIT = "split";
+    var _DYN_LENGTH$1 = "length";
+    var _DYN_TO_LOWER_CASE = "toLowerCase";
+    var _DYN_TO_STRING$1 = "toString";
+    var _DYN_REMOVE_ITEM = "removeItem";
+    var _DYN_NAME$1 = "name";
+    var _DYN_PATHNAME = "pathname";
+    var _DYN_INDEX_OF = "indexOf";
+    var _DYN_EXCEPTIONS = "exceptions";
+    var _DYN_PARSED_STACK = "parsedStack";
+    var _DYN_PROPERTIES = "properties";
+    var _DYN_MEASUREMENTS$1 = "measurements";
+    var _DYN_STRINGIFY$1 = "stringify";
+    var _DYN_MESSAGE = "message";
+    var _DYN_SIZE_IN_BYTES = "sizeInBytes";
+    var _DYN_TYPE_NAME = "typeName";
+    var _DYN_SEVERITY_LEVEL = "severityLevel";
+    var _DYN_PROBLEM_GROUP = "problemGroup";
+    var _DYN_IS_MANUAL = "isManual";
+    var _DYN__CREATE_FROM_INTERFA1 = "CreateFromInterface";
+    var _DYN_HAS_FULL_STACK = "hasFullStack";
+    var _DYN_LEVEL = "level";
+    var _DYN_METHOD = "method";
+    var _DYN_ASSEMBLY = "assembly";
+    var _DYN_FILE_NAME = "fileName";
+    var _DYN_LINE = "line";
+    var _DYN_DURATION = "duration";
+    var _DYN_RECEIVED_RESPONSE = "receivedResponse";
+    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"],
+        requestContextAppIdFormat: [2 , "appId=cid-v1:"],
+        requestIdHeader: [3 , "Request-Id"],
+        traceParentHeader: [4 , "traceparent"],
+        traceStateHeader: [5 , "tracestate"],
+        sdkContextHeader: [6 , "Sdk-Context"],
+        sdkContextHeaderAppIdRequest: [7 , "appId"],
+        requestContextHeaderLowerCase: [8 , "request-context"]
+    });
+
+    var StorageType = createEnumStyle({
+        LocalStorage: 0 ,
+        SessionStorage: 1
+    });
+    createEnumStyle({
+        AI: 0 ,
+        AI_AND_W3C: 1 ,
+        W3C: 2
+    });
+
+    var _canUseSessionStorage = undefined;
+    function _getVerifiedStorageObject(storageType) {
+        try {
+            if (isNullOrUndefined(getGlobal())) {
+                return null;
+            }
+            var uid = (new Date)[_DYN_TO_STRING$1 ]();
+            var storage = getGlobalInst(storageType === StorageType.LocalStorage ? "localStorage" : "sessionStorage");
+            storage.setItem(uid, uid);
+            var fail = storage.getItem(uid) !== uid;
+            storage[_DYN_REMOVE_ITEM ](uid);
+            if (!fail) {
+                return storage;
+            }
+        }
+        catch (exception) {
+        }
+        return null;
+    }
+    function _getSessionStorageObject() {
+        if (utlCanUseSessionStorage()) {
+            return _getVerifiedStorageObject(StorageType.SessionStorage);
+        }
+        return null;
+    }
+    function utlCanUseSessionStorage(reset) {
+        if (reset || _canUseSessionStorage === undefined) {
+            _canUseSessionStorage = !!_getVerifiedStorageObject(StorageType.SessionStorage);
+        }
+        return _canUseSessionStorage;
+    }
+    function utlGetSessionStorage(logger, name) {
+        var storage = _getSessionStorageObject();
+        if (storage !== null) {
+            try {
+                return storage.getItem(name);
+            }
+            catch (e) {
+                _canUseSessionStorage = false;
+                _throwInternal(logger, 2 , 2 , "Browser failed read of session storage. " + getExceptionName(e), { exception: dumpObj(e) });
+            }
+        }
+        return null;
+    }
+    function utlSetSessionStorage(logger, name, data) {
+        var storage = _getSessionStorageObject();
+        if (storage !== null) {
+            try {
+                storage.setItem(name, data);
+                return true;
+            }
+            catch (e) {
+                _canUseSessionStorage = false;
+                _throwInternal(logger, 2 , 4 , "Browser failed write to session storage. " + getExceptionName(e), { exception: dumpObj(e) });
+            }
+        }
+        return false;
+    }
+
+    var _a$1;
+    function dataSanitizeKeyAndAddUniqueness(logger, key, map) {
+        var origLength = key[_DYN_LENGTH$1 ];
+        var field = dataSanitizeKey(logger, key);
+        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;
         }
@@ -2077,9 +2258,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$1 ]());
+            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);
             }
         }
@@ -2091,8 +2272,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$1 ]()[_DYN_SUBSTRING ](0, maxLength);
                 _throwInternal(logger, 2 , 61 , "string value is too long. It has been truncated to " + maxLength + " characters.", { value: value }, true);
             }
         }
@@ -2104,8 +2285,8 @@
     function dataSanitizeMessage(logger, message) {
         var messageTrunc;
         if (message) {
-            if (message.length > 32768 ) {
-                messageTrunc = message.substring(0, 32768 );
+            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);
             }
         }
@@ -2115,8 +2296,8 @@
         var exceptionTrunc;
         if (exception) {
             var value = "" + exception;
-            if (value.length > 32768 ) {
-                exceptionTrunc = value.substring(0, 32768 );
+            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);
             }
         }
@@ -2128,7 +2309,7 @@
             objForEachKey(properties, function (prop, value) {
                 if (isObject(value) && hasJSON()) {
                     try {
-                        value = getJSON().stringify(value);
+                        value = getJSON()[_DYN_STRINGIFY$1 ](value);
                     }
                     catch (e) {
                         _throwInternal(logger, 2 , 49 , "custom property is not valid", { exception: e }, true);
@@ -2154,14 +2335,14 @@
         return measurements;
     }
     function dataSanitizeId(logger, id) {
-        return id ? dataSanitizeInput(logger, id, 128 , 69 ).toString() : id;
+        return id ? dataSanitizeInput(logger, id, 128 , 69 )[_DYN_TO_STRING$1 ]() : 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);
             }
         }
@@ -2169,101 +2350,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 SampleRate = "sampleRate";
-    var ProcessLegacy = "ProcessLegacy";
-    var HttpMethod = "http.method";
-    var strNotSpecified = "not_specified";
-
-    var StorageType = createEnumStyle({
-        LocalStorage: 0 ,
-        SessionStorage: 1
-    });
-    createEnumStyle({
-        AI: 0 ,
-        AI_AND_W3C: 1 ,
-        W3C: 2
-    });
-
-    var _canUseSessionStorage = undefined;
-    function _getVerifiedStorageObject(storageType) {
-        try {
-            if (isNullOrUndefined(getGlobal())) {
-                return null;
-            }
-            var uid = (new Date).toString();
-            var storage = getGlobalInst(storageType === StorageType.LocalStorage ? "localStorage" : "sessionStorage");
-            storage.setItem(uid, uid);
-            var fail = storage.getItem(uid) !== uid;
-            storage.removeItem(uid);
-            if (!fail) {
-                return storage;
-            }
-        }
-        catch (exception) {
-        }
-        return null;
-    }
-    function _getSessionStorageObject() {
-        if (utlCanUseSessionStorage()) {
-            return _getVerifiedStorageObject(StorageType.SessionStorage);
-        }
-        return null;
-    }
-    function utlCanUseSessionStorage(reset) {
-        if (reset || _canUseSessionStorage === undefined) {
-            _canUseSessionStorage = !!_getVerifiedStorageObject(StorageType.SessionStorage);
-        }
-        return _canUseSessionStorage;
-    }
-    function utlGetSessionStorage(logger, name) {
-        var storage = _getSessionStorageObject();
-        if (storage !== null) {
-            try {
-                return storage.getItem(name);
-            }
-            catch (e) {
-                _canUseSessionStorage = false;
-                _throwInternal(logger, 2 , 2 , "Browser failed read of session storage. " + getExceptionName(e), { exception: dumpObj(e) });
-            }
-        }
-        return null;
-    }
-    function utlSetSessionStorage(logger, name, data) {
-        var storage = _getSessionStorageObject();
-        if (storage !== null) {
-            try {
-                storage.setItem(name, data);
-                return true;
-            }
-            catch (e) {
-                _canUseSessionStorage = false;
-                _throwInternal(logger, 2 , 4 , "Browser failed write to session storage. " + getExceptionName(e), { exception: dumpObj(e) });
-            }
-        }
-        return false;
-    }
+        return s.substr(s[_DYN_LENGTH$1 ] - 3);
+    }
+    (_a$1 = {
+            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$1[_DYN_SANITIZE_KEY_AND_ADD2 ] = dataSanitizeKeyAndAddUniqueness,
+        _a$1.sanitizeKey = dataSanitizeKey,
+        _a$1.sanitizeString = dataSanitizeString,
+        _a$1.sanitizeUrl = dataSanitizeUrl,
+        _a$1.sanitizeMessage = dataSanitizeMessage,
+        _a$1[_DYN_SANITIZE_EXCEPTION ] = dataSanitizeException,
+        _a$1[_DYN_SANITIZE_PROPERTIES ] = dataSanitizeProperties,
+        _a$1[_DYN_SANITIZE_MEASUREMENT3 ] = dataSanitizeMeasurements,
+        _a$1.sanitizeId = dataSanitizeId,
+        _a$1.sanitizeInput = dataSanitizeInput,
+        _a$1.padNumber = dsPadNumber,
+        _a$1.trim = strTrim,
+        _a$1);
 
     var _document = getDocument() || {};
     var _htmlAnchorIdx = 0;
@@ -2280,7 +2390,7 @@
         }
         tempAnchor.href = url;
         anchorIdx++;
-        if (anchorIdx >= anchorCache.length) {
+        if (anchorIdx >= anchorCache[_DYN_LENGTH$1 ]) {
             anchorIdx = 0;
         }
         _htmlAnchorIdx = anchorIdx;
@@ -2290,7 +2400,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] || "");
             }
         }
@@ -2300,10 +2410,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 ]();
                     var port = match[3] || "";
                     if (protocol === "http" && port === ":80") {
                         port = "";
@@ -2319,25 +2429,25 @@
     }
 
     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;
     }
     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 {
@@ -2363,7 +2473,7 @@
             _self.ver = 1;
             _self.sampleRate = 100.0;
             _self.tags = {};
-            _self.name = dataSanitizeString(logger, name) || strNotSpecified;
+            _self[_DYN_NAME$1 ] = dataSanitizeString(logger, name) || strNotSpecified;
             _self.data = data;
             _self.time = toISOString(new Date());
             _self.aiDataContract = {
@@ -2390,9 +2500,9 @@
             };
             var _self = this;
             _self.ver = 2;
-            _self.name = dataSanitizeString(logger, name) || strNotSpecified;
-            _self.properties = dataSanitizeProperties(logger, properties);
-            _self.measurements = dataSanitizeMeasurements(logger, measurements);
+            _self[_DYN_NAME$1 ] = dataSanitizeString(logger, name) || strNotSpecified;
+            _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+            _self[_DYN_MEASUREMENTS$1 ] = dataSanitizeMeasurements(logger, measurements);
         }
         Event.envelopeType = "Microsoft.ApplicationInsights.{0}.Event";
         Event.dataType = "EventData";
@@ -2409,11 +2519,11 @@
     function _stringify(value, convertToString) {
         var result = value;
         if (result && !isString(result)) {
-            if (JSON && JSON.stringify) {
-                result = JSON.stringify(value);
+            if (JSON && JSON[_DYN_STRINGIFY$1 ]) {
+                result = JSON[_DYN_STRINGIFY$1 ](value);
                 if (convertToString && (!result || result === "{}")) {
-                    if (isFunction(value.toString)) {
-                        result = value.toString();
+                    if (isFunction(value[_DYN_TO_STRING$1 ])) {
+                        result = value[_DYN_TO_STRING$1 ]();
                     }
                     else {
                         result = "" + value;
@@ -2439,7 +2549,7 @@
                 evtMessage = evtMessage + " @" + (theEvent["filename"] || "") + ":" + (theEvent["lineno"] || "?") + ":" + (theEvent["colno"] || "?");
             }
         }
-        if (errorType && errorType !== "String" && errorType !== "Object" && errorType !== "Error" && (evtMessage || "").indexOf(errorType) === -1) {
+        if (errorType && errorType !== "String" && errorType !== "Object" && errorType !== "Error" && (evtMessage || "")[_DYN_INDEX_OF ](errorType) === -1) {
             evtMessage = errorType + ": " + evtMessage;
         }
         return evtMessage || "";
@@ -2477,7 +2587,7 @@
                 src = "" + src;
             }
         }
-        var items = src.split("\n");
+        var items = src[_DYN_SPLIT ]("\n");
         return {
             src: src,
             obj: items
@@ -2485,8 +2595,8 @@
     }
     function _getOperaStack(errorMessage) {
         var stack = [];
-        var lines = errorMessage.split("\n");
-        for (var lp = 0; lp < lines.length; lp++) {
+        var lines = errorMessage[_DYN_SPLIT ]("\n");
+        for (var lp = 0; lp < lines[_DYN_LENGTH$1 ]; lp++) {
             var entry = lines[lp];
             if (lines[lp + 1]) {
                 entry += "@" + lines[lp + 1];
@@ -2519,7 +2629,7 @@
                     details = errorObj[strStackDetails];
                 }
                 else if (window && window["opera"] && errorObj[strMessage]) {
-                    details = _getOperaStack(errorObj.message);
+                    details = _getOperaStack(errorObj[_DYN_MESSAGE ]);
                 }
                 else if (isString(errorObj)) {
                     details = _convertStackObj(errorObj);
@@ -2563,28 +2673,28 @@
     function _parseStack(stack) {
         var parsedStack;
         var frames = stack.obj;
-        if (frames && frames.length > 0) {
+        if (frames && frames[_DYN_LENGTH$1 ] > 0) {
             parsedStack = [];
             var level_1 = 0;
             var totalSizeInBytes_1 = 0;
             arrForEach(frames, function (frame) {
-                var theFrame = frame.toString();
+                var theFrame = frame[_DYN_TO_STRING$1 ]();
                 if (_StackFrame.regex.test(theFrame)) {
                     var parsedFrame = new _StackFrame(theFrame, level_1++);
-                    totalSizeInBytes_1 += parsedFrame.sizeInBytes;
+                    totalSizeInBytes_1 += parsedFrame[_DYN_SIZE_IN_BYTES ];
                     parsedStack.push(parsedFrame);
                 }
             });
             var exceptionParsedStackThreshold = 32 * 1024;
             if (totalSizeInBytes_1 > exceptionParsedStackThreshold) {
                 var left = 0;
-                var right = parsedStack.length - 1;
+                var right = parsedStack[_DYN_LENGTH$1 ] - 1;
                 var size = 0;
                 var acceptedLeft = left;
                 var acceptedRight = right;
                 while (left < right) {
-                    var lSize = parsedStack[left].sizeInBytes;
-                    var rSize = parsedStack[right].sizeInBytes;
+                    var lSize = parsedStack[left][_DYN_SIZE_IN_BYTES ];
+                    var rSize = parsedStack[right][_DYN_SIZE_IN_BYTES ];
                     size += lSize + rSize;
                     if (size > exceptionParsedStackThreshold) {
                         var howMany = acceptedRight - acceptedLeft + 1;
@@ -2603,12 +2713,12 @@
     function _getErrorType(errorType) {
         var typeName = "";
         if (errorType) {
-            typeName = errorType.typeName || errorType.name || "";
+            typeName = errorType.typeName || errorType[_DYN_NAME$1 ] || "";
             if (!typeName) {
                 try {
                     var funcNameRegex = /function (.{1,200})\(/;
-                    var results = (funcNameRegex).exec((errorType).constructor.toString());
-                    typeName = (results && results.length > 1) ? results[1] : "";
+                    var results = (funcNameRegex).exec((errorType).constructor[_DYN_TO_STRING$1 ]());
+                    typeName = (results && results[_DYN_LENGTH$1 ] > 1) ? results[1] : "";
                 }
                 catch (e) {
                 }
@@ -2629,7 +2739,7 @@
                         }
                         result = _stringify(errorObj, true);
                     }
-                    if (result.indexOf(errorType) !== 0 && errorType !== "String") {
+                    if (result[_DYN_INDEX_OF ](errorType) !== 0 && errorType !== "String") {
                         return errorType + ":" + result;
                     }
                     return result;
@@ -2655,79 +2765,83 @@
                 if (!properties) {
                     properties = {};
                 }
-                _self.exceptions = [new _ExceptionDetails(logger, exception, properties)];
-                _self.properties = dataSanitizeProperties(logger, properties);
-                _self.measurements = dataSanitizeMeasurements(logger, measurements);
+                _self[_DYN_EXCEPTIONS ] = [new _ExceptionDetails(logger, exception, properties)];
+                _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+                _self[_DYN_MEASUREMENTS$1 ] = dataSanitizeMeasurements(logger, measurements);
                 if (severityLevel) {
-                    _self.severityLevel = severityLevel;
+                    _self[_DYN_SEVERITY_LEVEL ] = severityLevel;
                 }
                 if (id) {
                     _self.id = id;
                 }
             }
             else {
-                _self.exceptions = exception.exceptions || [];
-                _self.properties = exception.properties;
-                _self.measurements = exception.measurements;
-                if (exception.severityLevel) {
-                    _self.severityLevel = exception.severityLevel;
+                _self[_DYN_EXCEPTIONS ] = exception[_DYN_EXCEPTIONS ] || [];
+                _self[_DYN_PROPERTIES ] = exception[_DYN_PROPERTIES ];
+                _self[_DYN_MEASUREMENTS$1 ] = exception[_DYN_MEASUREMENTS$1 ];
+                if (exception[_DYN_SEVERITY_LEVEL ]) {
+                    _self[_DYN_SEVERITY_LEVEL ] = exception[_DYN_SEVERITY_LEVEL ];
                 }
                 if (exception.id) {
                     _self.id = exception.id;
                 }
-                if (exception.problemGroup) {
-                    _self.problemGroup = exception.problemGroup;
+                if (exception[_DYN_PROBLEM_GROUP ]) {
+                    _self[_DYN_PROBLEM_GROUP ] = exception[_DYN_PROBLEM_GROUP ];
                 }
-                if (!isNullOrUndefined(exception.isManual)) {
-                    _self.isManual = exception.isManual;
+                if (!isNullOrUndefined(exception[_DYN_IS_MANUAL ])) {
+                    _self[_DYN_IS_MANUAL ] = exception[_DYN_IS_MANUAL ];
                 }
             }
         }
         Exception.CreateAutoException = function (message, url, lineNumber, columnNumber, error, evt, stack, errorSrc) {
+            var _a;
             var errorType = _getErrorType(error || evt || message);
-            return {
-                message: _formatMessage(message, errorType),
-                url: url,
-                lineNumber: lineNumber,
-                columnNumber: columnNumber,
-                error: _formatErrorCode(error || evt || message),
-                evt: _formatErrorCode(evt || message),
-                typeName: errorType,
-                stackDetails: _getStackFromErrorObj(stack || error || evt),
-                errorSrc: errorSrc
-            };
+            return _a = {},
+                _a[_DYN_MESSAGE ] = _formatMessage(message, errorType),
+                _a.url = url,
+                _a.lineNumber = lineNumber,
+                _a.columnNumber = columnNumber,
+                _a.error = _formatErrorCode(error || evt || message),
+                _a.evt = _formatErrorCode(evt || message),
+                _a[_DYN_TYPE_NAME ] = errorType,
+                _a.stackDetails = _getStackFromErrorObj(stack || error || evt),
+                _a.errorSrc = errorSrc,
+                _a;
         };
         Exception.CreateFromInterface = function (logger, exception, properties, measurements) {
-            var exceptions = exception.exceptions
-                && arrMap(exception.exceptions, function (ex) { return _ExceptionDetails.CreateFromInterface(logger, ex); });
+            var exceptions = exception[_DYN_EXCEPTIONS ]
+                && arrMap(exception[_DYN_EXCEPTIONS ], function (ex) { return _ExceptionDetails[_DYN__CREATE_FROM_INTERFA1 ](logger, ex); });
             var exceptionData = new Exception(logger, __assignFn(__assignFn({}, exception), { exceptions: exceptions }), properties, measurements);
             return exceptionData;
         };
         Exception.prototype.toInterface = function () {
-            var _a = this, exceptions = _a.exceptions, properties = _a.properties, measurements = _a.measurements, severityLevel = _a.severityLevel, problemGroup = _a.problemGroup, id = _a.id, isManual = _a.isManual;
+            var _a;
+            var _b = this, exceptions = _b.exceptions, properties = _b.properties, measurements = _b.measurements, severityLevel = _b.severityLevel, problemGroup = _b.problemGroup, id = _b.id, isManual = _b.isManual;
             var exceptionDetailsInterface = exceptions instanceof Array
                 && arrMap(exceptions, function (exception) { return exception.toInterface(); })
                 || undefined;
-            return {
-                ver: "4.0",
-                exceptions: exceptionDetailsInterface,
-                severityLevel: severityLevel,
-                properties: properties,
-                measurements: measurements,
-                problemGroup: problemGroup,
-                id: id,
-                isManual: isManual
-            };
+            return _a = {
+                    ver: "4.0"
+                },
+                _a[_DYN_EXCEPTIONS ] = exceptionDetailsInterface,
+                _a.severityLevel = severityLevel,
+                _a.properties = properties,
+                _a.measurements = measurements,
+                _a.problemGroup = problemGroup,
+                _a.id = id,
+                _a.isManual = isManual,
+                _a;
         };
         Exception.CreateSimpleException = function (message, typeName, assembly, fileName, details, line) {
+            var _a;
             return {
                 exceptions: [
-                    {
-                        hasFullStack: true,
-                        message: message,
-                        stack: details,
-                        typeName: typeName
-                    }
+                    (_a = {},
+                        _a[_DYN_HAS_FULL_STACK ] = true,
+                        _a.message = message,
+                        _a.stack = details,
+                        _a.typeName = typeName,
+                        _a)
                 ]
             };
         };
@@ -2754,43 +2868,45 @@
                 if (!isError(error)) {
                     error = error[strError] || evt || error;
                 }
-                _self.typeName = dataSanitizeString(logger, _getErrorType(error)) || strNotSpecified;
-                _self.message = dataSanitizeMessage(logger, _formatMessage(exception || error, _self.typeName)) || strNotSpecified;
+                _self[_DYN_TYPE_NAME ] = dataSanitizeString(logger, _getErrorType(error)) || strNotSpecified;
+                _self[_DYN_MESSAGE ] = dataSanitizeMessage(logger, _formatMessage(exception || error, _self[_DYN_TYPE_NAME ])) || strNotSpecified;
                 var stack = exception[strStackDetails] || _getStackFromErrorObj(exception);
-                _self.parsedStack = _parseStack(stack);
+                _self[_DYN_PARSED_STACK ] = _parseStack(stack);
                 _self[strStack] = dataSanitizeException(logger, _formatStackTrace(stack));
-                _self.hasFullStack = isArray(_self.parsedStack) && _self.parsedStack.length > 0;
+                _self.hasFullStack = isArray(_self.parsedStack) && _self.parsedStack[_DYN_LENGTH$1 ] > 0;
                 if (properties) {
-                    properties.typeName = properties.typeName || _self.typeName;
+                    properties[_DYN_TYPE_NAME ] = properties[_DYN_TYPE_NAME ] || _self[_DYN_TYPE_NAME ];
                 }
             }
             else {
-                _self.typeName = exception.typeName;
-                _self.message = exception.message;
+                _self[_DYN_TYPE_NAME ] = exception[_DYN_TYPE_NAME ];
+                _self[_DYN_MESSAGE ] = exception[_DYN_MESSAGE ];
                 _self[strStack] = exception[strStack];
-                _self.parsedStack = exception.parsedStack || [];
-                _self.hasFullStack = exception.hasFullStack;
+                _self[_DYN_PARSED_STACK ] = exception[_DYN_PARSED_STACK ] || [];
+                _self[_DYN_HAS_FULL_STACK ] = exception[_DYN_HAS_FULL_STACK ];
             }
         }
         _ExceptionDetails.prototype.toInterface = function () {
+            var _a;
             var _self = this;
-            var parsedStack = _self.parsedStack instanceof Array
-                && arrMap(_self.parsedStack, function (frame) { return frame.toInterface(); });
-            var exceptionDetailsInterface = {
-                id: _self.id,
-                outerId: _self.outerId,
-                typeName: _self.typeName,
-                message: _self.message,
-                hasFullStack: _self.hasFullStack,
-                stack: _self[strStack],
-                parsedStack: parsedStack || undefined
-            };
+            var parsedStack = _self[_DYN_PARSED_STACK ] instanceof Array
+                && arrMap(_self[_DYN_PARSED_STACK ], function (frame) { return frame.toInterface(); });
+            var exceptionDetailsInterface = (_a = {
+                    id: _self.id,
+                    outerId: _self.outerId,
+                    typeName: _self[_DYN_TYPE_NAME ],
+                    message: _self[_DYN_MESSAGE ],
+                    hasFullStack: _self[_DYN_HAS_FULL_STACK ],
+                    stack: _self[strStack]
+                },
+                _a[_DYN_PARSED_STACK ] = parsedStack || undefined,
+                _a);
             return exceptionDetailsInterface;
         };
         _ExceptionDetails.CreateFromInterface = function (logger, exception) {
-            var parsedStack = (exception.parsedStack instanceof Array
-                && arrMap(exception.parsedStack, function (frame) { return _StackFrame.CreateFromInterface(frame); }))
-                || exception.parsedStack;
+            var parsedStack = (exception[_DYN_PARSED_STACK ] instanceof Array
+                && arrMap(exception[_DYN_PARSED_STACK ], function (frame) { return _StackFrame[_DYN__CREATE_FROM_INTERFA1 ](frame); }))
+                || exception[_DYN_PARSED_STACK ];
             var exceptionDetails = new _ExceptionDetails(logger, __assignFn(__assignFn({}, exception), { parsedStack: parsedStack }));
             return exceptionDetails;
         };
@@ -2806,35 +2922,35 @@
                 line: 0
             };
             var _self = this;
-            _self.sizeInBytes = 0;
+            _self[_DYN_SIZE_IN_BYTES ] = 0;
             if (typeof sourceFrame === "string") {
                 var frame = sourceFrame;
-                _self.level = level;
-                _self.method = NoMethod;
-                _self.assembly = strTrim(frame);
-                _self.fileName = "";
-                _self.line = 0;
+                _self[_DYN_LEVEL ] = level;
+                _self[_DYN_METHOD ] = NoMethod;
+                _self[_DYN_ASSEMBLY ] = strTrim(frame);
+                _self[_DYN_FILE_NAME ] = "";
+                _self[_DYN_LINE ] = 0;
                 var matches = frame.match(_StackFrame.regex);
-                if (matches && matches.length >= 5) {
-                    _self.method = strTrim(matches[2]) || _self.method;
-                    _self.fileName = strTrim(matches[4]);
-                    _self.line = parseInt(matches[5]) || 0;
+                if (matches && matches[_DYN_LENGTH$1 ] >= 5) {
+                    _self[_DYN_METHOD ] = strTrim(matches[2]) || _self[_DYN_METHOD ];
+                    _self[_DYN_FILE_NAME ] = strTrim(matches[4]);
+                    _self[_DYN_LINE ] = parseInt(matches[5]) || 0;
                 }
             }
             else {
-                _self.level = sourceFrame.level;
-                _self.method = sourceFrame.method;
-                _self.assembly = sourceFrame.assembly;
-                _self.fileName = sourceFrame.fileName;
-                _self.line = sourceFrame.line;
-                _self.sizeInBytes = 0;
-            }
-            _self.sizeInBytes += _self.method.length;
-            _self.sizeInBytes += _self.fileName.length;
-            _self.sizeInBytes += _self.assembly.length;
-            _self.sizeInBytes += _StackFrame.baseSize;
-            _self.sizeInBytes += _self.level.toString().length;
-            _self.sizeInBytes += _self.line.toString().length;
+                _self[_DYN_LEVEL ] = sourceFrame[_DYN_LEVEL ];
+                _self[_DYN_METHOD ] = sourceFrame[_DYN_METHOD ];
+                _self[_DYN_ASSEMBLY ] = sourceFrame[_DYN_ASSEMBLY ];
+                _self[_DYN_FILE_NAME ] = sourceFrame[_DYN_FILE_NAME ];
+                _self[_DYN_LINE ] = sourceFrame[_DYN_LINE ];
+                _self[_DYN_SIZE_IN_BYTES ] = 0;
+            }
+            _self.sizeInBytes += _self.method[_DYN_LENGTH$1 ];
+            _self.sizeInBytes += _self.fileName[_DYN_LENGTH$1 ];
+            _self.sizeInBytes += _self.assembly[_DYN_LENGTH$1 ];
+            _self[_DYN_SIZE_IN_BYTES ] += _StackFrame.baseSize;
+            _self.sizeInBytes += _self.level.toString()[_DYN_LENGTH$1 ];
+            _self.sizeInBytes += _self.line.toString()[_DYN_LENGTH$1 ];
         }
         _StackFrame.CreateFromInterface = function (frame) {
             return new _StackFrame(frame, null );
@@ -2842,11 +2958,11 @@
         _StackFrame.prototype.toInterface = function () {
             var _self = this;
             return {
-                level: _self.level,
-                method: _self.method,
-                assembly: _self.assembly,
-                fileName: _self.fileName,
-                line: _self.line
+                level: _self[_DYN_LEVEL ],
+                method: _self[_DYN_METHOD ],
+                assembly: _self[_DYN_ASSEMBLY ],
+                fileName: _self[_DYN_FILE_NAME ],
+                line: _self[_DYN_LINE ]
             };
         };
         _StackFrame.regex = /^([\s]+at)?[\s]{0,50}([^\@\()]+?)[\s]{0,50}(\@|\()([^\(\n]+):([0-9]+):([0-9]+)(\)?)$/;
@@ -2883,12 +2999,12 @@
             dataPoint.count = count > 0 ? count : undefined;
             dataPoint.max = isNaN(max) || max === null ? undefined : max;
             dataPoint.min = isNaN(min) || min === null ? undefined : min;
-            dataPoint.name = dataSanitizeString(logger, name) || strNotSpecified;
+            dataPoint[_DYN_NAME$1 ] = dataSanitizeString(logger, name) || strNotSpecified;
             dataPoint.value = value;
             dataPoint.stdDev = isNaN(stdDev) || stdDev === null ? undefined : stdDev;
             _self.metrics = [dataPoint];
-            _self.properties = dataSanitizeProperties(logger, properties);
-            _self.measurements = dataSanitizeMeasurements(logger, measurements);
+            _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+            _self[_DYN_MEASUREMENTS$1 ] = dataSanitizeMeasurements(logger, measurements);
         }
         Metric.envelopeType = "Microsoft.ApplicationInsights.{0}.Metric";
         Metric.dataType = "MetricData";
@@ -2910,12 +3026,12 @@
             _self.ver = 2;
             _self.id = dataSanitizeId(logger, id);
             _self.url = dataSanitizeUrl(logger, url);
-            _self.name = dataSanitizeString(logger, name) || strNotSpecified;
+            _self[_DYN_NAME$1 ] = dataSanitizeString(logger, name) || strNotSpecified;
             if (!isNaN(durationMs)) {
-                _self.duration = msToTimeSpan(durationMs);
+                _self[_DYN_DURATION ] = msToTimeSpan(durationMs);
             }
-            _self.properties = dataSanitizeProperties(logger, properties);
-            _self.measurements = dataSanitizeMeasurements(logger, measurements);
+            _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+            _self[_DYN_MEASUREMENTS$1 ] = dataSanitizeMeasurements(logger, measurements);
         }
         PageView.envelopeType = "Microsoft.ApplicationInsights.{0}.Pageview";
         PageView.dataType = "PageviewData";
@@ -2951,7 +3067,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);
@@ -2961,9 +3077,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$1 ] = dataSanitizeMeasurements(logger, measurements);
         }
         RemoteDependencyData.envelopeType = "Microsoft.ApplicationInsights.{0}.RemoteDependency";
         RemoteDependencyData.dataType = "RemoteDependencyData";
@@ -2981,11 +3097,11 @@
             var _self = this;
             _self.ver = 2;
             message = message || strNotSpecified;
-            _self.message = dataSanitizeMessage(logger, message);
-            _self.properties = dataSanitizeProperties(logger, properties);
-            _self.measurements = dataSanitizeMeasurements(logger, measurements);
+            _self[_DYN_MESSAGE ] = dataSanitizeMessage(logger, message);
+            _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+            _self[_DYN_MEASUREMENTS$1 ] = dataSanitizeMeasurements(logger, measurements);
             if (severityLevel) {
-                _self.severityLevel = severityLevel;
+                _self[_DYN_SEVERITY_LEVEL ] = severityLevel;
             }
         }
         Trace.envelopeType = "Microsoft.ApplicationInsights.{0}.Message";
@@ -3011,15 +3127,15 @@
             var _self = this;
             _self.ver = 2;
             _self.url = dataSanitizeUrl(logger, url);
-            _self.name = dataSanitizeString(logger, name) || strNotSpecified;
-            _self.properties = dataSanitizeProperties(logger, properties);
-            _self.measurements = dataSanitizeMeasurements(logger, measurements);
+            _self[_DYN_NAME$1 ] = dataSanitizeString(logger, name) || strNotSpecified;
+            _self[_DYN_PROPERTIES ] = dataSanitizeProperties(logger, properties);
+            _self[_DYN_MEASUREMENTS$1 ] = dataSanitizeMeasurements(logger, measurements);
             if (cs4BaseData) {
                 _self.domProcessing = cs4BaseData.domProcessing;
-                _self.duration = cs4BaseData.duration;
+                _self[_DYN_DURATION ] = cs4BaseData[_DYN_DURATION ];
                 _self.networkConnect = cs4BaseData.networkConnect;
                 _self.perfTotal = cs4BaseData.perfTotal;
-                _self.receivedResponse = cs4BaseData.receivedResponse;
+                _self[_DYN_RECEIVED_RESPONSE ] = cs4BaseData[_DYN_RECEIVED_RESPONSE ];
                 _self.sentRequest = cs4BaseData.sentRequest;
             }
         }
@@ -3124,189 +3240,80 @@
 
     var BreezeChannelIdentifier = "AppInsightsChannelPlugin";
 
-    var BaseSendBuffer = /** @class */ (function () {
-        function BaseSendBuffer(logger, config) {
-            var _buffer = [];
-            var _bufferFullMessageSent = false;
-            this._get = function () {
-                return _buffer;
-            };
-            this._set = function (buffer) {
-                _buffer = buffer;
-                return _buffer;
-            };
-            dynamicProto(BaseSendBuffer, this, function (_self) {
-                _self.enqueue = function (payload) {
-                    if (_self.count() >= config.eventsLimitInMem()) {
-                        if (!_bufferFullMessageSent) {
-                            _throwInternal(logger, 2 , 105 , "Maximum in-memory buffer size reached: " + _self.count(), true);
-                            _bufferFullMessageSent = true;
-                        }
-                        return;
-                    }
-                    _buffer.push(payload);
-                };
-                _self.count = function () {
-                    return _buffer.length;
-                };
-                _self.size = function () {
-                    var size = _buffer.length;
-                    for (var lp = 0; lp < _buffer.length; lp++) {
-                        size += _buffer[lp].length;
-                    }
-                    if (!config.emitLineDelimitedJson()) {
-                        size += 2;
-                    }
-                    return size;
-                };
-                _self.clear = function () {
-                    _buffer = [];
-                    _bufferFullMessageSent = false;
-                };
-                _self.getItems = function () {
-                    return _buffer.slice(0);
-                };
-                _self.batchPayloads = function (payload) {
-                    if (payload && payload.length > 0) {
-                        var batch = config.emitLineDelimitedJson() ?
-                            payload.join("\n") :
-                            "[" + payload.join(",") + "]";
-                        return batch;
-                    }
-                    return null;
-                };
-            });
-        }
-        return BaseSendBuffer;
-    }());
-    var ArraySendBuffer = /** @class */ (function (_super) {
-        __extendsFn(ArraySendBuffer, _super);
-        function ArraySendBuffer(logger, config) {
-            var _this = _super.call(this, logger, config) || this;
-            dynamicProto(ArraySendBuffer, _this, function (_self, _base) {
-                _self.markAsSent = function (payload) {
-                    _base.clear();
-                };
-                _self.clearSent = function (payload) {
-                };
-            });
-            return _this;
-        }
-        return ArraySendBuffer;
-    }(BaseSendBuffer));
-    var SessionStorageSendBuffer = /** @class */ (function (_super) {
-        __extendsFn(SessionStorageSendBuffer, _super);
-        function SessionStorageSendBuffer(logger, config) {
-            var _this = _super.call(this, logger, config) || this;
-            var _bufferFullMessageSent = false;
-            dynamicProto(SessionStorageSendBuffer, _this, function (_self, _base) {
-                var bufferItems = _getBuffer(SessionStorageSendBuffer.BUFFER_KEY);
-                var notDeliveredItems = _getBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY);
-                var buffer = _self._set(bufferItems.concat(notDeliveredItems));
-                if (buffer.length > SessionStorageSendBuffer.MAX_BUFFER_SIZE) {
-                    buffer.length = SessionStorageSendBuffer.MAX_BUFFER_SIZE;
-                }
-                _setBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY, []);
-                _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, buffer);
-                _self.enqueue = function (payload) {
-                    if (_self.count() >= SessionStorageSendBuffer.MAX_BUFFER_SIZE) {
-                        if (!_bufferFullMessageSent) {
-                            _throwInternal(logger, 2 , 67 , "Maximum buffer size reached: " + _self.count(), true);
-                            _bufferFullMessageSent = true;
-                        }
-                        return;
-                    }
-                    _base.enqueue(payload);
-                    _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, _self._get());
-                };
-                _self.clear = function () {
-                    _base.clear();
-                    _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, _self._get());
-                    _setBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY, []);
-                    _bufferFullMessageSent = false;
-                };
-                _self.markAsSent = function (payload) {
-                    _setBuffer(SessionStorageSendBuffer.BUFFER_KEY, _self._set(_removePayloadsFromBuffer(payload, _self._get())));
-                    var sentElements = _getBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY);
-                    if (sentElements instanceof Array && payload instanceof Array) {
-                        sentElements = sentElements.concat(payload);
-                        if (sentElements.length > SessionStorageSendBuffer.MAX_BUFFER_SIZE) {
-                            _throwInternal(logger, 1 , 67 , "Sent buffer reached its maximum size: " + sentElements.length, true);
-                            sentElements.length = SessionStorageSendBuffer.MAX_BUFFER_SIZE;
-                        }
-                        _setBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY, sentElements);
-                    }
-                };
-                _self.clearSent = function (payload) {
-                    var sentElements = _getBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY);
-                    sentElements = _removePayloadsFromBuffer(payload, sentElements);
-                    _setBuffer(SessionStorageSendBuffer.SENT_BUFFER_KEY, sentElements);
-                };
-                function _removePayloadsFromBuffer(payloads, buffer) {
-                    var remaining = [];
-                    arrForEach(buffer, function (value) {
-                        if (!isFunction(value) && arrIndexOf(payloads, value) === -1) {
-                            remaining.push(value);
-                        }
-                    });
-                    return remaining;
-                }
-                function _getBuffer(key) {
-                    var prefixedKey = key;
-                    try {
-                        prefixedKey = config.namePrefix && config.namePrefix() ? config.namePrefix() + "_" + prefixedKey : prefixedKey;
-                        var bufferJson = utlGetSessionStorage(logger, prefixedKey);
-                        if (bufferJson) {
-                            var buffer_1 = getJSON().parse(bufferJson);
-                            if (isString(buffer_1)) {
-                                buffer_1 = getJSON().parse(buffer_1);
-                            }
-                            if (buffer_1 && isArray(buffer_1)) {
-                                return buffer_1;
-                            }
-                        }
-                    }
-                    catch (e) {
-                        _throwInternal(logger, 1 , 42 , " storage key: " + prefixedKey + ", " + getExceptionName(e), { exception: dumpObj(e) });
-                    }
-                    return [];
-                }
-                function _setBuffer(key, buffer) {
-                    var prefixedKey = key;
-                    try {
-                        prefixedKey = config.namePrefix && config.namePrefix() ? config.namePrefix() + "_" + prefixedKey : prefixedKey;
-                        var bufferJson = JSON.stringify(buffer);
-                        utlSetSessionStorage(logger, prefixedKey, bufferJson);
-                    }
-                    catch (e) {
-                        utlSetSessionStorage(logger, prefixedKey, JSON.stringify([]));
-                        _throwInternal(logger, 2 , 41 , " storage key: " + prefixedKey + ", " + getExceptionName(e) + ". Buffer cleared", { exception: dumpObj(e) });
-                    }
-                }
-            });
-            return _this;
-        }
-        SessionStorageSendBuffer.BUFFER_KEY = "AI_buffer";
-        SessionStorageSendBuffer.SENT_BUFFER_KEY = "AI_sentBuffer";
-        SessionStorageSendBuffer.MAX_BUFFER_SIZE = 2000;
-        return SessionStorageSendBuffer;
-    }(BaseSendBuffer));
-
-    var strBaseType = "baseType";
-    var strBaseData = "baseData";
-    var strProperties = "properties";
-    var strTrue = "true";
-    function _setValueIf(target, field, value) {
-        return setValue(target, field, value, isTruthy);
-    }
-    function _extractPartAExtensions(logger, item, env) {
-        var envTags = env.tags = env.tags || {};
-        var itmExt = item.ext = item.ext || {};
-        var itmTags = item.tags = item.tags || [];
-        var extUser = itmExt.user;
-        if (extUser) {
-            _setValueIf(envTags, CtxTagKeys.userAuthUserId, extUser.authId);
-            _setValueIf(envTags, CtxTagKeys.userId, extUser.id || extUser.localId);
+    var STR_DURATION = "duration";
+
+    var _DYN_TAGS = "tags";
+    var _DYN_DEVICE_TYPE = "deviceType";
+    var _DYN_DATA = "data";
+    var _DYN_NAME = "name";
+    var _DYN_TRACE_ID = "traceID";
+    var _DYN_LENGTH = "length";
+    var _DYN_STRINGIFY = "stringify";
+    var _DYN_MEASUREMENTS = "measurements";
+    var _DYN_DATA_TYPE = "dataType";
+    var _DYN_ENVELOPE_TYPE = "envelopeType";
+    var _DYN_TO_STRING = "toString";
+    var _DYN_ON_LINE = "onLine";
+    var _DYN_ENQUEUE = "enqueue";
+    var _DYN_COUNT = "count";
+    var _DYN_PUSH = "push";
+    var _DYN_EMIT_LINE_DELIMITED_0 = "emitLineDelimitedJson";
+    var _DYN_CLEAR = "clear";
+    var _DYN_BATCH_PAYLOADS = "batchPayloads";
+    var _DYN_MARK_AS_SENT = "markAsSent";
+    var _DYN_CLEAR_SENT = "clearSent";
+    var _DYN__BUFFER__KEY = "BUFFER_KEY";
+    var _DYN__SENT__BUFFER__KEY = "SENT_BUFFER_KEY";
+    var _DYN__MAX__BUFFER__SIZE = "MAX_BUFFER_SIZE";
+    var _DYN_NAME_PREFIX = "namePrefix";
+    var _DYN_MAX_BATCH_SIZE_IN_BY1 = "maxBatchSizeInBytes";
+    var _DYN_TRIGGER_SEND = "triggerSend";
+    var _DYN_DIAG_LOG = "diagLog";
+    var _DYN_ONUNLOAD_DISABLE_BEA2 = "onunloadDisableBeacon";
+    var _DYN_IS_BEACON_API_DISABL3 = "isBeaconApiDisabled";
+    var _DYN__SENDER = "_sender";
+    var _DYN__SENDER_CONFIG = "_senderConfig";
+    var _DYN__BUFFER = "_buffer";
+    var _DYN_ENABLE_SESSION_STORA4 = "enableSessionStorageBuffer";
+    var _DYN_SAMPLING_PERCENTAGE = "samplingPercentage";
+    var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
+    var _DYN_ENDPOINT_URL = "endpointUrl";
+    var _DYN_CUSTOM_HEADERS = "customHeaders";
+    var _DYN_DISABLE_XHR = "disableXhr";
+    var _DYN_ONUNLOAD_DISABLE_FET5 = "onunloadDisableFetch";
+    var _DYN_DISABLE_TELEMETRY = "disableTelemetry";
+    var _DYN_BASE_TYPE = "baseType";
+    var _DYN_SAMPLE_RATE = "sampleRate";
+    var _DYN_CONVERT_UNDEFINED = "convertUndefined";
+    var _DYN__XHR_READY_STATE_CHA6 = "_xhrReadyStateChange";
+    var _DYN__ON_ERROR = "_onError";
+    var _DYN__ON_PARTIAL_SUCCESS = "_onPartialSuccess";
+    var _DYN__ON_SUCCESS = "_onSuccess";
+    var _DYN_ITEMS_ACCEPTED = "itemsAccepted";
+    var _DYN_ITEMS_RECEIVED = "itemsReceived";
+    var _DYN_IS_RETRY_DISABLED = "isRetryDisabled";
+    var _DYN_SET_REQUEST_HEADER = "setRequestHeader";
+    var _DYN_MAX_BATCH_INTERVAL = "maxBatchInterval";
+    var _DYN_EVENTS_SEND_REQUEST = "eventsSendRequest";
+    var _DYN_DISABLE_INSTRUMENTAT7 = "disableInstrumentationKeyValidation";
+    var _DYN_GET_SAMPLING_SCORE = "getSamplingScore";
+    var _DYN_GET_HASH_CODE_SCORE = "getHashCodeScore";
+
+    var strBaseType = "baseType";
+    var strBaseData = "baseData";
+    var strProperties = "properties";
+    var strTrue = "true";
+    function _setValueIf(target, field, value) {
+        return setValue(target, field, value, isTruthy);
+    }
+    function _extractPartAExtensions(logger, item, env) {
+        var envTags = env[_DYN_TAGS ] = env[_DYN_TAGS ] || {};
+        var itmExt = item.ext = item.ext || {};
+        var itmTags = item[_DYN_TAGS ] = item[_DYN_TAGS ] || [];
+        var extUser = itmExt.user;
+        if (extUser) {
+            _setValueIf(envTags, CtxTagKeys.userAuthUserId, extUser.authId);
+            _setValueIf(envTags, CtxTagKeys.userId, extUser.id || extUser.localId);
         }
         var extApp = itmExt.app;
         if (extApp) {
@@ -3315,17 +3322,17 @@
         var extDevice = itmExt.device;
         if (extDevice) {
             _setValueIf(envTags, CtxTagKeys.deviceId, extDevice.id || extDevice.localId);
-            _setValueIf(envTags, CtxTagKeys.deviceType, extDevice.deviceClass);
+            _setValueIf(envTags, CtxTagKeys[_DYN_DEVICE_TYPE ], extDevice.deviceClass);
             _setValueIf(envTags, CtxTagKeys.deviceIp, extDevice.ip);
             _setValueIf(envTags, CtxTagKeys.deviceModel, extDevice.model);
-            _setValueIf(envTags, CtxTagKeys.deviceType, extDevice.deviceType);
+            _setValueIf(envTags, CtxTagKeys[_DYN_DEVICE_TYPE ], extDevice[_DYN_DEVICE_TYPE ]);
         }
         var web = item.ext.web;
         if (web) {
             _setValueIf(envTags, CtxTagKeys.deviceLanguage, web.browserLang);
             _setValueIf(envTags, CtxTagKeys.deviceBrowserVersion, web.browserVer);
             _setValueIf(envTags, CtxTagKeys.deviceBrowser, web.browser);
-            var envData = env.data = env.data || {};
+            var envData = env[_DYN_DATA ] = env[_DYN_DATA ] || {};
             var envBaseData = envData[strBaseData] = envData[strBaseData] || {};
             var envProps = envBaseData[strProperties] = envBaseData[strProperties] || {};
             _setValueIf(envProps, "domain", web.domain);
@@ -3335,16 +3342,16 @@
         }
         var extOs = itmExt.os;
         if (extOs) {
-            _setValueIf(envTags, CtxTagKeys.deviceOS, extOs.name);
+            _setValueIf(envTags, CtxTagKeys.deviceOS, extOs[_DYN_NAME ]);
         }
         var extTrace = itmExt.trace;
         if (extTrace) {
             _setValueIf(envTags, CtxTagKeys.operationParentId, extTrace.parentID);
-            _setValueIf(envTags, CtxTagKeys.operationName, dataSanitizeString(logger, extTrace.name));
-            _setValueIf(envTags, CtxTagKeys.operationId, extTrace.traceID);
+            _setValueIf(envTags, CtxTagKeys.operationName, dataSanitizeString(logger, extTrace[_DYN_NAME ]));
+            _setValueIf(envTags, CtxTagKeys.operationId, extTrace[_DYN_TRACE_ID ]);
         }
         var tgs = {};
-        for (var i = itmTags.length - 1; i >= 0; i--) {
+        for (var i = itmTags[_DYN_LENGTH ] - 1; i >= 0; i--) {
             var tg = itmTags[i];
             objForEachKey(tg, function (key, value) {
                 tgs[key] = value;
@@ -3358,7 +3365,7 @@
         if (!theTags[CtxTagKeys.internalSdkVersion]) {
             theTags[CtxTagKeys.internalSdkVersion] = "javascript:".concat(EnvelopeCreator.Version);
         }
-        env.tags = optimizeObject(theTags);
+        env[_DYN_TAGS ] = optimizeObject(theTags);
     }
     function _extractPropsAndMeasurements(data, properties, measurements) {
         if (!isNullOrUndefined(data)) {
@@ -3370,7 +3377,7 @@
                     properties[key] = value;
                 }
                 else if (hasJSON()) {
-                    properties[key] = getJSON().stringify(value);
+                    properties[key] = getJSON()[_DYN_STRINGIFY ](value);
                 }
             });
         }
@@ -3390,9 +3397,9 @@
         }
         envelope.iKey = telemetryItem.iKey;
         var iKeyNoDashes = telemetryItem.iKey.replace(/-/g, "");
-        envelope.name = envelope.name.replace("{0}", iKeyNoDashes);
+        envelope[_DYN_NAME ] = envelope[_DYN_NAME ].replace("{0}", iKeyNoDashes);
         _extractPartAExtensions(logger, telemetryItem, envelope);
-        telemetryItem.tags = telemetryItem.tags || [];
+        telemetryItem[_DYN_TAGS ] = telemetryItem[_DYN_TAGS ] || [];
         return optimizeObject(envelope);
     }
     function EnvelopeCreatorInit(logger, telemetryItem) {
@@ -3401,13 +3408,13 @@
         }
     }
     var EnvelopeCreator = {
-        Version: "2.8.5-nightly.2206-02"
+        Version: "2.8.5-nightly.2206-06"
     };
     function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
-        var customMeasurements = telemetryItem[strBaseData].measurements || {};
+        var customMeasurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS ] || {};
         var customProperties = telemetryItem[strBaseData][strProperties] || {};
-        _extractPropsAndMeasurements(telemetryItem.data, customProperties, customMeasurements);
+        _extractPropsAndMeasurements(telemetryItem[_DYN_DATA ], customProperties, customMeasurements);
         if (!isNullOrUndefined(customUndefinedValue)) {
             _convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
         }
@@ -3417,87 +3424,86 @@
             return null;
         }
         var method = bd[strProperties] && bd[strProperties][HttpMethod] ? bd[strProperties][HttpMethod] : "GET";
-        var remoteDepData = new RemoteDependencyData(logger, bd.id, bd.target, bd.name, bd.duration, bd.success, bd.responseCode, method, bd.type, bd.correlationContext, customProperties, customMeasurements);
-        var data = new Data(RemoteDependencyData.dataType, remoteDepData);
-        return _createEnvelope(logger, RemoteDependencyData.envelopeType, telemetryItem, data);
+        var remoteDepData = new RemoteDependencyData(logger, bd.id, bd.target, bd[_DYN_NAME ], bd[STR_DURATION ], bd.success, bd.responseCode, method, bd.type, bd.correlationContext, customProperties, customMeasurements);
+        var data = new Data(RemoteDependencyData[_DYN_DATA_TYPE ], remoteDepData);
+        return _createEnvelope(logger, RemoteDependencyData[_DYN_ENVELOPE_TYPE ], telemetryItem, data);
     }
     function EventEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
         var customProperties = {};
         var customMeasurements = {};
-        if (telemetryItem[strBaseType] !== Event.dataType) {
+        if (telemetryItem[strBaseType] !== Event[_DYN_DATA_TYPE ]) {
             customProperties["baseTypeSource"] = telemetryItem[strBaseType];
         }
-        if (telemetryItem[strBaseType] === Event.dataType) {
+        if (telemetryItem[strBaseType] === Event[_DYN_DATA_TYPE ]) {
             customProperties = telemetryItem[strBaseData][strProperties] || {};
-            customMeasurements = telemetryItem[strBaseData].measurements || {};
+            customMeasurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS ] || {};
         }
         else {
             if (telemetryItem[strBaseData]) {
                 _extractPropsAndMeasurements(telemetryItem[strBaseData], customProperties, customMeasurements);
             }
         }
-        _extractPropsAndMeasurements(telemetryItem.data, customProperties, customMeasurements);
+        _extractPropsAndMeasurements(telemetryItem[_DYN_DATA ], customProperties, customMeasurements);
         if (!isNullOrUndefined(customUndefinedValue)) {
             _convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
         }
-        var eventName = telemetryItem[strBaseData].name;
+        var eventName = telemetryItem[strBaseData][_DYN_NAME ];
         var eventData = new Event(logger, eventName, customProperties, customMeasurements);
-        var data = new Data(Event.dataType, eventData);
-        return _createEnvelope(logger, Event.envelopeType, telemetryItem, data);
+        var data = new Data(Event[_DYN_DATA_TYPE ], eventData);
+        return _createEnvelope(logger, Event[_DYN_ENVELOPE_TYPE ], telemetryItem, data);
     }
     function ExceptionEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
-        var customMeasurements = telemetryItem[strBaseData].measurements || {};
+        var customMeasurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS ] || {};
         var customProperties = telemetryItem[strBaseData][strProperties] || {};
-        _extractPropsAndMeasurements(telemetryItem.data, customProperties, customMeasurements);
+        _extractPropsAndMeasurements(telemetryItem[_DYN_DATA ], customProperties, customMeasurements);
         if (!isNullOrUndefined(customUndefinedValue)) {
             _convertPropsUndefinedToCustomDefinedValue(customProperties, customUndefinedValue);
         }
         var bd = telemetryItem[strBaseData];
         var exData = Exception.CreateFromInterface(logger, bd, customProperties, customMeasurements);
-        var data = new Data(Exception.dataType, exData);
-        return _createEnvelope(logger, Exception.envelopeType, telemetryItem, data);
+        var data = new Data(Exception[_DYN_DATA_TYPE ], exData);
+        return _createEnvelope(logger, Exception[_DYN_ENVELOPE_TYPE ], telemetryItem, data);
     }
     function MetricEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
         var baseData = telemetryItem[strBaseData];
         var props = baseData[strProperties] || {};
-        var measurements = baseData.measurements || {};
-        _extractPropsAndMeasurements(telemetryItem.data, props, measurements);
+        var measurements = baseData[_DYN_MEASUREMENTS ] || {};
+        _extractPropsAndMeasurements(telemetryItem[_DYN_DATA ], props, measurements);
         if (!isNullOrUndefined(customUndefinedValue)) {
             _convertPropsUndefinedToCustomDefinedValue(props, customUndefinedValue);
         }
-        var baseMetricData = new Metric(logger, baseData.name, baseData.average, baseData.sampleCount, baseData.min, baseData.max, baseData.stdDev, props, measurements);
-        var data = new Data(Metric.dataType, baseMetricData);
-        return _createEnvelope(logger, Metric.envelopeType, telemetryItem, data);
+        var baseMetricData = new Metric(logger, baseData[_DYN_NAME ], baseData.average, baseData.sampleCount, baseData.min, baseData.max, baseData.stdDev, props, measurements);
+        var data = new Data(Metric[_DYN_DATA_TYPE ], baseMetricData);
+        return _createEnvelope(logger, Metric[_DYN_ENVELOPE_TYPE ], telemetryItem, data);
     }
     function PageViewEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
-        var strDuration = "duration";
         var duration;
         var baseData = telemetryItem[strBaseData];
         if (!isNullOrUndefined(baseData) &&
             !isNullOrUndefined(baseData[strProperties]) &&
-            !isNullOrUndefined(baseData[strProperties][strDuration])) {
-            duration = baseData[strProperties][strDuration];
-            delete baseData[strProperties][strDuration];
+            !isNullOrUndefined(baseData[strProperties][STR_DURATION])) {
+            duration = baseData[strProperties][STR_DURATION];
+            delete baseData[strProperties][STR_DURATION];
         }
-        else if (!isNullOrUndefined(telemetryItem.data) &&
-            !isNullOrUndefined(telemetryItem.data[strDuration])) {
-            duration = telemetryItem.data[strDuration];
-            delete telemetryItem.data[strDuration];
+        else if (!isNullOrUndefined(telemetryItem[_DYN_DATA ]) &&
+            !isNullOrUndefined(telemetryItem[_DYN_DATA ][STR_DURATION])) {
+            duration = telemetryItem[_DYN_DATA ][STR_DURATION];
+            delete telemetryItem[_DYN_DATA ][STR_DURATION];
         }
         var bd = telemetryItem[strBaseData];
         var currentContextId;
-        if (((telemetryItem.ext || {}).trace || {}).traceID) {
-            currentContextId = telemetryItem.ext.trace.traceID;
+        if (((telemetryItem.ext || {}).trace || {})[_DYN_TRACE_ID ]) {
+            currentContextId = telemetryItem.ext.trace[_DYN_TRACE_ID ];
         }
         var id = bd.id || currentContextId;
-        var name = bd.name;
+        var name = bd[_DYN_NAME ];
         var url = bd.uri;
         var properties = bd[strProperties] || {};
-        var measurements = bd.measurements || {};
+        var measurements = bd[_DYN_MEASUREMENTS ] || {};
         if (!isNullOrUndefined(bd.refUri)) {
             properties["refUri"] = bd.refUri;
         }
@@ -3505,7 +3511,7 @@
             properties["pageType"] = bd.pageType;
         }
         if (!isNullOrUndefined(bd.isLoggedIn)) {
-            properties["isLoggedIn"] = bd.isLoggedIn.toString();
+            properties["isLoggedIn"] = bd.isLoggedIn[_DYN_TO_STRING ]();
         }
         if (!isNullOrUndefined(bd[strProperties])) {
             var pageTags = bd[strProperties];
@@ -3513,54 +3519,300 @@
                 properties[key] = value;
             });
         }
-        _extractPropsAndMeasurements(telemetryItem.data, properties, measurements);
+        _extractPropsAndMeasurements(telemetryItem[_DYN_DATA ], properties, measurements);
         if (!isNullOrUndefined(customUndefinedValue)) {
             _convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue);
         }
         var pageViewData = new PageView(logger, name, url, duration, properties, measurements, id);
-        var data = new Data(PageView.dataType, pageViewData);
-        return _createEnvelope(logger, PageView.envelopeType, telemetryItem, data);
+        var data = new Data(PageView[_DYN_DATA_TYPE ], pageViewData);
+        return _createEnvelope(logger, PageView[_DYN_ENVELOPE_TYPE ], telemetryItem, data);
     }
     function PageViewPerformanceEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
         var bd = telemetryItem[strBaseData];
-        var name = bd.name;
+        var name = bd[_DYN_NAME ];
         var url = bd.uri || bd.url;
         var properties = bd[strProperties] || {};
-        var measurements = bd.measurements || {};
-        _extractPropsAndMeasurements(telemetryItem.data, properties, measurements);
+        var measurements = bd[_DYN_MEASUREMENTS ] || {};
+        _extractPropsAndMeasurements(telemetryItem[_DYN_DATA ], properties, measurements);
         if (!isNullOrUndefined(customUndefinedValue)) {
             _convertPropsUndefinedToCustomDefinedValue(properties, customUndefinedValue);
         }
         var baseData = new PageViewPerformance(logger, name, url, undefined, properties, measurements, bd);
-        var data = new Data(PageViewPerformance.dataType, baseData);
-        return _createEnvelope(logger, PageViewPerformance.envelopeType, telemetryItem, data);
+        var data = new Data(PageViewPerformance[_DYN_DATA_TYPE ], baseData);
+        return _createEnvelope(logger, PageViewPerformance[_DYN_ENVELOPE_TYPE ], telemetryItem, data);
     }
     function TraceEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
         var message = telemetryItem[strBaseData].message;
         var severityLevel = telemetryItem[strBaseData].severityLevel;
         var props = telemetryItem[strBaseData][strProperties] || {};
-        var measurements = telemetryItem[strBaseData].measurements || {};
-        _extractPropsAndMeasurements(telemetryItem.data, props, measurements);
+        var measurements = telemetryItem[strBaseData][_DYN_MEASUREMENTS ] || {};
+        _extractPropsAndMeasurements(telemetryItem[_DYN_DATA ], props, measurements);
         if (!isNullOrUndefined(customUndefinedValue)) {
             _convertPropsUndefinedToCustomDefinedValue(props, customUndefinedValue);
         }
         var baseData = new Trace(logger, message, severityLevel, props, measurements);
-        var data = new Data(Trace.dataType, baseData);
-        return _createEnvelope(logger, Trace.envelopeType, telemetryItem, data);
+        var data = new Data(Trace[_DYN_DATA_TYPE ], baseData);
+        return _createEnvelope(logger, Trace[_DYN_ENVELOPE_TYPE ], telemetryItem, data);
+    }
+
+    function _disableEvents(target, evtNamespace) {
+        eventOff(target, null, null, evtNamespace);
+    }
+    function createOfflineListener(parentEvtNamespace) {
+        var _document = getDocument();
+        var _navigator = getNavigator();
+        var _isListening = false;
+        var _onlineStatus = true;
+        var _evtNamespace = mergeEvtNamespace(createUniqueNamespace("OfflineListener"), parentEvtNamespace);
+        try {
+            if (_enableEvents(getWindow())) {
+                _isListening = true;
+            }
+            if (_document) {
+                var target = _document.body || _document;
+                if (target.ononline) {
+                    if (_enableEvents(target)) {
+                        _isListening = true;
+                    }
+                }
+            }
+            if (_isListening) {
+                if (_navigator && !isNullOrUndefined(_navigator[_DYN_ON_LINE ])) {
+                    _onlineStatus = _navigator[_DYN_ON_LINE ];
+                }
+            }
+        }
+        catch (e) {
+            _isListening = false;
+        }
+        function _enableEvents(target) {
+            var enabled = false;
+            if (target) {
+                enabled = eventOn(target, "online", _setOnline, _evtNamespace);
+                if (enabled) {
+                    eventOn(target, "offline", _setOffline, _evtNamespace);
+                }
+            }
+            return enabled;
+        }
+        function _setOnline() {
+            _onlineStatus = true;
+        }
+        function _setOffline() {
+            _onlineStatus = false;
+        }
+        function _isOnline() {
+            var result = true;
+            if (_isListening) {
+                result = _onlineStatus;
+            }
+            else if (_navigator && !isNullOrUndefined(_navigator[_DYN_ON_LINE ])) {
+                result = _navigator[_DYN_ON_LINE ];
+            }
+            return result;
+        }
+        function _unload() {
+            var win = getWindow();
+            if (win && _isListening) {
+                _disableEvents(win, _evtNamespace);
+                if (_document) {
+                    var target = _document.body || _document;
+                    if (!isUndefined(target.ononline)) {
+                        _disableEvents(target, _evtNamespace);
+                    }
+                }
+                _isListening = false;
+            }
+        }
+        return {
+            isOnline: _isOnline,
+            isListening: function () { return _isListening; },
+            unload: _unload
+        };
     }
 
+    var BaseSendBuffer = /** @class */ (function () {
+        function BaseSendBuffer(logger, config) {
+            var _buffer = [];
+            var _bufferFullMessageSent = false;
+            this._get = function () {
+                return _buffer;
+            };
+            this._set = function (buffer) {
+                _buffer = buffer;
+                return _buffer;
+            };
+            dynamicProto(BaseSendBuffer, this, function (_self) {
+                _self[_DYN_ENQUEUE ] = function (payload) {
+                    if (_self[_DYN_COUNT ]() >= config.eventsLimitInMem()) {
+                        if (!_bufferFullMessageSent) {
+                            _throwInternal(logger, 2 , 105 , "Maximum in-memory buffer size reached: " + _self[_DYN_COUNT ](), true);
+                            _bufferFullMessageSent = true;
+                        }
+                        return;
+                    }
+                    _buffer[_DYN_PUSH ](payload);
+                };
+                _self[_DYN_COUNT ] = function () {
+                    return _buffer[_DYN_LENGTH ];
+                };
+                _self.size = function () {
+                    var size = _buffer[_DYN_LENGTH ];
+                    for (var lp = 0; lp < _buffer[_DYN_LENGTH ]; lp++) {
+                        size += _buffer[lp][_DYN_LENGTH ];
+                    }
+                    if (!config[_DYN_EMIT_LINE_DELIMITED_0 ]()) {
+                        size += 2;
+                    }
+                    return size;
+                };
+                _self[_DYN_CLEAR ] = function () {
+                    _buffer = [];
+                    _bufferFullMessageSent = false;
+                };
+                _self.getItems = function () {
+                    return _buffer.slice(0);
+                };
+                _self[_DYN_BATCH_PAYLOADS ] = function (payload) {
+                    if (payload && payload[_DYN_LENGTH ] > 0) {
+                        var batch = config[_DYN_EMIT_LINE_DELIMITED_0 ]() ?
+                            payload.join("\n") :
+                            "[" + payload.join(",") + "]";
+                        return batch;
+                    }
+                    return null;
+                };
+            });
+        }
+        BaseSendBuffer.__ieDyn=1;
+        return BaseSendBuffer;
+    }());
+    var ArraySendBuffer = /** @class */ (function (_super) {
+        __extendsFn(ArraySendBuffer, _super);
+        function ArraySendBuffer(logger, config) {
+            var _this = _super.call(this, logger, config) || this;
+            dynamicProto(ArraySendBuffer, _this, function (_self, _base) {
+                _self[_DYN_MARK_AS_SENT ] = function (payload) {
+                    _base[_DYN_CLEAR ]();
+                };
+                _self[_DYN_CLEAR_SENT ] = function (payload) {
+                };
+            });
+            return _this;
+        }
+        ArraySendBuffer.__ieDyn=1;
+        return ArraySendBuffer;
+    }(BaseSendBuffer));
+    var SessionStorageSendBuffer = /** @class */ (function (_super) {
+        __extendsFn(SessionStorageSendBuffer, _super);
+        function SessionStorageSendBuffer(logger, config) {
+            var _this = _super.call(this, logger, config) || this;
+            var _bufferFullMessageSent = false;
+            dynamicProto(SessionStorageSendBuffer, _this, function (_self, _base) {
+                var bufferItems = _getBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY ]);
+                var notDeliveredItems = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ]);
+                var buffer = _self._set(bufferItems.concat(notDeliveredItems));
+                if (buffer[_DYN_LENGTH ] > SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ]) {
+                    buffer[_DYN_LENGTH ] = SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ];
+                }
+                _setBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ], []);
+                _setBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY ], buffer);
+                _self[_DYN_ENQUEUE ] = function (payload) {
+                    if (_self[_DYN_COUNT ]() >= SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ]) {
+                        if (!_bufferFullMessageSent) {
+                            _throwInternal(logger, 2 , 67 , "Maximum buffer size reached: " + _self[_DYN_COUNT ](), true);
+                            _bufferFullMessageSent = true;
+                        }
+                        return;
+                    }
+                    _base[_DYN_ENQUEUE ](payload);
+                    _setBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY ], _self._get());
+                };
+                _self[_DYN_CLEAR ] = function () {
+                    _base[_DYN_CLEAR ]();
+                    _setBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY ], _self._get());
+                    _setBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ], []);
+                    _bufferFullMessageSent = false;
+                };
+                _self[_DYN_MARK_AS_SENT ] = function (payload) {
+                    _setBuffer(SessionStorageSendBuffer[_DYN__BUFFER__KEY ], _self._set(_removePayloadsFromBuffer(payload, _self._get())));
+                    var sentElements = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ]);
+                    if (sentElements instanceof Array && payload instanceof Array) {
+                        sentElements = sentElements.concat(payload);
+                        if (sentElements[_DYN_LENGTH ] > SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ]) {
+                            _throwInternal(logger, 1 , 67 , "Sent buffer reached its maximum size: " + sentElements[_DYN_LENGTH ], true);
+                            sentElements[_DYN_LENGTH ] = SessionStorageSendBuffer[_DYN__MAX__BUFFER__SIZE ];
+                        }
+                        _setBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ], sentElements);
+                    }
+                };
+                _self[_DYN_CLEAR_SENT ] = function (payload) {
+                    var sentElements = _getBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ]);
+                    sentElements = _removePayloadsFromBuffer(payload, sentElements);
+                    _setBuffer(SessionStorageSendBuffer[_DYN__SENT__BUFFER__KEY ], sentElements);
+                };
+                function _removePayloadsFromBuffer(payloads, buffer) {
+                    var remaining = [];
+                    arrForEach(buffer, function (value) {
+                        if (!isFunction(value) && arrIndexOf(payloads, value) === -1) {
+                            remaining[_DYN_PUSH ](value);
+                        }
+                    });
+                    return remaining;
+                }
+                function _getBuffer(key) {
+                    var prefixedKey = key;
+                    try {
+                        prefixedKey = config[_DYN_NAME_PREFIX ] && config[_DYN_NAME_PREFIX ]() ? config[_DYN_NAME_PREFIX ]() + "_" + prefixedKey : prefixedKey;
+                        var bufferJson = utlGetSessionStorage(logger, prefixedKey);
+                        if (bufferJson) {
+                            var buffer_1 = getJSON().parse(bufferJson);
+                            if (isString(buffer_1)) {
+                                buffer_1 = getJSON().parse(buffer_1);
+                            }
+                            if (buffer_1 && isArray(buffer_1)) {
+                                return buffer_1;
+                            }
+                        }
+                    }
+                    catch (e) {
+                        _throwInternal(logger, 1 , 42 , " storage key: " + prefixedKey + ", " + getExceptionName(e), { exception: dumpObj(e) });
+                    }
+                    return [];
+                }
+                function _setBuffer(key, buffer) {
+                    var prefixedKey = key;
+                    try {
+                        prefixedKey = config[_DYN_NAME_PREFIX ] && config[_DYN_NAME_PREFIX ]() ? config[_DYN_NAME_PREFIX ]() + "_" + prefixedKey : prefixedKey;
+                        var bufferJson = JSON[_DYN_STRINGIFY ](buffer);
+                        utlSetSessionStorage(logger, prefixedKey, bufferJson);
+                    }
+                    catch (e) {
+                        utlSetSessionStorage(logger, prefixedKey, JSON[_DYN_STRINGIFY ]([]));
+                        _throwInternal(logger, 2 , 41 , " storage key: " + prefixedKey + ", " + getExceptionName(e) + ". Buffer cleared", { exception: dumpObj(e) });
+                    }
+                }
+            });
+            return _this;
+        }
+        SessionStorageSendBuffer.BUFFER_KEY = "AI_buffer";
+        SessionStorageSendBuffer.SENT_BUFFER_KEY = "AI_sentBuffer";
+        SessionStorageSendBuffer.MAX_BUFFER_SIZE = 2000;
+        return SessionStorageSendBuffer;
+    }(BaseSendBuffer));
+
     var Serializer = /** @class */ (function () {
         function Serializer(logger) {
             dynamicProto(Serializer, this, function (_self) {
                 _self.serialize = function (input) {
                     var output = _serializeObject(input, "root");
                     try {
-                        return getJSON().stringify(output);
+                        return getJSON()[_DYN_STRINGIFY ](output);
                     }
                     catch (e) {
-                        _throwInternal(logger, 1 , 48 , (e && isFunction(e.toString)) ? e.toString() : "Error serializing object", null, true);
+                        _throwInternal(logger, 1 , 48 , (e && isFunction(e[_DYN_TO_STRING ])) ? e[_DYN_TO_STRING ]() : "Error serializing object", null, true);
                     }
                 };
                 function _serializeObject(source, name) {
@@ -3590,11 +3842,11 @@
                         else {
                             _throwInternal(logger, 2 , 49 , "Attempting to serialize an object which does not implement ISerializable", { name: name }, true);
                             try {
-                                getJSON().stringify(source);
+                                getJSON()[_DYN_STRINGIFY ](source);
                                 output = source;
                             }
                             catch (e) {
-                                _throwInternal(logger, 1 , 48 , (e && isFunction(e.toString)) ? e.toString() : "Error serializing object", null, true);
+                                _throwInternal(logger, 1 , 48 , (e && isFunction(e[_DYN_TO_STRING ])) ? e[_DYN_TO_STRING ]() : "Error serializing object", null, true);
                             }
                         }
                         return output;
@@ -3638,10 +3890,10 @@
                         }
                         else {
                             output = [];
-                            for (var i = 0; i < sources.length; i++) {
+                            for (var i = 0; i < sources[_DYN_LENGTH ]; i++) {
                                 var source = sources[i];
                                 var item = _serializeObject(source, name + "[" + i + "]");
-                                output.push(item);
+                                output[_DYN_PUSH ](item);
                             }
                         }
                     }
@@ -3659,11 +3911,11 @@
                                 else if (value === null) {
                                     output[field] = "null";
                                 }
-                                else if (!value.toString) {
+                                else if (!value[_DYN_TO_STRING ]) {
                                     output[field] = "invalid field: toString() is not defined.";
                                 }
                                 else {
-                                    output[field] = value.toString();
+                                    output[field] = value[_DYN_TO_STRING ]();
                                 }
                             }
                             else if (expectedType === "number") {
@@ -3693,85 +3945,10 @@
                 }
             });
         }
+        Serializer.__ieDyn=1;
         return Serializer;
     }());
 
-    function _disableEvents(target, evtNamespace) {
-        eventOff(target, null, null, evtNamespace);
-    }
-    function createOfflineListener(parentEvtNamespace) {
-        var _document = getDocument();
-        var _navigator = getNavigator();
-        var _isListening = false;
-        var _onlineStatus = true;
-        var _evtNamespace = mergeEvtNamespace(createUniqueNamespace("OfflineListener"), parentEvtNamespace);
-        try {
-            if (_enableEvents(getWindow())) {
-                _isListening = true;
-            }
-            if (_document) {
-                var target = _document.body || _document;
-                if (target.ononline) {
-                    if (_enableEvents(target)) {
-                        _isListening = true;
-                    }
-                }
-            }
-            if (_isListening) {
-                if (_navigator && !isNullOrUndefined(_navigator.onLine)) {
-                    _onlineStatus = _navigator.onLine;
-                }
-            }
-        }
-        catch (e) {
-            _isListening = false;
-        }
-        function _enableEvents(target) {
-            var enabled = false;
-            if (target) {
-                enabled = eventOn(target, "online", _setOnline, _evtNamespace);
-                if (enabled) {
-                    eventOn(target, "offline", _setOffline, _evtNamespace);
-                }
-            }
-            return enabled;
-        }
-        function _setOnline() {
-            _onlineStatus = true;
-        }
-        function _setOffline() {
-            _onlineStatus = false;
-        }
-        function _isOnline() {
-            var result = true;
-            if (_isListening) {
-                result = _onlineStatus;
-            }
-            else if (_navigator && !isNullOrUndefined(_navigator.onLine)) {
-                result = _navigator.onLine;
-            }
-            return result;
-        }
-        function _unload() {
-            var win = getWindow();
-            if (win && _isListening) {
-                _disableEvents(win, _evtNamespace);
-                if (_document) {
-                    var target = _document.body || _document;
-                    if (!isUndefined(target.ononline)) {
-                        _disableEvents(target, _evtNamespace);
-                    }
-                }
-                _isListening = false;
-            }
-        }
-        return {
-            isOnline: _isOnline,
-            isListening: function () { return _isListening; },
-            unload: _unload
-        };
-    }
-
     var MIN_INPUT_LENGTH = 8;
     var HashCodeScoreGenerator = /** @class */ (function () {
         function HashCodeScoreGenerator() {
@@ -3784,11 +3961,11 @@
             if (input === "") {
                 return 0;
             }
-            while (input.length < MIN_INPUT_LENGTH) {
+            while (input[_DYN_LENGTH ] < MIN_INPUT_LENGTH) {
                 input = input.concat(input);
             }
             var hash = 5381;
-            for (var i = 0; i < input.length; ++i) {
+            for (var i = 0; i < input[_DYN_LENGTH ]; ++i) {
                 hash = ((hash << 5) + hash) + input.charCodeAt(i);
                 hash = hash & hash;
             }
@@ -3803,19 +3980,19 @@
             var _self = this;
             var hashCodeGenerator = new HashCodeScoreGenerator();
             var keys = new ContextTagKeys();
-            _self.getSamplingScore = function (item) {
+            _self[_DYN_GET_SAMPLING_SCORE ] = function (item) {
                 var score = 0;
-                if (item.tags && item.tags[keys.userId]) {
-                    score = hashCodeGenerator.getHashCodeScore(item.tags[keys.userId]);
+                if (item[_DYN_TAGS ] && item[_DYN_TAGS ][keys.userId]) {
+                    score = hashCodeGenerator.getHashCodeScore(item[_DYN_TAGS ][keys.userId]);
                 }
                 else if (item.ext && item.ext.user && item.ext.user.id) {
-                    score = hashCodeGenerator.getHashCodeScore(item.ext.user.id);
+                    score = hashCodeGenerator[_DYN_GET_HASH_CODE_SCORE ](item.ext.user.id);
                 }
-                else if (item.tags && item.tags[keys.operationId]) {
-                    score = hashCodeGenerator.getHashCodeScore(item.tags[keys.operationId]);
+                else if (item[_DYN_TAGS ] && item[_DYN_TAGS ][keys.operationId]) {
+                    score = hashCodeGenerator.getHashCodeScore(item[_DYN_TAGS ][keys.operationId]);
                 }
-                else if (item.ext && item.ext.telemetryTrace && item.ext.telemetryTrace.traceID) {
-                    score = hashCodeGenerator.getHashCodeScore(item.ext.telemetryTrace.traceID);
+                else if (item.ext && item.ext.telemetryTrace && item.ext.telemetryTrace[_DYN_TRACE_ID ]) {
+                    score = hashCodeGenerator.getHashCodeScore(item.ext.telemetryTrace[_DYN_TRACE_ID ]);
                 }
                 else {
                     score = (Math.random() * 100);
@@ -3834,19 +4011,19 @@
                 _logger.throwInternal(2 , 58 , "Sampling rate is out of range (0..100). Sampling will be disabled, you may be sending too much data which may affect your AI service level.", { samplingRate: sampleRate }, true);
                 sampleRate = 100;
             }
-            this.sampleRate = sampleRate;
+            this[_DYN_SAMPLE_RATE ] = sampleRate;
             this.samplingScoreGenerator = new SamplingScoreGenerator();
         }
         Sample.prototype.isSampledIn = function (envelope) {
-            var samplingPercentage = this.sampleRate;
+            var samplingPercentage = this[_DYN_SAMPLE_RATE ];
             var isSampledIn = false;
             if (samplingPercentage === null || samplingPercentage === undefined || samplingPercentage >= 100) {
                 return true;
             }
-            else if (envelope.baseType === Metric.dataType) {
+            else if (envelope.baseType === Metric[_DYN_DATA_TYPE ]) {
                 return true;
             }
-            isSampledIn = this.samplingScoreGenerator.getSamplingScore(envelope) < samplingPercentage;
+            isSampledIn = this.samplingScoreGenerator[_DYN_GET_SAMPLING_SCORE ](envelope) < samplingPercentage;
             return isSampledIn;
         };
         return Sample;
@@ -3863,25 +4040,29 @@
         return null;
     }
     function _getDefaultAppInsightsChannelConfig() {
-        return {
-            endpointUrl: function () { return "https://dc.services.visualstudio.com/v2/track"; },
-            emitLineDelimitedJson: function () { return false; },
-            maxBatchInterval: function () { return 15000; },
-            maxBatchSizeInBytes: function () { return 102400; },
-            disableTelemetry: function () { return false; },
-            enableSessionStorageBuffer: function () { return true; },
-            isRetryDisabled: function () { return false; },
-            isBeaconApiDisabled: function () { return true; },
-            disableXhr: function () { return false; },
-            onunloadDisableFetch: function () { return false; },
-            onunloadDisableBeacon: function () { return false; },
-            instrumentationKey: function () { return undefined; },
-            namePrefix: function () { return undefined; },
-            samplingPercentage: function () { return 100; },
-            customHeaders: function () { return undefined; },
-            convertUndefined: function () { return undefined; },
-            eventsLimitInMem: function () { return 10000; }
-        };
+        var _a;
+        var defaultValue;
+        var defaultCustomHeaders;
+        return _a = {
+                endpointUrl: function () { return DEFAULT_BREEZE_ENDPOINT + DEFAULT_BREEZE_PATH; }
+            },
+            _a[_DYN_EMIT_LINE_DELIMITED_0 ] = function () { return false; },
+            _a[_DYN_MAX_BATCH_INTERVAL ] = function () { return 15000; },
+            _a[_DYN_MAX_BATCH_SIZE_IN_BY1 ] = function () { return 102400; },
+            _a[_DYN_DISABLE_TELEMETRY ] = function () { return false; },
+            _a[_DYN_ENABLE_SESSION_STORA4 ] = function () { return true; },
+            _a[_DYN_IS_RETRY_DISABLED ] = function () { return false; },
+            _a[_DYN_IS_BEACON_API_DISABL3 ] = function () { return true; },
+            _a[_DYN_DISABLE_XHR ] = function () { return false; },
+            _a[_DYN_ONUNLOAD_DISABLE_FET5 ] = function () { return false; },
+            _a[_DYN_ONUNLOAD_DISABLE_BEA2 ] = function () { return false; },
+            _a[_DYN_INSTRUMENTATION_KEY ] = function () { return defaultValue; },
+            _a[_DYN_NAME_PREFIX ] = function () { return defaultValue; },
+            _a[_DYN_SAMPLING_PERCENTAGE ] = function () { return 100; },
+            _a[_DYN_CUSTOM_HEADERS ] = function () { return defaultCustomHeaders; },
+            _a[_DYN_CONVERT_UNDEFINED ] = function () { return defaultValue; },
+            _a.eventsLimitInMem = function () { return 10000; },
+            _a;
     }
     var EnvelopeTypeCreator = (_a = {},
         _a[Event.dataType] = EventEnvelopeCreator,
@@ -3922,8 +4103,8 @@
                     if (_paused) {
                         _paused = false;
                         _retryAt = null;
-                        if (_self._buffer.size() > _self._senderConfig.maxBatchSizeInBytes()) {
-                            _self.triggerSend(true, null, 10 );
+                        if (_self._buffer.size() > _self._senderConfig[_DYN_MAX_BATCH_SIZE_IN_BY1 ]()) {
+                            _self[_DYN_TRIGGER_SEND ](true, null, 10 );
                         }
                         _setupTimer();
                     }
@@ -3933,21 +4114,21 @@
                     if (!_paused) {
                         _clearScheduledTimer();
                         try {
-                            _self.triggerSend(isAsync, null, sendReason || 1 );
+                            _self[_DYN_TRIGGER_SEND ](isAsync, null, sendReason || 1 );
                         }
                         catch (e) {
-                            _throwInternal(_self.diagLog(), 1 , 22 , "flush failed, telemetry will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
+                            _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 22 , "flush failed, telemetry will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
                         }
                     }
                 };
                 _self.onunloadFlush = function () {
                     if (!_paused) {
-                        if ((_self._senderConfig.onunloadDisableBeacon() === false || _self._senderConfig.isBeaconApiDisabled() === false) && isBeaconsSupported()) {
+                        if ((_self._senderConfig[_DYN_ONUNLOAD_DISABLE_BEA2 ]() === false || _self[_DYN__SENDER_CONFIG ][_DYN_IS_BEACON_API_DISABL3 ]() === false) && isBeaconsSupported()) {
                             try {
-                                _self.triggerSend(true, _doUnloadSend, 2 );
+                                _self[_DYN_TRIGGER_SEND ](true, _doUnloadSend, 2 );
                             }
                             catch (e) {
-                                _throwInternal(_self.diagLog(), 1 , 20 , "failed to flush with beacon sender on page unload, telemetry will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
+                                _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 20 , "failed to flush with beacon sender on page unload, telemetry will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
                             }
                         }
                         else {
@@ -3960,7 +4141,7 @@
                 };
                 _self.initialize = function (config, core, extensions, pluginChain) {
                     if (_self.isInitialized()) {
-                        _throwInternal(_self.diagLog(), 1 , 28 , "Sender is already initialized");
+                        _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 28 , "Sender is already initialized");
                     }
                     _base.initialize(config, core, extensions, pluginChain);
                     var ctx = _self._getTelCtx();
@@ -3969,52 +4150,52 @@
                     _consecutiveErrors = 0;
                     _retryAt = null;
                     _lastSend = 0;
-                    _self._sender = null;
+                    _self[_DYN__SENDER ] = null;
                     _stamp_specific_redirects = 0;
-                    var diagLog = _self.diagLog();
+                    var diagLog = _self[_DYN_DIAG_LOG ]();
                     _evtNamespace = mergeEvtNamespace(createUniqueNamespace("Sender"), core.evtNamespace && core.evtNamespace());
                     _offlineListener = createOfflineListener(_evtNamespace);
                     var defaultConfig = _getDefaultAppInsightsChannelConfig();
                     objForEachKey(defaultConfig, function (field, value) {
-                        _self._senderConfig[field] = function () { return ctx.getConfig(identifier, field, value()); };
+                        _self[_DYN__SENDER_CONFIG ][field] = function () { return ctx.getConfig(identifier, field, value()); };
                     });
-                    _self._buffer = (_self._senderConfig.enableSessionStorageBuffer() && utlCanUseSessionStorage())
-                        ? new SessionStorageSendBuffer(diagLog, _self._senderConfig) : new ArraySendBuffer(diagLog, _self._senderConfig);
-                    _self._sample = new Sample(_self._senderConfig.samplingPercentage(), diagLog);
+                    _self._buffer = (_self[_DYN__SENDER_CONFIG ][_DYN_ENABLE_SESSION_STORA4 ]() && utlCanUseSessionStorage())
+                        ? new SessionStorageSendBuffer(diagLog, _self[_DYN__SENDER_CONFIG ]) : new ArraySendBuffer(diagLog, _self[_DYN__SENDER_CONFIG ]);
+                    _self._sample = new Sample(_self[_DYN__SENDER_CONFIG ][_DYN_SAMPLING_PERCENTAGE ](), diagLog);
                     if (!_validateInstrumentationKey(config)) {
-                        _throwInternal(diagLog, 1 , 100 , "Invalid Instrumentation key " + config.instrumentationKey);
+                        _throwInternal(diagLog, 1 , 100 , "Invalid Instrumentation key " + config[_DYN_INSTRUMENTATION_KEY ]);
                     }
-                    if (!isInternalApplicationInsightsEndpoint(_self._senderConfig.endpointUrl()) && _self._senderConfig.customHeaders() && _self._senderConfig.customHeaders().length > 0) {
-                        arrForEach(_self._senderConfig.customHeaders(), function (customHeader) {
+                    if (!isInternalApplicationInsightsEndpoint(_self._senderConfig.endpointUrl()) && _self._senderConfig.customHeaders() && _self._senderConfig.customHeaders()[_DYN_LENGTH ] > 0) {
+                        arrForEach(_self[_DYN__SENDER_CONFIG ][_DYN_CUSTOM_HEADERS ](), function (customHeader) {
                             _this.addHeader(customHeader.header, customHeader.value);
                         });
                     }
-                    var senderConfig = _self._senderConfig;
+                    var senderConfig = _self[_DYN__SENDER_CONFIG ];
                     var sendPostFunc = null;
-                    if (!senderConfig.disableXhr() && useXDomainRequest()) {
+                    if (!senderConfig[_DYN_DISABLE_XHR ]() && useXDomainRequest()) {
                         sendPostFunc = _xdrSender;
                     }
-                    else if (!senderConfig.disableXhr() && isXhrSupported()) {
+                    else if (!senderConfig[_DYN_DISABLE_XHR ]() && isXhrSupported()) {
                         sendPostFunc = _xhrSender;
                     }
                     if (!sendPostFunc && isFetchSupported()) {
                         sendPostFunc = _fetchSender;
                     }
                     _fallbackSender = sendPostFunc || _xhrSender;
-                    if (!senderConfig.isBeaconApiDisabled() && isBeaconsSupported()) {
+                    if (!senderConfig[_DYN_IS_BEACON_API_DISABL3 ]() && isBeaconsSupported()) {
                         sendPostFunc = _beaconSender;
                     }
-                    _self._sender = sendPostFunc || _xhrSender;
-                    if (!senderConfig.onunloadDisableFetch() && isFetchSupported(true)) {
+                    _self[_DYN__SENDER ] = sendPostFunc || _xhrSender;
+                    if (!senderConfig[_DYN_ONUNLOAD_DISABLE_FET5 ]() && isFetchSupported(true)) {
                         _syncUnloadSender = _fetchKeepAliveSender;
                     }
                     else if (isBeaconsSupported()) {
                         _syncUnloadSender = _beaconSender;
                     }
-                    else if (!senderConfig.disableXhr() && useXDomainRequest()) {
+                    else if (!senderConfig[_DYN_DISABLE_XHR ]() && useXDomainRequest()) {
                         _syncUnloadSender = _xdrSender;
                     }
-                    else if (!senderConfig.disableXhr() && isXhrSupported()) {
+                    else if (!senderConfig[_DYN_DISABLE_XHR ]() && isXhrSupported()) {
                         _syncUnloadSender = _xhrSender;
                     }
                     else {
@@ -4023,103 +4204,104 @@
                 };
                 _self.processTelemetry = function (telemetryItem, itemCtx) {
                     itemCtx = _self._getTelCtx(itemCtx);
+                    var diagLogger = itemCtx[_DYN_DIAG_LOG ]();
                     try {
-                        if (_self._senderConfig.disableTelemetry()) {
+                        if (_self[_DYN__SENDER_CONFIG ][_DYN_DISABLE_TELEMETRY ]()) {
                             return;
                         }
                         if (!telemetryItem) {
-                            _throwInternal(itemCtx.diagLog(), 1 , 7 , "Cannot send empty telemetry");
+                            _throwInternal(diagLogger, 1 , 7 , "Cannot send empty telemetry");
                             return;
                         }
-                        if (telemetryItem.baseData && !telemetryItem.baseType) {
-                            _throwInternal(itemCtx.diagLog(), 1 , 70 , "Cannot send telemetry without baseData and baseType");
+                        if (telemetryItem.baseData && !telemetryItem[_DYN_BASE_TYPE ]) {
+                            _throwInternal(diagLogger, 1 , 70 , "Cannot send telemetry without baseData and baseType");
                             return;
                         }
-                        if (!telemetryItem.baseType) {
-                            telemetryItem.baseType = "EventData";
+                        if (!telemetryItem[_DYN_BASE_TYPE ]) {
+                            telemetryItem[_DYN_BASE_TYPE ] = "EventData";
                         }
-                        if (!_self._sender) {
-                            _throwInternal(itemCtx.diagLog(), 1 , 28 , "Sender was not initialized");
+                        if (!_self[_DYN__SENDER ]) {
+                            _throwInternal(diagLogger, 1 , 28 , "Sender was not initialized");
                             return;
                         }
                         if (!_isSampledIn(telemetryItem)) {
-                            _throwInternal(itemCtx.diagLog(), 2 , 33 , "Telemetry item was sampled out and not sent", { SampleRate: _self._sample.sampleRate });
+                            _throwInternal(diagLogger, 2 , 33 , "Telemetry item was sampled out and not sent", { SampleRate: _self._sample[_DYN_SAMPLE_RATE ] });
                             return;
                         }
                         else {
-                            telemetryItem[SampleRate] = _self._sample.sampleRate;
+                            telemetryItem[SampleRate] = _self._sample[_DYN_SAMPLE_RATE ];
                         }
-                        var convertUndefined = _self._senderConfig.convertUndefined() || undefined;
-                        var defaultEnvelopeIkey = telemetryItem.iKey || _self._senderConfig.instrumentationKey();
-                        var aiEnvelope_1 = Sender.constructEnvelope(telemetryItem, defaultEnvelopeIkey, itemCtx.diagLog(), convertUndefined);
+                        var convertUndefined = _self[_DYN__SENDER_CONFIG ][_DYN_CONVERT_UNDEFINED ]() || undefined;
+                        var defaultEnvelopeIkey = telemetryItem.iKey || _self[_DYN__SENDER_CONFIG ][_DYN_INSTRUMENTATION_KEY ]();
+                        var aiEnvelope_1 = Sender.constructEnvelope(telemetryItem, defaultEnvelopeIkey, diagLogger, convertUndefined);
                         if (!aiEnvelope_1) {
-                            _throwInternal(itemCtx.diagLog(), 1 , 47 , "Unable to create an AppInsights envelope");
+                            _throwInternal(diagLogger, 1 , 47 , "Unable to create an AppInsights envelope");
                             return;
                         }
                         var doNotSendItem_1 = false;
-                        if (telemetryItem.tags && telemetryItem.tags[ProcessLegacy]) {
-                            arrForEach(telemetryItem.tags[ProcessLegacy], function (callBack) {
+                        if (telemetryItem[_DYN_TAGS ] && telemetryItem[_DYN_TAGS ][ProcessLegacy]) {
+                            arrForEach(telemetryItem[_DYN_TAGS ][ProcessLegacy], function (callBack) {
                                 try {
                                     if (callBack && callBack(aiEnvelope_1) === false) {
                                         doNotSendItem_1 = true;
-                                        _warnToConsole(itemCtx.diagLog(), "Telemetry processor check returns false");
+                                        _warnToConsole(diagLogger, "Telemetry processor check returns false");
                                     }
                                 }
                                 catch (e) {
-                                    _throwInternal(itemCtx.diagLog(), 1 , 64 , "One of telemetry initializers failed, telemetry item will not be sent: " + getExceptionName(e), { exception: dumpObj(e) }, true);
+                                    _throwInternal(diagLogger, 1 , 64 , "One of telemetry initializers failed, telemetry item will not be sent: " + getExceptionName(e), { exception: dumpObj(e) }, true);
                                 }
                             });
-                            delete telemetryItem.tags[ProcessLegacy];
+                            delete telemetryItem[_DYN_TAGS ][ProcessLegacy];
                         }
                         if (doNotSendItem_1) {
                             return;
                         }
                         var payload = _serializer.serialize(aiEnvelope_1);
-                        var buffer = _self._buffer;
+                        var buffer = _self[_DYN__BUFFER ];
                         var bufferSize = buffer.size();
-                        if ((bufferSize + payload.length) > _self._senderConfig.maxBatchSizeInBytes()) {
-                            _self.triggerSend(true, null, 10 );
+                        if ((bufferSize + payload[_DYN_LENGTH ]) > _self[_DYN__SENDER_CONFIG ][_DYN_MAX_BATCH_SIZE_IN_BY1 ]()) {
+                            _self[_DYN_TRIGGER_SEND ](true, null, 10 );
                         }
-                        buffer.enqueue(payload);
+                        buffer[_DYN_ENQUEUE ](payload);
                         _setupTimer();
                     }
                     catch (e) {
-                        _throwInternal(itemCtx.diagLog(), 2 , 12 , "Failed adding telemetry to the sender's buffer, some telemetry will be lost: " + getExceptionName(e), { exception: dumpObj(e) });
+                        _throwInternal(diagLogger, 2 , 12 , "Failed adding telemetry to the sender's buffer, some telemetry will be lost: " + getExceptionName(e), { exception: dumpObj(e) });
                     }
                     _self.processNext(telemetryItem, itemCtx);
                 };
-                _self._xhrReadyStateChange = function (xhr, payload, countOfItemsInPayload) {
+                _self[_DYN__XHR_READY_STATE_CHA6 ] = function (xhr, payload, countOfItemsInPayload) {
                     if (xhr.readyState === 4) {
                         _checkResponsStatus(xhr.status, payload, xhr.responseURL, countOfItemsInPayload, _formatErrorMessageXhr(xhr), _getResponseText(xhr) || xhr.response);
                     }
                 };
-                _self.triggerSend = function (async, forcedSender, sendReason) {
+                _self[_DYN_TRIGGER_SEND ] = function (async, forcedSender, sendReason) {
                     if (async === void 0) { async = true; }
                     if (!_paused) {
                         try {
-                            var buffer = _self._buffer;
-                            if (!_self._senderConfig.disableTelemetry()) {
-                                if (buffer.count() > 0) {
+                            var buffer = _self[_DYN__BUFFER ];
+                            if (!_self[_DYN__SENDER_CONFIG ][_DYN_DISABLE_TELEMETRY ]()) {
+                                if (buffer[_DYN_COUNT ]() > 0) {
                                     var payload = buffer.getItems();
                                     _notifySendRequest(sendReason || 0 , async);
                                     if (forcedSender) {
                                         forcedSender.call(_this, payload, async);
                                     }
                                     else {
-                                        _self._sender(payload, async);
+                                        _self[_DYN__SENDER ](payload, async);
                                     }
                                 }
                                 _lastSend = +new Date;
                             }
                             else {
-                                buffer.clear();
+                                buffer[_DYN_CLEAR ]();
                             }
                             _clearScheduledTimer();
                         }
                         catch (e) {
                             var ieVer = getIEVersion();
                             if (!ieVer || ieVer > 9) {
-                                _throwInternal(_self.diagLog(), 1 , 40 , "Telemetry transmission failed, some telemetry will be lost: " + getExceptionName(e), { exception: dumpObj(e) });
+                                _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 40 , "Telemetry transmission failed, some telemetry will be lost: " + getExceptionName(e), { exception: dumpObj(e) });
                             }
                         }
                     }
@@ -4129,11 +4311,11 @@
                     _offlineListener.unload();
                     _initDefaults();
                 };
-                _self._onError = function (payload, message, event) {
-                    _throwInternal(_self.diagLog(), 2 , 26 , "Failed to send telemetry.", { message: message });
-                    _self._buffer.clearSent(payload);
+                _self[_DYN__ON_ERROR ] = function (payload, message, event) {
+                    _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 26 , "Failed to send telemetry.", { message: message });
+                    _self._buffer[_DYN_CLEAR_SENT ](payload);
                 };
-                _self._onPartialSuccess = function (payload, results) {
+                _self[_DYN__ON_PARTIAL_SUCCESS ] = function (payload, results) {
                     var failed = [];
                     var retry = [];
                     var errors = results.errors.reverse();
@@ -4141,42 +4323,42 @@
                         var error = errors_1[_i];
                         var extracted = payload.splice(error.index, 1)[0];
                         if (_isRetriable(error.statusCode)) {
-                            retry.push(extracted);
+                            retry[_DYN_PUSH ](extracted);
                         }
                         else {
-                            failed.push(extracted);
+                            failed[_DYN_PUSH ](extracted);
                         }
                     }
-                    if (payload.length > 0) {
-                        _self._onSuccess(payload, results.itemsAccepted);
+                    if (payload[_DYN_LENGTH ] > 0) {
+                        _self[_DYN__ON_SUCCESS ](payload, results[_DYN_ITEMS_ACCEPTED ]);
                     }
-                    if (failed.length > 0) {
-                        _self._onError(failed, _formatErrorMessageXhr(null, ["partial success", results.itemsAccepted, "of", results.itemsReceived].join(" ")));
+                    if (failed[_DYN_LENGTH ] > 0) {
+                        _self[_DYN__ON_ERROR ](failed, _formatErrorMessageXhr(null, ["partial success", results[_DYN_ITEMS_ACCEPTED ], "of", results.itemsReceived].join(" ")));
                     }
-                    if (retry.length > 0) {
+                    if (retry[_DYN_LENGTH ] > 0) {
                         _resendPayload(retry);
-                        _throwInternal(_self.diagLog(), 2 , 40 , "Partial success. " +
-                            "Delivered: " + payload.length + ", Failed: " + failed.length +
-                            ". Will retry to send " + retry.length + " our of " + results.itemsReceived + " items");
+                        _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , "Partial success. " +
+                            "Delivered: " + payload[_DYN_LENGTH ] + ", Failed: " + failed[_DYN_LENGTH ] +
+                            ". Will retry to send " + retry[_DYN_LENGTH ] + " our of " + results[_DYN_ITEMS_RECEIVED ] + " items");
                     }
                 };
-                _self._onSuccess = function (payload, countOfItemsInPayload) {
-                    _self._buffer.clearSent(payload);
+                _self[_DYN__ON_SUCCESS ] = function (payload, countOfItemsInPayload) {
+                    _self._buffer[_DYN_CLEAR_SENT ](payload);
                 };
                 _self._xdrOnLoad = function (xdr, payload) {
                     var responseText = _getResponseText(xdr);
                     if (xdr && (responseText + "" === "200" || responseText === "")) {
                         _consecutiveErrors = 0;
-                        _self._onSuccess(payload, 0);
+                        _self[_DYN__ON_SUCCESS ](payload, 0);
                     }
                     else {
                         var results = _parseResponse(responseText);
-                        if (results && results.itemsReceived && results.itemsReceived > results.itemsAccepted
-                            && !_self._senderConfig.isRetryDisabled()) {
-                            _self._onPartialSuccess(payload, results);
+                        if (results && results.itemsReceived && results.itemsReceived > results[_DYN_ITEMS_ACCEPTED ]
+                            && !_self[_DYN__SENDER_CONFIG ][_DYN_IS_RETRY_DISABLED ]()) {
+                            _self[_DYN__ON_PARTIAL_SUCCESS ](payload, results);
                         }
                         else {
-                            _self._onError(payload, _formatErrorMessageXdr(xdr));
+                            _self[_DYN__ON_ERROR ](payload, _formatErrorMessageXdr(xdr));
                         }
                     }
                 };
@@ -4194,24 +4376,24 @@
                     if ((status < 200 || status >= 300) && status !== 0) {
                         if (status === 301 || status === 307 || status === 308) {
                             if (!_checkAndUpdateEndPointUrl(responseUrl)) {
-                                _self._onError(payload, errorMessage);
+                                _self[_DYN__ON_ERROR ](payload, errorMessage);
                                 return;
                             }
                         }
-                        if (!_self._senderConfig.isRetryDisabled() && _isRetriable(status)) {
+                        if (!_self[_DYN__SENDER_CONFIG ][_DYN_IS_RETRY_DISABLED ]() && _isRetriable(status)) {
                             _resendPayload(payload);
-                            _throwInternal(_self.diagLog(), 2 , 40 , ". " +
-                                "Response code " + status + ". Will retry to send " + payload.length + " items.");
+                            _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " +
+                                "Response code " + status + ". Will retry to send " + payload[_DYN_LENGTH ] + " items.");
                         }
                         else {
-                            _self._onError(payload, errorMessage);
+                            _self[_DYN__ON_ERROR ](payload, errorMessage);
                         }
                     }
                     else if (_offlineListener && !_offlineListener.isOnline()) {
-                        if (!_self._senderConfig.isRetryDisabled()) {
+                        if (!_self[_DYN__SENDER_CONFIG ][_DYN_IS_RETRY_DISABLED ]()) {
                             var offlineBackOffMultiplier = 10;
                             _resendPayload(payload, offlineBackOffMultiplier);
-                            _throwInternal(_self.diagLog(), 2 , 40 , ". Offline - Response Code: ".concat(status, ". Offline status: ").concat(!_offlineListener.isOnline(), ". Will retry to send ").concat(payload.length, " items."));
+                            _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". Offline - Response Code: ".concat(status, ". Offline status: ").concat(!_offlineListener.isOnline(), ". Will retry to send ").concat(payload.length, " items."));
                         }
                     }
                     else {
@@ -4220,16 +4402,16 @@
                             if (!response) {
                                 response = _parseResponse(res);
                             }
-                            if (response && !_self._senderConfig.isRetryDisabled()) {
-                                _self._onPartialSuccess(payload, response);
+                            if (response && !_self[_DYN__SENDER_CONFIG ][_DYN_IS_RETRY_DISABLED ]()) {
+                                _self[_DYN__ON_PARTIAL_SUCCESS ](payload, response);
                             }
                             else {
-                                _self._onError(payload, errorMessage);
+                                _self[_DYN__ON_ERROR ](payload, errorMessage);
                             }
                         }
                         else {
                             _consecutiveErrors = 0;
-                            _self._onSuccess(payload, countOfItemsInPayload);
+                            _self[_DYN__ON_SUCCESS ](payload, countOfItemsInPayload);
                         }
                     }
                 }
@@ -4238,8 +4420,8 @@
                         return false;
                     }
                     if (!isNullOrUndefined(responseUrl) && responseUrl !== "") {
-                        if (responseUrl !== _self._senderConfig.endpointUrl()) {
-                            _self._senderConfig.endpointUrl = function () { return responseUrl; };
+                        if (responseUrl !== _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]()) {
+                            _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ] = function () { return responseUrl; };
                             ++_stamp_specific_redirects;
                             return true;
                         }
@@ -4251,76 +4433,76 @@
                         _syncUnloadSender(payload, false);
                     }
                     else {
-                        _beaconSender(payload, isAsync);
+                        _beaconSender(payload);
                     }
                 }
                 function _doBeaconSend(payload) {
                     var nav = getNavigator();
-                    var buffer = _self._buffer;
-                    var url = _self._senderConfig.endpointUrl();
-                    var batch = _self._buffer.batchPayloads(payload);
+                    var buffer = _self[_DYN__BUFFER ];
+                    var url = _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]();
+                    var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
                     var plainTextBatch = new Blob([batch], { type: "text/plain;charset=UTF-8" });
                     var queued = nav.sendBeacon(url, plainTextBatch);
                     if (queued) {
-                        buffer.markAsSent(payload);
-                        _self._onSuccess(payload, payload.length);
+                        buffer[_DYN_MARK_AS_SENT ](payload);
+                        _self._onSuccess(payload, payload[_DYN_LENGTH ]);
                     }
                     return queued;
                 }
                 function _beaconSender(payload, isAsync) {
-                    if (isArray(payload) && payload.length > 0) {
+                    if (isArray(payload) && payload[_DYN_LENGTH ] > 0) {
                         if (!_doBeaconSend(payload)) {
                             var droppedPayload = [];
-                            for (var lp = 0; lp < payload.length; lp++) {
+                            for (var lp = 0; lp < payload[_DYN_LENGTH ]; lp++) {
                                 var thePayload = payload[lp];
                                 if (!_doBeaconSend([thePayload])) {
-                                    droppedPayload.push(thePayload);
+                                    droppedPayload[_DYN_PUSH ](thePayload);
                                 }
                             }
-                            if (droppedPayload.length > 0) {
+                            if (droppedPayload[_DYN_LENGTH ] > 0) {
                                 _fallbackSender && _fallbackSender(droppedPayload, true);
-                                _throwInternal(_self.diagLog(), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
+                                _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with normal sender.");
                             }
                         }
                     }
                 }
                 function _xhrSender(payload, isAsync) {
                     var xhr = new XMLHttpRequest();
-                    var endPointUrl = _self._senderConfig.endpointUrl();
+                    var endPointUrl = _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]();
                     try {
                         xhr[DisabledPropertyName] = true;
                     }
                     catch (e) {
                     }
                     xhr.open("POST", endPointUrl, isAsync);
-                    xhr.setRequestHeader("Content-type", "application/json");
+                    xhr[_DYN_SET_REQUEST_HEADER ]("Content-type", "application/json");
                     if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
-                        xhr.setRequestHeader(RequestHeaders.sdkContextHeader, RequestHeaders.sdkContextHeaderAppIdRequest);
+                        xhr[_DYN_SET_REQUEST_HEADER ](RequestHeaders[6 ], RequestHeaders[7 ]);
                     }
                     arrForEach(objKeys(_headers), function (headerName) {
-                        xhr.setRequestHeader(headerName, _headers[headerName]);
+                        xhr[_DYN_SET_REQUEST_HEADER ](headerName, _headers[headerName]);
                     });
-                    xhr.onreadystatechange = function () { return _self._xhrReadyStateChange(xhr, payload, payload.length); };
-                    xhr.onerror = function (event) { return _self._onError(payload, _formatErrorMessageXhr(xhr), event); };
-                    var batch = _self._buffer.batchPayloads(payload);
+                    xhr.onreadystatechange = function () { return _self._xhrReadyStateChange(xhr, payload, payload[_DYN_LENGTH ]); };
+                    xhr.onerror = function (event) { return _self[_DYN__ON_ERROR ](payload, _formatErrorMessageXhr(xhr), event); };
+                    var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
                     xhr.send(batch);
-                    _self._buffer.markAsSent(payload);
+                    _self._buffer[_DYN_MARK_AS_SENT ](payload);
                 }
                 function _fetchKeepAliveSender(payload, isAsync) {
                     if (isArray(payload)) {
-                        var payloadSize = payload.length;
-                        for (var lp = 0; lp < payload.length; lp++) {
-                            payloadSize += payload[lp].length;
+                        var payloadSize = payload[_DYN_LENGTH ];
+                        for (var lp = 0; lp < payload[_DYN_LENGTH ]; lp++) {
+                            payloadSize += payload[lp][_DYN_LENGTH ];
                         }
                         if ((_syncFetchPayload + payloadSize) <= FetchSyncRequestSizeLimitBytes) {
                             _doFetchSender(payload, false);
                         }
                         else if (isBeaconsSupported()) {
-                            _beaconSender(payload, isAsync);
+                            _beaconSender(payload);
                         }
                         else {
                             _fallbackSender && _fallbackSender(payload, true);
-                            _throwInternal(_self.diagLog(), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with xhrSender.");
+                            _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " + "Failed to send telemetry with Beacon API, retried with xhrSender.");
                         }
                     }
                 }
@@ -4329,15 +4511,15 @@
                 }
                 function _doFetchSender(payload, isAsync) {
                     var _a;
-                    var endPointUrl = _self._senderConfig.endpointUrl();
-                    var batch = _self._buffer.batchPayloads(payload);
+                    var endPointUrl = _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]();
+                    var batch = _self._buffer[_DYN_BATCH_PAYLOADS ](payload);
                     var plainTextBatch = new Blob([batch], { type: "application/json" });
                     var requestHeaders = new Headers();
-                    var batchLength = batch.length;
+                    var batchLength = batch[_DYN_LENGTH ];
                     var ignoreResponse = false;
                     var responseHandled = false;
                     if (isInternalApplicationInsightsEndpoint(endPointUrl)) {
-                        requestHeaders.append(RequestHeaders.sdkContextHeader, RequestHeaders.sdkContextHeaderAppIdRequest);
+                        requestHeaders.append(RequestHeaders[6 ], RequestHeaders[7 ]);
                     }
                     arrForEach(objKeys(_headers), function (headerName) {
                         requestHeaders.append(headerName, _headers[headerName]);
@@ -4361,7 +4543,7 @@
                     }
                     catch (e) {
                     }
-                    _self._buffer.markAsSent(payload);
+                    _self._buffer[_DYN_MARK_AS_SENT ](payload);
                     try {
                         fetch(request).then(function (response) {
                             if (!isAsync) {
@@ -4371,11 +4553,11 @@
                             if (!responseHandled) {
                                 responseHandled = true;
                                 if (!response.ok) {
-                                    _self._onError(payload, response.statusText);
+                                    _self[_DYN__ON_ERROR ](payload, response.statusText);
                                 }
                                 else {
                                     response.text().then(function (text) {
-                                        _checkResponsStatus(response.status, payload, response.url, payload.length, response.statusText, text);
+                                        _checkResponsStatus(response.status, payload, response.url, payload[_DYN_LENGTH ], response.statusText, text);
                                     });
                                 }
                             }
@@ -4386,32 +4568,32 @@
                             }
                             if (!responseHandled) {
                                 responseHandled = true;
-                                _self._onError(payload, error.message);
+                                _self[_DYN__ON_ERROR ](payload, error.message);
                             }
                         });
                     }
                     catch (e) {
                         if (!responseHandled) {
-                            _self._onError(payload, dumpObj(e));
+                            _self[_DYN__ON_ERROR ](payload, dumpObj(e));
                         }
                     }
                     if (ignoreResponse && !responseHandled) {
                         responseHandled = true;
-                        _self._onSuccess(payload, payload.length);
+                        _self._onSuccess(payload, payload[_DYN_LENGTH ]);
                     }
                 }
                 function _parseResponse(response) {
                     try {
                         if (response && response !== "") {
                             var result = getJSON().parse(response);
-                            if (result && result.itemsReceived && result.itemsReceived >= result.itemsAccepted &&
-                                result.itemsReceived - result.itemsAccepted === result.errors.length) {
+                            if (result && result.itemsReceived && result.itemsReceived >= result[_DYN_ITEMS_ACCEPTED ] &&
+                                result.itemsReceived - result.itemsAccepted === result.errors[_DYN_LENGTH ]) {
                                 return result;
                             }
                         }
                     }
                     catch (e) {
-                        _throwInternal(_self.diagLog(), 1 , 43 , "Cannot parse the response. " + getExceptionName(e), {
+                        _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 43 , "Cannot parse the response. " + getExceptionName(e), {
                             response: response
                         });
                     }
@@ -4419,15 +4601,15 @@
                 }
                 function _resendPayload(payload, linearFactor) {
                     if (linearFactor === void 0) { linearFactor = 1; }
-                    if (!payload || payload.length === 0) {
+                    if (!payload || payload[_DYN_LENGTH ] === 0) {
                         return;
                     }
-                    var buffer = _self._buffer;
-                    buffer.clearSent(payload);
+                    var buffer = _self[_DYN__BUFFER ];
+                    buffer[_DYN_CLEAR_SENT ](payload);
                     _consecutiveErrors++;
                     for (var _i = 0, payload_1 = payload; _i < payload_1.length; _i++) {
                         var item = payload_1[_i];
-                        buffer.enqueue(item);
+                        buffer[_DYN_ENQUEUE ](item);
                     }
                     _setRetryTime(linearFactor);
                     _setupTimer();
@@ -4450,10 +4632,10 @@
                 function _setupTimer() {
                     if (!_timeoutHandle && !_paused) {
                         var retryInterval = _retryAt ? Math.max(0, _retryAt - dateNow()) : 0;
-                        var timerValue = Math.max(_self._senderConfig.maxBatchInterval(), retryInterval);
+                        var timerValue = Math.max(_self[_DYN__SENDER_CONFIG ][_DYN_MAX_BATCH_INTERVAL ](), retryInterval);
                         _timeoutHandle = setTimeout(function () {
                             _timeoutHandle = null;
-                            _self.triggerSend(true, null, 1 );
+                            _self[_DYN_TRIGGER_SEND ](true, null, 1 );
                         }, timerValue);
                     }
                 }
@@ -4475,23 +4657,23 @@
                     return message;
                 }
                 function _xdrSender(payload, isAsync) {
-                    var buffer = _self._buffer;
+                    var buffer = _self[_DYN__BUFFER ];
                     var _window = getWindow();
                     var xdr = new XDomainRequest();
                     xdr.onload = function () { return _self._xdrOnLoad(xdr, payload); };
-                    xdr.onerror = function (event) { return _self._onError(payload, _formatErrorMessageXdr(xdr), event); };
+                    xdr.onerror = function (event) { return _self[_DYN__ON_ERROR ](payload, _formatErrorMessageXdr(xdr), event); };
                     var hostingProtocol = _window && _window.location && _window.location.protocol || "";
-                    if (_self._senderConfig.endpointUrl().lastIndexOf(hostingProtocol, 0) !== 0) {
-                        _throwInternal(_self.diagLog(), 2 , 40 , ". " +
+                    if (_self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]().lastIndexOf(hostingProtocol, 0) !== 0) {
+                        _throwInternal(_self[_DYN_DIAG_LOG ](), 2 , 40 , ". " +
                             "Cannot send XDomain request. The endpoint URL protocol doesn't match the hosting page protocol.");
-                        buffer.clear();
+                        buffer[_DYN_CLEAR ]();
                         return;
                     }
-                    var endpointUrl = _self._senderConfig.endpointUrl().replace(/^(https?:)/, "");
+                    var endpointUrl = _self[_DYN__SENDER_CONFIG ][_DYN_ENDPOINT_URL ]().replace(/^(https?:)/, "");
                     xdr.open("POST", endpointUrl);
-                    var batch = buffer.batchPayloads(payload);
+                    var batch = buffer[_DYN_BATCH_PAYLOADS ](payload);
                     xdr.send(batch);
-                    buffer.markAsSent(payload);
+                    buffer[_DYN_MARK_AS_SENT ](payload);
                 }
                 function _formatErrorMessageXdr(xdr, message) {
                     if (xdr) {
@@ -4508,27 +4690,27 @@
                 }
                 function _notifySendRequest(sendRequest, isAsync) {
                     var manager = _getNotifyMgr();
-                    if (manager && manager.eventsSendRequest) {
+                    if (manager && manager[_DYN_EVENTS_SEND_REQUEST ]) {
                         try {
-                            manager.eventsSendRequest(sendRequest, isAsync);
+                            manager[_DYN_EVENTS_SEND_REQUEST ](sendRequest, isAsync);
                         }
                         catch (e) {
-                            _throwInternal(_self.diagLog(), 1 , 74 , "send request notification failed: " + getExceptionName(e), { exception: dumpObj(e) });
+                            _throwInternal(_self[_DYN_DIAG_LOG ](), 1 , 74 , "send request notification failed: " + getExceptionName(e), { exception: dumpObj(e) });
                         }
                     }
                 }
                 function _validateInstrumentationKey(config) {
-                    var disableIKeyValidationFlag = isNullOrUndefined(config.disableInstrumentationKeyValidation) ? false : config.disableInstrumentationKeyValidation;
+                    var disableIKeyValidationFlag = isNullOrUndefined(config[_DYN_DISABLE_INSTRUMENTAT7 ]) ? false : config[_DYN_DISABLE_INSTRUMENTAT7 ];
                     if (disableIKeyValidationFlag) {
                         return true;
                     }
                     var UUID_Regex = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
                     var regexp = new RegExp(UUID_Regex);
-                    return regexp.test(config.instrumentationKey);
+                    return regexp.test(config[_DYN_INSTRUMENTATION_KEY ]);
                 }
                 function _initDefaults() {
-                    _self._sender = null;
-                    _self._buffer = null;
+                    _self[_DYN__SENDER ] = null;
+                    _self[_DYN__BUFFER ] = null;
                     _self._appId = null;
                     _self._sample = null;
                     _headers = {};