@microsoft/applicationinsights-clickanalytics-js 2.8.5-nightly.2206-04 → 2.8.5-nightly.2206-06

package/browser/ai.clck.2.gbl.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Click Analytics, 2.8.5-nightly.2206-04
+ * Application Insights JavaScript SDK - Click Analytics, 2.8.5-nightly.2206-06
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 this.Microsoft = this.Microsoft || {};
@@ -101,7 +101,7 @@ this.Microsoft = this.Microsoft || {};
      * Copyright (c) Microsoft and contributors. All rights reserved.
      */
     var Constructor = 'constructor';
-    var Prototype$1 = 'prototype';
+    var Prototype = 'prototype';
     var strFunction = 'function';
     var DynInstFuncTable = '_dynInstFuncs';
     var DynProxyTag = '_isDynProxy';
@@ -121,13 +121,13 @@ this.Microsoft = this.Microsoft || {};
     var _objGetOwnProps = Obj["getOwnPropertyNames"];
     var _dynamicNames = 0;
     function _hasOwnProperty(obj, prop) {
-        return obj && Obj[Prototype$1].hasOwnProperty.call(obj, prop);
+        return obj && Obj[Prototype].hasOwnProperty.call(obj, prop);
     }
     function _isObjectOrArrayPrototype(target) {
-        return target && (target === Obj[Prototype$1] || target === Array[Prototype$1]);
+        return target && (target === Obj[Prototype] || target === Array[Prototype]);
     }
     function _isObjectArrayOrFunctionPrototype(target) {
-        return _isObjectOrArrayPrototype(target) || target === Function[Prototype$1];
+        return _isObjectOrArrayPrototype(target) || target === Function[Prototype];
     }
     function _getObjProto$1(target) {
         var newProto;
@@ -135,7 +135,7 @@ this.Microsoft = this.Microsoft || {};
             if (_objGetPrototypeOf$1) {
                 return _objGetPrototypeOf$1(target);
             }
-            var curProto = target[str__Proto$1] || target[Prototype$1] || (target[Constructor] ? target[Constructor][Prototype$1] : null);
+            var curProto = target[str__Proto$1] || target[Prototype] || (target[Constructor] ? target[Constructor][Prototype] : null);
             newProto = target[DynProtoBaseProto] || curProto;
             if (!_hasOwnProperty(target, DynProtoBaseProto)) {
                 delete target[DynProtoCurrent];
@@ -302,16 +302,16 @@ this.Microsoft = this.Microsoft || {};
         return true;
     }
     function _getObjName(target, unknownValue) {
-        if (_hasOwnProperty(target, Prototype$1)) {
+        if (_hasOwnProperty(target, Prototype)) {
             return target.name || unknownValue || UnknownValue;
         }
         return (((target || {})[Constructor]) || {}).name || unknownValue || UnknownValue;
     }
     function dynamicProto(theClass, target, delegateFunc, options) {
-        if (!_hasOwnProperty(theClass, Prototype$1)) {
+        if (!_hasOwnProperty(theClass, Prototype)) {
             _throwTypeError("theClass is an invalid class definition.");
         }
-        var classProto = theClass[Prototype$1];
+        var classProto = theClass[Prototype];
         if (!_checkPrototype(classProto, target)) {
             _throwTypeError("[" + _getObjName(theClass) + "] is not in class hierarchy of [" + _getObjName(target) + "]");
         }
@@ -344,14 +344,55 @@ this.Microsoft = this.Microsoft || {};
     };
     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$1 = "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$1 = "length";
+    var _DYN_TIME = "time";
+    var _DYN_PROCESS_NEXT = "processNext";
+    var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
+    var _DYN_GET_PLUGIN = "getPlugin";
+    var _DYN_SPLICE = "splice";
+    var _DYN_TEARDOWN = "teardown";
+    var _DYN_MESSAGE_ID = "messageId";
+    var _DYN_MESSAGE = "message";
+    var _DYN_IS_ASYNC = "isAsync";
+    var _DYN__DO_TEARDOWN = "_doTeardown";
+    var _DYN_UPDATE = "update";
+    var _DYN_GET_NEXT = "getNext";
+    var _DYN_DIAG_LOG = "diagLog";
+    var _DYN_SET_NEXT_PLUGIN = "setNextPlugin";
+    var _DYN_CREATE_NEW = "createNew";
+    var _DYN_INDEX_OF$1 = "indexOf";
+    var _DYN_USER_AGENT = "userAgent";
+    var _DYN_SPLIT = "split";
+    var _DYN_REPLACE = "replace";
+    var _DYN_NODE_TYPE = "nodeType";
+    var _DYN_APPLY = "apply";
+    var _DYN_ENABLE_DEBUG_EXCEPTI4 = "enableDebugExceptions";
+    var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
+    var _DYN_TO_LOWER_CASE = "toLowerCase";
+    var _DYN_CALL = "call";
+    var _DYN_TYPE = "type";
+    var _DYN_HANDLER = "handler";
+    var _DYN_IS_CHILD_EVT = "isChildEvt";
+    var _DYN_GET_CTX = "getCtx";
+    var _DYN_SET_CTX = "setCtx";
+    var _DYN_COMPLETE = "complete";
+
+    var STR_EMPTY = "";
+    var STR_CORE = "core";
+    var STR_DISABLED = "disabled";
+    var STR_EXTENSION_CONFIG = "extensionConfig";
+    var STR_PROCESS_TELEMETRY = "processTelemetry";
+    var STR_PRIORITY = "priority";
+    var STR_ERROR_TO_CONSOLE = "errorToConsole";
+    var STR_WARN_TO_CONSOLE = "warnToConsole";
+    var STR_GET_PERF_MGR = "getPerfMgr";
 
     var strToISOString = "toISOString";
     var cStrEndsWith = "endsWith";
@@ -373,7 +414,7 @@ this.Microsoft = this.Microsoft || {};
     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_$])/;
@@ -397,7 +438,7 @@ this.Microsoft = this.Microsoft || {};
         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);
@@ -408,11 +449,11 @@ this.Microsoft = this.Microsoft || {};
     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;
             });
         }
@@ -421,24 +462,24 @@ this.Microsoft = this.Microsoft || {};
     function objForEachKey(target, callbackfn) {
         if (target) {
             for (var prop in target) {
-                if (ObjHasOwnProperty.call(target, prop)) {
-                    callbackfn.call(target, prop, target[prop]);
+                if (ObjHasOwnProperty[_DYN_CALL ](target, prop)) {
+                    callbackfn[_DYN_CALL ](target, prop, target[prop]);
                 }
             }
         }
     }
     function strContains(value, search) {
         if (value && search) {
-            return value.indexOf(search) !== -1;
+            return value[_DYN_INDEX_OF$1 ](search) !== -1;
         }
         return false;
     }
     var isArray = _isArray || _isArrayPoly;
     function _isArrayPoly(obj) {
-        return !!(obj && _objToString.call(obj) === "[object Array]");
+        return !!(obj && _objToString[_DYN_CALL ](obj) === "[object Array]");
     }
     function isError(obj) {
-        return !!(obj && _objToString.call(obj) === "[object Error]");
+        return !!(obj && _objToString[_DYN_CALL ](obj) === "[object Error]");
     }
     function isString(value) {
         return typeof value === "string";
@@ -454,20 +495,20 @@ this.Microsoft = this.Microsoft || {};
                 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$1 ];
         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;
                     }
                 }
@@ -496,15 +537,15 @@ this.Microsoft = this.Microsoft || {};
         }
         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$1 ];
             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]);
                 }
             }
         }
@@ -551,9 +592,9 @@ this.Microsoft = this.Microsoft || {};
     }
     function getExceptionName(object) {
         if (isError(object)) {
-            return object.name;
+            return object[_DYN_NAME$1 ];
         }
-        return strEmpty;
+        return STR_EMPTY;
     }
     function setValue(target, field, value, valChk, srcChk) {
         var theValue = value;
@@ -566,6 +607,9 @@ this.Microsoft = this.Microsoft || {};
         }
         return theValue;
     }
+    function getCfgValue(theValue, defaultValue) {
+        return !isNullOrUndefined(theValue) ? theValue : defaultValue;
+    }
     function throwError(message) {
         throw new Error(message);
     }
@@ -584,7 +628,7 @@ this.Microsoft = this.Microsoft || {};
                 src = srcFunc();
             }
             if (src) {
-                return src[funcName].apply(src, originalArguments);
+                return src[funcName][_DYN_APPLY ](src, originalArguments);
             }
         };
     }
@@ -598,7 +642,7 @@ this.Microsoft = this.Microsoft || {};
     function objExtend(obj1, obj2, obj3, obj4, obj5, obj6) {
         var theArgs = arguments;
         var extended = theArgs[0] || {};
-        var argLen = theArgs.length;
+        var argLen = theArgs[_DYN_LENGTH$1 ];
         var deep = false;
         var idx = 1;
         if (argLen > 0 && isBoolean(extended)) {
@@ -614,7 +658,7 @@ this.Microsoft = this.Microsoft || {};
             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;
                 }
@@ -738,18 +782,18 @@ this.Microsoft = this.Microsoft || {};
     }
     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)[_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;
         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$1 ] + "'";
         }
         else if (hasJSON()) {
             propertyValueDump = getJSON().stringify(object);
@@ -776,13 +820,11 @@ this.Microsoft = this.Microsoft || {};
     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) + "\"";
         }
-        return strEmpty;
+        return STR_EMPTY;
     }
     function _logToConsole(func, message) {
         var theConsole = getConsole();
@@ -800,23 +842,23 @@ this.Microsoft = this.Microsoft || {};
         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;
             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) +
+                (properties ? " props:" + _sanitizeDiagnosticText(strProps) : STR_EMPTY);
+            _self[_DYN_MESSAGE ] += diagnosticText;
         }
         _InternalLogMessage.dataType = "MessageData";
         return _InternalLogMessage;
     }());
     function safeGetLogger(core, config) {
-        return (core || {}).logger || new DiagnosticLogger(config);
+        return (core || {})[_DYN_LOGGER ] || new DiagnosticLogger(config);
     }
     var DiagnosticLogger = /** @class */ (function () {
         function DiagnosticLogger(config) {
@@ -824,48 +866,49 @@ this.Microsoft = this.Microsoft || {};
             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);
                 };
@@ -873,12 +916,13 @@ this.Microsoft = this.Microsoft || {};
                     _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;
                     }
@@ -886,38 +930,37 @@ this.Microsoft = this.Microsoft || {};
                         _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);
                     }
                 }
             });
@@ -925,20 +968,25 @@ this.Microsoft = this.Microsoft || {};
         DiagnosticLogger.__ieDyn=1;
         return DiagnosticLogger;
     }());
+    function _getLogger(logger) {
+        return (logger || new DiagnosticLogger());
+    }
     function _throwInternal(logger, severity, msgId, msg, properties, isUserAct) {
         if (isUserAct === void 0) { isUserAct = false; }
-        (logger || new DiagnosticLogger()).throwInternal(severity, msgId, msg, properties, isUserAct);
+        _getLogger(logger).throwInternal(severity, msgId, msg, properties, isUserAct);
     }
 
     var strExecutionContextKey = "ctx";
+    var strParentContextKey = "ParentContextKey";
+    var strChildrenContextKey = "ChildrenContextKey";
     var PerfEvent = /** @class */ (function () {
         function PerfEvent(name, payloadDetails, isAsync) {
             var _self = this;
             var accessorDefined = false;
             _self.start = dateNow();
-            _self.name = name;
-            _self.isAsync = isAsync;
-            _self.isChildEvt = function () { return false; };
+            _self[_DYN_NAME$1 ] = 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 () {
@@ -949,24 +997,24 @@ this.Microsoft = this.Microsoft || {};
                     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 {
@@ -975,20 +1023,20 @@ this.Microsoft = this.Microsoft || {};
                     }
                 }
             };
-            _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$1 ]; 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();
                 }
@@ -1002,40 +1050,40 @@ this.Microsoft = this.Microsoft || {};
     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);
                 }
             }
         }
@@ -1097,8 +1145,8 @@ this.Microsoft = this.Microsoft || {};
         var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
         var number = random32() >>> 0;
         var chars = 0;
-        var result = strEmpty;
-        while (result.length < maxLength) {
+        var result = STR_EMPTY;
+        while (result[_DYN_LENGTH$1 ] < maxLength) {
             chars++;
             result += base64chars.charAt(number & 0x3F);
             number >>>= 6;
@@ -1111,7 +1159,7 @@ this.Microsoft = this.Microsoft || {};
     }
 
     var _objDefineProperty = ObjDefineProperty;
-    var version = "2.8.5-nightly.2206-04";
+    var version = "2.8.5-nightly.2206-06";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _createAccessor(target, prop, value) {
@@ -1130,7 +1178,7 @@ this.Microsoft = this.Microsoft || {};
         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];
@@ -1150,11 +1198,11 @@ this.Microsoft = this.Microsoft || {};
     }
     function createUniqueNamespace(name, includeVersion) {
         if (includeVersion === void 0) { includeVersion = false; }
-        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : "") + instanceName);
+        return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
     }
     function createElmNodeData(name) {
         var data = {
-            id: createUniqueNamespace("_aiData-" + (name || "") + "." + version),
+            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
             accept: function (target) {
                 return _canAcceptData(target);
             },
@@ -1196,16 +1244,17 @@ this.Microsoft = this.Microsoft || {};
     var elmNodeData = createElmNodeData("events");
     var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
     function _normalizeNamespace(name) {
-        if (name && name.replace) {
-            return name.replace(/^\s*\.*|\.*\s*$/g, "");
+        if (name && name[_DYN_REPLACE ]) {
+            return name.replace(/^\s*\.*|\.*\s*$/g, STR_EMPTY);
         }
         return name;
     }
     function _getEvtNamespace(eventName, evtNamespace) {
+        var _a;
         if (evtNamespace) {
-            var theNamespace_1 = "";
+            var theNamespace_1 = STR_EMPTY;
             if (isArray(evtNamespace)) {
-                theNamespace_1 = "";
+                theNamespace_1 = STR_EMPTY;
                 arrForEach(evtNamespace, function (name) {
                     name = _normalizeNamespace(name);
                     if (name) {
@@ -1223,14 +1272,14 @@ this.Microsoft = this.Microsoft || {};
                 if (theNamespace_1[0] !== ".") {
                     theNamespace_1 = "." + theNamespace_1;
                 }
-                eventName = (eventName || "") + theNamespace_1;
+                eventName = (eventName || STR_EMPTY) + theNamespace_1;
             }
         }
-        var parsedEvent = (eventNamespace.exec(eventName || "") || []);
-        return {
-            type: parsedEvent[1],
-            ns: ((parsedEvent[2] || "").replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, "").split(".").sort()).join(".")
-        };
+        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);
+        return _a = {},
+            _a[_DYN_TYPE ] = parsedEvent[1],
+            _a.ns = ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT ](".").sort()).join("."),
+            _a;
     }
     function _getRegisteredEvents(target, evtName, addDefault) {
         if (addDefault === void 0) { addDefault = true; }
@@ -1242,53 +1291,53 @@ this.Microsoft = this.Microsoft || {};
         return registeredEvents;
     }
     function _doDetach(obj, evtName, handlerRef, useCapture) {
-        if (obj && evtName && evtName.type) {
+        if (obj && evtName && evtName[_DYN_TYPE ]) {
             if (obj[strRemoveEventListener]) {
-                obj[strRemoveEventListener](evtName.type, handlerRef, useCapture);
+                obj[strRemoveEventListener](evtName[_DYN_TYPE ], handlerRef, useCapture);
             }
             else if (obj[strDetachEvent]) {
-                obj[strDetachEvent](strOnPrefix + evtName.type, handlerRef);
+                obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
             }
         }
     }
     function _doAttach(obj, evtName, handlerRef, useCapture) {
         var result = false;
-        if (obj && evtName && evtName.type && handlerRef) {
+        if (obj && evtName && evtName[_DYN_TYPE ] && handlerRef) {
             if (obj[strAddEventHelper]) {
-                obj[strAddEventHelper](evtName.type, handlerRef, useCapture);
+                obj[strAddEventHelper](evtName[_DYN_TYPE ], handlerRef, useCapture);
                 result = true;
             }
             else if (obj[strAttachEvent]) {
-                obj[strAttachEvent](strOnPrefix + evtName.type, handlerRef);
+                obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
                 result = true;
             }
         }
         return result;
     }
     function _doUnregister(target, events, evtName, unRegFn) {
-        var idx = events.length;
+        var idx = events[_DYN_LENGTH$1 ];
         while (idx--) {
             var theEvent = events[idx];
             if (theEvent) {
                 if (!evtName.ns || evtName.ns === theEvent.evtName.ns) {
                     if (!unRegFn || unRegFn(theEvent)) {
-                        _doDetach(target, theEvent.evtName, theEvent.handler, theEvent.capture);
-                        events.splice(idx, 1);
+                        _doDetach(target, theEvent.evtName, theEvent[_DYN_HANDLER ], theEvent.capture);
+                        events[_DYN_SPLICE ](idx, 1);
                     }
                 }
             }
         }
     }
     function _unregisterEvents(target, evtName, unRegFn) {
-        if (evtName.type) {
-            _doUnregister(target, _getRegisteredEvents(target, evtName.type), evtName, unRegFn);
+        if (evtName[_DYN_TYPE ]) {
+            _doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE ]), evtName, unRegFn);
         }
         else {
             var eventCache = elmNodeData.get(target, strEvents, {});
             objForEachKey(eventCache, function (evtType, events) {
                 _doUnregister(target, events, evtName, unRegFn);
             });
-            if (objKeys(eventCache).length === 0) {
+            if (objKeys(eventCache)[_DYN_LENGTH$1 ] === 0) {
                 elmNodeData.kill(target, strEvents);
             }
         }
@@ -1302,7 +1351,7 @@ this.Microsoft = this.Microsoft || {};
             else {
                 newNamespaces = [theNamespace, namespaces];
             }
-            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns).split(".");
+            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT ](".");
         }
         else {
             newNamespaces = theNamespace;
@@ -1310,6 +1359,7 @@ this.Microsoft = this.Microsoft || {};
         return newNamespaces;
     }
     function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
+        var _a;
         if (useCapture === void 0) { useCapture = false; }
         var result = false;
         if (target) {
@@ -1317,13 +1367,14 @@ this.Microsoft = this.Microsoft || {};
                 var evtName = _getEvtNamespace(eventName, evtNamespace);
                 result = _doAttach(target, evtName, handlerRef, useCapture);
                 if (result && elmNodeData.accept(target)) {
-                    var registeredEvent = {
-                        guid: _guid++,
-                        evtName: evtName,
-                        handler: handlerRef,
-                        capture: useCapture
-                    };
-                    _getRegisteredEvents(target, evtName.type).push(registeredEvent);
+                    var registeredEvent = (_a = {
+                            guid: _guid++,
+                            evtName: evtName
+                        },
+                        _a[_DYN_HANDLER ] = handlerRef,
+                        _a.capture = useCapture,
+                        _a);
+                    _getRegisteredEvents(target, evtName.type)[_DYN_PUSH ](registeredEvent);
                 }
             }
             catch (e) {
@@ -1338,7 +1389,7 @@ this.Microsoft = this.Microsoft || {};
                 var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
                 var found_1 = false;
                 _unregisterEvents(target, evtName_1, function (regEvent) {
-                    if ((evtName_1.ns && !handlerRef) || regEvent.handler === handlerRef) {
+                    if ((evtName_1.ns && !handlerRef) || regEvent[_DYN_HANDLER ] === handlerRef) {
                         found_1 = true;
                         return true;
                     }
@@ -1353,7 +1404,6 @@ this.Microsoft = this.Microsoft || {};
         }
     }
 
-    var strDoUnload = "_doUnload";
     var pluginStateData = createElmNodeData("plugin");
     function _getPluginState(plugin) {
         return pluginStateData.get(plugin, "state", {}, true);
@@ -1361,12 +1411,12 @@ this.Microsoft = this.Microsoft || {};
     function unloadComponents(components, unloadCtx, unloadState, asyncCallback) {
         var idx = 0;
         function _doUnload() {
-            while (idx < components.length) {
+            while (idx < components[_DYN_LENGTH$1 ]) {
                 var component = components[idx++];
                 if (component) {
-                    var func = component[strDoUnload] || component[strDoTeardown];
+                    var func = component._doUnload || component[_DYN__DO_TEARDOWN ];
                     if (isFunction(func)) {
-                        if (func.call(component, unloadCtx, unloadState, _doUnload) === true) {
+                        if (func[_DYN_CALL ](component, unloadCtx, unloadState, _doUnload) === true) {
                             return true;
                         }
                     }
@@ -1382,12 +1432,12 @@ this.Microsoft = this.Microsoft || {};
     var _chainId = 0;
     function _getNextProxyStart(proxy, core, startAt) {
         while (proxy) {
-            if (proxy.getPlugin() === startAt) {
+            if (proxy[_DYN_GET_PLUGIN ]() === startAt) {
                 return proxy;
             }
-            proxy = proxy.getNext();
+            proxy = proxy[_DYN_GET_NEXT ]();
         }
-        return createTelemetryProxyChain([startAt], core.config || {}, core);
+        return createTelemetryProxyChain([startAt], core[_DYN_CONFIG ] || {}, core);
     }
     function _createInternalContext(telemetryChain, config, core, startAt) {
         var _nextProxy = null;
@@ -1428,7 +1478,7 @@ this.Microsoft = this.Microsoft || {};
                 args[_i - 2] = arguments[_i];
             }
             if (onComplete) {
-                _onComplete.push({
+                _onComplete[_DYN_PUSH ]({
                     func: onComplete,
                     self: !isUndefined(that) ? that : context.ctx,
                     args: args
@@ -1437,16 +1487,16 @@ this.Microsoft = this.Microsoft || {};
         }
         function _moveNext() {
             var nextProxy = _nextProxy;
-            _nextProxy = nextProxy ? nextProxy.getNext() : null;
+            _nextProxy = nextProxy ? nextProxy[_DYN_GET_NEXT ]() : null;
             if (!nextProxy) {
                 var onComplete = _onComplete;
-                if (onComplete && onComplete.length > 0) {
+                if (onComplete && onComplete[_DYN_LENGTH$1 ] > 0) {
                     arrForEach(onComplete, function (completeDetails) {
                         try {
-                            completeDetails.func.call(completeDetails.self, completeDetails.args);
+                            completeDetails.func[_DYN_CALL ](completeDetails.self, completeDetails.args);
                         }
                         catch (e) {
-                            _throwInternal(core.logger, 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
+                            _throwInternal(core[_DYN_LOGGER ], 2 , 73 , "Unexpected Exception during onComplete - " + dumpObj(e));
                         }
                     });
                     _onComplete = [];
@@ -1459,7 +1509,7 @@ this.Microsoft = this.Microsoft || {};
             if (mergeDefault === void 0) { mergeDefault = 0 ; }
             var theConfig;
             if (config) {
-                var extConfig = config.extensionConfig;
+                var extConfig = config[STR_EXTENSION_CONFIG ];
                 if (extConfig && identifier) {
                     theConfig = extConfig[identifier];
                 }
@@ -1500,7 +1550,7 @@ this.Microsoft = this.Microsoft || {};
         function _iterateChain(cb) {
             var nextPlugin;
             while (!!(nextPlugin = context._next())) {
-                var plugin = nextPlugin.getPlugin();
+                var plugin = nextPlugin[_DYN_GET_PLUGIN ]();
                 if (plugin) {
                     cb(plugin);
                 }
@@ -1513,7 +1563,7 @@ this.Microsoft = this.Microsoft || {};
         var context = internalContext.ctx;
         function _processNext(env) {
             var nextPlugin = internalContext._next();
-            nextPlugin && nextPlugin.processTelemetry(env, context);
+            nextPlugin && nextPlugin[STR_PROCESS_TELEMETRY ](env, context);
             return !nextPlugin;
         }
         function _createNew(plugins, startAt) {
@@ -1521,14 +1571,14 @@ this.Microsoft = this.Microsoft || {};
             if (isArray(plugins)) {
                 plugins = createTelemetryProxyChain(plugins, config, core, startAt);
             }
-            return createProcessTelemetryContext(plugins || context.getNext(), config, core, startAt);
+            return createProcessTelemetryContext(plugins || context[_DYN_GET_NEXT ](), config, core, startAt);
         }
-        context.processNext = _processNext;
-        context.createNew = _createNew;
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
         return context;
     }
     function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
-        var config = core.config || {};
+        var config = core[_DYN_CONFIG ] || {};
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(unloadState) {
@@ -1541,20 +1591,20 @@ this.Microsoft = this.Microsoft || {};
             if (isArray(plugins)) {
                 plugins = createTelemetryProxyChain(plugins, config, core, startAt);
             }
-            return createProcessTelemetryUnloadContext(plugins || context.getNext(), core, startAt);
+            return createProcessTelemetryUnloadContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
         }
-        context.processNext = _processNext;
-        context.createNew = _createNew;
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
         return context;
     }
     function createProcessTelemetryUpdateContext(telemetryChain, core, startAt) {
-        var config = core.config || {};
+        var config = core[_DYN_CONFIG ] || {};
         var internalContext = _createInternalContext(telemetryChain, config, core, startAt);
         var context = internalContext.ctx;
         function _processNext(updateState) {
             return context.iterate(function (plugin) {
-                if (isFunction(plugin.update)) {
-                    plugin.update(context, updateState);
+                if (isFunction(plugin[_DYN_UPDATE ])) {
+                    plugin[_DYN_UPDATE ](context, updateState);
                 }
             });
         }
@@ -1563,22 +1613,22 @@ this.Microsoft = this.Microsoft || {};
             if (isArray(plugins)) {
                 plugins = createTelemetryProxyChain(plugins, config, core, startAt);
             }
-            return createProcessTelemetryUpdateContext(plugins || context.getNext(), core, startAt);
+            return createProcessTelemetryUpdateContext(plugins || context[_DYN_GET_NEXT ](), core, startAt);
         }
-        context.processNext = _processNext;
-        context.createNew = _createNew;
+        context[_DYN_PROCESS_NEXT ] = _processNext;
+        context[_DYN_CREATE_NEW ] = _createNew;
         return context;
     }
     function createTelemetryProxyChain(plugins, config, core, startAt) {
         var firstProxy = null;
         var add = startAt ? false : true;
-        if (isArray(plugins) && plugins.length > 0) {
+        if (isArray(plugins) && plugins[_DYN_LENGTH$1 ] > 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;
@@ -1597,11 +1647,11 @@ this.Microsoft = this.Microsoft || {};
     }
     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++;
@@ -1633,17 +1683,17 @@ this.Microsoft = this.Microsoft || {};
         }
         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;
                         if (nextId) {
                             hasRunContext[nextId] = false;
                         }
@@ -1655,7 +1705,7 @@ this.Microsoft = this.Microsoft || {};
                             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);
@@ -1669,17 +1719,17 @@ this.Microsoft = this.Microsoft || {};
                     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) {
@@ -1687,20 +1737,20 @@ this.Microsoft = this.Microsoft || {};
                 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) {
@@ -1708,9 +1758,9 @@ this.Microsoft = this.Microsoft || {};
                 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;
                         }
                     }
@@ -1718,19 +1768,17 @@ this.Microsoft = this.Microsoft || {};
                 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) {
@@ -1739,7 +1787,7 @@ this.Microsoft = this.Microsoft || {};
                     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 = [];
@@ -1761,37 +1809,40 @@ this.Microsoft = this.Microsoft || {};
             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 {
@@ -1799,9 +1850,9 @@ this.Microsoft = this.Microsoft || {};
                     }
                     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;
@@ -1813,7 +1864,7 @@ this.Microsoft = this.Microsoft || {};
                     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) {
@@ -1830,30 +1881,30 @@ this.Microsoft = this.Microsoft || {};
                             _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;
@@ -1861,33 +1912,33 @@ this.Microsoft = this.Microsoft || {};
                 if (currentCtx === void 0) { currentCtx = null; }
                 var itemCtx = currentCtx;
                 if (!itemCtx) {
-                    var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self.core);
+                    var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self[STR_CORE ]);
                     if (_nextPlugin && _nextPlugin[strGetPlugin]) {
-                        itemCtx = rootCtx.createNew(null, _nextPlugin[strGetPlugin]);
+                        itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin[strGetPlugin]);
                     }
                     else {
-                        itemCtx = rootCtx.createNew(null, _nextPlugin);
+                        itemCtx = rootCtx[_DYN_CREATE_NEW ](null, _nextPlugin);
                     }
                 }
                 return itemCtx;
             }
             function _setDefaults(config, core, pluginChain) {
                 if (config) {
-                    setValue(config, strExtensionConfig, [], null, isNullOrUndefined);
+                    setValue(config, STR_EXTENSION_CONFIG, [], null, isNullOrUndefined);
                 }
                 if (!pluginChain && core) {
-                    pluginChain = core.getProcessTelContext().getNext();
+                    pluginChain = core[_DYN_GET_PROCESS_TEL_CONT0 ]()[_DYN_GET_NEXT ]();
                 }
                 var nextPlugin = _nextPlugin;
                 if (_nextPlugin && _nextPlugin[strGetPlugin]) {
                     nextPlugin = _nextPlugin[strGetPlugin]();
                 }
-                _self.core = core;
+                _self[STR_CORE ] = core;
                 _rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
             }
             function _initDefaults() {
                 _isinitialized = false;
-                _self.core = null;
+                _self[STR_CORE ] = null;
                 _rootCtx = null;
                 _nextPlugin = null;
                 _hooks = [];
@@ -1898,109 +1949,176 @@ this.Microsoft = this.Microsoft || {};
         return BaseTelemetryPlugin;
     }());
 
+    var _a;
+    var FAILED = "Failed";
+    var FAILED_MONITOR_AJAX = FAILED + "MonitorAjax";
+    var TRACK = "Track";
+    var START = "Start";
+    var STOP = "Stop";
+    var EVENT = "Event";
+    var AUTH_CONTEXT = "AuthContext";
+    var EXCEPTION = "Exception";
+    var LOCAL = "Local";
+    var SESSION = "Session";
+    var STORAGE = "Storage";
+    var BROWSER = "Browser";
+    var CANNOT = "Cannot";
+    var BUFFER = "Buffer";
+    var INSTRUMENTATION_KEY = "InstrumentationKey";
     createEnumStyle({
         CRITICAL: 1 ,
         WARNING: 2
     });
-    var _InternalMessageId = createEnumStyle({
-        BrowserDoesNotSupportLocalStorage: 0 ,
-        BrowserCannotReadLocalStorage: 1 ,
-        BrowserCannotReadSessionStorage: 2 ,
-        BrowserCannotWriteLocalStorage: 3 ,
-        BrowserCannotWriteSessionStorage: 4 ,
-        BrowserFailedRemovalFromLocalStorage: 5 ,
-        BrowserFailedRemovalFromSessionStorage: 6 ,
-        CannotSendEmptyTelemetry: 7 ,
-        ClientPerformanceMathError: 8 ,
-        ErrorParsingAISessionCookie: 9 ,
-        ErrorPVCalc: 10 ,
-        ExceptionWhileLoggingError: 11 ,
-        FailedAddingTelemetryToBuffer: 12 ,
-        FailedMonitorAjaxAbort: 13 ,
-        FailedMonitorAjaxDur: 14 ,
-        FailedMonitorAjaxOpen: 15 ,
-        FailedMonitorAjaxRSC: 16 ,
-        FailedMonitorAjaxSend: 17 ,
-        FailedMonitorAjaxGetCorrelationHeader: 18 ,
-        FailedToAddHandlerForOnBeforeUnload: 19 ,
-        FailedToSendQueuedTelemetry: 20 ,
-        FailedToReportDataLoss: 21 ,
-        FlushFailed: 22 ,
-        MessageLimitPerPVExceeded: 23 ,
-        MissingRequiredFieldSpecification: 24 ,
-        NavigationTimingNotSupported: 25 ,
-        OnError: 26 ,
-        SessionRenewalDateIsZero: 27 ,
-        SenderNotInitialized: 28 ,
-        StartTrackEventFailed: 29 ,
-        StopTrackEventFailed: 30 ,
-        StartTrackFailed: 31 ,
-        StopTrackFailed: 32 ,
-        TelemetrySampledAndNotSent: 33 ,
-        TrackEventFailed: 34 ,
-        TrackExceptionFailed: 35 ,
-        TrackMetricFailed: 36 ,
-        TrackPVFailed: 37 ,
-        TrackPVFailedCalc: 38 ,
-        TrackTraceFailed: 39 ,
-        TransmissionFailed: 40 ,
-        FailedToSetStorageBuffer: 41 ,
-        FailedToRestoreStorageBuffer: 42 ,
-        InvalidBackendResponse: 43 ,
-        FailedToFixDepricatedValues: 44 ,
-        InvalidDurationValue: 45 ,
-        TelemetryEnvelopeInvalid: 46 ,
-        CreateEnvelopeError: 47 ,
-        CannotSerializeObject: 48 ,
-        CannotSerializeObjectNonSerializable: 49 ,
-        CircularReferenceDetected: 50 ,
-        ClearAuthContextFailed: 51 ,
-        ExceptionTruncated: 52 ,
-        IllegalCharsInName: 53 ,
-        ItemNotInArray: 54 ,
-        MaxAjaxPerPVExceeded: 55 ,
-        MessageTruncated: 56 ,
-        NameTooLong: 57 ,
-        SampleRateOutOfRange: 58 ,
-        SetAuthContextFailed: 59 ,
-        SetAuthContextFailedAccountName: 60 ,
-        StringValueTooLong: 61 ,
-        StartCalledMoreThanOnce: 62 ,
-        StopCalledWithoutStart: 63 ,
-        TelemetryInitializerFailed: 64 ,
-        TrackArgumentsNotSpecified: 65 ,
-        UrlTooLong: 66 ,
-        SessionStorageBufferFull: 67 ,
-        CannotAccessCookie: 68 ,
-        IdTooLong: 69 ,
-        InvalidEvent: 70 ,
-        FailedMonitorAjaxSetRequestHeader: 71 ,
-        SendBrowserInfoOnUserInit: 72 ,
-        PluginException: 73 ,
-        NotificationException: 74 ,
-        SnippetScriptLoadFailure: 99 ,
-        InvalidInstrumentationKey: 100 ,
-        CannotParseAiBlobValue: 101 ,
-        InvalidContentBlob: 102 ,
-        TrackPageActionEventFailed: 103 ,
-        FailedAddingCustomDefinedRequestContext: 104 ,
-        InMemoryStorageBufferFull: 105 ,
-        InstrumentationKeyDeprecation: 106
-    });
+    var _InternalMessageId = createEnumStyle((_a = {},
+        _a[BROWSER + "DoesNotSupport" + LOCAL + STORAGE] = 0 ,
+        _a[BROWSER + CANNOT + "Read" + LOCAL + STORAGE] = 1 ,
+        _a[BROWSER + CANNOT + "Read" + SESSION + STORAGE] = 2 ,
+        _a[BROWSER + CANNOT + "Write" + LOCAL + STORAGE] = 3 ,
+        _a[BROWSER + CANNOT + "Write" + SESSION + STORAGE] = 4 ,
+        _a[BROWSER + FAILED + "RemovalFrom" + LOCAL + STORAGE] = 5 ,
+        _a[BROWSER + FAILED + "RemovalFrom" + SESSION + STORAGE] = 6 ,
+        _a[CANNOT + "SendEmptyTelemetry"] = 7 ,
+        _a.ClientPerformanceMathError = 8 ,
+        _a["ErrorParsingAI" + SESSION + "Cookie"] = 9 ,
+        _a.ErrorPVCalc = 10 ,
+        _a[EXCEPTION + "WhileLoggingError"] = 11 ,
+        _a[FAILED + "AddingTelemetryTo" + BUFFER] = 12 ,
+        _a[FAILED_MONITOR_AJAX + "Abort"] = 13 ,
+        _a[FAILED_MONITOR_AJAX + "Dur"] = 14 ,
+        _a[FAILED_MONITOR_AJAX + "Open"] = 15 ,
+        _a[FAILED_MONITOR_AJAX + "RSC"] = 16 ,
+        _a[FAILED_MONITOR_AJAX + "Send"] = 17 ,
+        _a[FAILED_MONITOR_AJAX + "GetCorrelationHeader"] = 18 ,
+        _a[FAILED + "ToAddHandlerForOnBeforeUnload"] = 19 ,
+        _a[FAILED + "ToSendQueuedTelemetry"] = 20 ,
+        _a[FAILED + "ToReportDataLoss"] = 21 ,
+        _a["Flush" + FAILED] = 22 ,
+        _a.MessageLimitPerPVExceeded = 23 ,
+        _a.MissingRequiredFieldSpecification = 24 ,
+        _a.NavigationTimingNotSupported = 25 ,
+        _a.OnError = 26 ,
+        _a[SESSION + "RenewalDateIsZero"] = 27 ,
+        _a.SenderNotInitialized = 28 ,
+        _a[START + TRACK + EVENT + FAILED] = 29 ,
+        _a[STOP + TRACK + EVENT + FAILED] = 30 ,
+        _a[START + TRACK + FAILED] = 31 ,
+        _a[STOP + TRACK + FAILED] = 32 ,
+        _a.TelemetrySampledAndNotSent = 33 ,
+        _a[TRACK + EVENT + FAILED] = 34 ,
+        _a[TRACK + EXCEPTION + FAILED] = 35 ,
+        _a[TRACK + "Metric" + FAILED] = 36 ,
+        _a[TRACK + "PV" + FAILED] = 37 ,
+        _a[TRACK + "PV" + FAILED + "Calc"] = 38 ,
+        _a[TRACK + "Trace" + FAILED] = 39 ,
+        _a["Transmission" + FAILED] = 40 ,
+        _a[FAILED + "ToSet" + STORAGE + BUFFER] = 41 ,
+        _a[FAILED + "ToRestore" + STORAGE + BUFFER] = 42 ,
+        _a.InvalidBackendResponse = 43 ,
+        _a[FAILED + "ToFixDepricatedValues"] = 44 ,
+        _a.InvalidDurationValue = 45 ,
+        _a.TelemetryEnvelopeInvalid = 46 ,
+        _a.CreateEnvelopeError = 47 ,
+        _a[CANNOT + "SerializeObject"] = 48 ,
+        _a[CANNOT + "SerializeObjectNonSerializable"] = 49 ,
+        _a.CircularReferenceDetected = 50 ,
+        _a["Clear" + AUTH_CONTEXT + FAILED] = 51 ,
+        _a[EXCEPTION + "Truncated"] = 52 ,
+        _a.IllegalCharsInName = 53 ,
+        _a.ItemNotInArray = 54 ,
+        _a.MaxAjaxPerPVExceeded = 55 ,
+        _a.MessageTruncated = 56 ,
+        _a.NameTooLong = 57 ,
+        _a.SampleRateOutOfRange = 58 ,
+        _a["Set" + AUTH_CONTEXT + FAILED] = 59 ,
+        _a["Set" + AUTH_CONTEXT + FAILED + "AccountName"] = 60 ,
+        _a.StringValueTooLong = 61 ,
+        _a.StartCalledMoreThanOnce = 62 ,
+        _a.StopCalledWithoutStart = 63 ,
+        _a["TelemetryInitializer" + FAILED] = 64 ,
+        _a.TrackArgumentsNotSpecified = 65 ,
+        _a.UrlTooLong = 66 ,
+        _a[SESSION + STORAGE + BUFFER + "Full"] = 67 ,
+        _a[CANNOT + "AccessCookie"] = 68 ,
+        _a.IdTooLong = 69 ,
+        _a.InvalidEvent = 70 ,
+        _a[FAILED_MONITOR_AJAX + "SetRequestHeader"] = 71 ,
+        _a["Send" + BROWSER + "InfoOnUserInit"] = 72 ,
+        _a["Plugin" + EXCEPTION] = 73 ,
+        _a["Notification" + EXCEPTION] = 74 ,
+        _a.SnippetScriptLoadFailure = 99 ,
+        _a["Invalid" + INSTRUMENTATION_KEY] = 100 ,
+        _a[CANNOT + "ParseAiBlobValue"] = 101 ,
+        _a.InvalidContentBlob = 102 ,
+        _a[TRACK + "PageAction" + EVENT + FAILED] = 103 ,
+        _a[FAILED + "AddingCustomDefinedRequestContext"] = 104 ,
+        _a["InMemory" + STORAGE + BUFFER + "Full"] = 105 ,
+        _a[INSTRUMENTATION_KEY + "Deprecation"] = 106 ,
+        _a));
 
     var strNotSpecified = "not_specified";
 
     var PropertiesPluginIdentifier = "AppInsightsPropertiesPlugin";
 
-    var Prototype = "prototype";
+    var _DYN_EXTENSION_CONFIG = "extensionConfig";
+    var _DYN_PAGE_ACTION_PAGE_TAG0 = "pageActionPageTags";
+    var _DYN_TRACK_PAGE_ACTION = "trackPageAction";
+    var _DYN_LENGTH = "length";
+    var _DYN_TAG_NAME = "tagName";
+    var _DYN_TO_UPPER_CASE = "toUpperCase";
+    var _DYN_PATHNAME = "pathname";
+    var _DYN_PAGE_NAME = "pageName";
+    var _DYN_CORE_DATA = "coreData";
+    var _DYN_REQUEST_URI = "requestUri";
+    var _DYN_GET_ATTRIBUTE = "getAttribute";
+    var _DYN_PARENT_NODE = "parentNode";
+    var _DYN_CUSTOM_DATA_PREFIX = "customDataPrefix";
+    var _DYN_INDEX_OF = "indexOf";
+    var _DYN_DATA_TAGS = "dataTags";
+    var _DYN_USE_DEFAULT_CONTENT_1 = "useDefaultContentNameOrId";
+    var _DYN_AI_BLOB_ATTRIBUTE_TA2 = "aiBlobAttributeTag";
+    var _DYN_CAPTURE_ALL_META_DAT3 = "captureAllMetaDataContent";
+    var _DYN_BEHAVIOR_VALIDATOR = "behaviorValidator";
+    var _DYN_NAME = "name";
+    var _DYN_DATA = "data";
+    var _DYN_PAGE_TYPE = "pageType";
+    var _DYN_PROPERTIES = "properties";
+    var _DYN_ACTION_TYPE = "actionType";
+    var _DYN_BEHAVIOR = "behavior";
+    var _DYN_CLICK_COORDINATES = "clickCoordinates";
+    var _DYN_CONTENT = "content";
+    var _DYN_REF_URI = "refUri";
+    var _DYN_PARENT_ID = "parentId";
+    var _DYN_CAPTURE_PAGE_ACTION = "capturePageAction";
+    var _DYN_SET_COMMON_PROPERTIE4 = "setCommonProperties";
+    var _DYN_GET_ELEMENT_CONTENT = "getElementContent";
+    var _DYN__GET_VALID_BEHAVIOR = "_getValidBehavior";
+    var _DYN_CONTENT_NAME = "contentName";
+    var _DYN__TRACE_LOGGER = "_traceLogger";
+    var _DYN_CLICK_COORDINATE_X = "clickCoordinateX";
+    var _DYN_CLICK_COORDINATE_Y = "clickCoordinateY";
+    var _DYN__CONFIG = "_config";
+    var _DYN_PARENT_DATA_TAG = "parentDataTag";
+    var _DYN__PAGE_TAGS = "_pageTags";
+    var _DYN__PAGE_TAGS_CALLBACK = "_pageTagsCallback";
+    var _DYN__META_TAGS = "_metaTags";
+    var _DYN_SET_BASIC_PROPERTIES = "setBasicProperties";
+    var _DYN__PAGE_TYPE_META_TAG = "_pageTypeMetaTag";
+    var _DYN__BEHAVIOR_META_TAG = "_behaviorMetaTag";
+    var _DYN_PARENT_ELEMENT = "parentElement";
+    var _DYN_ATTRIBUTES = "attributes";
+
     var DEFAULT_DONOT_TRACK_TAG = "ai-dnt";
     var DEFAULT_AI_BLOB_ATTRIBUTE_TAG = "ai-blob";
     var DEFAULT_DATA_PREFIX = "data-";
-    __assignFn(__assignFn({}, _InternalMessageId), { CannotParseAiBlobValue: 101, InvalidContentBlob: 102, TrackPageActionEventFailed: 103 });
+    __assignFn(__assignFn({}, _InternalMessageId), createEnumStyle({
+        CannotParseAiBlobValue: 101 ,
+        InvalidContentBlob: 102 ,
+        TrackPageActionEventFailed: 103
+    }));
     function removeNonObjectsAndInvalidElements(overrideConfig, attributeNamesExpectedObjects) {
         removeInvalidElements(overrideConfig);
         for (var i in attributeNamesExpectedObjects) {
-            if (attributeNamesExpectedObjects.hasOwnProperty(i)) {
+            if (hasOwnProperty(attributeNamesExpectedObjects, i)) {
                 var objectName = attributeNamesExpectedObjects[i];
                 if (typeof overrideConfig[objectName] === "object") {
                     removeInvalidElements(overrideConfig[objectName]);
@@ -2087,15 +2205,15 @@ this.Microsoft = this.Microsoft || {};
         return walkUpDomChainWithElementValidation(el, isAttributeInElement, attribute);
     }
     function isAttributeInElement(element, attributeToLookFor) {
-        var value = element.getAttribute(attributeToLookFor);
+        var value = element[_DYN_GET_ATTRIBUTE ](attributeToLookFor);
         return isValueAssigned(value);
     }
     function walkUpDomChainWithElementValidation(el, validationMethod, validationMethodParam) {
         var element = el;
         if (element) {
             while (!validationMethod(element, validationMethodParam)) {
-                element = element.parentNode;
-                if (!element || !(element.getAttribute)) {
+                element = element[_DYN_PARENT_NODE ];
+                if (!element || !(element[_DYN_GET_ATTRIBUTE ])) {
                     return null;
                 }
             }
@@ -2119,62 +2237,35 @@ this.Microsoft = this.Microsoft || {};
     function bracketIt(str) {
         return "[" + str + "]";
     }
-    function extend(obj, obj2, obj3, obj4, obj5) {
-        var extended = {};
-        var deep = false;
-        var i = 0;
-        var length = arguments.length;
-        var objProto = Object[Prototype];
-        var theArgs = arguments;
-        if (objProto.toString.call(theArgs[0]) === "[object Boolean]") {
-            deep = theArgs[0];
-            i++;
-        }
-        var merge = function (obj) {
-            for (var prop in obj) {
-                if (hasOwnProperty(obj, prop)) {
-                    if (deep && objProto.toString.call(obj[prop]) === "[object Object]") {
-                        extended[prop] = extend(true, extended[prop], obj[prop]);
-                    }
-                    else {
-                        extended[prop] = obj[prop];
-                    }
-                }
-            }
-        };
-        for (; i < length; i++) {
-            var obj = theArgs[i];
-            merge(obj);
-        }
-        return extended;
-    }
     function validateContentNamePrefix(config, defaultDataPrefix) {
-        return isValueAssigned(config.dataTags.customDataPrefix) && (config.dataTags.customDataPrefix.indexOf(defaultDataPrefix) === 0);
+        return isValueAssigned(config.dataTags[_DYN_CUSTOM_DATA_PREFIX ]) && (config[_DYN_DATA_TAGS ][_DYN_CUSTOM_DATA_PREFIX ][_DYN_INDEX_OF ](defaultDataPrefix) === 0);
     }
     function mergeConfig(overrideConfig) {
-        var defaultConfig = {
-            autoCapture: true,
-            callback: {
-                pageActionPageTags: null
-            },
-            pageTags: {},
-            coreData: {
-                referrerUri: hasDocument ? document.referrer : "",
-                requestUri: "",
-                pageName: "",
-                pageType: ""
-            },
-            dataTags: {
-                useDefaultContentNameOrId: false,
-                aiBlobAttributeTag: DEFAULT_AI_BLOB_ATTRIBUTE_TAG,
-                customDataPrefix: DEFAULT_DATA_PREFIX,
-                captureAllMetaDataContent: false,
-                dntDataTag: DEFAULT_DONOT_TRACK_TAG
+        var _a, _b, _c;
+        var defaultConfig = (_a = {
+                autoCapture: true,
+                callback: (_b = {},
+                    _b[_DYN_PAGE_ACTION_PAGE_TAG0 ] = null,
+                    _b),
+                pageTags: {},
+                coreData: {
+                    referrerUri: hasDocument ? document.referrer : "",
+                    requestUri: "",
+                    pageName: "",
+                    pageType: ""
+                },
+                dataTags: (_c = {},
+                    _c[_DYN_USE_DEFAULT_CONTENT_1 ] = false,
+                    _c[_DYN_AI_BLOB_ATTRIBUTE_TA2 ] = DEFAULT_AI_BLOB_ATTRIBUTE_TAG,
+                    _c[_DYN_CUSTOM_DATA_PREFIX ] = DEFAULT_DATA_PREFIX,
+                    _c[_DYN_CAPTURE_ALL_META_DAT3 ] = false,
+                    _c.dntDataTag = DEFAULT_DONOT_TRACK_TAG,
+                    _c)
             },
-            behaviorValidator: function (key) { return key || ""; },
-            defaultRightClickBhvr: "",
-            dropInvalidEvents: false
-        };
+            _a[_DYN_BEHAVIOR_VALIDATOR ] = function (key) { return key || ""; },
+            _a.defaultRightClickBhvr = "",
+            _a.dropInvalidEvents = false,
+            _a);
         var attributesThatAreObjectsInConfig = [];
         for (var attribute in defaultConfig) {
             if (typeof defaultConfig[attribute] === "object") {
@@ -2183,10 +2274,10 @@ this.Microsoft = this.Microsoft || {};
         }
         if (overrideConfig) {
             removeNonObjectsAndInvalidElements(overrideConfig, attributesThatAreObjectsInConfig);
-            if (isValueAssigned(overrideConfig.dataTags)) {
-                overrideConfig.dataTags.customDataPrefix = validateContentNamePrefix(overrideConfig, DEFAULT_DATA_PREFIX) ? overrideConfig.dataTags.customDataPrefix : DEFAULT_DATA_PREFIX;
+            if (isValueAssigned(overrideConfig[_DYN_DATA_TAGS ])) {
+                overrideConfig.dataTags[_DYN_CUSTOM_DATA_PREFIX ] = validateContentNamePrefix(overrideConfig, DEFAULT_DATA_PREFIX) ? overrideConfig[_DYN_DATA_TAGS ][_DYN_CUSTOM_DATA_PREFIX ] : DEFAULT_DATA_PREFIX;
             }
-            return extend(true, defaultConfig, overrideConfig);
+            return objExtend(true, defaultConfig, overrideConfig);
         }
     }
     function BehaviorMapValidator(map) {
@@ -2213,7 +2304,7 @@ this.Microsoft = this.Microsoft || {};
         var temp = element;
         if (temp) {
             var parent = findClosestAnchor(temp);
-            if (parent.length === 1) {
+            if (parent[_DYN_LENGTH ] === 1) {
                 var firstParent = parent[0];
                 if (firstParent.href) {
                     return firstParent.href;
@@ -2227,7 +2318,7 @@ this.Microsoft = this.Microsoft || {};
     }
     function getClickTarget(element) {
         var clickTarget = "";
-        switch (element.tagName) {
+        switch (element[_DYN_TAG_NAME ]) {
             case "A":
             case "AREA":
                 clickTarget = element.href || "";
@@ -2237,13 +2328,13 @@ this.Microsoft = this.Microsoft || {};
                 break;
             case "INPUT":
                 var type = element.type;
-                if (type && (clickCaptureInputTypes$1[type.toUpperCase()])) {
+                if (type && (clickCaptureInputTypes$1[type[_DYN_TO_UPPER_CASE ]()])) {
                     var loc = getLocation() || {};
                     if (element.form) {
-                        clickTarget = element.form.action || (loc.pathname || "");
+                        clickTarget = element.form.action || (loc[_DYN_PATHNAME ] || "");
                     }
                     else {
-                        clickTarget = loc.pathname || "";
+                        clickTarget = loc[_DYN_PATHNAME ] || "";
                     }
                 }
                 break;
@@ -2251,14 +2342,14 @@ this.Microsoft = this.Microsoft || {};
         return clickTarget;
     }
     function getPageName(config, overrideValues) {
-        if (overrideValues && overrideValues.pageName) {
-            return overrideValues.pageName;
+        if (overrideValues && overrideValues[_DYN_PAGE_NAME ]) {
+            return overrideValues[_DYN_PAGE_NAME ];
         }
-        else if (config.callback && isFunction(config.callback.pageName)) {
-            return config.callback.pageName();
+        else if (config.callback && isFunction(config.callback[_DYN_PAGE_NAME ])) {
+            return config.callback[_DYN_PAGE_NAME ]();
         }
-        else if (config.coreData && config.coreData.pageName) {
-            return config.coreData.pageName;
+        else if (config.coreData && config.coreData[_DYN_PAGE_NAME ]) {
+            return config.coreData[_DYN_PAGE_NAME ];
         }
         else {
             var doc = getDocument();
@@ -2271,12 +2362,12 @@ this.Microsoft = this.Microsoft || {};
         }
         var url = location.protocol + "//" + (location.hostname || location.host) +
             (isValueAssigned(location.port) ? ":" + location.port : "") +
-            location.pathname;
+            location[_DYN_PATHNAME ];
         return url;
     }
     function getUri(config, location) {
-        if (config.coreData && config.coreData.requestUri && config.coreData.requestUri !== "") {
-            return config.coreData.requestUri;
+        if (config[_DYN_CORE_DATA ] && config[_DYN_CORE_DATA ][_DYN_REQUEST_URI ] && config[_DYN_CORE_DATA ][_DYN_REQUEST_URI ] !== "") {
+            return config[_DYN_CORE_DATA ][_DYN_REQUEST_URI ];
         }
         return sanitizeUrl(config, location);
     }
@@ -2286,64 +2377,64 @@ this.Microsoft = this.Microsoft || {};
             dynamicProto(WebEvent, this, function (_self) {
                 _initDefaults();
                 function _initDefaults() {
-                    _self._pageTags = {};
+                    _self[_DYN__PAGE_TAGS ] = {};
                     _self._clickAnalyticsPlugin = clickAnalyticsPlugin;
-                    _self._config = config;
+                    _self[_DYN__CONFIG ] = config;
                     _self._contentHandler = contentHandler;
-                    _self._pageTagsCallback = pageTagsCallback;
-                    _self._metaTags = metaTags;
-                    _self._traceLogger = traceLogger;
+                    _self[_DYN__PAGE_TAGS_CALLBACK ] = pageTagsCallback;
+                    _self[_DYN__META_TAGS ] = metaTags;
+                    _self[_DYN__TRACE_LOGGER ] = traceLogger;
                 }
-                _self.setBasicProperties = function (event, overrideValues) {
-                    if (!isValueAssigned(event.name)) {
-                        event.pageName = getPageName(_self._config, overrideValues);
+                _self[_DYN_SET_BASIC_PROPERTIES ] = function (event, overrideValues) {
+                    if (!isValueAssigned(event[_DYN_NAME ])) {
+                        event[_DYN_PAGE_NAME ] = getPageName(_self[_DYN__CONFIG ], overrideValues);
                     }
                     if (!isValueAssigned(event.uri) && hasWindow) {
-                        event.uri = getUri(_self._config, getLocation());
+                        event.uri = getUri(_self[_DYN__CONFIG ], getLocation());
                     }
                 };
-                _self.setCommonProperties = function (event, overrideValues) {
-                    _self.setBasicProperties(event, overrideValues);
+                _self[_DYN_SET_COMMON_PROPERTIE4 ] = function (event, overrideValues) {
+                    _self[_DYN_SET_BASIC_PROPERTIES ](event, overrideValues);
                     _self._setPageTags(event, overrideValues);
-                    _self._pageTypeMetaTag = _getMetaData(_self._metaTags, _self._config.coreData, "pageType");
-                    _self._behaviorMetaTag = _getMetaData(_self._metaTags, _self._config.coreData, "behavior");
-                    if (isValueAssigned(overrideValues.pageType)) {
-                        event.pageType = overrideValues.pageType;
+                    _self._pageTypeMetaTag = _getMetaData(_self._metaTags, _self._config[_DYN_CORE_DATA ], "pageType");
+                    _self._behaviorMetaTag = _getMetaData(_self._metaTags, _self._config[_DYN_CORE_DATA ], "behavior");
+                    if (isValueAssigned(overrideValues[_DYN_PAGE_TYPE ])) {
+                        event[_DYN_PAGE_TYPE ] = overrideValues[_DYN_PAGE_TYPE ];
                     }
-                    if (isValueAssigned(_self._pageTypeMetaTag) && !isValueAssigned(event.pageType)) {
-                        event.pageType = _self._pageTypeMetaTag;
+                    if (isValueAssigned(_self._pageTypeMetaTag) && !isValueAssigned(event[_DYN_PAGE_TYPE ])) {
+                        event[_DYN_PAGE_TYPE ] = _self[_DYN__PAGE_TYPE_META_TAG ];
                     }
                 };
                 _self._setPageTags = function (event, overrideValues) {
-                    if (_self._pageTagsCallback) {
-                        _self._pageTags = extend(true, _self._pageTags, _self._pageTagsCallback());
+                    if (_self[_DYN__PAGE_TAGS_CALLBACK ]) {
+                        _self[_DYN__PAGE_TAGS ] = objExtend(true, _self[_DYN__PAGE_TAGS ], _self[_DYN__PAGE_TAGS_CALLBACK ]());
                     }
                     if (isValueAssigned(overrideValues.pageTags)) {
-                        _self._pageTags = extend(true, _self._pageTags, overrideValues.pageTags);
+                        _self[_DYN__PAGE_TAGS ] = objExtend(true, _self[_DYN__PAGE_TAGS ], overrideValues.pageTags);
                     }
-                    if (_self._metaTags) {
-                        _self._pageTags.metaTags = {};
-                        for (var metaTag in _self._metaTags) {
+                    if (_self[_DYN__META_TAGS ]) {
+                        _self[_DYN__PAGE_TAGS ].metaTags = {};
+                        for (var metaTag in _self[_DYN__META_TAGS ]) {
                             if (metaTag != "behavior" && metaTag != "market" && metaTag != "pageType") {
-                                _self._pageTags.metaTags[metaTag] = _self._metaTags[metaTag];
+                                _self[_DYN__PAGE_TAGS ].metaTags[metaTag] = _self[_DYN__META_TAGS ][metaTag];
                             }
                         }
                     }
-                    event.properties = event.properties || {};
-                    event.properties["pageTags"] = _self._pageTags;
+                    event[_DYN_PROPERTIES ] = event[_DYN_PROPERTIES ] || {};
+                    event[_DYN_PROPERTIES ]["pageTags"] = _self[_DYN__PAGE_TAGS ];
                 };
                 _self._getBehavior = function (overrideValues) {
                     var behavior;
-                    if (overrideValues && isValueAssigned(overrideValues.behavior)) {
-                        behavior = overrideValues.behavior;
+                    if (overrideValues && isValueAssigned(overrideValues[_DYN_BEHAVIOR ])) {
+                        behavior = overrideValues[_DYN_BEHAVIOR ];
                     }
-                    else if (isValueAssigned(_self._behaviorMetaTag)) {
-                        behavior = _self._behaviorMetaTag;
+                    else if (isValueAssigned(_self[_DYN__BEHAVIOR_META_TAG ])) {
+                        behavior = _self[_DYN__BEHAVIOR_META_TAG ];
                     }
-                    return _self._getValidBehavior(behavior);
+                    return _self[_DYN__GET_VALID_BEHAVIOR ](behavior);
                 };
-                _self._getValidBehavior = function (behavior) {
-                    return _self._config.behaviorValidator(behavior);
+                _self[_DYN__GET_VALID_BEHAVIOR ] = function (behavior) {
+                    return _self._config[_DYN_BEHAVIOR_VALIDATOR ](behavior);
                 };
                 _self._doUnload = function (unloadCtx, unloadState, asyncCallback) {
                     _initDefaults();
@@ -2368,7 +2459,7 @@ this.Microsoft = this.Microsoft || {};
         function PageAction(clickAnalyticsPlugin, config, contentHandler, pageTagsCallback, metaTags, traceLogger) {
             var _this = _super.call(this, clickAnalyticsPlugin, config, contentHandler, pageTagsCallback, metaTags, traceLogger) || this;
             dynamicProto(PageAction, _this, function (_self, _base) {
-                _self.trackPageAction = function (pageActionEvent, properties) {
+                _self[_DYN_TRACK_PAGE_ACTION ] = function (pageActionEvent, properties) {
                     var ext = {};
                     ext["web"] = {};
                     var event = {
@@ -2378,66 +2469,66 @@ this.Microsoft = this.Microsoft || {};
                         data: {},
                         baseData: {}
                     };
-                    _populateEventDataIfPresent(event.baseData, "name", pageActionEvent.name);
-                    _populateEventDataIfPresent(event.data, "baseTypeSource", "ClickEvent");
-                    _populateEventDataIfPresent(event.data, "uri", pageActionEvent.uri);
-                    _populateEventDataIfPresent(event.data, "pageType", pageActionEvent.pageType);
-                    _populateEventDataIfPresent(event.data, "properties", pageActionEvent.properties);
-                    _populateEventDataIfPresent(event.data, "actionType", pageActionEvent.actionType);
-                    _populateEventDataIfPresent(event.data, "behavior", pageActionEvent.behavior);
-                    _populateEventDataIfPresent(event.data, "clickCoordinates", pageActionEvent.clickCoordinates);
-                    _populateEventDataIfPresent(event.data, "content", pageActionEvent.content);
-                    _populateEventDataIfPresent(event.data, "targetUri", pageActionEvent.targetUri);
-                    _populateEventDataIfPresent(event.data, "timeToAction", pageActionEvent.timeToAction);
-                    _populateEventDataIfPresent(event.data, "refUri", pageActionEvent.refUri);
-                    _populateEventDataIfPresent(event.data, "pageName", pageActionEvent.pageName);
-                    _populateEventDataIfPresent(event.data, "parentId", pageActionEvent.parentId);
+                    _populateEventDataIfPresent(event.baseData, "name", pageActionEvent[_DYN_NAME ]);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "baseTypeSource", "ClickEvent");
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "uri", pageActionEvent.uri);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "pageType", pageActionEvent[_DYN_PAGE_TYPE ]);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "properties", pageActionEvent[_DYN_PROPERTIES ]);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "actionType", pageActionEvent[_DYN_ACTION_TYPE ]);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "behavior", pageActionEvent[_DYN_BEHAVIOR ]);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "clickCoordinates", pageActionEvent[_DYN_CLICK_COORDINATES ]);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "content", pageActionEvent[_DYN_CONTENT ]);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "targetUri", pageActionEvent.targetUri);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "timeToAction", pageActionEvent.timeToAction);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "refUri", pageActionEvent[_DYN_REF_URI ]);
+                    _populateEventDataIfPresent(event.data, "pageName", pageActionEvent[_DYN_PAGE_NAME ]);
+                    _populateEventDataIfPresent(event[_DYN_DATA ], "parentId", pageActionEvent[_DYN_PARENT_ID ]);
                     if (properties) {
                         objForEachKey(properties, function (property, value) {
-                            if (!event.data[property]) {
-                                _populateEventDataIfPresent(event.data, property, value);
+                            if (!event[_DYN_DATA ][property]) {
+                                _populateEventDataIfPresent(event[_DYN_DATA ], property, value);
                             }
                         });
                     }
                     _self._clickAnalyticsPlugin.core.track(event);
                 };
-                _self.capturePageAction = function (element, overrideValues, customProperties, isRightClick) {
+                _self[_DYN_CAPTURE_PAGE_ACTION ] = function (element, overrideValues, customProperties, isRightClick) {
                     overrideValues = !isValueAssigned(overrideValues) ? {} : overrideValues;
                     var pageActionEvent = { name: "" };
                     var pageActionProperties = isValueAssigned(customProperties) ? customProperties : {};
-                    _self.setCommonProperties(pageActionEvent, overrideValues);
-                    pageActionEvent.behavior = _self._getBehavior(overrideValues);
+                    _self[_DYN_SET_COMMON_PROPERTIE4 ](pageActionEvent, overrideValues);
+                    pageActionEvent[_DYN_BEHAVIOR ] = _self._getBehavior(overrideValues);
                     var elementContent = {};
                     if (isRightClick) {
-                        pageActionEvent.behavior = _self._config.defaultRightClickBhvr;
+                        pageActionEvent[_DYN_BEHAVIOR ] = _self[_DYN__CONFIG ].defaultRightClickBhvr;
                     }
                     if (element) {
                         pageActionEvent.targetUri = getClickTarget(element);
-                        elementContent = _self._contentHandler.getElementContent(element);
-                        if (elementContent.bhvr && !isValueAssigned(overrideValues.behavior)) {
+                        elementContent = _self._contentHandler[_DYN_GET_ELEMENT_CONTENT ](element);
+                        if (elementContent.bhvr && !isValueAssigned(overrideValues[_DYN_BEHAVIOR ])) {
                             var currentBehavior = extractFieldFromObject(elementContent, "bhvr");
-                            pageActionEvent.behavior = _self._getValidBehavior(currentBehavior);
+                            pageActionEvent[_DYN_BEHAVIOR ] = _self[_DYN__GET_VALID_BEHAVIOR ](currentBehavior);
                         }
-                        if (!isValueAssigned(elementContent.id) && !isValueAssigned(elementContent.contentName)) {
-                            _throwInternal(_self._traceLogger, 2 , 102 , "Missing attributes id or contentName in click event. Click event information will still be collected!");
+                        if (!isValueAssigned(elementContent.id) && !isValueAssigned(elementContent[_DYN_CONTENT_NAME ])) {
+                            _throwInternal(_self[_DYN__TRACE_LOGGER ], 2 , 102 , "Missing attributes id or contentName in click event. Click event information will still be collected!");
                         }
                     }
-                    pageActionEvent.name = elementContent.id || elementContent.contentName || strNotSpecified;
-                    pageActionEvent.parentId = elementContent.parentid || elementContent.parentName || strNotSpecified;
-                    if (isValueAssigned(overrideValues.actionType)) {
-                        pageActionEvent.actionType = overrideValues.actionType;
+                    pageActionEvent[_DYN_NAME ] = elementContent.id || elementContent[_DYN_CONTENT_NAME ] || strNotSpecified;
+                    pageActionEvent[_DYN_PARENT_ID ] = elementContent.parentid || elementContent.parentName || strNotSpecified;
+                    if (isValueAssigned(overrideValues[_DYN_ACTION_TYPE ])) {
+                        pageActionEvent[_DYN_ACTION_TYPE ] = overrideValues[_DYN_ACTION_TYPE ];
                     }
-                    if (isValueAssigned(overrideValues.clickCoordinateX) && isValueAssigned(overrideValues.clickCoordinateY)) {
-                        pageActionEvent.clickCoordinates = overrideValues.clickCoordinateX + "X" + overrideValues.clickCoordinateY;
+                    if (isValueAssigned(overrideValues[_DYN_CLICK_COORDINATE_X ]) && isValueAssigned(overrideValues[_DYN_CLICK_COORDINATE_Y ])) {
+                        pageActionEvent[_DYN_CLICK_COORDINATES ] = overrideValues[_DYN_CLICK_COORDINATE_X ] + "X" + overrideValues[_DYN_CLICK_COORDINATE_Y ];
                     }
                     _sanitizePageActionEventContent(elementContent);
-                    pageActionEvent.content = bracketIt(JSON.stringify(extend(elementContent, overrideValues && overrideValues.contentTags ? overrideValues.contentTags : {})));
+                    pageActionEvent[_DYN_CONTENT ] = bracketIt(JSON.stringify(objExtend(elementContent, overrideValues && overrideValues.contentTags ? overrideValues.contentTags : {})));
                     pageActionEvent.timeToAction = _getTimeToClick();
-                    pageActionEvent.refUri = isValueAssigned(overrideValues.refUri) ? overrideValues.refUri : _self._config.coreData.referrerUri;
+                    pageActionEvent.refUri = isValueAssigned(overrideValues.refUri) ? overrideValues.refUri : _self._config[_DYN_CORE_DATA ].referrerUri;
                     if (_isUndefinedEvent(pageActionEvent)) {
                         return;
                     }
-                    _self.trackPageAction(pageActionEvent, pageActionProperties);
+                    _self[_DYN_TRACK_PAGE_ACTION ](pageActionEvent, pageActionProperties);
                 };
                 function _getTimeToClick() {
                     var perf = getPerformance();
@@ -2459,16 +2550,16 @@ this.Microsoft = this.Microsoft || {};
                         delete pageActionContent.id;
                         delete pageActionContent.parentid;
                         delete pageActionContent.parentname;
-                        if (_self._config && _self._config.dataTags && isValueAssigned(_self._config.dataTags.parentDataTag)) {
-                            delete pageActionContent[_self._config.dataTags.parentDataTag];
+                        if (_self._config && _self._config[_DYN_DATA_TAGS ] && isValueAssigned(_self[_DYN__CONFIG ][_DYN_DATA_TAGS ][_DYN_PARENT_DATA_TAG ])) {
+                            delete pageActionContent[_self._config[_DYN_DATA_TAGS ].parentDataTag];
                         }
                     }
                 }
                 function _isUndefinedEvent(pageActionEvent) {
-                    if (_self._config.dropInvalidEvents) {
-                        if (pageActionEvent.name === strNotSpecified
-                            && pageActionEvent.parentId === strNotSpecified
-                            && pageActionEvent.content === "[{}]") {
+                    if (_self[_DYN__CONFIG ].dropInvalidEvents) {
+                        if (pageActionEvent[_DYN_NAME ] === strNotSpecified
+                            && pageActionEvent[_DYN_PARENT_ID ] === strNotSpecified
+                            && pageActionEvent[_DYN_CONTENT ] === "[{}]") {
                             return true;
                         }
                     }
@@ -2506,7 +2597,7 @@ this.Microsoft = this.Microsoft || {};
                     var win = getWindow();
                     var doc = getDocument();
                     if (win) {
-                        var event_1 = (navigator.appVersion.indexOf("MSIE") !== -1) ? "click" : "mousedown";
+                        var event_1 = (navigator.appVersion[_DYN_INDEX_OF ]("MSIE") !== -1) ? "click" : "mousedown";
                         eventOn(win, event_1, _processClick, _evtNamespace);
                         eventOn(win, "keyup", _processClick, _evtNamespace);
                     }
@@ -2520,12 +2611,13 @@ this.Microsoft = this.Microsoft || {};
                     eventOff(getDocument(), null, null, _evtNamespace);
                 };
                 function _capturePageAction(element, overrideValues, customProperties, isRightClick) {
-                    var donotTrackTag = _self._config.dataTags.customDataPrefix + _self._config.dataTags.dntDataTag;
+                    var donotTrackTag = _self._config.dataTags[_DYN_CUSTOM_DATA_PREFIX ] + _self[_DYN__CONFIG ][_DYN_DATA_TAGS ].dntDataTag;
                     if (!isElementDnt(element, donotTrackTag)) {
-                        _self._pageAction.capturePageAction(element, overrideValues, customProperties, isRightClick);
+                        _self._pageAction[_DYN_CAPTURE_PAGE_ACTION ](element, overrideValues, customProperties, isRightClick);
                     }
                 }
                 function _processClick(clickEvent) {
+                    var _a;
                     var clickCaptureElements = { A: true, BUTTON: true, AREA: true, INPUT: true };
                     var win = getWindow();
                     if (isNullOrUndefined(clickEvent) && win) {
@@ -2533,40 +2625,40 @@ this.Microsoft = this.Microsoft || {};
                     }
                     if (clickEvent) {
                         var element = clickEvent.srcElement || clickEvent.target;
-                        var overrideValues = {
-                            clickCoordinateX: clickEvent.pageX,
-                            clickCoordinateY: clickEvent.pageY
-                        };
+                        var overrideValues = (_a = {},
+                            _a[_DYN_CLICK_COORDINATE_X ] = clickEvent.pageX,
+                            _a[_DYN_CLICK_COORDINATE_Y ] = clickEvent.pageY,
+                            _a);
                         var isRightClickObj = isRightClick(clickEvent);
                         if (isRightClickObj) {
-                            overrideValues.actionType = ActionType.CLICKRIGHT;
+                            overrideValues[_DYN_ACTION_TYPE ] = ActionType.CLICKRIGHT;
                         }
                         else if (isLeftClick(clickEvent)) {
-                            overrideValues.actionType = ActionType.CLICKLEFT;
+                            overrideValues[_DYN_ACTION_TYPE ] = ActionType.CLICKLEFT;
                         }
                         else if (isKeyboardEnter(clickEvent)) {
-                            overrideValues.actionType = ActionType.KEYBOARDENTER;
+                            overrideValues[_DYN_ACTION_TYPE ] = ActionType.KEYBOARDENTER;
                         }
                         else if (isKeyboardSpace(clickEvent)) {
-                            overrideValues.actionType = ActionType.KEYBOARDSPACE;
+                            overrideValues[_DYN_ACTION_TYPE ] = ActionType.KEYBOARDSPACE;
                         }
                         else if (isMiddleClick(clickEvent)) {
-                            overrideValues.actionType = ActionType.CLICKMIDDLE;
+                            overrideValues[_DYN_ACTION_TYPE ] = ActionType.CLICKMIDDLE;
                         }
                         else {
                             return;
                         }
-                        while (element && element.tagName) {
-                            if (element.control && clickCaptureElements[element.control.tagName.toUpperCase()]) {
+                        while (element && element[_DYN_TAG_NAME ]) {
+                            if (element.control && clickCaptureElements[element.control[_DYN_TAG_NAME ][_DYN_TO_UPPER_CASE ]()]) {
                                 element = element.control;
                             }
-                            var tagNameUpperCased = element.tagName.toUpperCase();
+                            var tagNameUpperCased = element[_DYN_TAG_NAME ][_DYN_TO_UPPER_CASE ]();
                             if (!clickCaptureElements[tagNameUpperCased]) {
-                                element = element.parentElement || element.parentNode;
+                                element = element.parentElement || element[_DYN_PARENT_NODE ];
                                 continue;
                             }
                             else {
-                                var sendEvent = tagNameUpperCased === "INPUT" ? clickCaptureInputTypes[element.type.toUpperCase()] : true;
+                                var sendEvent = tagNameUpperCased === "INPUT" ? clickCaptureInputTypes[element.type[_DYN_TO_UPPER_CASE ]()] : true;
                                 if (sendEvent) {
                                     _capturePageAction(element, overrideValues, {}, isRightClickObj);
                                 }
@@ -2588,57 +2680,57 @@ this.Microsoft = this.Microsoft || {};
             this._traceLogger = _traceLogger;
             dynamicProto(DomContentHandler, this, function (_self) {
                 _self.getMetadata = function () {
-                    var dataTags = (_self._config || {}).dataTags;
+                    var dataTags = (_self._config || {})[_DYN_DATA_TAGS ];
                     var metaTags = {};
                     if (hasDocument) {
-                        metaTags = isValueAssigned(dataTags.metaDataPrefix) ? _getMetaDataFromDOM(dataTags.captureAllMetaDataContent, dataTags.metaDataPrefix, false) :
-                            _getMetaDataFromDOM(dataTags.captureAllMetaDataContent, "", false);
+                        metaTags = isValueAssigned(dataTags.metaDataPrefix) ? _getMetaDataFromDOM(dataTags[_DYN_CAPTURE_ALL_META_DAT3 ], dataTags.metaDataPrefix, false) :
+                            _getMetaDataFromDOM(dataTags[_DYN_CAPTURE_ALL_META_DAT3 ], "", false);
                     }
                     return metaTags;
                 };
-                _self.getElementContent = function (element) {
+                _self[_DYN_GET_ELEMENT_CONTENT ] = function (element) {
                     if (!element) {
                         return {};
                     }
-                    var dataTags = (_self._config || {}).dataTags;
+                    var dataTags = (_self._config || {})[_DYN_DATA_TAGS ];
                     var elementContent = {};
                     var biBlobValue;
                     var parentDataTagPrefix;
-                    var dataTagPrefix = dataTags.customDataPrefix;
-                    var aiBlobAttributeTag = dataTagPrefix + dataTags.aiBlobAttributeTag;
-                    if (isValueAssigned(dataTags.parentDataTag)) {
-                        parentDataTagPrefix = dataTagPrefix + dataTags.parentDataTag;
+                    var dataTagPrefix = dataTags[_DYN_CUSTOM_DATA_PREFIX ];
+                    var aiBlobAttributeTag = dataTagPrefix + dataTags[_DYN_AI_BLOB_ATTRIBUTE_TA2 ];
+                    if (isValueAssigned(dataTags[_DYN_PARENT_DATA_TAG ])) {
+                        parentDataTagPrefix = dataTagPrefix + dataTags[_DYN_PARENT_DATA_TAG ];
                     }
                     if (!_isTracked(element, dataTagPrefix, aiBlobAttributeTag)) {
-                        biBlobValue = element.getAttribute(aiBlobAttributeTag);
+                        biBlobValue = element[_DYN_GET_ATTRIBUTE ](aiBlobAttributeTag);
                         if (biBlobValue) {
                             try {
                                 elementContent = JSON.parse(biBlobValue);
                             }
                             catch (e) {
-                                _throwInternal(_self._traceLogger, 1 , 101 , "Can not parse " + biBlobValue);
+                                _throwInternal(_self[_DYN__TRACE_LOGGER ], 1 , 101 , "Can not parse " + biBlobValue);
                             }
                         }
                         else {
-                            elementContent = extend(elementContent, _populateElementContent(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag));
+                            elementContent = objExtend(elementContent, _populateElementContent(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag));
                         }
                     }
                     else {
-                        elementContent = extend(elementContent, _populateElementContentwithDataTag(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag));
+                        elementContent = objExtend(elementContent, _populateElementContentwithDataTag(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag));
                     }
                     removeInvalidElements(elementContent);
                     if (parentDataTagPrefix) {
-                        elementContent = extend(elementContent, _getParentDetails(element, elementContent, dataTagPrefix, aiBlobAttributeTag));
+                        elementContent = objExtend(elementContent, _getParentDetails(element, elementContent, dataTagPrefix, aiBlobAttributeTag));
                     }
                     return elementContent;
                 };
                 function _captureElementContentWithDataTag(contentElement, elementContent, dataTagPrefix) {
-                    for (var i = 0, attrib; i < contentElement.attributes.length; i++) {
-                        attrib = contentElement.attributes[i];
-                        if (attrib.name.indexOf(dataTagPrefix) !== 0) {
+                    for (var i = 0, attrib; i < contentElement.attributes[_DYN_LENGTH ]; i++) {
+                        attrib = contentElement[_DYN_ATTRIBUTES ][i];
+                        if (attrib.name[_DYN_INDEX_OF ](dataTagPrefix) !== 0) {
                             continue;
                         }
-                        var attribName = attrib.name.replace(dataTagPrefix, "");
+                        var attribName = attrib[_DYN_NAME ].replace(dataTagPrefix, "");
                         elementContent[attribName] = attrib.value;
                     }
                 }
@@ -2646,20 +2738,20 @@ this.Microsoft = this.Microsoft || {};
                     var element = el;
                     var parentDataTagFound = false;
                     var elementLevelFlag = false;
-                    while (!isNullOrUndefined(element) && !isNullOrUndefined(element.attributes)) {
-                        var attributes = element.attributes;
-                        for (var i = 0; i < attributes.length; i++) {
+                    while (!isNullOrUndefined(element) && !isNullOrUndefined(element[_DYN_ATTRIBUTES ])) {
+                        var attributes = element[_DYN_ATTRIBUTES ];
+                        for (var i = 0; i < attributes[_DYN_LENGTH ]; i++) {
                             var attrib = attributes[i];
-                            if (attrib.name.indexOf(dataTagPrefix) !== 0) {
+                            if (attrib.name[_DYN_INDEX_OF ](dataTagPrefix) !== 0) {
                                 continue;
                             }
-                            if (attrib.name.indexOf(parentDataTagPrefix) === 0) {
+                            if (attrib.name[_DYN_INDEX_OF ](parentDataTagPrefix) === 0) {
                                 parentDataTagFound = true;
                             }
-                            if (attrib.name.indexOf(aiBlobAttributeTag) === 0) {
+                            if (attrib.name[_DYN_INDEX_OF ](aiBlobAttributeTag) === 0) {
                                 continue;
                             }
-                            var attribName = attrib.name.replace(dataTagPrefix, "");
+                            var attribName = attrib[_DYN_NAME ].replace(dataTagPrefix, "");
                             if (elementLevelFlag && attribName === "id") {
                                 continue;
                             }
@@ -2671,7 +2763,7 @@ this.Microsoft = this.Microsoft || {};
                             break;
                         }
                         elementLevelFlag = true;
-                        element = element.parentNode;
+                        element = element[_DYN_PARENT_NODE ];
                     }
                 }
                 function _populateElementContent(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag) {
@@ -2682,19 +2774,19 @@ this.Microsoft = this.Microsoft || {};
                     var htmlContent = _getHtmlIdAndContentName(element);
                     elementContent = {
                         id: htmlContent.id || "",
-                        contentName: htmlContent.contentName || ""
+                        contentName: htmlContent[_DYN_CONTENT_NAME ] || ""
                     };
                     if (isValueAssigned(parentDataTagPrefix)) {
                         _walkUpDomChainCaptureData(element, elementContent, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag);
                     }
-                    if (!elementContent.id && !elementContent.contentName) {
+                    if (!elementContent.id && !elementContent[_DYN_CONTENT_NAME ]) {
                         _throwInternal(_traceLogger, 2 , 102 , "Invalid content blob.  Missing required attributes (id, contentName. " +
                             " Content information will still be collected!");
                     }
                     return elementContent;
                 }
                 function _populateElementContentwithDataTag(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag) {
-                    var dataTags = (_self._config || {}).dataTags;
+                    var dataTags = (_self._config || {})[_DYN_DATA_TAGS ];
                     var elementContent = {};
                     if (!element) {
                         return elementContent;
@@ -2706,13 +2798,13 @@ this.Microsoft = this.Microsoft || {};
                     else {
                         _captureElementContentWithDataTag(element, elementContent, dataTagPrefix);
                     }
-                    if (dataTags.useDefaultContentNameOrId) {
+                    if (dataTags[_DYN_USE_DEFAULT_CONTENT_1 ]) {
                         if (!isValueAssigned(elementContent.id)) {
                             elementContent.id = htmlContent.id || "";
                         }
-                        elementContent.contentName = htmlContent.contentName || "";
+                        elementContent[_DYN_CONTENT_NAME ] = htmlContent[_DYN_CONTENT_NAME ] || "";
                     }
-                    if (!elementContent.id && !elementContent.contentName) {
+                    if (!elementContent.id && !elementContent[_DYN_CONTENT_NAME ]) {
                         _throwInternal(_traceLogger, 2 , 102 , "Invalid content blob.  Missing required attributes (id, contentName. " +
                             " Content information will still be collected!");
                     }
@@ -2723,12 +2815,12 @@ this.Microsoft = this.Microsoft || {};
                     var metaData = {};
                     if (hasDocument) {
                         metaElements = document.querySelectorAll("meta");
-                        for (var i = 0; i < metaElements.length; i++) {
+                        for (var i = 0; i < metaElements[_DYN_LENGTH ]; i++) {
                             var meta = metaElements[i];
-                            if (meta.name) {
-                                if (captureAllMetaDataContent || meta.name.indexOf(prefix) === 0) {
-                                    var name_1 = removePrefix ? meta.name.replace(prefix, "") : meta.name;
-                                    metaData[name_1] = meta.content;
+                            if (meta[_DYN_NAME ]) {
+                                if (captureAllMetaDataContent || meta.name[_DYN_INDEX_OF ](prefix) === 0) {
+                                    var name_1 = removePrefix ? meta[_DYN_NAME ].replace(prefix, "") : meta[_DYN_NAME ];
+                                    metaData[name_1] = meta[_DYN_CONTENT ];
                                 }
                             }
                         }
@@ -2736,12 +2828,12 @@ this.Microsoft = this.Microsoft || {};
                     return metaData;
                 }
                 function _getDefaultContentName(element, useDefaultContentName) {
-                    if (useDefaultContentName === false || !element.tagName) {
+                    if (useDefaultContentName === false || !element[_DYN_TAG_NAME ]) {
                         return "";
                     }
                     var doc = getDocument() || {};
                     var contentName;
-                    switch (element.tagName) {
+                    switch (element[_DYN_TAG_NAME ]) {
                         case "A":
                             contentName = doc.all ? element.innerText || element.innerHTML : element.text || element.innerHTML;
                             break;
@@ -2750,37 +2842,37 @@ this.Microsoft = this.Microsoft || {};
                             contentName = element.alt;
                             break;
                         default:
-                            contentName = element.value || element.name || element.alt || element.innerText || element.id;
+                            contentName = element.value || element[_DYN_NAME ] || element.alt || element.innerText || element.id;
                     }
                     return contentName.substring(0, MAX_CONTENTNAME_LENGTH);
                 }
                 function _isTracked(element, dataTag, aiBlobAttributeTag) {
-                    var attrs = element.attributes;
+                    var attrs = element[_DYN_ATTRIBUTES ];
                     var dataTagFound = false;
-                    for (var i = 0; i < attrs.length; i++) {
-                        var attributeName = attrs[i].name;
+                    for (var i = 0; i < attrs[_DYN_LENGTH ]; i++) {
+                        var attributeName = attrs[i][_DYN_NAME ];
                         if (attributeName === aiBlobAttributeTag) {
                             return false;
                         }
-                        else if (attributeName.indexOf(dataTag) === 0) {
+                        else if (attributeName[_DYN_INDEX_OF ](dataTag) === 0) {
                             dataTagFound = true;
                         }
                     }
                     return dataTagFound;
                 }
                 function _getHtmlIdAndContentName(element) {
-                    var dataTags = (_self._config || {}).dataTags;
-                    var callback = (_self._config || {}).callback;
+                    var dataTags = (_self._config || {})[_DYN_DATA_TAGS ];
+                    var callback = (_self[_DYN__CONFIG ] || {}).callback;
                     var htmlContent = {};
                     if (!element) {
                         return htmlContent;
                     }
-                    if (dataTags.useDefaultContentNameOrId) {
-                        var customizedContentName = callback.contentName ? callback.contentName(element, dataTags.useDefaultContentNameOrId) : "";
-                        var defaultContentName = _getDefaultContentName(element, dataTags.useDefaultContentNameOrId);
+                    if (dataTags[_DYN_USE_DEFAULT_CONTENT_1 ]) {
+                        var customizedContentName = callback.contentName ? callback.contentName(element, dataTags[_DYN_USE_DEFAULT_CONTENT_1 ]) : "";
+                        var defaultContentName = _getDefaultContentName(element, dataTags[_DYN_USE_DEFAULT_CONTENT_1 ]);
                         htmlContent = {
                             id: element.id,
-                            contentName: customizedContentName || defaultContentName || element.getAttribute("alt")
+                            contentName: customizedContentName || defaultContentName || element[_DYN_GET_ATTRIBUTE ]("alt")
                         };
                     }
                     return htmlContent;
@@ -2797,9 +2889,9 @@ this.Microsoft = this.Microsoft || {};
                 function _populateParentInfo(element, dataTagPrefix, aiBlobAttributeTag) {
                     var parentInfo = {};
                     var parentId;
-                    var closestParentElement = walkUpDomChainWithElementValidation(element.parentElement, _isTracked, dataTagPrefix);
+                    var closestParentElement = walkUpDomChainWithElementValidation(element[_DYN_PARENT_ELEMENT ], _isTracked, dataTagPrefix);
                     if (closestParentElement) {
-                        var dataAttr = closestParentElement.getAttribute(aiBlobAttributeTag) || element[aiBlobAttributeTag];
+                        var dataAttr = closestParentElement[_DYN_GET_ATTRIBUTE ](aiBlobAttributeTag) || element[aiBlobAttributeTag];
                         if (dataAttr) {
                             try {
                                 var telemetryObject = JSON.parse(dataAttr);
@@ -2812,16 +2904,16 @@ this.Microsoft = this.Microsoft || {};
                             }
                         }
                         else {
-                            parentId = closestParentElement.getAttribute(dataTagPrefix + "id");
+                            parentId = closestParentElement[_DYN_GET_ATTRIBUTE ](dataTagPrefix + "id");
                         }
                     }
                     if (parentId) {
                         parentInfo["parentid"] = parentId;
                     }
                     else {
-                        var htmlContent = _getHtmlIdAndContentName(element.parentElement);
+                        var htmlContent = _getHtmlIdAndContentName(element[_DYN_PARENT_ELEMENT ]);
                         parentInfo["parentid"] = htmlContent.id;
-                        parentInfo["parentname"] = htmlContent.contentName;
+                        parentInfo["parentname"] = htmlContent[_DYN_CONTENT_NAME ];
                     }
                     return parentInfo;
                 }
@@ -2848,14 +2940,14 @@ this.Microsoft = this.Microsoft || {};
                     if (isNullOrUndefined(core)) {
                         throwError("Error initializing");
                     }
-                    config.extensionConfig = config.extensionConfig || [];
-                    config.extensionConfig[_identifier] = config.extensionConfig[_identifier] || {};
-                    _config = mergeConfig(config.extensionConfig[_identifier]);
+                    config[_DYN_EXTENSION_CONFIG ] = config[_DYN_EXTENSION_CONFIG ] || [];
+                    config[_DYN_EXTENSION_CONFIG ][_identifier] = config[_DYN_EXTENSION_CONFIG ][_identifier] || {};
+                    _config = mergeConfig(config[_DYN_EXTENSION_CONFIG ][_identifier]);
                     _super.prototype.initialize.call(_this, config, core, extensions, pluginChain);
                     var logger = _self.diagLog();
                     _contentHandler = _contentHandler ? _contentHandler : new DomContentHandler(_config, logger);
                     var metaTags = _contentHandler.getMetadata();
-                    _pageAction = new PageAction(_this, _config, _contentHandler, _config.callback.pageActionPageTags, metaTags, logger);
+                    _pageAction = new PageAction(_this, _config, _contentHandler, _config.callback[_DYN_PAGE_ACTION_PAGE_TAG0 ], metaTags, logger);
                     _autoCaptureHandler = _autoCaptureHandler ? _autoCaptureHandler : new AutoCaptureHandler(_self, _config, _pageAction, logger);
                     if (_config.autoCapture) {
                         _autoCaptureHandler.click();
@@ -2874,9 +2966,9 @@ this.Microsoft = this.Microsoft || {};
                 _self.processTelemetry = function (env, itemCtx) {
                     _self.processNext(env, itemCtx);
                 };
-                _self.trackPageAction = function (pageAction, customProperties) {
+                _self[_DYN_TRACK_PAGE_ACTION ] = function (pageAction, customProperties) {
                     try {
-                        _pageAction.trackPageAction(pageAction, customProperties);
+                        _pageAction[_DYN_TRACK_PAGE_ACTION ](pageAction, customProperties);
                     }
                     catch (e) {
                         _throwInternal(_self.diagLog(), 1 , 103 , "trackPageAction failed, page action event will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
@@ -2898,7 +2990,7 @@ this.Microsoft = this.Microsoft || {};
             }
             return _this;
         }
-        ClickAnalyticsPlugin.Version = "2.8.5-nightly.2206-04";
+        ClickAnalyticsPlugin.Version = "2.8.5-nightly.2206-06";
         return ClickAnalyticsPlugin;
     }(BaseTelemetryPlugin));