angulartics2 10.1.0 → 12.1.0

package/esm2020/providers/appinsights/appinsights.mjs

@@ -0,0 +1,118 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd, NavigationError, NavigationStart, } from '@angular/router';
+import { filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+import * as i2 from "@angular/platform-browser";
+import * as i3 from "@angular/router";
+export class AppInsightsDefaults {
+    constructor() {
+        this.userId = null;
+    }
+}
+export class Angulartics2AppInsights {
+    constructor(angulartics2, title, router) {
+        this.angulartics2 = angulartics2;
+        this.title = title;
+        this.router = router;
+        this.loadStartTime = null;
+        this.loadTime = null;
+        this.metrics = null;
+        this.dimensions = null;
+        this.measurements = null;
+        if (typeof appInsights === 'undefined') {
+            console.warn('appInsights not found');
+        }
+        const defaults = new AppInsightsDefaults();
+        // Set the default settings for this module
+        this.angulartics2.settings.appInsights = {
+            ...defaults,
+            ...this.angulartics2.settings.appInsights,
+        };
+        this.angulartics2.setUsername.subscribe((x) => this.setUsername(x));
+        this.angulartics2.setUserProperties.subscribe((x) => this.setUserProperties(x));
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe((x) => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe((x) => this.eventTrack(x.action, x.properties));
+        this.angulartics2.exceptionTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe((x) => this.exceptionTrack(x));
+        this.router.events
+            .pipe(this.angulartics2.filterDeveloperMode(), filter((event) => event instanceof NavigationStart))
+            .subscribe((event) => this.startTimer());
+        this.router.events
+            .pipe(filter((event) => event instanceof NavigationError || event instanceof NavigationEnd))
+            .subscribe((error) => this.stopTimer());
+    }
+    startTimer() {
+        this.loadStartTime = Date.now();
+        this.loadTime = null;
+    }
+    stopTimer() {
+        this.loadTime = Date.now() - this.loadStartTime;
+        this.loadStartTime = null;
+    }
+    /**
+     * Page Track in Baidu Analytics
+     *
+     * @param path - Location 'path'
+     *
+     * @link https://github.com/Microsoft/ApplicationInsights-JS/blob/master/API-reference.md#trackpageview
+     */
+    pageTrack(path) {
+        appInsights.trackPageView(this.title.getTitle(), path, this.dimensions, this.metrics, this.loadTime);
+    }
+    /**
+     * Log a user action or other occurrence.
+     *
+     * @param name Name to identify this event in the portal.
+     * @param properties Additional data used to filter events and metrics in the portal. Defaults to empty.
+     *
+     * @link https://github.com/Microsoft/ApplicationInsights-JS/blob/master/API-reference.md#trackevent
+     */
+    eventTrack(name, properties) {
+        appInsights.trackEvent(name, properties, this.measurements);
+    }
+    /**
+     * Exception Track Event in GA
+     *
+     * @param properties - Comprised of the mandatory fields 'appId' (string), 'appName' (string) and 'appVersion' (string) and
+     * optional fields 'fatal' (boolean) and 'description' (string), error
+     *
+     * @link https://github.com/Microsoft/ApplicationInsights-JS/blob/master/API-reference.md#trackexception
+     */
+    exceptionTrack(properties) {
+        const description = properties.event || properties.description || properties;
+        appInsights.trackException(description);
+    }
+    /**
+     * @link https://github.com/Microsoft/ApplicationInsights-JS/blob/master/API-reference.md#setauthenticatedusercontext
+     */
+    setUsername(userId) {
+        this.angulartics2.settings.appInsights.userId = userId;
+        appInsights.setAuthenticatedUserContext(userId);
+    }
+    setUserProperties(properties) {
+        if (properties.userId) {
+            this.angulartics2.settings.appInsights.userId = properties.userId;
+        }
+        if (properties.accountId) {
+            appInsights.setAuthenticatedUserContext(this.angulartics2.settings.appInsights.userId, properties.accountId);
+        }
+        else {
+            appInsights.setAuthenticatedUserContext(this.angulartics2.settings.appInsights.userId);
+        }
+    }
+}
+Angulartics2AppInsights.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2AppInsights, deps: [{ token: i1.Angulartics2 }, { token: i2.Title }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2AppInsights.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2AppInsights, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2AppInsights, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }, { type: i2.Title }, { type: i3.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appinsights.js","sourceRoot":"","sources":["../../../../src/lib/providers/appinsights/appinsights.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Title } from '@angular/platform-browser';\nimport {\n  NavigationEnd,\n  NavigationError,\n  NavigationStart,\n  Router,\n} from '@angular/router';\nimport { filter } from 'rxjs/operators';\n\nimport { AppInsightsSettings } from '../../angulartics2-config';\nimport { Angulartics2 } from '../../angulartics2-core';\n\ndeclare const appInsights: Microsoft.ApplicationInsights.IAppInsights;\n\nexport class AppInsightsDefaults implements AppInsightsSettings {\n  userId = null;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class Angulartics2AppInsights {\n  loadStartTime: number = null;\n  loadTime: number = null;\n\n  metrics: { [name: string]: number } = null;\n  dimensions: { [name: string]: string } = null;\n  measurements: { [name: string]: number } = null;\n\n  constructor(\n    private angulartics2: Angulartics2,\n    private title: Title,\n    private router: Router\n  ) {\n    if (typeof appInsights === 'undefined') {\n      console.warn('appInsights not found');\n    }\n\n    const defaults = new AppInsightsDefaults();\n    // Set the default settings for this module\n    this.angulartics2.settings.appInsights = {\n      ...defaults,\n      ...this.angulartics2.settings.appInsights,\n    };\n    this.angulartics2.setUsername.subscribe((x: string) => this.setUsername(x));\n    this.angulartics2.setUserProperties.subscribe((x) =>\n      this.setUserProperties(x)\n    );\n  }\n\n  startTracking(): void {\n    this.angulartics2.pageTrack\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe((x) => this.pageTrack(x.path));\n    this.angulartics2.eventTrack\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe((x) => this.eventTrack(x.action, x.properties));\n    this.angulartics2.exceptionTrack\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe((x) => this.exceptionTrack(x));\n    this.router.events\n      .pipe(\n        this.angulartics2.filterDeveloperMode(),\n        filter((event) => event instanceof NavigationStart)\n      )\n      .subscribe((event) => this.startTimer());\n\n    this.router.events\n      .pipe(\n        filter(\n          (event) =>\n            event instanceof NavigationError || event instanceof NavigationEnd\n        )\n      )\n      .subscribe((error) => this.stopTimer());\n  }\n\n  startTimer() {\n    this.loadStartTime = Date.now();\n    this.loadTime = null;\n  }\n\n  stopTimer() {\n    this.loadTime = Date.now() - this.loadStartTime;\n    this.loadStartTime = null;\n  }\n\n  /**\n   * Page Track in Baidu Analytics\n   *\n   * @param path - Location 'path'\n   *\n   * @link https://github.com/Microsoft/ApplicationInsights-JS/blob/master/API-reference.md#trackpageview\n   */\n  pageTrack(path: string) {\n    appInsights.trackPageView(\n      this.title.getTitle(),\n      path,\n      this.dimensions,\n      this.metrics,\n      this.loadTime\n    );\n  }\n\n  /**\n   * Log a user action or other occurrence.\n   *\n   * @param name Name to identify this event in the portal.\n   * @param properties Additional data used to filter events and metrics in the portal. Defaults to empty.\n   *\n   * @link https://github.com/Microsoft/ApplicationInsights-JS/blob/master/API-reference.md#trackevent\n   */\n  eventTrack(name: string, properties: { [name: string]: string }) {\n    appInsights.trackEvent(name, properties, this.measurements);\n  }\n\n  /**\n   * Exception Track Event in GA\n   *\n   * @param properties - Comprised of the mandatory fields 'appId' (string), 'appName' (string) and 'appVersion' (string) and\n   * optional fields 'fatal' (boolean) and 'description' (string), error\n   *\n   * @link https://github.com/Microsoft/ApplicationInsights-JS/blob/master/API-reference.md#trackexception\n   */\n  exceptionTrack(properties: any) {\n    const description =\n      properties.event || properties.description || properties;\n\n    appInsights.trackException(description);\n  }\n\n  /**\n   * @link https://github.com/Microsoft/ApplicationInsights-JS/blob/master/API-reference.md#setauthenticatedusercontext\n   */\n  setUsername(userId: string) {\n    this.angulartics2.settings.appInsights.userId = userId;\n    appInsights.setAuthenticatedUserContext(userId);\n  }\n\n  setUserProperties(\n    properties: Partial<{ userId: string; accountId: string }>\n  ) {\n    if (properties.userId) {\n      this.angulartics2.settings.appInsights.userId = properties.userId;\n    }\n    if (properties.accountId) {\n      appInsights.setAuthenticatedUserContext(\n        this.angulartics2.settings.appInsights.userId,\n        properties.accountId\n      );\n    } else {\n      appInsights.setAuthenticatedUserContext(\n        this.angulartics2.settings.appInsights.userId\n      );\n    }\n  }\n}\n"]}

package/esm2020/providers/baidu/baidu.mjs

@@ -0,0 +1,81 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class Angulartics2BaiduAnalytics {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        if (typeof _hmt === 'undefined') {
+            _hmt = [];
+        }
+        else {
+            _hmt.push(['_setAutoPageview', false]);
+        }
+        this.angulartics2.setUsername
+            .subscribe((x) => this.setUsername(x));
+        this.angulartics2.setUserProperties
+            .subscribe((x) => this.setUserProperties(x));
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe((x) => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe((x) => this.eventTrack(x.action, x.properties));
+    }
+    /**
+     * Page Track in Baidu Analytics
+     *
+     * @param path Required url 'path'
+     *
+     * @link http://tongji.baidu.com/open/api/more?p=ref_trackPageview
+     */
+    pageTrack(path) {
+        if (typeof _hmt !== 'undefined' && _hmt) {
+            _hmt.push(['_trackPageview', path]);
+        }
+    }
+    /**
+     * Track Event in Baidu Analytics
+     *
+     * @param action Name associated with the event
+     * @param properties Comprised of:
+     *  - 'category' (string)
+     *  - 'opt_label' (string)
+     *  - 'opt_value' (string)
+     *
+     * @link http://tongji.baidu.com/open/api/more?p=ref_trackEvent
+     */
+    eventTrack(action, properties) {
+        // baidu analytics requires category
+        if (!properties || !properties.category) {
+            properties = properties || {};
+            properties.category = 'Event';
+            properties.opt_label = 'default';
+            properties.opt_value = 'default';
+        }
+        if (typeof _hmt !== 'undefined' && _hmt) {
+            _hmt.push([
+                '_trackEvent',
+                properties.category,
+                action,
+                properties.opt_label,
+                properties.opt_value,
+            ]);
+        }
+    }
+    setUsername(userId) {
+        // set default custom variables name to 'identity' and 'value'
+        _hmt.push(['_setCustomVar', 1, 'identity', userId]);
+    }
+    setUserProperties(properties) {
+        _hmt.push(['_setCustomVar', 2, 'user', JSON.stringify(properties)]);
+    }
+}
+Angulartics2BaiduAnalytics.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2BaiduAnalytics, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2BaiduAnalytics.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2BaiduAnalytics, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2BaiduAnalytics, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{clicky/esm2015/clicky.interfaces.js → esm2020/providers/clicky/clicky.interfaces.mjs}

@@ -1 +1,2 @@
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpY2t5LmludGVyZmFjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3Byb3ZpZGVycy9jbGlja3kvY2xpY2t5LmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHJvcGVydGllcyBwYXNzZWQgdGhyb3VnaCBhbmd1bGFydGljczItY2xpY2t5IGFuZCBmZWQgaW50byBjbGlja3kgaXRzZWxmXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ2xpY2t5UHJvcGVydGllcyB7XG4gICAgLyoqIFRpdGxlIG9mIHRoZSBwYWdlIGZvciBwYWdlIHRyYWNraW5nLCBvciBuYW1lIG9mIHRoZSBldmVudCBmb3IgZXZlbnQgdHJhY2tpbmcgKi9cbiAgICB0aXRsZTogc3RyaW5nO1xuICAgIC8qKiBUaGUgbGltaXRlZCBzZXQgb2YgdGhpbmdzIHRoYXQgY2FuIGJlIHRyYWNrZWQgd2l0aCBjbGlja3kgKi9cbiAgICB0eXBlOiBzdHJpbmc7XG4gICAgLyoqIFRoZSBpZCAvIG5hbWUgb2YgYSBjbGlja3kgZ29hbCBhZ2FpbnN0IHdoaWNoIHJldmVudWUgY2FuIGJlIHRyYWNrZWQgKi9cbiAgICBnb2FsOiBzdHJpbmc7XG4gICAgLyoqIFRoZSByZXZlbnVlIHRoYXQgaXMgdHJhY2tlZCBhZ2FpbnN0IGEgZ2l2ZW4gY2xpY2t5IGdvYWwgKi9cbiAgICByZXZlbnVlOiBudW1iZXI7XG4gICAgLyoqIFdoZXRoZXIgb3Igbm90IHRvIGJ5cGFzcyB0aGUgY2xpY2t5IHF1ZXVlIC0tIHRyYWNraW5nIG1heSBub3Qgb2NjdXIgb24gcGFnZWxvYWRzIGlmICd0cnVlJyAgKi9cbiAgICBub1F1ZXVlOiBib29sZWFuO1xufVxuIl19

package/esm2020/providers/clicky/clicky.mjs

@@ -0,0 +1,64 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+import * as i2 from "@angular/platform-browser";
+export class Angulartics2Clicky {
+    constructor(angulartics2, titleService) {
+        this.angulartics2 = angulartics2;
+        this.titleService = titleService;
+        if (typeof clicky === 'undefined') {
+            console.warn('Angulartics 2 Clicky Plugin: clicky global not found');
+        }
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.eventOrGoalTrack(x.action, x.properties));
+    }
+    /**
+     * Track Page in Clicky
+     *
+     * @param path location
+     *
+     * @link https://clicky.com/help/custom/manual#log
+     */
+    pageTrack(path) {
+        const title = this.titleService.getTitle();
+        clicky.log(path, title, 'pageview');
+    }
+    /**
+     * Track Event Or Goal in Clicky
+     *
+     * @param action Action name
+     * @param properties Definition of 'properties.goal' determines goal vs event tracking
+     *
+     * @link https://clicky.com/help/custom/manual#log
+     * @link https://clicky.com/help/custom/manual#goal
+     */
+    eventOrGoalTrack(action, properties) {
+        if (typeof properties.goal === 'undefined') {
+            const title = properties.title || null;
+            const type = properties.type != null ? this.validateType(properties.type) : null;
+            clicky.log(action, title, type);
+        }
+        else {
+            const goalId = properties.goal;
+            const revenue = properties.revenue;
+            clicky.goal(goalId, revenue, !!properties.noQueue);
+        }
+    }
+    validateType(type) {
+        const EventType = ['pageview', 'click', 'download', 'outbound'];
+        return EventType.indexOf(type) > -1 ? type : 'pageview';
+    }
+}
+Angulartics2Clicky.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Clicky, deps: [{ token: i1.Angulartics2 }, { token: i2.Title }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2Clicky.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Clicky, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Clicky, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }, { type: i2.Title }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/facebook/facebook.mjs

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+const facebookEventList = [
+    'ViewContent',
+    'Search',
+    'AddToCart',
+    'AddToWishlist',
+    'InitiateCheckout',
+    'AddPaymentInfo',
+    'Purchase',
+    'Lead',
+    'CompleteRegistration',
+];
+export class Angulartics2Facebook {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+    }
+    startTracking() {
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.eventTrack(x.action, x.properties));
+    }
+    /**
+     * Send interactions to the Pixel, i.e. for event tracking in Pixel
+     *
+     * @param action action associated with the event
+     */
+    eventTrack(action, properties = {}) {
+        if (typeof fbq === 'undefined') {
+            return;
+        }
+        if (facebookEventList.indexOf(action) === -1) {
+            return fbq('trackCustom', action, properties);
+        }
+        return fbq('track', action, properties);
+    }
+}
+Angulartics2Facebook.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Facebook, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2Facebook.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Facebook, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2Facebook, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/providers/ga/ga.mjs

@@ -0,0 +1,219 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../angulartics2-core";
+export class GoogleAnalyticsDefaults {
+    constructor() {
+        this.additionalAccountNames = [];
+        this.userId = null;
+        this.transport = '';
+        this.anonymizeIp = false;
+    }
+}
+export class Angulartics2GoogleAnalytics {
+    constructor(angulartics2) {
+        this.angulartics2 = angulartics2;
+        this.dimensionsAndMetrics = [];
+        const defaults = new GoogleAnalyticsDefaults();
+        // Set the default settings for this module
+        this.angulartics2.settings.ga = {
+            ...defaults,
+            ...this.angulartics2.settings.ga,
+        };
+        this.settings = this.angulartics2.settings.ga;
+        this.angulartics2.setUsername.subscribe((x) => this.setUsername(x));
+        this.angulartics2.setUserProperties.subscribe(x => this.setUserProperties(x));
+    }
+    startTracking() {
+        this.angulartics2.pageTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.pageTrack(x.path));
+        this.angulartics2.eventTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.eventTrack(x.action, x.properties));
+        this.angulartics2.exceptionTrack
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.exceptionTrack(x));
+        this.angulartics2.userTimings
+            .pipe(this.angulartics2.filterDeveloperMode())
+            .subscribe(x => this.userTimings(x));
+    }
+    pageTrack(path) {
+        if (typeof _gaq !== 'undefined' && _gaq) {
+            _gaq.push(['_trackPageview', path]);
+            for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                _gaq.push([accountName + '._trackPageview', path]);
+            }
+        }
+        if (typeof ga !== 'undefined' && ga) {
+            if (this.angulartics2.settings.ga.userId) {
+                ga('set', '&uid', this.angulartics2.settings.ga.userId);
+                for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                    ga(accountName + '.set', '&uid', this.angulartics2.settings.ga.userId);
+                }
+            }
+            if (this.angulartics2.settings.ga.anonymizeIp) {
+                ga('set', 'anonymizeIp', true);
+                for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                    ga(accountName + '.set', 'anonymizeIp', true);
+                }
+            }
+            ga('send', 'pageview', path);
+            for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                ga(accountName + '.send', 'pageview', path);
+            }
+        }
+    }
+    /**
+     * Track Event in GA
+     *
+     * @param action Associated with the event
+     * @param properties Comprised of:
+     *  - category (string) and optional
+     *  - label (string)
+     *  - value (integer)
+     *  - noninteraction (boolean)
+     *
+     * @link https://developers.google.com/analytics/devguides/collection/gajs/eventTrackerGuide#SettingUpEventTracking
+     * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/events
+     */
+    eventTrack(action, properties) {
+        // Google Analytics requires an Event Category
+        if (!properties || !properties.category) {
+            properties = properties || {};
+            properties.category = 'Event';
+        }
+        // GA requires that eventValue be an integer, see:
+        // https://developers.google.com/analytics/devguides/collection/analyticsjs/field-reference#eventValue
+        // https://github.com/luisfarzati/angulartics/issues/81
+        if (properties.value) {
+            const parsed = parseInt(properties.value, 10);
+            properties.value = isNaN(parsed) ? 0 : parsed;
+        }
+        if (typeof ga !== 'undefined') {
+            const eventOptions = {
+                eventCategory: properties.category,
+                eventAction: action,
+                eventLabel: properties.label,
+                eventValue: properties.value,
+                nonInteraction: properties.noninteraction,
+                page: properties.page || location.hash.substring(1) || location.pathname,
+                userId: this.angulartics2.settings.ga.userId,
+                hitCallback: properties.hitCallback,
+                ...(this.angulartics2.settings.ga.transport && {
+                    transport: this.angulartics2.settings.ga.transport,
+                }),
+            };
+            // add custom dimensions and metrics
+            this.setDimensionsAndMetrics(properties);
+            ga('send', 'event', eventOptions);
+            for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                ga(accountName + '.send', 'event', eventOptions);
+            }
+        }
+        else if (typeof _gaq !== 'undefined') {
+            _gaq.push([
+                '_trackEvent',
+                properties.category,
+                action,
+                properties.label,
+                properties.value,
+                properties.noninteraction,
+            ]);
+        }
+    }
+    /**
+     * Exception Track Event in GA
+     *
+     * @param properties Comprised of the optional fields:
+     *  - fatal (string)
+     *  - description (string)
+     *
+     * @https://developers.google.com/analytics/devguides/collection/analyticsjs/exceptions
+     *
+     * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/events
+     */
+    exceptionTrack(properties) {
+        if (properties.fatal === undefined) {
+            console.log('No "fatal" provided, sending with fatal=true');
+            properties.fatal = true;
+        }
+        properties.exDescription = properties.description;
+        const eventOptions = {
+            exFatal: properties.fatal,
+            exDescription: properties.description,
+        };
+        ga('send', 'exception', eventOptions);
+        for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+            ga(accountName + '.send', 'exception', eventOptions);
+        }
+    }
+    /**
+     * User Timings Event in GA
+     *
+     * @param properties Comprised of the mandatory fields:
+     *  - timingCategory (string)
+     *  - timingVar (string)
+     *  - timingValue (number)
+     * Properties can also have the optional fields:
+     *  - timingLabel (string)
+     *
+     * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/user-timings
+     */
+    userTimings(properties) {
+        if (!properties ||
+            !properties.timingCategory ||
+            !properties.timingVar ||
+            !properties.timingValue) {
+            console.error('Properties timingCategory, timingVar, and timingValue are required to be set.');
+            return;
+        }
+        if (typeof ga !== 'undefined') {
+            ga('send', 'timing', properties);
+            for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {
+                ga(accountName + '.send', 'timing', properties);
+            }
+        }
+    }
+    setUsername(userId) {
+        this.angulartics2.settings.ga.userId = userId;
+        if (typeof ga === 'undefined') {
+            return;
+        }
+        ga('set', 'userId', userId);
+    }
+    setUserProperties(properties) {
+        this.setDimensionsAndMetrics(properties);
+    }
+    setDimensionsAndMetrics(properties) {
+        if (typeof ga === 'undefined') {
+            return;
+        }
+        // clean previously used dimensions and metrics that will not be overriden
+        this.dimensionsAndMetrics.forEach(elem => {
+            if (!properties.hasOwnProperty(elem)) {
+                ga('set', elem, undefined);
+                this.angulartics2.settings.ga.additionalAccountNames.forEach((accountName) => {
+                    ga(`${accountName}.set`, elem, undefined);
+                });
+            }
+        });
+        this.dimensionsAndMetrics = [];
+        // add custom dimensions and metrics
+        Object.keys(properties).forEach(key => {
+            if (key.lastIndexOf('dimension', 0) === 0 || key.lastIndexOf('metric', 0) === 0) {
+                ga('set', key, properties[key]);
+                this.angulartics2.settings.ga.additionalAccountNames.forEach((accountName) => {
+                    ga(`${accountName}.set`, key, properties[key]);
+                });
+                this.dimensionsAndMetrics.push(key);
+            }
+        });
+    }
+}
+Angulartics2GoogleAnalytics.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleAnalytics, deps: [{ token: i1.Angulartics2 }], target: i0.ɵɵFactoryTarget.Injectable });
+Angulartics2GoogleAnalytics.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleAnalytics, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: Angulartics2GoogleAnalytics, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.Angulartics2 }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ga.js","sourceRoot":"","sources":["../../../../src/lib/providers/ga/ga.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { Angulartics2 } from '../../angulartics2-core';\nimport { GoogleAnalyticsSettings } from '../../angulartics2-config';\nimport { UserTimings } from '../../angulartics2-interfaces';\n\ndeclare var _gaq: GoogleAnalyticsCode;\ndeclare var ga: UniversalAnalytics.ga;\ndeclare var location: any;\n\nexport class GoogleAnalyticsDefaults implements GoogleAnalyticsSettings {\n  additionalAccountNames = [];\n  userId = null;\n  transport = '';\n  anonymizeIp = false;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class Angulartics2GoogleAnalytics {\n  dimensionsAndMetrics = [];\n  settings: Partial<GoogleAnalyticsSettings>;\n\n  constructor(private angulartics2: Angulartics2) {\n    const defaults = new GoogleAnalyticsDefaults();\n    // Set the default settings for this module\n    this.angulartics2.settings.ga = {\n      ...defaults,\n      ...this.angulartics2.settings.ga,\n    };\n    this.settings = this.angulartics2.settings.ga;\n    this.angulartics2.setUsername.subscribe((x: string) => this.setUsername(x));\n    this.angulartics2.setUserProperties.subscribe(x => this.setUserProperties(x));\n  }\n\n  startTracking(): void {\n    this.angulartics2.pageTrack\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe(x => this.pageTrack(x.path));\n    this.angulartics2.eventTrack\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe(x => this.eventTrack(x.action, x.properties));\n    this.angulartics2.exceptionTrack\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe(x => this.exceptionTrack(x));\n    this.angulartics2.userTimings\n      .pipe(this.angulartics2.filterDeveloperMode())\n      .subscribe(x => this.userTimings(x));\n  }\n\n  pageTrack(path: string) {\n    if (typeof _gaq !== 'undefined' && _gaq) {\n      _gaq.push(['_trackPageview', path]);\n      for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n        _gaq.push([accountName + '._trackPageview', path]);\n      }\n    }\n    if (typeof ga !== 'undefined' && ga) {\n      if (this.angulartics2.settings.ga.userId) {\n        ga('set', '&uid', this.angulartics2.settings.ga.userId);\n        for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n          ga(accountName + '.set', '&uid', this.angulartics2.settings.ga.userId);\n        }\n      }\n      if (this.angulartics2.settings.ga.anonymizeIp) {\n        ga('set', 'anonymizeIp', true);\n        for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n          ga(accountName + '.set', 'anonymizeIp', true);\n        }\n      }\n      ga('send', 'pageview', path);\n      for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n        ga(accountName + '.send', 'pageview', path);\n      }\n    }\n  }\n\n  /**\n   * Track Event in GA\n   *\n   * @param action Associated with the event\n   * @param properties Comprised of:\n   *  - category (string) and optional\n   *  - label (string)\n   *  - value (integer)\n   *  - noninteraction (boolean)\n   *\n   * @link https://developers.google.com/analytics/devguides/collection/gajs/eventTrackerGuide#SettingUpEventTracking\n   * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/events\n   */\n  eventTrack(action: string, properties: any) {\n    // Google Analytics requires an Event Category\n    if (!properties || !properties.category) {\n      properties = properties || {};\n      properties.category = 'Event';\n    }\n    // GA requires that eventValue be an integer, see:\n    // https://developers.google.com/analytics/devguides/collection/analyticsjs/field-reference#eventValue\n    // https://github.com/luisfarzati/angulartics/issues/81\n    if (properties.value) {\n      const parsed = parseInt(properties.value, 10);\n      properties.value = isNaN(parsed) ? 0 : parsed;\n    }\n\n    if (typeof ga !== 'undefined') {\n      const eventOptions = {\n        eventCategory: properties.category,\n        eventAction: action,\n        eventLabel: properties.label,\n        eventValue: properties.value,\n        nonInteraction: properties.noninteraction,\n        page: properties.page || location.hash.substring(1) || location.pathname,\n        userId: this.angulartics2.settings.ga.userId,\n        hitCallback: properties.hitCallback,\n        ...(this.angulartics2.settings.ga.transport && {\n          transport: this.angulartics2.settings.ga.transport,\n        }),\n      };\n\n      // add custom dimensions and metrics\n      this.setDimensionsAndMetrics(properties);\n\n      ga('send', 'event', eventOptions);\n\n      for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n        ga(accountName + '.send', 'event', eventOptions);\n      }\n    } else if (typeof _gaq !== 'undefined') {\n      _gaq.push([\n        '_trackEvent',\n        properties.category,\n        action,\n        properties.label,\n        properties.value,\n        properties.noninteraction,\n      ]);\n    }\n  }\n\n  /**\n   * Exception Track Event in GA\n   *\n   * @param properties Comprised of the optional fields:\n   *  - fatal (string)\n   *  - description (string)\n   *\n   * @https://developers.google.com/analytics/devguides/collection/analyticsjs/exceptions\n   *\n   * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/events\n   */\n  exceptionTrack(properties: any) {\n    if (properties.fatal === undefined) {\n      console.log('No \"fatal\" provided, sending with fatal=true');\n      properties.fatal = true;\n    }\n\n    properties.exDescription = properties.description;\n\n    const eventOptions = {\n      exFatal: properties.fatal,\n      exDescription: properties.description,\n    };\n\n    ga('send', 'exception', eventOptions);\n    for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n      ga(accountName + '.send', 'exception', eventOptions);\n    }\n  }\n\n  /**\n   * User Timings Event in GA\n   *\n   * @param properties Comprised of the mandatory fields:\n   *  - timingCategory (string)\n   *  - timingVar (string)\n   *  - timingValue (number)\n   * Properties can also have the optional fields:\n   *  - timingLabel (string)\n   *\n   * @link https://developers.google.com/analytics/devguides/collection/analyticsjs/user-timings\n   */\n  userTimings(properties: UserTimings) {\n    if (\n      !properties ||\n      !properties.timingCategory ||\n      !properties.timingVar ||\n      !properties.timingValue\n    ) {\n      console.error(\n        'Properties timingCategory, timingVar, and timingValue are required to be set.',\n      );\n      return;\n    }\n\n    if (typeof ga !== 'undefined') {\n      ga('send', 'timing', properties);\n      for (const accountName of this.angulartics2.settings.ga.additionalAccountNames) {\n        ga(accountName + '.send', 'timing', properties);\n      }\n    }\n  }\n\n  setUsername(userId: string) {\n    this.angulartics2.settings.ga.userId = userId;\n    if (typeof ga === 'undefined') {\n      return;\n    }\n    ga('set', 'userId', userId);\n  }\n\n  setUserProperties(properties: any) {\n    this.setDimensionsAndMetrics(properties);\n  }\n\n  private setDimensionsAndMetrics(properties: any) {\n    if (typeof ga === 'undefined') {\n      return;\n    }\n    // clean previously used dimensions and metrics that will not be overriden\n    this.dimensionsAndMetrics.forEach(elem => {\n      if (!properties.hasOwnProperty(elem)) {\n        ga('set', elem, undefined);\n\n        this.angulartics2.settings.ga.additionalAccountNames.forEach((accountName: string) => {\n          ga(`${accountName}.set`, elem, undefined);\n        });\n      }\n    });\n    this.dimensionsAndMetrics = [];\n\n    // add custom dimensions and metrics\n    Object.keys(properties).forEach(key => {\n      if (key.lastIndexOf('dimension', 0) === 0 || key.lastIndexOf('metric', 0) === 0) {\n        ga('set', key, properties[key]);\n\n        this.angulartics2.settings.ga.additionalAccountNames.forEach((accountName: string) => {\n          ga(`${accountName}.set`, key, properties[key]);\n        });\n        this.dimensionsAndMetrics.push(key);\n      }\n    });\n  }\n}\n"]}

package/{ga-enhanced-ecom/esm2015/ga-enhanced-ecom-options.js → esm2020/providers/ga-enhanced-ecom/ga-enhanced-ecom-options.mjs}

@@ -3,4 +3,5 @@
  *
  * Actions specify how to interpret product and promotion data that you send to Google Analytics.
  */
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2EtZW5oYW5jZWQtZWNvbS1vcHRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9wcm92aWRlcnMvZ2EtZW5oYW5jZWQtZWNvbS9nYS1lbmhhbmNlZC1lY29tLW9wdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUHJvZHVjdCBhbmQgUHJvbW90aW9uIEFjdGlvbnNcbiAqXG4gKiBBY3Rpb25zIHNwZWNpZnkgaG93IHRvIGludGVycHJldCBwcm9kdWN0IGFuZCBwcm9tb3Rpb24gZGF0YSB0aGF0IHlvdSBzZW5kIHRvIEdvb2dsZSBBbmFseXRpY3MuXG4gKi9cblxuZXhwb3J0IHR5cGUgR2FFbmhhbmNlZEVjb21BY3Rpb24gPVxuICB8ICdjbGljaycgLy8gQSBjbGljayBvbiBhIHByb2R1Y3Qgb3IgcHJvZHVjdCBsaW5rIGZvciBvbmUgb3IgbW9yZSBwcm9kdWN0cy5cbiAgfCAnZGV0YWlsJyAvLyBBIHZpZXcgb2YgcHJvZHVjdCBkZXRhaWxzLlxuICB8ICdhZGQnIC8vIEFkZGluZyBvbmUgb3IgbW9yZSBwcm9kdWN0cyB0byBhIHNob3BwaW5nIGNhcnQuXG4gIHwgJ3JlbW92ZScgLy8gUmVtb3ZlIG9uZSBvciBtb3JlIHByb2R1Y3RzIGZyb20gYSBzaG9wcGluZyBjYXJ0LlxuICB8ICdjaGVja291dCcgLy8gSW5pdGlhdGluZyB0aGUgY2hlY2tvdXQgcHJvY2VzcyBmb3Igb25lIG9yIG1vcmUgcHJvZHVjdHMuXG4gIHwgJ2NoZWNrb3V0X29wdGlvbicgLy8gU2VuZGluZyB0aGUgb3B0aW9uIHZhbHVlIGZvciBhIGdpdmVuIGNoZWNrb3V0IHN0ZXAuXG4gIHwgJ3B1cmNoYXNlJyAvLyBUaGUgc2FsZSBvZiBvbmUgb3IgbW9yZSBwcm9kdWN0cy5cbiAgfCAncmVmdW5kJyAvLyBUaGUgcmVmdW5kIG9mIG9uZSBvciBtb3JlIHByb2R1Y3RzLlxuICB8ICdwcm9tb19jbGljayc7IC8vIEEgY2xpY2sgb24gYW4gaW50ZXJuYWwgcHJvbW90aW9uLlxuXG4vKipcbiAqIEltcHJlc3Npb24gRGF0YVxuICpcbiAqIFJlcHJlc2VudHMgaW5mb3JtYXRpb24gYWJvdXQgYSBwcm9kdWN0IHRoYXQgaGFzIGJlZW4gdmlld2VkLiBJdCBpc1xuICogcmVmZXJyZWQgdG8gYXMgYW4gaW1wcmVzc2lvbkZpZWxkT2JqZWN0IGFuZCBjb250YWlucyB0aGUgZm9sbG93aW5nIHZhbHVlcy5cbiAqXG4gKiBAbGluayBodHRwczovL2RldmVsb3BlcnMuZ29vZ2xlLmNvbS9hbmFseXRpY3MvZGV2Z3VpZGVzL2NvbGxlY3Rpb24vYW5hbHl0aWNzanMvZW5oYW5jZWQtZWNvbW1lcmNlI2ltcHJlc3Npb24tZGF0YVxuICovXG5leHBvcnQgaW50ZXJmYWNlIEdhRW5oYW5jZWRFY29tSW1wcmVzc2lvbkZpZWxkT2JqZWN0IHtcbiAgLyoqIFRoZSBwcm9kdWN0IElEIG9yIFNLVSAoZS5nLiBQNjc4OTApLiAqRWl0aGVyIHRoaXMgZmllbGQgb3IgbmFtZSBtdXN0IGJlIHNldC4gKi9cbiAgaWQ6IHN0cmluZztcbiAgLyoqIFRoZSBuYW1lIG9mIHRoZSBwcm9kdWN0IChlLmcuIEFuZHJvaWQgVC1TaGlydCkuICpFaXRoZXIgdGhpcyBmaWVsZCBvciBpZCBtdXN0IGJlIHNldC4gKi9cbiAgbmFtZTogc3RyaW5nO1xuICAvKiogVGhlIGxpc3Qgb3IgY29sbGVjdGlvbiB0byB3aGljaCB0aGUgcHJvZHVjdCBiZWxvbmdzIChlLmcuIFNlYXJjaCBSZXN1bHRzKSAqL1xuICBsaXN0OiBzdHJpbmc7XG4gIC8qKiBUaGUgYnJhbmQgYXNzb2NpYXRlZCB3aXRoIHRoZSBwcm9kdWN0IChlLmcuIEdvb2dsZSkuICovXG4gIGJyYW5kOiBzdHJpbmc7XG4gIC8qKlxuICAgKiBUaGUgY2F0ZWdvcnkgdG8gd2hpY2ggdGhlIHByb2R1Y3QgYmVsb25ncyAoZS5nLiBBcHBhcmVsKS5cbiAgICogVXNlIC8gYXMgYSBkZWxpbWl0ZXIgdG8gc3BlY2lmeSB1cCB0byA1LWxldmVscyBvZiBoaWVyYXJjaHkgKGUuZy4gQXBwYXJlbC9NZW4vVC1TaGlydHMpXG4gICAqL1xuICBjYXRlZ29yeTogc3RyaW5nO1xuICAvKiogVGhlIHZhcmlhbnQgb2YgdGhlIHByb2R1Y3QgKGUuZy4gQmxhY2spLiAqL1xuICB2YXJpYW50OiBzdHJpbmc7XG4gIC8qKiBUaGUgcHJvZHVjdCdzIHBvc2l0aW9uIGluIGEgbGlzdCBvciBjb2xsZWN0aW9uIChlLmcuIDIpICovXG4gIHBvc2l0aW9uOiBudW1iZXI7XG4gIC8qKiBUaGUgcHJpY2Ugb2YgYSBwcm9kdWN0IChlLmcuIDI5LjIwKSAqL1xuICBwcmljZTogbnVtYmVyO1xufVxuXG4vKipcbiAqIFByb2R1Y3QgRGF0YVxuICpcbiAqIFByb2R1Y3QgZGF0YSByZXByZXNlbnRzIGluZGl2aWR1YWwgcHJvZHVjdHMgdGhhdCB3ZXJlIHZpZXdlZCwgYWRkZWRcbiAqIHRvIHRoZSBzaG9wcGluZyBjYXJ0LCBldGMuIEl0IGlzIHJlZmVycmVkIHRvIGFzIGEgcHJvZHVjdEZpZWxkT2JqZWN0XG4gKiBhbmQgY29udGFpbnMgdGhlIGZvbGxvd2luZyB2YWx1ZXMuXG4gKlxuICogQGxpbmsgaHR0cHM6Ly9kZXZlbG9wZXJzLmdvb2dsZS5jb20vYW5hbHl0aWNzL2Rldmd1aWRlcy9jb2xsZWN0aW9uL2FuYWx5dGljc2pzL2VuaGFuY2VkLWVjb21tZXJjZSNwcm9kdWN0LWRhdGFcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBHYUVuaGFuY2VkRWNvbVByb2R1Y3RGaWVsZE9iamVjdCB7XG4gIC8qKiBUaGUgcHJvZHVjdCBJRCBvciBTS1UgKGUuZy4gUDY3ODkwKS4gKkVpdGhlciB0aGlzIGZpZWxkIG9yIG5hbWUgbXVzdCBiZSBzZXQuICovXG4gIGlkOiBzdHJpbmc7XG4gIC8qKiBUaGUgbmFtZSBvZiB0aGUgcHJvZHVjdCAoZS5nLiBBbmRyb2lkIFQtU2hpcnQpLiAqRWl0aGVyIHRoaXMgZmllbGQgb3IgaWQgbXVzdCBiZSBzZXQuICovXG4gIG5hbWU6IHN0cmluZztcbiAgLyoqIFRoZSBicmFuZCBhc3NvY2lhdGVkIHdpdGggdGhlIHByb2R1Y3QgKGUuZy4gR29vZ2xlKS4gKi9cbiAgYnJhbmQ6IHN0cmluZztcbiAgLyoqXG4gICAqIFRoZSBjYXRlZ29yeSB0byB3aGljaCB0aGUgcHJvZHVjdCBiZWxvbmdzIChlLmcuIEFwcGFyZWwpLlxuICAgKiBVc2UgLyBhcyBhIGRlbGltaXRlciB0byBzcGVjaWZ5IHVwIHRvIDUtbGV2ZWxzIG9mIGhpZXJhcmNoeSAoZS5nLiBBcHBhcmVsL01lbi9ULVNoaXJ0cykuXG4gICAqL1xuICBjYXRlZ29yeTogc3RyaW5nO1xuICAvKiogVGhlIHZhcmlhbnQgb2YgdGhlIHByb2R1Y3QgKGUuZy4gQmxhY2spLiAqL1xuICB2YXJpYW50OiBzdHJpbmc7XG4gIC8qKiBUaGUgcHJpY2Ugb2YgYSBwcm9kdWN0IChlLmcuIDI5LjIwKS4gKi9cbiAgcHJpY2U6IG51bWJlcjtcbiAgLyoqIFRoZSBxdWFudGl0eSBvZiBhIHByb2R1Y3QgKGUuZy4gMikuICovXG4gIHF1YW50aXR5OiBudW1iZXI7XG4gIC8qKiBUaGUgY291cG9uIGNvZGUgYXNzb2NpYXRlZCB3aXRoIGEgcHJvZHVjdCAoZS5nLiBTVU1NRVJfU0FMRTEzKS4gKi9cbiAgY291cG9uOiBzdHJpbmc7XG4gIC8qKiBUaGUgcHJvZHVjdCdzIHBvc2l0aW9uIGluIGEgbGlzdCBvciBjb2xsZWN0aW9uIChlLmcuIDIpLiAqL1xuICBwb3NpdGlvbjogbnVtYmVyO1xufVxuXG4vKipcbiAqIFByb21vdGlvbiBEYXRhXG4gKlxuICogUmVwcmVzZW50cyBpbmZvcm1hdGlvbiBhYm91dCBhIHByb21vdGlvbiB0aGF0IGhhcyBiZWVuIHZpZXdlZC5cbiAqIEl0IGlzIHJlZmVycmVkIHRvIGEgcHJvbW9GaWVsZE9iamVjdCBhbmQgY29udGFpbnMgdGhlIGZvbGxvd2luZyB2YWx1ZXMuXG4gKlxuICogQGxpbmsgaHR0cHM6Ly9kZXZlbG9wZXJzLmdvb2dsZS5jb20vYW5hbHl0aWNzL2Rldmd1aWRlcy9jb2xsZWN0aW9uL2FuYWx5dGljc2pzL2VuaGFuY2VkLWVjb21tZXJjZSNwcm9tb3Rpb24tZGF0YVxuICovXG5leHBvcnQgaW50ZXJmYWNlIEdhRW5oYW5jZWRFY29tUHJvbW9GaWVsZE9iamVjdCB7XG4gIC8qKiBUaGUgcHJvbW90aW9uIElEIChlLmcuIFBST01PXzEyMzQpLiAqRWl0aGVyIHRoaXMgZmllbGQgb3IgbmFtZSBtdXN0IGJlIHNldC4gKi9cbiAgaWQ6IHN0cmluZztcbiAgLyoqIFRoZSBuYW1lIG9mIHRoZSBwcm9tb3Rpb24gKGUuZy4gU3VtbWVyIFNhbGUpLiAqRWl0aGVyIHRoaXMgZmllbGQgb3IgaWQgbXVzdCBiZSBzZXQuICovXG4gIG5hbWU6IHN0cmluZztcbiAgLyoqIFRoZSBjcmVhdGl2ZSBhc3NvY2lhdGVkIHdpdGggdGhlIHByb21vdGlvbiAoZS5nLiBzdW1tZXJfYmFubmVyMikuICovXG4gIGNyZWF0aXZlOiBzdHJpbmc7XG4gIC8qKiBUaGUgcG9zaXRpb24gb2YgdGhlIGNyZWF0aXZlIChlLmcuIGJhbm5lcl9zbG90XzEpLiAqL1xuICBwb3NpdGlvbjogc3RyaW5nO1xufVxuXG4vKipcbiAqIEFjdGlvbiBEYXRhXG4gKlxuICogUmVwcmVzZW50cyBpbmZvcm1hdGlvbiBhYm91dCBhbiBlY29tbWVyY2UgcmVsYXRlZCBhY3Rpb25cbiAqIHRoYXQgaGFzIHRha2VuIHBsYWNlLiBJdCBpcyByZWZlcnJlZCB0byBhcyBhbiBhY3Rpb25GaWVsZE9iamVjdFxuICogYW5kIGNvbnRhaW5zIHRoZSBmb2xsb3dpbmcgdmFsdWVzLlxuICpcbiAqIEBsaW5rIGh0dHBzOi8vZGV2ZWxvcGVycy5nb29nbGUuY29tL2FuYWx5dGljcy9kZXZndWlkZXMvY29sbGVjdGlvbi9hbmFseXRpY3Nqcy9lbmhhbmNlZC1lY29tbWVyY2UjYWN0aW9uLWRhdGFcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBHYUVuaGFuY2VkRWNvbUFjdGlvbkZpZWxkT2JqZWN0IHtcbiAgLyoqIFRoZSB0cmFuc2FjdGlvbiBJRCAoZS5nLiBUMTIzNCkuICpSZXF1aXJlZCBpZiB0aGUgYWN0aW9uIHR5cGUgaXMgcHVyY2hhc2Ugb3IgcmVmdW5kLiAqL1xuICBpZDogc3RyaW5nO1xuICAvKiogVGhlIHN0b3JlIG9yIGFmZmlsaWF0aW9uIGZyb20gd2hpY2ggdGhpcyB0cmFuc2FjdGlvbiBvY2N1cnJlZCAoZS5nLiBHb29nbGUgU3RvcmUpLiAqL1xuICBhZmZpbGlhdGlvbjogc3RyaW5nO1xuICAvKipcbiAgICogU3BlY2lmaWVzIHRoZSB0b3RhbCByZXZlbnVlIG9yIGdyYW5kIHRvdGFsIGFzc29jaWF0ZWQgd2l0aCB0aGUgdHJhbnNhY3Rpb24gKGUuZy4gMTEuOTkpLlxuICAgKiBUaGlzIHZhbHVlIG1heSBpbmNsdWRlIHNoaXBwaW5nLCB0YXggY29zdHMsIG9yIG90aGVyIGFkanVzdG1lbnRzIHRvIHRvdGFsIHJldmVudWUgdGhhdFxuICAgKiB5b3Ugd2FudCB0byBpbmNsdWRlIGFzIHBhcnQgb2YgeW91ciByZXZlbnVlIGNhbGN1bGF0aW9ucy4gTm90ZTogaWYgcmV2ZW51ZSBpcyBub3Qgc2V0LFxuICAgKiBpdHMgdmFsdWUgd2lsbCBiZSBhdXRvbWF0aWNhbGx5IGNhbGN1bGF0ZWQgdXNpbmcgdGhlIHByb2R1Y3QgcXVhbnRpdHkgYW5kIHByaWNlIGZpZWxkc1xuICAgKiBvZiBhbGwgcHJvZHVjdHMgaW4gdGhlIHNhbWUgaGl0LlxuICAgKi9cbiAgcmV2ZW51ZTogbnVtYmVyO1xuICAvKiogVGhlIHRvdGFsIHRheCBhc3NvY2lhdGVkIHdpdGggdGhlIHRyYW5zYWN0aW9uLiAqL1xuICB0YXg6IG51bWJlcjtcbiAgLyoqIFRoZSBzaGlwcGluZyBjb3N0IGFzc29jaWF0ZWQgd2l0aCB0aGUgdHJhbnNhY3Rpb24uICovXG4gIHNoaXBwaW5nOiBudW1iZXI7XG4gIC8qKiBUaGUgdHJhbnNhY3Rpb24gY291cG9uIHJlZGVlbWVkIHdpdGggdGhlIHRyYW5zYWN0aW9uLiAqL1xuICBjb3Vwb246IHN0cmluZztcbiAgLyoqIFRoZSBsaXN0IHRoYXQgdGhlIGFzc29jaWF0ZWQgcHJvZHVjdHMgYmVsb25nIHRvLiBPcHRpb25hbC4gKi9cbiAgbGlzdDogc3RyaW5nO1xuICAvKiogQSBudW1iZXIgcmVwcmVzZW50aW5nIGEgc3RlcCBpbiB0aGUgY2hlY2tvdXQgcHJvY2Vzcy4gT3B0aW9uYWwgb24gY2hlY2tvdXQgYWN0aW9ucy4gKi9cbiAgc3RlcDogbnVtYmVyO1xuICAvKipcbiAgICogQWRkaXRpb25hbCBmaWVsZCBmb3IgY2hlY2tvdXQgYW5kIGNoZWNrb3V0X29wdGlvbiBhY3Rpb25zIHRoYXQgY2FuIGRlc2NyaWJlXG4gICAqIG9wdGlvbiBpbmZvcm1hdGlvbiBvbiB0aGUgY2hlY2tvdXQgcGFnZSwgbGlrZSBzZWxlY3RlZCBwYXltZW50IG1ldGhvZC5cbiAgICovXG4gIG9wdGlvbjogc3RyaW5nO1xufVxuIl19