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

package/dist/_esm5.processed/core/init/media_source_content_initializer.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,84 +14,34 @@
  * 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 __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import { shouldReloadMediaSourceOnDecipherabilityUpdate } from "../../compat";
-import config from "../../config";
-import { MediaError } from "../../errors";
-import log from "../../log";
-import assert from "../../utils/assert";
-import createCancellablePromise from "../../utils/create_cancellable_promise";
-import objectAssign from "../../utils/object_assign";
-import createSharedReference from "../../utils/reference";
-import TaskCanceller from "../../utils/task_canceller";
-import AdaptiveRepresentationSelector from "../adaptive";
-import { getKeySystemConfiguration, } from "../decrypt";
-import { ManifestFetcher, SegmentFetcherCreator, } from "../fetchers";
-import SegmentBuffersStore from "../segment_buffers";
-import StreamOrchestrator from "../stream";
-import { ContentInitializer } from "./types";
-import ContentTimeBoundariesObserver from "./utils/content_time_boundaries_observer";
-import openMediaSource from "./utils/create_media_source";
-import createStreamPlaybackObserver from "./utils/create_stream_playback_observer";
-import { maintainEndOfStream } from "./utils/end_of_stream";
-import getInitialTime from "./utils/get_initial_time";
-import getLoadedReference from "./utils/get_loaded_reference";
-import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
-import initializeContentDecryption from "./utils/initialize_content_decryption";
-import MediaSourceDurationUpdater from "./utils/media_source_duration_updater";
-import RebufferingController from "./utils/rebuffering_controller";
-import streamEventsEmitter from "./utils/stream_events_emitter";
-import listenToMediaError from "./utils/throw_on_media_error";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compat_1 = require("../../compat");
+const config_1 = require("../../config");
+const errors_1 = require("../../errors");
+const log_1 = require("../../log");
+const assert_1 = require("../../utils/assert");
+const create_cancellable_promise_1 = require("../../utils/create_cancellable_promise");
+const object_assign_1 = require("../../utils/object_assign");
+const reference_1 = require("../../utils/reference");
+const task_canceller_1 = require("../../utils/task_canceller");
+const adaptive_1 = require("../adaptive");
+const decrypt_1 = require("../decrypt");
+const fetchers_1 = require("../fetchers");
+const segment_buffers_1 = require("../segment_buffers");
+const stream_1 = require("../stream");
+const types_1 = require("./types");
+const content_time_boundaries_observer_1 = require("./utils/content_time_boundaries_observer");
+const create_media_source_1 = require("./utils/create_media_source");
+const create_stream_playback_observer_1 = require("./utils/create_stream_playback_observer");
+const end_of_stream_1 = require("./utils/end_of_stream");
+const get_initial_time_1 = require("./utils/get_initial_time");
+const get_loaded_reference_1 = require("./utils/get_loaded_reference");
+const initial_seek_and_play_1 = require("./utils/initial_seek_and_play");
+const initialize_content_decryption_1 = require("./utils/initialize_content_decryption");
+const media_source_duration_updater_1 = require("./utils/media_source_duration_updater");
+const rebuffering_controller_1 = require("./utils/rebuffering_controller");
+const stream_events_emitter_1 = require("./utils/stream_events_emitter");
+const throw_on_media_error_1 = require("./utils/throw_on_media_error");
 /**
  * Allows to load a new content thanks to the MediaSource Extensions (a.k.a. MSE)
  * Web APIs.
@@ -102,66 +53,60 @@ import listenToMediaError from "./utils/throw_on_media_error";
  *
  * @class MediaSourceContentInitializer
  */
-var MediaSourceContentInitializer = /** @class */ (function (_super) {
-    __extends(MediaSourceContentInitializer, _super);
+class MediaSourceContentInitializer extends types_1.ContentInitializer {
     /**
      * Create a new `MediaSourceContentInitializer`, associated to the given
      * settings.
      * @param {Object} settings
      */
-    function MediaSourceContentInitializer(settings) {
-        var _this = _super.call(this) || this;
-        _this._settings = settings;
-        _this._initCanceller = new TaskCanceller();
-        _this._initialManifestProm = null;
-        var urls = settings.url === undefined ? undefined :
+    constructor(settings) {
+        super();
+        this._settings = settings;
+        this._initCanceller = new task_canceller_1.default();
+        this._initialManifestProm = null;
+        const urls = settings.url === undefined ? undefined :
             [settings.url];
-        _this._manifestFetcher = new ManifestFetcher(urls, settings.transport, settings.manifestRequestSettings);
-        return _this;
+        this._manifestFetcher = new fetchers_1.ManifestFetcher(urls, settings.transport, settings.manifestRequestSettings);
     }
     /**
      * Perform non-destructive preparation steps, to prepare a future content.
      * For now, this mainly mean loading the Manifest document.
      */
-    MediaSourceContentInitializer.prototype.prepare = function () {
-        var _this = this;
+    prepare() {
         if (this._initialManifestProm !== null) {
             return;
         }
-        this._initialManifestProm = createCancellablePromise(this._initCanceller.signal, function (res, rej) {
-            _this._manifestFetcher.addEventListener("warning", function (err) {
-                return _this.trigger("warning", err);
-            });
-            _this._manifestFetcher.addEventListener("error", function (err) {
-                _this.trigger("error", err);
+        this._initialManifestProm = (0, create_cancellable_promise_1.default)(this._initCanceller.signal, (res, rej) => {
+            this._manifestFetcher.addEventListener("warning", (err) => this.trigger("warning", err));
+            this._manifestFetcher.addEventListener("error", (err) => {
+                this.trigger("error", err);
                 rej(err);
             });
-            _this._manifestFetcher.addEventListener("manifestReady", function (manifest) {
+            this._manifestFetcher.addEventListener("manifestReady", (manifest) => {
                 res(manifest);
             });
         });
         this._manifestFetcher.start();
-        this._initCanceller.signal.register(function () {
-            _this._manifestFetcher.dispose();
+        this._initCanceller.signal.register(() => {
+            this._manifestFetcher.dispose();
         });
-    };
+    }
     /**
      * @param {HTMLMediaElement} mediaElement
      * @param {Object} playbackObserver
      */
-    MediaSourceContentInitializer.prototype.start = function (mediaElement, playbackObserver) {
-        var _this = this;
+    start(mediaElement, playbackObserver) {
         this.prepare(); // Load Manifest if not already done
         /** Translate errors coming from the media element into RxPlayer errors. */
-        listenToMediaError(mediaElement, function (error) { return _this._onFatalError(error); }, this._initCanceller.signal);
+        (0, throw_on_media_error_1.default)(mediaElement, (error) => this._onFatalError(error), this._initCanceller.signal);
         /** Send content protection initialization data to the decryption logic. */
-        var protectionRef = createSharedReference(null, this._initCanceller.signal);
+        const protectionRef = new reference_1.default(null, this._initCanceller.signal);
         this._initializeMediaSourceAndDecryption(mediaElement, protectionRef)
-            .then(function (initResult) { return _this._onInitialMediaSourceReady(mediaElement, initResult.mediaSource, playbackObserver, initResult.drmSystemId, protectionRef, initResult.unlinkMediaSource); })
-            .catch(function (err) {
-            _this._onFatalError(err);
+            .then(initResult => this._onInitialMediaSourceReady(mediaElement, initResult.mediaSource, playbackObserver, initResult.drmSystemId, protectionRef, initResult.unlinkMediaSource))
+            .catch((err) => {
+            this._onFatalError(err);
         });
-    };
+    }
     /**
      * Update URL of the Manifest.
      * @param {Array.<string>|undefined} urls - URLs to reach that Manifest from
@@ -169,191 +114,200 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
      * @param {boolean} refreshNow - If `true` the resource in question (e.g.
      * DASH's MPD) will be refreshed immediately.
      */
-    MediaSourceContentInitializer.prototype.updateContentUrls = function (urls, refreshNow) {
+    updateContentUrls(urls, refreshNow) {
         this._manifestFetcher.updateContentUrls(urls, refreshNow);
-    };
-    MediaSourceContentInitializer.prototype.dispose = function () {
+    }
+    dispose() {
         this._initCanceller.cancel();
-    };
-    MediaSourceContentInitializer.prototype._onFatalError = function (err) {
+    }
+    _onFatalError(err) {
         if (this._initCanceller.isUsed()) {
             return;
         }
         this._initCanceller.cancel();
         this.trigger("error", err);
-    };
-    MediaSourceContentInitializer.prototype._initializeMediaSourceAndDecryption = function (mediaElement, protectionRef) {
-        var _this = this;
-        var initCanceller = this._initCanceller;
-        return createCancellablePromise(initCanceller.signal, function (resolve) {
-            var keySystems = _this._settings.keySystems;
+    }
+    _initializeMediaSourceAndDecryption(mediaElement, protectionRef) {
+        const initCanceller = this._initCanceller;
+        return (0, create_cancellable_promise_1.default)(initCanceller.signal, (resolve) => {
+            const { keySystems } = this._settings;
             /** Initialize decryption capabilities. */
-            var drmInitRef = initializeContentDecryption(mediaElement, keySystems, protectionRef, {
-                onWarning: function (err) { return _this.trigger("warning", err); },
-                onError: function (err) { return _this._onFatalError(err); },
-            }, initCanceller.signal);
-            drmInitRef.onUpdate(function (drmStatus, stopListeningToDrmUpdates) {
+            const drmInitRef = (0, initialize_content_decryption_1.default)(mediaElement, keySystems, protectionRef, { onWarning: (err) => this.trigger("warning", err),
+                onError: (err) => this._onFatalError(err) }, initCanceller.signal);
+            drmInitRef.onUpdate((drmStatus, stopListeningToDrmUpdates) => {
                 if (drmStatus.initializationState.type === "uninitialized") {
                     return;
                 }
                 stopListeningToDrmUpdates();
-                var mediaSourceCanceller = new TaskCanceller();
+                const mediaSourceCanceller = new task_canceller_1.default();
                 mediaSourceCanceller.linkToSignal(initCanceller.signal);
-                openMediaSource(mediaElement, mediaSourceCanceller.signal)
-                    .then(function (mediaSource) {
-                    var lastDrmStatus = drmInitRef.getValue();
+                (0, create_media_source_1.default)(mediaElement, mediaSourceCanceller.signal)
+                    .then((mediaSource) => {
+                    const lastDrmStatus = drmInitRef.getValue();
                     if (lastDrmStatus.initializationState.type === "awaiting-media-link") {
                         lastDrmStatus.initializationState.value.isMediaLinked.setValue(true);
-                        drmInitRef.onUpdate(function (newDrmStatus, stopListeningToDrmUpdatesAgain) {
+                        drmInitRef.onUpdate((newDrmStatus, stopListeningToDrmUpdatesAgain) => {
                             if (newDrmStatus.initializationState.type === "initialized") {
                                 stopListeningToDrmUpdatesAgain();
-                                resolve({ mediaSource: mediaSource, drmSystemId: newDrmStatus.drmSystemId,
+                                resolve({ mediaSource,
+                                    drmSystemId: newDrmStatus.drmSystemId,
                                     unlinkMediaSource: mediaSourceCanceller });
                                 return;
                             }
                         }, { emitCurrentValue: true, clearSignal: initCanceller.signal });
                     }
                     else if (drmStatus.initializationState.type === "initialized") {
-                        resolve({ mediaSource: mediaSource, drmSystemId: drmStatus.drmSystemId,
+                        resolve({ mediaSource,
+                            drmSystemId: drmStatus.drmSystemId,
                             unlinkMediaSource: mediaSourceCanceller });
                         return;
                     }
                 })
-                    .catch(function (err) {
+                    .catch((err) => {
                     if (mediaSourceCanceller.isUsed()) {
                         return;
                     }
-                    _this._onFatalError(err);
+                    this._onFatalError(err);
                 });
             }, { emitCurrentValue: true, clearSignal: initCanceller.signal });
         });
-    };
-    MediaSourceContentInitializer.prototype._onInitialMediaSourceReady = function (mediaElement, initialMediaSource, playbackObserver, drmSystemId, protectionRef, initialMediaSourceCanceller) {
-        return __awaiter(this, void 0, void 0, function () {
-            /**
-             * Load the content defined by the Manifest in the mediaSource given at the
-             * given position and playing status.
-             * This function recursively re-call itself when a MediaSource reload is
-             * wanted.
-             * @param {MediaSource} mediaSource
-             * @param {number} startingPos
-             * @param {Object} currentCanceller
-             * @param {boolean} shouldPlay
-             */
-            function recursivelyLoadOnMediaSource(mediaSource, startingPos, shouldPlay, currentCanceller) {
-                var opts = { mediaElement: mediaElement, playbackObserver: playbackObserver, mediaSource: mediaSource, initialTime: startingPos,
-                    autoPlay: shouldPlay, manifest: manifest, representationEstimator: representationEstimator, segmentFetcherCreator: segmentFetcherCreator, speed: speed, protectionRef: protectionRef, bufferOptions: subBufferOptions };
-                bufferOnMediaSource(opts, onReloadMediaSource, currentCanceller.signal);
-                function onReloadMediaSource(reloadOrder) {
-                    currentCanceller.cancel();
-                    if (initCanceller.isUsed()) {
-                        return;
-                    }
-                    triggerEvent("reloadingMediaSource", reloadOrder);
-                    if (initCanceller.isUsed()) {
+    }
+    async _onInitialMediaSourceReady(mediaElement, initialMediaSource, playbackObserver, drmSystemId, protectionRef, initialMediaSourceCanceller) {
+        const { adaptiveOptions, autoPlay, bufferOptions, lowLatencyMode, segmentRequestOptions, speed, startAt, textTrackOptions, transport } = this._settings;
+        const initCanceller = this._initCanceller;
+        (0, assert_1.default)(this._initialManifestProm !== null);
+        const manifestProm = this._initialManifestProm;
+        let manifest;
+        try {
+            manifest = await manifestProm;
+        }
+        catch (_e) {
+            return; // The error should already have been processed through an event listener
+        }
+        manifest.addEventListener("manifestUpdate", () => {
+            this.trigger("manifestUpdate", null);
+        }, initCanceller.signal);
+        log_1.default.debug("Init: Calculating initial time");
+        const initialTime = (0, get_initial_time_1.default)(manifest, lowLatencyMode, startAt);
+        log_1.default.debug("Init: Initial time calculated:", initialTime);
+        /** Choose the right "Representation" for a given "Adaptation". */
+        const representationEstimator = (0, adaptive_1.default)(adaptiveOptions);
+        const subBufferOptions = (0, object_assign_1.default)({ textTrackOptions, drmSystemId }, bufferOptions);
+        const segmentFetcherCreator = new fetchers_1.SegmentFetcherCreator(transport, segmentRequestOptions, initCanceller.signal);
+        this.trigger("manifestReady", manifest);
+        if (initCanceller.isUsed()) {
+            return;
+        }
+        const bufferOnMediaSource = this._startBufferingOnMediaSource.bind(this);
+        const triggerEvent = this.trigger.bind(this);
+        const onFatalError = this._onFatalError.bind(this);
+        // handle initial load and reloads
+        recursivelyLoadOnMediaSource(initialMediaSource, initialTime, autoPlay, initialMediaSourceCanceller);
+        /**
+         * Load the content defined by the Manifest in the mediaSource given at the
+         * given position and playing status.
+         * This function recursively re-call itself when a MediaSource reload is
+         * wanted.
+         * @param {MediaSource} mediaSource
+         * @param {number} startingPos
+         * @param {Object} currentCanceller
+         * @param {boolean} shouldPlay
+         */
+        function recursivelyLoadOnMediaSource(mediaSource, startingPos, shouldPlay, currentCanceller) {
+            const opts = { mediaElement,
+                playbackObserver,
+                mediaSource,
+                initialTime: startingPos,
+                autoPlay: shouldPlay,
+                manifest,
+                representationEstimator,
+                segmentFetcherCreator,
+                speed,
+                protectionRef,
+                bufferOptions: subBufferOptions };
+            bufferOnMediaSource(opts, onReloadMediaSource, currentCanceller.signal);
+            function onReloadMediaSource(reloadOrder) {
+                currentCanceller.cancel();
+                if (initCanceller.isUsed()) {
+                    return;
+                }
+                triggerEvent("reloadingMediaSource", reloadOrder);
+                if (initCanceller.isUsed()) {
+                    return;
+                }
+                const newCanceller = new task_canceller_1.default();
+                newCanceller.linkToSignal(initCanceller.signal);
+                (0, create_media_source_1.default)(mediaElement, newCanceller.signal)
+                    .then(newMediaSource => {
+                    recursivelyLoadOnMediaSource(newMediaSource, reloadOrder.position, reloadOrder.autoPlay, newCanceller);
+                })
+                    .catch((err) => {
+                    if (newCanceller.isUsed()) {
                         return;
                     }
-                    var newCanceller = new TaskCanceller();
-                    newCanceller.linkToSignal(initCanceller.signal);
-                    openMediaSource(mediaElement, newCanceller.signal)
-                        .then(function (newMediaSource) {
-                        recursivelyLoadOnMediaSource(newMediaSource, reloadOrder.position, reloadOrder.autoPlay, newCanceller);
-                    })
-                        .catch(function (err) {
-                        if (newCanceller.isUsed()) {
-                            return;
-                        }
-                        onFatalError(err);
-                    });
-                }
+                    onFatalError(err);
+                });
             }
-            var _a, adaptiveOptions, autoPlay, bufferOptions, lowLatencyMode, segmentRequestOptions, speed, startAt, textTrackOptions, transport, initCanceller, manifestProm, manifest, _e_1, initialTime, representationEstimator, subBufferOptions, segmentFetcherCreator, bufferOnMediaSource, triggerEvent, onFatalError;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this._settings, adaptiveOptions = _a.adaptiveOptions, autoPlay = _a.autoPlay, bufferOptions = _a.bufferOptions, lowLatencyMode = _a.lowLatencyMode, segmentRequestOptions = _a.segmentRequestOptions, speed = _a.speed, startAt = _a.startAt, textTrackOptions = _a.textTrackOptions, transport = _a.transport;
-                        initCanceller = this._initCanceller;
-                        assert(this._initialManifestProm !== null);
-                        manifestProm = this._initialManifestProm;
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, manifestProm];
-                    case 2:
-                        manifest = _b.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        _e_1 = _b.sent();
-                        return [2 /*return*/]; // The error should already have been processed through an event listener
-                    case 4:
-                        manifest.addEventListener("manifestUpdate", function () {
-                            _this.trigger("manifestUpdate", null);
-                        }, initCanceller.signal);
-                        log.debug("Init: Calculating initial time");
-                        initialTime = getInitialTime(manifest, lowLatencyMode, startAt);
-                        log.debug("Init: Initial time calculated:", initialTime);
-                        representationEstimator = AdaptiveRepresentationSelector(adaptiveOptions);
-                        subBufferOptions = objectAssign({ textTrackOptions: textTrackOptions, drmSystemId: drmSystemId }, bufferOptions);
-                        segmentFetcherCreator = new SegmentFetcherCreator(transport, segmentRequestOptions, initCanceller.signal);
-                        this.trigger("manifestReady", manifest);
-                        if (initCanceller.isUsed()) {
-                            return [2 /*return*/];
-                        }
-                        bufferOnMediaSource = this._startBufferingOnMediaSource.bind(this);
-                        triggerEvent = this.trigger.bind(this);
-                        onFatalError = this._onFatalError.bind(this);
-                        // handle initial load and reloads
-                        recursivelyLoadOnMediaSource(initialMediaSource, initialTime, autoPlay, initialMediaSourceCanceller);
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+        }
+    }
     /**
      * Buffer the content on the given MediaSource.
      * @param {Object} args
      * @param {function} onReloadOrder
      * @param {Object} cancelSignal
      */
-    MediaSourceContentInitializer.prototype._startBufferingOnMediaSource = function (args, onReloadOrder, cancelSignal) {
-        var _this = this;
+    _startBufferingOnMediaSource(args, onReloadOrder, cancelSignal) {
         var _a;
-        var autoPlay = args.autoPlay, bufferOptions = args.bufferOptions, initialTime = args.initialTime, manifest = args.manifest, mediaElement = args.mediaElement, mediaSource = args.mediaSource, playbackObserver = args.playbackObserver, protectionRef = args.protectionRef, representationEstimator = args.representationEstimator, segmentFetcherCreator = args.segmentFetcherCreator, speed = args.speed;
-        var initialPeriod = (_a = manifest.getPeriodForTime(initialTime)) !== null && _a !== void 0 ? _a : manifest.getNextPeriod(initialTime);
+        const { autoPlay, bufferOptions, initialTime, manifest, mediaElement, mediaSource, playbackObserver, protectionRef, representationEstimator, segmentFetcherCreator, speed } = args;
+        const initialPeriod = (_a = manifest.getPeriodForTime(initialTime)) !== null && _a !== void 0 ? _a : manifest.getNextPeriod(initialTime);
         if (initialPeriod === undefined) {
-            var error = new MediaError("MEDIA_STARTING_TIME_NOT_FOUND", "Wanted starting time not found in the Manifest.");
+            const error = new errors_1.MediaError("MEDIA_STARTING_TIME_NOT_FOUND", "Wanted starting time not found in the Manifest.");
             return this._onFatalError(error);
         }
         /** Interface to create media buffers. */
-        var segmentBuffersStore = new SegmentBuffersStore(mediaElement, mediaSource);
-        cancelSignal.register(function () {
+        const segmentBuffersStore = new segment_buffers_1.default(mediaElement, mediaSource);
+        cancelSignal.register(() => {
             segmentBuffersStore.disposeAll();
         });
-        var _b = performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, function (err) { return _this.trigger("warning", err); }, cancelSignal), autoPlayResult = _b.autoPlayResult, initialPlayPerformed = _b.initialPlayPerformed, initialSeekPerformed = _b.initialSeekPerformed;
+        const { autoPlayResult, initialPlayPerformed, initialSeekPerformed } = (0, initial_seek_and_play_1.default)(mediaElement, playbackObserver, initialTime, autoPlay, (err) => this.trigger("warning", err), cancelSignal);
         if (cancelSignal.isCancelled()) {
             return;
         }
-        initialPlayPerformed.onUpdate(function (isPerformed, stopListening) {
+        initialPlayPerformed.onUpdate((isPerformed, stopListening) => {
             if (isPerformed) {
                 stopListening();
-                streamEventsEmitter(manifest, mediaElement, playbackObserver, function (evt) { return _this.trigger("streamEvent", evt); }, function (evt) { return _this.trigger("streamEventSkip", evt); }, cancelSignal);
+                const streamEventsEmitter = new stream_events_emitter_1.default(manifest, mediaElement, playbackObserver);
+                streamEventsEmitter.addEventListener("event", (payload) => {
+                    this.trigger("streamEvent", payload);
+                }, cancelSignal);
+                streamEventsEmitter.addEventListener("eventSkip", (payload) => {
+                    this.trigger("streamEventSkip", payload);
+                }, cancelSignal);
+                streamEventsEmitter.start();
+                cancelSignal.register(() => {
+                    streamEventsEmitter.stop();
+                });
             }
         }, { clearSignal: cancelSignal, emitCurrentValue: true });
-        var streamObserver = createStreamPlaybackObserver(manifest, playbackObserver, { autoPlay: autoPlay, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed, speed: speed, startTime: initialTime });
-        var rebufferingController = this._createRebufferingController(playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal);
-        rebufferingController.addEventListener("needsReload", function () {
+        const streamObserver = (0, create_stream_playback_observer_1.default)(playbackObserver, { autoPlay,
+            manifest,
+            initialPlayPerformed,
+            initialSeekPerformed,
+            speed,
+            startTime: initialTime }, cancelSignal);
+        const rebufferingController = this._createRebufferingController(playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal);
+        rebufferingController.addEventListener("needsReload", () => {
             // NOTE couldn't both be always calculated at event destination?
             // Maybe there are exceptions?
-            var position = initialSeekPerformed.getValue() ?
+            const position = initialSeekPerformed.getValue() ?
                 playbackObserver.getCurrentTime() :
                 initialTime;
-            var autoplay = initialPlayPerformed.getValue() ?
+            const autoplay = initialPlayPerformed.getValue() ?
                 !playbackObserver.getIsPaused() :
                 autoPlay;
-            onReloadOrder({ position: position, autoPlay: autoplay });
+            onReloadOrder({ position, autoPlay: autoplay });
         }, cancelSignal);
-        var contentTimeBoundariesObserver = this
+        const contentTimeBoundariesObserver = this
             ._createContentTimeBoundariesObserver(manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal);
         /**
          * Emit a "loaded" events once the initial play has been performed and the
@@ -361,24 +315,24 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
          * Also emits warning events if issues arise when doing so.
          */
         autoPlayResult
-            .then(function () {
-            getLoadedReference(playbackObserver, mediaElement, false, cancelSignal)
-                .onUpdate(function (isLoaded, stopListening) {
+            .then(() => {
+            (0, get_loaded_reference_1.default)(playbackObserver, mediaElement, false, cancelSignal)
+                .onUpdate((isLoaded, stopListening) => {
                 if (isLoaded) {
                     stopListening();
-                    _this.trigger("loaded", { segmentBuffersStore: segmentBuffersStore });
+                    this.trigger("loaded", { segmentBuffersStore });
                 }
             }, { emitCurrentValue: true, clearSignal: cancelSignal });
         })
-            .catch(function (err) {
+            .catch((err) => {
             if (cancelSignal.isCancelled()) {
                 return; // Current loading cancelled, no need to trigger the error
             }
-            _this._onFatalError(err);
+            this._onFatalError(err);
         });
         /* eslint-disable-next-line @typescript-eslint/no-this-alias */
-        var self = this;
-        StreamOrchestrator({ manifest: manifest, initialPeriod: initialPeriod }, streamObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, bufferOptions, handleStreamOrchestratorCallbacks(), cancelSignal);
+        const self = this;
+        (0, stream_1.default)({ manifest, initialPeriod }, streamObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, bufferOptions, handleStreamOrchestratorCallbacks(), cancelSignal);
         /**
          * Returns Object handling the callbacks from a `StreamOrchestrator`, which
          * are basically how it communicates about events.
@@ -386,8 +340,8 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
          */
         function handleStreamOrchestratorCallbacks() {
             return {
-                needsBufferFlush: function () {
-                    var seekedTime = mediaElement.currentTime + 0.001;
+                needsBufferFlush: () => {
+                    const seekedTime = mediaElement.currentTime + 0.001;
                     playbackObserver.setCurrentTime(seekedTime);
                     // Seek again once data begins to be buffered.
                     // This is sadly necessary on some browsers to avoid decoding
@@ -403,7 +357,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                     // `needsBufferFlush` once MSE media removal operations have been
                     // explicitely validated by the browser, but that's a complex and easy
                     // to break system.
-                    playbackObserver.listen(function (obs, stopListening) {
+                    playbackObserver.listen((obs, stopListening) => {
                         if (
                         // Data is buffered around the current position
                         obs.currentRange !== null ||
@@ -414,14 +368,14 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                         }
                     }, { includeLastObservation: false, clearSignal: cancelSignal });
                 },
-                streamStatusUpdate: function (value) {
+                streamStatusUpdate(value) {
                     // Announce discontinuities if found
-                    var period = value.period, bufferType = value.bufferType, imminentDiscontinuity = value.imminentDiscontinuity, position = value.position;
+                    const { period, bufferType, imminentDiscontinuity, position } = value;
                     rebufferingController.updateDiscontinuityInfo({
-                        period: period,
-                        bufferType: bufferType,
+                        period,
+                        bufferType,
                         discontinuity: imminentDiscontinuity,
-                        position: position,
+                        position,
                     });
                     if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
@@ -431,7 +385,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                     // ContentTimeBoundariesObserver.
                     if (manifest.isLastPeriodKnown &&
                         value.period.id === manifest.periods[manifest.periods.length - 1].id) {
-                        var hasFinishedLoadingLastPeriod = value.hasFinishedLoading ||
+                        const hasFinishedLoadingLastPeriod = value.hasFinishedLoading ||
                             value.isEmptyStream;
                         if (hasFinishedLoadingLastPeriod) {
                             contentTimeBoundariesObserver
@@ -443,79 +397,92 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                         }
                     }
                 },
-                needsManifestRefresh: function () { return self._manifestFetcher.scheduleManualRefresh({
+                needsManifestRefresh: () => self._manifestFetcher.scheduleManualRefresh({
                     enablePartialRefresh: true,
                     canUseUnsafeMode: true,
-                }); },
-                manifestMightBeOufOfSync: function () {
-                    var OUT_OF_SYNC_MANIFEST_REFRESH_DELAY = config.getCurrent().OUT_OF_SYNC_MANIFEST_REFRESH_DELAY;
+                }),
+                manifestMightBeOufOfSync: () => {
+                    const { OUT_OF_SYNC_MANIFEST_REFRESH_DELAY } = config_1.default.getCurrent();
                     self._manifestFetcher.scheduleManualRefresh({
                         enablePartialRefresh: false,
                         canUseUnsafeMode: false,
                         delay: OUT_OF_SYNC_MANIFEST_REFRESH_DELAY,
                     });
                 },
-                lockedStream: function (value) {
-                    return rebufferingController.onLockedStream(value.bufferType, value.period);
-                },
-                adaptationChange: function (value) {
+                lockedStream: (value) => rebufferingController.onLockedStream(value.bufferType, value.period),
+                adaptationChange: (value) => {
                     self.trigger("adaptationChange", value);
                     if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     contentTimeBoundariesObserver.onAdaptationChange(value.type, value.period, value.adaptation);
                 },
-                representationChange: function (value) {
+                representationChange: (value) => {
                     self.trigger("representationChange", value);
                     if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     contentTimeBoundariesObserver.onRepresentationChange(value.type, value.period);
                 },
-                inbandEvent: function (value) { return self.trigger("inbandEvents", value); },
-                warning: function (value) { return self.trigger("warning", value); },
-                periodStreamReady: function (value) { return self.trigger("periodStreamReady", value); },
-                periodStreamCleared: function (value) {
+                inbandEvent: (value) => self.trigger("inbandEvents", value),
+                warning: (value) => self.trigger("warning", value),
+                periodStreamReady: (value) => self.trigger("periodStreamReady", value),
+                periodStreamCleared: (value) => {
                     contentTimeBoundariesObserver.onPeriodCleared(value.type, value.period);
                     if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     self.trigger("periodStreamCleared", value);
                 },
-                bitrateEstimateChange: function (value) {
-                    return self.trigger("bitrateEstimateChange", value);
+                bitrateEstimateChange: (value) => self.trigger("bitrateEstimateChange", value),
+                needsMediaSourceReload: (payload) => {
+                    var _a, _b;
+                    const lastObservation = streamObserver.getReference().getValue();
+                    const currentPosition = (_a = lastObservation.position.pending) !== null && _a !== void 0 ? _a : streamObserver.getCurrentTime();
+                    const isPaused = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : streamObserver.getIsPaused();
+                    let position = currentPosition + payload.timeOffset;
+                    if (payload.minimumPosition !== undefined) {
+                        position = Math.max(payload.minimumPosition, position);
+                    }
+                    if (payload.maximumPosition !== undefined) {
+                        position = Math.min(payload.maximumPosition, position);
+                    }
+                    onReloadOrder({ position, autoPlay: !isPaused });
                 },
-                addedSegment: function (value) { return self.trigger("addedSegment", value); },
-                needsMediaSourceReload: function (value) { return onReloadOrder(value); },
-                needsDecipherabilityFlush: function (value) {
-                    var keySystem = getKeySystemConfiguration(mediaElement);
-                    if (shouldReloadMediaSourceOnDecipherabilityUpdate(keySystem === null || keySystem === void 0 ? void 0 : keySystem[0])) {
-                        onReloadOrder(value);
+                needsDecipherabilityFlush() {
+                    var _a, _b, _c;
+                    const keySystem = (0, decrypt_1.getKeySystemConfiguration)(mediaElement);
+                    if ((0, compat_1.shouldReloadMediaSourceOnDecipherabilityUpdate)(keySystem === null || keySystem === void 0 ? void 0 : keySystem[0])) {
+                        const lastObservation = streamObserver.getReference().getValue();
+                        const position = (_a = lastObservation.position.pending) !== null && _a !== void 0 ? _a : streamObserver.getCurrentTime();
+                        const isPaused = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : streamObserver.getIsPaused();
+                        onReloadOrder({ position, autoPlay: !isPaused });
                     }
                     else {
+                        const lastObservation = streamObserver.getReference().getValue();
+                        const position = (_c = lastObservation.position.pending) !== null && _c !== void 0 ? _c : streamObserver.getCurrentTime();
                         // simple seek close to the current position
                         // to flush the buffers
-                        if (value.position + 0.001 < value.duration) {
+                        if (position + 0.001 < lastObservation.duration) {
                             playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
                         }
                         else {
-                            playbackObserver.setCurrentTime(value.position);
+                            playbackObserver.setCurrentTime(position);
                         }
                     }
                 },
-                encryptionDataEncountered: function (value) {
-                    for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
-                        var protectionData = value_1[_i];
+                encryptionDataEncountered: (value) => {
+                    for (const protectionData of value) {
                         protectionRef.setValue(protectionData);
                         if (cancelSignal.isCancelled()) {
                             return; // Previous call has stopped streams due to a side-effect
                         }
                     }
                 },
-                error: function (err) { return self._onFatalError(err); },
+                error: (err) => self._onFatalError(err),
             };
         }
-    };
+    }
     /**
      * Creates a `ContentTimeBoundariesObserver`, a class indicating various
      * events related to media time (such as duration updates, period changes,
@@ -531,47 +498,44 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
      * @param {Object} cancelSignal
      * @returns {Object}
      */
-    MediaSourceContentInitializer.prototype._createContentTimeBoundariesObserver = function (manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal) {
-        var _this = this;
+    _createContentTimeBoundariesObserver(manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal) {
         /** Maintains the MediaSource's duration up-to-date with the Manifest */
-        var mediaSourceDurationUpdater = new MediaSourceDurationUpdater(mediaSource);
-        cancelSignal.register(function () {
+        const mediaSourceDurationUpdater = new media_source_duration_updater_1.default(mediaSource);
+        cancelSignal.register(() => {
             mediaSourceDurationUpdater.stopUpdating();
         });
         /** Allows to cancel a pending `end-of-stream` operation. */
-        var endOfStreamCanceller = null;
-        var contentTimeBoundariesObserver = new ContentTimeBoundariesObserver(manifest, streamObserver, segmentBuffersStore.getBufferTypes());
-        cancelSignal.register(function () {
+        let endOfStreamCanceller = null;
+        const contentTimeBoundariesObserver = new content_time_boundaries_observer_1.default(manifest, streamObserver, segmentBuffersStore.getBufferTypes());
+        cancelSignal.register(() => {
             contentTimeBoundariesObserver.dispose();
         });
-        contentTimeBoundariesObserver.addEventListener("warning", function (err) {
-            return _this.trigger("warning", err);
-        });
-        contentTimeBoundariesObserver.addEventListener("periodChange", function (period) {
-            _this.trigger("activePeriodChanged", { period: period });
+        contentTimeBoundariesObserver.addEventListener("warning", (err) => this.trigger("warning", err));
+        contentTimeBoundariesObserver.addEventListener("periodChange", (period) => {
+            this.trigger("activePeriodChanged", { period });
         });
-        contentTimeBoundariesObserver.addEventListener("durationUpdate", function (newDuration) {
+        contentTimeBoundariesObserver.addEventListener("durationUpdate", (newDuration) => {
             mediaSourceDurationUpdater.updateDuration(newDuration.duration, newDuration.isEnd);
         });
-        contentTimeBoundariesObserver.addEventListener("endOfStream", function () {
+        contentTimeBoundariesObserver.addEventListener("endOfStream", () => {
             if (endOfStreamCanceller === null) {
-                endOfStreamCanceller = new TaskCanceller();
+                endOfStreamCanceller = new task_canceller_1.default();
                 endOfStreamCanceller.linkToSignal(cancelSignal);
-                log.debug("Init: end-of-stream order received.");
-                maintainEndOfStream(mediaSource, endOfStreamCanceller.signal);
+                log_1.default.debug("Init: end-of-stream order received.");
+                (0, end_of_stream_1.maintainEndOfStream)(mediaSource, endOfStreamCanceller.signal);
             }
         });
-        contentTimeBoundariesObserver.addEventListener("resumeStream", function () {
+        contentTimeBoundariesObserver.addEventListener("resumeStream", () => {
             if (endOfStreamCanceller !== null) {
-                log.debug("Init: resume-stream order received.");
+                log_1.default.debug("Init: resume-stream order received.");
                 endOfStreamCanceller.cancel();
                 endOfStreamCanceller = null;
             }
         });
-        var currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
+        const currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
         mediaSourceDurationUpdater.updateDuration(currentDuration.duration, currentDuration.isEnd);
         return contentTimeBoundariesObserver;
-    };
+    }
     /**
      * Creates a `RebufferingController`, a class trying to avoid various stalling
      * situations (such as rebuffering periods), and returns it.
@@ -590,17 +554,15 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
      * @param {Object} cancelSignal
      * @returns {Object}
      */
-    MediaSourceContentInitializer.prototype._createRebufferingController = function (playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal) {
-        var _this = this;
-        var rebufferingController = new RebufferingController(playbackObserver, manifest, segmentBuffersStore, speed);
+    _createRebufferingController(playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal) {
+        const rebufferingController = new rebuffering_controller_1.default(playbackObserver, manifest, segmentBuffersStore, speed);
         // Bubble-up events
-        rebufferingController.addEventListener("stalled", function (evt) { return _this.trigger("stalled", evt); });
-        rebufferingController.addEventListener("unstalled", function () { return _this.trigger("unstalled", null); });
-        rebufferingController.addEventListener("warning", function (err) { return _this.trigger("warning", err); });
-        cancelSignal.register(function () { return rebufferingController.destroy(); });
+        rebufferingController.addEventListener("stalled", (evt) => this.trigger("stalled", evt));
+        rebufferingController.addEventListener("unstalled", () => this.trigger("unstalled", null));
+        rebufferingController.addEventListener("warning", (err) => this.trigger("warning", err));
+        cancelSignal.register(() => rebufferingController.destroy());
         rebufferingController.start();
         return rebufferingController;
-    };
-    return MediaSourceContentInitializer;
-}(ContentInitializer));
-export default MediaSourceContentInitializer;
+    }
+}
+exports.default = MediaSourceContentInitializer;