rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

package/dist/_esm5.processed/core/api/playback_observer.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,20 +14,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../config";
-import log from "../../log";
-import getMonotonicTimeStamp from "../../utils/monotonic_timestamp";
-import noop from "../../utils/noop";
-import objectAssign from "../../utils/object_assign";
-import { getBufferedTimeRange } from "../../utils/ranges";
-import SharedReference from "../../utils/reference";
-import TaskCanceller from "../../utils/task_canceller";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../config");
+const log_1 = require("../../log");
+const monotonic_timestamp_1 = require("../../utils/monotonic_timestamp");
+const noop_1 = require("../../utils/noop");
+const object_assign_1 = require("../../utils/object_assign");
+const ranges_1 = require("../../utils/ranges");
+const reference_1 = require("../../utils/reference");
+const task_canceller_1 = require("../../utils/task_canceller");
 /**
  * HTMLMediaElement Events for which playback observations are calculated and
  * emitted.
  * @type {Array.<string>}
  */
-var SCANNED_MEDIA_ELEMENTS_EVENTS = ["canplay",
+const SCANNED_MEDIA_ELEMENTS_EVENTS = ["canplay",
     "ended",
     "play",
     "pause",
@@ -47,7 +49,7 @@ var SCANNED_MEDIA_ELEMENTS_EVENTS = ["canplay",
  *
  * @class {PlaybackObserver}
  */
-var PlaybackObserver = /** @class */ (function () {
+class PlaybackObserver {
     /**
      * Create a new `PlaybackObserver`, which allows to produce new "playback
      * observations" on various media events and intervals.
@@ -58,12 +60,12 @@ var PlaybackObserver = /** @class */ (function () {
      * @param {HTMLMediaElement} mediaElement
      * @param {Object} options
      */
-    function PlaybackObserver(mediaElement, options) {
+    constructor(mediaElement, options) {
         this._internalSeeksIncoming = [];
         this._mediaElement = mediaElement;
         this._withMediaSource = options.withMediaSource;
         this._lowLatencyMode = options.lowLatencyMode;
-        this._canceller = new TaskCanceller();
+        this._canceller = new task_canceller_1.default();
         this._observationRef = this._createSharedReference();
     }
     /**
@@ -75,24 +77,24 @@ var PlaybackObserver = /** @class */ (function () {
      * Note that it is important to call stop once the `PlaybackObserver` is no
      * more needed to avoid unnecessarily leaking resources.
      */
-    PlaybackObserver.prototype.stop = function () {
+    stop() {
         this._canceller.cancel();
-    };
+    }
     /**
      * Returns the current position advertised by the `HTMLMediaElement`, in
      * seconds.
      * @returns {number}
      */
-    PlaybackObserver.prototype.getCurrentTime = function () {
+    getCurrentTime() {
         return this._mediaElement.currentTime;
-    };
+    }
     /**
      * Returns the current playback rate advertised by the `HTMLMediaElement`.
      * @returns {number}
      */
-    PlaybackObserver.prototype.getPlaybackRate = function () {
+    getPlaybackRate() {
         return this._mediaElement.playbackRate;
-    };
+    }
     /**
      * Returns the current `paused` status advertised by the `HTMLMediaElement`.
      *
@@ -100,9 +102,9 @@ var PlaybackObserver = /** @class */ (function () {
      * to be sure you're using the current value.
      * @returns {boolean}
      */
-    PlaybackObserver.prototype.getIsPaused = function () {
+    getIsPaused() {
         return this._mediaElement.paused;
-    };
+    }
     /**
      * Update the current position (seek) on the `HTMLMediaElement`, by giving a
      * new position in seconds.
@@ -113,25 +115,25 @@ var PlaybackObserver = /** @class */ (function () {
      * e.g. the user).
      * @param {number} time
      */
-    PlaybackObserver.prototype.setCurrentTime = function (time) {
+    setCurrentTime(time) {
         this._internalSeeksIncoming.push(time);
-        log.info("API: Seeking internally", time);
+        log_1.default.info("API: Seeking internally", time);
         this._mediaElement.currentTime = time;
-    };
+    }
     /**
      * Update the playback rate of the `HTMLMediaElement`.
      * @param {number} playbackRate
      */
-    PlaybackObserver.prototype.setPlaybackRate = function (playbackRate) {
+    setPlaybackRate(playbackRate) {
         this._mediaElement.playbackRate = playbackRate;
-    };
+    }
     /**
      * Returns the current `readyState` advertised by the `HTMLMediaElement`.
      * @returns {number}
      */
-    PlaybackObserver.prototype.getReadyState = function () {
+    getReadyState() {
         return this._mediaElement.readyState;
-    };
+    }
     /**
      * Returns an `IReadOnlySharedReference` storing the last playback observation
      * produced by the `PlaybackObserver` and updated each time a new one is
@@ -142,9 +144,9 @@ var PlaybackObserver = /** @class */ (function () {
      *
      * @returns {Object}
      */
-    PlaybackObserver.prototype.getReference = function () {
+    getReference() {
         return this._observationRef;
-    };
+    }
     /**
      * Register a callback so it regularly receives playback observations.
      * @param {Function} cb
@@ -154,16 +156,16 @@ var PlaybackObserver = /** @class */ (function () {
      *   - `clearSignal`: If set, the callback will be unregistered when this
      *     CancellationSignal emits.
      */
-    PlaybackObserver.prototype.listen = function (cb, options) {
+    listen(cb, options) {
         var _a;
         if (this._canceller.isUsed() || ((_a = options === null || options === void 0 ? void 0 : options.clearSignal) === null || _a === void 0 ? void 0 : _a.isCancelled()) === true) {
-            return noop;
+            return noop_1.default;
         }
         this._observationRef.onUpdate(cb, {
             clearSignal: options === null || options === void 0 ? void 0 : options.clearSignal,
             emitCurrentValue: options === null || options === void 0 ? void 0 : options.includeLastObservation,
         });
-    };
+    }
     /**
      * Generate a new playback observer which can listen to other
      * properties and which can only be accessed to read observations (e.g.
@@ -178,31 +180,30 @@ var PlaybackObserver = /** @class */ (function () {
      * @param {Function} transform
      * @returns {Object}
      */
-    PlaybackObserver.prototype.deriveReadOnlyObserver = function (transform) {
+    deriveReadOnlyObserver(transform) {
         return generateReadOnlyObserver(this, transform, this._canceller.signal);
-    };
+    }
     /**
      * Creates the `IReadOnlySharedReference` that will generate playback
      * observations.
      * @returns {Object}
      */
-    PlaybackObserver.prototype._createSharedReference = function () {
-        var _this = this;
+    _createSharedReference() {
         if (this._observationRef !== undefined) {
             return this._observationRef;
         }
-        var lastObservation;
-        var _a = config.getCurrent(), SAMPLING_INTERVAL_MEDIASOURCE = _a.SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY = _a.SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE = _a.SAMPLING_INTERVAL_NO_MEDIASOURCE;
-        var getCurrentObservation = function (event) {
-            var tmpEvt = event;
-            var startedInternalSeekTime;
-            if (tmpEvt === "seeking" && _this._internalSeeksIncoming.length > 0) {
+        let lastObservation;
+        const { SAMPLING_INTERVAL_MEDIASOURCE, SAMPLING_INTERVAL_LOW_LATENCY, SAMPLING_INTERVAL_NO_MEDIASOURCE } = config_1.default.getCurrent();
+        const getCurrentObservation = (event) => {
+            let tmpEvt = event;
+            let startedInternalSeekTime;
+            if (tmpEvt === "seeking" && this._internalSeeksIncoming.length > 0) {
                 tmpEvt = "internal-seeking";
-                startedInternalSeekTime = _this._internalSeeksIncoming.shift();
+                startedInternalSeekTime = this._internalSeeksIncoming.shift();
             }
-            var _lastObservation = lastObservation !== null && lastObservation !== void 0 ? lastObservation : _this._generateInitialObservation();
-            var mediaTimings = getMediaInfos(_this._mediaElement, tmpEvt, _this._withMediaSource);
-            var pendingInternalSeek = null;
+            const _lastObservation = lastObservation !== null && lastObservation !== void 0 ? lastObservation : this._generateInitialObservation();
+            const mediaTimings = getMediaInfos(this._mediaElement, tmpEvt, this._withMediaSource);
+            let pendingInternalSeek = null;
             if (mediaTimings.seeking) {
                 if (typeof startedInternalSeekTime === "number") {
                     pendingInternalSeek = startedInternalSeekTime;
@@ -211,43 +212,44 @@ var PlaybackObserver = /** @class */ (function () {
                     pendingInternalSeek = _lastObservation.pendingInternalSeek;
                 }
             }
-            var rebufferingStatus = getRebufferingStatus(_lastObservation, mediaTimings, { lowLatencyMode: _this._lowLatencyMode,
-                withMediaSource: _this._withMediaSource });
-            var freezingStatus = getFreezingStatus(_lastObservation, mediaTimings);
-            var timings = objectAssign({}, { rebuffering: rebufferingStatus,
-                freezing: freezingStatus, pendingInternalSeek: pendingInternalSeek }, mediaTimings);
-            if (log.hasLevel("DEBUG")) {
-                log.debug("API: current media element state tick", "event", timings.event, "position", timings.position, "seeking", timings.seeking, "internalSeek", timings.pendingInternalSeek, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
+            const rebufferingStatus = getRebufferingStatus(_lastObservation, mediaTimings, { lowLatencyMode: this._lowLatencyMode,
+                withMediaSource: this._withMediaSource });
+            const freezingStatus = getFreezingStatus(_lastObservation, mediaTimings);
+            const timings = (0, object_assign_1.default)({}, { rebuffering: rebufferingStatus,
+                freezing: freezingStatus,
+                pendingInternalSeek }, mediaTimings);
+            if (log_1.default.hasLevel("DEBUG")) {
+                log_1.default.debug("API: current media element state tick", "event", timings.event, "position", timings.position, "seeking", timings.seeking, "internalSeek", timings.pendingInternalSeek, "rebuffering", timings.rebuffering !== null, "freezing", timings.freezing !== null, "ended", timings.ended, "paused", timings.paused, "playbackRate", timings.playbackRate, "readyState", timings.readyState);
             }
             return timings;
         };
-        var returnedSharedReference = new SharedReference(getCurrentObservation("init"), this._canceller.signal);
-        var generateObservationForEvent = function (event) {
-            var newObservation = getCurrentObservation(event);
-            if (log.hasLevel("DEBUG")) {
-                log.debug("API: current playback timeline:\n" +
-                    prettyPrintBuffered(newObservation.buffered, newObservation.position), "\n".concat(event));
+        const returnedSharedReference = new reference_1.default(getCurrentObservation("init"), this._canceller.signal);
+        const generateObservationForEvent = (event) => {
+            const newObservation = getCurrentObservation(event);
+            if (log_1.default.hasLevel("DEBUG")) {
+                log_1.default.debug("API: current playback timeline:\n" +
+                    prettyPrintBuffered(newObservation.buffered, newObservation.position), `\n${event}`);
             }
             lastObservation = newObservation;
             returnedSharedReference.setValue(newObservation);
         };
-        var interval = this._lowLatencyMode ? SAMPLING_INTERVAL_LOW_LATENCY :
+        const interval = this._lowLatencyMode ? SAMPLING_INTERVAL_LOW_LATENCY :
             this._withMediaSource ? SAMPLING_INTERVAL_MEDIASOURCE :
                 SAMPLING_INTERVAL_NO_MEDIASOURCE;
-        var intervalId = setInterval(onInterval, interval);
-        var removeEventListeners = SCANNED_MEDIA_ELEMENTS_EVENTS.map(function (eventName) {
-            _this._mediaElement.addEventListener(eventName, onMediaEvent);
+        let intervalId = setInterval(onInterval, interval);
+        const removeEventListeners = SCANNED_MEDIA_ELEMENTS_EVENTS.map((eventName) => {
+            this._mediaElement.addEventListener(eventName, onMediaEvent);
             function onMediaEvent() {
                 restartInterval();
                 generateObservationForEvent(eventName);
             }
-            return function () {
-                _this._mediaElement.removeEventListener(eventName, onMediaEvent);
+            return () => {
+                this._mediaElement.removeEventListener(eventName, onMediaEvent);
             };
         });
-        this._canceller.signal.register(function () {
+        this._canceller.signal.register(() => {
             clearInterval(intervalId);
-            removeEventListeners.forEach(function (cb) { return cb(); });
+            removeEventListeners.forEach(cb => cb());
             returnedSharedReference.finish();
         });
         return returnedSharedReference;
@@ -258,15 +260,14 @@ var PlaybackObserver = /** @class */ (function () {
             clearInterval(intervalId);
             intervalId = setInterval(onInterval, interval);
         }
-    };
-    PlaybackObserver.prototype._generateInitialObservation = function () {
-        return objectAssign(getMediaInfos(this._mediaElement, "init", this._withMediaSource), { rebuffering: null,
+    }
+    _generateInitialObservation() {
+        return (0, object_assign_1.default)(getMediaInfos(this._mediaElement, "init", this._withMediaSource), { rebuffering: null,
             freezing: null,
             pendingInternalSeek: null });
-    };
-    return PlaybackObserver;
-}());
-export default PlaybackObserver;
+    }
+}
+exports.default = PlaybackObserver;
 /**
  * Returns the amount of time in seconds the buffer should have ahead of the
  * current position before resuming playback. Based on the infos of the
@@ -282,9 +283,9 @@ function getRebufferingEndGap(rebufferingStatus, lowLatencyMode) {
     if (rebufferingStatus === null) {
         return 0;
     }
-    var suffix = lowLatencyMode ? "LOW_LATENCY" :
+    const suffix = lowLatencyMode ? "LOW_LATENCY" :
         "DEFAULT";
-    var _a = config.getCurrent(), RESUME_GAP_AFTER_SEEKING = _a.RESUME_GAP_AFTER_SEEKING, RESUME_GAP_AFTER_NOT_ENOUGH_DATA = _a.RESUME_GAP_AFTER_NOT_ENOUGH_DATA, RESUME_GAP_AFTER_BUFFERING = _a.RESUME_GAP_AFTER_BUFFERING;
+    const { RESUME_GAP_AFTER_SEEKING, RESUME_GAP_AFTER_NOT_ENOUGH_DATA, RESUME_GAP_AFTER_BUFFERING } = config_1.default.getCurrent();
     switch (rebufferingStatus.reason) {
         case "seeking":
             return RESUME_GAP_AFTER_SEEKING[suffix];
@@ -301,8 +302,8 @@ function getRebufferingEndGap(rebufferingStatus, lowLatencyMode) {
  * @returns {Boolean}
  */
 function hasLoadedUntilTheEnd(currentTime, currentRange, ended, duration, lowLatencyMode) {
-    var REBUFFERING_GAP = config.getCurrent().REBUFFERING_GAP;
-    var suffix = lowLatencyMode ? "LOW_LATENCY" :
+    const { REBUFFERING_GAP } = config_1.default.getCurrent();
+    const suffix = lowLatencyMode ? "LOW_LATENCY" :
         "DEFAULT";
     if (currentRange === undefined) {
         return ended && Math.abs(duration - currentTime) <= REBUFFERING_GAP[suffix];
@@ -317,9 +318,9 @@ function hasLoadedUntilTheEnd(currentTime, currentRange, ended, duration, lowLat
  * @returns {Object}
  */
 function getMediaInfos(mediaElement, event, withMediaSource) {
-    var buffered = mediaElement.buffered, currentTime = mediaElement.currentTime, duration = mediaElement.duration, ended = mediaElement.ended, paused = mediaElement.paused, playbackRate = mediaElement.playbackRate, readyState = mediaElement.readyState, seeking = mediaElement.seeking;
-    var currentRange;
-    var bufferGap;
+    const { buffered, currentTime, duration, ended, paused, playbackRate, readyState, seeking } = mediaElement;
+    let currentRange;
+    let bufferGap;
     if (!withMediaSource && buffered.length === 0 && readyState >= 3) {
         // Sometimes `buffered` stay empty for directfile contents yet we are able
         // to play. This seems to be linked to browser-side issues but has been
@@ -329,13 +330,23 @@ function getMediaInfos(mediaElement, event, withMediaSource) {
         bufferGap = undefined;
     }
     else {
-        currentRange = getBufferedTimeRange(buffered, currentTime);
+        currentRange = (0, ranges_1.getBufferedTimeRange)(buffered, currentTime);
         bufferGap = currentRange !== null ? currentRange.end - currentTime :
             // TODO null/0 would probably be
             // more appropriate
             Infinity;
     }
-    return { bufferGap: bufferGap, buffered: buffered, currentRange: currentRange, position: currentTime, duration: duration, ended: ended, paused: paused, playbackRate: playbackRate, readyState: readyState, seeking: seeking, event: event };
+    return { bufferGap,
+        buffered,
+        currentRange,
+        position: currentTime,
+        duration,
+        ended,
+        paused,
+        playbackRate,
+        readyState,
+        seeking,
+        event };
 }
 /**
  * Infer rebuffering status of the media based on:
@@ -349,20 +360,19 @@ function getMediaInfos(mediaElement, event, withMediaSource) {
  * @param {Object} options
  * @returns {Object|null}
  */
-function getRebufferingStatus(prevObservation, currentInfo, _a) {
-    var withMediaSource = _a.withMediaSource, lowLatencyMode = _a.lowLatencyMode;
-    var REBUFFERING_GAP = config.getCurrent().REBUFFERING_GAP;
-    var currentEvt = currentInfo.event, currentTime = currentInfo.position, bufferGap = currentInfo.bufferGap, currentRange = currentInfo.currentRange, duration = currentInfo.duration, paused = currentInfo.paused, readyState = currentInfo.readyState, ended = currentInfo.ended;
-    var prevRebuffering = prevObservation.rebuffering, prevEvt = prevObservation.event, prevTime = prevObservation.position;
-    var fullyLoaded = hasLoadedUntilTheEnd(currentTime, currentRange, ended, duration, lowLatencyMode);
-    var canSwitchToRebuffering = (readyState >= 1 &&
+function getRebufferingStatus(prevObservation, currentInfo, { withMediaSource, lowLatencyMode }) {
+    const { REBUFFERING_GAP } = config_1.default.getCurrent();
+    const { event: currentEvt, position: currentTime, bufferGap, currentRange, duration, paused, readyState, ended } = currentInfo;
+    const { rebuffering: prevRebuffering, event: prevEvt, position: prevTime } = prevObservation;
+    const fullyLoaded = hasLoadedUntilTheEnd(currentTime, currentRange, ended, duration, lowLatencyMode);
+    const canSwitchToRebuffering = (readyState >= 1 &&
         currentEvt !== "loadedmetadata" &&
         prevRebuffering === null &&
         !(fullyLoaded || ended));
-    var rebufferEndPosition = null;
-    var shouldRebuffer;
-    var shouldStopRebuffer;
-    var rebufferGap = lowLatencyMode ? REBUFFERING_GAP.LOW_LATENCY :
+    let rebufferEndPosition = null;
+    let shouldRebuffer;
+    let shouldStopRebuffer;
+    const rebufferGap = lowLatencyMode ? REBUFFERING_GAP.LOW_LATENCY :
         REBUFFERING_GAP.DEFAULT;
     if (withMediaSource) {
         if (canSwitchToRebuffering) {
@@ -382,7 +392,7 @@ function getRebufferingStatus(prevObservation, currentInfo, _a) {
             }
         }
         else if (prevRebuffering !== null) {
-            var resumeGap = getRebufferingEndGap(prevRebuffering, lowLatencyMode);
+            const resumeGap = getRebufferingEndGap(prevRebuffering, lowLatencyMode);
             if (shouldRebuffer !== true && prevRebuffering !== null && readyState > 1 &&
                 (fullyLoaded || ended ||
                     (bufferGap !== undefined && isFinite(bufferGap) && bufferGap > resumeGap)) ||
@@ -425,7 +435,7 @@ function getRebufferingStatus(prevObservation, currentInfo, _a) {
         return null;
     }
     else if (shouldRebuffer === true || prevRebuffering !== null) {
-        var reason = void 0;
+        let reason;
         if (currentEvt === "seeking" ||
             prevRebuffering !== null && prevRebuffering.reason === "seeking") {
             reason = "seeking";
@@ -444,7 +454,8 @@ function getRebufferingStatus(prevObservation, currentInfo, _a) {
                 timestamp: prevRebuffering.timestamp,
                 position: rebufferEndPosition };
         }
-        return { reason: reason, timestamp: getMonotonicTimeStamp(),
+        return { reason,
+            timestamp: (0, monotonic_timestamp_1.default)(),
             position: rebufferEndPosition };
     }
     return null;
@@ -460,7 +471,7 @@ function getRebufferingStatus(prevObservation, currentInfo, _a) {
  * @returns {Object|null}
  */
 function getFreezingStatus(prevObservation, currentInfo) {
-    var MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING = config.getCurrent().MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING;
+    const { MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING } = config_1.default.getCurrent();
     if (prevObservation.freezing) {
         if (currentInfo.ended ||
             currentInfo.paused ||
@@ -479,7 +490,7 @@ function getFreezingStatus(prevObservation, currentInfo) {
         currentInfo.readyState >= 1 &&
         currentInfo.playbackRate !== 0 &&
         currentInfo.position === prevObservation.position ?
-        { timestamp: getMonotonicTimeStamp() } :
+        { timestamp: (0, monotonic_timestamp_1.default)() } :
         null;
 }
 /**
@@ -510,33 +521,33 @@ function getFreezingStatus(prevObservation, currentInfo) {
  * @returns {string}
  */
 function prettyPrintBuffered(buffered, currentTime) {
-    var str = "";
-    var currentTimeStr = "";
-    for (var i = 0; i < buffered.length; i++) {
-        var start = buffered.start(i);
-        var end = buffered.end(i);
-        var fixedStart = start.toFixed(2);
-        var fixedEnd = end.toFixed(2);
-        var fixedDuration = (end - start).toFixed(2);
-        var newIntervalStr = "".concat(fixedStart, "|==").concat(fixedDuration, "==|").concat(fixedEnd);
+    let str = "";
+    let currentTimeStr = "";
+    for (let i = 0; i < buffered.length; i++) {
+        const start = buffered.start(i);
+        const end = buffered.end(i);
+        const fixedStart = start.toFixed(2);
+        const fixedEnd = end.toFixed(2);
+        const fixedDuration = (end - start).toFixed(2);
+        const newIntervalStr = `${fixedStart}|==${fixedDuration}==|${fixedEnd}`;
         str += newIntervalStr;
         if (currentTimeStr.length === 0 && end > currentTime) {
-            var padBefore = str.length - Math.floor(newIntervalStr.length / 2);
-            currentTimeStr = " ".repeat(padBefore) + "^".concat(currentTime);
+            const padBefore = str.length - Math.floor(newIntervalStr.length / 2);
+            currentTimeStr = " ".repeat(padBefore) + `^${currentTime}`;
         }
         if (i < buffered.length - 1) {
-            var nextStart = buffered.start(i + 1);
-            var fixedDiff = (nextStart - end).toFixed(2);
-            var holeStr = " ~".concat(fixedDiff, "~ ");
+            const nextStart = buffered.start(i + 1);
+            const fixedDiff = (nextStart - end).toFixed(2);
+            const holeStr = ` ~${fixedDiff}~ `;
             str += holeStr;
             if (currentTimeStr.length === 0 && currentTime < nextStart) {
-                var padBefore = str.length - Math.floor(holeStr.length / 2);
-                currentTimeStr = " ".repeat(padBefore) + "^".concat(currentTime);
+                const padBefore = str.length - Math.floor(holeStr.length / 2);
+                currentTimeStr = " ".repeat(padBefore) + `^${currentTime}`;
             }
         }
     }
     if (currentTimeStr.length === 0) {
-        currentTimeStr = " ".repeat(str.length) + "^".concat(currentTime);
+        currentTimeStr = " ".repeat(str.length) + `^${currentTime}`;
     }
     return str + "\n" + currentTimeStr;
 }
@@ -548,24 +559,24 @@ function prettyPrintBuffered(buffered, currentTime) {
  * @returns {Object}
  */
 function generateReadOnlyObserver(src, transform, cancellationSignal) {
-    var mappedRef = transform(src.getReference(), cancellationSignal);
+    const mappedRef = transform(src.getReference(), cancellationSignal);
     return {
-        getCurrentTime: function () {
+        getCurrentTime() {
             return src.getCurrentTime();
         },
-        getReadyState: function () {
+        getReadyState() {
             return src.getReadyState();
         },
-        getPlaybackRate: function () {
+        getPlaybackRate() {
             return src.getPlaybackRate();
         },
-        getIsPaused: function () {
+        getIsPaused() {
             return src.getIsPaused();
         },
-        getReference: function () {
+        getReference() {
             return mappedRef;
         },
-        listen: function (cb, options) {
+        listen(cb, options) {
             var _a;
             if (cancellationSignal.isCancelled() ||
                 ((_a = options === null || options === void 0 ? void 0 : options.clearSignal) === null || _a === void 0 ? void 0 : _a.isCancelled()) === true) {
@@ -576,7 +587,7 @@ function generateReadOnlyObserver(src, transform, cancellationSignal) {
                 emitCurrentValue: options === null || options === void 0 ? void 0 : options.includeLastObservation,
             });
         },
-        deriveReadOnlyObserver: function (newTransformFn) {
+        deriveReadOnlyObserver(newTransformFn) {
             return generateReadOnlyObserver(this, newTransformFn, cancellationSignal);
         },
     };