@microsoft/applicationinsights-clickanalytics-js 3.0.0-beta.2302-03 → 3.0.0-beta.2302-05

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

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Click Analytics, 3.0.0-beta.2302-03
+ * Application Insights JavaScript SDK - Click Analytics, 3.0.0-beta.2302-05
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 this.Microsoft = this.Microsoft || {};
@@ -390,7 +390,8 @@ this.Microsoft = this.Microsoft || {};
             return typeof value === theType;
         };
     }
-    function _createObjIs(theType) {
+    function _createObjIs(theName) {
+        var theType = "[object " + theName + "]";
         return function (value) {
             return !!(value && objToString(value) === theType);
         };
@@ -418,7 +419,7 @@ this.Microsoft = this.Microsoft || {};
     var isArray = ArrCls.isArray;
     var isNumber = _createIs(NUMBER);
     var isBoolean = _createIs(BOOLEAN);
-    var isError = _createObjIs("[object Error]");
+    var isError = _createObjIs("Error");
 
     var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
 
@@ -451,9 +452,7 @@ this.Microsoft = this.Microsoft || {};
     }
 
     var _objFreeze = ObjClass["freeze"];
-    function _doNothing(value) {
-        return value;
-    }
+    var _doNothing = function (value) { return value; };
     ObjClass["assign"];
     function objKeys(value) {
         if (!isObject(value) || value === null) {
@@ -503,6 +502,40 @@ this.Microsoft = this.Microsoft || {};
         return _globalCfg;
     }
 
+    function dumpObj(object, format) {
+        var propertyValueDump = "";
+        if (isError(object)) {
+            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
+        }
+        else {
+            try {
+                propertyValueDump = JSON.stringify(object, null, format ? (isNumber(format) ? format : 4) : UNDEF_VALUE);
+            }
+            catch (e) {
+                propertyValueDump = " - " + dumpObj(e, format);
+            }
+        }
+        return objToString(object) + ": " + propertyValueDump;
+    }
+
+    function _extractArgs(args, startAt) {
+        var theArgs = [];
+        for (var lp = startAt; lp < args[LENGTH]; lp++) {
+            theArgs[lp - startAt] = args[lp];
+        }
+        return theArgs;
+    }
+
+    function _unwrapFunction(funcName) {
+        return function (thisArg) {
+            var args = _extractArgs(arguments, 1);
+            if ((thisArg || thisArg === EMPTY) && thisArg[funcName]) {
+                return thisArg[funcName].apply(thisArg, args);
+            }
+            throwTypeError("'" + funcName + "' not defined for " + dumpObj(thisArg));
+        };
+    }
+
     var _polySymbols;
     function _globalSymbolRegistry() {
         if (!_polySymbols) {
@@ -602,6 +635,9 @@ this.Microsoft = this.Microsoft || {};
     var _cachedWindow;
     var _cachedDocument;
     var _cachedNavigator;
+    function _lazySafeGetInst(name) {
+        return _lazySafeGet(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
+    }
     function getGlobal(useCached) {
         (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = _lazySafeGet(_getGlobalValue, null));
         return _cachedGlobal.v;
@@ -620,29 +656,34 @@ this.Microsoft = this.Microsoft || {};
         return !!getDocument();
     }
     function getDocument() {
-        (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = _lazySafeGet(function () { return getInst(DOCUMENT); }, UNDEF_VALUE));
+        (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = _lazySafeGetInst(DOCUMENT));
         return _cachedDocument.v;
     }
     function hasWindow() {
         return !!getWindow();
     }
     function getWindow() {
-        (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = _lazySafeGet(function () { return getInst(WINDOW); }, UNDEF_VALUE));
+        (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = _lazySafeGetInst(WINDOW));
         return _cachedWindow.v;
     }
     function getNavigator() {
-        (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = _lazySafeGet(function () { return getInst(NAVIGATOR); }, UNDEF_VALUE));
+        (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = _lazySafeGetInst(NAVIGATOR));
         return _cachedNavigator.v;
     }
 
     var _symbol;
     var _symbolFor;
     var _symbolKeyFor;
+    function _getSymbolValue(name) {
+        return _lazySafeGet(function () {
+            return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
+        }, UNDEF_VALUE);
+    }
     function getSymbol() {
         var resetCache = !_symbol || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_symbol.b);
-        resetCache && (_symbol = _lazySafeGet(function () { return isDefined(Symbol) ? getInst(SYMBOL) : UNDEF_VALUE; }, UNDEF_VALUE));
-        (!_symbolFor || resetCache) && (_symbolFor = _lazySafeGet(function () { return _symbol.v ? _symbol["for"] : UNDEF_VALUE; }, UNDEF_VALUE));
-        (!_symbolKeyFor || resetCache) && (_symbolKeyFor = _lazySafeGet(function () { return _symbol.v ? _symbol["keyFor"] : UNDEF_VALUE; }, UNDEF_VALUE));
+        resetCache && (_symbol = _lazySafeGetInst(SYMBOL));
+        (!_symbolFor || resetCache) && (_symbolFor = _getSymbolValue("for"));
+        (!_symbolKeyFor || resetCache) && (_symbolKeyFor = _getSymbolValue("keyFor"));
         return _symbol.v;
     }
     function newSymbol(description, noPoly) {
@@ -690,46 +731,6 @@ this.Microsoft = this.Microsoft || {};
         }
     }
 
-    function dumpObj(object, format) {
-        var objectTypeDump = objToString(object);
-        var propertyValueDump = "";
-        if (objectTypeDump === "[object Error]") {
-            propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
-        }
-        else {
-            try {
-                if (format) {
-                    if (isNumber(format)) {
-                        propertyValueDump = JSON.stringify(object, null, format);
-                    }
-                    else {
-                        propertyValueDump = JSON.stringify(object, null, 4);
-                    }
-                }
-                else {
-                    propertyValueDump = JSON.stringify(object);
-                }
-            }
-            catch (e) {
-                propertyValueDump = objToString(object) + " - " + dumpObj(e, format);
-            }
-        }
-        return objectTypeDump + ": " + propertyValueDump;
-    }
-
-    function _unwrapFunction(funcName) {
-        return function (thisArg) {
-            var args = [];
-            for (var _i = 1; _i < arguments.length; _i++) {
-                args[_i - 1] = arguments[_i];
-            }
-            if ((thisArg || thisArg === EMPTY) && thisArg[funcName]) {
-                return thisArg[funcName].apply(thisArg, args);
-            }
-            throwTypeError("'" + funcName + "' not defined for " + dumpObj(thisArg));
-        };
-    }
-
     var arrIndexOf = _unwrapFunction(INDEX_OF);
 
     function objSetPrototypeOf(obj, proto) {
@@ -738,9 +739,7 @@ this.Microsoft = this.Microsoft || {};
                 d.__proto__ = b;
             }) ||
             function (d, b) {
-                objForEachKey(b, function (key, value) {
-                    d[key] = value;
-                });
+                objForEachKey(b, function (key, value) { return d[key] = value; });
             };
         return fn(obj, proto);
     }
@@ -773,7 +772,7 @@ this.Microsoft = this.Microsoft || {};
         return new Date().getTime();
     }
 
-    var _fnToString$1;
+    var _fnToString;
     var _objCtrFnString;
     var _gblWindow;
     function isPlainObject(value) {
@@ -786,8 +785,8 @@ this.Microsoft = this.Microsoft || {};
         var result = false;
         if (value !== _gblWindow) {
             if (!_objCtrFnString) {
-                _fnToString$1 = Function[PROTOTYPE].toString;
-                _objCtrFnString = _fnToString$1.call(ObjClass);
+                _fnToString = Function[PROTOTYPE].toString;
+                _objCtrFnString = _fnToString.call(ObjClass);
             }
             try {
                 var proto = objGetPrototypeOf(value);
@@ -796,7 +795,7 @@ this.Microsoft = this.Microsoft || {};
                     if (objHasOwnProperty(proto, CONSTRUCTOR)) {
                         proto = proto[CONSTRUCTOR];
                     }
-                    result = proto && typeof proto === FUNCTION && _fnToString$1.call(proto) === _objCtrFnString;
+                    result = proto && typeof proto === FUNCTION && _fnToString.call(proto) === _objCtrFnString;
                 }
             }
             catch (ex) {
@@ -807,7 +806,7 @@ this.Microsoft = this.Microsoft || {};
 
     var _perf;
     function getPerformance() {
-        (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = _lazySafeGet(function () { return getInst("performance"); }, UNDEF_VALUE));
+        (!_perf || (_globalLazyTestHooks.lzy && !_perf.b)) && (_perf = _lazySafeGetInst("performance"));
         return _perf.v;
     }
 
@@ -851,14 +850,6 @@ this.Microsoft = this.Microsoft || {};
         return timer;
     }
 
-    function _extractArgs(args, startAt) {
-        var theArgs = [];
-        for (var lp = startAt; lp < args[LENGTH]; lp++) {
-            theArgs[lp - startAt] = args[lp];
-        }
-        return theArgs;
-    }
-
     function _createTimeoutWith(self, startTimer, overrideFn, theArgs) {
         var isArr = isArray(overrideFn);
         var len = isArr ? overrideFn.length : 0;
@@ -881,7 +872,9 @@ this.Microsoft = this.Microsoft || {};
         return _createTimeoutWith(this, true, UNDEF_VALUE, _extractArgs(arguments, 0));
     }
 
+    var _DYN_TO_LOWER_CASE = "toLowerCase";
     var _DYN_LENGTH$1 = "length";
+    var _DYN_RD_ONLY = "rdOnly";
     var _DYN_NOTIFY = "notify";
     var _DYN_THROW_INTERNAL = "throwInternal";
     var _DYN_SET_DF = "setDf";
@@ -918,7 +911,6 @@ this.Microsoft = this.Microsoft || {};
     var _DYN_REPLACE = "replace";
     var _DYN_ENABLE_DEBUG_EXCEPTI5 = "enableDebugExceptions";
     var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
-    var _DYN_TO_LOWER_CASE = "toLowerCase";
     var _DYN_TYPE = "type";
     var _DYN_HANDLER = "handler";
     var _DYN_IS_CHILD_EVT = "isChildEvt";
@@ -954,9 +946,6 @@ this.Microsoft = this.Microsoft || {};
     var STR_GET_PERF_MGR = "getPerfMgr";
     var STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";
 
-    var strToString = "toString";
-    var _fnToString = ObjClass$1[strToString];
-    _fnToString.call(ObjClass$1);
     var rCamelCase = /-([a-z])/g;
     var rNormalizeInvalid = /([^\w\d_$])/g;
     var rLeadingNumeric = /^(\d+[\w\d_$])/;
@@ -1181,7 +1170,7 @@ this.Microsoft = this.Microsoft || {};
     }
 
     var _objDefineProperty = ObjDefineProperty;
-    var version = "3.0.0-beta.2302-03";
+    var version = "3.0.0-beta.2302-05";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _createAccessor(target, prop, value) {
@@ -1254,39 +1243,9 @@ this.Microsoft = this.Microsoft || {};
         return data;
     }
 
-    var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_1]]");
-    function _cfgDeepCopy(source) {
-        if (source) {
-            var target_1;
-            if (isArray(source)) {
-                target_1 = [];
-                target_1[_DYN_LENGTH$1 ] = source[_DYN_LENGTH$1 ];
-            }
-            else if (isPlainObject(source)) {
-                target_1 = {};
-            }
-            if (target_1) {
-                objForEachKey(source, function (key, value) {
-                    target_1[key] = _cfgDeepCopy(value);
-                });
-                return target_1;
-            }
-        }
-        return source;
+    function _isConfigDefaults(value) {
+        return (value && isObject(value) && (value.isVal || value.fb || objHasOwn(value, "v") || objHasOwn(value, "mrg") || objHasOwn(value, "ref") || value.set));
     }
-    function getDynamicConfigHandler(value) {
-        if (value) {
-            var handler = value[CFG_HANDLER_LINK] || value;
-            if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
-                return handler;
-            }
-        }
-        return null;
-    }
-    function throwInvalidAccess(message) {
-        throwTypeError("InvalidAccess:" + message);
-    }
-
     function _getDefault(dynamicHandler, theConfig, cfgDefaults) {
         var defValue;
         var isDefaultValid = cfgDefaults.dfVal || isDefined;
@@ -1301,7 +1260,7 @@ this.Microsoft = this.Microsoft || {};
                 if (isDefaultValid(fbValue)) {
                     defValue = fbValue;
                 }
-                else {
+                else if (dynamicHandler) {
                     fbValue = dynamicHandler.cfg[fallback];
                     if (isDefaultValid(fbValue)) {
                         defValue = fbValue;
@@ -1318,27 +1277,63 @@ this.Microsoft = this.Microsoft || {};
         }
         return defValue;
     }
+    function _resolveDefaultValue(dynamicHandler, theConfig, cfgDefaults) {
+        var theValue = cfgDefaults;
+        if (cfgDefaults && _isConfigDefaults(cfgDefaults)) {
+            theValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
+        }
+        if (theValue) {
+            if (_isConfigDefaults(theValue)) {
+                theValue = _resolveDefaultValue(dynamicHandler, theConfig, theValue);
+            }
+            var newValue_1;
+            if (isArray(theValue)) {
+                newValue_1 = [];
+                newValue_1[_DYN_LENGTH$1 ] = theValue[_DYN_LENGTH$1 ];
+            }
+            else if (isPlainObject(theValue)) {
+                newValue_1 = {};
+            }
+            if (newValue_1) {
+                objForEachKey(theValue, function (key, value) {
+                    if (value && _isConfigDefaults(value)) {
+                        value = _resolveDefaultValue(dynamicHandler, theConfig, value);
+                    }
+                    newValue_1[key] = value;
+                });
+                theValue = newValue_1;
+            }
+        }
+        return theValue;
+    }
     function _applyDefaultValue(dynamicHandler, theConfig, name, defaultValue) {
         var isValid;
         var setFn;
         var defValue;
         var cfgDefaults = defaultValue;
-        if (cfgDefaults && isObject(cfgDefaults) && (cfgDefaults.isVal || cfgDefaults.set || cfgDefaults.fb || objHasOwn(cfgDefaults, "v"))) {
+        var mergeDf;
+        var reference;
+        var readOnly;
+        if (_isConfigDefaults(cfgDefaults)) {
             isValid = cfgDefaults.isVal;
             setFn = cfgDefaults.set;
+            readOnly = cfgDefaults[_DYN_RD_ONLY ];
+            mergeDf = cfgDefaults.mrg;
+            reference = cfgDefaults.ref;
+            if (!reference && isUndefined(reference)) {
+                reference = !!mergeDf;
+            }
             defValue = _getDefault(dynamicHandler, theConfig, cfgDefaults);
         }
         else {
             defValue = defaultValue;
         }
-        var theValue = defValue;
+        var theValue;
         var usingDefault = true;
         var cfgValue = theConfig[name];
         if (cfgValue || !isNullOrUndefined(cfgValue)) {
             theValue = cfgValue;
             usingDefault = false;
-        }
-        if (!usingDefault) {
             if (isValid && theValue !== defValue && !isValid(theValue)) {
                 theValue = defValue;
                 usingDefault = true;
@@ -1348,10 +1343,61 @@ this.Microsoft = this.Microsoft || {};
                 usingDefault = theValue === defValue;
             }
         }
-        if (theValue && usingDefault && (isPlainObject(theValue) || isArray(theValue))) {
-            theValue = _cfgDeepCopy(theValue);
+        if (!usingDefault) {
+            if (isPlainObject(theValue) || isArray(defValue)) {
+                if (mergeDf && defValue && (isPlainObject(defValue) || isArray(defValue))) {
+                    objForEachKey(defValue, function (dfName, dfValue) {
+                        _applyDefaultValue(dynamicHandler, theValue, dfName, dfValue);
+                    });
+                }
+            }
+        }
+        else if (defValue) {
+            theValue = _resolveDefaultValue(dynamicHandler, theConfig, defValue);
+        }
+        else {
+            theValue = defValue;
         }
         dynamicHandler.set(theConfig, name, theValue);
+        if (reference) {
+            dynamicHandler.ref(theConfig, name);
+        }
+        if (readOnly) {
+            dynamicHandler[_DYN_RD_ONLY ](theConfig, name);
+        }
+    }
+
+    var CFG_HANDLER_LINK = symbolFor("[[ai_dynCfg_1]]");
+    function _cfgDeepCopy(source) {
+        if (source) {
+            var target_1;
+            if (isArray(source)) {
+                target_1 = [];
+                target_1[_DYN_LENGTH$1 ] = source[_DYN_LENGTH$1 ];
+            }
+            else if (isPlainObject(source)) {
+                target_1 = {};
+            }
+            if (target_1) {
+                objForEachKey(source, function (key, value) {
+                    target_1[key] = _cfgDeepCopy(value);
+                });
+                return target_1;
+            }
+        }
+        return source;
+    }
+    function getDynamicConfigHandler(value) {
+        if (value) {
+            var handler = value[CFG_HANDLER_LINK] || value;
+            if (handler.cfg && (handler.cfg === value || handler.cfg[CFG_HANDLER_LINK] === handler)) {
+                return handler;
+            }
+        }
+        return null;
+    }
+    function throwInvalidAccess(message) {
+        throwTypeError("InvalidAccess:" + message);
     }
 
     var arrayMethodsToPatch = [
@@ -1531,7 +1577,7 @@ this.Microsoft = this.Microsoft || {};
                     set: cfgHandler.set.bind(cfgHandler),
                     setDf: cfgHandler[_DYN_SET_DF ].bind(cfgHandler),
                     ref: cfgHandler.ref.bind(cfgHandler),
-                    rdOnly: cfgHandler.rdOnly.bind(cfgHandler)
+                    rdOnly: cfgHandler[_DYN_RD_ONLY ].bind(cfgHandler)
                 });
             }
             catch (e) {
@@ -1681,7 +1727,7 @@ this.Microsoft = this.Microsoft || {};
             _a[_DYN_SET_DF ] = _applyDefaults,
             _a[_DYN_WATCH ] = _watch,
             _a.ref = _ref,
-            _a.rdOnly = _rdOnly,
+            _a[_DYN_RD_ONLY ] = _rdOnly,
             _a._block = _block,
             _a);
         objDefineProp(cfgHandler, "uid", (_b = {},
@@ -1719,6 +1765,32 @@ this.Microsoft = this.Microsoft || {};
         createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
     }
 
+    function cfgDfMerge(defaultValue) {
+        return {
+            mrg: true,
+            v: defaultValue
+        };
+    }
+    function cfgDfValidate(validator, defaultValue, fallBackName) {
+        return {
+            fb: fallBackName,
+            isVal: validator,
+            v: defaultValue
+        };
+    }
+    function cfgDfFunc(defaultValue) {
+        return {
+            isVal: isFunction,
+            v: defaultValue || null
+        };
+    }
+    function cfgDfString(defaultValue) {
+        return {
+            isVal: isString,
+            v: asString(defaultValue || STR_EMPTY)
+        };
+    }
+
     var _aiNamespace = null;
     function _getExtensionNamespace() {
         var target = getInst("Microsoft");
@@ -2770,23 +2842,26 @@ this.Microsoft = this.Microsoft || {};
     var _DYN_TRACK_PAGE_ACTION = "trackPageAction";
     var _DYN_PAGE_ACTION_PAGE_TAG0 = "pageActionPageTags";
     var _DYN__DO_UNLOAD = "_doUnload";
-    var _DYN_USE_DEFAULT_CONTENT_1 = "useDefaultContentNameOrId";
-    var _DYN_CAPTURE_ALL_META_DAT2 = "captureAllMetaDataContent";
     var _DYN_PAGE_NAME = "pageName";
     var _DYN_CONTENT_NAME = "contentName";
+    var _DYN_REQUEST_URI = "requestUri";
+    var _DYN_PAGE_TYPE = "pageType";
+    var _DYN_USE_DEFAULT_CONTENT_1 = "useDefaultContentNameOrId";
+    var _DYN_CAPTURE_ALL_META_DAT2 = "captureAllMetaDataContent";
+    var _DYN_META_DATA_PREFIX = "metaDataPrefix";
+    var _DYN_PARENT_DATA_TAG = "parentDataTag";
     var _DYN_BEHAVIOR_VALIDATOR = "behaviorValidator";
+    var _DYN_DEFAULT_RIGHT_CLICK_3 = "defaultRightClickBhvr";
     var _DYN_LENGTH = "length";
     var _DYN_TAG_NAME = "tagName";
     var _DYN_TO_UPPER_CASE = "toUpperCase";
     var _DYN_PATHNAME = "pathname";
     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_NAME = "name";
     var _DYN_DATA = "data";
-    var _DYN_PAGE_TYPE = "pageType";
     var _DYN_PROPERTIES = "properties";
     var _DYN_ACTION_TYPE = "actionType";
     var _DYN_BEHAVIOR = "behavior";
@@ -2795,7 +2870,7 @@ this.Microsoft = this.Microsoft || {};
     var _DYN_REF_URI = "refUri";
     var _DYN_PARENT_ID = "parentId";
     var _DYN_CAPTURE_PAGE_ACTION = "capturePageAction";
-    var _DYN_SET_COMMON_PROPERTIE3 = "setCommonProperties";
+    var _DYN_SET_COMMON_PROPERTIE4 = "setCommonProperties";
     var _DYN_GET_ELEMENT_CONTENT = "getElementContent";
     var _DYN__GET_VALID_BEHAVIOR = "_getValidBehavior";
     var _DYN__TRACE_LOGGER = "_traceLogger";
@@ -2803,7 +2878,6 @@ this.Microsoft = this.Microsoft || {};
     var _DYN_CLICK_COORDINATE_Y = "clickCoordinateY";
     var _DYN__CONFIG = "_config";
     var _DYN_DATA_TAGS = "dataTags";
-    var _DYN_PARENT_DATA_TAG = "parentDataTag";
     var _DYN__PAGE_TAGS = "_pageTags";
     var _DYN__PAGE_TAGS_CALLBACK = "_pageTagsCallback";
     var _DYN__META_TAGS = "_metaTags";
@@ -3016,8 +3090,8 @@ this.Microsoft = this.Microsoft || {};
         return url;
     }
     function getUri(config, location) {
-        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 ];
+        if (config.coreData && config.coreData[_DYN_REQUEST_URI ] && config[_DYN_CORE_DATA ][_DYN_REQUEST_URI ] !== "") {
+            return config.coreData[_DYN_REQUEST_URI ];
         }
         return sanitizeUrl(config, location);
     }
@@ -3043,7 +3117,7 @@ this.Microsoft = this.Microsoft || {};
                         event.uri = getUri(_self[_DYN__CONFIG ], getLocation());
                     }
                 };
-                _self[_DYN_SET_COMMON_PROPERTIE3 ] = function (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[_DYN_CORE_DATA ], "pageType");
@@ -3122,7 +3196,7 @@ this.Microsoft = this.Microsoft || {};
                     _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.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 ]);
@@ -3146,11 +3220,11 @@ this.Microsoft = this.Microsoft || {};
                     overrideValues = !isValueAssigned(overrideValues) ? {} : overrideValues;
                     var pageActionEvent = { name: "" };
                     var pageActionProperties = isValueAssigned(customProperties) ? customProperties : {};
-                    _self[_DYN_SET_COMMON_PROPERTIE3 ](pageActionEvent, overrideValues);
+                    _self[_DYN_SET_COMMON_PROPERTIE4 ](pageActionEvent, overrideValues);
                     pageActionEvent[_DYN_BEHAVIOR ] = _self._getBehavior(overrideValues);
                     var elementContent = {};
                     if (isRightClick) {
-                        pageActionEvent[_DYN_BEHAVIOR ] = _self[_DYN__CONFIG ].defaultRightClickBhvr;
+                        pageActionEvent.behavior = _self._config[_DYN_DEFAULT_RIGHT_CLICK_3 ];
                     }
                     if (element) {
                         pageActionEvent.targetUri = getClickTarget(element);
@@ -3200,7 +3274,7 @@ this.Microsoft = this.Microsoft || {};
                         delete pageActionContent.id;
                         delete pageActionContent.parentid;
                         delete pageActionContent.parentname;
-                        if (_self[_DYN__CONFIG ] && _self[_DYN__CONFIG ][_DYN_DATA_TAGS ] && isValueAssigned(_self[_DYN__CONFIG ][_DYN_DATA_TAGS ][_DYN_PARENT_DATA_TAG ])) {
+                        if (_self._config && _self._config.dataTags && isValueAssigned(_self._config.dataTags[_DYN_PARENT_DATA_TAG ])) {
                             delete pageActionContent[_self[_DYN__CONFIG ][_DYN_DATA_TAGS ].parentDataTag];
                         }
                     }
@@ -3333,7 +3407,7 @@ this.Microsoft = this.Microsoft || {};
                     var dataTags = (_self[_DYN__CONFIG ] || {})[_DYN_DATA_TAGS ];
                     var metaTags = {};
                     if (hasDocument) {
-                        metaTags = isValueAssigned(dataTags.metaDataPrefix) ? _getMetaDataFromDOM(dataTags[_DYN_CAPTURE_ALL_META_DAT2 ], dataTags.metaDataPrefix, false) :
+                        metaTags = isValueAssigned(dataTags.metaDataPrefix) ? _getMetaDataFromDOM(dataTags[_DYN_CAPTURE_ALL_META_DAT2 ], dataTags[_DYN_META_DATA_PREFIX ], false) :
                             _getMetaDataFromDOM(dataTags[_DYN_CAPTURE_ALL_META_DAT2 ], "", false);
                     }
                     return metaTags;
@@ -3519,7 +3593,7 @@ this.Microsoft = this.Microsoft || {};
                         return htmlContent;
                     }
                     if (dataTags[_DYN_USE_DEFAULT_CONTENT_1 ]) {
-                        var customizedContentName = callback.contentName ? callback.contentName(element, dataTags[_DYN_USE_DEFAULT_CONTENT_1 ]) : "";
+                        var customizedContentName = callback[_DYN_CONTENT_NAME ] ? callback[_DYN_CONTENT_NAME ](element, dataTags[_DYN_USE_DEFAULT_CONTENT_1 ]) : "";
                         var defaultContentName = _getDefaultContentName(element, dataTags[_DYN_USE_DEFAULT_CONTENT_1 ]);
                         htmlContent = (_a = {
                                 id: element.id
@@ -3575,50 +3649,40 @@ this.Microsoft = this.Microsoft || {};
         return DomContentHandler;
     }());
 
-    var _a, _b, _c;
-    var dataTagsDefault = (_a = {},
-        _a[_DYN_USE_DEFAULT_CONTENT_1 ] = false,
-        _a.aiBlobAttributeTag = DEFAULT_AI_BLOB_ATTRIBUTE_TAG,
-        _a.customDataPrefix = DEFAULT_DATA_PREFIX,
-        _a[_DYN_CAPTURE_ALL_META_DAT2 ] = false,
-        _a.dntDataTag = DEFAULT_DONOT_TRACK_TAG,
-        _a.metaDataPrefix = "",
-        _a.parentDataTag = "",
-        _a);
-    var coreDataDefault = {
-        eferrerUri: hasDocument ? document.referrer : "",
-        requestUri: "",
-        pageName: "",
-        pageType: ""
-    };
-    var defaultValues = objDeepFreeze((_b = {
+    var _a, _b, _c, _d;
+    var defaultValues = objDeepFreeze((_a = {
             autoCapture: true,
-            callback: (_c = {},
-                _c[_DYN_PAGE_ACTION_PAGE_TAG0 ] = null,
-                _c[_DYN_PAGE_NAME ] = null,
-                _c[_DYN_CONTENT_NAME ] = null,
-                _c),
+            callback: cfgDfMerge((_b = {},
+                _b[_DYN_PAGE_ACTION_PAGE_TAG0 ] = cfgDfFunc(),
+                _b[_DYN_PAGE_NAME ] = cfgDfFunc(),
+                _b[_DYN_CONTENT_NAME ] = cfgDfFunc(),
+                _b)),
             pageTags: {},
-            coreData: { set: _setProp, v: coreDataDefault },
-            dataTags: { set: _setProp, v: dataTagsDefault }
+            coreData: cfgDfMerge((_c = {
+                    referrerUri: hasDocument ? document.referrer : ""
+                },
+                _c[_DYN_REQUEST_URI ] = cfgDfString(),
+                _c[_DYN_PAGE_NAME ] = cfgDfString(),
+                _c[_DYN_PAGE_TYPE ] = cfgDfString(),
+                _c)),
+            dataTags: cfgDfMerge((_d = {},
+                _d[_DYN_USE_DEFAULT_CONTENT_1 ] = false,
+                _d.aiBlobAttributeTag = DEFAULT_AI_BLOB_ATTRIBUTE_TAG,
+                _d.customDataPrefix = cfgDfValidate(_dataPrefixChk, DEFAULT_DATA_PREFIX),
+                _d[_DYN_CAPTURE_ALL_META_DAT2 ] = false,
+                _d.dntDataTag = DEFAULT_DONOT_TRACK_TAG,
+                _d[_DYN_META_DATA_PREFIX ] = cfgDfString(),
+                _d[_DYN_PARENT_DATA_TAG ] = cfgDfString(),
+                _d))
         },
-        _b[_DYN_BEHAVIOR_VALIDATOR ] = function (key) { return key || ""; },
-        _b.defaultRightClickBhvr = "",
-        _b.dropInvalidEvents = false,
-        _b.urlCollectHash = false,
-        _b.urlCollectQuery = false,
-        _b));
-    function _setProp(val, def) {
-        if (def && isObject(def)) {
-            objForEachKey(def, function (key, obj) {
-                val[key] = val[key] || obj;
-                if (key === "customDataPrefix") {
-                    var prefix = val[key];
-                    val[key] = prefix && prefix[_DYN_INDEX_OF ](DEFAULT_DATA_PREFIX) === 0 ? prefix : DEFAULT_DATA_PREFIX;
-                }
-            });
-        }
-        return val;
+        _a[_DYN_BEHAVIOR_VALIDATOR ] = cfgDfFunc(function (key) { return key || ""; }),
+        _a[_DYN_DEFAULT_RIGHT_CLICK_3 ] = cfgDfString(),
+        _a.dropInvalidEvents = false,
+        _a.urlCollectHash = false,
+        _a.urlCollectQuery = false,
+        _a));
+    function _dataPrefixChk(val) {
+        return val && val[_DYN_INDEX_OF ](DEFAULT_DATA_PREFIX) === 0;
     }
     var ClickAnalyticsPlugin = /** @class */ (function (_super) {
         __extendsFn(ClickAnalyticsPlugin, _super);
@@ -3706,7 +3770,7 @@ this.Microsoft = this.Microsoft || {};
             }
             return _this;
         }
-        ClickAnalyticsPlugin.Version = "3.0.0-beta.2302-03";
+        ClickAnalyticsPlugin.Version = "3.0.0-beta.2302-05";
         return ClickAnalyticsPlugin;
     }(BaseTelemetryPlugin));