@gcorevideo/player 2.22.16 → 2.22.17

package/dist/index.js

@@ -13045,13 +13045,11 @@ class DashPlayback extends BasePlayback {
             this.getPlaybackType() === Playback.LIVE);
     }
     _onProgress() {
-        if (!this._dash) {
-            return;
-        }
-        let buffer = this._dash.getDashMetrics().getCurrentBufferLevel('video');
-        if (!buffer) {
-            buffer = this._dash.getDashMetrics().getCurrentBufferLevel('audio');
-        }
+        const buffer = 
+        // @ts-expect-error
+        this._dash.getDashMetrics().getCurrentBufferLevel('video') ||
+            // @ts-expect-error
+            this._dash.getDashMetrics().getCurrentBufferLevel('audio');
         const progress = {
             start: this.getCurrentTime(),
             current: this.getCurrentTime() + buffer,
@@ -43307,7 +43305,7 @@ class Player {
     }
 }
 
-var version$1 = "2.22.16";
+var version$1 = "2.22.17";
 
 var packages = {
 	"node_modules/@clappr/core": {
@@ -43885,6 +43883,339 @@ class BottomGear extends UICorePlugin {
     }
 }
 
+/**
+ * @beta
+ */
+var Chronograph;
+(function (Chronograph) {
+    Chronograph["Startup"] = "startup";
+    Chronograph["Watch"] = "watch";
+    Chronograph["Pause"] = "pause";
+    Chronograph["Buffering"] = "buffering";
+    Chronograph["Session"] = "session";
+    // Latency = 'latency',
+})(Chronograph || (Chronograph = {}));
+/**
+ * @beta
+ */
+var Counter;
+(function (Counter) {
+    Counter["Play"] = "play";
+    Counter["Pause"] = "pause";
+    Counter["Error"] = "error";
+    Counter["Buffering"] = "buffering";
+    Counter["DecodedFrames"] = "decodedFrames";
+    Counter["DroppedFrames"] = "droppedFrames";
+    Counter["Fps"] = "fps";
+    Counter["ChangeLevel"] = "changeLevel";
+    Counter["Seek"] = "seek";
+    Counter["Fullscreen"] = "fullscreen";
+    Counter["DvrUsage"] = "dvrUsage";
+})(Counter || (Counter = {}));
+/**
+ * @beta
+ */
+var ClapprStatsEvents;
+(function (ClapprStatsEvents) {
+    /**
+     * Emitted periodically with current measurements.
+     */
+    ClapprStatsEvents["REPORT"] = "clappr:stats:report";
+    /**
+     * Emitted when the playback reaches a certain percentage of the total duration.
+     */
+    // PERCENTAGE = 'clappr:stats:percentage',
+})(ClapprStatsEvents || (ClapprStatsEvents = {}));
+
+function newMetrics$1() {
+    return {
+        counters: {
+            play: 0,
+            pause: 0,
+            error: 0,
+            buffering: 0,
+            decodedFrames: 0,
+            droppedFrames: 0,
+            fps: 0,
+            changeLevel: 0,
+            seek: 0,
+            fullscreen: 0,
+            dvrUsage: 0,
+        },
+        chrono: {
+            startup: 0,
+            watch: 0,
+            pause: 0,
+            buffering: 0,
+            session: 0,
+        },
+        extra: {
+            playbackName: '',
+            playbackType: '',
+            bitratesHistory: [],
+            bitrateWeightedMean: 0,
+            bitrateMostUsed: 0,
+            buffersize: 0,
+            watchHistory: [],
+            watchedPercentage: 0,
+            bufferingPercentage: 0,
+            bandwidth: 0,
+            duration: 0,
+            currentTime: 0,
+        },
+        custom: {},
+    };
+}
+
+/**
+ * `PLUGIN` that measures data about playback, which can be useful for analyzing performance and UX.
+ * @beta
+ * @remarks
+ * This plugin does not render anything and is supposed to be extended or used together with other plugins that actually render something.
+ *
+ * Configuration options - {@link ClapprStatsSettings}
+ *
+ * Events - {@link ClapprStatsEvents}
+ */
+class ClapprStats extends ContainerPlugin {
+    timerId = null;
+    lastDecodedFramesCount = 0;
+    metrics = newMetrics$1();
+    timers = {
+        [Chronograph.Startup]: 0,
+        [Chronograph.Watch]: 0,
+        [Chronograph.Pause]: 0,
+        [Chronograph.Buffering]: 0,
+        [Chronograph.Session]: 0,
+    };
+    runEach;
+    /**
+     * @internal
+     */
+    get name() {
+        return 'clappr_stats';
+    }
+    /**
+     * @internal
+     */
+    get supportedVersion() {
+        return { min: CLAPPR_VERSION$1 };
+    }
+    get playbackName() {
+        return String(this.container.playback.name || '');
+    }
+    get playbackType() {
+        return this.container.getPlaybackType();
+    }
+    now() {
+        const hasPerformanceSupport = window.performance && typeof window.performance.now === 'function';
+        return hasPerformanceSupport
+            ? window.performance.now()
+            : new Date().getTime();
+    }
+    inc(counter) {
+        this.metrics.counters[counter] += 1;
+    }
+    // _timerHasStarted(timer) {
+    //   return this[`_start${timer}`] !== undefined;
+    // }
+    start(timer) {
+        // this[`_start${timer}`] = this._now();
+        this.timers[timer] = this.now();
+    }
+    stop(timer) {
+        // this._metrics.timers[timer] += this._now() - this[`_start${timer}`];
+        this.metrics.chrono[timer] += this.now() - this.timers[timer];
+    }
+    constructor(container) {
+        super(container);
+        this.runEach = container.options.clapprStats?.runEach ?? 5000;
+    }
+    /**
+     * @internal
+     */
+    bindEvents() {
+        this.listenTo(this.container, Events$1.CONTAINER_BITRATE, this.onBitrate);
+        this.listenTo(this.container, Events$1.CONTAINER_STOP, this.stopReporting);
+        this.listenTo(this.container, Events$1.CONTAINER_ENDED, this.stopReporting);
+        this.listenToOnce(this.container.playback, Events$1.PLAYBACK_PLAY_INTENT, this.startTimers);
+        this.listenToOnce(this.container, Events$1.CONTAINER_PLAY, this.onFirstPlaying);
+        this.listenTo(this.container, Events$1.CONTAINER_PLAY, this.onPlay);
+        this.listenTo(this.container, Events$1.CONTAINER_PAUSE, this.onPause);
+        this.listenToOnce(this.container, Events$1.CONTAINER_STATE_BUFFERING, this.onBuffering);
+        this.listenTo(this.container, Events$1.CONTAINER_SEEK, this.onSeek);
+        this.listenTo(this.container, Events$1.CONTAINER_ERROR, () => this.inc(Counter.Error));
+        this.listenTo(this.container, Events$1.CONTAINER_FULLSCREEN, () => this.inc(Counter.Fullscreen));
+        this.listenTo(this.container, Events$1.CONTAINER_PLAYBACKDVRSTATECHANGED, (dvrInUse) => {
+            dvrInUse && this.inc(Counter.DvrUsage);
+        });
+        this.listenTo(this.container.playback, Events$1.PLAYBACK_PROGRESS, this.onProgress);
+        this.listenTo(this.container.playback, Events$1.PLAYBACK_TIMEUPDATE, this.onTimeUpdate);
+    }
+    /**
+     * @internal
+     */
+    destroy() {
+        this.stopReporting();
+        super.destroy();
+    }
+    /**
+     * Returns the collected metrics.
+     * @returns Measurements collected so far
+     */
+    exportMetrics() {
+        return structuredClone(this.metrics);
+    }
+    onBitrate(newBitrate) {
+        const bitrate = newBitrate.bitrate;
+        const now = this.now();
+        if (this.metrics.extra.bitratesHistory.length > 0) {
+            const last = this.metrics.extra.bitratesHistory[this.metrics.extra.bitratesHistory.length - 1];
+            last.end = now;
+            last.time = now - last.start;
+        }
+        this.metrics.extra.bitratesHistory.push({ start: this.now(), bitrate });
+        this.inc(Counter.ChangeLevel);
+    }
+    stopReporting() {
+        this.buildReport();
+        if (this.timerId !== null) {
+            clearInterval(this.timerId);
+            this.timerId = null;
+        }
+    }
+    startTimers() {
+        this.timerId = setInterval(this.buildReport.bind(this), this.runEach);
+        this.start(Chronograph.Session);
+        this.start(Chronograph.Startup);
+    }
+    onFirstPlaying() {
+        this.listenTo(this.container, Events$1.CONTAINER_TIMEUPDATE, this.onContainerUpdateWhilePlaying);
+        this.start(Chronograph.Watch);
+        this.stop(Chronograph.Startup);
+    }
+    playAfterPause() {
+        this.listenTo(this.container, Events$1.CONTAINER_TIMEUPDATE, this.onContainerUpdateWhilePlaying);
+        this.stop(Chronograph.Pause);
+        this.start(Chronograph.Watch);
+    }
+    onPlay() {
+        this.inc(Counter.Play);
+    }
+    onPause() {
+        this.stop(Chronograph.Watch);
+        this.start(Chronograph.Pause);
+        this.inc(Counter.Pause);
+        this.listenToOnce(this.container, Events$1.CONTAINER_PLAY, this.playAfterPause);
+        this.stopListening(this.container, Events$1.CONTAINER_TIMEUPDATE, this.onContainerUpdateWhilePlaying);
+    }
+    onSeek(e) {
+        this.inc(Counter.Seek);
+        this.metrics.extra.watchHistory.push([e * 1000, e * 1000]);
+    }
+    onTimeUpdate(e) {
+        const current = e.current * 1000, total = e.total * 1000, l = this.metrics.extra.watchHistory.length;
+        this.metrics.extra.duration = total;
+        this.metrics.extra.currentTime = current;
+        // TODO what if it's a live stream?
+        this.metrics.extra.watchedPercentage = (current / total) * 100;
+        if (l === 0) {
+            this.metrics.extra.watchHistory.push([current, current]);
+        }
+        else {
+            this.metrics.extra.watchHistory[l - 1][1] = current;
+        }
+        if (this.metrics.extra.bitratesHistory.length > 0) {
+            const lastBitrate = this.metrics.extra.bitratesHistory[this.metrics.extra.bitratesHistory.length - 1];
+            if (!lastBitrate.end) {
+                lastBitrate.time = this.now() - lastBitrate.start;
+            }
+        }
+        this.onCompletion();
+    }
+    onContainerUpdateWhilePlaying() {
+        if (this.container.playback.isPlaying()) {
+            this.stop(Chronograph.Watch);
+            this.start(Chronograph.Watch);
+        }
+    }
+    onBuffering() {
+        this.inc(Counter.Buffering);
+        this.start(Chronograph.Buffering);
+        this.listenToOnce(this.container, Events$1.CONTAINER_STATE_BUFFERFULL, this.onBufferfull);
+    }
+    onBufferfull() {
+        this.stop(Chronograph.Buffering);
+        this.listenToOnce(this.container, Events$1.CONTAINER_STATE_BUFFERING, this.onBuffering);
+    }
+    onProgress(progress) {
+        this.metrics.extra.buffersize = progress.current * 1000;
+    }
+    onCompletion() {
+        // Decide if this is needed
+        // const currentPercentage = this.metrics.extra.watchedPercentage;
+        // this.trigger(ClapprStatsEvents.PERCENTAGE, currentPercentage);
+    }
+    buildReport() {
+        this.stop(Chronograph.Session);
+        this.start(Chronograph.Session);
+        this.metrics.extra.playbackName = this.playbackName;
+        this.metrics.extra.playbackType = this.playbackType;
+        this.calcBitrates();
+        this.calcBufferingPercentage();
+        // TODO calc FPS properly, e.g., on TIMEUPDATE event
+        this.fetchFPS();
+        this.trigger(ClapprStatsEvents.REPORT, structuredClone(this.metrics));
+    }
+    fetchFPS() {
+        // TODO check if the playback and media sources support video, then use the common method
+        // flashls ??? - hls.droppedFramesl hls.stream.bufferLength (seconds)
+        // hls ??? (use the same?)
+        const fetchFPS = {
+            html5_video: this.html5FetchFPS,
+            hls: this.html5FetchFPS,
+            dash: this.html5FetchFPS,
+        };
+        if (this.playbackName in fetchFPS) {
+            fetchFPS[this.playbackName].call(this);
+        }
+    }
+    // TODO sort out
+    calcBitrates() {
+        const { bitratesHistory } = this.metrics.extra;
+        if (bitratesHistory.length === 0) {
+            return;
+        }
+        let totalTime = 0;
+        let weightedTotal = 0;
+        for (const { bitrate, time = 0 } of bitratesHistory) {
+            totalTime += time;
+            weightedTotal += bitrate * time;
+        }
+        this.metrics.extra.bitrateWeightedMean = weightedTotal / totalTime;
+        this.metrics.extra.bitrateMostUsed = bitratesHistory.reduce((mostUsed, current) => (current.time || 0) > (mostUsed.time || 0) ? current : mostUsed, { time: 0, bitrate: 0, start: 0, end: 0 }).bitrate;
+    }
+    calcBufferingPercentage() {
+        if (this.metrics.extra.duration > 0) {
+            this.metrics.extra.bufferingPercentage =
+                (this.metrics.chrono.buffering / this.metrics.extra.duration) * 100;
+        }
+    }
+    html5FetchFPS() {
+        const videoTag = this.container.playback.el;
+        const getFirstValidValue = (...args) => args.find((val) => val !== undefined);
+        const decodedFrames = getFirstValidValue(videoTag.webkitDecodedFrameCount, videoTag.mozDecodedFrames, 0);
+        const droppedFrames = getFirstValidValue(videoTag.webkitDroppedFrameCount, videoTag.mozParsedFrames && videoTag.mozDecodedFrames
+            ? videoTag.mozParsedFrames - videoTag.mozDecodedFrames
+            : 0, 0);
+        const delta = decodedFrames - (this.lastDecodedFramesCount || 0);
+        this.metrics.counters.decodedFrames = decodedFrames;
+        this.metrics.counters.droppedFrames = droppedFrames;
+        this.metrics.counters.fps = delta / (this.runEach / 1000); // TODO use time delta instead of runEach
+        this.lastDecodedFramesCount = decodedFrames;
+    }
+}
+
 var mousetrap = {exports: {}};
 
 /*global define:false */
@@ -44952,56 +45283,6 @@ function requireMousetrap () {
 var mousetrapExports = requireMousetrap();
 const Mousetrap = /*@__PURE__*/getDefaultExportFromCjs$1(mousetrapExports);
 
-/**
- * @beta
- */
-var ClapprStatsEvents;
-(function (ClapprStatsEvents) {
-    ClapprStatsEvents["REPORT_EVENT"] = "clappr:stats:report";
-    ClapprStatsEvents["PERCENTAGE_EVENT"] = "clappr:stats:percentage";
-})(ClapprStatsEvents || (ClapprStatsEvents = {}));
-
-function newMetrics$1() {
-    return {
-        counters: {
-            play: 0,
-            pause: 0,
-            error: 0,
-            buffering: 0,
-            decodedFrames: 0,
-            droppedFrames: 0,
-            fps: 0,
-            changeLevel: 0,
-            seek: 0,
-            fullscreen: 0,
-            dvrUsage: 0,
-        },
-        timers: {
-            startup: 0,
-            watch: 0,
-            pause: 0,
-            buffering: 0,
-            session: 0,
-            latency: 0,
-        },
-        extra: {
-            playbackName: '',
-            playbackType: '',
-            bitratesHistory: [],
-            bitrateWeightedMean: 0,
-            bitrateMostUsed: 0,
-            buffersize: 0,
-            watchHistory: [],
-            watchedPercentage: 0,
-            bufferingPercentage: 0,
-            bandwidth: 0,
-            duration: 0,
-            currentTime: 0,
-        },
-        custom: {},
-    };
-}
-
 var humanFormat$2 = {exports: {}};
 
 var humanFormat$1 = humanFormat$2.exports;
@@ -46026,7 +46307,7 @@ const drawSummary = (customMetrics, vodContainer, liveContainer) => {
     vodContainer.html(vodHtml);
     liveContainer.html(liveHtml);
 };
-const T$f = 'plugins.clappr_nerd_stats';
+const T$f = 'plugins.nerd_stats';
 /**
  * `PLUGIN` that displays useful network-related statistics.
  * @beta
@@ -46043,7 +46324,7 @@ const T$f = 'plugins.clappr_nerd_stats';
  * When clicked, it shows an overlay window with the information about the network speed, latency, etc,
  * and recommended quality level.
  */
-class ClapprNerdStats extends UICorePlugin {
+class NerdStats extends UICorePlugin {
     container = null;
     customMetrics = {
         connectionSpeed: 0,
@@ -46126,32 +46407,29 @@ class ClapprNerdStats extends UICorePlugin {
         this.listenTo(bottomGear, GearEvents.RENDERED, this.addToBottomGear);
         this.container = this.core.activeContainer;
         const clapprStats = this.container?.getPlugin('clappr_stats');
-        if (!clapprStats) {
-            reportError({
-                message: 'clappr_stats plugin is not available',
-            });
-            console.error('clappr-stats not available. Please, include it as a plugin of your Clappr instance.\n' +
-                'For more info, visit: https://github.com/clappr/clappr-stats.');
-            this.disable();
-        }
-        else {
-            Mousetrap.bind(this.shortcut, () => this.toggle());
-            this.listenTo(this.core, Events$1.CORE_RESIZE, this.onPlayerResize);
-            // TODO: fix
-            this.listenTo(clapprStats, ClapprStatsEvents.REPORT_EVENT, this.updateMetrics);
-            clapprStats.setUpdateMetrics(this.updateMetrics.bind(this));
-            this.updateMetrics(clapprStats.exportMetrics());
-            this.render();
-        }
+        assert(clapprStats, 'clappr-stats not available. Please, include it as a plugin of your Clappr instance.\n' +
+            'For more info, visit: https://github.com/clappr/clappr-stats.');
+        Mousetrap.bind(this.shortcut, this.toggle);
+        this.listenTo(this.core, Events$1.CORE_RESIZE, this.onPlayerResize);
+        this.listenTo(clapprStats, ClapprStatsEvents.REPORT, this.updateMetrics);
+        this.updateMetrics(clapprStats.exportMetrics());
+        this.render();
     }
-    toggle() {
+    /**
+     * @internal
+     */
+    destroy() {
+        Mousetrap.unbind(this.shortcut);
+        return super.destroy();
+    }
+    toggle = () => {
         if (this.showing) {
             this.hide();
         }
         else {
             this.show();
         }
-    }
+    };
     show() {
         this.core.$el.find(this.statsBoxElem).show();
         this.showing = true;
@@ -46209,7 +46487,7 @@ class ClapprNerdStats extends UICorePlugin {
         this.addGeneralMetrics();
         this.addCustomMetrics();
         const scrollTop = this.core.$el.find(this.statsBoxElem).scrollTop();
-        this.$el.html(ClapprNerdStats.template({
+        this.$el.html(NerdStats.template({
             metrics: Formatter.format(this.metrics),
             iconPosition: this.iconPosition,
         }));
@@ -46245,8 +46523,8 @@ class ClapprNerdStats extends UICorePlugin {
         trace(`${T$f} addToBottomGear`);
         const gear = this.core.getPlugin('bottom_gear');
         gear
-            .addItem('nerd')
-            .html(ClapprNerdStats.buttonTemplate({
+            .addItem('nerd_stats')
+            .html(NerdStats.buttonTemplate({
             icon: statsIcon,
             i18n: this.core.i18n,
         }))
@@ -46288,362 +46566,6 @@ function newMetrics() {
     };
 }
 
-// TODO: fix
-const updateMetrics = () => { };
-/**
- * `PLUGIN` that collects useful statistics about playback performance.
- * @beta
- * @remarks
- * This plugin does not render anything and is supposed to be extended or used together with other plugins that actually render something.
- */
-class ClapprStats extends ContainerPlugin {
-    bwMeasureCount = 0;
-    intervalId = null;
-    lastDecodedFramesCount = 0;
-    metrics = newMetrics$1();
-    completion;
-    _onReport;
-    runBandwidthTestEvery;
-    runEach;
-    timers = {
-        startup: 0,
-        watch: 0,
-        pause: 0,
-        buffering: 0,
-        session: 0,
-        latency: 0,
-    };
-    updateFn = updateMetrics;
-    urisToMeasureBandwidth;
-    uriToMeasureLatency;
-    /**
-     * @internal
-     */
-    get name() {
-        return 'clappr_stats';
-    }
-    /**
-     * @internal
-     */
-    get supportedVersion() {
-        return { min: CLAPPR_VERSION$1 };
-    }
-    get _playbackName() {
-        return String(this.container.playback.name || '');
-    }
-    get _playbackType() {
-        return this.container.getPlaybackType();
-    }
-    _now() {
-        const hasPerformanceSupport = window.performance && typeof (window.performance.now) === 'function';
-        return (hasPerformanceSupport) ? window.performance.now() : new Date().getTime();
-    }
-    _inc(counter) {
-        this.metrics.counters[counter] += 1;
-    }
-    // _timerHasStarted(timer) {
-    //   return this[`_start${timer}`] !== undefined;
-    // }
-    start(timer) {
-        // this[`_start${timer}`] = this._now();
-        this.timers[timer] = this._now();
-    }
-    _stop(timer) {
-        // this._metrics.timers[timer] += this._now() - this[`_start${timer}`];
-        this.metrics.timers[timer] += this._now() - this.timers[timer];
-    }
-    /**
-     * Registers a callback to receive the metrics.
-     * @param updateMetricsFn - The callback to receive the metrics
-     */
-    setUpdateMetrics(updateMetricsFn) {
-        // TODO use events instead
-        this.updateFn = updateMetricsFn;
-    }
-    _defaultReport(metrics) {
-        this.updateFn(metrics);
-    }
-    constructor(container) {
-        super(container);
-        this.runEach = container.options.clapprStats?.runEach ?? 5000;
-        this._onReport = container.options.clapprStats?.onReport ?? this._defaultReport;
-        this.uriToMeasureLatency = container.options.clapprStats?.uriToMeasureLatency;
-        this.urisToMeasureBandwidth = container.options.clapprStats?.urisToMeasureBandwidth;
-        this.runBandwidthTestEvery = container.options.clapprStats?.runBandwidthTestEvery ?? 10;
-        this.completion = {
-            watch: container.options.clapprStats?.onCompletion ?? [],
-            calls: []
-        };
-    }
-    /**
-     * @internal
-     */
-    bindEvents() {
-        this.listenTo(this.container, Events$1.CONTAINER_BITRATE, this.onBitrate);
-        this.listenTo(this.container, Events$1.CONTAINER_STOP, this.stopReporting);
-        this.listenTo(this.container, Events$1.CONTAINER_ENDED, this.stopReporting);
-        this.listenToOnce(this.container.playback, Events$1.PLAYBACK_PLAY_INTENT, this.startTimers);
-        this.listenToOnce(this.container, Events$1.CONTAINER_PLAY, this.onFirstPlaying);
-        this.listenTo(this.container, Events$1.CONTAINER_PLAY, this.onPlay);
-        this.listenTo(this.container, Events$1.CONTAINER_PAUSE, this.onPause);
-        this.listenToOnce(this.container, Events$1.CONTAINER_STATE_BUFFERING, this.onBuffering);
-        this.listenTo(this.container, Events$1.CONTAINER_SEEK, this.onSeek);
-        this.listenTo(this.container, Events$1.CONTAINER_ERROR, () => this._inc('error'));
-        this.listenTo(this.container, Events$1.CONTAINER_FULLSCREEN, () => this._inc('fullscreen'));
-        this.listenTo(this.container, Events$1.CONTAINER_PLAYBACKDVRSTATECHANGED, (dvrInUse) => {
-            dvrInUse && this._inc('dvrUsage');
-        });
-        this.listenTo(this.container.playback, Events$1.PLAYBACK_PROGRESS, this.onProgress);
-        this.listenTo(this.container.playback, Events$1.PLAYBACK_TIMEUPDATE, this.onTimeUpdate);
-    }
-    /**
-     * @internal
-     */
-    destroy() {
-        this.stopReporting();
-        super.destroy();
-    }
-    /**
-     * Returns the collected metrics.
-     * @returns Currently collected metrics
-     */
-    exportMetrics() {
-        return structuredClone(this.metrics);
-    }
-    onBitrate(newBitrate) {
-        const bitrate = newBitrate.bitrate;
-        const now = this._now();
-        if (this.metrics.extra.bitratesHistory.length > 0) {
-            const beforeLast = this.metrics.extra.bitratesHistory[this.metrics.extra.bitratesHistory.length - 1];
-            beforeLast.end = now;
-            beforeLast.time = now - beforeLast.start;
-        }
-        this.metrics.extra.bitratesHistory.push({ start: this._now(), bitrate: bitrate });
-        this._inc('changeLevel');
-    }
-    stopReporting() {
-        this._buildReport();
-        if (this.intervalId !== null) {
-            clearInterval(this.intervalId);
-            this.intervalId = null;
-        }
-        this._newMetrics();
-        // TODO
-        // @ts-ignore
-        this.stopListening();
-        this.bindEvents();
-    }
-    startTimers() {
-        this.intervalId = setInterval(this._buildReport.bind(this), this.runEach);
-        this.start('session');
-        this.start('startup');
-    }
-    onFirstPlaying() {
-        this.listenTo(this.container, Events$1.CONTAINER_TIMEUPDATE, this.onContainerUpdateWhilePlaying);
-        this.start('watch');
-        this._stop('startup');
-    }
-    playAfterPause() {
-        this.listenTo(this.container, Events$1.CONTAINER_TIMEUPDATE, this.onContainerUpdateWhilePlaying);
-        this._stop('pause');
-        this.start('watch');
-    }
-    onPlay() {
-        this._inc('play');
-    }
-    onPause() {
-        this._stop('watch');
-        this.start('pause');
-        this._inc('pause');
-        this.listenToOnce(this.container, Events$1.CONTAINER_PLAY, this.playAfterPause);
-        this.stopListening(this.container, Events$1.CONTAINER_TIMEUPDATE, this.onContainerUpdateWhilePlaying);
-    }
-    onSeek(e) {
-        this._inc('seek');
-        this.metrics.extra.watchHistory.push([e * 1000, e * 1000]);
-    }
-    onTimeUpdate(e) {
-        const current = e.current * 1000, total = e.total * 1000, l = this.metrics.extra.watchHistory.length;
-        this.metrics.extra.duration = total;
-        this.metrics.extra.currentTime = current;
-        this.metrics.extra.watchedPercentage = (current / total) * 100;
-        if (l === 0) {
-            this.metrics.extra.watchHistory.push([current, current]);
-        }
-        else {
-            this.metrics.extra.watchHistory[l - 1][1] = current;
-        }
-        if (this.metrics.extra.bitratesHistory.length > 0) {
-            const lastBitrate = this.metrics.extra.bitratesHistory[this.metrics.extra.bitratesHistory.length - 1];
-            if (!lastBitrate.end) {
-                lastBitrate.time = this._now() - lastBitrate.start;
-            }
-        }
-        this._onCompletion();
-    }
-    onContainerUpdateWhilePlaying() {
-        if (this.container.playback.isPlaying()) {
-            this._stop('watch');
-            this.start('watch');
-        }
-    }
-    onBuffering() {
-        this._inc('buffering');
-        this.start('buffering');
-        this.listenToOnce(this.container, Events$1.CONTAINER_STATE_BUFFERFULL, this.onBufferfull);
-    }
-    onBufferfull() {
-        this._stop('buffering');
-        this.listenToOnce(this.container, Events$1.CONTAINER_STATE_BUFFERING, this.onBuffering);
-    }
-    onProgress(progress) {
-        this.metrics.extra.buffersize = progress.current * 1000;
-    }
-    _newMetrics() {
-        this.metrics = newMetrics$1();
-    }
-    _onCompletion() {
-        const currentPercentage = this.metrics.extra.watchedPercentage;
-        const allPercentages = this.completion.watch;
-        const isCalled = this.completion.calls.indexOf(currentPercentage) !== -1;
-        if (allPercentages.indexOf(currentPercentage) !== -1 && !isCalled) {
-            Log.info(this.name + ' PERCENTAGE_EVENT: ' + currentPercentage);
-            this.completion.calls.push(currentPercentage);
-            this.trigger(ClapprStatsEvents.PERCENTAGE_EVENT, currentPercentage);
-        }
-    }
-    _buildReport() {
-        this._stop('session');
-        this.start('session');
-        this.metrics.extra.playbackName = this._playbackName;
-        this.metrics.extra.playbackType = this._playbackType;
-        this._calculateBitrates();
-        this._calculatePercentages();
-        this._fetchFPS();
-        this._measureLatency();
-        this._measureBandwidth();
-        this._onReport(this.metrics);
-        this.trigger(ClapprStatsEvents.REPORT_EVENT, structuredClone(this.metrics));
-    }
-    _fetchFPS() {
-        // flashls ??? - hls.droppedFramesl hls.stream.bufferLength (seconds)
-        // hls ??? (use the same?)
-        const fetchFPS = {
-            'html5_video': this._html5FetchFPS,
-            'hls': this._html5FetchFPS,
-            'dash_shaka_playback': this._html5FetchFPS
-        };
-        if (this._playbackName in fetchFPS) {
-            fetchFPS[this._playbackName].call(this);
-        }
-    }
-    _calculateBitrates() {
-        const { bitratesHistory } = this.metrics.extra;
-        if (bitratesHistory.length === 0) {
-            return;
-        }
-        let totalTime = 0;
-        let weightedTotal = 0;
-        for (const { bitrate, time = 0 } of bitratesHistory) {
-            totalTime += time;
-            weightedTotal += bitrate * time;
-        }
-        this.metrics.extra.bitrateWeightedMean = weightedTotal / totalTime;
-        this.metrics.extra.bitrateMostUsed = bitratesHistory.reduce((mostUsed, current) => (current.time || 0) > (mostUsed.time || 0) ? current : mostUsed, { time: 0, bitrate: 0, start: 0, end: 0 }).bitrate;
-    }
-    _calculatePercentages() {
-        if (this.metrics.extra.duration > 0) {
-            this.metrics.extra.bufferingPercentage = (this.metrics.timers.buffering / this.metrics.extra.duration) * 100;
-        }
-    }
-    _html5FetchFPS() {
-        const videoTag = this.container.playback.el;
-        const getFirstValidValue = (...args) => args.find(val => val !== undefined);
-        const decodedFrames = getFirstValidValue(videoTag.webkitDecodedFrameCount, videoTag.mozDecodedFrames, 0);
-        const droppedFrames = getFirstValidValue(videoTag.webkitDroppedFrameCount, videoTag.mozParsedFrames && videoTag.mozDecodedFrames ? videoTag.mozParsedFrames - videoTag.mozDecodedFrames : 0, 0);
-        const decodedFramesLastTime = decodedFrames - (this.lastDecodedFramesCount || 0);
-        this.metrics.counters.decodedFrames = decodedFrames;
-        this.metrics.counters.droppedFrames = droppedFrames;
-        this.metrics.counters.fps = decodedFramesLastTime / (this.runEach / 1000);
-        this.lastDecodedFramesCount = decodedFrames;
-    }
-    // originally from https://www.smashingmagazine.com/2011/11/analyzing-network-characteristics-using-javascript-and-the-dom-part-1/
-    _measureLatency() {
-        if (this.uriToMeasureLatency) {
-            const t = [];
-            const n = 2;
-            let rtt;
-            const ld = () => {
-                t.push(this._now());
-                if (t.length > n) {
-                    done();
-                }
-                else {
-                    const img = new Image;
-                    img.onload = ld;
-                    img.src = this.uriToMeasureLatency + '?' + Math.random()
-                        + '=' + this._now();
-                }
-            };
-            const done = () => {
-                rtt = t[2] - t[1];
-                this.metrics.timers.latency = rtt;
-            };
-            ld();
-        }
-    }
-    // originally from https://www.smashingmagazine.com/2011/11/analyzing-network-characteristics-using-javascript-and-the-dom-part-1/
-    _measureBandwidth() {
-        if (this.urisToMeasureBandwidth && (this.bwMeasureCount % this.runBandwidthTestEvery === 0)) {
-            let i = 0;
-            const ld = (e) => {
-                if (i > 0) {
-                    const prev = this.urisToMeasureBandwidth[i - 1];
-                    prev.end = this._now();
-                    if (prev.timer !== null) {
-                        clearTimeout(prev.timer);
-                    }
-                }
-                if (i >= this.urisToMeasureBandwidth.length || (i > 0 && this.urisToMeasureBandwidth[i - 1].expired)) {
-                    assert(e, 'incorrect invocation in _measureBandwidth');
-                    done(e);
-                }
-                else {
-                    const xhr = new XMLHttpRequest();
-                    xhr.open('GET', this.urisToMeasureBandwidth[i].url, true);
-                    xhr.responseType = 'arraybuffer';
-                    xhr.onload = xhr.onabort = ld;
-                    this.urisToMeasureBandwidth[i].start = this._now();
-                    this.urisToMeasureBandwidth[i].timer = setTimeout((j) => {
-                        this.urisToMeasureBandwidth[j].expired = true;
-                        xhr.abort();
-                    }, this.urisToMeasureBandwidth[i].timeout, i);
-                    xhr.send();
-                }
-                i++;
-            };
-            const done = (e) => {
-                const timeSpent = (this.urisToMeasureBandwidth[i - 1].end - this.urisToMeasureBandwidth[i - 1].start) / 1000;
-                const bandwidthBps = (e.loaded * 8) / timeSpent;
-                this.metrics.extra.bandwidth = bandwidthBps;
-                this.urisToMeasureBandwidth.forEach((x) => {
-                    x.start = 0;
-                    x.end = 0;
-                    x.expired = false;
-                    if (x.timer !== null) {
-                        clearTimeout(x.timer);
-                        x.timer = null;
-                    }
-                });
-            };
-            ld();
-        }
-        this.bwMeasureCount++;
-    }
-}
-// ClapprStats.REPORT_EVENT = 'clappr:stats:report';
-// ClapprStats.PERCENTAGE_EVENT = 'clappr:stats:percentage';
-
 // This work is based on the original work of the following authors:
 // Copyright 2014 Globo.com Player authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -52404,4 +52326,4 @@ class VolumeFade extends UICorePlugin {
     }
 }
 
-export { AudioTracks as AudioSelector, AudioTracks, BigMuteButton, BottomGear, ClapprNerdStats, ClapprStats, ClickToPause, Clips, ClosedCaptions, ContextMenu, DvrControls, ErrorScreen, Favicon, GearEvents, GoogleAnalytics, QualityLevels as LevelSelector, LogTracer, Logger, Logo, MediaControl, MultiCamera, PictureInPicture, PlaybackErrorCode, PlaybackRate, Player, PlayerEvent, Poster, QualityLevels, SeekTime, SentryTracer, Share, SkipTime, SourceController, SpinnerThreeBounce as Spinner, SpinnerEvents, SpinnerThreeBounce, ClosedCaptions as Subtitles, Telemetry, TelemetryEvent, Thumbnails, VolumeFade, VolumeFadeEvents, reportError, setTracer, trace, version };
+export { AudioTracks as AudioSelector, AudioTracks, BigMuteButton, BottomGear, NerdStats as ClapprNerdStats, ClapprStats, ClickToPause, Clips, ClosedCaptions, ContextMenu, DvrControls, ErrorScreen, Favicon, GearEvents, GoogleAnalytics, QualityLevels as LevelSelector, LogTracer, Logger, Logo, MediaControl, MultiCamera, NerdStats, PictureInPicture, PlaybackErrorCode, PlaybackRate, Player, PlayerEvent, Poster, QualityLevels, SeekTime, SentryTracer, Share, SkipTime, SourceController, SpinnerThreeBounce as Spinner, SpinnerEvents, SpinnerThreeBounce, ClosedCaptions as Subtitles, Telemetry, TelemetryEvent, Thumbnails, VolumeFade, VolumeFadeEvents, reportError, setTracer, trace, version };