within the
) this will get the actual link element
+ sourceElement = getSourceElement(sourceElement);
+
+ if(isLinkToDifferentDomainButSameMatomoWebsite(sourceElement)) {
+ replaceHrefForCrossDomainLink(sourceElement);
+ }
+
+ }
+ }
+
+ function isIE8orOlder()
+ {
+ return documentAlias.all && !documentAlias.addEventListener;
+ }
+
+ function getKeyCodeFromEvent(event)
+ {
+ // event.which is deprecated https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/which
+ var which = event.which;
+
+ /**
+ 1 : Left mouse button
+ 2 : Wheel button or middle button
+ 3 : Right mouse button
+ */
+
+ var typeOfEventButton = (typeof event.button);
+
+ if (!which && typeOfEventButton !== 'undefined' ) {
+ /**
+ -1: No button pressed
+ 0 : Main button pressed, usually the left button
+ 1 : Auxiliary button pressed, usually the wheel button or themiddle button (if present)
+ 2 : Secondary button pressed, usually the right button
+ 3 : Fourth button, typically the Browser Back button
+ 4 : Fifth button, typically the Browser Forward button
+
+ IE8 and earlier has different values:
+ 1 : Left mouse button
+ 2 : Right mouse button
+ 4 : Wheel button or middle button
+
+ For a left-hand configured mouse, the return values are reversed. We do not take care of that.
+ */
+
+ if (isIE8orOlder()) {
+ if (event.button & 1) {
+ which = 1;
+ } else if (event.button & 2) {
+ which = 3;
+ } else if (event.button & 4) {
+ which = 2;
+ }
+ } else {
+ if (event.button === 0 || event.button === '0') {
+ which = 1;
+ } else if (event.button & 1) {
+ which = 2;
+ } else if (event.button & 2) {
+ which = 3;
+ }
+ }
+ }
+
+ return which;
+ }
+
+ function getNameOfClickedButton(event)
+ {
+ switch (getKeyCodeFromEvent(event)) {
+ case 1:
+ return 'left';
+ case 2:
+ return 'middle';
+ case 3:
+ return 'right';
+ }
+ }
+
+ function getTargetElementFromEvent(event)
+ {
+ return event.target || event.srcElement;
+ }
+
+ function isClickNode(nodeName)
+ {
+ return nodeName === 'A' || nodeName === 'AREA';
+ }
+
+ /*
+ * Handle click event
+ */
+ function clickHandler(enable) {
+
+ function getLinkTarget(event)
+ {
+ var target = getTargetElementFromEvent(event);
+ var nodeName = target.nodeName;
+ var ignorePattern = getClassesRegExp(configIgnoreClasses, 'ignore');
+
+ while (!isClickNode(nodeName) && target && target.parentNode) {
+ target = target.parentNode;
+ nodeName = target.nodeName;
+ }
+
+ if (target && isClickNode(nodeName) && !ignorePattern.test(target.className)) {
+ return target;
+ }
+ }
+
+ return function (event) {
+
+ event = event || windowAlias.event;
+
+ var target = getLinkTarget(event);
+ if (!target) {
+ return;
+ }
+
+ var button = getNameOfClickedButton(event);
+
+ if (event.type === 'click') {
+
+ var ignoreClick = false;
+ if (enable && button === 'middle') {
+ // if enabled, we track middle clicks via mouseup
+ // some browsers (eg chrome) trigger click and mousedown/up events when middle is clicked,
+ // whereas some do not. This way we make "sure" to track them only once, either in click
+ // (default) or in mouseup (if enable == true)
+ ignoreClick = true;
+ }
+
+ if (target && !ignoreClick) {
+ processClick(target);
+ }
+ } else if (event.type === 'mousedown') {
+ if (button === 'middle' && target) {
+ lastButton = button;
+ lastTarget = target;
+ } else {
+ lastButton = lastTarget = null;
+ }
+ } else if (event.type === 'mouseup') {
+ if (button === lastButton && target === lastTarget) {
+ processClick(target);
+ }
+ lastButton = lastTarget = null;
+ } else if (event.type === 'contextmenu') {
+ processClick(target);
+ }
+ };
+ }
+
+ /*
+ * Add click listener to a DOM element
+ */
+ function addClickListener(element, enable, useCapture) {
+ var enableType = typeof enable;
+ if (enableType === 'undefined') {
+ enable = true;
+ }
+
+ addEventListener(element, 'click', clickHandler(enable), useCapture);
+
+ if (enable) {
+ addEventListener(element, 'mouseup', clickHandler(enable), useCapture);
+ addEventListener(element, 'mousedown', clickHandler(enable), useCapture);
+ addEventListener(element, 'contextmenu', clickHandler(enable), useCapture);
+ }
+ }
+
+
+ function enableTrackOnlyVisibleContent (checkOnScroll, timeIntervalInMs, tracker) {
+
+ if (isTrackOnlyVisibleContentEnabled) {
+ // already enabled, do not register intervals again
+ return true;
+ }
+
+ isTrackOnlyVisibleContentEnabled = true;
+
+ var didScroll = false;
+ var events, index;
+
+ function setDidScroll() { didScroll = true; }
+
+ trackCallbackOnLoad(function () {
+
+ function checkContent(intervalInMs) {
+ setTimeout(function () {
+ if (!isTrackOnlyVisibleContentEnabled) {
+ return; // the tests stopped tracking only visible content
+ }
+ didScroll = false;
+ tracker.trackVisibleContentImpressions();
+ checkContent(intervalInMs);
+ }, intervalInMs);
+ }
+
+ function checkContentIfDidScroll(intervalInMs) {
+
+ setTimeout(function () {
+ if (!isTrackOnlyVisibleContentEnabled) {
+ return; // the tests stopped tracking only visible content
+ }
+
+ if (didScroll) {
+ didScroll = false;
+ tracker.trackVisibleContentImpressions();
+ }
+
+ checkContentIfDidScroll(intervalInMs);
+ }, intervalInMs);
+ }
+
+ if (checkOnScroll) {
+
+ // scroll event is executed after each pixel, so we make sure not to
+ // execute event too often. otherwise FPS goes down a lot!
+ events = ['scroll', 'resize'];
+ for (index = 0; index < events.length; index++) {
+ if (documentAlias.addEventListener) {
+ documentAlias.addEventListener(events[index], setDidScroll, false);
+ } else {
+ windowAlias.attachEvent('on' + events[index], setDidScroll);
+ }
+ }
+
+ checkContentIfDidScroll(100);
+ }
+
+ if (timeIntervalInMs && timeIntervalInMs > 0) {
+ timeIntervalInMs = parseInt(timeIntervalInMs, 10);
+ checkContent(timeIntervalInMs);
+ }
+
+ });
+ }
+
+ /**/
+ /*
+ * Register a test hook. Using eval() permits access to otherwise
+ * privileged members.
+ */
+ function registerHook(hookName, userHook) {
+ var hookObj = null;
+
+ if (isString(hookName) && !isDefined(registeredHooks[hookName]) && userHook) {
+ if (isObject(userHook)) {
+ hookObj = userHook;
+ } else if (isString(userHook)) {
+ try {
+ eval('hookObj =' + userHook);
+ } catch (ignore) { }
+ }
+
+ registeredHooks[hookName] = hookObj;
+ }
+
+ return hookObj;
+ }
+
+ /**/
+
+ var requestQueue = {
+ enabled: true,
+ requests: [],
+ timeout: null,
+ interval: 2500,
+ sendRequests: function () {
+ var requestsToTrack = this.requests;
+ this.requests = [];
+ if (requestsToTrack.length === 1) {
+ sendRequest(requestsToTrack[0], configTrackerPause);
+ } else {
+ sendBulkRequest(requestsToTrack, configTrackerPause);
+ }
+ },
+ canQueue: function () {
+ return !isPageUnloading && this.enabled;
+ },
+ pushMultiple: function (requests) {
+ if (!this.canQueue()) {
+ sendBulkRequest(requests, configTrackerPause);
+ return;
+ }
+
+ var i;
+ for (i = 0; i < requests.length; i++) {
+ this.push(requests[i]);
+ }
+ },
+ push: function (requestUrl) {
+ if (!requestUrl) {
+ return;
+ }
+ if (!this.canQueue()) {
+ // we don't queue as we need to ensure the request will be sent when the page is unloading...
+ sendRequest(requestUrl, configTrackerPause);
+ return;
+ }
+
+ requestQueue.requests.push(requestUrl);
+
+ if (this.timeout) {
+ clearTimeout(this.timeout);
+ this.timeout = null;
+ }
+ // we always extend by another 2.5 seconds after receiving a tracking request
+ this.timeout = setTimeout(function () {
+ requestQueue.timeout = null;
+ requestQueue.sendRequests();
+ }, requestQueue.interval);
+
+ var trackerQueueId = 'RequestQueue' + uniqueTrackerId;
+ if (!Object.prototype.hasOwnProperty.call(plugins, trackerQueueId)) {
+ // we setup one unload handler per tracker...
+ // Matomo.addPlugin might not be defined at this point, we add the plugin directly also to make
+ // JSLint happy.
+ plugins[trackerQueueId] = {
+ unload: function () {
+ if (requestQueue.timeout) {
+ clearTimeout(requestQueue.timeout);
+ }
+ requestQueue.sendRequests();
+ }
+ };
+ }
+ }
+ };
+ /************************************************************
+ * Constructor
+ ************************************************************/
+
+ /*
+ * initialize tracker
+ */
+ updateDomainHash();
+
+ /**/
+ /*
+ * initialize test plugin
+ */
+ executePluginMethod('run', null, registerHook);
+ /**/
+
+ /************************************************************
+ * Public data and methods
+ ************************************************************/
+
+
+ /**/
+ /*
+ * Test hook accessors
+ */
+ this.hook = registeredHooks;
+ this.getHook = function (hookName) {
+ return registeredHooks[hookName];
+ };
+ this.getQuery = function () {
+ return query;
+ };
+ this.getContent = function () {
+ return content;
+ };
+ this.isUsingAlwaysUseSendBeacon = function () {
+ return configAlwaysUseSendBeacon;
+ };
+
+ this.buildContentImpressionRequest = buildContentImpressionRequest;
+ this.buildContentInteractionRequest = buildContentInteractionRequest;
+ this.buildContentInteractionRequestNode = buildContentInteractionRequestNode;
+ this.getContentImpressionsRequestsFromNodes = getContentImpressionsRequestsFromNodes;
+ this.getCurrentlyVisibleContentImpressionsRequestsIfNotTrackedYet = getCurrentlyVisibleContentImpressionsRequestsIfNotTrackedYet;
+ this.trackCallbackOnLoad = trackCallbackOnLoad;
+ this.trackCallbackOnReady = trackCallbackOnReady;
+ this.buildContentImpressionsRequests = buildContentImpressionsRequests;
+ this.wasContentImpressionAlreadyTracked = wasContentImpressionAlreadyTracked;
+ this.appendContentInteractionToRequestIfPossible = getContentInteractionToRequestIfPossible;
+ this.setupInteractionsTracking = setupInteractionsTracking;
+ this.trackContentImpressionClickInteraction = trackContentImpressionClickInteraction;
+ this.internalIsNodeVisible = isVisible;
+ this.isNodeAuthorizedToTriggerInteraction = isNodeAuthorizedToTriggerInteraction;
+ this.getDomains = function () {
+ return configHostsAlias;
+ };
+ this.getExcludedReferrers = function () {
+ return configExcludedReferrers;
+ };
+ this.getConfigIdPageView = function () {
+ return configIdPageView;
+ };
+ this.getConfigDownloadExtensions = function () {
+ return configDownloadExtensions;
+ };
+ this.enableTrackOnlyVisibleContent = function (checkOnScroll, timeIntervalInMs) {
+ return enableTrackOnlyVisibleContent(checkOnScroll, timeIntervalInMs, this);
+ };
+ this.clearTrackedContentImpressions = function () {
+ trackedContentImpressions = [];
+ };
+ this.getTrackedContentImpressions = function () {
+ return trackedContentImpressions;
+ };
+ this.clearEnableTrackOnlyVisibleContent = function () {
+ isTrackOnlyVisibleContentEnabled = false;
+ };
+ this.disableLinkTracking = function () {
+ linkTrackingInstalled = false;
+ linkTrackingEnabled = false;
+ };
+
+ this.getConfigVisitorCookieTimeout = function () {
+ return configVisitorCookieTimeout;
+ };
+ this.getConfigCookieSameSite = function () {
+ return configCookieSameSite;
+ };
+ this.getCustomPagePerformanceTiming = function () {
+ return customPagePerformanceTiming;
+ };
+ this.removeAllAsyncTrackersButFirst = function () {
+ var firstTracker = asyncTrackers[0];
+ asyncTrackers = [firstTracker];
+ };
+ this.getConsentRequestsQueue = function () {
+ return consentRequestsQueue;
+ };
+ this.getRequestQueue = function () {
+ return requestQueue;
+ };
+ this.getJavascriptErrors = function () {
+ return javaScriptErrors;
+ };
+ this.unsetPageIsUnloading = function () {
+ isPageUnloading = false;
+ };
+ this.getRemainingVisitorCookieTimeout = getRemainingVisitorCookieTimeout;
+ /**/
+ this.hasConsent = function () {
+ return configHasConsent;
+ };
+
+ /**
+ * Get the visitor information (from first party cookie)
+ *
+ * @return array
+ */
+ this.getVisitorInfo = function () {
+ if (!getCookie(getCookieName('id'))) {
+ setVisitorIdCookie();
+ }
+
+ // Note: in a new method, we could return also return getValuesFromVisitorIdCookie()
+ // which returns named parameters rather than returning integer indexed array
+ return loadVisitorIdCookie();
+ };
+
+ /**
+ * Get visitor ID (from first party cookie)
+ *
+ * @return string Visitor ID in hexits (or empty string, if not yet known)
+ */
+ this.getVisitorId = function () {
+ return this.getVisitorInfo()[1];
+ };
+
+ /**
+ * Get the Attribution information, which is an array that contains
+ * the Referrer used to reach the site as well as the campaign name and keyword
+ * It is useful only when used in conjunction with Tracker API function setAttributionInfo()
+ * To access specific data point, you should use the other functions getAttributionReferrer* and getAttributionCampaign*
+ *
+ * @return array Attribution array, Example use:
+ * 1) Call windowAlias.JSON.stringify(matomoTracker.getAttributionInfo())
+ * 2) Pass this json encoded string to the Tracking API (php or java client): setAttributionInfo()
+ */
+ this.getAttributionInfo = function () {
+ return loadReferrerAttributionCookie();
+ };
+
+ /**
+ * Get the Campaign name that was parsed from the landing page URL when the visitor
+ * landed on the site originally
+ *
+ * @return string
+ */
+ this.getAttributionCampaignName = function () {
+ return loadReferrerAttributionCookie()[0];
+ };
+
+ /**
+ * Get the Campaign keyword that was parsed from the landing page URL when the visitor
+ * landed on the site originally
+ *
+ * @return string
+ */
+ this.getAttributionCampaignKeyword = function () {
+ return loadReferrerAttributionCookie()[1];
+ };
+
+ /**
+ * Get the time at which the referrer (used for Goal Attribution) was detected
+ *
+ * @return int Timestamp or 0 if no referrer currently set
+ */
+ this.getAttributionReferrerTimestamp = function () {
+ return loadReferrerAttributionCookie()[2];
+ };
+
+ /**
+ * Get the full referrer URL that will be used for Goal Attribution
+ *
+ * @return string Raw URL, or empty string '' if no referrer currently set
+ */
+ this.getAttributionReferrerUrl = function () {
+ return loadReferrerAttributionCookie()[3];
+ };
+
+ /**
+ * Specify the Matomo tracking URL
+ *
+ * @param string trackerUrl
+ */
+ this.setTrackerUrl = function (trackerUrl) {
+ configTrackerUrl = trackerUrl;
+ };
+
+ /**
+ * Returns the Matomo tracking URL
+ * @returns string
+ */
+ this.getTrackerUrl = function () {
+ return configTrackerUrl;
+ };
+
+ /**
+ * Returns the Matomo server URL.
+ *
+ * @returns string
+ */
+ this.getMatomoUrl = function () {
+ return getMatomoUrlForOverlay(this.getTrackerUrl(), configApiUrl);
+ };
+
+ /**
+ * Returns the Matomo server URL.
+ * @deprecated since Matomo 4.0.0 use `getMatomoUrl()` instead.
+ * @returns string
+ */
+ this.getPiwikUrl = function () {
+ return this.getMatomoUrl();
+ };
+
+ /**
+ * Adds a new tracker. All sent requests will be also sent to the given siteId and matomoUrl.
+ *
+ * @param string matomoUrl The tracker URL of the current tracker instance
+ * @param int|string siteId
+ * @return Tracker
+ */
+ this.addTracker = function (matomoUrl, siteId) {
+ if (!isDefined(matomoUrl) || null === matomoUrl) {
+ matomoUrl = this.getTrackerUrl();
+ }
+
+ var tracker = new Tracker(matomoUrl, siteId);
+
+ asyncTrackers.push(tracker);
+
+ Matomo.trigger('TrackerAdded', [this]);
+
+ return tracker;
+ };
+
+ /**
+ * Returns the site ID
+ *
+ * @returns int
+ */
+ this.getSiteId = function() {
+ return configTrackerSiteId;
+ };
+
+ /**
+ * Specify the site ID
+ *
+ * @param int|string siteId
+ */
+ this.setSiteId = function (siteId) {
+ setSiteId(siteId);
+ };
+
+ /**
+ * Clears the User ID
+ */
+ this.resetUserId = function() {
+ configUserId = '';
+ };
+
+ /**
+ * Sets a User ID to this user (such as an email address or a username)
+ *
+ * @param string User ID
+ */
+ this.setUserId = function (userId) {
+ if (isNumberOrHasLength(userId)) {
+ configUserId = userId;
+ }
+ };
+
+ /**
+ * Sets a Visitor ID to this visitor. Should be a 16 digit hex string.
+ * The visitorId won't be persisted in a cookie or something similar and needs to be set every time.
+ *
+ * @param string User ID
+ */
+ this.setVisitorId = function (visitorId) {
+ var validation = /[0-9A-Fa-f]{16}/g;
+
+ if (isString(visitorId) && validation.test(visitorId)) {
+ visitorUUID = visitorId;
+ } else {
+ logConsoleError('Invalid visitorId set' + visitorId);
+ }
+ };
+
+ /**
+ * Gets the User ID if set.
+ *
+ * @returns string User ID
+ */
+ this.getUserId = function() {
+ return configUserId;
+ };
+
+ /**
+ * Pass custom data to the server
+ *
+ * Examples:
+ * tracker.setCustomData(object);
+ * tracker.setCustomData(key, value);
+ *
+ * @param mixed key_or_obj
+ * @param mixed opt_value
+ */
+ this.setCustomData = function (key_or_obj, opt_value) {
+ if (isObject(key_or_obj)) {
+ configCustomData = key_or_obj;
+ } else {
+ if (!configCustomData) {
+ configCustomData = {};
+ }
+ configCustomData[key_or_obj] = opt_value;
+ }
+ };
+
+ /**
+ * Get custom data
+ *
+ * @return mixed
+ */
+ this.getCustomData = function () {
+ return configCustomData;
+ };
+
+ /**
+ * Configure function with custom request content processing logic.
+ * It gets called after request content in form of query parameters string has been prepared and before request content gets sent.
+ *
+ * Examples:
+ * tracker.setCustomRequestProcessing(function(request){
+ * var pairs = request.split('&');
+ * var result = {};
+ * pairs.forEach(function(pair) {
+ * pair = pair.split('=');
+ * result[pair[0]] = decodeURIComponent(pair[1] || '');
+ * });
+ * return JSON.stringify(result);
+ * });
+ *
+ * @param function customRequestContentProcessingLogic
+ */
+ this.setCustomRequestProcessing = function (customRequestContentProcessingLogic) {
+ configCustomRequestContentProcessing = customRequestContentProcessingLogic;
+ };
+
+ /**
+ * Appends the specified query string to the matomo.php?... Tracking API URL
+ *
+ * @param string queryString eg. 'lat=140&long=100'
+ */
+ this.appendToTrackingUrl = function (queryString) {
+ configAppendToTrackingUrl = queryString;
+ };
+
+ /**
+ * Returns the query string for the current HTTP Tracking API request.
+ * Matomo would prepend the hostname and path to Matomo: http://example.org/matomo/matomo.php?
+ * prior to sending the request.
+ *
+ * @param request eg. "param=value¶m2=value2"
+ */
+ this.getRequest = function (request) {
+ return getRequest(request);
+ };
+
+ /**
+ * Add plugin defined by a name and a callback function.
+ * The callback function will be called whenever a tracking request is sent.
+ * This can be used to append data to the tracking request, or execute other custom logic.
+ *
+ * @param string pluginName
+ * @param Object pluginObj
+ */
+ this.addPlugin = function (pluginName, pluginObj) {
+ plugins[pluginName] = pluginObj;
+ };
+
+ /**
+ * Set Custom Dimensions. Set Custom Dimensions will not be cleared after a tracked pageview and will
+ * be sent along all following tracking requests. It is possible to remove/clear a value via `deleteCustomDimension`.
+ *
+ * @param int index A Custom Dimension index
+ * @param string value
+ */
+ this.setCustomDimension = function (customDimensionId, value) {
+ customDimensionId = parseInt(customDimensionId, 10);
+ if (customDimensionId > 0) {
+ if (!isDefined(value)) {
+ value = '';
+ }
+ if (!isString(value)) {
+ value = String(value);
+ }
+ customDimensions[customDimensionId] = value;
+ }
+ };
+
+ /**
+ * Get a stored value for a specific Custom Dimension index.
+ *
+ * @param int index A Custom Dimension index
+ */
+ this.getCustomDimension = function (customDimensionId) {
+ customDimensionId = parseInt(customDimensionId, 10);
+ if (customDimensionId > 0 && Object.prototype.hasOwnProperty.call(customDimensions, customDimensionId)) {
+ return customDimensions[customDimensionId];
+ }
+ };
+
+ /**
+ * Delete a custom dimension.
+ *
+ * @param int index Custom dimension Id
+ */
+ this.deleteCustomDimension = function (customDimensionId) {
+ customDimensionId = parseInt(customDimensionId, 10);
+ if (customDimensionId > 0) {
+ delete customDimensions[customDimensionId];
+ }
+ };
+
+ /**
+ * Set custom variable within this visit
+ *
+ * @param int index Custom variable slot ID from 1-5
+ * @param string name
+ * @param string value
+ * @param string scope Scope of Custom Variable:
+ * - "visit" will store the name/value in the visit and will persist it in the cookie for the duration of the visit,
+ * - "page" will store the name/value in the next page view tracked.
+ * - "event" will store the name/value in the next event tracked.
+ */
+ this.setCustomVariable = function (index, name, value, scope) {
+ var toRecord;
+
+ if (!isDefined(scope)) {
+ scope = 'visit';
+ }
+ if (!isDefined(name)) {
+ return;
+ }
+ if (!isDefined(value)) {
+ value = "";
+ }
+ if (index > 0) {
+ name = !isString(name) ? String(name) : name;
+ value = !isString(value) ? String(value) : value;
+ toRecord = [name.slice(0, customVariableMaximumLength), value.slice(0, customVariableMaximumLength)];
+ // numeric scope is there for GA compatibility
+ if (scope === 'visit' || scope === 2) {
+ loadCustomVariables();
+ customVariables[index] = toRecord;
+ } else if (scope === 'page' || scope === 3) {
+ customVariablesPage[index] = toRecord;
+ } else if (scope === 'event') { /* GA does not have 'event' scope but we do */
+ customVariablesEvent[index] = toRecord;
+ }
+ }
+ };
+
+ /**
+ * Get custom variable
+ *
+ * @param int index Custom variable slot ID from 1-5
+ * @param string scope Scope of Custom Variable: "visit" or "page" or "event"
+ */
+ this.getCustomVariable = function (index, scope) {
+ var cvar;
+
+ if (!isDefined(scope)) {
+ scope = "visit";
+ }
+
+ if (scope === "page" || scope === 3) {
+ cvar = customVariablesPage[index];
+ } else if (scope === "event") {
+ cvar = customVariablesEvent[index];
+ } else if (scope === "visit" || scope === 2) {
+ loadCustomVariables();
+ cvar = customVariables[index];
+ }
+
+ if (!isDefined(cvar)
+ || (cvar && cvar[0] === '')) {
+ return false;
+ }
+
+ return cvar;
+ };
+
+ /**
+ * Delete custom variable
+ *
+ * @param int index Custom variable slot ID from 1-5
+ * @param string scope
+ */
+ this.deleteCustomVariable = function (index, scope) {
+ // Only delete if it was there already
+ if (this.getCustomVariable(index, scope)) {
+ this.setCustomVariable(index, '', '', scope);
+ }
+ };
+
+ /**
+ * Deletes all custom variables for a certain scope.
+ *
+ * @param string scope
+ */
+ this.deleteCustomVariables = function (scope) {
+ if (scope === "page" || scope === 3) {
+ customVariablesPage = {};
+ } else if (scope === "event") {
+ customVariablesEvent = {};
+ } else if (scope === "visit" || scope === 2) {
+ customVariables = {};
+ }
+ };
+
+ /**
+ * When called then the Custom Variables of scope "visit" will be stored (persisted) in a first party cookie
+ * for the duration of the visit. This is useful if you want to call getCustomVariable later in the visit.
+ *
+ * By default, Custom Variables of scope "visit" are not stored on the visitor's computer.
+ */
+ this.storeCustomVariablesInCookie = function () {
+ configStoreCustomVariablesInCookie = true;
+ };
+
+ /**
+ * Set delay for link tracking (in milliseconds)
+ *
+ * @param int delay
+ */
+ this.setLinkTrackingTimer = function (delay) {
+ configTrackerPause = delay;
+ };
+
+ /**
+ * Get delay for link tracking (in milliseconds)
+ *
+ * @param int delay
+ */
+ this.getLinkTrackingTimer = function () {
+ return configTrackerPause;
+ };
+
+ /**
+ * Set list of file extensions to be recognized as downloads
+ *
+ * @param string|array extensions
+ */
+ this.setDownloadExtensions = function (extensions) {
+ if(isString(extensions)) {
+ extensions = extensions.split('|');
+ }
+ configDownloadExtensions = extensions;
+ };
+
+ /**
+ * Specify additional file extensions to be recognized as downloads
+ *
+ * @param string|array extensions for example 'custom' or ['custom1','custom2','custom3']
+ */
+ this.addDownloadExtensions = function (extensions) {
+ var i;
+ if(isString(extensions)) {
+ extensions = extensions.split('|');
+ }
+ for (i=0; i < extensions.length; i++) {
+ configDownloadExtensions.push(extensions[i]);
+ }
+ };
+
+ /**
+ * Removes specified file extensions from the list of recognized downloads
+ *
+ * @param string|array extensions for example 'custom' or ['custom1','custom2','custom3']
+ */
+ this.removeDownloadExtensions = function (extensions) {
+ var i, newExtensions = [];
+ if(isString(extensions)) {
+ extensions = extensions.split('|');
+ }
+ for (i=0; i < configDownloadExtensions.length; i++) {
+ if (indexOfArray(extensions, configDownloadExtensions[i]) === -1) {
+ newExtensions.push(configDownloadExtensions[i]);
+ }
+ }
+ configDownloadExtensions = newExtensions;
+ };
+
+ /**
+ * Set array of domains to be treated as local. Also supports path, eg '.matomo.org/subsite1'. In this
+ * case all links that don't go to '*.matomo.org/subsite1/ *' would be treated as outlinks.
+ * For example a link to 'matomo.org/' or 'matomo.org/subsite2' both would be treated as outlinks.
+ *
+ * Also supports page wildcard, eg 'matomo.org/index*'. In this case all links
+ * that don't go to matomo.org/index* would be treated as outlinks.
+ *
+ * The current domain will be added automatically if no given host alias contains a path and if no host
+ * alias is already given for the current host alias. Say you are on "example.org" and set
+ * "hostAlias = ['example.com', 'example.org/test']" then the current "example.org" domain will not be
+ * added as there is already a more restrictive hostAlias 'example.org/test' given. We also do not add
+ * it automatically if there was any other host specifying any path like
+ * "['example.com', 'example2.com/test']". In this case we would also not add the current
+ * domain "example.org" automatically as the "path" feature is used. As soon as someone uses the path
+ * feature, for Matomo JS Tracker to work correctly in all cases, one needs to specify all hosts
+ * manually.
+ *
+ * @param string|array hostsAlias
+ */
+ this.setDomains = function (hostsAlias) {
+ configHostsAlias = isString(hostsAlias) ? [hostsAlias] : hostsAlias;
+
+ var hasDomainAliasAlready = false, i = 0, alias;
+ for (i; i < configHostsAlias.length; i++) {
+ alias = String(configHostsAlias[i]);
+
+ if (isSameHost(domainAlias, domainFixup(alias))) {
+ hasDomainAliasAlready = true;
+ break;
+ }
+
+ var pathName = getPathName(alias);
+ if (pathName && pathName !== '/' && pathName !== '/*') {
+ hasDomainAliasAlready = true;
+ break;
+ }
+ }
+
+ // The current domain will be added automatically if no given host alias contains a path
+ // and if no host alias is already given for the current host alias.
+ if (!hasDomainAliasAlready) {
+ /**
+ * eg if domainAlias = 'matomo.org' and someone set hostsAlias = ['matomo.org/foo'] then we should
+ * not add matomo.org as it would increase the allowed scope.
+ */
+ configHostsAlias.push(domainAlias);
+ }
+ };
+
+ /**
+ * Set array of domains to be excluded as referrer. Also supports path, eg '.matomo.org/subsite1'. In this
+ * case all referrers that don't match '*.matomo.org/subsite1/ *' would still be used as referrer.
+ * For example 'matomo.org/' or 'matomo.org/subsite2' would both be used as referrer.
+ *
+ * Also supports page wildcard, eg 'matomo.org/index*'. In this case all referrers
+ * that don't match matomo.org/index* would still be treated as referrer.
+ *
+ * Domains added with setDomains will automatically be excluded as referrers.
+ *
+ * @param string|array excludedReferrers
+ */
+ this.setExcludedReferrers = function(excludedReferrers) {
+ configExcludedReferrers = isString(excludedReferrers) ? [excludedReferrers] : excludedReferrers;
+ };
+
+ /**
+ * Enables cross domain linking. By default, the visitor ID that identifies a unique visitor is stored in
+ * the browser's first party cookies. This means the cookie can only be accessed by pages on the same domain.
+ * If you own multiple domains and would like to track all the actions and pageviews of a specific visitor
+ * into the same visit, you may enable cross domain linking. Whenever a user clicks on a link it will append
+ * a URL parameter pk_vid to the clicked URL which consists of these parts: 16 char visitorId, a 10 character
+ * current timestamp and the last 6 characters are an id based on the userAgent to identify the users device).
+ * This way the current visitorId is forwarded to the page of the different domain.
+ *
+ * On the different domain, the Matomo tracker will recognize the set visitorId from the URL parameter and
+ * reuse this parameter if the page was loaded within 45 seconds. If cross domain linking was not enabled,
+ * it would create a new visit on that page because we wouldn't be able to access the previously created
+ * cookie. By enabling cross domain linking you can track several different domains into one website and
+ * won't lose for example the original referrer.
+ *
+ * To make cross domain linking work you need to set which domains should be considered as your domains by
+ * calling the method "setDomains()" first. We will add the URL parameter to links that go to a
+ * different domain but only if the domain was previously set with "setDomains()" to make sure not to append
+ * the URL parameters when a link actually goes to a third-party URL.
+ */
+ this.enableCrossDomainLinking = function () {
+ crossDomainTrackingEnabled = true;
+ };
+
+ /**
+ * Disable cross domain linking if it was previously enabled. See enableCrossDomainLinking();
+ */
+ this.disableCrossDomainLinking = function () {
+ crossDomainTrackingEnabled = false;
+ };
+
+ /**
+ * Detect whether cross domain linking is enabled or not. See enableCrossDomainLinking();
+ * @returns bool
+ */
+ this.isCrossDomainLinkingEnabled = function () {
+ return crossDomainTrackingEnabled;
+ };
+
+
+ /**
+ * By default, the two visits across domains will be linked together
+ * when the link is click and the page is loaded within 180 seconds.
+ * @param timeout in seconds
+ */
+ this.setCrossDomainLinkingTimeout = function (timeout) {
+ configVisitorIdUrlParameterTimeoutInSeconds = timeout;
+ };
+
+ /**
+ * Returns the query parameter appended to link URLs so cross domain visits
+ * can be detected.
+ *
+ * If your application creates links dynamically, then you'll have to add this
+ * query parameter manually to those links (since the JavaScript tracker cannot
+ * detect when those links are added).
+ *
+ * Eg:
+ *
+ * var url = 'http://myotherdomain.com/?' + matomoTracker.getCrossDomainLinkingUrlParameter();
+ * $element.append('');
+ */
+ this.getCrossDomainLinkingUrlParameter = function () {
+ return encodeWrapper(configVisitorIdUrlParameter) + '=' + encodeWrapper(getCrossDomainVisitorId());
+ };
+
+ /**
+ * Set array of classes to be ignored if present in link
+ *
+ * @param string|array ignoreClasses
+ */
+ this.setIgnoreClasses = function (ignoreClasses) {
+ configIgnoreClasses = isString(ignoreClasses) ? [ignoreClasses] : ignoreClasses;
+ };
+
+ /**
+ * Set request method. If you specify GET then it will automatically disable sendBeacon.
+ *
+ * @param string method GET or POST; default is GET
+ */
+ this.setRequestMethod = function (method) {
+ if (method) {
+ configRequestMethod = String(method).toUpperCase();
+ } else {
+ configRequestMethod = defaultRequestMethod;
+ }
+
+ if (configRequestMethod === 'GET') {
+ // send beacon always sends a POST request so we have to disable it to make GET work
+ this.disableAlwaysUseSendBeacon();
+ }
+ };
+
+ /**
+ * Set request Content-Type header value, applicable when POST request method is used for submitting tracking events.
+ * See XMLHttpRequest Level 2 spec, section 4.7.2 for invalid headers
+ * @link http://dvcs.w3.org/hg/xhr/raw-file/tip/Overview.html
+ *
+ * @param string requestContentType; default is 'application/x-www-form-urlencoded; charset=UTF-8'
+ */
+ this.setRequestContentType = function (requestContentType) {
+ configRequestContentType = requestContentType || defaultRequestContentType;
+ };
+
+ /**
+ * Removed since Matomo 4
+ * @param generationTime
+ */
+ this.setGenerationTimeMs = function(generationTime) {
+ logConsoleError('setGenerationTimeMs is no longer supported since Matomo 4. The call will be ignored. The replacement is setPagePerformanceTiming.');
+ };
+
+ /**
+ * Replace setGenerationTimeMs with this more generic function
+ * Use in SPA
+ * @param networkTimeInMs
+ * @param serverTimeInMs
+ * @param transferTimeInMs
+ * @param domProcessingTimeInMs
+ * @param domCompletionTimeInMs
+ * @param onloadTimeInMs
+ */
+ this.setPagePerformanceTiming = function(
+ networkTimeInMs, serverTimeInMs, transferTimeInMs,
+ domProcessingTimeInMs, domCompletionTimeInMs, onloadTimeInMs
+ ) {
+ /*members pf_net, pf_srv, pf_tfr, pf_dm1, pf_dm2, pf_onl */
+ var data = {
+ pf_net: networkTimeInMs,
+ pf_srv: serverTimeInMs,
+ pf_tfr: transferTimeInMs,
+ pf_dm1: domProcessingTimeInMs,
+ pf_dm2: domCompletionTimeInMs,
+ pf_onl: onloadTimeInMs
+ };
+
+ try {
+ data = filterIn(data, isDefined);
+ data = onlyPositiveIntegers(data);
+ customPagePerformanceTiming = queryStringify(data);
+ if (customPagePerformanceTiming === '') {
+ logConsoleError('setPagePerformanceTiming() called without parameters. This function needs to be called with at least one performance parameter.');
+ return;
+ }
+
+ performanceTracked = false; // to ensure the values are sent (again)
+ performanceAvailable = true; // so appendAvailablePerformanceMetrics will be called directly
+ // Otherwise performanceAvailable will be set when the pageload finished, but there is no need
+ // to wait for that, when the values are set manually.
+ } catch (error) {
+ logConsoleError('setPagePerformanceTiming: ' + error.toString());
+ }
+ };
+
+ /**
+ * Override referrer
+ *
+ * @param string url
+ */
+ this.setReferrerUrl = function (url) {
+ configReferrerUrl = url;
+ };
+
+ /**
+ * Override url
+ *
+ * @param string url
+ */
+ this.setCustomUrl = function (url) {
+ configCustomUrl = resolveRelativeReference(locationHrefAlias, url);
+ };
+
+ /**
+ * Returns the current url of the page that is currently being visited. If a custom URL was set, the
+ * previously defined custom URL will be returned.
+ */
+ this.getCurrentUrl = function () {
+ return configCustomUrl || locationHrefAlias;
+ };
+
+ /**
+ * Override document.title
+ *
+ * @param string title
+ */
+ this.setDocumentTitle = function (title) {
+ configTitle = title;
+ };
+
+ /**
+ * Override PageView id for every use of logPageView(). Do not use this if you call trackPageView()
+ * multiple times during tracking (if, for example, you are tracking a single page application).
+ *
+ * @param string pageView
+ */
+ this.setPageViewId = function (pageView) {
+ configIdPageView = pageView;
+ configIdPageViewSetManually = true;
+ };
+
+ /**
+ * Set the URL of the Matomo API. It is used for Page Overlay.
+ * This method should only be called when the API URL differs from the tracker URL.
+ *
+ * @param string apiUrl
+ */
+ this.setAPIUrl = function (apiUrl) {
+ configApiUrl = apiUrl;
+ };
+
+ /**
+ * Set array of classes to be treated as downloads
+ *
+ * @param string|array downloadClasses
+ */
+ this.setDownloadClasses = function (downloadClasses) {
+ configDownloadClasses = isString(downloadClasses) ? [downloadClasses] : downloadClasses;
+ };
+
+ /**
+ * Set array of classes to be treated as outlinks
+ *
+ * @param string|array linkClasses
+ */
+ this.setLinkClasses = function (linkClasses) {
+ configLinkClasses = isString(linkClasses) ? [linkClasses] : linkClasses;
+ };
+
+ /**
+ * Set array of campaign name parameters
+ *
+ * @see https://matomo.org/faq/how-to/faq_120
+ * @param string|array campaignNames
+ */
+ this.setCampaignNameKey = function (campaignNames) {
+ configCampaignNameParameters = isString(campaignNames) ? [campaignNames] : campaignNames;
+ };
+
+ /**
+ * Set array of campaign keyword parameters
+ *
+ * @see https://matomo.org/faq/how-to/faq_120
+ * @param string|array campaignKeywords
+ */
+ this.setCampaignKeywordKey = function (campaignKeywords) {
+ configCampaignKeywordParameters = isString(campaignKeywords) ? [campaignKeywords] : campaignKeywords;
+ };
+
+ /**
+ * Strip hash tag (or anchor) from URL
+ * Note: this can be done in the Matomo>Settings>Websites on a per-website basis
+ *
+ * @deprecated
+ * @param bool enableFilter
+ */
+ this.discardHashTag = function (enableFilter) {
+ configDiscardHashTag = enableFilter;
+ };
+
+ /**
+ * Set first-party cookie name prefix
+ *
+ * @param string cookieNamePrefix
+ */
+ this.setCookieNamePrefix = function (cookieNamePrefix) {
+ configCookieNamePrefix = cookieNamePrefix;
+ // Re-init the Custom Variables cookie
+ if (customVariables) {
+ customVariables = getCustomVariablesFromCookie();
+ }
+ };
+
+ /**
+ * Set first-party cookie domain
+ *
+ * @param string domain
+ */
+ this.setCookieDomain = function (domain) {
+ var domainFixed = domainFixup(domain);
+
+ if (!configCookiesDisabled && !isPossibleToSetCookieOnDomain(domainFixed)) {
+ logConsoleError('Can\'t write cookie on domain ' + domain);
+ } else {
+ configCookieDomain = domainFixed;
+ updateDomainHash();
+ }
+ };
+
+ /**
+ * Set an array of query parameters to be excluded if in the url
+ *
+ * @param string|array excludedQueryParams 'uid' or ['uid', 'sid']
+ */
+ this.setExcludedQueryParams = function (excludedQueryParams) {
+ configExcludedQueryParams = isString(excludedQueryParams) ? [excludedQueryParams] : excludedQueryParams;
+ };
+
+ /**
+ * Get first-party cookie domain
+ */
+ this.getCookieDomain = function () {
+ return configCookieDomain;
+ };
+
+ /**
+ * Detect if cookies are enabled and supported by browser.
+ */
+ this.hasCookies = function () {
+ return '1' === hasCookies();
+ };
+
+ /**
+ * Set a first-party cookie for the duration of the session.
+ *
+ * @param string cookieName
+ * @param string cookieValue
+ * @param int msToExpire Defaults to session cookie timeout
+ */
+ this.setSessionCookie = function (cookieName, cookieValue, msToExpire) {
+ if (!cookieName) {
+ throw new Error('Missing cookie name');
+ }
+
+ if (!isDefined(msToExpire)) {
+ msToExpire = configSessionCookieTimeout;
+ }
+
+ configCookiesToDelete.push(cookieName);
+
+ setCookie(getCookieName(cookieName), cookieValue, msToExpire, configCookiePath, configCookieDomain, configCookieIsSecure, configCookieSameSite);
+ };
+
+ /**
+ * Get first-party cookie value.
+ *
+ * Returns null if cookies are disabled or if no cookie could be found for this name.
+ *
+ * @param string cookieName
+ */
+ this.getCookie = function (cookieName) {
+ var cookieValue = getCookie(getCookieName(cookieName));
+
+ if (cookieValue === 0) {
+ return null;
+ }
+
+ return cookieValue;
+ };
+
+ /**
+ * Set first-party cookie path.
+ *
+ * @param string domain
+ */
+ this.setCookiePath = function (path) {
+ configCookiePath = path;
+ updateDomainHash();
+ };
+
+ /**
+ * Get first-party cookie path.
+ *
+ * @param string domain
+ */
+ this.getCookiePath = function (path) {
+ return configCookiePath;
+ };
+
+ /**
+ * Set visitor cookie timeout (in seconds)
+ * Defaults to 13 months (timeout=33955200)
+ *
+ * @param int timeout
+ */
+ this.setVisitorCookieTimeout = function (timeout) {
+ configVisitorCookieTimeout = timeout * 1000;
+ };
+
+ /**
+ * Set session cookie timeout (in seconds).
+ * Defaults to 30 minutes (timeout=1800)
+ *
+ * @param int timeout
+ */
+ this.setSessionCookieTimeout = function (timeout) {
+ configSessionCookieTimeout = timeout * 1000;
+ };
+
+ /**
+ * Get session cookie timeout (in seconds).
+ */
+ this.getSessionCookieTimeout = function () {
+ return configSessionCookieTimeout;
+ };
+
+ /**
+ * Set referral cookie timeout (in seconds).
+ * Defaults to 6 months (15768000000)
+ *
+ * @param int timeout
+ */
+ this.setReferralCookieTimeout = function (timeout) {
+ configReferralCookieTimeout = timeout * 1000;
+ };
+
+ /**
+ * Set conversion attribution to first referrer and campaign
+ *
+ * @param bool if true, use first referrer (and first campaign)
+ * if false, use the last referrer (or campaign)
+ */
+ this.setConversionAttributionFirstReferrer = function (enable) {
+ configConversionAttributionFirstReferrer = enable;
+ };
+
+ /**
+ * Enable the Secure cookie flag on all first party cookies.
+ * This should be used when your website is only available under HTTPS
+ * so that all tracking cookies are always sent over secure connection.
+ *
+ * Warning: If your site is available under http and https,
+ * setting this might lead to duplicate or incomplete visits.
+ *
+ * @param bool
+ */
+ this.setSecureCookie = function (enable) {
+ if(enable && location.protocol !== 'https:') {
+ logConsoleError("Error in setSecureCookie: You cannot use `Secure` on http.");
+ return;
+ }
+ configCookieIsSecure = enable;
+ };
+
+ /**
+ * Set the SameSite attribute for cookies to a custom value.
+ * You might want to use this if your site is running in an iframe since
+ * then it will only be able to access the cookies if SameSite is set to 'None'.
+ *
+ *
+ * Warning:
+ * Sets CookieIsSecure to true on None, because None will only work with Secure; cookies
+ * If your site is available under http and https,
+ * using "None" might lead to duplicate or incomplete visits.
+ *
+ * @param string either Lax, None or Strict
+ */
+ this.setCookieSameSite = function (sameSite) {
+ sameSite = String(sameSite);
+ sameSite = sameSite.charAt(0).toUpperCase() + sameSite.toLowerCase().slice(1);
+ if (sameSite !== 'None' && sameSite !== 'Lax' && sameSite !== 'Strict') {
+ logConsoleError('Ignored value for sameSite. Please use either Lax, None, or Strict.');
+ return;
+ }
+ if (sameSite === 'None') {
+ if (location.protocol === 'https:') {
+ this.setSecureCookie(true);
+ } else {
+ logConsoleError('sameSite=None cannot be used on http, reverted to sameSite=Lax.');
+ sameSite = 'Lax';
+ }
+ }
+ configCookieSameSite = sameSite;
+ };
+
+ /**
+ * Disables all cookies from being set
+ *
+ * Existing cookies will be deleted on the next call to track
+ */
+ this.disableCookies = function () {
+ configCookiesDisabled = true;
+
+ if (configTrackerSiteId) {
+ deleteCookies();
+ }
+ };
+
+ /**
+ * Detects if cookies are enabled or not
+ * @returns {boolean}
+ */
+ this.areCookiesEnabled = function () {
+ return !configCookiesDisabled;
+ };
+
+ /**
+ * Enables cookies if they were disabled previously.
+ */
+ this.setCookieConsentGiven = function () {
+ if (configCookiesDisabled && !configDoNotTrack) {
+ configCookiesDisabled = false;
+ configBrowserFeatureDetection = true;
+ if (configTrackerSiteId && hasSentTrackingRequestYet) {
+ setVisitorIdCookie();
+
+ // sets attribution cookie, and updates visitorId in the backend
+ // because hasSentTrackingRequestYet=true we assume there might not be another tracking
+ // request within this page view so we trigger one ourselves.
+ // if no tracking request has been sent yet, we don't set the attribution cookie cause Matomo
+ // sets the cookie only when there is a tracking request. It'll be set if the user sends
+ // a tracking request afterwards
+ var request = getRequest('ping=1', null, 'ping');
+ sendRequest(request, configTrackerPause);
+ }
+ }
+ };
+
+ /**
+ * When called, no cookies will be set until you have called `setCookieConsentGiven()`
+ * unless consent was given previously AND you called {@link rememberCookieConsentGiven()} when the user
+ * gave consent.
+ *
+ * This may be useful when you want to implement for example a popup to ask for cookie consent.
+ * Once the user has given consent, you should call {@link setCookieConsentGiven()}
+ * or {@link rememberCookieConsentGiven()}.
+ *
+ * If you require tracking consent for example because you are tracking personal data and GDPR applies to you,
+ * then have a look at `_paq.push(['requireConsent'])` instead.
+ *
+ * If the user has already given consent in the past, you can either decide to not call `requireCookieConsent` at all
+ * or call `_paq.push(['setCookieConsentGiven'])` on each page view at any time after calling `requireCookieConsent`.
+ *
+ * When the user gives you the consent to set cookies, you can also call `_paq.push(['rememberCookieConsentGiven', optionalTimeoutInHours])`
+ * and for the duration while the cookie consent is remembered, any call to `requireCoookieConsent` will be automatically ignored
+ * until you call `forgetCookieConsentGiven`.
+ * `forgetCookieConsentGiven` needs to be called when the user removes consent for using cookies. This means if you call `rememberCookieConsentGiven` at the
+ * time the user gives you consent, you do not need to ever call `_paq.push(['setCookieConsentGiven'])` as the consent
+ * will be detected automatically through cookies.
+ */
+ this.requireCookieConsent = function() {
+ if (this.getRememberedCookieConsent()) {
+ return false;
+ }
+ this.disableCookies();
+ return true;
+ };
+
+ /**
+ * If the user has given cookie consent previously and this consent was remembered, it will return the number
+ * in milliseconds since 1970/01/01 which is the date when the user has given cookie consent. Please note that
+ * the returned time depends on the users local time which may not always be correct.
+ *
+ * @returns number|string
+ */
+ this.getRememberedCookieConsent = function () {
+ return getCookie(COOKIE_CONSENT_COOKIE_NAME);
+ };
+
+ /**
+ * Calling this method will remove any previously given cookie consent and it disables cookies for subsequent
+ * page views. You may call this method if the user removes cookie consent manually, or if you
+ * want to re-ask for cookie consent after a specific time period.
+ */
+ this.forgetCookieConsentGiven = function () {
+ deleteCookie(COOKIE_CONSENT_COOKIE_NAME, configCookiePath, configCookieDomain);
+ this.disableCookies();
+ };
+
+ /**
+ * Calling this method will remember that the user has given cookie consent across multiple requests by setting
+ * a cookie named "mtm_cookie_consent". You can optionally define the lifetime of that cookie in hours
+ * using a parameter.
+ *
+ * When you call this method, we imply that the user has given cookie consent for this page view, and will also
+ * imply consent for all future page views unless the cookie expires or the user
+ * deletes all their cookies. Remembering cookie consent means even if you call {@link disableCookies()},
+ * then cookies will still be enabled and it won't disable cookies since the user has given consent for cookies.
+ *
+ * Please note that this feature requires you to set the `cookieDomain` and `cookiePath` correctly. Please
+ * also note that when you call this method, consent will be implied for all sites that match the configured
+ * cookieDomain and cookiePath. Depending on your website structure, you may need to restrict or widen the
+ * scope of the cookie domain/path to ensure the consent is applied to the sites you want.
+ *
+ * @param int hoursToExpire After how many hours the cookie consent should expire. By default the consent is valid
+ * for 30 years unless cookies are deleted by the user or the browser prior to this
+ */
+ this.rememberCookieConsentGiven = function (hoursToExpire) {
+ if (hoursToExpire) {
+ hoursToExpire = hoursToExpire * 60 * 60 * 1000;
+ } else {
+ hoursToExpire = 30 * 365 * 24 * 60 * 60 * 1000;
+ }
+ this.setCookieConsentGiven();
+ var now = new Date().getTime();
+ setCookie(COOKIE_CONSENT_COOKIE_NAME, now, hoursToExpire, configCookiePath, configCookieDomain, configCookieIsSecure, configCookieSameSite);
+ };
+
+ /**
+ * One off cookies clearing. Useful to call this when you know for sure a new visitor is using the same browser,
+ * it maybe helps to "reset" tracking cookies to prevent data reuse for different users.
+ */
+ this.deleteCookies = function () {
+ deleteCookies();
+ };
+
+ /**
+ * Handle do-not-track requests
+ *
+ * @param bool enable If true, don't track if user agent sends 'do-not-track' header
+ */
+ this.setDoNotTrack = function (enable) {
+ var dnt = navigatorAlias.doNotTrack || navigatorAlias.msDoNotTrack;
+ configDoNotTrack = enable && (dnt === 'yes' || dnt === '1');
+
+ // do not track also disables cookies and deletes existing cookies
+ if (configDoNotTrack) {
+ this.disableCookies();
+ }
+ };
+
+ /**
+ * Enables send beacon usage instead of regular XHR which reduces the link tracking time to a minimum
+ * of 100ms instead of 500ms (default). This means when a user clicks for example on an outlink, the
+ * navigation to this page will happen 400ms faster.
+ * In case you are setting a callback method when issuing a tracking request, the callback method will
+ * be executed as soon as the tracking request was sent through "sendBeacon" and not after the tracking
+ * request finished as it is not possible to find out when the request finished.
+ * Send beacon will only be used if the browser actually supports it.
+ */
+ this.alwaysUseSendBeacon = function () {
+ configAlwaysUseSendBeacon = true;
+ };
+
+ /**
+ * Disables send beacon usage instead and instead enables using regular XHR when possible. This makes
+ * callbacks work and also tracking requests will appear in the browser developer tools console.
+ */
+ this.disableAlwaysUseSendBeacon = function () {
+ configAlwaysUseSendBeacon = false;
+ };
+
+ /**
+ * Add click listener to a specific link element.
+ * When clicked, Matomo will log the click automatically.
+ *
+ * @param DOMElement element
+ * @param bool enable If false, do not use pseudo click-handler (middle click + context menu)
+ */
+ this.addListener = function (element, enable) {
+ addClickListener(element, enable, false);
+ };
+
+ /**
+ * Install link tracker.
+ *
+ * If you change the DOM of your website or web application Matomo will automatically detect links
+ * that were added newly.
+ *
+ * The default behaviour is to use actual click events. However, some browsers
+ * (e.g., Firefox, Opera, and Konqueror) don't generate click events for the middle mouse button.
+ *
+ * To capture more "clicks", the pseudo click-handler uses mousedown + mouseup events.
+ * This is not industry standard and is vulnerable to false positives (e.g., drag events).
+ *
+ * There is a Safari/Chrome/Webkit bug that prevents tracking requests from being sent
+ * by either click handler. The workaround is to set a target attribute (which can't
+ * be "_self", "_top", or "_parent").
+ *
+ * @see https://bugs.webkit.org/show_bug.cgi?id=54783
+ *
+ * @param bool enable Defaults to true.
+ * * If "true", use pseudo click-handler (treat middle click and open contextmenu as
+ * left click). A right click (or any click that opens the context menu) on a link
+ * will be tracked as clicked even if "Open in new tab" is not selected.
+ * * If "false" (default), nothing will be tracked on open context menu or middle click.
+ * The context menu is usually opened to open a link / download in a new tab
+ * therefore you can get more accurate results by treat it as a click but it can lead
+ * to wrong click numbers.
+ */
+ this.enableLinkTracking = function (enable) {
+ if (linkTrackingEnabled) {
+ return;
+ }
+ linkTrackingEnabled = true;
+
+ var self = this;
+
+ trackCallbackOnReady(function () {
+ linkTrackingInstalled = true;
+
+ var element = documentAlias.body;
+ addClickListener(element, enable, true);
+ });
+
+ };
+
+ /**
+ * Enable tracking of uncatched JavaScript errors
+ *
+ * If enabled, uncaught JavaScript Errors will be tracked as an event by defining a
+ * window.onerror handler. If a window.onerror handler is already defined we will make
+ * sure to call this previously registered error handler after tracking the error.
+ *
+ * By default we return false in the window.onerror handler to make sure the error still
+ * appears in the browser's console etc. Note: Some older browsers might behave differently
+ * so it could happen that an actual JavaScript error will be suppressed.
+ * If a window.onerror handler was registered we will return the result of this handler.
+ *
+ * Make sure not to overwrite the window.onerror handler after enabling the JS error
+ * tracking as the error tracking won't work otherwise. To capture all JS errors we
+ * recommend to include the Matomo JavaScript tracker in the HTML as early as possible.
+ * If possible directly in before loading any other JavaScript.
+ */
+ this.enableJSErrorTracking = function () {
+ if (enableJSErrorTracking) {
+ return;
+ }
+
+ enableJSErrorTracking = true;
+ var onError = windowAlias.onerror;
+
+ windowAlias.onerror = function (message, url, linenumber, column, error) {
+ trackCallback(function () {
+ var category = 'JavaScript Errors';
+
+ var action = url + ':' + linenumber;
+ if (column) {
+ action += ':' + column;
+ }
+
+ if (indexOfArray(javaScriptErrors, category + action + message) === -1) {
+ javaScriptErrors.push(category + action + message);
+
+ logEvent(category, action, message);
+ }
+ });
+
+ if (onError) {
+ return onError(message, url, linenumber, column, error);
+ }
+
+ return false;
+ };
+ };
+
+ /**
+ * Disable automatic performance tracking
+ */
+ this.disablePerformanceTracking = function () {
+ configPerformanceTrackingEnabled = false;
+ };
+
+ /**
+ * Set heartbeat (in seconds)
+ *
+ * @param int heartBeatDelayInSeconds Defaults to 15s. Cannot be lower than 5.
+ */
+ this.enableHeartBeatTimer = function (heartBeatDelayInSeconds) {
+ heartBeatDelayInSeconds = Math.max(heartBeatDelayInSeconds || 15, 5);
+ configHeartBeatDelay = heartBeatDelayInSeconds * 1000;
+
+ // if a tracking request has already been sent, start the heart beat timeout
+ if (lastTrackerRequestTime !== null) {
+ setUpHeartBeat();
+ }
+ };
+
+ /**
+ * Disable heartbeat if it was previously activated.
+ */
+ this.disableHeartBeatTimer = function () {
+
+ if (configHeartBeatDelay || heartBeatSetUp) {
+ if (windowAlias.removeEventListener) {
+ windowAlias.removeEventListener('focus', heartBeatOnFocus);
+ windowAlias.removeEventListener('blur', heartBeatOnBlur);
+ windowAlias.removeEventListener('visibilitychange', heartBeatOnVisible);
+ } else if (windowAlias.detachEvent) {
+ windowAlias.detachEvent('onfocus', heartBeatOnFocus);
+ windowAlias.detachEvent('onblur', heartBeatOnBlur);
+ windowAlias.detachEvent('visibilitychange', heartBeatOnVisible);
+ }
+ }
+
+ configHeartBeatDelay = null;
+ heartBeatSetUp = false;
+ };
+
+ /**
+ * Frame buster
+ */
+ this.killFrame = function () {
+ if (windowAlias.location !== windowAlias.top.location) {
+ windowAlias.top.location = windowAlias.location;
+ }
+ };
+
+ /**
+ * Redirect if browsing offline (aka file: buster)
+ *
+ * @param string url Redirect to this URL
+ */
+ this.redirectFile = function (url) {
+ if (windowAlias.location.protocol === 'file:') {
+ windowAlias.location = url;
+ }
+ };
+
+ /**
+ * Count sites in pre-rendered state
+ *
+ * @param bool enable If true, track when in pre-rendered state
+ */
+ this.setCountPreRendered = function (enable) {
+ configCountPreRendered = enable;
+ };
+
+ /**
+ * Trigger a goal
+ *
+ * @param int|string idGoal
+ * @param int|float customRevenue
+ * @param mixed customData
+ * @param function callback
+ */
+ this.trackGoal = function (idGoal, customRevenue, customData, callback) {
+ trackCallback(function () {
+ logGoal(idGoal, customRevenue, customData, callback);
+ });
+ };
+
+ /**
+ * Manually log a click from your own code
+ *
+ * @param string sourceUrl
+ * @param string linkType
+ * @param mixed customData
+ * @param function callback
+ */
+ this.trackLink = function (sourceUrl, linkType, customData, callback) {
+ trackCallback(function () {
+ logLink(sourceUrl, linkType, customData, callback);
+ });
+ };
+
+ /**
+ * Get the number of page views that have been tracked so far within the currently loaded page.
+ */
+ this.getNumTrackedPageViews = function () {
+ return numTrackedPageviews;
+ };
+
+ /**
+ * Log visit to this page
+ *
+ * @param string customTitle
+ * @param mixed customData
+ * @param function callback
+ */
+ this.trackPageView = function (customTitle, customData, callback) {
+ trackedContentImpressions = [];
+ consentRequestsQueue = [];
+ javaScriptErrors = [];
+
+ if (isOverlaySession(configTrackerSiteId)) {
+ trackCallback(function () {
+ injectOverlayScripts(configTrackerUrl, configApiUrl, configTrackerSiteId);
+ });
+ } else {
+ trackCallback(function () {
+ numTrackedPageviews++;
+ logPageView(customTitle, customData, callback);
+ });
+ }
+ };
+
+ this.disableBrowserFeatureDetection = function () {
+ configBrowserFeatureDetection = false;
+ };
+
+ this.enableBrowserFeatureDetection = function () {
+ configBrowserFeatureDetection = true;
+ };
+
+ /**
+ * Scans the entire DOM for all content blocks and tracks all impressions once the DOM ready event has
+ * been triggered.
+ *
+ * If you only want to track visible content impressions have a look at `trackVisibleContentImpressions()`.
+ * We do not track an impression of the same content block twice if you call this method multiple times
+ * unless `trackPageView()` is called meanwhile. This is useful for single page applications.
+ */
+ this.trackAllContentImpressions = function () {
+ if (isOverlaySession(configTrackerSiteId)) {
+ return;
+ }
+
+ trackCallback(function () {
+ trackCallbackOnReady(function () {
+ // we have to wait till DOM ready
+ var contentNodes = content.findContentNodes();
+ var requests = getContentImpressionsRequestsFromNodes(contentNodes);
+
+ requestQueue.pushMultiple(requests);
+ });
+ });
+ };
+
+ /**
+ * Scans the entire DOM for all content blocks as soon as the page is loaded. It tracks an impression
+ * only if a content block is actually visible. Meaning it is not hidden and the content is or was at
+ * some point in the viewport.
+ *
+ * If you want to track all content blocks have a look at `trackAllContentImpressions()`.
+ * We do not track an impression of the same content block twice if you call this method multiple times
+ * unless `trackPageView()` is called meanwhile. This is useful for single page applications.
+ *
+ * Once you have called this method you can no longer change `checkOnScroll` or `timeIntervalInMs`.
+ *
+ * If you do want to only track visible content blocks but not want us to perform any automatic checks
+ * as they can slow down your frames per second you can call `trackVisibleContentImpressions()` or
+ * `trackContentImpressionsWithinNode()` manually at any time to rescan the entire DOM for newly
+ * visible content blocks.
+ * o Call `trackVisibleContentImpressions(false, 0)` to initially track only visible content impressions
+ * o Call `trackVisibleContentImpressions()` at any time again to rescan the entire DOM for newly visible content blocks or
+ * o Call `trackContentImpressionsWithinNode(node)` at any time to rescan only a part of the DOM for newly visible content blocks
+ *
+ * @param boolean [checkOnScroll=true] Optional, you can disable rescanning the entire DOM automatically
+ * after each scroll event by passing the value `false`. If enabled,
+ * we check whether a previously hidden content blocks became visible
+ * after a scroll and if so track the impression.
+ * Note: If a content block is placed within a scrollable element
+ * (`overflow: scroll`), we can currently not detect when this block
+ * becomes visible.
+ * @param integer [timeIntervalInMs=750] Optional, you can define an interval to rescan the entire DOM
+ * for new impressions every X milliseconds by passing
+ * for instance `timeIntervalInMs=500` (rescan DOM every 500ms).
+ * Rescanning the entire DOM and detecting the visible state of content
+ * blocks can take a while depending on the browser and amount of content.
+ * In case your frames per second goes down you might want to increase
+ * this value or disable it by passing the value `0`.
+ */
+ this.trackVisibleContentImpressions = function (checkOnScroll, timeIntervalInMs) {
+ if (isOverlaySession(configTrackerSiteId)) {
+ return;
+ }
+
+ if (!isDefined(checkOnScroll)) {
+ checkOnScroll = true;
+ }
+
+ if (!isDefined(timeIntervalInMs)) {
+ timeIntervalInMs = 750;
+ }
+
+ enableTrackOnlyVisibleContent(checkOnScroll, timeIntervalInMs, this);
+
+ trackCallback(function () {
+ trackCallbackOnLoad(function () {
+ // we have to wait till CSS parsed and applied
+ var contentNodes = content.findContentNodes();
+ var requests = getCurrentlyVisibleContentImpressionsRequestsIfNotTrackedYet(contentNodes);
+
+ requestQueue.pushMultiple(requests);
+ });
+ });
+ };
+
+ /**
+ * Tracks a content impression using the specified values. You should not call this method too often
+ * as each call causes an XHR tracking request and can slow down your site or your server.
+ *
+ * @param string contentName For instance "Ad Sale".
+ * @param string [contentPiece='Unknown'] For instance a path to an image or the text of a text ad.
+ * @param string [contentTarget] For instance the URL of a landing page.
+ */
+ this.trackContentImpression = function (contentName, contentPiece, contentTarget) {
+ if (isOverlaySession(configTrackerSiteId)) {
+ return;
+ }
+
+ contentName = trim(contentName);
+ contentPiece = trim(contentPiece);
+ contentTarget = trim(contentTarget);
+
+ if (!contentName) {
+ return;
+ }
+
+ contentPiece = contentPiece || 'Unknown';
+
+ trackCallback(function () {
+ var request = buildContentImpressionRequest(contentName, contentPiece, contentTarget);
+ requestQueue.push(request);
+ });
+ };
+
+ /**
+ * Scans the given DOM node and its children for content blocks and tracks an impression for them if
+ * no impression was already tracked for it. If you have called `trackVisibleContentImpressions()`
+ * upfront only visible content blocks will be tracked. You can use this method if you, for instance,
+ * dynamically add an element using JavaScript to your DOM after we have tracked the initial impressions.
+ *
+ * @param Element domNode
+ */
+ this.trackContentImpressionsWithinNode = function (domNode) {
+ if (isOverlaySession(configTrackerSiteId) || !domNode) {
+ return;
+ }
+
+ trackCallback(function () {
+ if (isTrackOnlyVisibleContentEnabled) {
+ trackCallbackOnLoad(function () {
+ // we have to wait till CSS parsed and applied
+ var contentNodes = content.findContentNodesWithinNode(domNode);
+
+ var requests = getCurrentlyVisibleContentImpressionsRequestsIfNotTrackedYet(contentNodes);
+ requestQueue.pushMultiple(requests);
+ });
+ } else {
+ trackCallbackOnReady(function () {
+ // we have to wait till DOM ready
+ var contentNodes = content.findContentNodesWithinNode(domNode);
+
+ var requests = getContentImpressionsRequestsFromNodes(contentNodes);
+ requestQueue.pushMultiple(requests);
+ });
+ }
+ });
+ };
+
+ /**
+ * Tracks a content interaction using the specified values. You should use this method only in conjunction
+ * with `trackContentImpression()`. The specified `contentName` and `contentPiece` has to be exactly the
+ * same as the ones that were used in `trackContentImpression()`. Otherwise the interaction will not count.
+ *
+ * @param string contentInteraction The type of interaction that happened. For instance 'click' or 'submit'.
+ * @param string contentName The name of the content. For instance "Ad Sale".
+ * @param string [contentPiece='Unknown'] The actual content. For instance a path to an image or the text of a text ad.
+ * @param string [contentTarget] For instance the URL of a landing page.
+ */
+ this.trackContentInteraction = function (contentInteraction, contentName, contentPiece, contentTarget) {
+ if (isOverlaySession(configTrackerSiteId)) {
+ return;
+ }
+
+ contentInteraction = trim(contentInteraction);
+ contentName = trim(contentName);
+ contentPiece = trim(contentPiece);
+ contentTarget = trim(contentTarget);
+
+ if (!contentInteraction || !contentName) {
+ return;
+ }
+
+ contentPiece = contentPiece || 'Unknown';
+
+ trackCallback(function () {
+ var request = buildContentInteractionRequest(contentInteraction, contentName, contentPiece, contentTarget);
+ if (request) {
+ requestQueue.push(request);
+ }
+ });
+ };
+
+ /**
+ * Tracks an interaction with the given DOM node / content block.
+ *
+ * By default we track interactions on click but sometimes you might want to track interactions yourself.
+ * For instance you might want to track an interaction manually on a double click or a form submit.
+ * Make sure to disable the automatic interaction tracking in this case by specifying either the CSS
+ * class `matomoContentIgnoreInteraction` or the attribute `data-content-ignoreinteraction`.
+ *
+ * @param Element domNode This element itself or any of its parent elements has to be a content block
+ * element. Meaning one of those has to have a `matomoTrackContent` CSS class or
+ * a `data-track-content` attribute.
+ * @param string [contentInteraction='Unknown] The name of the interaction that happened. For instance
+ * 'click', 'formSubmit', 'DblClick', ...
+ */
+ this.trackContentInteractionNode = function (domNode, contentInteraction) {
+ if (isOverlaySession(configTrackerSiteId) || !domNode) {
+ return;
+ }
+
+ var theRequest = null;
+
+ trackCallback(function () {
+ theRequest = buildContentInteractionRequestNode(domNode, contentInteraction);
+ if (theRequest) {
+ requestQueue.push(theRequest);
+ }
+ });
+ //note: return value is only for tests... will only work if dom is already ready...
+ return theRequest;
+ };
+
+ /**
+ * Useful to debug content tracking. This method will log all detected content blocks to console
+ * (if the browser supports the console). It will list the detected name, piece, and target of each
+ * content block.
+ */
+ this.logAllContentBlocksOnPage = function () {
+ var contentNodes = content.findContentNodes();
+ var contents = content.collectContent(contentNodes);
+
+ // needed to write it this way for jslint
+ var consoleType = typeof console;
+ if (consoleType !== 'undefined' && console && console.log) {
+ console.log(contents);
+ }
+ };
+
+ /**
+ * Records an event
+ *
+ * @param string category The Event Category (Videos, Music, Games...)
+ * @param string action The Event's Action (Play, Pause, Duration, Add Playlist, Downloaded, Clicked...)
+ * @param string name (optional) The Event's object Name (a particular Movie name, or Song name, or File name...)
+ * @param float value (optional) The Event's value
+ * @param function callback
+ * @param mixed customData
+ */
+ this.trackEvent = function (category, action, name, value, customData, callback) {
+ trackCallback(function () {
+ logEvent(category, action, name, value, customData, callback);
+ });
+ };
+
+ /**
+ * Log special pageview: Internal search
+ *
+ * @param string keyword
+ * @param string category
+ * @param int resultsCount
+ * @param mixed customData
+ */
+ this.trackSiteSearch = function (keyword, category, resultsCount, customData) {
+ trackedContentImpressions = [];
+ trackCallback(function () {
+ logSiteSearch(keyword, category, resultsCount, customData);
+ });
+ };
+
+ /**
+ * Used to record that the current page view is an item (product) page view, or a Ecommerce Category page view.
+ * This must be called before trackPageView() on the product/category page.
+ *
+ * On a category page, you can set the parameter category, and set the other parameters to empty string or false
+ *
+ * Tracking Product/Category page views will allow Matomo to report on Product & Categories
+ * conversion rates (Conversion rate = Ecommerce orders containing this product or category / Visits to the product or category)
+ *
+ * @param string sku Item's SKU code being viewed
+ * @param string name Item's Name being viewed
+ * @param string category Category page being viewed. On an Item's page, this is the item's category
+ * @param float price Item's display price, not use in standard Matomo reports, but output in API product reports.
+ */
+ this.setEcommerceView = function (sku, name, category, price) {
+ ecommerceProductView = {};
+
+ if (isNumberOrHasLength(category)) {
+ category = String(category);
+ }
+ if (!isDefined(category) || category === null || category === false || !category.length) {
+ category = "";
+ } else if (category instanceof Array) {
+ category = windowAlias.JSON.stringify(category);
+ }
+
+ var param = '_pkc';
+ ecommerceProductView[param] = category;
+
+ if (isDefined(price) && price !== null && price !== false && String(price).length) {
+ param = '_pkp';
+ ecommerceProductView[param] = price;
+ }
+
+ // On a category page, do not track Product name not defined
+ if (!isNumberOrHasLength(sku) && !isNumberOrHasLength(name)) {
+ return;
+ }
+
+ if (isNumberOrHasLength(sku)) {
+ param = '_pks';
+ ecommerceProductView[param] = sku;
+ }
+
+ if (!isNumberOrHasLength(name)) {
+ name = "";
+ }
+
+ param = '_pkn';
+ ecommerceProductView[param] = name;
+ };
+
+ /**
+ * Returns the list of ecommerce items that will be sent when a cart update or order is tracked.
+ * The returned value is read-only, modifications will not change what will be tracked. Use
+ * addEcommerceItem/removeEcommerceItem/clearEcommerceCart to modify what items will be tracked.
+ *
+ * Note: the cart will be cleared after an order.
+ *
+ * @returns array
+ */
+ this.getEcommerceItems = function () {
+ return JSON.parse(JSON.stringify(ecommerceItems));
+ };
+
+ /**
+ * Adds an item (product) that is in the current Cart or in the Ecommerce order.
+ * This function is called for every item (product) in the Cart or the Order.
+ * The only required parameter is sku.
+ * The items are deleted from this JavaScript object when the Ecommerce order is tracked via the method trackEcommerceOrder.
+ *
+ * If there is already a saved item for the given sku, it will be updated with the
+ * new information.
+ *
+ * @param string sku (required) Item's SKU Code. This is the unique identifier for the product.
+ * @param string name (optional) Item's name
+ * @param string name (optional) Item's category, or array of up to 5 categories
+ * @param float price (optional) Item's price. If not specified, will default to 0
+ * @param float quantity (optional) Item's quantity. If not specified, will default to 1
+ */
+ this.addEcommerceItem = function (sku, name, category, price, quantity) {
+ if (isNumberOrHasLength(sku)) {
+ ecommerceItems[sku] = [ String(sku), name, category, price, quantity ];
+ }
+ };
+
+ /**
+ * Removes a single ecommerce item by SKU from the current cart.
+ *
+ * @param string sku (required) Item's SKU Code. This is the unique identifier for the product.
+ */
+ this.removeEcommerceItem = function (sku) {
+ if (isNumberOrHasLength(sku)) {
+ sku = String(sku);
+ delete ecommerceItems[sku];
+ }
+ };
+
+ /**
+ * Clears the current cart, removing all saved ecommerce items. Call this method to manually clear
+ * the cart before sending an ecommerce order.
+ */
+ this.clearEcommerceCart = function () {
+ ecommerceItems = {};
+ };
+
+ /**
+ * Tracks an Ecommerce order.
+ * If the Ecommerce order contains items (products), you must call first the addEcommerceItem() for each item in the order.
+ * All revenues (grandTotal, subTotal, tax, shipping, discount) will be individually summed and reported in Matomo reports.
+ * Parameters orderId and grandTotal are required. For others, you can set to false if you don't need to specify them.
+ * After calling this method, items added to the cart will be removed from this JavaScript object.
+ *
+ * @param string|int orderId (required) Unique Order ID.
+ * This will be used to count this order only once in the event the order page is reloaded several times.
+ * orderId must be unique for each transaction, even on different days, or the transaction will not be recorded by Matomo.
+ * @param float grandTotal (required) Grand Total revenue of the transaction (including tax, shipping, etc.)
+ * @param float subTotal (optional) Sub total amount, typically the sum of items prices for all items in this order (before Tax and Shipping costs are applied)
+ * @param float tax (optional) Tax amount for this order
+ * @param float shipping (optional) Shipping amount for this order
+ * @param float discount (optional) Discounted amount in this order
+ */
+ this.trackEcommerceOrder = function (orderId, grandTotal, subTotal, tax, shipping, discount) {
+ logEcommerceOrder(orderId, grandTotal, subTotal, tax, shipping, discount);
+ };
+
+ /**
+ * Tracks a Cart Update (add item, remove item, update item).
+ * On every Cart update, you must call addEcommerceItem() for each item (product) in the cart, including the items that haven't been updated since the last cart update.
+ * Then you can call this function with the Cart grandTotal (typically the sum of all items' prices)
+ * Calling this method does not remove from this JavaScript object the items that were added to the cart via addEcommerceItem
+ *
+ * @param float grandTotal (required) Items (products) amount in the Cart
+ */
+ this.trackEcommerceCartUpdate = function (grandTotal) {
+ logEcommerceCartUpdate(grandTotal);
+ };
+
+ /**
+ * Sends a tracking request with custom request parameters.
+ * Matomo will prepend the hostname and path to Matomo, as well as all other needed tracking request
+ * parameters prior to sending the request. Useful eg if you track custom dimensions via a plugin.
+ *
+ * @param request eg. "param=value¶m2=value2"
+ * @param customData
+ * @param callback
+ * @param pluginMethod
+ */
+ this.trackRequest = function (request, customData, callback, pluginMethod) {
+ trackCallback(function () {
+ var fullRequest = getRequest(request, customData, pluginMethod);
+ sendRequest(fullRequest, configTrackerPause, callback);
+ });
+ };
+
+ /**
+ * Sends a ping request.
+ *
+ * Ping requests do not track new actions. If they are sent within the standard visit length, they will
+ * extend the existing visit and the current last action for the visit. If after the standard visit
+ * length, ping requests will create a new visit using the last action in the last known visit.
+ */
+ this.ping = function () {
+ this.trackRequest('ping=1', null, null, 'ping');
+ };
+
+ /**
+ * Disables sending requests queued
+ */
+ this.disableQueueRequest = function () {
+ requestQueue.enabled = false;
+ };
+
+ /**
+ * Defines after how many ms a queued requests will be executed after the request was queued initially.
+ * The higher the value the more tracking requests can be send together at once.
+ */
+ this.setRequestQueueInterval = function (interval) {
+ if (interval < 1000) {
+ throw new Error('Request queue interval needs to be at least 1000ms');
+ }
+ requestQueue.interval = interval;
+ };
+
+ /**
+ * Won't send the tracking request directly but wait for a short time to possibly send this tracking request
+ * along with other tracking requests in one go. This can reduce the number of requests send to your server.
+ * If the page unloads (user navigates to another page or closes the browser), then all remaining queued
+ * requests will be sent immediately so that no tracking request gets lost.
+ * Note: Any queued request may not be possible to be replayed in case a POST request is sent. Only queue
+ * requests that don't have to be replayed.
+ *
+ * @param request eg. "param=value¶m2=value2"
+ */
+ this.queueRequest = function (request) {
+ trackCallback(function () {
+ var fullRequest = getRequest(request);
+ requestQueue.push(fullRequest);
+ });
+ };
+
+ /**
+ * Returns whether consent is required or not.
+ *
+ * @returns boolean
+ */
+ this.isConsentRequired = function()
+ {
+ return configConsentRequired;
+ };
+
+ /**
+ * If the user has given consent previously and this consent was remembered, it will return the number
+ * in milliseconds since 1970/01/01 which is the date when the user has given consent. Please note that
+ * the returned time depends on the users local time which may not always be correct.
+ *
+ * @returns number|string
+ */
+ this.getRememberedConsent = function () {
+ var value = getCookie(CONSENT_COOKIE_NAME);
+ if (getCookie(CONSENT_REMOVED_COOKIE_NAME)) {
+ // if for some reason the consent_removed cookie is also set with the consent cookie, the
+ // consent_removed cookie overrides the consent one, and we make sure to delete the consent
+ // cookie.
+ if (value) {
+ deleteCookie(CONSENT_COOKIE_NAME, configCookiePath, configCookieDomain);
+ }
+ return null;
+ }
+
+ if (!value || value === 0) {
+ return null;
+ }
+ return value;
+ };
+
+ /**
+ * Detects whether the user has given consent previously.
+ *
+ * @returns bool
+ */
+ this.hasRememberedConsent = function () {
+ return !!this.getRememberedConsent();
+ };
+
+ /**
+ * When called, no tracking request will be sent to the Matomo server until you have called `setConsentGiven()`
+ * unless consent was given previously AND you called {@link rememberConsentGiven()} when the user gave their
+ * consent.
+ *
+ * This may be useful when you want to implement for example a popup to ask for consent before tracking the user.
+ * Once the user has given consent, you should call {@link setConsentGiven()} or {@link rememberConsentGiven()}.
+ *
+ * If you require consent for tracking personal data for example, you should first call
+ * `_paq.push(['requireConsent'])`.
+ *
+ * If the user has already given consent in the past, you can either decide to not call `requireConsent` at all
+ * or call `_paq.push(['setConsentGiven'])` on each page view at any time after calling `requireConsent`.
+ *
+ * When the user gives you the consent to track data, you can also call `_paq.push(['rememberConsentGiven', optionalTimeoutInHours])`
+ * and for the duration while the consent is remembered, any call to `requireConsent` will be automatically ignored until you call `forgetConsentGiven`.
+ * `forgetConsentGiven` needs to be called when the user removes consent for tracking. This means if you call `rememberConsentGiven` at the
+ * time the user gives you consent, you do not need to ever call `_paq.push(['setConsentGiven'])`.
+ */
+ this.requireConsent = function () {
+ configConsentRequired = true;
+ configHasConsent = this.hasRememberedConsent();
+ if (!configHasConsent) {
+ // we won't call this.disableCookies() since we don't want to delete any cookies just yet
+ // user might call `setConsentGiven` next
+ configCookiesDisabled = true;
+ }
+ // Matomo.addPlugin might not be defined at this point, we add the plugin directly also to make JSLint happy
+ // We also want to make sure to define an unload listener for each tracker, not only one tracker.
+ coreConsentCounter++;
+ plugins['CoreConsent' + coreConsentCounter] = {
+ unload: function () {
+ if (!configHasConsent) {
+ // we want to make sure to remove all previously set cookies again
+ deleteCookies();
+ }
+ }
+ };
+ };
+
+ /**
+ * Call this method once the user has given consent. This will cause all tracking requests from this
+ * page view to be sent. Please note that the given consent won't be remembered across page views. If you
+ * want to remember consent across page views, call {@link rememberConsentGiven()} instead.
+ *
+ * It will also automatically enable cookies if they were disabled previously.
+ *
+ * @param bool [setCookieConsent=true] Internal parameter. Defines whether cookies should be enabled or not.
+ */
+ this.setConsentGiven = function (setCookieConsent) {
+ configHasConsent = true;
+ configBrowserFeatureDetection = true;
+ deleteCookie(CONSENT_REMOVED_COOKIE_NAME, configCookiePath, configCookieDomain);
+
+ var i, requestType;
+ for (i = 0; i < consentRequestsQueue.length; i++) {
+ requestType = typeof consentRequestsQueue[i];
+ if (requestType === 'string') {
+ sendRequest(consentRequestsQueue[i], configTrackerPause);
+ } else if (requestType === 'object') {
+ sendBulkRequest(consentRequestsQueue[i], configTrackerPause);
+ }
+ }
+ consentRequestsQueue = [];
+
+ // we need to enable cookies after sending the previous requests as it will make sure that we send
+ // a ping request if needed. Cookies are only set once we call `getRequest`. Above only calls sendRequest
+ // meaning no cookies will be created unless we called enableCookies after at least one request has been sent.
+ // this will cause a ping request to be sent that sets the cookies and also updates the newly generated visitorId
+ // on the server.
+ // If the user calls setConsentGiven before sending any tracking request (which usually is the case) then
+ // nothing will need to be done as it only enables cookies and the next tracking request will set the cookies
+ // etc.
+ if (!isDefined(setCookieConsent) || setCookieConsent) {
+ this.setCookieConsentGiven();
+ }
+ };
+
+ /**
+ * Calling this method will remember that the user has given consent across multiple requests by setting
+ * a cookie. You can optionally define the lifetime of that cookie in hours using a parameter.
+ *
+ * When you call this method, we imply that the user has given consent for this page view, and will also
+ * imply consent for all future page views unless the cookie expires (if timeout defined) or the user
+ * deletes all their cookies. This means even if you call {@link requireConsent()}, then all requests
+ * will still be tracked.
+ *
+ * Please note that this feature requires you to set the `cookieDomain` and `cookiePath` correctly and requires
+ * that you do not disable cookies. Please also note that when you call this method, consent will be implied
+ * for all sites that match the configured cookieDomain and cookiePath. Depending on your website structure,
+ * you may need to restrict or widen the scope of the cookie domain/path to ensure the consent is applied
+ * to the sites you want.
+ *
+ * @param int hoursToExpire After how many hours the consent should expire. By default the consent is valid
+ * for 30 years unless cookies are deleted by the user or the browser prior to this
+ */
+ this.rememberConsentGiven = function (hoursToExpire) {
+ if (hoursToExpire) {
+ hoursToExpire = hoursToExpire * 60 * 60 * 1000;
+ } else {
+ hoursToExpire = 30 * 365 * 24 * 60 * 60 * 1000;
+ }
+ var setCookieConsent = true;
+ // we currently always enable cookies if we remember consent cause we don't store across requests whether
+ // cookies should be automatically enabled or not.
+ this.setConsentGiven(setCookieConsent);
+ var now = new Date().getTime();
+ setCookie(CONSENT_COOKIE_NAME, now, hoursToExpire, configCookiePath, configCookieDomain, configCookieIsSecure, configCookieSameSite);
+ };
+
+ /**
+ * Calling this method will remove any previously given consent and during this page view no request
+ * will be sent anymore ({@link requireConsent()}) will be called automatically to ensure the removed
+ * consent will be enforced. You may call this method if the user removes consent manually, or if you
+ * want to re-ask for consent after a specific time period.
+ */
+ this.forgetConsentGiven = function () {
+ var thirtyYears = 30 * 365 * 24 * 60 * 60 * 1000;
+
+ deleteCookie(CONSENT_COOKIE_NAME, configCookiePath, configCookieDomain);
+ setCookie(CONSENT_REMOVED_COOKIE_NAME, new Date().getTime(), thirtyYears, configCookiePath, configCookieDomain, configCookieIsSecure, configCookieSameSite);
+ this.forgetCookieConsentGiven();
+ this.requireConsent();
+ };
+
+ /**
+ * Returns true if user is opted out, false if otherwise.
+ *
+ * @returns {boolean}
+ */
+ this.isUserOptedOut = function () {
+ return !configHasConsent;
+ };
+
+ /**
+ * Alias for forgetConsentGiven(). After calling this function, the user will no longer be tracked,
+ * (even if they come back to the site).
+ */
+ this.optUserOut = this.forgetConsentGiven;
+
+ /**
+ * Alias for rememberConsentGiven(). After calling this function, the current user will be tracked.
+ */
+ this.forgetUserOptOut = function () {
+ // we can't automatically enable cookies here as we don't know if user actually gave consent for cookies
+ this.setConsentGiven(false);
+ };
+
+ /**
+ * Mark performance metrics as available, once onload event has finished
+ */
+ trackCallbackOnLoad(function(){
+ setTimeout(function(){
+ performanceAvailable = true;
+ }, 0);
+ });
+
+ Matomo.trigger('TrackerSetup', [this]);
+
+ Matomo.addPlugin('TrackerVisitorIdCookie' + uniqueTrackerId, {
+ // if no tracking request was sent we refresh the visitor id cookie on page unload
+ unload: function () {
+ if (!hasSentTrackingRequestYet) {
+ setVisitorIdCookie();
+ // this will set the referrer attribution cookie
+ detectReferrerAttribution();
+ }
+ }
+ });
+ }
+
+ function TrackerProxy() {
+ return {
+ push: apply
+ };
+ }
+
+ /**
+ * Applies the given methods in the given order if they are present in paq.
+ *
+ * @param {Array} paq
+ * @param {Array} methodsToApply an array containing method names in the order that they should be applied
+ * eg ['setSiteId', 'setTrackerUrl']
+ * @returns {Array} the modified paq array with the methods that were already applied set to undefined
+ */
+ function applyMethodsInOrder(paq, methodsToApply)
+ {
+ var appliedMethods = {};
+ var index, iterator;
+
+ for (index = 0; index < methodsToApply.length; index++) {
+ var methodNameToApply = methodsToApply[index];
+ appliedMethods[methodNameToApply] = 1;
+
+ for (iterator = 0; iterator < paq.length; iterator++) {
+ if (paq[iterator] && paq[iterator][0]) {
+ var methodName = paq[iterator][0];
+
+ if (methodNameToApply === methodName) {
+ apply(paq[iterator]);
+ delete paq[iterator];
+
+ if (appliedMethods[methodName] > 1
+ && methodName !== "addTracker"
+ && methodName !== "enableLinkTracking") {
+ logConsoleError('The method ' + methodName + ' is registered more than once in "_paq" variable. Only the last call has an effect. Please have a look at the multiple Matomo trackers documentation: https://developer.matomo.org/guides/tracking-javascript-guide#multiple-piwik-trackers');
+ }
+
+ appliedMethods[methodName]++;
+ }
+ }
+ }
+ }
+
+ return paq;
+ }
+
+ /************************************************************
+ * Constructor
+ ************************************************************/
+
+ var applyFirst = ['addTracker', 'forgetCookieConsentGiven', 'requireCookieConsent','disableBrowserFeatureDetection', 'disableCookies', 'setTrackerUrl', 'setAPIUrl', 'enableCrossDomainLinking', 'setCrossDomainLinkingTimeout', 'setSessionCookieTimeout', 'setVisitorCookieTimeout', 'setCookieNamePrefix', 'setCookieSameSite', 'setSecureCookie', 'setCookiePath', 'setCookieDomain', 'setDomains', 'setUserId', 'setVisitorId', 'setSiteId', 'alwaysUseSendBeacon', 'disableAlwaysUseSendBeacon', 'enableLinkTracking', 'setCookieConsentGiven', 'requireConsent', 'setConsentGiven', 'disablePerformanceTracking', 'setPagePerformanceTiming', 'setExcludedQueryParams', 'setExcludedReferrers'];
+
+ function createFirstTracker(matomoUrl, siteId)
+ {
+ var tracker = new Tracker(matomoUrl, siteId);
+ asyncTrackers.push(tracker);
+
+ _paq = applyMethodsInOrder(_paq, applyFirst);
+
+ // apply the queue of actions
+ for (iterator = 0; iterator < _paq.length; iterator++) {
+ if (_paq[iterator]) {
+ apply(_paq[iterator]);
+ }
+ }
+
+ // replace initialization array with proxy object
+ _paq = new TrackerProxy();
+
+ Matomo.trigger('TrackerAdded', [tracker]);
+
+ return tracker;
+ }
+
+ /************************************************************
+ * Proxy object
+ * - this allows the caller to continue push()'ing to _paq
+ * after the Tracker has been initialized and loaded
+ ************************************************************/
+
+ // initialize the Matomo singleton
+ addEventListener(windowAlias, 'beforeunload', beforeUnloadHandler, false);
+ addEventListener(windowAlias, 'visibilitychange', function () {
+ // if unloaded, return
+ if (isPageUnloading) {
+ return;
+ }
+ // if not visible
+ if (documentAlias.visibilityState === 'hidden') {
+ executePluginMethod('unload');
+ }
+ }, false);
+ addEventListener(windowAlias, 'online', function () {
+ if (isDefined(navigatorAlias.serviceWorker)) {
+ navigatorAlias.serviceWorker.ready.then(function(swRegistration) {
+ if (swRegistration && swRegistration.sync) {
+ return swRegistration.sync.register('matomoSync');
+ }
+ }, function() {
+ // handle (but ignore) failed promise, see https://github.com/matomo-org/matomo/issues/17454
+ });
+ }
+ }, false);
+
+ addEventListener(windowAlias,'message', function(e) {
+ if (!e || !e.origin) {
+ return;
+ }
+
+ var tracker, i, matomoHost;
+ var originHost = getHostName(e.origin);
+
+ var trackers = Matomo.getAsyncTrackers();
+ for (i = 0; i < trackers.length; i++) {
+ matomoHost = getHostName(trackers[i].getMatomoUrl());
+
+ // find the matching tracker
+ if (matomoHost === originHost) {
+ tracker = trackers[i];
+ break;
+ }
+ }
+
+ if (!tracker) {
+ // no matching tracker
+ // Don't accept the message unless it came from the expected origin
+ return;
+ }
+
+ var data = null;
+ try {
+ data = JSON.parse(e.data);
+ } catch (ex) {
+ return;
+ }
+
+ if (!data) {
+ return;
+ }
+
+ function postMessageToCorrectFrame(postMessage){
+ // Find the iframe with the right URL to send it back to
+ var iframes = documentAlias.getElementsByTagName('iframe');
+ for (i = 0; i < iframes.length; i++) {
+ var iframe = iframes[i];
+ var iframeHost = getHostName(iframe.src);
+
+ if (iframe.contentWindow && isDefined(iframe.contentWindow.postMessage) && iframeHost === originHost) {
+ var jsonMessage = JSON.stringify(postMessage);
+ iframe.contentWindow.postMessage(jsonMessage, '*');
+ }
+ }
+ }
+
+ // This listener can process two kinds of messages
+ // 1) maq_initial_value => sent by optout iframe when it finishes loading. Passes the value of the third
+ // party opt-out cookie (if set) - we need to use this and any first-party cookies that are present to
+ // initialise the configHasConsent value and send back the result so that the display can be updated.
+ // 2) maq_opted_in => sent by optout iframe when the user changes their optout setting. We need to update
+ // our first-party cookie.
+ if (isDefined(data.maq_initial_value)) {
+ // Make a message to tell the optout iframe about the current state
+
+ postMessageToCorrectFrame({
+ maq_opted_in: data.maq_initial_value && tracker.hasConsent(),
+ maq_url: tracker.getMatomoUrl(),
+ maq_optout_by_default: tracker.isConsentRequired()
+ });
+ } else if (isDefined(data.maq_opted_in)) {
+ // perform the opt in or opt out...
+ trackers = Matomo.getAsyncTrackers();
+ for (i = 0; i < trackers.length; i++) {
+ tracker = trackers[i];
+ if (data.maq_opted_in) {
+ tracker.rememberConsentGiven();
+ } else {
+ tracker.forgetConsentGiven();
+ }
+ }
+
+ // Make a message to tell the optout iframe about the current state
+ postMessageToCorrectFrame({
+ maq_confirm_opted_in: tracker.hasConsent(),
+ maq_url: tracker.getMatomoUrl(),
+ maq_optout_by_default: tracker.isConsentRequired()
+ });
+ }
+ }, false);
+
+ Date.prototype.getTimeAlias = Date.prototype.getTime;
+
+ /************************************************************
+ * Public data and methods
+ ************************************************************/
+
+ Matomo = {
+ initialized: false,
+
+ JSON: windowAlias.JSON,
+
+ /**
+ * DOM Document related methods
+ */
+ DOM: {
+ /**
+ * Adds an event listener to the given element.
+ * @param element
+ * @param eventType
+ * @param eventHandler
+ * @param useCapture Optional
+ */
+ addEventListener: function (element, eventType, eventHandler, useCapture) {
+ var captureType = typeof useCapture;
+ if (captureType === 'undefined') {
+ useCapture = false;
+ }
+
+ addEventListener(element, eventType, eventHandler, useCapture);
+ },
+ /**
+ * Specify a function to execute when the DOM is fully loaded.
+ *
+ * If the DOM is already loaded, the function will be executed immediately.
+ *
+ * @param function callback
+ */
+ onLoad: trackCallbackOnLoad,
+
+ /**
+ * Specify a function to execute when the DOM is ready.
+ *
+ * If the DOM is already ready, the function will be executed immediately.
+ *
+ * @param function callback
+ */
+ onReady: trackCallbackOnReady,
+
+ /**
+ * Detect whether a node is visible right now.
+ */
+ isNodeVisible: isVisible,
+
+ /**
+ * Detect whether a node has been visible at some point
+ */
+ isOrWasNodeVisible: content.isNodeVisible
+ },
+
+ /**
+ * Listen to an event and invoke the handler when a the event is triggered.
+ *
+ * @param string event
+ * @param function handler
+ */
+ on: function (event, handler) {
+ if (!eventHandlers[event]) {
+ eventHandlers[event] = [];
+ }
+
+ eventHandlers[event].push(handler);
+ },
+
+ /**
+ * Remove a handler to no longer listen to the event. Must pass the same handler that was used when
+ * attaching the event via ".on".
+ * @param string event
+ * @param function handler
+ */
+ off: function (event, handler) {
+ if (!eventHandlers[event]) {
+ return;
+ }
+
+ var i = 0;
+ for (i; i < eventHandlers[event].length; i++) {
+ if (eventHandlers[event][i] === handler) {
+ eventHandlers[event].splice(i, 1);
+ }
+ }
+ },
+
+ /**
+ * Triggers the given event and passes the parameters to all handlers.
+ *
+ * @param string event
+ * @param Array extraParameters
+ * @param Object context If given the handler will be executed in this context
+ */
+ trigger: function (event, extraParameters, context) {
+ if (!eventHandlers[event]) {
+ return;
+ }
+
+ var i = 0;
+ for (i; i < eventHandlers[event].length; i++) {
+ eventHandlers[event][i].apply(context || windowAlias, extraParameters);
+ }
+ },
+
+ /**
+ * Add plugin
+ *
+ * @param string pluginName
+ * @param Object pluginObj
+ */
+ addPlugin: function (pluginName, pluginObj) {
+ plugins[pluginName] = pluginObj;
+ },
+
+ /**
+ * Get Tracker (factory method)
+ *
+ * @param string matomoUrl
+ * @param int|string siteId
+ * @return Tracker
+ */
+ getTracker: function (matomoUrl, siteId) {
+ if (!isDefined(siteId)) {
+ siteId = this.getAsyncTracker().getSiteId();
+ }
+ if (!isDefined(matomoUrl)) {
+ matomoUrl = this.getAsyncTracker().getTrackerUrl();
+ }
+
+ return new Tracker(matomoUrl, siteId);
+ },
+
+ /**
+ * Get all created async trackers
+ *
+ * @return Tracker[]
+ */
+ getAsyncTrackers: function () {
+ return asyncTrackers;
+ },
+
+ /**
+ * Adds a new tracker. All sent requests will be also sent to the given siteId and matomoUrl.
+ * If matomoUrl is not set, current url will be used.
+ *
+ * @param null|string matomoUrl If null, will reuse the same tracker URL of the current tracker instance
+ * @param int|string siteId
+ * @return Tracker
+ */
+ addTracker: function (matomoUrl, siteId) {
+ var tracker;
+ if (!asyncTrackers.length) {
+ tracker = createFirstTracker(matomoUrl, siteId);
+ } else {
+ tracker = asyncTrackers[0].addTracker(matomoUrl, siteId);
+ }
+ return tracker;
+ },
+
+ /**
+ * Get internal asynchronous tracker object.
+ *
+ * If no parameters are given, it returns the internal asynchronous tracker object. If a matomoUrl and idSite
+ * is given, it will try to find an optional
+ *
+ * @param string matomoUrl
+ * @param int|string siteId
+ * @return Tracker
+ */
+ getAsyncTracker: function (matomoUrl, siteId) {
+
+ var firstTracker;
+ if (asyncTrackers && asyncTrackers.length && asyncTrackers[0]) {
+ firstTracker = asyncTrackers[0];
+ } else {
+ return createFirstTracker(matomoUrl, siteId);
+ }
+
+ if (!siteId && !matomoUrl) {
+ // for BC and by default we just return the initially created tracker
+ return firstTracker;
+ }
+
+ // we look for another tracker created via `addTracker` method
+ if ((!isDefined(siteId) || null === siteId) && firstTracker) {
+ siteId = firstTracker.getSiteId();
+ }
+
+ if ((!isDefined(matomoUrl) || null === matomoUrl) && firstTracker) {
+ matomoUrl = firstTracker.getTrackerUrl();
+ }
+
+ var tracker, i = 0;
+ for (i; i < asyncTrackers.length; i++) {
+ tracker = asyncTrackers[i];
+ if (tracker
+ && String(tracker.getSiteId()) === String(siteId)
+ && tracker.getTrackerUrl() === matomoUrl) {
+
+ return tracker;
+ }
+ }
+ },
+
+ /**
+ * When calling plugin methods via "_paq.push(['...'])" and the plugin is loaded separately because
+ * matomo.js is not writable then there is a chance that first matomo.js is loaded and later the plugin.
+ * In this case we would have already executed all "_paq.push" methods and they would not have succeeded
+ * because the plugin will be loaded only later. In this case, once a plugin is loaded, it should call
+ * "Matomo.retryMissedPluginCalls()" so they will be executed after all.
+ */
+ retryMissedPluginCalls: function () {
+ var missedCalls = missedPluginTrackerCalls;
+ missedPluginTrackerCalls = [];
+ var i = 0;
+ for (i; i < missedCalls.length; i++) {
+ apply(missedCalls[i]);
+ }
+ }
+
+ };
+
+ // Expose Matomo as an AMD module
+ if (typeof define === 'function' && define.amd) {
+ define('piwik', [], function () { return Matomo; });
+ define('matomo', [], function () { return Matomo; });
+ }
+
+ return Matomo;
+ }());
+}
+
+/*!! pluginTrackerHook */
+
+(function () {
+ 'use strict';
+
+ function hasPaqConfiguration()
+ {
+ if ('object' !== typeof _paq) {
+ return false;
+ }
+ // needed to write it this way for jslint
+ var lengthType = typeof _paq.length;
+ if ('undefined' === lengthType) {
+ return false;
+ }
+
+ return !!_paq.length;
+ }
+
+ if (window
+ && 'object' === typeof window.matomoPluginAsyncInit
+ && window.matomoPluginAsyncInit.length) {
+ var i = 0;
+ for (i; i < window.matomoPluginAsyncInit.length; i++) {
+ if (typeof window.matomoPluginAsyncInit[i] === 'function') {
+ window.matomoPluginAsyncInit[i]();
+ }
+ }
+ }
+
+ if (window && window.piwikAsyncInit) {
+ window.piwikAsyncInit();
+ }
+
+ if (window && window.matomoAsyncInit) {
+ window.matomoAsyncInit();
+ }
+
+ if (!window.Matomo.getAsyncTrackers().length) {
+ // we only create an initial tracker when no other async tracker has been created yet in matomoAsyncInit()
+ if (hasPaqConfiguration()) {
+ // we only create an initial tracker if there is a configuration for it via _paq. Otherwise
+ // Matomo.getAsyncTrackers() would return unconfigured trackers
+ window.Matomo.addTracker();
+ } else {
+ _paq = {push: function (args) {
+ // needed to write it this way for jslint
+ var consoleType = typeof console;
+ if (consoleType !== 'undefined' && console && console.error) {
+ console.error('_paq.push() was used but Matomo tracker was not initialized before the matomo.js file was loaded. Make sure to configure the tracker via _paq.push before loading matomo.js. Alternatively, you can create a tracker via Matomo.addTracker() manually and then use _paq.push but it may not fully work as tracker methods may not be executed in the correct order.', args);
+ }
+ }};
+ }
+ }
+
+ window.Matomo.trigger('MatomoInitialized', []);
+ window.Matomo.initialized = true;
+}());
+
+
+/*jslint sloppy: true */
+(function () {
+ var jsTrackerType = (typeof window.AnalyticsTracker);
+ if (jsTrackerType === 'undefined') {
+ window.AnalyticsTracker = window.Matomo;
+ }
+}());
+/*jslint sloppy: false */
+
+/************************************************************
+ * Deprecated functionality below
+ * Legacy piwik.js compatibility ftw
+ ************************************************************/
+
+/*
+ * Matomo globals
+ *
+ * var piwik_install_tracker, piwik_tracker_pause, piwik_download_extensions, piwik_hosts_alias, piwik_ignore_classes;
+ */
+/*global piwik_log:true */
+/*global piwik_track:true */
+
+/**
+ * Track page visit
+ *
+ * @param string documentTitle
+ * @param int|string siteId
+ * @param string matomoUrl
+ * @param mixed customData
+ */
+if (typeof window.piwik_log !== 'function') {
+ window.piwik_log = function (documentTitle, siteId, matomoUrl, customData) {
+ 'use strict';
+
+ function getOption(optionName) {
+ try {
+ if (window['piwik_' + optionName]) {
+ return window['piwik_' + optionName];
+ }
+ } catch (ignore) { }
+
+ return; // undefined
+ }
+
+ // instantiate the tracker
+ var option,
+ matomoTracker = window.Matomo.getTracker(matomoUrl, siteId);
+
+ // initialize tracker
+ matomoTracker.setDocumentTitle(documentTitle);
+ matomoTracker.setCustomData(customData);
+
+ // handle Matomo globals
+ option = getOption('tracker_pause');
+
+ if (option) {
+ matomoTracker.setLinkTrackingTimer(option);
+ }
+
+ option = getOption('download_extensions');
+
+ if (option) {
+ matomoTracker.setDownloadExtensions(option);
+ }
+
+ option = getOption('hosts_alias');
+
+ if (option) {
+ matomoTracker.setDomains(option);
+ }
+
+ option = getOption('ignore_classes');
+
+ if (option) {
+ matomoTracker.setIgnoreClasses(option);
+ }
+
+ // track this page view
+ matomoTracker.trackPageView();
+
+ // default is to install the link tracker
+ if (getOption('install_tracker')) {
+
+ /**
+ * Track click manually (function is defined below)
+ *
+ * @param string sourceUrl
+ * @param int|string siteId
+ * @param string matomoUrl
+ * @param string linkType
+ */
+ piwik_track = function (sourceUrl, siteId, matomoUrl, linkType) {
+ matomoTracker.setSiteId(siteId);
+ matomoTracker.setTrackerUrl(matomoUrl);
+ matomoTracker.trackLink(sourceUrl, linkType);
+ };
+
+ // set-up link tracking
+ matomoTracker.enableLinkTracking();
+ }
+ };
+}
+
+/*! @license-end */