@microsoft/1ds-post-js 3.2.2 → 3.2.5

package/bundle/{ms.post-3.2.2.gbl.js → ms.post-3.2.5.gbl.js}

@@ -1,5 +1,5 @@
 /*!
- * 1DS JS SDK POST plugin, 3.2.2
+ * 1DS JS SDK POST plugin, 3.2.5
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -328,14 +328,55 @@
     };
     dynamicProto[DynProtoDefaultOptions] = perfDefaults;
 
-    var strEmpty = "";
-    var strSetNextPlugin = "setNextPlugin";
-    var strIsInitialized = "isInitialized";
-    var strTeardown = "teardown";
-    var strCore = "core";
-    var strUpdate = "update";
-    var strDisabled = "disabled";
-    var strDoTeardown = "_doTeardown";
+    var _DYN_INITIALIZE = "initialize";
+    var _DYN_NAME = "name";
+    var _DYN_IDENTIFIER = "identifier";
+    var _DYN_PUSH = "push";
+    var _DYN_IS_INITIALIZED = "isInitialized";
+    var _DYN_CONFIG = "config";
+    var _DYN_LOGGER = "logger";
+    var _DYN_LENGTH = "length";
+    var _DYN_TIME = "time";
+    var _DYN_PROCESS_NEXT = "processNext";
+    var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
+    var _DYN_GET_PLUGIN = "getPlugin";
+    var _DYN_SPLICE = "splice";
+    var _DYN_TEARDOWN = "teardown";
+    var _DYN_MESSAGE_ID = "messageId";
+    var _DYN_MESSAGE = "message";
+    var _DYN_IS_ASYNC = "isAsync";
+    var _DYN__DO_TEARDOWN = "_doTeardown";
+    var _DYN_UPDATE = "update";
+    var _DYN_GET_NEXT = "getNext";
+    var _DYN_DIAG_LOG = "diagLog";
+    var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
+    var _DYN_CREATE_NEW = "createNew";
+    var _DYN_INDEX_OF = "indexOf";
+    var _DYN_USER_AGENT = "userAgent";
+    var _DYN_SPLIT = "split";
+    var _DYN_NODE_TYPE = "nodeType";
+    var _DYN_APPLY = "apply";
+    var _DYN_REPLACE = "replace";
+    var _DYN_ENABLE_DEBUG_EXCEPTI4 = "enableDebugExceptions";
+    var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
+    var _DYN_TO_LOWER_CASE = "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$1 = "";
+    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 cStrStartsWith = "startsWith";
     var strIndexOf = "indexOf";
@@ -352,7 +393,7 @@
     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_$])/;
@@ -376,7 +417,7 @@
         return (value === null || isUndefined(value));
     }
     function hasOwnProperty(obj, prop) {
-        return !!(obj && ObjHasOwnProperty.call(obj, prop));
+        return !!(obj && ObjHasOwnProperty[_DYN_CALL ](obj, prop));
     }
     function isObject(value) {
         return !!(value && typeof value === strShimObject);
@@ -387,11 +428,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;
             });
         }
@@ -400,8 +441,8 @@
     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]);
                 }
             }
         }
@@ -415,8 +456,8 @@
     }
     function _strStartsWithPoly(value, checkValue) {
         var result = false;
-        var chkLen = checkValue ? checkValue.length : 0;
-        if (value && chkLen && value.length >= chkLen && !(result = value === checkValue)) {
+        var chkLen = checkValue ? checkValue[_DYN_LENGTH ] : 0;
+        if (value && chkLen && value[_DYN_LENGTH ] >= chkLen && !(result = value === checkValue)) {
             for (var lp = 0; lp < chkLen; lp++) {
                 if (value[lp] !== checkValue[lp]) {
                     return false;
@@ -428,13 +469,13 @@
     }
     function strContains(value, search) {
         if (value && search) {
-            return value.indexOf(search) !== -1;
+            return value[_DYN_INDEX_OF ](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 isString(value) {
         return typeof value === "string";
@@ -453,20 +494,20 @@
                 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;
     }
     function arrForEach(arr, callbackfn, thisArg) {
-        var len = arr.length;
+        var len = arr[_DYN_LENGTH ];
         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;
                     }
                 }
@@ -480,7 +521,7 @@
             if (arr[strIndexOf]) {
                 return arr[strIndexOf](searchElement, fromIndex);
             }
-            var len = arr.length;
+            var len = arr[_DYN_LENGTH ];
             var from = fromIndex || 0;
             try {
                 for (var lp = Math.max(from >= 0 ? from : len - Math.abs(from), 0); lp < len; lp++) {
@@ -496,7 +537,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$1) : str);
         }
         return str;
     }
@@ -520,15 +561,15 @@
         }
         var result = [];
         for (var prop in obj) {
-            if (obj && ObjHasOwnProperty.call(obj, prop)) {
-                result.push(prop);
+            if (obj && ObjHasOwnProperty[_DYN_CALL ](obj, prop)) {
+                result[_DYN_PUSH ](prop);
             }
         }
         if (_objKeysHasDontEnumBug) {
-            var dontEnumsLength = _objKeysDontEnums.length;
+            var dontEnumsLength = _objKeysDontEnums[_DYN_LENGTH ];
             for (var lp = 0; lp < dontEnumsLength; lp++) {
-                if (obj && ObjHasOwnProperty.call(obj, _objKeysDontEnums[lp])) {
-                    result.push(_objKeysDontEnums[lp]);
+                if (obj && ObjHasOwnProperty[_DYN_CALL ](obj, _objKeysDontEnums[lp])) {
+                    result[_DYN_PUSH ](_objKeysDontEnums[lp]);
                 }
             }
         }
@@ -584,6 +625,9 @@
         }
         return theValue;
     }
+    function getCfgValue(theValue, defaultValue) {
+        return !isNullOrUndefined(theValue) ? theValue : defaultValue;
+    }
     function _createProxyFunction(source, funcName) {
         var srcFunc = null;
         var src = null;
@@ -599,7 +643,7 @@
                 src = srcFunc();
             }
             if (src) {
-                return src[funcName].apply(src, originalArguments);
+                return src[funcName][_DYN_APPLY ](src, originalArguments);
             }
         };
     }
@@ -619,7 +663,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 ];
         var deep = false;
         var idx = 1;
         if (argLen > 0 && isBoolean(extended)) {
@@ -635,7 +679,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;
                 }
@@ -804,18 +848,18 @@
     }
     function isIE() {
         var nav = getNavigator();
-        if (nav && (nav.userAgent !== _navUserAgentCheck || _isTrident === null)) {
-            _navUserAgentCheck = nav.userAgent;
-            var userAgent = (_navUserAgentCheck || strEmpty).toLowerCase();
+        if (nav && (nav[_DYN_USER_AGENT ] !== _navUserAgentCheck || _isTrident === null)) {
+            _navUserAgentCheck = nav[_DYN_USER_AGENT ];
+            var userAgent = (_navUserAgentCheck || STR_EMPTY$1)[_DYN_TO_LOWER_CASE ]();
             _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
         }
         return _isTrident;
     }
     function dumpObj(object) {
-        var objectTypeDump = Object[strShimPrototype].toString.call(object);
-        var propertyValueDump = strEmpty;
+        var objectTypeDump = Object[strShimPrototype].toString[_DYN_CALL ](object);
+        var propertyValueDump = STR_EMPTY$1;
         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 ] + "'";
         }
         else if (hasJSON()) {
             propertyValueDump = getJSON().stringify(object);
@@ -880,13 +924,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) + "\"";
+            return "\"" + text[_DYN_REPLACE ](/\"/g, STR_EMPTY$1) + "\"";
         }
-        return strEmpty;
+        return STR_EMPTY$1;
     }
     function _logToConsole(func, message) {
         var theConsole = getConsole();
@@ -904,23 +946,23 @@
         function _InternalLogMessage(msgId, msg, isUserAct, properties) {
             if (isUserAct === void 0) { isUserAct = false; }
             var _self = this;
-            _self.messageId = msgId;
-            _self.message =
+            _self[_DYN_MESSAGE_ID ] = msgId;
+            _self[_DYN_MESSAGE ] =
                 (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
                     msgId;
-            var strProps = strEmpty;
+            var strProps = STR_EMPTY$1;
             if (hasJSON()) {
                 strProps = getJSON().stringify(properties);
             }
-            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : strEmpty) +
-                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : strEmpty);
-            _self.message += diagnosticText;
+            var diagnosticText = (msg ? " message:" + _sanitizeDiagnosticText(msg) : STR_EMPTY$1) +
+                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY$1);
+            _self[_DYN_MESSAGE ] += diagnosticText;
         }
         _InternalLogMessage.dataType = "MessageData";
         return _InternalLogMessage;
     }());
     function safeGetLogger(core, config) {
-        return (core || {}).logger || new DiagnosticLogger(config);
+        return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
     }
     var DiagnosticLogger = /** @class */ (function () {
         function DiagnosticLogger(config) {
@@ -928,48 +970,49 @@
             this.queue = [];
             var _messageCount = 0;
             var _messageLogged = {};
+            var _loggingLevelConsole;
+            var _loggingLevelTelemetry;
+            var _maxInternalMessageLimit;
+            var _enableDebugExceptions;
             dynamicProto(DiagnosticLogger, this, function (_self) {
-                if (isNullOrUndefined(config)) {
-                    config = {};
-                }
-                _self.consoleLoggingLevel = function () { return _getConfigValue("loggingLevelConsole", 0); };
-                _self.telemetryLoggingLevel = function () { return _getConfigValue("loggingLevelTelemetry", 1); };
-                _self.maxInternalMessageLimit = function () { return _getConfigValue("maxMessageLimit", 25); };
-                _self.enableDebugExceptions = function () { return _getConfigValue("enableDebugExceptions", false); };
+                _setDefaultsFromConfig(config || {});
+                _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
+                _self.telemetryLoggingLevel = function () { return _loggingLevelTelemetry; };
+                _self.maxInternalMessageLimit = function () { return _maxInternalMessageLimit; };
+                _self[_DYN_ENABLE_DEBUG_EXCEPTI4 ] = function () { return _enableDebugExceptions; };
                 _self.throwInternal = function (severity, msgId, msg, properties, isUserAct) {
                     if (isUserAct === void 0) { isUserAct = false; }
                     var message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
-                    if (_self.enableDebugExceptions()) {
+                    if (_enableDebugExceptions) {
                         throw dumpObj(message);
                     }
                     else {
-                        var logFunc = severity === 1  ? strErrorToConsole : strWarnToConsole;
-                        if (!isUndefined(message.message)) {
-                            var logLevel = _self.consoleLoggingLevel();
+                        var logFunc = severity === 1  ? STR_ERROR_TO_CONSOLE : STR_WARN_TO_CONSOLE;
+                        if (!isUndefined(message[_DYN_MESSAGE ])) {
                             if (isUserAct) {
-                                var messageKey = +message.messageId;
-                                if (!_messageLogged[messageKey] && logLevel >= severity) {
-                                    _self[logFunc](message.message);
+                                var messageKey = +message[_DYN_MESSAGE_ID ];
+                                if (!_messageLogged[messageKey] && _loggingLevelConsole >= severity) {
+                                    _self[logFunc](message[_DYN_MESSAGE ]);
                                     _messageLogged[messageKey] = true;
                                 }
                             }
                             else {
-                                if (logLevel >= severity) {
-                                    _self[logFunc](message.message);
+                                if (_loggingLevelConsole >= severity) {
+                                    _self[logFunc](message[_DYN_MESSAGE ]);
                                 }
                             }
-                            _self.logInternalMessage(severity, message);
+                            _logInternalMessage(severity, message);
                         }
                         else {
                             _debugExtMsg("throw" + (severity === 1  ? "Critical" : "Warning"), message);
                         }
                     }
                 };
-                _self.warnToConsole = function (message) {
+                _self[STR_WARN_TO_CONSOLE ] = function (message) {
                     _logToConsole("warn", message);
                     _debugExtMsg("warning", message);
                 };
-                _self.errorToConsole = function (message) {
+                _self[STR_ERROR_TO_CONSOLE ] = function (message) {
                     _logToConsole("error", message);
                     _debugExtMsg("error", message);
                 };
@@ -977,12 +1020,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;
                     }
@@ -990,58 +1034,66 @@
                         _messageLogged[messageKey] = true;
                     }
                     if (logMessage) {
-                        if (severity <= _self.telemetryLoggingLevel()) {
-                            _self.queue.push(message);
+                        if (severity <= _loggingLevelTelemetry) {
+                            _self.queue[_DYN_PUSH ](message);
                             _messageCount++;
                             _debugExtMsg((severity === 1  ? "error" : "warn"), message);
                         }
-                        if (_messageCount === _self.maxInternalMessageLimit()) {
+                        if (_messageCount === _maxInternalMessageLimit) {
                             var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
                             var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
-                            _self.queue.push(throttleMessage);
+                            _self.queue[_DYN_PUSH ](throttleMessage);
                             if (severity === 1 ) {
-                                _self.errorToConsole(throttleLimitMessage);
+                                _self[STR_ERROR_TO_CONSOLE ](throttleLimitMessage);
                             }
                             else {
-                                _self.warnToConsole(throttleLimitMessage);
+                                _self[STR_WARN_TO_CONSOLE ](throttleLimitMessage);
                             }
                         }
                     }
-                };
-                function _getConfigValue(name, defValue) {
-                    var value = config[name];
-                    if (!isNullOrUndefined(value)) {
-                        return value;
-                    }
-                    return defValue;
+                }
+                function _setDefaultsFromConfig(config) {
+                    _loggingLevelConsole = getCfgValue(config.loggingLevelConsole, 0);
+                    _loggingLevelTelemetry = getCfgValue(config.loggingLevelTelemetry, 1);
+                    _maxInternalMessageLimit = getCfgValue(config.maxMessageLimit, 25);
+                    _enableDebugExceptions = getCfgValue(config[_DYN_ENABLE_DEBUG_EXCEPTI4 ], false);
                 }
                 function _areInternalMessagesThrottled() {
-                    return _messageCount >= _self.maxInternalMessageLimit();
+                    return _messageCount >= _maxInternalMessageLimit;
                 }
                 function _debugExtMsg(name, data) {
-                    var dbgExt = getDebugExt(config);
-                    if (dbgExt && dbgExt.diagLog) {
-                        dbgExt.diagLog(name, data);
+                    var dbgExt = getDebugExt(config || {});
+                    if (dbgExt && dbgExt[_DYN_DIAG_LOG ]) {
+                        dbgExt[_DYN_DIAG_LOG ](name, data);
                     }
                 }
             });
         }
+        DiagnosticLogger.__ieDyn=1;
         return DiagnosticLogger;
     }());
+    function _getLogger(logger) {
+        return (logger || new DiagnosticLogger());
+    }
     function _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {
         if (isUserAct === void 0) { isUserAct = false; }
-        (logger || new DiagnosticLogger()).throwInternal(severity, msgId, msg, properties, isUserAct);
+        _getLogger(logger).throwInternal(severity, msgId, msg, properties, isUserAct);
+    }
+    function _warnToConsole(logger, 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 ] = 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 () {
@@ -1052,24 +1104,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 {
@@ -1078,20 +1130,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 ]; 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();
                 }
@@ -1105,40 +1157,40 @@
     function doPerf(mgrSource, getSource, func, details, isAsync) {
         if (mgrSource) {
             var perfMgr = mgrSource;
-            if (isFunction(perfMgr["getPerfMgr"])) {
-                perfMgr = perfMgr["getPerfMgr"]();
+            if (perfMgr[STR_GET_PERF_MGR]) {
+                perfMgr = perfMgr[STR_GET_PERF_MGR]();
             }
             if (perfMgr) {
                 var perfEvt = void 0;
-                var currentActive = perfMgr.getCtx(doPerfActiveKey);
+                var currentActive = perfMgr[_DYN_GET_CTX ](doPerfActiveKey);
                 try {
                     perfEvt = perfMgr.create(getSource(), details, isAsync);
                     if (perfEvt) {
-                        if (currentActive && perfEvt.setCtx) {
-                            perfEvt.setCtx(PerfEvent.ParentContextKey, currentActive);
-                            if (currentActive.getCtx && currentActive.setCtx) {
-                                var children = currentActive.getCtx(PerfEvent.ChildrenContextKey);
+                        if (currentActive && perfEvt[_DYN_SET_CTX ]) {
+                            perfEvt[_DYN_SET_CTX ](PerfEvent[strParentContextKey], currentActive);
+                            if (currentActive[_DYN_GET_CTX ] && currentActive[_DYN_SET_CTX ]) {
+                                var children = currentActive[_DYN_GET_CTX ](PerfEvent[strChildrenContextKey]);
                                 if (!children) {
                                     children = [];
-                                    currentActive.setCtx(PerfEvent.ChildrenContextKey, children);
+                                    currentActive[_DYN_SET_CTX ](PerfEvent[strChildrenContextKey], children);
                                 }
-                                children.push(perfEvt);
+                                children[_DYN_PUSH ](perfEvt);
                             }
                         }
-                        perfMgr.setCtx(doPerfActiveKey, perfEvt);
+                        perfMgr[_DYN_SET_CTX ](doPerfActiveKey, perfEvt);
                         return func(perfEvt);
                     }
                 }
                 catch (ex) {
-                    if (perfEvt && perfEvt.setCtx) {
-                        perfEvt.setCtx("exception", ex);
+                    if (perfEvt && perfEvt[_DYN_SET_CTX ]) {
+                        perfEvt[_DYN_SET_CTX ]("exception", ex);
                     }
                 }
                 finally {
                     if (perfEvt) {
                         perfMgr.fire(perfEvt);
                     }
-                    perfMgr.setCtx(doPerfActiveKey, currentActive);
+                    perfMgr[_DYN_SET_CTX ](doPerfActiveKey, currentActive);
                 }
             }
         }
@@ -1200,8 +1252,8 @@
         var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
         var number = random32() >>> 0;
         var chars = 0;
-        var result = strEmpty;
-        while (result.length < maxLength) {
+        var result = STR_EMPTY$1;
+        while (result[_DYN_LENGTH ] < maxLength) {
             chars++;
             result += base64chars.charAt(number & 0x3F);
             number >>>= 6;
@@ -1214,7 +1266,7 @@
     }
 
     var _objDefineProperty = ObjDefineProperty;
-    var version = "2.8.3";
+    var version = '2.8.6';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _createAccessor(target, prop, value) {
@@ -1233,7 +1285,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];
@@ -1253,11 +1305,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$1) + instanceName);
     }
     function createElmNodeData(name) {
         var data = {
-            id: createUniqueNamespace("_aiData-" + (name || "") + "." + version),
+            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY$1) + "." + version),
             accept: function (target) {
                 return _canAcceptData(target);
             },
@@ -1285,214 +1337,505 @@
         return data;
     }
 
-    var pluginStateData = createElmNodeData("plugin");
-    function _getPluginState(plugin) {
-        return pluginStateData.get(plugin, "state", {}, true);
-    }
-
-    var strTelemetryPluginChain = "TelemetryPluginChain";
-    var strHasRunFlags = "_hasRun";
-    var strGetTelCtx = "_getTelCtx";
-    var _chainId = 0;
-    function _getNextProxyStart(proxy, core, startAt) {
-        while (proxy) {
-            if (proxy.getPlugin() === startAt) {
-                return proxy;
-            }
-            proxy = proxy.getNext();
+    var strOnPrefix = "on";
+    var strAttachEvent = "attachEvent";
+    var strAddEventHelper = "addEventListener";
+    var strDetachEvent = "detachEvent";
+    var strRemoveEventListener = "removeEventListener";
+    var strEvents = "events";
+    var strVisibilityChangeEvt = "visibilitychange";
+    var strPageHide = "pagehide";
+    var strPageShow = "pageshow";
+    var strUnload = "unload";
+    var strBeforeUnload = "beforeunload";
+    var strPageHideNamespace = createUniqueNamespace("aiEvtPageHide");
+    var strPageShowNamespace = createUniqueNamespace("aiEvtPageShow");
+    var rRemoveEmptyNs = /\.[\.]+/g;
+    var rRemoveTrailingEmptyNs = /[\.]+$/;
+    var _guid = 1;
+    var elmNodeData = createElmNodeData("events");
+    var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
+    function _normalizeNamespace(name) {
+        if (name && name[_DYN_REPLACE ]) {
+            return name.replace(/^\s*\.*|\.*\s*$/g, STR_EMPTY$1);
         }
-        return createTelemetryProxyChain([startAt], core.config || {}, core);
+        return name;
     }
-    function _createInternalContext(telemetryChain, config, core, startAt) {
-        var _nextProxy = null;
-        var _onComplete = [];
-        if (startAt !== null) {
-            _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
-        }
-        var context = {
-            _next: _moveNext,
-            ctx: {
-                core: function () {
-                    return core;
-                },
-                diagLog: function () {
-                    return safeGetLogger(core, config);
-                },
-                getCfg: function () {
-                    return config;
-                },
-                getExtCfg: _getExtCfg,
-                getConfig: _getConfig,
-                hasNext: function () {
-                    return !!_nextProxy;
-                },
-                getNext: function () {
-                    return _nextProxy;
-                },
-                setNext: function (nextPlugin) {
-                    _nextProxy = nextPlugin;
-                },
-                iterate: _iterateChain,
-                onComplete: _addOnComplete
-            }
-        };
-        function _addOnComplete(onComplete, that) {
-            var args = [];
-            for (var _i = 2; _i < arguments.length; _i++) {
-                args[_i - 2] = arguments[_i];
-            }
-            if (onComplete) {
-                _onComplete.push({
-                    func: onComplete,
-                    self: !isUndefined(that) ? that : context.ctx,
-                    args: args
+    function _getEvtNamespace(eventName, evtNamespace) {
+        var _a;
+        if (evtNamespace) {
+            var theNamespace_1 = STR_EMPTY$1;
+            if (isArray(evtNamespace)) {
+                theNamespace_1 = STR_EMPTY$1;
+                arrForEach(evtNamespace, function (name) {
+                    name = _normalizeNamespace(name);
+                    if (name) {
+                        if (name[0] !== ".") {
+                            name = "." + name;
+                        }
+                        theNamespace_1 += name;
+                    }
                 });
             }
-        }
-        function _moveNext() {
-            var nextProxy = _nextProxy;
-            _nextProxy = nextProxy ? nextProxy.getNext() : null;
-            if (!nextProxy) {
-                var onComplete = _onComplete;
-                if (onComplete && onComplete.length > 0) {
-                    arrForEach(onComplete, function (completeDetails) {
-                        try {
-                            completeDetails.func.call(completeDetails.self, completeDetails.args);
-                        }
-                        catch (e) {
-                            _throwInternal(core.logger, 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
-                        }
-                    });
-                    _onComplete = [];
-                }
+            else {
+                theNamespace_1 = _normalizeNamespace(evtNamespace);
             }
-            return nextProxy;
-        }
-        function _getExtCfg(identifier, defaultValue, mergeDefault) {
-            if (defaultValue === void 0) { defaultValue = {}; }
-            if (mergeDefault === void 0) { mergeDefault = 0 ; }
-            var theConfig;
-            if (config) {
-                var extConfig = config.extensionConfig;
-                if (extConfig && identifier) {
-                    theConfig = extConfig[identifier];
+            if (theNamespace_1) {
+                if (theNamespace_1[0] !== ".") {
+                    theNamespace_1 = "." + theNamespace_1;
                 }
+                eventName = (eventName || STR_EMPTY$1) + theNamespace_1;
             }
-            if (!theConfig) {
-                theConfig = defaultValue;
+        }
+        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY$1) || []);
+        return _a = {},
+            _a[_DYN_TYPE ] = parsedEvent[1],
+            _a.ns = ((parsedEvent[2] || STR_EMPTY$1).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY$1)[_DYN_SPLIT ](".").sort()).join("."),
+            _a;
+    }
+    function _getRegisteredEvents(target, evtName, addDefault) {
+        if (addDefault === void 0) { addDefault = true; }
+        var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);
+        var registeredEvents = aiEvts[evtName];
+        if (!registeredEvents) {
+            registeredEvents = aiEvts[evtName] = [];
+        }
+        return registeredEvents;
+    }
+    function _doDetach(obj, evtName, handlerRef, useCapture) {
+        if (obj && evtName && evtName[_DYN_TYPE ]) {
+            if (obj[strRemoveEventListener]) {
+                obj[strRemoveEventListener](evtName[_DYN_TYPE ], handlerRef, useCapture);
             }
-            else if (isObject(defaultValue)) {
-                if (mergeDefault !== 0 ) {
-                    var newConfig_1 = objExtend(true, defaultValue, theConfig);
-                    if (config && mergeDefault === 2 ) {
-                        objForEachKey(defaultValue, function (field) {
-                            if (isNullOrUndefined(newConfig_1[field])) {
-                                var cfgValue = config[field];
-                                if (!isNullOrUndefined(cfgValue)) {
-                                    newConfig_1[field] = cfgValue;
-                                }
-                            }
-                        });
-                    }
-                    theConfig = newConfig_1;
-                }
+            else if (obj[strDetachEvent]) {
+                obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
             }
-            return theConfig;
         }
-        function _getConfig(identifier, field, defaultValue) {
-            if (defaultValue === void 0) { defaultValue = false; }
-            var theValue;
-            var extConfig = _getExtCfg(identifier, null);
-            if (extConfig && !isNullOrUndefined(extConfig[field])) {
-                theValue = extConfig[field];
+    }
+    function _doAttach(obj, evtName, handlerRef, useCapture) {
+        var result = false;
+        if (obj && evtName && evtName[_DYN_TYPE ] && handlerRef) {
+            if (obj[strAddEventHelper]) {
+                obj[strAddEventHelper](evtName[_DYN_TYPE ], handlerRef, useCapture);
+                result = true;
             }
-            else if (config && !isNullOrUndefined(config[field])) {
-                theValue = config[field];
+            else if (obj[strAttachEvent]) {
+                obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
+                result = true;
             }
-            return !isNullOrUndefined(theValue) ? theValue : defaultValue;
         }
-        function _iterateChain(cb) {
-            var nextPlugin;
-            while (!!(nextPlugin = context._next())) {
-                var plugin = nextPlugin.getPlugin();
-                if (plugin) {
-                    cb(plugin);
+        return result;
+    }
+    function _doUnregister(target, events, evtName, unRegFn) {
+        var idx = events[_DYN_LENGTH ];
+        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[_DYN_HANDLER ], theEvent.capture);
+                        events[_DYN_SPLICE ](idx, 1);
+                    }
                 }
             }
         }
-        return context;
     }
-    function createProcessTelemetryContext(telemetryChain, config, core, startAt) {
-        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
-        var context = internalContext.ctx;
-        function _processNext(env) {
-            var nextPlugin = internalContext._next();
-            nextPlugin && nextPlugin.processTelemetry(env, context);
-            return !nextPlugin;
+    function _unregisterEvents(target, evtName, unRegFn) {
+        if (evtName[_DYN_TYPE ]) {
+            _doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE ]), evtName, unRegFn);
         }
-        function _createNew(plugins, startAt) {
-            if (plugins === void 0) { plugins = null; }
-            if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+        else {
+            var eventCache = elmNodeData.get(target, strEvents, {});
+            objForEachKey(eventCache, function (evtType, events) {
+                _doUnregister(target, events, evtName, unRegFn);
+            });
+            if (objKeys(eventCache)[_DYN_LENGTH ] === 0) {
+                elmNodeData.kill(target, strEvents);
             }
-            return createProcessTelemetryContext(plugins || context.getNext(), config, core, startAt);
         }
-        context.processNext = _processNext;
-        context.createNew = _createNew;
-        return context;
     }
-    function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
-        var config = core.config || {};
-        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
-        var context = internalContext.ctx;
-        function _processNext(unloadState) {
-            var nextPlugin = internalContext._next();
-            nextPlugin && nextPlugin.unload(context, unloadState);
-            return !nextPlugin;
-        }
-        function _createNew(plugins, startAt) {
-            if (plugins === void 0) { plugins = null; }
-            if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+    function mergeEvtNamespace(theNamespace, namespaces) {
+        var newNamespaces;
+        if (namespaces) {
+            if (isArray(namespaces)) {
+                newNamespaces = [theNamespace].concat(namespaces);
             }
-            return createProcessTelemetryUnloadContext(plugins || context.getNext(), core, startAt);
+            else {
+                newNamespaces = [theNamespace, namespaces];
+            }
+            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT ](".");
         }
-        context.processNext = _processNext;
-        context.createNew = _createNew;
-        return context;
+        else {
+            newNamespaces = theNamespace;
+        }
+        return newNamespaces;
     }
-    function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
-        var config = core.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);
+    function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
+        var _a;
+        if (useCapture === void 0) { useCapture = false; }
+        var result = false;
+        if (target) {
+            try {
+                var evtName = _getEvtNamespace(eventName, evtNamespace);
+                result = _doAttach(target, evtName, handlerRef, useCapture);
+                if (result && elmNodeData.accept(target)) {
+                    var registeredEvent = (_a = {
+                            guid: _guid++,
+                            evtName: evtName
+                        },
+                        _a[_DYN_HANDLER ] = handlerRef,
+                        _a.capture = useCapture,
+                        _a);
+                    _getRegisteredEvents(target, evtName.type)[_DYN_PUSH ](registeredEvent);
                 }
-            });
-        }
-        function _createNew(plugins, startAt) {
-            if (plugins === void 0) { plugins = null; }
-            if (isArray(plugins)) {
-                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
             }
-            return createProcessTelemetryUpdateContext(plugins || context.getNext(), core, startAt);
+            catch (e) {
+            }
         }
-        context.processNext = _processNext;
-        context.createNew = _createNew;
-        return context;
+        return result;
     }
-    function createTelemetryProxyChain(plugins, config, core, startAt) {
-        var firstProxy = null;
-        var add = startAt ? false : true;
-        if (isArray(plugins) && plugins.length > 0) {
+    function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {
+        if (useCapture === void 0) { useCapture = false; }
+        if (target) {
+            try {
+                var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
+                var found_1 = false;
+                _unregisterEvents(target, evtName_1, function (regEvent) {
+                    if ((evtName_1.ns && !handlerRef) || regEvent[_DYN_HANDLER ] === handlerRef) {
+                        found_1 = true;
+                        return true;
+                    }
+                    return false;
+                });
+                if (!found_1) {
+                    _doDetach(target, evtName_1, handlerRef, useCapture);
+                }
+            }
+            catch (e) {
+            }
+        }
+    }
+    function addEventHandler(eventName, callback, evtNamespace) {
+        var result = false;
+        var w = getWindow();
+        if (w) {
+            result = eventOn(w, eventName, callback, evtNamespace);
+            result = eventOn(w["body"], eventName, callback, evtNamespace) || result;
+        }
+        var doc = getDocument();
+        if (doc) {
+            result = eventOn(doc, eventName, callback, evtNamespace) || result;
+        }
+        return result;
+    }
+    function removeEventHandler(eventName, callback, evtNamespace) {
+        var w = getWindow();
+        if (w) {
+            eventOff(w, eventName, callback, evtNamespace);
+            eventOff(w["body"], eventName, callback, evtNamespace);
+        }
+        var doc = getDocument();
+        if (doc) {
+            eventOff(doc, eventName, callback, evtNamespace);
+        }
+    }
+    function _addEventListeners(events, listener, excludeEvents, evtNamespace) {
+        var added = false;
+        if (listener && events && events[_DYN_LENGTH ] > 0) {
+            arrForEach(events, function (name) {
+                if (name) {
+                    if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
+                        added = addEventHandler(name, listener, evtNamespace) || added;
+                    }
+                }
+            });
+        }
+        return added;
+    }
+    function addEventListeners(events, listener, excludeEvents, evtNamespace) {
+        var added = false;
+        if (listener && events && isArray(events)) {
+            added = _addEventListeners(events, listener, excludeEvents, evtNamespace);
+            if (!added && excludeEvents && excludeEvents[_DYN_LENGTH ] > 0) {
+                added = _addEventListeners(events, listener, null, evtNamespace);
+            }
+        }
+        return added;
+    }
+    function removeEventListeners(events, listener, evtNamespace) {
+        if (events && isArray(events)) {
+            arrForEach(events, function (name) {
+                if (name) {
+                    removeEventHandler(name, listener, evtNamespace);
+                }
+            });
+        }
+    }
+    function addPageUnloadEventListener(listener, excludeEvents, evtNamespace) {
+        return addEventListeners([strBeforeUnload, strUnload, strPageHide], listener, excludeEvents, evtNamespace);
+    }
+    function removePageUnloadEventListener(listener, evtNamespace) {
+        removeEventListeners([strBeforeUnload, strUnload, strPageHide], listener, evtNamespace);
+    }
+    function addPageHideEventListener(listener, excludeEvents, evtNamespace) {
+        function _handlePageVisibility(evt) {
+            var doc = getDocument();
+            if (listener && doc && doc.visibilityState === "hidden") {
+                listener(evt);
+            }
+        }
+        var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
+        var pageUnloadAdded = _addEventListeners([strPageHide], listener, excludeEvents, newNamespaces);
+        if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
+            pageUnloadAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageUnloadAdded;
+        }
+        if (!pageUnloadAdded && excludeEvents) {
+            pageUnloadAdded = addPageHideEventListener(listener, null, evtNamespace);
+        }
+        return pageUnloadAdded;
+    }
+    function removePageHideEventListener(listener, evtNamespace) {
+        var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
+        removeEventListeners([strPageHide], listener, newNamespaces);
+        removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
+    }
+    function addPageShowEventListener(listener, excludeEvents, evtNamespace) {
+        function _handlePageVisibility(evt) {
+            var doc = getDocument();
+            if (listener && doc && doc.visibilityState === "visible") {
+                listener(evt);
+            }
+        }
+        var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
+        var pageShowAdded = _addEventListeners([strPageShow], listener, excludeEvents, newNamespaces);
+        pageShowAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageShowAdded;
+        if (!pageShowAdded && excludeEvents) {
+            pageShowAdded = addPageShowEventListener(listener, null, evtNamespace);
+        }
+        return pageShowAdded;
+    }
+    function removePageShowEventListener(listener, evtNamespace) {
+        var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
+        removeEventListeners([strPageShow], listener, newNamespaces);
+        removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
+    }
+
+    function perfNow() {
+        var perf = getPerformance();
+        if (perf && perf.now) {
+            return perf.now();
+        }
+        return dateNow();
+    }
+
+    var pluginStateData = createElmNodeData("plugin");
+    function _getPluginState(plugin) {
+        return pluginStateData.get(plugin, "state", {}, true);
+    }
+
+    var strTelemetryPluginChain = "TelemetryPluginChain";
+    var strHasRunFlags = "_hasRun";
+    var strGetTelCtx = "_getTelCtx";
+    var _chainId = 0;
+    function _getNextProxyStart(proxy, core, startAt) {
+        while (proxy) {
+            if (proxy[_DYN_GET_PLUGIN ]() === startAt) {
+                return proxy;
+            }
+            proxy = proxy[_DYN_GET_NEXT ]();
+        }
+        return createTelemetryProxyChain([startAt], core[_DYN_CONFIG ] || {}, core);
+    }
+    function _createInternalContext(telemetryChain, config, core, startAt) {
+        var _nextProxy = null;
+        var _onComplete = [];
+        if (startAt !== null) {
+            _nextProxy = startAt ? _getNextProxyStart(telemetryChain, core, startAt) : telemetryChain;
+        }
+        var context = {
+            _next: _moveNext,
+            ctx: {
+                core: function () {
+                    return core;
+                },
+                diagLog: function () {
+                    return safeGetLogger(core, config);
+                },
+                getCfg: function () {
+                    return config;
+                },
+                getExtCfg: _getExtCfg,
+                getConfig: _getConfig,
+                hasNext: function () {
+                    return !!_nextProxy;
+                },
+                getNext: function () {
+                    return _nextProxy;
+                },
+                setNext: function (nextPlugin) {
+                    _nextProxy = nextPlugin;
+                },
+                iterate: _iterateChain,
+                onComplete: _addOnComplete
+            }
+        };
+        function _addOnComplete(onComplete, that) {
+            var args = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
+            }
+            if (onComplete) {
+                _onComplete[_DYN_PUSH ]({
+                    func: onComplete,
+                    self: !isUndefined(that) ? that : context.ctx,
+                    args: args
+                });
+            }
+        }
+        function _moveNext() {
+            var nextProxy = _nextProxy;
+            _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT ]() : null;
+            if (!nextProxy) {
+                var onComplete = _onComplete;
+                if (onComplete && onComplete[_DYN_LENGTH ] > 0) {
+                    arrForEach(onComplete, function (completeDetails) {
+                        try {
+                            completeDetails.func[_DYN_CALL ](completeDetails.self, completeDetails.args);
+                        }
+                        catch (e) {
+                            _throwInternal(core[_DYN_LOGGER ], 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
+                        }
+                    });
+                    _onComplete = [];
+                }
+            }
+            return nextProxy;
+        }
+        function _getExtCfg(identifier, defaultValue, mergeDefault) {
+            if (defaultValue === void 0) { defaultValue = {}; }
+            if (mergeDefault === void 0) { mergeDefault = 0 ; }
+            var theConfig;
+            if (config) {
+                var extConfig = config[STR_EXTENSION_CONFIG ];
+                if (extConfig && identifier) {
+                    theConfig = extConfig[identifier];
+                }
+            }
+            if (!theConfig) {
+                theConfig = defaultValue;
+            }
+            else if (isObject(defaultValue)) {
+                if (mergeDefault !== 0 ) {
+                    var newConfig_1 = objExtend(true, defaultValue, theConfig);
+                    if (config && mergeDefault === 2 ) {
+                        objForEachKey(defaultValue, function (field) {
+                            if (isNullOrUndefined(newConfig_1[field])) {
+                                var cfgValue = config[field];
+                                if (!isNullOrUndefined(cfgValue)) {
+                                    newConfig_1[field] = cfgValue;
+                                }
+                            }
+                        });
+                    }
+                    theConfig = newConfig_1;
+                }
+            }
+            return theConfig;
+        }
+        function _getConfig(identifier, field, defaultValue) {
+            if (defaultValue === void 0) { defaultValue = false; }
+            var theValue;
+            var extConfig = _getExtCfg(identifier, null);
+            if (extConfig && !isNullOrUndefined(extConfig[field])) {
+                theValue = extConfig[field];
+            }
+            else if (config && !isNullOrUndefined(config[field])) {
+                theValue = config[field];
+            }
+            return !isNullOrUndefined(theValue) ? theValue : defaultValue;
+        }
+        function _iterateChain(cb) {
+            var nextPlugin;
+            while (!!(nextPlugin = context._next())) {
+                var plugin = nextPlugin[_DYN_GET_PLUGIN ]();
+                if (plugin) {
+                    cb(plugin);
+                }
+            }
+        }
+        return context;
+    }
+    function createProcessTelemetryContext(telemetryChain, config, core, startAt) {
+        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
+        var context = internalContext.ctx;
+        function _processNext(env) {
+            var nextPlugin = internalContext._next();
+            nextPlugin && nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
+            return !nextPlugin;
+        }
+        function _createNew(plugins, startAt) {
+            if (plugins === void 0) { plugins = null; }
+            if (isArray(plugins)) {
+                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+            }
+            return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config, core, startAt);
+        }
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
+        return context;
+    }
+    function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
+        var config = core[_DYN_CONFIG ] || {};
+        var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
+        var context = internalContext.ctx;
+        function _processNext(unloadState) {
+            var nextPlugin = internalContext._next();
+            nextPlugin && nextPlugin.unload(context, unloadState);
+            return !nextPlugin;
+        }
+        function _createNew(plugins, startAt) {
+            if (plugins === void 0) { plugins = null; }
+            if (isArray(plugins)) {
+                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+            }
+            return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
+        }
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
+        return context;
+    }
+    function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
+        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[_DYN_UPDATE ])) {
+                    plugin[_DYN_UPDATE ](context, updateState);
+                }
+            });
+        }
+        function _createNew(plugins, startAt) {
+            if (plugins === void 0) { plugins = null; }
+            if (isArray(plugins)) {
+                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
+            }
+            return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
+        }
+        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[_DYN_LENGTH ] > 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;
@@ -1511,11 +1854,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++;
@@ -1547,17 +1890,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;
+                        var nextId = nextProxy ? nextProxy._id : STR_EMPTY$1;
                         if (nextId) {
                             hasRunContext[nextId] = false;
                         }
@@ -1569,7 +1912,7 @@
                             hasRun = true;
                         }
                         if (!nextProxy || !hasNextRun) {
-                            _throwInternal(itemCtx.diagLog(), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
+                            _throwInternal(itemCtx[_DYN_DIAG_LOG ](), 1 , 73 , "Plugin [" + identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
                         }
                     }
                 }, details, isAsync);
@@ -1583,17 +1926,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) {
@@ -1601,20 +1944,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) {
@@ -1622,9 +1965,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;
                         }
                     }
@@ -1632,19 +1975,17 @@
                 return hasRun;
             }
             if (!_processChain(updateCtx, _callUpdate, "update", function () { }, false)) {
-                updateCtx.processNext(updateState);
+                updateCtx[_DYN_PROCESS_NEXT ](updateState);
             }
         }
         return objFreeze(proxyChain);
     }
 
-    var strExtensionConfig = "extensionConfig";
-
     function createUnloadHandlerContainer() {
         var handlers = [];
         function _addHandler(handler) {
             if (handler) {
-                handlers.push(handler);
+                handlers[_DYN_PUSH ](handler);
             }
         }
         function _runHandlers(unloadCtx, unloadState) {
@@ -1653,7 +1994,7 @@
                     handler(unloadCtx, unloadState);
                 }
                 catch (e) {
-                    _throwInternal(unloadCtx.diagLog(), 2 , 73 , "Unexpected error calling unload handler - " + dumpObj(e));
+                    _throwInternal(unloadCtx[_DYN_DIAG_LOG ](), 2 , 73 , "Unexpected error calling unload handler - " + dumpObj(e));
                 }
             });
             handlers = [];
@@ -1675,37 +2016,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 {
@@ -1713,9 +2057,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;
@@ -1727,7 +2071,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) {
@@ -1744,30 +2088,30 @@
                             _hooks = _hooks.concat(hooks);
                         }
                         else {
-                            _hooks.push(hooks);
+                            _hooks[_DYN_PUSH ](hooks);
                         }
                     }
                 };
                 proxyFunctionAs(_self, "_addUnloadCb", function () { return _unloadHandlerContainer; }, "add");
             });
-            _self.diagLog = function (itemCtx) {
-                return _getTelCtx(itemCtx).diagLog();
+            _self[_DYN_DIAG_LOG ] = function (itemCtx) {
+                return _getTelCtx(itemCtx)[_DYN_DIAG_LOG ]();
             };
-            _self[strIsInitialized] = function () {
+            _self[_DYN_IS_INITIALIZED ] = function () {
                 return _isinitialized;
             };
             _self.setInitialized = function (isInitialized) {
                 _isinitialized = isInitialized;
             };
-            _self[strSetNextPlugin] = function (next) {
+            _self[_DYN_SET_NEXT_PLUGIN ] = function (next) {
                 _nextPlugin = next;
             };
-            _self.processNext = function (env, itemCtx) {
+            _self[_DYN_PROCESS_NEXT ] = function (env, itemCtx) {
                 if (itemCtx) {
-                    itemCtx.processNext(env);
+                    itemCtx[_DYN_PROCESS_NEXT ](env);
                 }
-                else if (_nextPlugin && isFunction(_nextPlugin.processTelemetry)) {
-                    _nextPlugin.processTelemetry(env, null);
+                else if (_nextPlugin && isFunction(_nextPlugin[STR_PROCESS_TELEMETRY ])) {
+                    _nextPlugin[STR_PROCESS_TELEMETRY ](env, null);
                 }
             };
             _self._getTelCtx = _getTelCtx;
@@ -1775,332 +2119,47 @@
                 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;
-                _rootCtx = null;
-                _nextPlugin = null;
-                _hooks = [];
-                _unloadHandlerContainer = createUnloadHandlerContainer();
-            }
-        }
-        return BaseTelemetryPlugin;
-    }());
-
-    var strOnPrefix = "on";
-    var strAttachEvent = "attachEvent";
-    var strAddEventHelper = "addEventListener";
-    var strDetachEvent = "detachEvent";
-    var strRemoveEventListener = "removeEventListener";
-    var strEvents = "events";
-    var strVisibilityChangeEvt = "visibilitychange";
-    var strPageHide = "pagehide";
-    var strPageShow = "pageshow";
-    var strUnload = "unload";
-    var strBeforeUnload = "beforeunload";
-    var strPageHideNamespace = createUniqueNamespace("aiEvtPageHide");
-    var strPageShowNamespace = createUniqueNamespace("aiEvtPageShow");
-    var rRemoveEmptyNs = /\.[\.]+/g;
-    var rRemoveTrailingEmptyNs = /[\.]+$/;
-    var _guid = 1;
-    var elmNodeData = createElmNodeData("events");
-    var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
-    function _normalizeNamespace(name) {
-        if (name && name.replace) {
-            return name.replace(/^\s*\.*|\.*\s*$/g, "");
-        }
-        return name;
-    }
-    function _getEvtNamespace(eventName, evtNamespace) {
-        if (evtNamespace) {
-            var theNamespace_1 = "";
-            if (isArray(evtNamespace)) {
-                theNamespace_1 = "";
-                arrForEach(evtNamespace, function (name) {
-                    name = _normalizeNamespace(name);
-                    if (name) {
-                        if (name[0] !== ".") {
-                            name = "." + name;
-                        }
-                        theNamespace_1 += name;
-                    }
-                });
-            }
-            else {
-                theNamespace_1 = _normalizeNamespace(evtNamespace);
-            }
-            if (theNamespace_1) {
-                if (theNamespace_1[0] !== ".") {
-                    theNamespace_1 = "." + theNamespace_1;
-                }
-                eventName = (eventName || "") + theNamespace_1;
-            }
-        }
-        var parsedEvent = (eventNamespace.exec(eventName || "") || []);
-        return {
-            type: parsedEvent[1],
-            ns: ((parsedEvent[2] || "").replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, "").split(".").sort()).join(".")
-        };
-    }
-    function _getRegisteredEvents(target, evtName, addDefault) {
-        if (addDefault === void 0) { addDefault = true; }
-        var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);
-        var registeredEvents = aiEvts[evtName];
-        if (!registeredEvents) {
-            registeredEvents = aiEvts[evtName] = [];
-        }
-        return registeredEvents;
-    }
-    function _doDetach(obj, evtName, handlerRef, useCapture) {
-        if (obj && evtName && evtName.type) {
-            if (obj[strRemoveEventListener]) {
-                obj[strRemoveEventListener](evtName.type, handlerRef, useCapture);
-            }
-            else if (obj[strDetachEvent]) {
-                obj[strDetachEvent](strOnPrefix + evtName.type, handlerRef);
-            }
-        }
-    }
-    function _doAttach(obj, evtName, handlerRef, useCapture) {
-        var result = false;
-        if (obj && evtName && evtName.type && handlerRef) {
-            if (obj[strAddEventHelper]) {
-                obj[strAddEventHelper](evtName.type, handlerRef, useCapture);
-                result = true;
-            }
-            else if (obj[strAttachEvent]) {
-                obj[strAttachEvent](strOnPrefix + evtName.type, handlerRef);
-                result = true;
-            }
-        }
-        return result;
-    }
-    function _doUnregister(target, events, evtName, unRegFn) {
-        var idx = events.length;
-        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);
-                    }
-                }
-            }
-        }
-    }
-    function _unregisterEvents(target, evtName, unRegFn) {
-        if (evtName.type) {
-            _doUnregister(target, _getRegisteredEvents(target, evtName.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) {
-                elmNodeData.kill(target, strEvents);
-            }
-        }
-    }
-    function mergeEvtNamespace(theNamespace, namespaces) {
-        var newNamespaces;
-        if (namespaces) {
-            if (isArray(namespaces)) {
-                newNamespaces = [theNamespace].concat(namespaces);
-            }
-            else {
-                newNamespaces = [theNamespace, namespaces];
-            }
-            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns).split(".");
-        }
-        else {
-            newNamespaces = theNamespace;
-        }
-        return newNamespaces;
-    }
-    function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
-        if (useCapture === void 0) { useCapture = false; }
-        var result = false;
-        if (target) {
-            try {
-                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);
-                }
-            }
-            catch (e) {
-            }
-        }
-        return result;
-    }
-    function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {
-        if (useCapture === void 0) { useCapture = false; }
-        if (target) {
-            try {
-                var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
-                var found_1 = false;
-                _unregisterEvents(target, evtName_1, function (regEvent) {
-                    if ((evtName_1.ns && !handlerRef) || regEvent.handler === handlerRef) {
-                        found_1 = true;
-                        return true;
-                    }
-                    return false;
-                });
-                if (!found_1) {
-                    _doDetach(target, evtName_1, handlerRef, useCapture);
-                }
-            }
-            catch (e) {
-            }
-        }
-    }
-    function addEventHandler(eventName, callback, evtNamespace) {
-        var result = false;
-        var w = getWindow();
-        if (w) {
-            result = eventOn(w, eventName, callback, evtNamespace);
-            result = eventOn(w["body"], eventName, callback, evtNamespace) || result;
-        }
-        var doc = getDocument();
-        if (doc) {
-            result = eventOn(doc, eventName, callback, evtNamespace) || result;
-        }
-        return result;
-    }
-    function removeEventHandler(eventName, callback, evtNamespace) {
-        var w = getWindow();
-        if (w) {
-            eventOff(w, eventName, callback, evtNamespace);
-            eventOff(w["body"], eventName, callback, evtNamespace);
-        }
-        var doc = getDocument();
-        if (doc) {
-            eventOff(doc, eventName, callback, evtNamespace);
-        }
-    }
-    function _addEventListeners(events, listener, excludeEvents, evtNamespace) {
-        var added = false;
-        if (listener && events && events.length > 0) {
-            arrForEach(events, function (name) {
-                if (name) {
-                    if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
-                        added = addEventHandler(name, listener, evtNamespace) || added;
-                    }
-                }
-            });
-        }
-        return added;
-    }
-    function addEventListeners(events, listener, excludeEvents, evtNamespace) {
-        var added = false;
-        if (listener && events && isArray(events)) {
-            added = _addEventListeners(events, listener, excludeEvents, evtNamespace);
-            if (!added && excludeEvents && excludeEvents.length > 0) {
-                added = _addEventListeners(events, listener, null, evtNamespace);
-            }
-        }
-        return added;
-    }
-    function removeEventListeners(events, listener, evtNamespace) {
-        if (events && isArray(events)) {
-            arrForEach(events, function (name) {
-                if (name) {
-                    removeEventHandler(name, listener, evtNamespace);
-                }
-            });
-        }
-    }
-    function addPageUnloadEventListener(listener, excludeEvents, evtNamespace) {
-        return addEventListeners([strBeforeUnload, strUnload, strPageHide], listener, excludeEvents, evtNamespace);
-    }
-    function removePageUnloadEventListener(listener, evtNamespace) {
-        removeEventListeners([strBeforeUnload, strUnload, strPageHide], listener, evtNamespace);
-    }
-    function addPageHideEventListener(listener, excludeEvents, evtNamespace) {
-        function _handlePageVisibility(evt) {
-            var doc = getDocument();
-            if (listener && doc && doc.visibilityState === "hidden") {
-                listener(evt);
-            }
-        }
-        var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
-        var pageUnloadAdded = _addEventListeners([strPageHide], listener, excludeEvents, newNamespaces);
-        if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
-            pageUnloadAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageUnloadAdded;
-        }
-        if (!pageUnloadAdded && excludeEvents) {
-            pageUnloadAdded = addPageHideEventListener(listener, null, evtNamespace);
-        }
-        return pageUnloadAdded;
-    }
-    function removePageHideEventListener(listener, evtNamespace) {
-        var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
-        removeEventListeners([strPageHide], listener, newNamespaces);
-        removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
-    }
-    function addPageShowEventListener(listener, excludeEvents, evtNamespace) {
-        function _handlePageVisibility(evt) {
-            var doc = getDocument();
-            if (listener && doc && doc.visibilityState === "visible") {
-                listener(evt);
+                _isinitialized = false;
+                _self[STR_CORE ] = null;
+                _rootCtx = null;
+                _nextPlugin = null;
+                _hooks = [];
+                _unloadHandlerContainer = createUnloadHandlerContainer();
             }
         }
-        var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
-        var pageShowAdded = _addEventListeners([strPageShow], listener, excludeEvents, newNamespaces);
-        pageShowAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageShowAdded;
-        if (!pageShowAdded && excludeEvents) {
-            pageShowAdded = addPageShowEventListener(listener, null, evtNamespace);
-        }
-        return pageShowAdded;
-    }
-    function removePageShowEventListener(listener, evtNamespace) {
-        var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
-        removeEventListeners([strPageShow], listener, newNamespaces);
-        removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
-    }
+        BaseTelemetryPlugin.__ieDyn=1;
+        return BaseTelemetryPlugin;
+    }());
 
-    function perfNow() {
-        var perf = getPerformance();
-        if (perf && perf.now) {
-            return perf.now();
-        }
-        return dateNow();
-    }
+    var STR_EMPTY = "";
 
     var _a$1;
-    var Version = '3.2.2';
+    var Version = '3.2.5';
     var FullVersionString = "1DS-Web-JS-" + Version;
     var strDisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
     var strWithCredentials = "withCredentials";
@@ -2117,7 +2176,7 @@
     Boolean(getDocument());
     Boolean(getWindow());
     function isValueAssigned(value) {
-        return !(value === "" || isNullOrUndefined(value));
+        return !(value === STR_EMPTY || isNullOrUndefined(value));
     }
     function getTenantId(apiKey) {
         if (apiKey) {
@@ -2126,7 +2185,7 @@
                 return apiKey.substring(0, indexTenantId);
             }
         }
-        return "";
+        return STR_EMPTY;
     }
     function sanitizeProperty(name, property, stringifyObjects) {
         if ((!property && !isValueAssigned(property)) || typeof name !== "string") {
@@ -2136,11 +2195,11 @@
         if (propType === "string" || propType === "number" || propType === "boolean" || isArray(property)) {
             property = { value: property };
         }
-        else if (propType === "object" && !property.hasOwnProperty("value")) {
+        else if (propType === "object" && !ObjHasOwnProperty.call(property, "value")) {
             property = { value: stringifyObjects ? JSON.stringify(property) : property };
         }
         else if (isNullOrUndefined(property.value)
-            || property.value === "" || (!isString(property.value)
+            || property.value === STR_EMPTY || (!isString(property.value)
             && !isNumber(property.value) && !isBoolean(property.value)
             && !isArray(property.value))) {
             return null;
@@ -2266,7 +2325,7 @@
                         theType |= getFieldValueType(value[0]);
                     }
                 }
-                else if (hasOwnProperty(value, "value")) {
+                else if (ObjHasOwnProperty.call(value, "value")) {
                     theType = 8192  | getFieldValueType(value.value);
                 }
             }
@@ -2307,35 +2366,37 @@
     var NRT_PROFILE = "NEAR_REAL_TIME";
     var BE_PROFILE = "BEST_EFFORT";
 
-    var Method = "POST";
-    var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
-    var strDropped = "drop";
-    var strSending = "send";
-    var strRequeue = "requeue";
-    var strResponseFail = "rspFail";
-    var strOther = "oth";
-    var defaultCacheControl = "no-cache, no-store";
-    var defaultContentType = "application/x-json-stream";
-    var strCacheControl = "cache-control";
-    var strContentTypeHeader = "content-type";
-    var strKillTokensHeader = "kill-tokens";
-    var strKillDurationHeader = "kill-duration";
-    var strKillDurationSecondsHeader = "kill-duration-seconds";
-    var strTimeDeltaHeader = "time-delta-millis";
-    var strClientVersion = "client-version";
-    var strClientId = "client-id";
-    var strTimeDeltaToApply = "time-delta-to-apply-millis";
-    var strUploadTime = "upload-time";
-    var strApiKey = "apikey";
-    var strMsaDeviceTicket = "AuthMsaDeviceTicket";
-    var strAuthXToken = "AuthXToken";
-    var strNoResponseBody = "NoResponseBody";
-    var strMsfpc = "msfpc";
+    var STR_POST_METHOD = "POST";
+    var STR_DISABLED_PROPERTY_NAME = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
+    var STR_DROPPED = "drop";
+    var STR_SENDING = "send";
+    var STR_REQUEUE = "requeue";
+    var STR_RESPONSE_FAIL = "rspFail";
+    var STR_OTHER = "oth";
+    var DEFAULT_CACHE_CONTROL = "no-cache, no-store";
+    var DEFAULT_CONTENT_TYPE = "application/x-json-stream";
+    var STR_CACHE_CONTROL = "cache-control";
+    var STR_CONTENT_TYPE_HEADER = "content-type";
+    var STR_KILL_TOKENS_HEADER = "kill-tokens";
+    var STR_KILL_DURATION_HEADER = "kill-duration";
+    var STR_KILL_DURATION_SECONDS_HEADER = "kill-duration-seconds";
+    var STR_TIME_DELTA_HEADER = "time-delta-millis";
+    var STR_CLIENT_VERSION = "client-version";
+    var STR_CLIENT_ID = "client-id";
+    var STR_TIME_DELTA_TO_APPLY = "time-delta-to-apply-millis";
+    var STR_UPLOAD_TIME = "upload-time";
+    var STR_API_KEY = "apikey";
+    var STR_MSA_DEVICE_TICKET = "AuthMsaDeviceTicket";
+    var STR_AUTH_XTOKEN = "AuthXToken";
+    var STR_NO_RESPONSE_BODY = "NoResponseBody";
+    var STR_MSFPC = "msfpc";
+    var STR_TRACE = "trace";
+    var STR_USER = "user";
 
     function _getEventMsfpc(theEvent) {
         var intWeb = ((theEvent.ext || {})["intweb"]);
-        if (intWeb && isValueAssigned(intWeb[strMsfpc])) {
-            return intWeb[strMsfpc];
+        if (intWeb && isValueAssigned(intWeb[STR_MSFPC])) {
+            return intWeb[STR_MSFPC];
         }
         return null;
     }
@@ -2392,6 +2453,117 @@
         return EventBatch;
     }());
 
+    var ClockSkewManager = /** @class */ (function () {
+        function ClockSkewManager() {
+            var _allowRequestSending = true;
+            var _shouldAddClockSkewHeaders = true;
+            var _isFirstRequest = true;
+            var _clockSkewHeaderValue = "use-collector-delta";
+            var _clockSkewSet = false;
+            dynamicProto(ClockSkewManager, this, function (_self) {
+                _self.allowRequestSending = function () {
+                    return _allowRequestSending;
+                };
+                _self.firstRequestSent = function () {
+                    if (_isFirstRequest) {
+                        _isFirstRequest = false;
+                        if (!_clockSkewSet) {
+                            _allowRequestSending = false;
+                        }
+                    }
+                };
+                _self.shouldAddClockSkewHeaders = function () {
+                    return _shouldAddClockSkewHeaders;
+                };
+                _self.getClockSkewHeaderValue = function () {
+                    return _clockSkewHeaderValue;
+                };
+                _self.setClockSkew = function (timeDeltaInMillis) {
+                    if (!_clockSkewSet) {
+                        if (timeDeltaInMillis) {
+                            _clockSkewHeaderValue = timeDeltaInMillis;
+                            _shouldAddClockSkewHeaders = true;
+                            _clockSkewSet = true;
+                        }
+                        else {
+                            _shouldAddClockSkewHeaders = false;
+                        }
+                        _allowRequestSending = true;
+                    }
+                };
+            });
+        }
+        ClockSkewManager.__ieDyn=1;
+        return ClockSkewManager;
+    }());
+    var EVTClockSkewManager = ClockSkewManager;
+
+    var SecToMsMultiplier = 1000;
+    var KillSwitch = /** @class */ (function () {
+        function KillSwitch() {
+            var _killedTokenDictionary = {};
+            function _normalizeTenants(values) {
+                var result = [];
+                if (values) {
+                    arrForEach(values, function (value) {
+                        result.push(strTrim(value));
+                    });
+                }
+                return result;
+            }
+            dynamicProto(KillSwitch, this, function (_self) {
+                _self.setKillSwitchTenants = function (killTokens, killDuration) {
+                    if (killTokens && killDuration) {
+                        try {
+                            var killedTokens = _normalizeTenants(killTokens.split(","));
+                            if (killDuration === "this-request-only") {
+                                return killedTokens;
+                            }
+                            var durationMs = parseInt(killDuration, 10) * SecToMsMultiplier;
+                            for (var i = 0; i < killedTokens.length; ++i) {
+                                _killedTokenDictionary[killedTokens[i]] = dateNow() + durationMs;
+                            }
+                        }
+                        catch (ex) {
+                            return [];
+                        }
+                    }
+                    return [];
+                };
+                _self.isTenantKilled = function (tenantToken) {
+                    var killDictionary = _killedTokenDictionary;
+                    var name = strTrim(tenantToken);
+                    if (killDictionary[name] !== undefined && killDictionary[name] > dateNow()) {
+                        return true;
+                    }
+                    delete killDictionary[name];
+                    return false;
+                };
+            });
+        }
+        KillSwitch.__ieDyn=1;
+        return KillSwitch;
+    }());
+    var EVTKillSwitch = KillSwitch;
+
+    var RandomizationLowerThreshold = 0.8;
+    var RandomizationUpperThreshold = 1.2;
+    var BaseBackoff = 3000;
+    var MaxBackoff = 600000;
+    function retryPolicyShouldRetryForStatus(httpStatusCode) {
+        return !((httpStatusCode >= 300 && httpStatusCode < 500 && httpStatusCode != 408 && httpStatusCode != 429)
+            || (httpStatusCode == 501)
+            || (httpStatusCode == 505));
+    }
+    function retryPolicyGetMillisToBackoffForRetry(retriesSoFar) {
+        var waitDuration = 0;
+        var minBackoff = BaseBackoff * RandomizationLowerThreshold;
+        var maxBackoff = BaseBackoff * RandomizationUpperThreshold;
+        var randomBackoff = Math.floor(Math.random() * (maxBackoff - minBackoff)) + minBackoff;
+        waitDuration = Math.pow(2, retriesSoFar) * randomBackoff;
+        return Math.min(waitDuration, MaxBackoff);
+    }
+
     var _MAX_STRING_JOINS = 20;
     var RequestSizeLimitBytes = 3984588;
     var BeaconRequestSizeLimitBytes = 65000;
@@ -2597,6 +2769,7 @@
                 }
             });
         }
+        Serializer.__ieDyn=1;
         return Serializer;
     }());
     function _addJSONPropertyMetaData(json, propKeys, name, propertyValue) {
@@ -2637,124 +2810,15 @@
         }
     }
 
-    var RandomizationLowerThreshold = 0.8;
-    var RandomizationUpperThreshold = 1.2;
-    var BaseBackoff = 3000;
-    var MaxBackoff = 600000;
-    function retryPolicyShouldRetryForStatus(httpStatusCode) {
-        return !((httpStatusCode >= 300 && httpStatusCode < 500 && httpStatusCode != 408 && httpStatusCode != 429)
-            || (httpStatusCode == 501)
-            || (httpStatusCode == 505));
-    }
-    function retryPolicyGetMillisToBackoffForRetry(retriesSoFar) {
-        var waitDuration = 0;
-        var minBackoff = BaseBackoff * RandomizationLowerThreshold;
-        var maxBackoff = BaseBackoff * RandomizationUpperThreshold;
-        var randomBackoff = Math.floor(Math.random() * (maxBackoff - minBackoff)) + minBackoff;
-        waitDuration = Math.pow(2, retriesSoFar) * randomBackoff;
-        return Math.min(waitDuration, MaxBackoff);
-    }
-
-    var SecToMsMultiplier = 1000;
-    var KillSwitch = /** @class */ (function () {
-        function KillSwitch() {
-            var _killedTokenDictionary = {};
-            function _normalizeTenants(values) {
-                var result = [];
-                if (values) {
-                    arrForEach(values, function (value) {
-                        result.push(strTrim(value));
-                    });
-                }
-                return result;
-            }
-            dynamicProto(KillSwitch, this, function (_self) {
-                _self.setKillSwitchTenants = function (killTokens, killDuration) {
-                    if (killTokens && killDuration) {
-                        try {
-                            var killedTokens = _normalizeTenants(killTokens.split(","));
-                            if (killDuration === "this-request-only") {
-                                return killedTokens;
-                            }
-                            var durationMs = parseInt(killDuration, 10) * SecToMsMultiplier;
-                            for (var i = 0; i < killedTokens.length; ++i) {
-                                _killedTokenDictionary[killedTokens[i]] = dateNow() + durationMs;
-                            }
-                        }
-                        catch (ex) {
-                            return [];
-                        }
-                    }
-                    return [];
-                };
-                _self.isTenantKilled = function (tenantToken) {
-                    var killDictionary = _killedTokenDictionary;
-                    var name = strTrim(tenantToken);
-                    if (killDictionary[name] !== undefined && killDictionary[name] > dateNow()) {
-                        return true;
-                    }
-                    delete killDictionary[name];
-                    return false;
-                };
-            });
-        }
-        return KillSwitch;
-    }());
-    var EVTKillSwitch = KillSwitch;
-
-    var ClockSkewManager = /** @class */ (function () {
-        function ClockSkewManager() {
-            var _allowRequestSending = true;
-            var _shouldAddClockSkewHeaders = true;
-            var _isFirstRequest = true;
-            var _clockSkewHeaderValue = "use-collector-delta";
-            var _clockSkewSet = false;
-            dynamicProto(ClockSkewManager, this, function (_self) {
-                _self.allowRequestSending = function () {
-                    return _allowRequestSending;
-                };
-                _self.firstRequestSent = function () {
-                    if (_isFirstRequest) {
-                        _isFirstRequest = false;
-                        if (!_clockSkewSet) {
-                            _allowRequestSending = false;
-                        }
-                    }
-                };
-                _self.shouldAddClockSkewHeaders = function () {
-                    return _shouldAddClockSkewHeaders;
-                };
-                _self.getClockSkewHeaderValue = function () {
-                    return _clockSkewHeaderValue;
-                };
-                _self.setClockSkew = function (timeDeltaInMillis) {
-                    if (!_clockSkewSet) {
-                        if (timeDeltaInMillis) {
-                            _clockSkewHeaderValue = timeDeltaInMillis;
-                            _shouldAddClockSkewHeaders = true;
-                            _clockSkewSet = true;
-                        }
-                        else {
-                            _shouldAddClockSkewHeaders = false;
-                        }
-                        _allowRequestSending = true;
-                    }
-                };
-            });
-        }
-        return ClockSkewManager;
-    }());
-    var EVTClockSkewManager = ClockSkewManager;
-
     var _a;
     var strSendAttempt = "sendAttempt";
-    var _noResponseQs = "&" + strNoResponseBody + "=true";
+    var _noResponseQs = "&" + STR_NO_RESPONSE_BODY + "=true";
     var _eventActionMap = (_a = {},
-        _a[1 ] = strRequeue,
-        _a[100 ] = strRequeue,
+        _a[1 ] = STR_REQUEUE,
+        _a[100 ] = STR_REQUEUE,
         _a[200 ] = "sent",
-        _a[8004 ] = strDropped,
-        _a[8003 ] = strDropped,
+        _a[8004 ] = STR_DROPPED,
+        _a[8003 ] = STR_DROPPED,
         _a);
     var _collectorQsHeaders = {};
     var _collectorHeaderToQs = {};
@@ -2764,13 +2828,13 @@
             _collectorHeaderToQs[headerName] = qsName;
         }
     }
-    _addCollectorHeaderQsMapping(strMsaDeviceTicket, strMsaDeviceTicket, false);
-    _addCollectorHeaderQsMapping(strClientVersion, strClientVersion);
-    _addCollectorHeaderQsMapping(strClientId, "Client-Id");
-    _addCollectorHeaderQsMapping(strApiKey, strApiKey);
-    _addCollectorHeaderQsMapping(strTimeDeltaToApply, strTimeDeltaToApply);
-    _addCollectorHeaderQsMapping(strUploadTime, strUploadTime);
-    _addCollectorHeaderQsMapping(strAuthXToken, strAuthXToken);
+    _addCollectorHeaderQsMapping(STR_MSA_DEVICE_TICKET, STR_MSA_DEVICE_TICKET, false);
+    _addCollectorHeaderQsMapping(STR_CLIENT_VERSION, STR_CLIENT_VERSION);
+    _addCollectorHeaderQsMapping(STR_CLIENT_ID, "Client-Id");
+    _addCollectorHeaderQsMapping(STR_API_KEY, STR_API_KEY);
+    _addCollectorHeaderQsMapping(STR_TIME_DELTA_TO_APPLY, STR_TIME_DELTA_TO_APPLY);
+    _addCollectorHeaderQsMapping(STR_UPLOAD_TIME, STR_UPLOAD_TIME);
+    _addCollectorHeaderQsMapping(STR_AUTH_XTOKEN, STR_AUTH_XTOKEN);
     function _getResponseText(xhr) {
         try {
             return xhr.responseText;
@@ -2811,13 +2875,14 @@
     var HttpManager = /** @class */ (function () {
         function HttpManager(maxEventsPerBatch, maxConnections, maxRequestRetriesBeforeBackoff, actions, timeoutOverride) {
             this._responseHandlers = [];
-            var _urlString = "?cors=true&" + strContentTypeHeader.toLowerCase() + "=" + defaultContentType;
+            var _urlString = "?cors=true&" + STR_CONTENT_TYPE_HEADER.toLowerCase() + "=" + DEFAULT_CONTENT_TYPE;
             var _killSwitch = new EVTKillSwitch();
             var _paused = false;
             var _clockSkewManager = new EVTClockSkewManager();
             var _useBeacons = false;
             var _outstandingRequests = 0;
             var _postManager;
+            var _logger;
             var _sendInterfaces;
             var _core;
             var _customHttpInterface = true;
@@ -2845,6 +2910,7 @@
                     _enableEventTimings = !_core.config.disableEventTimings;
                     var enableCompoundKey = !!_core.config.enableCompoundKey;
                     _postManager = postChannel;
+                    _logger = _postManager.diagLog();
                     var valueSanitizer = channelConfig.valueSanitizer;
                     var stringifyObjects = channelConfig.stringifyObjects;
                     if (!isUndefined(channelConfig.enableCompoundKey)) {
@@ -2882,7 +2948,7 @@
                         httpInterface = _getSenderInterface(theTransports, false);
                         syncHttpInterface = _getSenderInterface(theTransports, true);
                         if (!httpInterface) {
-                            _postManager.diagLog().warnToConsole("No available transport to send events");
+                            _warnToConsole(_logger, "No available transport to send events");
                         }
                     }
                     _sendInterfaces = (_a = {},
@@ -2928,7 +2994,7 @@
                 };
                 function _xdrSendPost(payload, oncomplete, sync) {
                     var xdr = new XDomainRequest();
-                    xdr.open(Method, payload.urlString);
+                    xdr.open(STR_POST_METHOD, payload.urlString);
                     if (payload.timeout) {
                         xdr.timeout = payload.timeout;
                     }
@@ -2960,9 +3026,9 @@
                     var responseHandled = false;
                     var requestInit = (_a = {
                             body: payload.data,
-                            method: Method
+                            method: STR_POST_METHOD
                         },
-                        _a[DisabledPropertyName] = true,
+                        _a[STR_DISABLED_PROPERTY_NAME] = true,
                         _a);
                     if (sync) {
                         requestInit.keepalive = true;
@@ -2980,8 +3046,9 @@
                     fetch(theUrl, requestInit).then(function (response) {
                         var headerMap = {};
                         var responseText = "";
-                        if (response.headers) {
-                            response.headers.forEach(function (value, name) {
+                        var headers = response.headers;
+                        if (headers) {
+                            headers["forEach"](function (value, name) {
                                 headerMap[name] = value;
                             });
                         }
@@ -3028,9 +3095,9 @@
                     function _getAllResponseHeaders(xhr) {
                         var theHeaders = {};
                         if (!xhr.getAllResponseHeaders) {
-                            theHeaders = _appendHeader(theHeaders, xhr, strTimeDeltaHeader);
-                            theHeaders = _appendHeader(theHeaders, xhr, strKillDurationHeader);
-                            theHeaders = _appendHeader(theHeaders, xhr, strKillDurationSecondsHeader);
+                            theHeaders = _appendHeader(theHeaders, xhr, STR_TIME_DELTA_HEADER);
+                            theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_HEADER);
+                            theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_SECONDS_HEADER);
                         }
                         else {
                             theHeaders = _convertAllHeadersToMap(xhr.getAllResponseHeaders());
@@ -3043,7 +3110,7 @@
                     if (sync && payload.disableXhrSync) {
                         sync = false;
                     }
-                    var xhrRequest = openXhr(Method, theUrl, _sendCredentials, true, sync, payload.timeout);
+                    var xhrRequest = openXhr(STR_POST_METHOD, theUrl, _sendCredentials, true, sync, payload.timeout);
                     objForEachKey(payload.headers, function (name, value) {
                         xhrRequest.setRequestHeader(name, value);
                     });
@@ -3065,7 +3132,7 @@
                         oncomplete(status, headers, response);
                     }
                     catch (e) {
-                        _throwInternal(_postManager.diagLog(), 2 , 518 , dumpObj(e));
+                        _throwInternal(_logger, 2 , 518 , dumpObj(e));
                     }
                 }
                 function _beaconSendPost(payload, oncomplete, sync) {
@@ -3100,7 +3167,7 @@
                         }
                     }
                     catch (ex) {
-                        _postManager.diagLog().warnToConsole("Failed to send telemetry using sendBeacon API. Ex:" + dumpObj(ex));
+                        _warnToConsole(_logger, "Failed to send telemetry using sendBeacon API. Ex:" + dumpObj(ex));
                         status = 0;
                     }
                     finally {
@@ -3264,7 +3331,7 @@
                         }, function () { return ({ batches: _createDebugBatches(orgBatches_1), retryCount: retryCount, isTeardown: isTeardown, isSynchronous: isSynchronous_1, sendReason: sendReason, useSendBeacon: _isBeaconPayload(sendType), sendType: sendType }); }, !isSynchronous_1);
                     }
                     catch (ex) {
-                        _throwInternal(_postManager.diagLog(), 2 , 48 , "Unexpected Exception sending batch: " + dumpObj(ex));
+                        _throwInternal(_logger, 2 , 48 , "Unexpected Exception sending batch: " + dumpObj(ex));
                     }
                 }
                 function _buildRequestDetails(thePayload, useHeaders) {
@@ -3288,8 +3355,8 @@
                         requestDetails.hdrs = extend(requestDetails.hdrs, _headers);
                         requestDetails.useHdrs = (objKeys(requestDetails.hdrs).length > 0);
                     }
-                    _addRequestDetails(requestDetails, strClientId, "NO_AUTH", useHeaders);
-                    _addRequestDetails(requestDetails, strClientVersion, FullVersionString, useHeaders);
+                    _addRequestDetails(requestDetails, STR_CLIENT_ID, "NO_AUTH", useHeaders);
+                    _addRequestDetails(requestDetails, STR_CLIENT_VERSION, FullVersionString, useHeaders);
                     var apiQsKeys = "";
                     arrForEach(thePayload.apiKeys, function (apiKey) {
                         if (apiQsKeys.length > 0) {
@@ -3297,14 +3364,14 @@
                         }
                         apiQsKeys += apiKey;
                     });
-                    _addRequestDetails(requestDetails, strApiKey, apiQsKeys, useHeaders);
-                    _addRequestDetails(requestDetails, strUploadTime, dateNow().toString(), useHeaders);
+                    _addRequestDetails(requestDetails, STR_API_KEY, apiQsKeys, useHeaders);
+                    _addRequestDetails(requestDetails, STR_UPLOAD_TIME, dateNow().toString(), useHeaders);
                     var msfpc = _getMsfpc(thePayload);
                     if (isValueAssigned(msfpc)) {
                         requestDetails.url += "&ext.intweb.msfpc=" + msfpc;
                     }
                     if (_clockSkewManager.shouldAddClockSkewHeaders()) {
-                        _addRequestDetails(requestDetails, strTimeDeltaToApply, _clockSkewManager.getClockSkewHeaderValue(), useHeaders);
+                        _addRequestDetails(requestDetails, STR_TIME_DELTA_TO_APPLY, _clockSkewManager.getClockSkewHeaderValue(), useHeaders);
                     }
                     if (_core.getWParam) {
                         var wParam = _core.getWParam();
@@ -3366,11 +3433,11 @@
                                 orgPayloadData.disableXhrSync = !!_disableXhrSync;
                             }
                             if (useHeaders_1) {
-                                if (!_hasHeader(orgPayloadData.headers, strCacheControl)) {
-                                    orgPayloadData.headers[strCacheControl] = defaultCacheControl;
+                                if (!_hasHeader(orgPayloadData.headers, STR_CACHE_CONTROL)) {
+                                    orgPayloadData.headers[STR_CACHE_CONTROL] = DEFAULT_CACHE_CONTROL;
                                 }
-                                if (!_hasHeader(orgPayloadData.headers, strContentTypeHeader)) {
-                                    orgPayloadData.headers[strContentTypeHeader] = defaultContentType;
+                                if (!_hasHeader(orgPayloadData.headers, STR_CONTENT_TYPE_HEADER)) {
+                                    orgPayloadData.headers[STR_CONTENT_TYPE_HEADER] = DEFAULT_CONTENT_TYPE;
                                 }
                             }
                             var sender = null;
@@ -3388,7 +3455,7 @@
                                         }
                                     }
                                     catch (ex) {
-                                        _postManager.diagLog().warnToConsole("Unexpected exception sending payload. Ex:" + dumpObj(ex));
+                                        _warnToConsole(_logger, "Unexpected exception sending payload. Ex:" + dumpObj(ex));
                                         _doOnComplete(onComplete, 0, {});
                                     }
                                 };
@@ -3456,9 +3523,9 @@
                         var shouldRetry = true;
                         if (typeof status !== strShimUndefined) {
                             if (headers) {
-                                _clockSkewManager.setClockSkew(headers[strTimeDeltaHeader]);
-                                var killDuration = headers[strKillDurationHeader] || headers["kill-duration-seconds"];
-                                arrForEach(_killSwitch.setKillSwitchTenants(headers[strKillTokensHeader], killDuration), function (killToken) {
+                                _clockSkewManager.setClockSkew(headers[STR_TIME_DELTA_HEADER]);
+                                var killDuration = headers[STR_KILL_DURATION_HEADER] || headers["kill-duration-seconds"];
+                                arrForEach(_killSwitch.setKillSwitchTenants(headers[STR_KILL_TOKENS_HEADER], killDuration), function (killToken) {
                                     arrForEach(thePayload.batches, function (theBatch) {
                                         if (theBatch.iKey() === killToken) {
                                             droppedBatches = droppedBatches || [];
@@ -3585,13 +3652,13 @@
                                 responseHandlers[i](responseText);
                             }
                             catch (e) {
-                                _throwInternal(_postManager.diagLog(), 1 , 519 , "Response handler failed: " + e);
+                                _throwInternal(_logger, 1 , 519 , "Response handler failed: " + e);
                             }
                         }
                         if (responseText) {
                             var response = JSON.parse(responseText);
-                            if (isValueAssigned(response.webResult) && isValueAssigned(response.webResult[strMsfpc])) {
-                                _cookieMgr.set("MSFPC", response.webResult[strMsfpc], 365 * 86400);
+                            if (isValueAssigned(response.webResult) && isValueAssigned(response.webResult[STR_MSFPC])) {
+                                _cookieMgr.set("MSFPC", response.webResult[STR_MSFPC], 365 * 86400);
                             }
                         }
                     }
@@ -3609,7 +3676,7 @@
                                         theAction_1.call(actions, theBatches, batchReason, isSyncRequest_1, sendType);
                                     }
                                     catch (e) {
-                                        _throwInternal(_postManager.diagLog(), 1 , 74 , "send request notification failed: " + e);
+                                        _throwInternal(_logger, 1 , 74 , "send request notification failed: " + e);
                                     }
                                 }, sendSync || isSyncRequest_1, 0);
                             }, function () { return ({ batches: _createDebugBatches(theBatches), reason: batchReason, isSync: isSyncRequest_1, sendSync: sendSync, sendType: sendType }); }, !isSyncRequest_1);
@@ -3619,21 +3686,22 @@
                 function _getNotificationAction(reason) {
                     var action = _eventActionMap[reason];
                     if (!isValueAssigned(action)) {
-                        action = strOther;
+                        action = STR_OTHER;
                         if (reason >= 9000  && reason <= 9999 ) {
-                            action = strResponseFail;
+                            action = STR_RESPONSE_FAIL;
                         }
                         else if (reason >= 8000  && reason <= 8999 ) {
-                            action = strDropped;
+                            action = STR_DROPPED;
                         }
                         else if (reason >= 1000  && reason <= 1999 ) {
-                            action = strSending;
+                            action = STR_SENDING;
                         }
                     }
                     return action;
                 }
             });
         }
+        HttpManager.__ieDyn=1;
         return HttpManager;
     }());
 
@@ -3673,7 +3741,7 @@
             var _this = _super.call(this) || this;
             _this.identifier = "PostChannel";
             _this.priority = 1011;
-            _this.version = '3.2.2';
+            _this.version = '3.2.5';
             var _config;
             var _isTeardownCalled = false;
             var _flushCallbackQueue = [];
@@ -3698,7 +3766,6 @@
             var _delayedBatchReason;
             var _optimizeObject = true;
             var _isPageUnloadTriggered = false;
-            var _disableXhrSync = false;
             var _maxEventSendAttempts = MaxSendAttempts;
             var _maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
             var _evtNamespace;
@@ -3730,7 +3797,6 @@
                             if (_config.autoFlushEventsLimit > 0) {
                                 _autoFlushEventsLimit = _config.autoFlushEventsLimit;
                             }
-                            _disableXhrSync = _config.disableXhrSync;
                             if (isNumber(_config[strMaxEventRetryAttempts])) {
                                 _maxEventSendAttempts = _config[strMaxEventRetryAttempts];
                             }
@@ -3824,11 +3890,11 @@
                     if (!event.latency) {
                         event.latency = 1 ;
                     }
-                    if (event.ext && event.ext["trace"]) {
-                        delete (event.ext["trace"]);
+                    if (event.ext && event.ext[STR_TRACE]) {
+                        delete (event.ext[STR_TRACE]);
                     }
-                    if (event.ext && event.ext["user"] && event.ext["user"]["id"]) {
-                        delete (event.ext["user"]["id"]);
+                    if (event.ext && event.ext[STR_USER] && event.ext[STR_USER]["id"]) {
+                        delete (event.ext[STR_USER]["id"]);
                     }
                     if (_optimizeObject) {
                         event.ext = optimizeObject(event.ext);
@@ -3938,13 +4004,13 @@
                 _self.flush = function (async, callback, sendReason) {
                     if (async === void 0) { async = true; }
                     if (!_paused) {
-                        _clearScheduledTimer();
                         sendReason = sendReason || 1 ;
                         if (async) {
-                            _queueBatches(1 , 0 , sendReason);
-                            _resetQueueCounts();
                             if (_flushCallbackTimerId == null) {
+                                _clearScheduledTimer();
+                                _queueBatches(1 , 0 , sendReason);
                                 _flushCallbackTimerId = _createTimer(function () {
+                                    _flushCallbackTimerId = null;
                                     _flushImpl(callback, sendReason);
                                 }, 0);
                             }
@@ -3953,15 +4019,19 @@
                             }
                         }
                         else {
+                            var cleared = _clearScheduledTimer();
                             _sendEventsForLatencyAndAbove(1 , 1 , sendReason);
                             if (callback !== null && callback !== undefined) {
                                 callback();
                             }
+                            if (cleared) {
+                                _scheduleTimer();
+                            }
                         }
                     }
                 };
                 _self.setMsaAuthTicket = function (ticket) {
-                    _httpManager.addHeader(strMsaDeviceTicket, ticket);
+                    _httpManager.addHeader(STR_MSA_DEVICE_TICKET, ticket);
                 };
                 _self.hasEvents = _hasEvents;
                 _self._setTransmitProfile = function (profileName) {
@@ -4047,7 +4117,6 @@
                     _delayedBatchReason = null;
                     _optimizeObject = true;
                     _isPageUnloadTriggered = false;
-                    _disableXhrSync = false;
                     _maxEventSendAttempts = MaxSendAttempts;
                     _maxUnloadEventSendAttempts = MaxSyncUnloadSendAttempts;
                     _evtNamespace = null;
@@ -4079,7 +4148,9 @@
                         _timeoutWrapper.clear(_scheduledTimerId);
                         _scheduledTimerId = null;
                         _timerCount = 0;
+                        return true;
                     }
+                    return false;
                 }
                 function _releaseAllQueues(sendType, sendReason) {
                     _clearScheduledTimer();
@@ -4243,18 +4314,20 @@
                 }
                 function _flushImpl(callback, sendReason) {
                     _sendEventsForLatencyAndAbove(1 , 0 , sendReason);
+                    _resetQueueCounts();
                     _waitForIdleManager(function () {
                         if (callback) {
                             callback();
                         }
                         if (_flushCallbackQueue.length > 0) {
-                            _flushCallbackTimerId = _createTimer(function () { return _flushImpl(_flushCallbackQueue.shift(), sendReason); }, 0);
+                            _flushCallbackTimerId = _createTimer(function () {
+                                _flushCallbackTimerId = null;
+                                _flushImpl(_flushCallbackQueue.shift(), sendReason);
+                            }, 0);
                         }
                         else {
                             _flushCallbackTimerId = null;
-                            if (_hasEvents()) {
-                                _scheduleTimer();
-                            }
+                            _scheduleTimer();
                         }
                     });
                 }
@@ -4264,6 +4337,7 @@
                     }
                     else {
                         _flushCallbackTimerId = _createTimer(function () {
+                            _flushCallbackTimerId = null;
                             _waitForIdleManager(callback);
                         }, FlushCheckTimer);
                     }
@@ -4387,6 +4461,7 @@
             });
             return _this;
         }
+        PostChannel.__ieDyn=1;
         return PostChannel;
     }(BaseTelemetryPlugin));
     var PostChannel$1 = PostChannel;
@@ -4399,4 +4474,4 @@
     (function(obj, prop, descriptor) { /* ai_es3_polyfil defineProperty */ var func = Object["defineProperty"]; if (func) { try { return func(obj, prop, descriptor); } catch(e) { /* IE8 defines defineProperty, but will throw */ } } if (descriptor && typeof descriptor.value !== undefined) { obj[prop] = descriptor.value; } return obj; })(exports, '__esModule', { value: true });
 
 })(this.oneDS = this.oneDS || {});
-//# sourceMappingURL=ms.post-3.2.2.gbl.js.map
+//# sourceMappingURL=ms.post-3.2.5.gbl.js.map