@microsoft/applicationinsights-clickanalytics-js 2.8.0-beta.2203-09 → 2.8.0-beta.2203-12

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

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Click Analytics, 2.8.0-beta.2203-09
+ * Application Insights JavaScript SDK - Click Analytics, 2.8.0-beta.2203-12
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 'use strict';
@@ -73,7 +73,9 @@ var __objAssignFnImpl = function (t) {
 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 @@ function __extendsFn(d, b) {
         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 @@ var strUpdate = "update";
 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 @@ function arrForEach(arr, callbackfn, thisArg) {
     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 @@ function newId(maxLength) {
 }
 
 var _objDefineProperty = ObjDefineProperty;
-var version = "2.7.3";
+var version = "2.8.0-beta.2203-12";
 var instanceName = "." + newId(6);
 var _dataUid = 0;
 function _createAccessor(target, prop, value) {
@@ -1117,10 +1167,28 @@ function createElmNodeData(name) {
     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 @@ function _createInternalContext(telemetryChain, config, core, startAt) {
     var context = {
         _next: _moveNext,
         ctx: {
-            core: function () { return core; },
+            core: function () {
+                return core;
+            },
             diagLog: function () {
                 return safeGetLogger(core, config);
             },
@@ -1639,6 +1709,8 @@ var BaseTelemetryPlugin = /** @class */ (function () {
 var strOnPrefix = "on";
 var strAttachEvent = "attachEvent";
 var strAddEventHelper = "addEventListener";
+var strDetachEvent = "detachEvent";
+var strRemoveEventListener = "removeEventListener";
 var strEvents = "events";
 createUniqueNamespace("aiEvtPageHide");
 createUniqueNamespace("aiEvtPageShow");
@@ -1678,7 +1750,7 @@ function _getEvtNamespace(eventName, evtNamespace) {
             eventName = (eventName || "") + theNamespace_1;
         }
     }
-    var parsedEvent = (eventNamespace.exec(eventName) || []);
+    var parsedEvent = (eventNamespace.exec(eventName || "") || []);
     return {
         type: parsedEvent[1],
         ns: ((parsedEvent[2] || "").replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, "").split(".").sort()).join(".")
@@ -1693,6 +1765,16 @@ function _getRegisteredEvents(target, evtName, addDefault) {
     }
     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) {
@@ -1707,6 +1789,50 @@ function _doAttach(obj, evtName, handlerRef, useCapture) {
     }
     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;
@@ -1729,9 +1855,26 @@ function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
     }
     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({
@@ -2117,188 +2260,200 @@ function getUri(config, location) {
 }
 
 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));
 
@@ -2321,77 +2476,83 @@ var AutoCaptureHandler = /** @class */ (function () {
         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;
 }());
 
@@ -2400,285 +2561,318 @@ var DomContentHandler = /** @class */ (function () {
     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-09";
+        return _this;
+    }
+    ClickAnalyticsPlugin.Version = "2.8.0-beta.2203-12";
     return ClickAnalyticsPlugin;
 }(BaseTelemetryPlugin));