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

package/dist/_esm5.processed/core/init/utils/rebuffering_controller.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,20 +13,33 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const is_seeking_approximate_1 = require("../../../compat/is_seeking_approximate");
-const config_1 = require("../../../config");
-const errors_1 = require("../../../errors");
-const log_1 = require("../../../log");
-const event_emitter_1 = require("../../../utils/event_emitter");
-const monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
-const ranges_1 = require("../../../utils/ranges");
-const task_canceller_1 = require("../../../utils/task_canceller");
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import isSeekingApproximate from "../../../compat/is_seeking_approximate";
+import config from "../../../config";
+import { MediaError } from "../../../errors";
+import log from "../../../log";
+import EventEmitter from "../../../utils/event_emitter";
+import { getNextRangeGap } from "../../../utils/ranges";
+import TaskCanceller from "../../../utils/task_canceller";
 /**
  * Work-around rounding errors with floating points by setting an acceptable,
  * very short, deviation when checking equalities.
  */
-const EPSILON = 1 / 60;
+var EPSILON = 1 / 60;
 /**
  * Monitor playback, trying to avoid stalling situation.
  * If stopping the player to build buffer is needed, temporarily set the
@@ -36,24 +48,27 @@ const EPSILON = 1 / 60;
  * Emit "stalled" then "unstalled" respectively when an unavoidable stall is
  * encountered and exited.
  */
-class RebufferingController extends event_emitter_1.default {
+var RebufferingController = /** @class */ (function (_super) {
+    __extends(RebufferingController, _super);
     /**
      * @param {object} playbackObserver - emit the current playback conditions.
      * @param {Object} manifest - The Manifest of the currently-played content.
      * @param {Object} speed - The last speed set by the user
      */
-    constructor(playbackObserver, manifest, segmentBuffersStore, speed) {
-        super();
-        this._playbackObserver = playbackObserver;
-        this._manifest = manifest;
-        this._segmentBuffersStore = segmentBuffersStore;
-        this._speed = speed;
-        this._discontinuitiesStore = [];
-        this._isStarted = false;
-        this._canceller = new task_canceller_1.default();
-        this._currentFreezeTimestamp = null;
+    function RebufferingController(playbackObserver, manifest, segmentBuffersStore, speed) {
+        var _this = _super.call(this) || this;
+        _this._playbackObserver = playbackObserver;
+        _this._manifest = manifest;
+        _this._segmentBuffersStore = segmentBuffersStore;
+        _this._speed = speed;
+        _this._discontinuitiesStore = [];
+        _this._isStarted = false;
+        _this._canceller = new TaskCanceller();
+        _this._currentFreezeTimestamp = null;
+        return _this;
     }
-    start() {
+    RebufferingController.prototype.start = function () {
+        var _this = this;
         if (this._isStarted) {
             return;
         }
@@ -72,7 +87,7 @@ class RebufferingController extends event_emitter_1.default {
          * seek after that). When browsers seek back to a position behind a
          * discontinuity, they are usually able to skip them without our help.
          */
-        let lastSeekingPosition;
+        var lastSeekingPosition;
         /**
          * In some conditions (see `lastSeekingPosition`), we might want to not
          * automatically seek over discontinuities because the browser might do it
@@ -82,39 +97,39 @@ class RebufferingController extends event_emitter_1.default {
          * This variable allows to store the timestamp at which a discontinuity began
          * to be ignored.
          */
-        let ignoredStallTimeStamp = null;
-        const playbackRateUpdater = new PlaybackRateUpdater(this._playbackObserver, this._speed);
-        this._canceller.signal.register(() => {
+        var ignoredStallTimeStamp = null;
+        var playbackRateUpdater = new PlaybackRateUpdater(this._playbackObserver, this._speed);
+        this._canceller.signal.register(function () {
             playbackRateUpdater.dispose();
         });
-        let prevFreezingState = null;
-        this._playbackObserver.listen((observation) => {
+        var prevFreezingState = null;
+        this._playbackObserver.listen(function (observation) {
             var _a;
-            const discontinuitiesStore = this._discontinuitiesStore;
-            const { buffered, position, readyState, rebuffering, freezing } = observation;
-            const { BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION } = config_1.default.getCurrent();
+            var discontinuitiesStore = _this._discontinuitiesStore;
+            var buffered = observation.buffered, position = observation.position, readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
+            var _b = config.getCurrent(), BUFFER_DISCONTINUITY_THRESHOLD = _b.BUFFER_DISCONTINUITY_THRESHOLD, FORCE_DISCONTINUITY_SEEK_DELAY = _b.FORCE_DISCONTINUITY_SEEK_DELAY, FREEZING_STALLED_DELAY = _b.FREEZING_STALLED_DELAY, UNFREEZING_SEEK_DELAY = _b.UNFREEZING_SEEK_DELAY, UNFREEZING_DELTA_POSITION = _b.UNFREEZING_DELTA_POSITION;
             if (!observation.seeking &&
-                is_seeking_approximate_1.default &&
+                isSeekingApproximate &&
                 ignoredStallTimeStamp === null &&
                 lastSeekingPosition !== null && observation.position < lastSeekingPosition) {
-                log_1.default.debug("Init: the device appeared to have seeked back by itself.");
-                const now = (0, monotonic_timestamp_1.default)();
+                log.debug("Init: the device appeared to have seeked back by itself.");
+                var now = performance.now();
                 ignoredStallTimeStamp = now;
             }
             lastSeekingPosition = observation.seeking ?
                 Math.max((_a = observation.pendingInternalSeek) !== null && _a !== void 0 ? _a : 0, observation.position) :
                 null;
-            if (this._checkDecipherabilityFreeze(observation)) {
+            if (_this._checkDecipherabilityFreeze(observation)) {
                 return;
             }
             if (freezing !== null) {
-                const now = (0, monotonic_timestamp_1.default)();
-                const referenceTimestamp = prevFreezingState === null ?
+                var now = performance.now();
+                var referenceTimestamp = prevFreezingState === null ?
                     freezing.timestamp :
                     prevFreezingState.attemptTimestamp;
                 if (now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
-                    log_1.default.warn("Init: trying to seek to un-freeze player");
-                    this._playbackObserver.setCurrentTime(this._playbackObserver.getCurrentTime() + UNFREEZING_DELTA_POSITION);
+                    log.warn("Init: trying to seek to un-freeze player");
+                    _this._playbackObserver.setCurrentTime(_this._playbackObserver.getCurrentTime() + UNFREEZING_DELTA_POSITION);
                     prevFreezingState = { attemptTimestamp: now };
                 }
                 if (now - freezing.timestamp > FREEZING_STALLED_DELAY) {
@@ -124,7 +139,7 @@ class RebufferingController extends event_emitter_1.default {
                     else {
                         playbackRateUpdater.startRebuffering();
                     }
-                    this.trigger("stalled", "freezing");
+                    _this.trigger("stalled", "freezing");
                     return;
                 }
             }
@@ -136,7 +151,7 @@ class RebufferingController extends event_emitter_1.default {
                 if (readyState === 1) {
                     // With a readyState set to 1, we should still not be able to play:
                     // Return that we're stalled
-                    let reason;
+                    var reason = void 0;
                     if (observation.seeking) {
                         reason = observation.pendingInternalSeek !== null ? "internal-seek" :
                             "seeking";
@@ -144,56 +159,56 @@ class RebufferingController extends event_emitter_1.default {
                     else {
                         reason = "not-ready";
                     }
-                    this.trigger("stalled", reason);
+                    _this.trigger("stalled", reason);
                     return;
                 }
-                this.trigger("unstalled", null);
+                _this.trigger("unstalled", null);
                 return;
             }
             // We want to separate a stall situation when a seek is due to a seek done
             // internally by the player to when its due to a regular user seek.
-            const stalledReason = rebuffering.reason === "seeking" &&
+            var stalledReason = rebuffering.reason === "seeking" &&
                 observation.pendingInternalSeek !== null ?
                 "internal-seek" :
                 rebuffering.reason;
             if (ignoredStallTimeStamp !== null) {
-                const now = (0, monotonic_timestamp_1.default)();
+                var now = performance.now();
                 if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
                     playbackRateUpdater.stopRebuffering();
-                    log_1.default.debug("Init: letting the device get out of a stall by itself");
-                    this.trigger("stalled", stalledReason);
+                    log.debug("Init: letting the device get out of a stall by itself");
+                    _this.trigger("stalled", stalledReason);
                     return;
                 }
                 else {
-                    log_1.default.warn("Init: ignored stall for too long, considering it", now - ignoredStallTimeStamp);
+                    log.warn("Init: ignored stall for too long, considering it", now - ignoredStallTimeStamp);
                 }
             }
             ignoredStallTimeStamp = null;
             playbackRateUpdater.startRebuffering();
-            if (this._manifest === null) {
-                this.trigger("stalled", stalledReason);
+            if (_this._manifest === null) {
+                _this.trigger("stalled", stalledReason);
                 return;
             }
             /** Position at which data is awaited. */
-            const { position: stalledPosition } = rebuffering;
+            var stalledPosition = rebuffering.position;
             if (stalledPosition !== null &&
                 stalledPosition !== undefined &&
-                this._speed.getValue() > 0) {
-                const skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore, this._manifest, stalledPosition);
+                _this._speed.getValue() > 0) {
+                var skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore, _this._manifest, stalledPosition);
                 if (skippableDiscontinuity !== null) {
-                    const realSeekTime = skippableDiscontinuity + 0.001;
-                    if (realSeekTime <= this._playbackObserver.getCurrentTime()) {
-                        log_1.default.info("Init: position to seek already reached, no seeking", this._playbackObserver.getCurrentTime(), realSeekTime);
+                    var realSeekTime = skippableDiscontinuity + 0.001;
+                    if (realSeekTime <= _this._playbackObserver.getCurrentTime()) {
+                        log.info("Init: position to seek already reached, no seeking", _this._playbackObserver.getCurrentTime(), realSeekTime);
                     }
                     else {
-                        log_1.default.warn("SA: skippable discontinuity found in the stream", position, realSeekTime);
-                        this._playbackObserver.setCurrentTime(realSeekTime);
-                        this.trigger("warning", generateDiscontinuityError(stalledPosition, realSeekTime));
+                        log.warn("SA: skippable discontinuity found in the stream", position, realSeekTime);
+                        _this._playbackObserver.setCurrentTime(realSeekTime);
+                        _this.trigger("warning", generateDiscontinuityError(stalledPosition, realSeekTime));
                         return;
                     }
                 }
             }
-            const freezePosition = stalledPosition !== null && stalledPosition !== void 0 ? stalledPosition : position;
+            var freezePosition = stalledPosition !== null && stalledPosition !== void 0 ? stalledPosition : position;
             // Is it a very short discontinuity in buffer ? -> Seek at the beginning of the
             //                                                 next range
             //
@@ -201,49 +216,49 @@ class RebufferingController extends event_emitter_1.default {
             // calculate a stalled state. This is useful for some
             // implementation that might drop an injected segment, or in
             // case of small discontinuity in the content.
-            const nextBufferRangeGap = (0, ranges_1.getNextBufferedTimeRangeGap)(buffered, freezePosition);
-            if (this._speed.getValue() > 0 &&
+            var nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
+            if (_this._speed.getValue() > 0 &&
                 nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
-                const seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
-                if (this._playbackObserver.getCurrentTime() < seekTo) {
-                    log_1.default.warn("Init: discontinuity encountered inferior to the threshold", freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
-                    this._playbackObserver.setCurrentTime(seekTo);
-                    this.trigger("warning", generateDiscontinuityError(freezePosition, seekTo));
+                var seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
+                if (_this._playbackObserver.getCurrentTime() < seekTo) {
+                    log.warn("Init: discontinuity encountered inferior to the threshold", freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
+                    _this._playbackObserver.setCurrentTime(seekTo);
+                    _this.trigger("warning", generateDiscontinuityError(freezePosition, seekTo));
                     return;
                 }
             }
             // Are we in a discontinuity between periods ? -> Seek at the beginning of the
             //                                                next period
-            for (let i = this._manifest.periods.length - 2; i >= 0; i--) {
-                const period = this._manifest.periods[i];
+            for (var i = _this._manifest.periods.length - 2; i >= 0; i--) {
+                var period = _this._manifest.periods[i];
                 if (period.end !== undefined && period.end <= freezePosition) {
-                    if (this._manifest.periods[i + 1].start > freezePosition &&
-                        this._manifest.periods[i + 1].start >
-                            this._playbackObserver.getCurrentTime()) {
-                        const nextPeriod = this._manifest.periods[i + 1];
-                        this._playbackObserver.setCurrentTime(nextPeriod.start);
-                        this.trigger("warning", generateDiscontinuityError(freezePosition, nextPeriod.start));
+                    if (_this._manifest.periods[i + 1].start > freezePosition &&
+                        _this._manifest.periods[i + 1].start >
+                            _this._playbackObserver.getCurrentTime()) {
+                        var nextPeriod = _this._manifest.periods[i + 1];
+                        _this._playbackObserver.setCurrentTime(nextPeriod.start);
+                        _this.trigger("warning", generateDiscontinuityError(freezePosition, nextPeriod.start));
                         return;
                     }
                     break;
                 }
             }
-            this.trigger("stalled", stalledReason);
+            _this.trigger("stalled", stalledReason);
         }, { includeLastObservation: true, clearSignal: this._canceller.signal });
-    }
+    };
     /**
      * Update information on an upcoming discontinuity for a given buffer type and
      * Period.
      * Each new update for the same Period and type overwrites the previous one.
      * @param {Object} evt
      */
-    updateDiscontinuityInfo(evt) {
+    RebufferingController.prototype.updateDiscontinuityInfo = function (evt) {
         if (!this._isStarted) {
             this.start();
         }
-        const lastObservation = this._playbackObserver.getReference().getValue();
+        var lastObservation = this._playbackObserver.getReference().getValue();
         updateDiscontinuitiesStore(this._discontinuitiesStore, evt, lastObservation);
-    }
+    };
     /**
      * Function to call when a Stream is currently locked, i.e. we cannot load
      * segments for the corresponding Period and buffer type until it is seeked
@@ -252,35 +267,35 @@ class RebufferingController extends event_emitter_1.default {
      * currently load.
      * @param {Object} period - Period for which no segment will currently load.
      */
-    onLockedStream(bufferType, period) {
+    RebufferingController.prototype.onLockedStream = function (bufferType, period) {
         var _a;
         if (!this._isStarted) {
             this.start();
         }
-        const observation = this._playbackObserver.getReference().getValue();
+        var observation = this._playbackObserver.getReference().getValue();
         if (!observation.rebuffering ||
             observation.paused ||
             this._speed.getValue() <= 0 || (bufferType !== "audio" &&
             bufferType !== "video")) {
             return;
         }
-        const currPos = observation.position;
-        const rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : currPos;
-        const lockedPeriodStart = period.start;
+        var currPos = observation.position;
+        var rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : currPos;
+        var lockedPeriodStart = period.start;
         if (currPos < lockedPeriodStart &&
             Math.abs(rebufferingPos - lockedPeriodStart) < 1) {
-            log_1.default.warn("Init: rebuffering because of a future locked stream.\n" +
+            log.warn("Init: rebuffering because of a future locked stream.\n" +
                 "Trying to unlock by seeking to the next Period");
             this._playbackObserver.setCurrentTime(lockedPeriodStart + 0.001);
         }
-    }
+    };
     /**
      * Stops the `RebufferingController` from montoring stalling situations,
      * forever.
      */
-    destroy() {
+    RebufferingController.prototype.destroy = function () {
         this._canceller.cancel();
-    }
+    };
     /**
      * Support of contents with DRM on all the platforms out there is a pain in
      * the *ss considering all the DRM-related bugs there are.
@@ -301,10 +316,9 @@ class RebufferingController extends event_emitter_1.default {
      * decipherability freeze, in which case this method already performed the
      * right handling steps.
      */
-    _checkDecipherabilityFreeze(observation) {
-        // XXX TODO allow this in in-worker configuration
-        const { readyState, rebuffering, freezing } = observation;
-        const bufferGap = observation.bufferGap !== undefined &&
+    RebufferingController.prototype._checkDecipherabilityFreeze = function (observation) {
+        var readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
+        var bufferGap = observation.bufferGap !== undefined &&
             isFinite(observation.bufferGap) ? observation.bufferGap :
             0;
         if (this._segmentBuffersStore === null ||
@@ -314,24 +328,26 @@ class RebufferingController extends event_emitter_1.default {
             this._currentFreezeTimestamp = null;
             return false;
         }
-        const now = (0, monotonic_timestamp_1.default)();
+        var now = performance.now();
         if (this._currentFreezeTimestamp === null) {
             this._currentFreezeTimestamp = now;
         }
-        const rebufferingForTooLong = rebuffering !== null && now - rebuffering.timestamp > 4000;
-        const frozenForTooLong = freezing !== null && now - freezing.timestamp > 4000;
+        var rebufferingForTooLong = rebuffering !== null && now - rebuffering.timestamp > 4000;
+        var frozenForTooLong = freezing !== null && now - freezing.timestamp > 4000;
         if ((rebufferingForTooLong || frozenForTooLong) &&
-            (0, monotonic_timestamp_1.default)() - this._currentFreezeTimestamp > 4000) {
-            const statusAudio = this._segmentBuffersStore.getStatus("audio");
-            const statusVideo = this._segmentBuffersStore.getStatus("video");
-            let hasOnlyDecipherableSegments = true;
-            let isClear = true;
-            for (const status of [statusAudio, statusVideo]) {
-                if (status.type === "initialized") {
-                    for (const segment of status.value.getInventory()) {
-                        const { representation } = segment.infos;
+            this._currentFreezeTimestamp > 4000) {
+            var statusAudio = this._segmentBuffersStore.getStatus("audio");
+            var statusVideo = this._segmentBuffersStore.getStatus("video");
+            var hasOnlyDecipherableSegments = true;
+            var isClear = true;
+            for (var _i = 0, _a = [statusAudio, statusVideo]; _i < _a.length; _i++) {
+                var status_1 = _a[_i];
+                if (status_1.type === "initialized") {
+                    for (var _b = 0, _c = status_1.value.getInventory(); _b < _c.length; _b++) {
+                        var segment = _c[_b];
+                        var representation = segment.infos.representation;
                         if (representation.decipherable === false) {
-                            log_1.default.warn("Init: we have undecipherable segments left in the buffer, reloading");
+                            log.warn("Init: we have undecipherable segments left in the buffer, reloading");
                             this._currentFreezeTimestamp = null;
                             this.trigger("needsReload", null);
                             return true;
@@ -346,7 +362,7 @@ class RebufferingController extends event_emitter_1.default {
                 }
             }
             if (!isClear && hasOnlyDecipherableSegments) {
-                log_1.default.warn("Init: we are frozen despite only having decipherable " +
+                log.warn("Init: we are frozen despite only having decipherable " +
                     "segments left in the buffer, reloading");
                 this._currentFreezeTimestamp = null;
                 this.trigger("needsReload", null);
@@ -354,9 +370,10 @@ class RebufferingController extends event_emitter_1.default {
             }
         }
         return false;
-    }
-}
-exports.default = RebufferingController;
+    };
+    return RebufferingController;
+}(EventEmitter));
+export default RebufferingController;
 /**
  * @param {Array.<Object>} discontinuitiesStore
  * @param {Object} manifest
@@ -367,25 +384,25 @@ function findSeekableDiscontinuity(discontinuitiesStore, manifest, stalledPositi
     if (discontinuitiesStore.length === 0) {
         return null;
     }
-    let maxDiscontinuityEnd = null;
-    for (let i = 0; i < discontinuitiesStore.length; i++) {
-        const { period } = discontinuitiesStore[i];
+    var maxDiscontinuityEnd = null;
+    for (var i = 0; i < discontinuitiesStore.length; i++) {
+        var period = discontinuitiesStore[i].period;
         if (period.start > stalledPosition) {
             return maxDiscontinuityEnd;
         }
-        let discontinuityEnd;
+        var discontinuityEnd = void 0;
         if (period.end === undefined || period.end > stalledPosition) {
-            const { discontinuity, position } = discontinuitiesStore[i];
-            const { start, end } = discontinuity;
-            const discontinuityLowerLimit = start !== null && start !== void 0 ? start : position;
+            var _a = discontinuitiesStore[i], discontinuity = _a.discontinuity, position = _a.position;
+            var start = discontinuity.start, end = discontinuity.end;
+            var discontinuityLowerLimit = start !== null && start !== void 0 ? start : position;
             if (stalledPosition >= (discontinuityLowerLimit - EPSILON)) {
                 if (end === null) {
-                    const nextPeriod = manifest.getPeriodAfter(period);
+                    var nextPeriod = manifest.getPeriodAfter(period);
                     if (nextPeriod !== null) {
                         discontinuityEnd = nextPeriod.start + EPSILON;
                     }
                     else {
-                        log_1.default.warn("Init: discontinuity at Period's end but no next Period");
+                        log.warn("Init: discontinuity at Period's end but no next Period");
                     }
                 }
                 else if (stalledPosition < (end + EPSILON)) {
@@ -393,7 +410,7 @@ function findSeekableDiscontinuity(discontinuitiesStore, manifest, stalledPositi
                 }
             }
             if (discontinuityEnd !== undefined) {
-                log_1.default.info("Init: discontinuity found", stalledPosition, discontinuityEnd);
+                log.info("Init: discontinuity found", stalledPosition, discontinuityEnd);
                 maxDiscontinuityEnd =
                     maxDiscontinuityEnd !== null &&
                         maxDiscontinuityEnd > discontinuityEnd ? maxDiscontinuityEnd :
@@ -433,11 +450,11 @@ function updateDiscontinuitiesStore(discontinuitiesStore, evt, observation) {
         discontinuitiesStore[0].period.end + 10 < observation.position) {
         discontinuitiesStore.shift();
     }
-    const { period, bufferType } = evt;
+    var period = evt.period, bufferType = evt.bufferType;
     if (bufferType !== "audio" && bufferType !== "video") {
         return;
     }
-    for (let i = 0; i < discontinuitiesStore.length; i++) {
+    for (var i = 0; i < discontinuitiesStore.length; i++) {
         if (discontinuitiesStore[i].period.id === period.id) {
             if (discontinuitiesStore[i].bufferType === bufferType) {
                 if (!eventContainsDiscontinuity(evt)) {
@@ -468,7 +485,7 @@ function updateDiscontinuitiesStore(discontinuitiesStore, evt, observation) {
  * @returns {Error}
  */
 function generateDiscontinuityError(stalledPosition, seekTo) {
-    return new errors_1.MediaError("DISCONTINUITY_ENCOUNTERED", "A discontinuity has been encountered at position " +
+    return new MediaError("DISCONTINUITY_ENCOUNTERED", "A discontinuity has been encountered at position " +
         String(stalledPosition) + ", seeked at position " +
         String(seekTo));
 }
@@ -482,14 +499,14 @@ function generateDiscontinuityError(stalledPosition, seekTo) {
  * anymore.
  * @class PlaybackRateUpdater
  */
-class PlaybackRateUpdater {
+var PlaybackRateUpdater = /** @class */ (function () {
     /**
      * Create a new `PlaybackRateUpdater`.
      * @param {Object} playbackObserver
      * @param {Object} speed
      */
-    constructor(playbackObserver, speed) {
-        this._speedUpdateCanceller = new task_canceller_1.default();
+    function PlaybackRateUpdater(playbackObserver, speed) {
+        this._speedUpdateCanceller = new TaskCanceller();
         this._isRebuffering = false;
         this._playbackObserver = playbackObserver;
         this._isDisposed = false;
@@ -501,29 +518,29 @@ class PlaybackRateUpdater {
      *
      * You can call `stopRebuffering` when you want the rebuffering phase to end.
      */
-    startRebuffering() {
+    PlaybackRateUpdater.prototype.startRebuffering = function () {
         if (this._isRebuffering || this._isDisposed) {
             return;
         }
         this._isRebuffering = true;
         this._speedUpdateCanceller.cancel();
-        log_1.default.info("Init: Pause playback to build buffer");
+        log.info("Init: Pause playback to build buffer");
         this._playbackObserver.setPlaybackRate(0);
-    }
+    };
     /**
      * If in a rebuffering phase (during which the playback rate is forced to
      * `0`), exit that phase to apply the wanted playback rate instead.
      *
      * Do nothing if not in a rebuffering phase.
      */
-    stopRebuffering() {
+    PlaybackRateUpdater.prototype.stopRebuffering = function () {
         if (!this._isRebuffering || this._isDisposed) {
             return;
         }
         this._isRebuffering = false;
-        this._speedUpdateCanceller = new task_canceller_1.default();
+        this._speedUpdateCanceller = new TaskCanceller();
         this._updateSpeed();
-    }
+    };
     /**
      * The `PlaybackRateUpdater` allocate resources to for example listen to
      * wanted speed changes and react to it.
@@ -531,14 +548,16 @@ class PlaybackRateUpdater {
      * Consequently, you should call the `dispose` method, when you don't want the
      * `PlaybackRateUpdater` to have an effect anymore.
      */
-    dispose() {
+    PlaybackRateUpdater.prototype.dispose = function () {
         this._speedUpdateCanceller.cancel();
         this._isDisposed = true;
-    }
-    _updateSpeed() {
-        this._speed.onUpdate((lastSpeed) => {
-            log_1.default.info("Init: Resume playback speed", lastSpeed);
-            this._playbackObserver.setPlaybackRate(lastSpeed);
+    };
+    PlaybackRateUpdater.prototype._updateSpeed = function () {
+        var _this = this;
+        this._speed.onUpdate(function (lastSpeed) {
+            log.info("Init: Resume playback speed", lastSpeed);
+            _this._playbackObserver.setPlaybackRate(lastSpeed);
         }, { clearSignal: this._speedUpdateCanceller.signal, emitCurrentValue: true });
-    }
-}
+    };
+    return PlaybackRateUpdater;
+}());

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/are_same_stream_events.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Compare 2 events.
  * As the payload of two events may be the same, but the JS objects may not
@@ -34,4 +32,4 @@ function areSameStreamEvents(evt1, evt2) {
         evt1.start === evt2.start &&
         evt1.end === evt2.end;
 }
-exports.default = areSameStreamEvents;
+export default areSameStreamEvents;

package/dist/_esm5.processed/core/init/utils/stream_events_emitter/index.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,6 +13,5 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const stream_events_emitter_1 = require("./stream_events_emitter");
-exports.default = stream_events_emitter_1.default;
+import streamEventsEmitter from "./stream_events_emitter";
+export default streamEventsEmitter;