@microsoft/applicationinsights-clickanalytics-js 2.8.0-beta.2203-08 → 2.8.0-beta.2203-11

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

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Click Analytics, 2.8.0-beta.2203-08
+ * Application Insights JavaScript SDK - Click Analytics, 2.8.0-beta.2203-11
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 this.Microsoft = this.Microsoft || {};
@@ -73,7 +73,9 @@ this.Microsoft = this.Microsoft || {};
     var __assignFn = ObjAssign || __objAssignFnImpl;
     var extendStaticsFn = function (d, b) {
         extendStaticsFn = ObjClass["setPrototypeOf"] ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            ({ __proto__: [] } instanceof Array && function (d, b) {
+                d.__proto__ = b;
+            }) ||
             function (d, b) {
                 for (var p in b) {
                     if (b[strShimHasOwnProperty](p)) {
@@ -88,7 +90,9 @@ this.Microsoft = this.Microsoft || {};
             throwTypeError("Class extends value " + String(b) + " is not a constructor or null");
         }
         extendStaticsFn(d, b);
-        function __() { this.constructor = d; }
+        function __() {
+            this.constructor = d;
+        }
         d[strShimPrototype] = b === null ? objCreateFn(b) : (__[strShimPrototype] = b[strShimPrototype], new __());
     }
 
@@ -342,11 +346,23 @@ this.Microsoft = this.Microsoft || {};
     var strDisabled = "disabled";
     var strDoTeardown = "_doTeardown";
 
+    var strToISOString = "toISOString";
+    var cStrEndsWith = "endsWith";
+    var cStrStartsWith = "startsWith";
+    var cStrTrim = "trim";
     var strToString = "toString";
     var str__Proto = "__proto__";
     var strConstructor = "constructor";
     var _objDefineProperty$1 = ObjDefineProperty;
     var _objFreeze = ObjClass.freeze;
+    ObjClass.seal;
+    var _objKeys = ObjClass.keys;
+    var StringProto = String[strShimPrototype];
+    StringProto[cStrTrim];
+    StringProto[cStrEndsWith];
+    StringProto[cStrStartsWith];
+    var DateProto = Date[strShimPrototype];
+    DateProto[strToISOString];
     var _isArray = Array.isArray;
     var _objToString = ObjProto[strToString];
     var _fnToString = ObjHasOwnProperty[strToString];
@@ -453,6 +469,40 @@ this.Microsoft = this.Microsoft || {};
         catch (e) {
         }
     }
+    var _objKeysHasDontEnumBug = !({ toString: null }).propertyIsEnumerable("toString");
+    var _objKeysDontEnums = [
+        "toString",
+        "toLocaleString",
+        "valueOf",
+        "hasOwnProperty",
+        "isPrototypeOf",
+        "propertyIsEnumerable",
+        "constructor"
+    ];
+    function objKeys(obj) {
+        var objType = typeof obj;
+        if (objType !== strShimFunction && (objType !== strShimObject || obj === null)) {
+            throwTypeError("objKeys called on non-object");
+        }
+        if (!_objKeysHasDontEnumBug && _objKeys) {
+            return _objKeys(obj);
+        }
+        var result = [];
+        for (var prop in obj) {
+            if (obj && ObjHasOwnProperty.call(obj, prop)) {
+                result.push(prop);
+            }
+        }
+        if (_objKeysHasDontEnumBug) {
+            var dontEnumsLength = _objKeysDontEnums.length;
+            for (var lp = 0; lp < dontEnumsLength; lp++) {
+                if (obj && ObjHasOwnProperty.call(obj, _objKeysDontEnums[lp])) {
+                    result.push(_objKeysDontEnums[lp]);
+                }
+            }
+        }
+        return result;
+    }
     function objDefineAccessors(target, prop, getProp, setProp) {
         if (_objDefineProperty$1) {
             try {
@@ -1046,7 +1096,7 @@ this.Microsoft = this.Microsoft || {};
     }
 
     var _objDefineProperty = ObjDefineProperty;
-    var version = "2.7.3";
+    var version = "2.8.0-beta.2203-11";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _createAccessor(target, prop, value) {
@@ -1117,10 +1167,28 @@ this.Microsoft = this.Microsoft || {};
         return data;
     }
 
+    var strDoUnload = "_doUnload";
     var pluginStateData = createElmNodeData("plugin");
     function _getPluginState(plugin) {
         return pluginStateData.get(plugin, "state", {}, true);
     }
+    function unloadComponents(components, unloadCtx, unloadState, asyncCallback) {
+        var idx = 0;
+        function _doUnload() {
+            while (idx < components.length) {
+                var component = components[idx++];
+                if (component) {
+                    var func = component[strDoUnload] || component[strDoTeardown];
+                    if (isFunction(func)) {
+                        if (func.call(component, unloadCtx, unloadState, _doUnload) === true) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return _doUnload();
+    }
 
     var strTelemetryPluginChain = "TelemetryPluginChain";
     var strHasRunFlags = "_hasRun";
@@ -1144,7 +1212,9 @@ this.Microsoft = this.Microsoft || {};
         var context = {
             _next: _moveNext,
             ctx: {
-                core: function () { return core; },
+                core: function () {
+                    return core;
+                },
                 diagLog: function () {
                     return safeGetLogger(core, config);
                 },
@@ -1639,9 +1709,13 @@ this.Microsoft = this.Microsoft || {};
     var strOnPrefix = "on";
     var strAttachEvent = "attachEvent";
     var strAddEventHelper = "addEventListener";
+    var strDetachEvent = "detachEvent";
+    var strRemoveEventListener = "removeEventListener";
     var strEvents = "events";
     createUniqueNamespace("aiEvtPageHide");
     createUniqueNamespace("aiEvtPageShow");
+    var rRemoveEmptyNs = /\.[\.]+/g;
+    var rRemoveTrailingEmptyNs = /[\.]+$/;
     var _guid = 1;
     var elmNodeData = createElmNodeData("events");
     var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
@@ -1676,10 +1750,10 @@ this.Microsoft = this.Microsoft || {};
                 eventName = (eventName || "") + theNamespace_1;
             }
         }
-        var parsedEvent = (eventNamespace.exec(eventName) || []);
+        var parsedEvent = (eventNamespace.exec(eventName || "") || []);
         return {
             type: parsedEvent[1],
-            ns: ((parsedEvent[2] || "").split(".").sort()).join(".")
+            ns: ((parsedEvent[2] || "").replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, "").split(".").sort()).join(".")
         };
     }
     function _getRegisteredEvents(target, evtName, addDefault) {
@@ -1691,6 +1765,16 @@ this.Microsoft = this.Microsoft || {};
         }
         return registeredEvents;
     }
+    function _doDetach(obj, evtName, handlerRef, useCapture) {
+        if (obj && evtName && evtName.type) {
+            if (obj[strRemoveEventListener]) {
+                obj[strRemoveEventListener](evtName.type, handlerRef, useCapture);
+            }
+            else if (obj[strDetachEvent]) {
+                obj[strDetachEvent](strOnPrefix + evtName.type, handlerRef);
+            }
+        }
+    }
     function _doAttach(obj, evtName, handlerRef, useCapture) {
         var result = false;
         if (obj && evtName && evtName.type && handlerRef) {
@@ -1705,6 +1789,50 @@ this.Microsoft = this.Microsoft || {};
         }
         return result;
     }
+    function _doUnregister(target, events, evtName, unRegFn) {
+        var idx = events.length;
+        while (idx--) {
+            var theEvent = events[idx];
+            if (theEvent) {
+                if (!evtName.ns || evtName.ns === theEvent.evtName.ns) {
+                    if (!unRegFn || unRegFn(theEvent)) {
+                        _doDetach(target, theEvent.evtName, theEvent.handler, theEvent.capture);
+                        events.splice(idx, 1);
+                    }
+                }
+            }
+        }
+    }
+    function _unregisterEvents(target, evtName, unRegFn) {
+        if (evtName.type) {
+            _doUnregister(target, _getRegisteredEvents(target, evtName.type), evtName, unRegFn);
+        }
+        else {
+            var eventCache = elmNodeData.get(target, strEvents, {});
+            objForEachKey(eventCache, function (evtType, events) {
+                _doUnregister(target, events, evtName, unRegFn);
+            });
+            if (objKeys(eventCache).length === 0) {
+                elmNodeData.kill(target, strEvents);
+            }
+        }
+    }
+    function mergeEvtNamespace(theNamespace, namespaces) {
+        var newNamespaces;
+        if (namespaces) {
+            if (isArray(namespaces)) {
+                newNamespaces = [theNamespace].concat(namespaces);
+            }
+            else {
+                newNamespaces = [theNamespace, namespaces];
+            }
+            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns).split(".");
+        }
+        else {
+            newNamespaces = theNamespace;
+        }
+        return newNamespaces;
+    }
     function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
         if (useCapture === void 0) { useCapture = false; }
         var result = false;
@@ -1727,9 +1855,26 @@ this.Microsoft = this.Microsoft || {};
         }
         return result;
     }
-    function attachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
+    function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {
         if (useCapture === void 0) { useCapture = false; }
-        return eventOn(obj, eventNameWithoutOn, handlerRef, null, useCapture);
+        if (target) {
+            try {
+                var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
+                var found_1 = false;
+                _unregisterEvents(target, evtName_1, function (regEvent) {
+                    if ((evtName_1.ns && !handlerRef) || regEvent.handler === handlerRef) {
+                        found_1 = true;
+                        return true;
+                    }
+                    return false;
+                });
+                if (!found_1) {
+                    _doDetach(target, evtName_1, handlerRef, useCapture);
+                }
+            }
+            catch (e) {
+            }
+        }
     }
 
     var LoggingSeverity = createEnumStyle({
@@ -2115,188 +2260,200 @@ this.Microsoft = this.Microsoft || {};
     }
 
     var WebEvent = /** @class */ (function () {
-        function WebEvent(_clickAnalyticsPlugin, _config, _contentHandler, _pageTagsCallback, _metaTags, _traceLogger) {
-            this._clickAnalyticsPlugin = _clickAnalyticsPlugin;
-            this._config = _config;
-            this._contentHandler = _contentHandler;
-            this._pageTagsCallback = _pageTagsCallback;
-            this._metaTags = _metaTags;
-            this._traceLogger = _traceLogger;
-            this._pageTags = {};
-        }
-        WebEvent.prototype.setBasicProperties = function (event, overrideValues) {
-            if (!isValueAssigned(event.name)) {
-                event.pageName = getPageName(this._config, overrideValues);
-            }
-            if (!isValueAssigned(event.uri) && hasWindow) {
-                event.uri = getUri(this._config, getLocation());
-            }
-        };
-        WebEvent.prototype.setCommonProperties = function (event, overrideValues) {
-            this.setBasicProperties(event, overrideValues);
-            this._setPageTags(event, overrideValues);
-            this._pageTypeMetaTag = this._getMetaData(this._metaTags, this._config.coreData, "pageType");
-            this._behaviorMetaTag = this._getMetaData(this._metaTags, this._config.coreData, "behavior");
-            if (isValueAssigned(overrideValues.pageType)) {
-                event.pageType = overrideValues.pageType;
-            }
-            if (isValueAssigned(this._pageTypeMetaTag) && !isValueAssigned(event.pageType)) {
-                event.pageType = this._pageTypeMetaTag;
-            }
-        };
-        WebEvent.prototype._setPageTags = function (event, overrideValues) {
-            if (this._pageTagsCallback) {
-                this._pageTags = extend(true, this._pageTags, this._pageTagsCallback());
-            }
-            if (isValueAssigned(overrideValues.pageTags)) {
-                this._pageTags = extend(true, this._pageTags, overrideValues.pageTags);
-            }
-            if (this._metaTags) {
-                this._pageTags.metaTags = {};
-                for (var metaTag in this._metaTags) {
-                    if (metaTag != "behavior" && metaTag != "market" && metaTag != "pageType") {
-                        this._pageTags.metaTags[metaTag] = this._metaTags[metaTag];
+        function WebEvent(clickAnalyticsPlugin, config, contentHandler, pageTagsCallback, metaTags, traceLogger) {
+            dynamicProto(WebEvent, this, function (_self) {
+                _initDefaults();
+                function _initDefaults() {
+                    _self._pageTags = {};
+                    _self._clickAnalyticsPlugin = clickAnalyticsPlugin;
+                    _self._config = config;
+                    _self._contentHandler = contentHandler;
+                    _self._pageTagsCallback = pageTagsCallback;
+                    _self._metaTags = metaTags;
+                    _self._traceLogger = traceLogger;
+                }
+                _self.setBasicProperties = function (event, overrideValues) {
+                    if (!isValueAssigned(event.name)) {
+                        event.pageName = getPageName(_self._config, overrideValues);
+                    }
+                    if (!isValueAssigned(event.uri) && hasWindow) {
+                        event.uri = getUri(_self._config, getLocation());
+                    }
+                };
+                _self.setCommonProperties = function (event, overrideValues) {
+                    _self.setBasicProperties(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;
+                    }
+                    if (isValueAssigned(_self._pageTypeMetaTag) && !isValueAssigned(event.pageType)) {
+                        event.pageType = _self._pageTypeMetaTag;
                     }
+                };
+                _self._setPageTags = function (event, overrideValues) {
+                    if (_self._pageTagsCallback) {
+                        _self._pageTags = extend(true, _self._pageTags, _self._pageTagsCallback());
+                    }
+                    if (isValueAssigned(overrideValues.pageTags)) {
+                        _self._pageTags = extend(true, _self._pageTags, overrideValues.pageTags);
+                    }
+                    if (_self._metaTags) {
+                        _self._pageTags.metaTags = {};
+                        for (var metaTag in _self._metaTags) {
+                            if (metaTag != "behavior" && metaTag != "market" && metaTag != "pageType") {
+                                _self._pageTags.metaTags[metaTag] = _self._metaTags[metaTag];
+                            }
+                        }
+                    }
+                    event.properties = event.properties || {};
+                    event.properties["pageTags"] = _self._pageTags;
+                };
+                _self._getBehavior = function (overrideValues) {
+                    var behavior;
+                    if (overrideValues && isValueAssigned(overrideValues.behavior)) {
+                        behavior = overrideValues.behavior;
+                    }
+                    else if (isValueAssigned(_self._behaviorMetaTag)) {
+                        behavior = _self._behaviorMetaTag;
+                    }
+                    return _self._getValidBehavior(behavior);
+                };
+                _self._getValidBehavior = function (behavior) {
+                    return _self._config.behaviorValidator(behavior);
+                };
+                _self._doUnload = function (unloadCtx, unloadState, asyncCallback) {
+                    _initDefaults();
+                };
+                function _getMetaData(metaTags, coreData, metaTagName) {
+                    if (coreData && coreData[metaTagName]) {
+                        return coreData[metaTagName];
+                    }
+                    if (metaTags) {
+                        return metaTags[metaTagName];
+                    }
+                    return "";
                 }
-            }
-            event.properties = event.properties || {};
-            event.properties["pageTags"] = this._pageTags;
-        };
-        WebEvent.prototype._getBehavior = function (overrideValues) {
-            var behavior;
-            if (overrideValues && isValueAssigned(overrideValues.behavior)) {
-                behavior = overrideValues.behavior;
-            }
-            else if (isValueAssigned(this._behaviorMetaTag)) {
-                behavior = this._behaviorMetaTag;
-            }
-            return this._getValidBehavior(behavior);
-        };
-        WebEvent.prototype._getValidBehavior = function (behavior) {
-            return this._config.behaviorValidator(behavior);
-        };
-        WebEvent.prototype._getMetaData = function (metaTags, coreData, metaTagName) {
-            if (coreData && coreData[metaTagName]) {
-                return coreData[metaTagName];
-            }
-            else if (metaTags) {
-                return metaTags[metaTagName];
-            }
-            return "";
-        };
+            });
+        }
         return WebEvent;
     }());
 
     var PageAction = /** @class */ (function (_super) {
         __extendsFn(PageAction, _super);
-        function PageAction() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
-        PageAction.prototype.trackPageAction = function (pageActionEvent, properties) {
-            var _this = this;
-            var ext = {};
-            ext["web"] = {};
-            var event = {
-                name: "Microsoft.ApplicationInsights.{0}.Event",
-                baseType: "EventData",
-                ext: ext,
-                data: {},
-                baseData: {}
-            };
-            this._populateEventDataIfPresent(event.baseData, "name", pageActionEvent.name);
-            this._populateEventDataIfPresent(event.data, "baseTypeSource", "ClickEvent");
-            this._populateEventDataIfPresent(event.data, "uri", pageActionEvent.uri);
-            this._populateEventDataIfPresent(event.data, "pageType", pageActionEvent.pageType);
-            this._populateEventDataIfPresent(event.data, "properties", pageActionEvent.properties);
-            this._populateEventDataIfPresent(event.data, "actionType", pageActionEvent.actionType);
-            this._populateEventDataIfPresent(event.data, "behavior", pageActionEvent.behavior);
-            this._populateEventDataIfPresent(event.data, "clickCoordinates", pageActionEvent.clickCoordinates);
-            this._populateEventDataIfPresent(event.data, "content", pageActionEvent.content);
-            this._populateEventDataIfPresent(event.data, "targetUri", pageActionEvent.targetUri);
-            this._populateEventDataIfPresent(event.data, "timeToAction", pageActionEvent.timeToAction);
-            this._populateEventDataIfPresent(event.data, "refUri", pageActionEvent.refUri);
-            this._populateEventDataIfPresent(event.data, "pageName", pageActionEvent.pageName);
-            this._populateEventDataIfPresent(event.data, "parentId", pageActionEvent.parentId);
-            if (properties) {
-                objForEachKey(properties, function (property, value) {
-                    if (!event.data[property]) {
-                        _this._populateEventDataIfPresent(event.data, property, value);
+        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) {
+                    var ext = {};
+                    ext["web"] = {};
+                    var event = {
+                        name: "Microsoft.ApplicationInsights.{0}.Event",
+                        baseType: "EventData",
+                        ext: ext,
+                        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);
+                    if (properties) {
+                        objForEachKey(properties, function (property, value) {
+                            if (!event.data[property]) {
+                                _populateEventDataIfPresent(event.data, property, value);
+                            }
+                        });
                     }
-                });
-            }
-            this._clickAnalyticsPlugin.core.track(event);
-        };
-        PageAction.prototype.capturePageAction = function (element, overrideValues, customProperties, isRightClick) {
-            overrideValues = !isValueAssigned(overrideValues) ? {} : overrideValues;
-            var pageActionEvent = { name: "" };
-            var pageActionProperties = isValueAssigned(customProperties) ? customProperties : {};
-            this.setCommonProperties(pageActionEvent, overrideValues);
-            pageActionEvent.behavior = this._getBehavior(overrideValues);
-            var elementContent = {};
-            if (isRightClick) {
-                pageActionEvent.behavior = this._config.defaultRightClickBhvr;
-            }
-            if (element) {
-                pageActionEvent.targetUri = getClickTarget(element);
-                elementContent = this._contentHandler.getElementContent(element);
-                if (elementContent.bhvr && !isValueAssigned(overrideValues.behavior)) {
-                    var currentBehavior = extractFieldFromObject(elementContent, "bhvr");
-                    pageActionEvent.behavior = this._getValidBehavior(currentBehavior);
-                }
-                if (!isValueAssigned(elementContent.id) && !isValueAssigned(elementContent.contentName)) {
-                    this._traceLogger.throwInternal(LoggingSeverity.WARNING, _ExtendedInternalMessageId.InvalidContentBlob, "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;
-            }
-            if (isValueAssigned(overrideValues.clickCoordinateX) && isValueAssigned(overrideValues.clickCoordinateY)) {
-                pageActionEvent.clickCoordinates = overrideValues.clickCoordinateX + "X" + overrideValues.clickCoordinateY;
-            }
-            this._sanitizePageActionEventContent(elementContent);
-            pageActionEvent.content = bracketIt(JSON.stringify(extend(elementContent, overrideValues && overrideValues.contentTags ? overrideValues.contentTags : {})));
-            pageActionEvent.timeToAction = this._getTimeToClick();
-            pageActionEvent.refUri = isValueAssigned(overrideValues.refUri) ? overrideValues.refUri : this._config.coreData.referrerUri;
-            if (this._isUndefinedEvent(pageActionEvent))
-                return;
-            this.trackPageAction(pageActionEvent, pageActionProperties);
-        };
-        PageAction.prototype._getTimeToClick = function () {
-            var perf = getPerformance();
-            if (perf && perf.timing) {
-                var isNavigationStart = perf.timing.navigationStart;
-                if (isNavigationStart && isNavigationStart !== 0) {
-                    return new Date().getTime() - isNavigationStart;
+                    _self._clickAnalyticsPlugin.core.track(event);
+                };
+                _self.capturePageAction = 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);
+                    var elementContent = {};
+                    if (isRightClick) {
+                        pageActionEvent.behavior = _self._config.defaultRightClickBhvr;
+                    }
+                    if (element) {
+                        pageActionEvent.targetUri = getClickTarget(element);
+                        elementContent = _self._contentHandler.getElementContent(element);
+                        if (elementContent.bhvr && !isValueAssigned(overrideValues.behavior)) {
+                            var currentBehavior = extractFieldFromObject(elementContent, "bhvr");
+                            pageActionEvent.behavior = _self._getValidBehavior(currentBehavior);
+                        }
+                        if (!isValueAssigned(elementContent.id) && !isValueAssigned(elementContent.contentName)) {
+                            _self._traceLogger.throwInternal(LoggingSeverity.WARNING, _ExtendedInternalMessageId.InvalidContentBlob, "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;
+                    }
+                    if (isValueAssigned(overrideValues.clickCoordinateX) && isValueAssigned(overrideValues.clickCoordinateY)) {
+                        pageActionEvent.clickCoordinates = overrideValues.clickCoordinateX + "X" + overrideValues.clickCoordinateY;
+                    }
+                    _sanitizePageActionEventContent(elementContent);
+                    pageActionEvent.content = bracketIt(JSON.stringify(extend(elementContent, overrideValues && overrideValues.contentTags ? overrideValues.contentTags : {})));
+                    pageActionEvent.timeToAction = _getTimeToClick();
+                    pageActionEvent.refUri = isValueAssigned(overrideValues.refUri) ? overrideValues.refUri : _self._config.coreData.referrerUri;
+                    if (_isUndefinedEvent(pageActionEvent)) {
+                        return;
+                    }
+                    _self.trackPageAction(pageActionEvent, pageActionProperties);
+                };
+                function _getTimeToClick() {
+                    var perf = getPerformance();
+                    if (perf && perf.timing) {
+                        var isNavigationStart = perf.timing.navigationStart;
+                        if (isNavigationStart && isNavigationStart !== 0) {
+                            return new Date().getTime() - isNavigationStart;
+                        }
+                    }
+                    return -1;
                 }
-            }
-            return -1;
-        };
-        PageAction.prototype._populateEventDataIfPresent = function (obj, property, value) {
-            if (isValueAssigned(value)) {
-                obj[property] = value;
-            }
-        };
-        PageAction.prototype._sanitizePageActionEventContent = function (pageActionContent) {
-            if (pageActionContent) {
-                delete pageActionContent.id;
-                delete pageActionContent.parentid;
-                delete pageActionContent.parentname;
-                if (this._config && this._config.dataTags && isValueAssigned(this._config.dataTags.parentDataTag)) {
-                    delete pageActionContent[this._config.dataTags.parentDataTag];
+                function _populateEventDataIfPresent(obj, property, value) {
+                    if (isValueAssigned(value)) {
+                        obj[property] = value;
+                    }
                 }
-            }
-        };
-        PageAction.prototype._isUndefinedEvent = function (pageActionEvent) {
-            if (this._config.dropInvalidEvents) {
-                if (pageActionEvent.name === strNotSpecified
-                    && pageActionEvent.parentId === strNotSpecified
-                    && pageActionEvent.content === "[{}]")
-                    return true;
-            }
-            return false;
-        };
+                function _sanitizePageActionEventContent(pageActionContent) {
+                    if (pageActionContent) {
+                        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];
+                        }
+                    }
+                }
+                function _isUndefinedEvent(pageActionEvent) {
+                    if (_self._config.dropInvalidEvents) {
+                        if (pageActionEvent.name === strNotSpecified
+                            && pageActionEvent.parentId === strNotSpecified
+                            && pageActionEvent.content === "[{}]") {
+                            return true;
+                        }
+                    }
+                    return false;
+                }
+            });
+            return _this;
+        }
         return PageAction;
     }(WebEvent));
 
@@ -2319,77 +2476,83 @@ this.Microsoft = this.Microsoft || {};
             this._config = _config;
             this._pageAction = _pageAction;
             this._traceLogger = _traceLogger;
-        }
-        AutoCaptureHandler.prototype.click = function () {
-            var _this = this;
-            var win = getWindow();
-            var doc = getDocument();
-            if (win) {
-                var event_1 = (navigator.appVersion.indexOf("MSIE") !== -1) ? "click" : "mousedown";
-                attachEvent(win, event_1, function (evt) { _this._processClick(evt); });
-                attachEvent(win, "keyup", function (evt) { _this._processClick(evt); });
-            }
-            else if (doc) {
-                attachEvent(doc, "click", function (evt) { _this._processClick(evt); });
-                attachEvent(doc, "keyup", function (evt) { _this._processClick(evt); });
-            }
-        };
-        AutoCaptureHandler.prototype.capturePageAction = function (element, overrideValues, customProperties, isRightClick) {
-            var donotTrackTag = this._config.dataTags.customDataPrefix + this._config.dataTags.dntDataTag;
-            if (!isElementDnt(element, donotTrackTag)) {
-                this._pageAction.capturePageAction(element, overrideValues, customProperties, isRightClick);
-            }
-        };
-        AutoCaptureHandler.prototype._processClick = function (clickEvent) {
-            var clickCaptureElements = { A: true, BUTTON: true, AREA: true, INPUT: true };
-            var win = getWindow();
-            if (isNullOrUndefined(clickEvent) && win) {
-                clickEvent = win.event;
-            }
-            if (clickEvent) {
-                var element = clickEvent.srcElement || clickEvent.target;
-                var overrideValues = {
-                    clickCoordinateX: clickEvent.pageX,
-                    clickCoordinateY: clickEvent.pageY
-                };
-                var isRightClickObj = isRightClick(clickEvent);
-                if (isRightClickObj) {
-                    overrideValues.actionType = ActionType.CLICKRIGHT;
-                }
-                else if (isLeftClick(clickEvent)) {
-                    overrideValues.actionType = ActionType.CLICKLEFT;
-                }
-                else if (isKeyboardEnter(clickEvent)) {
-                    overrideValues.actionType = ActionType.KEYBOARDENTER;
-                }
-                else if (isKeyboardSpace(clickEvent)) {
-                    overrideValues.actionType = ActionType.KEYBOARDSPACE;
-                }
-                else if (isMiddleClick(clickEvent)) {
-                    overrideValues.actionType = ActionType.CLICKMIDDLE;
-                }
-                else {
-                    return;
-                }
-                while (element && element.tagName) {
-                    if (element.control && clickCaptureElements[element.control.tagName.toUpperCase()]) {
-                        element = element.control;
-                    }
-                    var tagNameUpperCased = element.tagName.toUpperCase();
-                    if (!clickCaptureElements[tagNameUpperCased]) {
-                        element = element.parentElement || element.parentNode;
-                        continue;
+            var _evtNamespace = mergeEvtNamespace(createUniqueNamespace("AutoCaptureHandler"), _analyticsPlugin._evtNamespace);
+            dynamicProto(AutoCaptureHandler, this, function (_self) {
+                _self.click = function () {
+                    var win = getWindow();
+                    var doc = getDocument();
+                    if (win) {
+                        var event_1 = (navigator.appVersion.indexOf("MSIE") !== -1) ? "click" : "mousedown";
+                        eventOn(win, event_1, _processClick, _evtNamespace);
+                        eventOn(win, "keyup", _processClick, _evtNamespace);
+                    }
+                    else if (doc) {
+                        eventOn(doc, "click", _processClick, _evtNamespace);
+                        eventOn(doc, "keyup", _processClick, _evtNamespace);
                     }
-                    else {
-                        var sendEvent = tagNameUpperCased === "INPUT" ? clickCaptureInputTypes[element.type.toUpperCase()] : true;
-                        if (sendEvent) {
-                            this.capturePageAction(element, overrideValues, {}, isRightClickObj);
+                };
+                _self._doUnload = function (unloadCtx, unloadState, asyncCallback) {
+                    eventOff(getWindow(), null, null, _evtNamespace);
+                    eventOff(getDocument(), null, null, _evtNamespace);
+                };
+                function _capturePageAction(element, overrideValues, customProperties, isRightClick) {
+                    var donotTrackTag = _self._config.dataTags.customDataPrefix + _self._config.dataTags.dntDataTag;
+                    if (!isElementDnt(element, donotTrackTag)) {
+                        _self._pageAction.capturePageAction(element, overrideValues, customProperties, isRightClick);
+                    }
+                }
+                function _processClick(clickEvent) {
+                    var clickCaptureElements = { A: true, BUTTON: true, AREA: true, INPUT: true };
+                    var win = getWindow();
+                    if (isNullOrUndefined(clickEvent) && win) {
+                        clickEvent = win.event;
+                    }
+                    if (clickEvent) {
+                        var element = clickEvent.srcElement || clickEvent.target;
+                        var overrideValues = {
+                            clickCoordinateX: clickEvent.pageX,
+                            clickCoordinateY: clickEvent.pageY
+                        };
+                        var isRightClickObj = isRightClick(clickEvent);
+                        if (isRightClickObj) {
+                            overrideValues.actionType = ActionType.CLICKRIGHT;
+                        }
+                        else if (isLeftClick(clickEvent)) {
+                            overrideValues.actionType = ActionType.CLICKLEFT;
+                        }
+                        else if (isKeyboardEnter(clickEvent)) {
+                            overrideValues.actionType = ActionType.KEYBOARDENTER;
+                        }
+                        else if (isKeyboardSpace(clickEvent)) {
+                            overrideValues.actionType = ActionType.KEYBOARDSPACE;
+                        }
+                        else if (isMiddleClick(clickEvent)) {
+                            overrideValues.actionType = ActionType.CLICKMIDDLE;
+                        }
+                        else {
+                            return;
+                        }
+                        while (element && element.tagName) {
+                            if (element.control && clickCaptureElements[element.control.tagName.toUpperCase()]) {
+                                element = element.control;
+                            }
+                            var tagNameUpperCased = element.tagName.toUpperCase();
+                            if (!clickCaptureElements[tagNameUpperCased]) {
+                                element = element.parentElement || element.parentNode;
+                                continue;
+                            }
+                            else {
+                                var sendEvent = tagNameUpperCased === "INPUT" ? clickCaptureInputTypes[element.type.toUpperCase()] : true;
+                                if (sendEvent) {
+                                    _capturePageAction(element, overrideValues, {}, isRightClickObj);
+                                }
+                                break;
+                            }
                         }
-                        break;
                     }
                 }
-            }
-        };
+            });
+        }
         return AutoCaptureHandler;
     }());
 
@@ -2398,285 +2561,318 @@ this.Microsoft = this.Microsoft || {};
         function DomContentHandler(_config, _traceLogger) {
             this._config = _config;
             this._traceLogger = _traceLogger;
-        }
-        DomContentHandler.prototype.getMetadata = function () {
-            var metaTags = {};
-            if (hasDocument) {
-                metaTags = isValueAssigned(this._config.dataTags.metaDataPrefix) ? this._getMetaDataFromDOM(this._config.dataTags.captureAllMetaDataContent, this._config.dataTags.metaDataPrefix, false) :
-                    this._getMetaDataFromDOM(this._config.dataTags.captureAllMetaDataContent, "", false);
-            }
-            return metaTags;
-        };
-        DomContentHandler.prototype.getElementContent = function (element) {
-            if (!element) {
-                return {};
-            }
-            var elementContent = {};
-            var biBlobValue;
-            var parentDataTagPrefix;
-            var dataTagPrefix = this._config.dataTags.customDataPrefix;
-            var aiBlobAttributeTag = dataTagPrefix + this._config.dataTags.aiBlobAttributeTag;
-            if (isValueAssigned(this._config.dataTags.parentDataTag)) {
-                parentDataTagPrefix = dataTagPrefix + this._config.dataTags.parentDataTag;
-            }
-            if (!this._isTracked(element, dataTagPrefix, aiBlobAttributeTag)) {
-                biBlobValue = element.getAttribute(aiBlobAttributeTag);
-                if (biBlobValue) {
-                    try {
-                        elementContent = JSON.parse(biBlobValue);
+            dynamicProto(DomContentHandler, this, function (_self) {
+                _self.getMetadata = function () {
+                    var dataTags = (_self._config || {}).dataTags;
+                    var metaTags = {};
+                    if (hasDocument) {
+                        metaTags = isValueAssigned(dataTags.metaDataPrefix) ? _getMetaDataFromDOM(dataTags.captureAllMetaDataContent, dataTags.metaDataPrefix, false) :
+                            _getMetaDataFromDOM(dataTags.captureAllMetaDataContent, "", false);
+                    }
+                    return metaTags;
+                };
+                _self.getElementContent = function (element) {
+                    if (!element) {
+                        return {};
+                    }
+                    var dataTags = (_self._config || {}).dataTags;
+                    var elementContent = {};
+                    var biBlobValue;
+                    var parentDataTagPrefix;
+                    var dataTagPrefix = dataTags.customDataPrefix;
+                    var aiBlobAttributeTag = dataTagPrefix + dataTags.aiBlobAttributeTag;
+                    if (isValueAssigned(dataTags.parentDataTag)) {
+                        parentDataTagPrefix = dataTagPrefix + dataTags.parentDataTag;
+                    }
+                    if (!_isTracked(element, dataTagPrefix, aiBlobAttributeTag)) {
+                        biBlobValue = element.getAttribute(aiBlobAttributeTag);
+                        if (biBlobValue) {
+                            try {
+                                elementContent = JSON.parse(biBlobValue);
+                            }
+                            catch (e) {
+                                _self._traceLogger.throwInternal(LoggingSeverity.CRITICAL, _ExtendedInternalMessageId.CannotParseAiBlobValue, "Can not parse " + biBlobValue);
+                            }
+                        }
+                        else {
+                            elementContent = extend(elementContent, _populateElementContent(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag));
+                        }
                     }
-                    catch (e) {
-                        this._traceLogger.throwInternal(LoggingSeverity.CRITICAL, _ExtendedInternalMessageId.CannotParseAiBlobValue, "Can not parse " + biBlobValue);
+                    else {
+                        elementContent = extend(elementContent, _populateElementContentwithDataTag(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag));
                     }
-                }
-                else {
-                    elementContent = extend(elementContent, this._populateElementContent(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag));
-                }
-            }
-            else {
-                elementContent = extend(elementContent, this._populateElementContentwithDataTag(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag));
-            }
-            removeInvalidElements(elementContent);
-            if (parentDataTagPrefix) {
-                elementContent = extend(elementContent, this._getParentDetails(element, elementContent, dataTagPrefix, aiBlobAttributeTag));
-            }
-            return elementContent;
-        };
-        DomContentHandler.prototype._captureElementContentWithDataTag = function (contentElement, elementContent, dataTagPrefix) {
-            for (var i = 0, attrib; i < contentElement.attributes.length; i++) {
-                attrib = contentElement.attributes[i];
-                if (attrib.name.indexOf(dataTagPrefix) !== 0) {
-                    continue;
-                }
-                var attribName = attrib.name.replace(dataTagPrefix, "");
-                elementContent[attribName] = attrib.value;
-            }
-        };
-        DomContentHandler.prototype._walkUpDomChainCaptureData = function (el, elementContent, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag) {
-            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++) {
-                    var attrib = attributes[i];
-                    if (attrib.name.indexOf(dataTagPrefix) !== 0) {
-                        continue;
-                    }
-                    if (attrib.name.indexOf(parentDataTagPrefix) === 0) {
-                        parentDataTagFound = true;
-                    }
-                    if (attrib.name.indexOf(aiBlobAttributeTag) === 0) {
-                        continue;
-                    }
-                    var attribName = attrib.name.replace(dataTagPrefix, "");
-                    if (elementLevelFlag && attribName === "id")
-                        continue;
-                    if (!isValueAssigned(elementContent[attribName])) {
+                    removeInvalidElements(elementContent);
+                    if (parentDataTagPrefix) {
+                        elementContent = extend(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) {
+                            continue;
+                        }
+                        var attribName = attrib.name.replace(dataTagPrefix, "");
                         elementContent[attribName] = attrib.value;
                     }
                 }
-                if (parentDataTagFound) {
-                    break;
-                }
-                elementLevelFlag = true;
-                element = element.parentNode;
-            }
-        };
-        DomContentHandler.prototype._populateElementContent = function (element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag) {
-            var elementContent = {};
-            if (!element)
-                return elementContent;
-            var htmlContent = this._getHtmlIdAndContentName(element);
-            elementContent = {
-                id: htmlContent.id || "",
-                contentName: htmlContent.contentName || ""
-            };
-            if (isValueAssigned(parentDataTagPrefix)) {
-                this._walkUpDomChainCaptureData(element, elementContent, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag);
-            }
-            if (!elementContent.id && !elementContent.contentName) {
-                this._traceLogger.throwInternal(LoggingSeverity.WARNING, _ExtendedInternalMessageId.InvalidContentBlob, "Invalid content blob.  Missing required attributes (id, contentName. " +
-                    " Content information will still be collected!");
-            }
-            return elementContent;
-        };
-        DomContentHandler.prototype._populateElementContentwithDataTag = function (element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag) {
-            var elementContent = {};
-            if (!element)
-                return elementContent;
-            var htmlContent = this._getHtmlIdAndContentName(element);
-            if (isValueAssigned(parentDataTagPrefix)) {
-                this._walkUpDomChainCaptureData(element, elementContent, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag);
-            }
-            else {
-                this._captureElementContentWithDataTag(element, elementContent, dataTagPrefix);
-            }
-            if (this._config.dataTags.useDefaultContentNameOrId) {
-                if (!isValueAssigned(elementContent.id)) {
-                    elementContent.id = htmlContent.id || "";
-                }
-                elementContent.contentName = htmlContent.contentName || "";
-            }
-            if (!elementContent.id && !elementContent.contentName) {
-                this._traceLogger.throwInternal(LoggingSeverity.WARNING, _ExtendedInternalMessageId.InvalidContentBlob, "Invalid content blob.  Missing required attributes (id, contentName. " +
-                    " Content information will still be collected!");
-            }
-            return elementContent;
-        };
-        DomContentHandler.prototype._getMetaDataFromDOM = function (captureAllMetaDataContent, prefix, removePrefix) {
-            var metaElements;
-            var metaData = {};
-            if (hasDocument) {
-                metaElements = document.querySelectorAll("meta");
-                for (var i = 0; i < metaElements.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;
+                function _walkUpDomChainCaptureData(el, elementContent, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag) {
+                    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++) {
+                            var attrib = attributes[i];
+                            if (attrib.name.indexOf(dataTagPrefix) !== 0) {
+                                continue;
+                            }
+                            if (attrib.name.indexOf(parentDataTagPrefix) === 0) {
+                                parentDataTagFound = true;
+                            }
+                            if (attrib.name.indexOf(aiBlobAttributeTag) === 0) {
+                                continue;
+                            }
+                            var attribName = attrib.name.replace(dataTagPrefix, "");
+                            if (elementLevelFlag && attribName === "id") {
+                                continue;
+                            }
+                            if (!isValueAssigned(elementContent[attribName])) {
+                                elementContent[attribName] = attrib.value;
+                            }
+                        }
+                        if (parentDataTagFound) {
+                            break;
                         }
+                        elementLevelFlag = true;
+                        element = element.parentNode;
                     }
                 }
-            }
-            return metaData;
-        };
-        DomContentHandler.prototype._getDefaultContentName = function (element, useDefaultContentName) {
-            if (useDefaultContentName === false || !element.tagName) {
-                return "";
-            }
-            var doc = getDocument() || {};
-            var contentName;
-            switch (element.tagName) {
-                case "A":
-                    contentName = doc.all ? element.innerText || element.innerHTML : element.text || element.innerHTML;
-                    break;
-                case "IMG":
-                case "AREA":
-                    contentName = element.alt;
-                    break;
-                default:
-                    contentName = element.value || element.name || element.alt || element.innerText || element.id;
-            }
-            return contentName.substring(0, MAX_CONTENTNAME_LENGTH);
-        };
-        DomContentHandler.prototype._isTracked = function (element, dataTag, aiBlobAttributeTag) {
-            var attrs = element.attributes;
-            var dataTagFound = false;
-            for (var i = 0; i < attrs.length; i++) {
-                var attributeName = attrs[i].name;
-                if (attributeName === aiBlobAttributeTag) {
-                    return false;
-                }
-                else if (attributeName.indexOf(dataTag) === 0) {
-                    dataTagFound = true;
-                }
-            }
-            return dataTagFound;
-        };
-        DomContentHandler.prototype._getHtmlIdAndContentName = function (element) {
-            var htmlContent = {};
-            if (!element)
-                return htmlContent;
-            if (this._config.dataTags.useDefaultContentNameOrId) {
-                var customizedContentName = this._config.callback.contentName ? this._config.callback.contentName(element, this._config.dataTags.useDefaultContentNameOrId) : "";
-                var defaultContentName = this._getDefaultContentName(element, this._config.dataTags.useDefaultContentNameOrId);
-                htmlContent = {
-                    id: element.id,
-                    contentName: customizedContentName || defaultContentName || element.getAttribute("alt")
-                };
-            }
-            return htmlContent;
-        };
-        DomContentHandler.prototype._getParentDetails = function (element, elementContent, dataTagPrefix, aiBlobAttributeTag) {
-            var parentId = elementContent["parentid"];
-            var parentName = elementContent["parentname"];
-            var parentInfo = {};
-            if (parentId || parentName || !element) {
-                return parentInfo;
-            }
-            return this._populateParentInfo(element, dataTagPrefix, aiBlobAttributeTag);
-        };
-        DomContentHandler.prototype._populateParentInfo = function (element, dataTagPrefix, aiBlobAttributeTag) {
-            var parentInfo = {};
-            var parentId;
-            var closestParentElement = walkUpDomChainWithElementValidation(element.parentElement, this._isTracked, dataTagPrefix);
-            if (closestParentElement) {
-                var dataAttr = closestParentElement.getAttribute(aiBlobAttributeTag) || element[aiBlobAttributeTag];
-                if (dataAttr) {
-                    try {
-                        var telemetryObject = JSON.parse(dataAttr);
+                function _populateElementContent(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag) {
+                    var elementContent = {};
+                    if (!element) {
+                        return elementContent;
                     }
-                    catch (e) {
-                        this._traceLogger.throwInternal(LoggingSeverity.CRITICAL, _ExtendedInternalMessageId.CannotParseAiBlobValue, "Can not parse " + dataAttr);
+                    var htmlContent = _getHtmlIdAndContentName(element);
+                    elementContent = {
+                        id: htmlContent.id || "",
+                        contentName: htmlContent.contentName || ""
+                    };
+                    if (isValueAssigned(parentDataTagPrefix)) {
+                        _walkUpDomChainCaptureData(element, elementContent, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag);
                     }
-                    if (telemetryObject) {
-                        parentId = telemetryObject.id;
+                    if (!elementContent.id && !elementContent.contentName) {
+                        _traceLogger.throwInternal(LoggingSeverity.WARNING, _ExtendedInternalMessageId.InvalidContentBlob, "Invalid content blob.  Missing required attributes (id, contentName. " +
+                            " Content information will still be collected!");
                     }
+                    return elementContent;
                 }
-                else {
-                    parentId = closestParentElement.getAttribute(dataTagPrefix + "id");
+                function _populateElementContentwithDataTag(element, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag) {
+                    var dataTags = (_self._config || {}).dataTags;
+                    var elementContent = {};
+                    if (!element) {
+                        return elementContent;
+                    }
+                    var htmlContent = _getHtmlIdAndContentName(element);
+                    if (isValueAssigned(parentDataTagPrefix)) {
+                        _walkUpDomChainCaptureData(element, elementContent, dataTagPrefix, parentDataTagPrefix, aiBlobAttributeTag);
+                    }
+                    else {
+                        _captureElementContentWithDataTag(element, elementContent, dataTagPrefix);
+                    }
+                    if (dataTags.useDefaultContentNameOrId) {
+                        if (!isValueAssigned(elementContent.id)) {
+                            elementContent.id = htmlContent.id || "";
+                        }
+                        elementContent.contentName = htmlContent.contentName || "";
+                    }
+                    if (!elementContent.id && !elementContent.contentName) {
+                        _traceLogger.throwInternal(LoggingSeverity.WARNING, _ExtendedInternalMessageId.InvalidContentBlob, "Invalid content blob.  Missing required attributes (id, contentName. " +
+                            " Content information will still be collected!");
+                    }
+                    return elementContent;
+                }
+                function _getMetaDataFromDOM(captureAllMetaDataContent, prefix, removePrefix) {
+                    var metaElements;
+                    var metaData = {};
+                    if (hasDocument) {
+                        metaElements = document.querySelectorAll("meta");
+                        for (var i = 0; i < metaElements.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;
+                                }
+                            }
+                        }
+                    }
+                    return metaData;
+                }
+                function _getDefaultContentName(element, useDefaultContentName) {
+                    if (useDefaultContentName === false || !element.tagName) {
+                        return "";
+                    }
+                    var doc = getDocument() || {};
+                    var contentName;
+                    switch (element.tagName) {
+                        case "A":
+                            contentName = doc.all ? element.innerText || element.innerHTML : element.text || element.innerHTML;
+                            break;
+                        case "IMG":
+                        case "AREA":
+                            contentName = element.alt;
+                            break;
+                        default:
+                            contentName = element.value || element.name || element.alt || element.innerText || element.id;
+                    }
+                    return contentName.substring(0, MAX_CONTENTNAME_LENGTH);
+                }
+                function _isTracked(element, dataTag, aiBlobAttributeTag) {
+                    var attrs = element.attributes;
+                    var dataTagFound = false;
+                    for (var i = 0; i < attrs.length; i++) {
+                        var attributeName = attrs[i].name;
+                        if (attributeName === aiBlobAttributeTag) {
+                            return false;
+                        }
+                        else if (attributeName.indexOf(dataTag) === 0) {
+                            dataTagFound = true;
+                        }
+                    }
+                    return dataTagFound;
+                }
+                function _getHtmlIdAndContentName(element) {
+                    var dataTags = (_self._config || {}).dataTags;
+                    var callback = (_self._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);
+                        htmlContent = {
+                            id: element.id,
+                            contentName: customizedContentName || defaultContentName || element.getAttribute("alt")
+                        };
+                    }
+                    return htmlContent;
+                }
+                function _getParentDetails(element, elementContent, dataTagPrefix, aiBlobAttributeTag) {
+                    var parentId = elementContent["parentid"];
+                    var parentName = elementContent["parentname"];
+                    var parentInfo = {};
+                    if (parentId || parentName || !element) {
+                        return parentInfo;
+                    }
+                    return _populateParentInfo(element, dataTagPrefix, aiBlobAttributeTag);
+                }
+                function _populateParentInfo(element, dataTagPrefix, aiBlobAttributeTag) {
+                    var parentInfo = {};
+                    var parentId;
+                    var closestParentElement = walkUpDomChainWithElementValidation(element.parentElement, _isTracked, dataTagPrefix);
+                    if (closestParentElement) {
+                        var dataAttr = closestParentElement.getAttribute(aiBlobAttributeTag) || element[aiBlobAttributeTag];
+                        if (dataAttr) {
+                            try {
+                                var telemetryObject = JSON.parse(dataAttr);
+                            }
+                            catch (e) {
+                                _traceLogger.throwInternal(LoggingSeverity.CRITICAL, _ExtendedInternalMessageId.CannotParseAiBlobValue, "Can not parse " + dataAttr);
+                            }
+                            if (telemetryObject) {
+                                parentId = telemetryObject.id;
+                            }
+                        }
+                        else {
+                            parentId = closestParentElement.getAttribute(dataTagPrefix + "id");
+                        }
+                    }
+                    if (parentId) {
+                        parentInfo["parentid"] = parentId;
+                    }
+                    else {
+                        var htmlContent = _getHtmlIdAndContentName(element.parentElement);
+                        parentInfo["parentid"] = htmlContent.id;
+                        parentInfo["parentname"] = htmlContent.contentName;
+                    }
+                    return parentInfo;
                 }
-            }
-            if (parentId) {
-                parentInfo["parentid"] = parentId;
-            }
-            else {
-                var htmlContent = this._getHtmlIdAndContentName(element.parentElement);
-                parentInfo["parentid"] = htmlContent.id;
-                parentInfo["parentname"] = htmlContent.contentName;
-            }
-            return parentInfo;
-        };
+            });
+        }
         return DomContentHandler;
     }());
 
     var ClickAnalyticsPlugin = /** @class */ (function (_super) {
         __extendsFn(ClickAnalyticsPlugin, _super);
         function ClickAnalyticsPlugin() {
-            var _this = _super !== null && _super.apply(this, arguments) || this;
+            var _this = _super.call(this) || this;
             _this.identifier = "ClickAnalyticsPlugin";
             _this.priority = 181;
-            return _this;
-        }
-        ClickAnalyticsPlugin.prototype.initialize = function (config, core, extensions, pluginChain) {
-            if (isNullOrUndefined(core)) {
-                throw Error("Error initializing");
-            }
-            config.extensionConfig = config.extensionConfig || [];
-            config.extensionConfig[this.identifier] = config.extensionConfig[this.identifier] || {};
-            this._config = mergeConfig(config.extensionConfig[this.identifier]);
-            _super.prototype.initialize.call(this, config, core, extensions, pluginChain);
-            this._contentHandler = this._contentHandler ? this._contentHandler : new DomContentHandler(this._config, this.diagLog());
-            var metaTags = this._contentHandler.getMetadata();
-            this.pageAction = new PageAction(this, this._config, this._contentHandler, this._config.callback.pageActionPageTags, metaTags, this.diagLog());
-            this._autoCaptureHandler = this._autoCaptureHandler ? this._autoCaptureHandler : new AutoCaptureHandler(this, this._config, this.pageAction, this.diagLog());
-            if (this._config.autoCapture) {
-                this._autoCaptureHandler.click();
-            }
-            var _propertiesExtension;
-            arrForEach(extensions, function (extension) {
-                if (extension.identifier === PropertiesPluginIdentifier) {
-                    _propertiesExtension = extension;
-                }
+            var _config;
+            var _pageAction;
+            var _autoCaptureHandler;
+            var _contentHandler;
+            dynamicProto(ClickAnalyticsPlugin, _this, function (_self, _base) {
+                var _identifier = _self.identifier;
+                _initDefaults();
+                _self.initialize = function (config, core, extensions, pluginChain) {
+                    if (isNullOrUndefined(core)) {
+                        throwError("Error initializing");
+                    }
+                    config.extensionConfig = config.extensionConfig || [];
+                    config.extensionConfig[_identifier] = config.extensionConfig[_identifier] || {};
+                    _config = mergeConfig(config.extensionConfig[_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);
+                    _autoCaptureHandler = _autoCaptureHandler ? _autoCaptureHandler : new AutoCaptureHandler(_self, _config, _pageAction, logger);
+                    if (_config.autoCapture) {
+                        _autoCaptureHandler.click();
+                    }
+                    var _propertiesExtension;
+                    arrForEach(extensions, function (extension) {
+                        if (extension.identifier === PropertiesPluginIdentifier) {
+                            _propertiesExtension = extension;
+                        }
+                    });
+                    if (_propertiesExtension && _propertiesExtension.context &&
+                        _propertiesExtension.context.internal && _propertiesExtension.context.internal.sdkVersion) {
+                        _propertiesExtension.context.internal.sdkVersion += "_ClickPlugin" + ClickAnalyticsPlugin.Version;
+                    }
+                };
+                _self.processTelemetry = function (env, itemCtx) {
+                    _self.processNext(env, itemCtx);
+                };
+                _self.trackPageAction = function (pageAction, customProperties) {
+                    try {
+                        _pageAction.trackPageAction(pageAction, customProperties);
+                    }
+                    catch (e) {
+                        _throwInternal(_self.diagLog(), LoggingSeverity.CRITICAL, _ExtendedInternalMessageId.TrackPageActionEventFailed, "trackPageAction failed, page action event will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
+                    }
+                };
+                _self._doTeardown = function (unloadCtx, unloadState, asyncCallback) {
+                    return unloadComponents([
+                        _autoCaptureHandler,
+                        _contentHandler,
+                        _pageAction
+                    ], unloadCtx, unloadState);
+                };
             });
-            if (_propertiesExtension && _propertiesExtension.context &&
-                _propertiesExtension.context.internal && _propertiesExtension.context.internal.sdkVersion) {
-                _propertiesExtension.context.internal.sdkVersion += "_ClickPlugin" + ClickAnalyticsPlugin.Version;
-            }
-        };
-        ClickAnalyticsPlugin.prototype.processTelemetry = function (env, itemCtx) {
-            this.processNext(env, itemCtx);
-        };
-        ClickAnalyticsPlugin.prototype.trackPageAction = function (pageAction, customProperties) {
-            try {
-                this.pageAction.trackPageAction(pageAction, customProperties);
-            }
-            catch (e) {
-                this.diagLog().throwInternal(LoggingSeverity.CRITICAL, _ExtendedInternalMessageId.TrackPageActionEventFailed, "trackPageAction failed, page action event will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
+            function _initDefaults() {
+                _config = null;
+                _pageAction = null;
+                _autoCaptureHandler = null;
+                _contentHandler = null;
             }
-        };
-        ClickAnalyticsPlugin.Version = "2.8.0-beta.2203-08";
+            return _this;
+        }
+        ClickAnalyticsPlugin.Version = "2.8.0-beta.2203-11";
         return ClickAnalyticsPlugin;
     }(BaseTelemetryPlugin));