rx-player 4.0.0-beta.2 → 4.0.0-beta.3

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,33 +14,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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";
+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");
 /**
  * Work-around rounding errors with floating points by setting an acceptable,
  * very short, deviation when checking equalities.
  */
-var EPSILON = 1 / 60;
+const EPSILON = 1 / 60;
 /**
  * Monitor playback, trying to avoid stalling situation.
  * If stopping the player to build buffer is needed, temporarily set the
@@ -48,27 +36,24 @@ var EPSILON = 1 / 60;
  * Emit "stalled" then "unstalled" respectively when an unavoidable stall is
  * encountered and exited.
  */
-var RebufferingController = /** @class */ (function (_super) {
-    __extends(RebufferingController, _super);
+class RebufferingController extends event_emitter_1.default {
     /**
      * @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
      */
-    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;
+    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;
     }
-    RebufferingController.prototype.start = function () {
-        var _this = this;
+    start() {
         if (this._isStarted) {
             return;
         }
@@ -87,7 +72,7 @@ var RebufferingController = /** @class */ (function (_super) {
          * seek after that). When browsers seek back to a position behind a
          * discontinuity, they are usually able to skip them without our help.
          */
-        var lastSeekingPosition;
+        let lastSeekingPosition;
         /**
          * In some conditions (see `lastSeekingPosition`), we might want to not
          * automatically seek over discontinuities because the browser might do it
@@ -97,39 +82,39 @@ var RebufferingController = /** @class */ (function (_super) {
          * This variable allows to store the timestamp at which a discontinuity began
          * to be ignored.
          */
-        var ignoredStallTimeStamp = null;
-        var playbackRateUpdater = new PlaybackRateUpdater(this._playbackObserver, this._speed);
-        this._canceller.signal.register(function () {
+        let ignoredStallTimeStamp = null;
+        const playbackRateUpdater = new PlaybackRateUpdater(this._playbackObserver, this._speed);
+        this._canceller.signal.register(() => {
             playbackRateUpdater.dispose();
         });
-        var prevFreezingState = null;
-        this._playbackObserver.listen(function (observation) {
+        let prevFreezingState = null;
+        this._playbackObserver.listen((observation) => {
             var _a;
-            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;
+            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();
             if (!observation.seeking &&
-                isSeekingApproximate &&
+                is_seeking_approximate_1.default &&
                 ignoredStallTimeStamp === null &&
                 lastSeekingPosition !== null && observation.position < lastSeekingPosition) {
-                log.debug("Init: the device appeared to have seeked back by itself.");
-                var now = performance.now();
+                log_1.default.debug("Init: the device appeared to have seeked back by itself.");
+                const now = (0, monotonic_timestamp_1.default)();
                 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) {
-                var now = performance.now();
-                var referenceTimestamp = prevFreezingState === null ?
+                const now = (0, monotonic_timestamp_1.default)();
+                const referenceTimestamp = prevFreezingState === null ?
                     freezing.timestamp :
                     prevFreezingState.attemptTimestamp;
                 if (now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
-                    log.warn("Init: trying to seek to un-freeze player");
-                    _this._playbackObserver.setCurrentTime(_this._playbackObserver.getCurrentTime() + UNFREEZING_DELTA_POSITION);
+                    log_1.default.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) {
@@ -139,7 +124,7 @@ var RebufferingController = /** @class */ (function (_super) {
                     else {
                         playbackRateUpdater.startRebuffering();
                     }
-                    _this.trigger("stalled", "freezing");
+                    this.trigger("stalled", "freezing");
                     return;
                 }
             }
@@ -151,7 +136,7 @@ var RebufferingController = /** @class */ (function (_super) {
                 if (readyState === 1) {
                     // With a readyState set to 1, we should still not be able to play:
                     // Return that we're stalled
-                    var reason = void 0;
+                    let reason;
                     if (observation.seeking) {
                         reason = observation.pendingInternalSeek !== null ? "internal-seek" :
                             "seeking";
@@ -159,56 +144,56 @@ var RebufferingController = /** @class */ (function (_super) {
                     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.
-            var stalledReason = rebuffering.reason === "seeking" &&
+            const stalledReason = rebuffering.reason === "seeking" &&
                 observation.pendingInternalSeek !== null ?
                 "internal-seek" :
                 rebuffering.reason;
             if (ignoredStallTimeStamp !== null) {
-                var now = performance.now();
+                const now = (0, monotonic_timestamp_1.default)();
                 if (now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
                     playbackRateUpdater.stopRebuffering();
-                    log.debug("Init: letting the device get out of a stall by itself");
-                    _this.trigger("stalled", stalledReason);
+                    log_1.default.debug("Init: letting the device get out of a stall by itself");
+                    this.trigger("stalled", stalledReason);
                     return;
                 }
                 else {
-                    log.warn("Init: ignored stall for too long, considering it", now - ignoredStallTimeStamp);
+                    log_1.default.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. */
-            var stalledPosition = rebuffering.position;
+            const { position: stalledPosition } = rebuffering;
             if (stalledPosition !== null &&
                 stalledPosition !== undefined &&
-                _this._speed.getValue() > 0) {
-                var skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore, _this._manifest, stalledPosition);
+                this._speed.getValue() > 0) {
+                const skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore, this._manifest, stalledPosition);
                 if (skippableDiscontinuity !== null) {
-                    var realSeekTime = skippableDiscontinuity + 0.001;
-                    if (realSeekTime <= _this._playbackObserver.getCurrentTime()) {
-                        log.info("Init: position to seek already reached, no seeking", _this._playbackObserver.getCurrentTime(), realSeekTime);
+                    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);
                     }
                     else {
-                        log.warn("SA: skippable discontinuity found in the stream", position, realSeekTime);
-                        _this._playbackObserver.setCurrentTime(realSeekTime);
-                        _this.trigger("warning", generateDiscontinuityError(stalledPosition, realSeekTime));
+                        log_1.default.warn("SA: skippable discontinuity found in the stream", position, realSeekTime);
+                        this._playbackObserver.setCurrentTime(realSeekTime);
+                        this.trigger("warning", generateDiscontinuityError(stalledPosition, realSeekTime));
                         return;
                     }
                 }
             }
-            var freezePosition = stalledPosition !== null && stalledPosition !== void 0 ? stalledPosition : position;
+            const freezePosition = stalledPosition !== null && stalledPosition !== void 0 ? stalledPosition : position;
             // Is it a very short discontinuity in buffer ? -> Seek at the beginning of the
             //                                                 next range
             //
@@ -216,49 +201,49 @@ var RebufferingController = /** @class */ (function (_super) {
             // 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.
-            var nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
-            if (_this._speed.getValue() > 0 &&
+            const nextBufferRangeGap = (0, ranges_1.getNextBufferedTimeRangeGap)(buffered, freezePosition);
+            if (this._speed.getValue() > 0 &&
                 nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
-                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));
+                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));
                     return;
                 }
             }
             // Are we in a discontinuity between periods ? -> Seek at the beginning of the
             //                                                next period
-            for (var i = _this._manifest.periods.length - 2; i >= 0; i--) {
-                var period = _this._manifest.periods[i];
+            for (let i = this._manifest.periods.length - 2; i >= 0; i--) {
+                const 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()) {
-                        var 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()) {
+                        const 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
      */
-    RebufferingController.prototype.updateDiscontinuityInfo = function (evt) {
+    updateDiscontinuityInfo(evt) {
         if (!this._isStarted) {
             this.start();
         }
-        var lastObservation = this._playbackObserver.getReference().getValue();
+        const 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
@@ -267,35 +252,35 @@ var RebufferingController = /** @class */ (function (_super) {
      * currently load.
      * @param {Object} period - Period for which no segment will currently load.
      */
-    RebufferingController.prototype.onLockedStream = function (bufferType, period) {
+    onLockedStream(bufferType, period) {
         var _a;
         if (!this._isStarted) {
             this.start();
         }
-        var observation = this._playbackObserver.getReference().getValue();
+        const observation = this._playbackObserver.getReference().getValue();
         if (!observation.rebuffering ||
             observation.paused ||
             this._speed.getValue() <= 0 || (bufferType !== "audio" &&
             bufferType !== "video")) {
             return;
         }
-        var currPos = observation.position;
-        var rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : currPos;
-        var lockedPeriodStart = period.start;
+        const currPos = observation.position;
+        const rebufferingPos = (_a = observation.rebuffering.position) !== null && _a !== void 0 ? _a : currPos;
+        const lockedPeriodStart = period.start;
         if (currPos < lockedPeriodStart &&
             Math.abs(rebufferingPos - lockedPeriodStart) < 1) {
-            log.warn("Init: rebuffering because of a future locked stream.\n" +
+            log_1.default.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.
      */
-    RebufferingController.prototype.destroy = function () {
+    destroy() {
         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.
@@ -316,9 +301,10 @@ var RebufferingController = /** @class */ (function (_super) {
      * decipherability freeze, in which case this method already performed the
      * right handling steps.
      */
-    RebufferingController.prototype._checkDecipherabilityFreeze = function (observation) {
-        var readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
-        var bufferGap = observation.bufferGap !== undefined &&
+    _checkDecipherabilityFreeze(observation) {
+        // XXX TODO allow this in in-worker configuration
+        const { readyState, rebuffering, freezing } = observation;
+        const bufferGap = observation.bufferGap !== undefined &&
             isFinite(observation.bufferGap) ? observation.bufferGap :
             0;
         if (this._segmentBuffersStore === null ||
@@ -328,26 +314,24 @@ var RebufferingController = /** @class */ (function (_super) {
             this._currentFreezeTimestamp = null;
             return false;
         }
-        var now = performance.now();
+        const now = (0, monotonic_timestamp_1.default)();
         if (this._currentFreezeTimestamp === null) {
             this._currentFreezeTimestamp = now;
         }
-        var rebufferingForTooLong = rebuffering !== null && now - rebuffering.timestamp > 4000;
-        var frozenForTooLong = freezing !== null && now - freezing.timestamp > 4000;
+        const rebufferingForTooLong = rebuffering !== null && now - rebuffering.timestamp > 4000;
+        const frozenForTooLong = freezing !== null && now - freezing.timestamp > 4000;
         if ((rebufferingForTooLong || frozenForTooLong) &&
-            performance.now() - 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;
+            (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;
                         if (representation.decipherable === false) {
-                            log.warn("Init: we have undecipherable segments left in the buffer, reloading");
+                            log_1.default.warn("Init: we have undecipherable segments left in the buffer, reloading");
                             this._currentFreezeTimestamp = null;
                             this.trigger("needsReload", null);
                             return true;
@@ -362,7 +346,7 @@ var RebufferingController = /** @class */ (function (_super) {
                 }
             }
             if (!isClear && hasOnlyDecipherableSegments) {
-                log.warn("Init: we are frozen despite only having decipherable " +
+                log_1.default.warn("Init: we are frozen despite only having decipherable " +
                     "segments left in the buffer, reloading");
                 this._currentFreezeTimestamp = null;
                 this.trigger("needsReload", null);
@@ -370,10 +354,9 @@ var RebufferingController = /** @class */ (function (_super) {
             }
         }
         return false;
-    };
-    return RebufferingController;
-}(EventEmitter));
-export default RebufferingController;
+    }
+}
+exports.default = RebufferingController;
 /**
  * @param {Array.<Object>} discontinuitiesStore
  * @param {Object} manifest
@@ -384,25 +367,25 @@ function findSeekableDiscontinuity(discontinuitiesStore, manifest, stalledPositi
     if (discontinuitiesStore.length === 0) {
         return null;
     }
-    var maxDiscontinuityEnd = null;
-    for (var i = 0; i < discontinuitiesStore.length; i++) {
-        var period = discontinuitiesStore[i].period;
+    let maxDiscontinuityEnd = null;
+    for (let i = 0; i < discontinuitiesStore.length; i++) {
+        const { period } = discontinuitiesStore[i];
         if (period.start > stalledPosition) {
             return maxDiscontinuityEnd;
         }
-        var discontinuityEnd = void 0;
+        let discontinuityEnd;
         if (period.end === undefined || period.end > stalledPosition) {
-            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;
+            const { discontinuity, position } = discontinuitiesStore[i];
+            const { start, end } = discontinuity;
+            const discontinuityLowerLimit = start !== null && start !== void 0 ? start : position;
             if (stalledPosition >= (discontinuityLowerLimit - EPSILON)) {
                 if (end === null) {
-                    var nextPeriod = manifest.getPeriodAfter(period);
+                    const nextPeriod = manifest.getPeriodAfter(period);
                     if (nextPeriod !== null) {
                         discontinuityEnd = nextPeriod.start + EPSILON;
                     }
                     else {
-                        log.warn("Init: discontinuity at Period's end but no next Period");
+                        log_1.default.warn("Init: discontinuity at Period's end but no next Period");
                     }
                 }
                 else if (stalledPosition < (end + EPSILON)) {
@@ -410,7 +393,7 @@ function findSeekableDiscontinuity(discontinuitiesStore, manifest, stalledPositi
                 }
             }
             if (discontinuityEnd !== undefined) {
-                log.info("Init: discontinuity found", stalledPosition, discontinuityEnd);
+                log_1.default.info("Init: discontinuity found", stalledPosition, discontinuityEnd);
                 maxDiscontinuityEnd =
                     maxDiscontinuityEnd !== null &&
                         maxDiscontinuityEnd > discontinuityEnd ? maxDiscontinuityEnd :
@@ -450,11 +433,11 @@ function updateDiscontinuitiesStore(discontinuitiesStore, evt, observation) {
         discontinuitiesStore[0].period.end + 10 < observation.position) {
         discontinuitiesStore.shift();
     }
-    var period = evt.period, bufferType = evt.bufferType;
+    const { period, bufferType } = evt;
     if (bufferType !== "audio" && bufferType !== "video") {
         return;
     }
-    for (var i = 0; i < discontinuitiesStore.length; i++) {
+    for (let i = 0; i < discontinuitiesStore.length; i++) {
         if (discontinuitiesStore[i].period.id === period.id) {
             if (discontinuitiesStore[i].bufferType === bufferType) {
                 if (!eventContainsDiscontinuity(evt)) {
@@ -485,7 +468,7 @@ function updateDiscontinuitiesStore(discontinuitiesStore, evt, observation) {
  * @returns {Error}
  */
 function generateDiscontinuityError(stalledPosition, seekTo) {
-    return new MediaError("DISCONTINUITY_ENCOUNTERED", "A discontinuity has been encountered at position " +
+    return new errors_1.MediaError("DISCONTINUITY_ENCOUNTERED", "A discontinuity has been encountered at position " +
         String(stalledPosition) + ", seeked at position " +
         String(seekTo));
 }
@@ -499,14 +482,14 @@ function generateDiscontinuityError(stalledPosition, seekTo) {
  * anymore.
  * @class PlaybackRateUpdater
  */
-var PlaybackRateUpdater = /** @class */ (function () {
+class PlaybackRateUpdater {
     /**
      * Create a new `PlaybackRateUpdater`.
      * @param {Object} playbackObserver
      * @param {Object} speed
      */
-    function PlaybackRateUpdater(playbackObserver, speed) {
-        this._speedUpdateCanceller = new TaskCanceller();
+    constructor(playbackObserver, speed) {
+        this._speedUpdateCanceller = new task_canceller_1.default();
         this._isRebuffering = false;
         this._playbackObserver = playbackObserver;
         this._isDisposed = false;
@@ -518,29 +501,29 @@ var PlaybackRateUpdater = /** @class */ (function () {
      *
      * You can call `stopRebuffering` when you want the rebuffering phase to end.
      */
-    PlaybackRateUpdater.prototype.startRebuffering = function () {
+    startRebuffering() {
         if (this._isRebuffering || this._isDisposed) {
             return;
         }
         this._isRebuffering = true;
         this._speedUpdateCanceller.cancel();
-        log.info("Init: Pause playback to build buffer");
+        log_1.default.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.
      */
-    PlaybackRateUpdater.prototype.stopRebuffering = function () {
+    stopRebuffering() {
         if (!this._isRebuffering || this._isDisposed) {
             return;
         }
         this._isRebuffering = false;
-        this._speedUpdateCanceller = new TaskCanceller();
+        this._speedUpdateCanceller = new task_canceller_1.default();
         this._updateSpeed();
-    };
+    }
     /**
      * The `PlaybackRateUpdater` allocate resources to for example listen to
      * wanted speed changes and react to it.
@@ -548,16 +531,14 @@ var PlaybackRateUpdater = /** @class */ (function () {
      * Consequently, you should call the `dispose` method, when you don't want the
      * `PlaybackRateUpdater` to have an effect anymore.
      */
-    PlaybackRateUpdater.prototype.dispose = function () {
+    dispose() {
         this._speedUpdateCanceller.cancel();
         this._isDisposed = true;
-    };
-    PlaybackRateUpdater.prototype._updateSpeed = function () {
-        var _this = this;
-        this._speed.onUpdate(function (lastSpeed) {
-            log.info("Init: Resume playback speed", lastSpeed);
-            _this._playbackObserver.setPlaybackRate(lastSpeed);
+    }
+    _updateSpeed() {
+        this._speed.onUpdate((lastSpeed) => {
+            log_1.default.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,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,7 @@
  * 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
@@ -32,4 +34,4 @@ function areSameStreamEvents(evt1, evt2) {
         evt1.start === evt2.start &&
         evt1.end === evt2.end;
 }
-export default areSameStreamEvents;
+exports.default = areSameStreamEvents;

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

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