rx-player 4.4.1-dev.2025101500 → 4.4.1

package/dist/commonjs/main_thread/init/media_source_content_initializer.js

@@ -1,4 +1,19 @@
 "use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * 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 ||
@@ -61,31 +76,6 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -98,21 +88,29 @@ var __values = (this && this.__values) || function(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var eme_1 = require("../../compat/eme");
+var is_codec_supported_1 = require("../../compat/is_codec_supported");
 var may_media_element_fail_on_undecipherable_data_1 = require("../../compat/may_media_element_fail_on_undecipherable_data");
 var should_reload_media_source_on_decipherability_update_1 = require("../../compat/should_reload_media_source_on_decipherability_update");
+var config_1 = require("../../config");
+var adaptive_1 = require("../../core/adaptive");
+var cmcd_1 = require("../../core/cmcd");
+var fetchers_1 = require("../../core/fetchers");
+var create_content_time_boundaries_observer_1 = require("../../core/main/common/create_content_time_boundaries_observer");
+var FreezeResolver_1 = require("../../core/main/common/FreezeResolver");
+var get_thumbnail_data_1 = require("../../core/main/common/get_thumbnail_data");
+var synchronize_sinks_on_observation_1 = require("../../core/main/common/synchronize_sinks_on_observation");
+var segment_sinks_1 = require("../../core/segment_sinks");
+var stream_1 = require("../../core/stream");
 var errors_1 = require("../../errors");
 var features_1 = require("../../features");
 var log_1 = require("../../log");
-var manifest_1 = require("../../manifest");
-var main_media_source_interface_1 = require("../../mse/main_media_source_interface");
-var array_find_1 = require("../../utils/array_find");
+var are_arrays_of_numbers_equal_1 = require("../../utils/are_arrays_of_numbers_equal");
 var assert_1 = require("../../utils/assert");
-var id_generator_1 = require("../../utils/id_generator");
+var create_cancellable_promise_1 = require("../../utils/create_cancellable_promise");
 var is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+var noop_1 = require("../../utils/noop");
 var object_assign_1 = require("../../utils/object_assign");
-var reference_1 = require("../../utils/reference");
-var request_1 = require("../../utils/request");
+var sync_or_async_1 = require("../../utils/sync_or_async");
 var task_canceller_1 = require("../../utils/task_canceller");
 var decrypt_1 = require("../decrypt");
 var types_1 = require("./types");
@@ -121,12 +119,20 @@ var create_media_source_1 = require("./utils/create_media_source");
 var get_initial_time_1 = require("./utils/get_initial_time");
 var get_loaded_reference_1 = require("./utils/get_loaded_reference");
 var initial_seek_and_play_1 = require("./utils/initial_seek_and_play");
+var initialize_content_decryption_1 = require("./utils/initialize_content_decryption");
+var main_thread_text_displayer_interface_1 = require("./utils/main_thread_text_displayer_interface");
 var rebuffering_controller_1 = require("./utils/rebuffering_controller");
-var stream_events_emitter_1 = require("./utils/stream_events_emitter/stream_events_emitter");
+var stream_events_emitter_1 = require("./utils/stream_events_emitter");
 var throw_on_media_error_1 = require("./utils/throw_on_media_error");
-var update_manifest_codec_support_1 = require("./utils/update_manifest_codec_support");
-var generateContentId = (0, id_generator_1.default)();
 /**
+ * Allows to load a new content thanks to the MediaSource Extensions (a.k.a. MSE)
+ * Web APIs.
+ *
+ * Through this `ContentInitializer`, a Manifest will be fetched (and depending
+ * on the situation, refreshed), a `MediaSource` instance will be linked to the
+ * wanted `HTMLMediaElement` and chunks of media data, called segments, will be
+ * pushed on buffers associated to this `MediaSource` instance.
+ *
  * @class MediaSourceContentInitializer
  */
 var MediaSourceContentInitializer = /** @class */ (function (_super) {
@@ -138,148 +144,58 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
      */
     function MediaSourceContentInitializer(settings) {
         var _this = _super.call(this) || this;
-        _this._settings = settings;
+        _this._initSettings = settings;
         _this._initCanceller = new task_canceller_1.default();
-        _this._currentMediaSourceCanceller = new task_canceller_1.default();
-        _this._currentMediaSourceCanceller.linkToSignal(_this._initCanceller.signal);
-        _this._currentContentInfo = null;
-        _this._awaitingRequests = {
-            nextRequestId: 0,
-            pendingSinkMetrics: new Map(),
-            pendingThumbnailFetching: new Map(),
-        };
-        _this._queuedCoreMessages = null;
+        _this._manifest = null;
+        _this._decryptionCapabilities = { status: "uninitialized", value: null };
+        var urls = settings.url === undefined ? undefined : [settings.url];
+        _this._cmcdDataBuilder =
+            settings.cmcd === undefined ? null : new cmcd_1.default(settings.cmcd);
+        _this._manifestFetcher = new fetchers_1.ManifestFetcher(urls, settings.transport, __assign(__assign({}, settings.manifestRequestSettings), { lowLatencyMode: settings.lowLatencyMode, cmcdDataBuilder: _this._cmcdDataBuilder }));
         return _this;
     }
     /**
      * 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;
-        var _a, _b;
-        if (this._currentContentInfo !== null || this._initCanceller.isUsed()) {
+        if (this._manifest !== null) {
             return;
         }
-        var contentId = generateContentId();
-        var _c = this._settings, adaptiveOptions = _c.adaptiveOptions, transport = _c.transport, transportOptions = _c.transportOptions, useMseInWorker = _c.useMseInWorker, coreInterface = _c.coreInterface;
-        var _d = this._settings.bufferOptions, wantedBufferAhead = _d.wantedBufferAhead, maxVideoBufferSize = _d.maxVideoBufferSize, maxBufferAhead = _d.maxBufferAhead, maxBufferBehind = _d.maxBufferBehind;
-        var initialVideoBitrate = adaptiveOptions.initialBitrates.video;
-        var initialAudioBitrate = adaptiveOptions.initialBitrates.audio;
-        this._currentContentInfo = {
-            contentId: contentId,
-            contentDecryptor: null,
-            manifest: null,
-            mediaSourceInfo: null,
-            rebufferingController: null,
-            streamEventsEmitter: null,
-            initialTime: undefined,
-            autoPlay: undefined,
-            initialPlayPerformed: null,
-            useMseInWorker: useMseInWorker,
-        };
-        coreInterface.sendMessage({
-            type: "prepare" /* MainThreadMessageType.PrepareContent */,
-            value: {
-                contentId: contentId,
-                cmcd: this._settings.cmcd,
-                enableRepresentationAvoidance: this._settings.enableRepresentationAvoidance,
-                url: this._settings.url,
-                hasText: this._hasTextBufferFeature(),
-                transport: transport,
-                transportOptions: transportOptions,
-                initialVideoBitrate: initialVideoBitrate,
-                initialAudioBitrate: initialAudioBitrate,
-                manifestRetryOptions: __assign(__assign({}, this._settings.manifestRequestSettings), { lowLatencyMode: this._settings.lowLatencyMode }),
-                segmentRetryOptions: this._settings.segmentRequestOptions,
-                useMseInWorker: useMseInWorker,
-            },
-        });
-        this._initCanceller.signal.register(function () {
-            coreInterface.sendMessage({
-                type: "stop" /* MainThreadMessageType.StopContent */,
-                contentId: contentId,
-                value: null,
+        this._manifest = sync_or_async_1.default.createAsync((0, create_cancellable_promise_1.default)(this._initCanceller.signal, function (res, rej) {
+            _this._manifestFetcher.addEventListener("warning", function (err) {
+                return _this.trigger("warning", err);
             });
-        });
-        if (this._initCanceller.isUsed()) {
-            return;
-        }
-        this._queuedCoreMessages = [];
-        log_1.default.debug("Init", "addEventListener prepare buffering core messages");
-        var onmessage = function (msgData) {
-            if (msgData.type !== "log" /* CoreMessageType.LogMessage */) {
-                log_1.default.debug("Init", "Core message received", msgData.type);
-            }
-            var type = msgData.type;
-            switch (type) {
-                case "log" /* CoreMessageType.LogMessage */: {
-                    var formatted = msgData.value.logs.map(function (l) {
-                        switch (typeof l) {
-                            case "string":
-                            case "number":
-                            case "boolean":
-                            case "undefined":
-                                return l;
-                            case "object":
-                                if (l === null) {
-                                    return null;
-                                }
-                                return formatSentLogObject(l);
-                            default:
-                                (0, assert_1.assertUnreachable)(l);
-                        }
-                    });
-                    switch (msgData.value.logLevel) {
-                        case "NONE":
-                            break;
-                        case "ERROR":
-                            log_1.default.error.apply(log_1.default, __spreadArray([msgData.value.namespace], __read(formatted), false));
-                            break;
-                        case "WARNING":
-                            log_1.default.warn.apply(log_1.default, __spreadArray([msgData.value.namespace], __read(formatted), false));
-                            break;
-                        case "INFO":
-                            log_1.default.info.apply(log_1.default, __spreadArray([msgData.value.namespace], __read(formatted), false));
-                            break;
-                        case "DEBUG":
-                            log_1.default.debug.apply(log_1.default, __spreadArray([msgData.value.namespace], __read(formatted), false));
-                            break;
-                        default:
-                            (0, assert_1.assertUnreachable)(msgData.value.logLevel);
-                    }
-                    break;
-                }
-                default:
-                    if (_this._queuedCoreMessages !== null) {
-                        _this._queuedCoreMessages.push(msgData);
-                    }
-                    break;
-            }
-        };
-        this._settings.coreInterface.addMessageListener(onmessage);
-        var onmessageerror = function () {
-            log_1.default.error("Init", "Error when receiving message from core.");
-        };
-        this._settings.coreInterface.addErrorListener(onmessageerror);
+            _this._manifestFetcher.addEventListener("error", function (err) {
+                _this.trigger("error", err);
+                rej(err);
+            });
+            _this._manifestFetcher.addEventListener("manifestReady", function (manifest) {
+                res(manifest);
+            });
+        }));
+        this._manifestFetcher.start();
         this._initCanceller.signal.register(function () {
-            log_1.default.debug("Init", "removeEventListener prepare for core message");
-            _this._settings.coreInterface.removeMessageListener(onmessage);
-            _this._settings.coreInterface.removeErrorListener(onmessageerror);
+            _this._manifestFetcher.dispose();
         });
-        // Also bind all `SharedReference` objects:
-        var throttleVideoBitrate = (_a = adaptiveOptions.throttlers.throttleBitrate.video) !== null && _a !== void 0 ? _a : new reference_1.default(Infinity);
-        bindNumberReferencesToCore(coreInterface, this._initCanceller.signal, [wantedBufferAhead, "wantedBufferAhead"], [maxVideoBufferSize, "maxVideoBufferSize"], [maxBufferAhead, "maxBufferAhead"], [maxBufferBehind, "maxBufferBehind"], [throttleVideoBitrate, "throttleVideoBitrate"]);
-        var limitVideoResolution = (_b = adaptiveOptions.throttlers.limitResolution.video) !== null && _b !== void 0 ? _b : new reference_1.default({
-            height: undefined,
-            width: undefined,
-            pixelRatio: 1,
+    };
+    /**
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} playbackObserver
+     */
+    MediaSourceContentInitializer.prototype.start = function (mediaElement, playbackObserver) {
+        var _this = this;
+        this.prepare(); // Load Manifest if not already done
+        /** Translate errors coming from the media element into RxPlayer errors. */
+        (0, throw_on_media_error_1.default)(mediaElement, function (error) { return _this._onFatalError(error); }, this._initCanceller.signal);
+        this._setupInitialMediaSourceAndDecryption(mediaElement)
+            .then(function (initResult) {
+            return _this._onInitialMediaSourceReady(mediaElement, initResult.mediaSource, playbackObserver, initResult.drmSystemId, initResult.unlinkMediaSource);
+        })
+            .catch(function (err) {
+            _this._onFatalError(err);
         });
-        limitVideoResolution.onUpdate(function (newVal) {
-            coreInterface.sendMessage({
-                type: "ref-update" /* MainThreadMessageType.ReferenceUpdate */,
-                value: { name: "limitVideoResolution", newVal: newVal },
-            });
-        }, { clearSignal: this._initCanceller.signal, emitCurrentValue: true });
     };
     /**
      * Update URL of the Manifest.
@@ -289,1069 +205,664 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
      * DASH's MPD) will be refreshed immediately.
      */
     MediaSourceContentInitializer.prototype.updateContentUrls = function (urls, refreshNow) {
-        if (this._currentContentInfo === null) {
+        this._manifestFetcher.updateContentUrls(urls, refreshNow);
+    };
+    /**
+     * Stop content and free all resources linked to this
+     * `MediaSourceContentInitializer`.
+     */
+    MediaSourceContentInitializer.prototype.dispose = function () {
+        this._initCanceller.cancel();
+    };
+    /**
+     * Callback called when an error interrupting playback arised.
+     * @param {*} err
+     */
+    MediaSourceContentInitializer.prototype._onFatalError = function (err) {
+        if (this._initCanceller.isUsed()) {
             return;
         }
-        this._settings.coreInterface.sendMessage({
-            type: "urls-update" /* MainThreadMessageType.ContentUrlsUpdate */,
-            contentId: this._currentContentInfo.contentId,
-            value: { urls: urls, refreshNow: refreshNow },
+        this._initCanceller.cancel();
+        this.trigger("error", err);
+    };
+    /**
+     * Initialize decryption mechanisms if needed and begin creating and relying
+     * on the initial `MediaSourceInterface` for this content.
+     * @param {HTMLMediaElement|null} mediaElement
+     * @returns {Promise.<Object>}
+     */
+    MediaSourceContentInitializer.prototype._setupInitialMediaSourceAndDecryption = function (mediaElement) {
+        var _this = this;
+        var initCanceller = this._initCanceller;
+        return (0, create_cancellable_promise_1.default)(initCanceller.signal, function (resolve) {
+            var keySystems = _this._initSettings.keySystems;
+            /** Initialize decryption capabilities. */
+            var _a = (0, initialize_content_decryption_1.default)(mediaElement, keySystems, {
+                onWarning: function (err) { return _this.trigger("warning", err); },
+                onError: function (err) { return _this._onFatalError(err); },
+                onBlackListProtectionData: function (val) {
+                    // Ugly IIFE workaround to allow async event listener
+                    (function () { return __awaiter(_this, void 0, void 0, function () {
+                        var manifest, _a;
+                        var _b;
+                        return __generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    if (this._manifest === null) {
+                                        return [2 /*return*/];
+                                    }
+                                    if (!((_b = this._manifest.syncValue) !== null && _b !== void 0)) return [3 /*break*/, 1];
+                                    _a = _b;
+                                    return [3 /*break*/, 3];
+                                case 1: return [4 /*yield*/, this._manifest.getValueAsAsync()];
+                                case 2:
+                                    _a = (_c.sent());
+                                    _c.label = 3;
+                                case 3:
+                                    manifest = _a;
+                                    blackListProtectionDataOnManifest(manifest, val);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })().catch(noop_1.default);
+                },
+                onKeyIdsCompatibilityUpdate: function (updates) {
+                    // Ugly IIFE workaround to allow async event listener
+                    (function () { return __awaiter(_this, void 0, void 0, function () {
+                        var manifest, _a;
+                        var _b;
+                        return __generator(this, function (_c) {
+                            switch (_c.label) {
+                                case 0:
+                                    if (this._manifest === null) {
+                                        return [2 /*return*/];
+                                    }
+                                    if (!((_b = this._manifest.syncValue) !== null && _b !== void 0)) return [3 /*break*/, 1];
+                                    _a = _b;
+                                    return [3 /*break*/, 3];
+                                case 1: return [4 /*yield*/, this._manifest.getValueAsAsync()];
+                                case 2:
+                                    _a = (_c.sent());
+                                    _c.label = 3;
+                                case 3:
+                                    manifest = _a;
+                                    updateKeyIdsDecipherabilityOnManifest(manifest, updates.whitelistedKeyIds, updates.blacklistedKeyIds, updates.delistedKeyIds);
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })().catch(noop_1.default);
+                },
+                onCodecSupportUpdate: function () {
+                    var _a, _b;
+                    var syncManifest = (_a = _this._manifest) === null || _a === void 0 ? void 0 : _a.syncValue;
+                    if ((0, is_null_or_undefined_1.default)(syncManifest)) {
+                        // The Manifest is not yet fetched, but we will be able to check
+                        // the codecs once it is the case
+                        (_b = _this._manifest) === null || _b === void 0 ? void 0 : _b.getValueAsAsync().then(function (loadedManifest) {
+                            if (_this._initCanceller.isUsed()) {
+                                return;
+                            }
+                            _this._refreshManifestCodecSupport(loadedManifest, mediaElement);
+                        }, noop_1.default);
+                    }
+                    else {
+                        _this._refreshManifestCodecSupport(syncManifest, mediaElement);
+                    }
+                },
+            }, initCanceller.signal), drmInitRef = _a.statusRef, contentDecryptor = _a.contentDecryptor;
+            if (contentDecryptor.enabled) {
+                _this._decryptionCapabilities = {
+                    status: "enabled",
+                    value: contentDecryptor.value,
+                };
+            }
+            else {
+                _this._decryptionCapabilities = {
+                    status: "disabled",
+                    value: contentDecryptor.value,
+                };
+            }
+            drmInitRef.onUpdate(function (drmStatus, stopListeningToDrmUpdates) {
+                if (drmStatus.initializationState.type === "uninitialized") {
+                    return;
+                }
+                stopListeningToDrmUpdates();
+                var mediaSourceCanceller = new task_canceller_1.default();
+                mediaSourceCanceller.linkToSignal(initCanceller.signal);
+                (0, create_media_source_1.default)(mediaElement, mediaSourceCanceller.signal)
+                    .then(function (mediaSource) {
+                    var lastDrmStatus = drmInitRef.getValue();
+                    if (lastDrmStatus.initializationState.type === "awaiting-media-link") {
+                        lastDrmStatus.initializationState.value.isMediaLinked.setValue(true);
+                        drmInitRef.onUpdate(function (newDrmStatus, stopListeningToDrmUpdatesAgain) {
+                            if (newDrmStatus.initializationState.type === "initialized") {
+                                stopListeningToDrmUpdatesAgain();
+                                resolve({
+                                    mediaSource: mediaSource,
+                                    drmSystemId: newDrmStatus.drmSystemId,
+                                    unlinkMediaSource: mediaSourceCanceller,
+                                });
+                                return;
+                            }
+                        }, { emitCurrentValue: true, clearSignal: initCanceller.signal });
+                    }
+                    else if (drmStatus.initializationState.type === "initialized") {
+                        resolve({
+                            mediaSource: mediaSource,
+                            drmSystemId: drmStatus.drmSystemId,
+                            unlinkMediaSource: mediaSourceCanceller,
+                        });
+                        return;
+                    }
+                })
+                    .catch(function (err) {
+                    if (mediaSourceCanceller.isUsed()) {
+                        return;
+                    }
+                    _this._onFatalError(err);
+                });
+            }, { emitCurrentValue: true, clearSignal: initCanceller.signal });
+        });
+    };
+    MediaSourceContentInitializer.prototype._onInitialMediaSourceReady = function (mediaElement, initialMediaSource, playbackObserver, drmSystemId, initialMediaSourceCanceller) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, adaptiveOptions, autoPlay, bufferOptions, lowLatencyMode, segmentRequestOptions, speed, startAt, textTrackOptions, transport, initCanceller, manifest, _b, _e_1, initialTime, representationEstimator, subBufferOptions, cdnPrioritizer, segmentQueueCreator;
+            var _this = this;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _a = this._initSettings, 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;
+                        (0, assert_1.default)(this._manifest !== null);
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 5, , 6]);
+                        if (!((_c = this._manifest.syncValue) !== null && _c !== void 0)) return [3 /*break*/, 2];
+                        _b = _c;
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this._manifest.getValueAsAsync()];
+                    case 3:
+                        _b = (_d.sent());
+                        _d.label = 4;
+                    case 4:
+                        manifest = _b;
+                        return [3 /*break*/, 6];
+                    case 5:
+                        _e_1 = _d.sent();
+                        return [2 /*return*/]; // The error should already have been processed through an event listener
+                    case 6:
+                        manifest.addEventListener("manifestUpdate", function (updates) {
+                            _this.trigger("manifestUpdate", updates);
+                            _this._refreshManifestCodecSupport(manifest, mediaElement);
+                        }, initCanceller.signal);
+                        manifest.addEventListener("decipherabilityUpdate", function (elts) {
+                            _this.trigger("decipherabilityUpdate", elts);
+                        }, initCanceller.signal);
+                        manifest.addEventListener("supportUpdate", function () {
+                            _this.trigger("codecSupportUpdate", null);
+                        }, initCanceller.signal);
+                        log_1.default.debug("Init", "Calculating initial time");
+                        initialTime = (0, get_initial_time_1.default)(manifest, lowLatencyMode, startAt);
+                        log_1.default.debug("Init", "Initial time calculated", { initialTime: initialTime });
+                        representationEstimator = (0, adaptive_1.default)(adaptiveOptions);
+                        subBufferOptions = (0, object_assign_1.default)({ textTrackOptions: textTrackOptions, drmSystemId: drmSystemId }, bufferOptions);
+                        cdnPrioritizer = new fetchers_1.CdnPrioritizer(initCanceller.signal);
+                        segmentQueueCreator = new fetchers_1.SegmentQueueCreator(transport, cdnPrioritizer, this._cmcdDataBuilder, segmentRequestOptions);
+                        this._refreshManifestCodecSupport(manifest, mediaElement);
+                        this.trigger("manifestReady", manifest);
+                        if (initCanceller.isUsed()) {
+                            return [2 /*return*/];
+                        }
+                        // handle initial load and reloads
+                        this._setupContentWithNewMediaSource({
+                            mediaElement: mediaElement,
+                            playbackObserver: playbackObserver,
+                            mediaSource: initialMediaSource,
+                            initialTime: initialTime,
+                            autoPlay: autoPlay,
+                            manifest: manifest,
+                            representationEstimator: representationEstimator,
+                            cdnPrioritizer: cdnPrioritizer,
+                            segmentQueueCreator: segmentQueueCreator,
+                            speed: speed,
+                            bufferOptions: subBufferOptions,
+                        }, initialMediaSourceCanceller);
+                        return [2 /*return*/];
+                }
+            });
         });
     };
     /**
-     * @param {HTMLMediaElement} mediaElement
-     * @param {Object} playbackObserver
+     * 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 {Object} args
+     * @param {Object} currentCanceller
      */
-    MediaSourceContentInitializer.prototype.start = function (mediaElement, playbackObserver) {
-        var e_1, _a;
+    MediaSourceContentInitializer.prototype._setupContentWithNewMediaSource = function (args, currentCanceller) {
+        this._startLoadingContentOnMediaSource(args, this._createReloadMediaSourceCallback(args, currentCanceller), currentCanceller.signal);
+    };
+    /**
+     * Create `IReloadMediaSourceCallback` allowing to handle reload orders.
+     * @param {Object} args
+     * @param {Object} currentCanceller
+     */
+    MediaSourceContentInitializer.prototype._createReloadMediaSourceCallback = function (args, currentCanceller) {
         var _this = this;
-        this.prepare(); // Load Manifest if not already done
-        if (this._initCanceller.isUsed()) {
-            return;
-        }
-        var textDisplayer = null;
-        if (this._settings.textTrackOptions.textTrackMode === "html" &&
-            features_1.default.htmlTextDisplayer !== null) {
-            (0, assert_1.default)(this._hasTextBufferFeature());
-            textDisplayer = new features_1.default.htmlTextDisplayer(mediaElement, this._settings.textTrackOptions.textTrackElement);
-        }
-        else if (features_1.default.nativeTextDisplayer !== null) {
-            (0, assert_1.default)(this._hasTextBufferFeature());
-            textDisplayer = new features_1.default.nativeTextDisplayer(mediaElement);
+        var initCanceller = this._initCanceller;
+        return function (reloadOrder) {
+            currentCanceller.cancel();
+            if (initCanceller.isUsed()) {
+                return;
+            }
+            _this.trigger("reloadingMediaSource", reloadOrder);
+            if (initCanceller.isUsed()) {
+                return;
+            }
+            var newCanceller = new task_canceller_1.default();
+            newCanceller.linkToSignal(initCanceller.signal);
+            (0, create_media_source_1.default)(args.mediaElement, newCanceller.signal)
+                .then(function (newMediaSource) {
+                _this._setupContentWithNewMediaSource(__assign(__assign({}, args), { mediaSource: newMediaSource, initialTime: reloadOrder.position, autoPlay: reloadOrder.autoPlay }), newCanceller);
+            })
+                .catch(function (err) {
+                if (newCanceller.isUsed()) {
+                    return;
+                }
+                _this._onFatalError(err);
+            });
+        };
+    };
+    /**
+     * Buffer the content on the given MediaSource.
+     * @param {Object} args
+     * @param {function} onReloadOrder
+     * @param {Object} cancelSignal
+     */
+    MediaSourceContentInitializer.prototype._startLoadingContentOnMediaSource = function (args, onReloadOrder, cancelSignal) {
+        var _this = this;
+        var _a, _b;
+        var autoPlay = args.autoPlay, bufferOptions = args.bufferOptions, initialTime = args.initialTime, manifest = args.manifest, mediaElement = args.mediaElement, mediaSource = args.mediaSource, playbackObserver = args.playbackObserver, representationEstimator = args.representationEstimator, cdnPrioritizer = args.cdnPrioritizer, segmentQueueCreator = args.segmentQueueCreator, speed = args.speed;
+        var transport = this._initSettings.transport;
+        var initialPeriod = (_a = manifest.getPeriodForTime(initialTime)) !== null && _a !== void 0 ? _a : manifest.getNextPeriod(initialTime);
+        if (initialPeriod === undefined) {
+            var error = new errors_1.MediaError("MEDIA_STARTING_TIME_NOT_FOUND", "Wanted starting time not found in the Manifest.");
+            return this._onFatalError(error);
         }
-        else {
-            (0, assert_1.default)(!this._hasTextBufferFeature());
+        var textDisplayerInterface = null;
+        var textDisplayer = createTextDisplayer(mediaElement, this._initSettings.textTrackOptions);
+        if (textDisplayer !== null) {
+            var sender_1 = new main_thread_text_displayer_interface_1.default(textDisplayer);
+            textDisplayerInterface = sender_1;
+            cancelSignal.register(function () {
+                sender_1.stop();
+                textDisplayer === null || textDisplayer === void 0 ? void 0 : textDisplayer.stop();
+            });
         }
-        this._initCanceller.signal.register(function () {
-            textDisplayer === null || textDisplayer === void 0 ? void 0 : textDisplayer.stop();
+        /** Interface to create media buffers. */
+        var segmentSinksStore = new segment_sinks_1.default(mediaSource, mediaElement.nodeName === "VIDEO", textDisplayerInterface);
+        cancelSignal.register(function () {
+            segmentSinksStore.disposeAll();
         });
-        /** Translate errors coming from the media element into RxPlayer errors. */
-        (0, throw_on_media_error_1.default)(mediaElement, function (error) { return _this._onFatalError(error); }, this._initCanceller.signal);
-        /**
-         * Send content protection initialization data.
-         * TODO remove and use ContentDecryptor directly when possible.
-         */
-        var lastContentProtection = new reference_1.default(null);
-        var mediaSourceStatus = new reference_1.default(0 /* MediaSourceInitializationStatus.Nothing */);
-        var _b = this._initializeContentDecryption(mediaElement, lastContentProtection, mediaSourceStatus, function () { return notifyAndStartMediaSourceReload(0, undefined, undefined); }, this._initCanceller.signal), drmInitializationStatus = _b.statusRef, contentDecryptor = _b.contentDecryptor;
-        var contentInfo = this._currentContentInfo;
-        if (contentInfo !== null) {
-            contentInfo.contentDecryptor = contentDecryptor;
-        }
-        var playbackStartParams = {
+        var _c = (0, initial_seek_and_play_1.default)({
             mediaElement: mediaElement,
-            textDisplayer: textDisplayer,
             playbackObserver: playbackObserver,
-            drmInitializationStatus: drmInitializationStatus,
-            mediaSourceStatus: mediaSourceStatus,
-        };
-        mediaSourceStatus.onUpdate(function (msInitStatus, stopListeningMSStatus) {
-            if (msInitStatus === 2 /* MediaSourceInitializationStatus.Attached */) {
-                stopListeningMSStatus();
-                _this._startPlaybackIfReady(playbackStartParams);
-            }
-        }, { clearSignal: this._initCanceller.signal, emitCurrentValue: true });
-        drmInitializationStatus.onUpdate(function (initializationStatus, stopListeningDrm) {
-            if (initializationStatus.initializationState.type === "initialized") {
-                stopListeningDrm();
-                _this._startPlaybackIfReady(playbackStartParams);
-            }
-        }, { emitCurrentValue: true, clearSignal: this._initCanceller.signal });
-        /**
-         * Reset directly (synchronously) the current `MediaSource` and signal to
-         * the core that we did so.
-         * @param {number} deltaPosition - Position you want to seek to after
-         * reloading, as a delta in seconds from the last polled playing position.
-         * @param {number|undefined} minimumPosition - If set, minimum time bound
-         * in seconds after `deltaPosition` has been applied.
-         * @param {number|undefined} maximumPosition - If set, minimum time bound
-         * in seconds after `deltaPosition` has been applied.
-         */
-        var notifyAndStartMediaSourceReload = function (deltaPosition, minimumPosition, maximumPosition) {
-            var reloadingContentInfo = _this._currentContentInfo;
-            if (reloadingContentInfo === null) {
-                log_1.default.warn("Init", "Asked to reload when no content is loaded.");
-                return;
+            startTime: initialTime,
+            mustAutoPlay: autoPlay,
+            onWarning: function (err) {
+                _this.trigger("warning", err);
+            },
+            isDirectfile: false,
+        }, cancelSignal), autoPlayResult = _c.autoPlayResult, initialPlayPerformed = _c.initialPlayPerformed;
+        if (cancelSignal.isCancelled()) {
+            return;
+        }
+        initialPlayPerformed.onUpdate(function (isPerformed, stopListening) {
+            if (isPerformed) {
+                stopListening();
+                var streamEventsEmitter_1 = new stream_events_emitter_1.default(manifest, playbackObserver);
+                manifest.addEventListener("manifestUpdate", function () {
+                    streamEventsEmitter_1.onManifestUpdate(manifest);
+                }, cancelSignal);
+                streamEventsEmitter_1.addEventListener("event", function (payload) {
+                    _this.trigger("streamEvent", payload);
+                }, cancelSignal);
+                streamEventsEmitter_1.addEventListener("eventSkip", function (payload) {
+                    _this.trigger("streamEventSkip", payload);
+                }, cancelSignal);
+                streamEventsEmitter_1.start();
+                cancelSignal.register(function () {
+                    streamEventsEmitter_1.stop();
+                });
             }
-            if (reloadingContentInfo === null ||
-                reloadingContentInfo.mediaSourceInfo === null) {
-                log_1.default.warn("Init", "Asked to reload when no MediaSource is active.");
+        }, { clearSignal: cancelSignal, emitCurrentValue: true });
+        var coreObserver = (0, create_core_playback_observer_1.default)(playbackObserver, {
+            autoPlay: autoPlay,
+            manifest: manifest,
+            mediaSource: mediaSource,
+            textDisplayer: textDisplayer,
+            initialPlayPerformed: initialPlayPerformed,
+            speed: speed,
+        }, cancelSignal);
+        (_b = this._cmcdDataBuilder) === null || _b === void 0 ? void 0 : _b.startMonitoringPlayback(coreObserver);
+        cancelSignal.register(function () {
+            var _a;
+            (_a = _this._cmcdDataBuilder) === null || _a === void 0 ? void 0 : _a.stopMonitoringPlayback();
+        });
+        var rebufferingController = this._createRebufferingController(playbackObserver, manifest, speed, cancelSignal);
+        var freezeResolver = new FreezeResolver_1.default(segmentSinksStore);
+        if ((0, may_media_element_fail_on_undecipherable_data_1.default)()) {
+            // On some devices, just reload immediately when data become undecipherable
+            manifest.addEventListener("decipherabilityUpdate", function (elts) {
+                if (elts.some(function (e) { return e.representation.decipherable !== true; })) {
+                    reloadMediaSource(0, undefined, undefined);
+                }
+            }, cancelSignal);
+        }
+        coreObserver.listen(function (observation) {
+            (0, synchronize_sinks_on_observation_1.default)(observation, segmentSinksStore);
+            var freezeResolution = freezeResolver.onNewObservation(observation);
+            if (freezeResolution === null) {
                 return;
             }
-            var mediaSourceId = reloadingContentInfo.mediaSourceInfo.type === "main"
-                ? reloadingContentInfo.mediaSourceInfo.mediaSource.id
-                : reloadingContentInfo.mediaSourceInfo.mediaSourceId;
-            _this._settings.coreInterface.sendMessage({
-                type: "ms-reload" /* MainThreadMessageType.MediaSourceReload */,
-                mediaSourceId: mediaSourceId,
-                value: null,
+            // TODO: The following method looks generic, we may be able to factorize
+            // it with other reload handlers after some work.
+            var triggerReload = function () {
+                var _a;
+                var lastObservation = playbackObserver.getReference().getValue();
+                var position = lastObservation.position.isAwaitingFuturePosition()
+                    ? lastObservation.position.getWanted()
+                    : ((_a = coreObserver.getCurrentTime()) !== null && _a !== void 0 ? _a : lastObservation.position.getPolled());
+                var autoplay = initialPlayPerformed.getValue()
+                    ? !playbackObserver.getIsPaused()
+                    : autoPlay;
+                onReloadOrder({ position: position, autoPlay: autoplay });
+            };
+            handleFreezeResolution(freezeResolution, {
+                enableRepresentationAvoidance: _this._initSettings.enableRepresentationAvoidance,
+                manifest: manifest,
+                triggerReload: triggerReload,
+                playbackObserver: playbackObserver,
             });
-            reloadMediaSource(deltaPosition, minimumPosition, maximumPosition);
-        };
+        }, { clearSignal: cancelSignal });
+        var contentTimeBoundariesObserver = (0, create_content_time_boundaries_observer_1.default)(manifest, mediaSource, coreObserver, segmentSinksStore, {
+            onWarning: function (err) { return _this.trigger("warning", err); },
+            onPeriodChanged: function (period) {
+                return _this.trigger("activePeriodChanged", { period: period });
+            },
+        }, cancelSignal);
         /**
-         * Reset directly (synchronously) the current `MediaSource`.
-         *
-         * It is assumed that `core` already knows about this action. If not, call
-         * `notifyAndStartMediaSourceReload` instead.
-         * @param {number} deltaPosition - Position you want to seek to after
-         * reloading, as a delta in seconds from the last polled playing position.
-         * @param {number|undefined} minimumPosition - If set, minimum time bound
-         * in seconds after `deltaPosition` has been applied.
-         * @param {number|undefined} maximumPosition - If set, minimum time bound
-         * in seconds after `deltaPosition` has been applied.
+         * Emit a "loaded" events once the initial play has been performed and the
+         * media can begin playback.
+         * Also emits warning events if issues arise when doing so.
          */
-        var reloadMediaSource = function (deltaPosition, minimumPosition, maximumPosition) {
-            var _a;
-            var reloadingContentInfo = _this._currentContentInfo;
-            if (reloadingContentInfo === null) {
-                log_1.default.warn("Init", "Asked to reload when no content is loaded.");
-                return;
-            }
-            var lastObservation = playbackObserver.getReference().getValue();
-            var currentPosition = lastObservation.position.getWanted();
-            var isPaused = ((_a = reloadingContentInfo.initialPlayPerformed) === null || _a === void 0 ? void 0 : _a.getValue()) === true ||
-                reloadingContentInfo.autoPlay === undefined
-                ? lastObservation.paused
-                : !reloadingContentInfo.autoPlay;
-            var position = currentPosition + deltaPosition;
-            if (minimumPosition !== undefined) {
-                position = Math.max(minimumPosition, position);
-            }
-            if (maximumPosition !== undefined) {
-                position = Math.min(maximumPosition, position);
+        autoPlayResult
+            .then(function () {
+            (0, get_loaded_reference_1.default)(playbackObserver, false, cancelSignal).onUpdate(function (isLoaded, stopListening) {
+                if (isLoaded) {
+                    var fetchThumbnails_1 = (0, fetchers_1.createThumbnailFetcher)(transport.thumbnails, cdnPrioritizer);
+                    stopListening();
+                    _this.trigger("loaded", {
+                        getSegmentSinkMetrics: function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                return [2 /*return*/, new Promise(function (resolve) {
+                                        return resolve(segmentSinksStore.getSegmentSinksMetrics());
+                                    })];
+                            });
+                        }); },
+                        getThumbnailData: function (periodId, thumbnailTrackId, time) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                return [2 /*return*/, (0, get_thumbnail_data_1.default)(fetchThumbnails_1, manifest, periodId, thumbnailTrackId, time)];
+                            });
+                        }); },
+                    });
+                }
+            }, { emitCurrentValue: true, clearSignal: cancelSignal });
+        })
+            .catch(function (err) {
+            if (cancelSignal.isCancelled()) {
+                return; // Current loading cancelled, no need to trigger the error
             }
-            _this._reload(mediaElement, textDisplayer, playbackObserver, mediaSourceStatus, position, !isPaused);
-        };
-        var onmessage = function (msgData) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28;
-            switch (msgData.type) {
-                case "attach-media-source" /* CoreMessageType.AttachMediaSource */: {
-                    if (((_a = _this._currentContentInfo) === null || _a === void 0 ? void 0 : _a.contentId) !== msgData.contentId) {
-                        return;
+            _this._onFatalError(err);
+        });
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        var self = this;
+        (0, stream_1.default)({ manifest: manifest, initialPeriod: initialPeriod }, coreObserver, representationEstimator, segmentSinksStore, segmentQueueCreator, bufferOptions, handleStreamOrchestratorCallbacks(), cancelSignal);
+        /**
+         * Returns Object handling the callbacks from a `StreamOrchestrator`, which
+         * are basically how it communicates about events.
+         * @returns {Object}
+         */
+        function handleStreamOrchestratorCallbacks() {
+            return {
+                needsBufferFlush: function (payload) {
+                    var _a;
+                    var wantedSeekingTime;
+                    var lastObservation = playbackObserver.getReference().getValue();
+                    var currentTime = lastObservation.position.isAwaitingFuturePosition()
+                        ? lastObservation.position.getWanted()
+                        : mediaElement.currentTime;
+                    var relativeResumingPosition = (_a = payload === null || payload === void 0 ? void 0 : payload.relativeResumingPosition) !== null && _a !== void 0 ? _a : 0;
+                    var canBeApproximateSeek = Boolean(payload === null || payload === void 0 ? void 0 : payload.relativePosHasBeenDefaulted);
+                    if (relativeResumingPosition === 0 && canBeApproximateSeek) {
+                        // in case relativeResumingPosition is 0, we still perform
+                        // a tiny seek to be sure that the browser will correclty reload the video.
+                        wantedSeekingTime = currentTime + 0.001;
                     }
-                    if (_this._currentContentInfo !== null) {
-                        if (((_b = _this._currentContentInfo.mediaSourceInfo) === null || _b === void 0 ? void 0 : _b.type) === "main") {
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.dispose();
-                        }
-                        _this._currentContentInfo.mediaSourceInfo = {
-                            type: "core",
-                            mediaSourceId: msgData.mediaSourceId,
-                        };
+                    else {
+                        wantedSeekingTime = currentTime + relativeResumingPosition;
                     }
-                    var mediaSourceLink_1 = msgData.value;
-                    mediaSourceStatus.onUpdate(function (currStatus, stopListening) {
-                        if (currStatus === 1 /* MediaSourceInitializationStatus.AttachNow */) {
+                    playbackObserver.setCurrentTime(wantedSeekingTime);
+                    // Seek again once data begins to be buffered.
+                    // This is sadly necessary on some browsers to avoid decoding
+                    // issues after a flush.
+                    //
+                    // NOTE: there's in theory a potential race condition in the following
+                    // logic as the callback could be called when media data is still
+                    // being removed by the browser - which is an asynchronous process.
+                    // The following condition checking for buffered data could thus lead
+                    // to a false positive where we're actually checking previous data.
+                    // For now, such scenario is avoided by setting the
+                    // `includeLastObservation` option to `false` and calling
+                    // `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) {
+                        if (
+                        // Data is buffered around the current position
+                        obs.currentRange !== null ||
+                            // Or, for whatever reason, we have no buffer but we're already advancing
+                            obs.position.getPolled() > wantedSeekingTime + 0.1) {
                             stopListening();
-                            log_1.default.info("media", "Attaching MediaSource URL to the media element");
-                            if (mediaSourceLink_1.type === "handle") {
-                                mediaElement.srcObject = mediaSourceLink_1.value;
-                                _this._currentMediaSourceCanceller.signal.register(function () {
-                                    mediaElement.srcObject = null;
-                                });
-                            }
-                            else {
-                                mediaElement.src = mediaSourceLink_1.value;
-                                _this._currentMediaSourceCanceller.signal.register(function () {
-                                    (0, create_media_source_1.resetMediaElement)(mediaElement, mediaSourceLink_1.value);
-                                });
-                            }
-                            (0, create_media_source_1.disableRemotePlaybackOnManagedMediaSource)(mediaElement, _this._currentMediaSourceCanceller.signal);
-                            mediaSourceStatus.setValue(2 /* MediaSourceInitializationStatus.Attached */);
+                            playbackObserver.setCurrentTime(obs.position.getWanted() + 0.001);
                         }
-                    }, { emitCurrentValue: true, clearSignal: _this._initCanceller.signal });
-                    break;
-                }
-                case "warning" /* CoreMessageType.Warning */:
-                    if (((_c = _this._currentContentInfo) === null || _c === void 0 ? void 0 : _c.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    _this.trigger("warning", formatCoreError(msgData.value));
-                    break;
-                case "error" /* CoreMessageType.Error */:
-                    if (((_d = _this._currentContentInfo) === null || _d === void 0 ? void 0 : _d.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    _this._onFatalError(formatCoreError(msgData.value));
-                    break;
-                case "create-media-source" /* CoreMessageType.CreateMediaSource */:
-                    _this._onCreateMediaSourceMessage(msgData, mediaElement, mediaSourceStatus, _this._settings.coreInterface);
-                    break;
-                case "add-source-buffer" /* CoreMessageType.AddSourceBuffer */:
-                    {
-                        if (((_f = (_e = _this._currentContentInfo) === null || _e === void 0 ? void 0 : _e.mediaSourceInfo) === null || _f === void 0 ? void 0 : _f.type) !== "main" ||
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
-                                msgData.mediaSourceId) {
-                            return;
-                        }
-                        var mediaSource = _this._currentContentInfo.mediaSourceInfo.mediaSource;
-                        mediaSource.addSourceBuffer(msgData.value.sourceBufferType, msgData.value.codec);
-                    }
-                    break;
-                case "source-buffer-append" /* CoreMessageType.SourceBufferAppend */:
-                    {
-                        if (((_h = (_g = _this._currentContentInfo) === null || _g === void 0 ? void 0 : _g.mediaSourceInfo) === null || _h === void 0 ? void 0 : _h.type) !== "main" ||
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
-                                msgData.mediaSourceId) {
-                            return;
+                    }, { includeLastObservation: false, clearSignal: cancelSignal });
+                },
+                streamStatusUpdate: function (value) {
+                    // Announce discontinuities if found
+                    var period = value.period, bufferType = value.bufferType, imminentDiscontinuity = value.imminentDiscontinuity, position = value.position;
+                    rebufferingController.updateDiscontinuityInfo({
+                        period: period,
+                        bufferType: bufferType,
+                        discontinuity: imminentDiscontinuity,
+                        position: position,
+                    });
+                    if (cancelSignal.isCancelled()) {
+                        return; // Previous call has stopped streams due to a side-effect
+                    }
+                    // If the status for the last Period indicates that segments are all loaded
+                    // or on the contrary that the loading resumed, announce it to the
+                    // ContentTimeBoundariesObserver.
+                    if (manifest.isLastPeriodKnown &&
+                        value.period.id === manifest.periods[manifest.periods.length - 1].id) {
+                        var hasFinishedLoadingLastPeriod = value.hasFinishedLoading || value.isEmptyStream;
+                        if (hasFinishedLoadingLastPeriod) {
+                            contentTimeBoundariesObserver.onLastSegmentFinishedLoading(value.bufferType);
                         }
-                        var mediaSource_1 = _this._currentContentInfo.mediaSourceInfo.mediaSource;
-                        var sourceBuffer_1 = (0, array_find_1.default)(mediaSource_1.sourceBuffers, function (s) { return s.type === msgData.sourceBufferType; });
-                        if (sourceBuffer_1 === undefined) {
-                            return;
+                        else {
+                            contentTimeBoundariesObserver.onLastSegmentLoadingResume(value.bufferType);
                         }
-                        sourceBuffer_1
-                            .appendBuffer(msgData.value.data, msgData.value.params)
-                            .then(function (buffered) {
-                            _this._settings.coreInterface.sendMessage({
-                                type: "sb-success" /* MainThreadMessageType.SourceBufferSuccess */,
-                                mediaSourceId: mediaSource_1.id,
-                                sourceBufferType: sourceBuffer_1.type,
-                                operationId: msgData.operationId,
-                                value: { buffered: buffered },
-                            });
-                        })
-                            .catch(function (error) {
-                            _this._settings.coreInterface.sendMessage({
-                                type: "sb-error" /* MainThreadMessageType.SourceBufferError */,
-                                mediaSourceId: mediaSource_1.id,
-                                sourceBufferType: sourceBuffer_1.type,
-                                operationId: msgData.operationId,
-                                value: error instanceof task_canceller_1.CancellationError
-                                    ? { errorName: "CancellationError" }
-                                    : formatSourceBufferError(error).serialize(),
-                            });
-                        });
                     }
-                    break;
-                case "source-buffer-remove" /* CoreMessageType.SourceBufferRemove */:
-                    {
-                        if (((_k = (_j = _this._currentContentInfo) === null || _j === void 0 ? void 0 : _j.mediaSourceInfo) === null || _k === void 0 ? void 0 : _k.type) !== "main" ||
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
-                                msgData.mediaSourceId) {
-                            return;
-                        }
-                        var mediaSource_2 = _this._currentContentInfo.mediaSourceInfo.mediaSource;
-                        var sourceBuffer_2 = (0, array_find_1.default)(mediaSource_2.sourceBuffers, function (s) { return s.type === msgData.sourceBufferType; });
-                        if (sourceBuffer_2 === undefined) {
-                            return;
-                        }
-                        sourceBuffer_2
-                            .remove(msgData.value.start, msgData.value.end)
-                            .then(function (buffered) {
-                            _this._settings.coreInterface.sendMessage({
-                                type: "sb-success" /* MainThreadMessageType.SourceBufferSuccess */,
-                                mediaSourceId: mediaSource_2.id,
-                                sourceBufferType: sourceBuffer_2.type,
-                                operationId: msgData.operationId,
-                                value: { buffered: buffered },
-                            });
-                        })
-                            .catch(function (error) {
-                            _this._settings.coreInterface.sendMessage({
-                                type: "sb-error" /* MainThreadMessageType.SourceBufferError */,
-                                mediaSourceId: mediaSource_2.id,
-                                sourceBufferType: sourceBuffer_2.type,
-                                operationId: msgData.operationId,
-                                value: error instanceof task_canceller_1.CancellationError
-                                    ? { errorName: "CancellationError" }
-                                    : formatSourceBufferError(error).serialize(),
-                            });
-                        });
-                    }
-                    break;
-                case "abort-source-buffer" /* CoreMessageType.AbortSourceBuffer */:
-                    {
-                        if (((_m = (_l = _this._currentContentInfo) === null || _l === void 0 ? void 0 : _l.mediaSourceInfo) === null || _m === void 0 ? void 0 : _m.type) !== "main" ||
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
-                                msgData.mediaSourceId) {
-                            return;
-                        }
-                        var mediaSource = _this._currentContentInfo.mediaSourceInfo.mediaSource;
-                        var sourceBuffer = (0, array_find_1.default)(mediaSource.sourceBuffers, function (s) { return s.type === msgData.sourceBufferType; });
-                        if (sourceBuffer === undefined) {
-                            return;
-                        }
-                        sourceBuffer.abort();
-                    }
-                    break;
-                case "update-media-source-duration" /* CoreMessageType.UpdateMediaSourceDuration */:
-                    {
-                        if (((_p = (_o = _this._currentContentInfo) === null || _o === void 0 ? void 0 : _o.mediaSourceInfo) === null || _p === void 0 ? void 0 : _p.type) !== "main" ||
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
-                                msgData.mediaSourceId) {
-                            return;
-                        }
-                        var mediaSource = _this._currentContentInfo.mediaSourceInfo.mediaSource;
-                        if ((mediaSource === null || mediaSource === void 0 ? void 0 : mediaSource.id) !== msgData.mediaSourceId) {
-                            return;
-                        }
-                        mediaSource.setDuration(msgData.value.duration, msgData.value.isRealEndKnown);
-                    }
-                    break;
-                case "stop-media-source-duration" /* CoreMessageType.InterruptMediaSourceDurationUpdate */:
-                    {
-                        if (((_r = (_q = _this._currentContentInfo) === null || _q === void 0 ? void 0 : _q.mediaSourceInfo) === null || _r === void 0 ? void 0 : _r.type) !== "main" ||
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
-                                msgData.mediaSourceId) {
-                            return;
-                        }
-                        var mediaSource = _this._currentContentInfo.mediaSourceInfo.mediaSource;
-                        if ((mediaSource === null || mediaSource === void 0 ? void 0 : mediaSource.id) !== msgData.mediaSourceId) {
-                            return;
-                        }
-                        mediaSource.interruptDurationSetting();
-                    }
-                    break;
-                case "end-of-stream" /* CoreMessageType.EndOfStream */:
-                    {
-                        if (((_t = (_s = _this._currentContentInfo) === null || _s === void 0 ? void 0 : _s.mediaSourceInfo) === null || _t === void 0 ? void 0 : _t.type) !== "main" ||
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
-                                msgData.mediaSourceId) {
-                            return;
-                        }
-                        var mediaSource = _this._currentContentInfo.mediaSourceInfo.mediaSource;
-                        mediaSource.maintainEndOfStream();
-                    }
-                    break;
-                case "stop-end-of-stream" /* CoreMessageType.InterruptEndOfStream */:
-                    {
-                        if (((_v = (_u = _this._currentContentInfo) === null || _u === void 0 ? void 0 : _u.mediaSourceInfo) === null || _v === void 0 ? void 0 : _v.type) !== "main" ||
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
-                                msgData.mediaSourceId) {
-                            return;
-                        }
-                        var mediaSource = _this._currentContentInfo.mediaSourceInfo.mediaSource;
-                        mediaSource.stopEndOfStream();
-                    }
-                    break;
-                case "dispose-media-source" /* CoreMessageType.DisposeMediaSource */:
-                    {
-                        if (((_x = (_w = _this._currentContentInfo) === null || _w === void 0 ? void 0 : _w.mediaSourceInfo) === null || _x === void 0 ? void 0 : _x.type) !== "main" ||
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.id !==
-                                msgData.mediaSourceId) {
-                            return;
-                        }
-                        var mediaSource = _this._currentContentInfo.mediaSourceInfo.mediaSource;
-                        mediaSource.dispose();
-                    }
-                    break;
-                case "needs-buffer-flush" /* CoreMessageType.NeedsBufferFlush */: {
-                    if (((_y = _this._currentContentInfo) === null || _y === void 0 ? void 0 : _y.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    var lastObservation = playbackObserver.getReference().getValue();
-                    var currentTime = lastObservation.position.isAwaitingFuturePosition()
-                        ? lastObservation.position.getWanted()
-                        : mediaElement.currentTime;
-                    var relativeResumingPosition = (_0 = (_z = msgData.value) === null || _z === void 0 ? void 0 : _z.relativeResumingPosition) !== null && _0 !== void 0 ? _0 : 0;
-                    var canBeApproximateSeek = Boolean((_1 = msgData.value) === null || _1 === void 0 ? void 0 : _1.relativePosHasBeenDefaulted);
-                    var wantedSeekingTime = void 0;
-                    if (relativeResumingPosition === 0 && canBeApproximateSeek) {
-                        // in case relativeResumingPosition is 0, we still perform
-                        // a tiny seek to be sure that the browser will correclty reload the video.
-                        wantedSeekingTime = currentTime + 0.001;
-                    }
-                    else {
-                        wantedSeekingTime = currentTime + relativeResumingPosition;
-                    }
-                    playbackObserver.setCurrentTime(wantedSeekingTime);
-                    break;
-                }
-                case "active-period-changed" /* CoreMessageType.ActivePeriodChanged */: {
-                    if (((_2 = _this._currentContentInfo) === null || _2 === void 0 ? void 0 : _2.contentId) !== msgData.contentId ||
-                        _this._currentContentInfo.manifest === null) {
-                        return;
-                    }
-                    var period = (0, array_find_1.default)(_this._currentContentInfo.manifest.periods, function (p) { return p.id === msgData.value.periodId; });
-                    if (period !== undefined) {
-                        _this.trigger("activePeriodChanged", { period: period });
-                    }
-                    break;
-                }
-                case "adaptation-changed" /* CoreMessageType.AdaptationChanged */: {
-                    if (((_3 = _this._currentContentInfo) === null || _3 === void 0 ? void 0 : _3.contentId) !== msgData.contentId ||
-                        _this._currentContentInfo.manifest === null) {
-                        return;
-                    }
-                    var period = (0, array_find_1.default)(_this._currentContentInfo.manifest.periods, function (p) { return p.id === msgData.value.periodId; });
-                    if (period === undefined) {
-                        return;
-                    }
-                    if (msgData.value.adaptationId === null) {
-                        _this.trigger("adaptationChange", {
-                            period: period,
-                            adaptation: null,
-                            type: msgData.value.type,
-                        });
-                        return;
-                    }
-                    var adaptations = (_4 = period.adaptations[msgData.value.type]) !== null && _4 !== void 0 ? _4 : [];
-                    var adaptation = (0, array_find_1.default)(adaptations, function (a) { return a.id === msgData.value.adaptationId; });
-                    if (adaptation !== undefined) {
-                        _this.trigger("adaptationChange", {
-                            period: period,
-                            adaptation: adaptation,
-                            type: msgData.value.type,
-                        });
-                    }
-                    break;
-                }
-                case "representation-changed" /* CoreMessageType.RepresentationChanged */: {
-                    if (((_5 = _this._currentContentInfo) === null || _5 === void 0 ? void 0 : _5.contentId) !== msgData.contentId ||
-                        _this._currentContentInfo.manifest === null) {
-                        return;
-                    }
-                    var period = (0, array_find_1.default)(_this._currentContentInfo.manifest.periods, function (p) { return p.id === msgData.value.periodId; });
-                    if (period === undefined) {
-                        return;
-                    }
-                    if (msgData.value.representationId === null) {
-                        _this.trigger("representationChange", {
-                            period: period,
-                            type: msgData.value.type,
-                            representation: null,
-                        });
-                        return;
-                    }
-                    var adaptations = (_6 = period.adaptations[msgData.value.type]) !== null && _6 !== void 0 ? _6 : [];
-                    var adaptation = (0, array_find_1.default)(adaptations, function (a) { return a.id === msgData.value.adaptationId; });
-                    if (adaptation === undefined) {
-                        return;
-                    }
-                    var representation = (0, array_find_1.default)(adaptation.representations, function (r) { return r.id === msgData.value.representationId; });
-                    if (representation !== undefined) {
-                        _this.trigger("representationChange", {
-                            period: period,
-                            type: msgData.value.type,
-                            representation: representation,
-                        });
-                    }
-                    break;
-                }
-                case "encryption-data-encountered" /* CoreMessageType.EncryptionDataEncountered */:
-                    if (((_7 = _this._currentContentInfo) === null || _7 === void 0 ? void 0 : _7.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    lastContentProtection.setValue(msgData.value);
-                    break;
-                case "manifest-ready" /* CoreMessageType.ManifestReady */: {
-                    if (((_8 = _this._currentContentInfo) === null || _8 === void 0 ? void 0 : _8.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    var manifest = msgData.value.manifest;
-                    _this._currentContentInfo.manifest = manifest;
-                    _this._updateCodecSupport(manifest, mediaElement);
-                    _this._startPlaybackIfReady(playbackStartParams);
-                    break;
-                }
-                case "manifest-update" /* CoreMessageType.ManifestUpdate */: {
-                    if (((_9 = _this._currentContentInfo) === null || _9 === void 0 ? void 0 : _9.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    var manifest = (_10 = _this._currentContentInfo) === null || _10 === void 0 ? void 0 : _10.manifest;
-                    if ((0, is_null_or_undefined_1.default)(manifest)) {
-                        log_1.default.error("Init", "Manifest update but no Manifest loaded");
-                        return;
-                    }
-                    (0, manifest_1.replicateUpdatesOnManifestMetadata)(manifest, msgData.value.manifest, msgData.value.updates);
-                    (_12 = (_11 = _this._currentContentInfo) === null || _11 === void 0 ? void 0 : _11.streamEventsEmitter) === null || _12 === void 0 ? void 0 : _12.onManifestUpdate(manifest);
-                    _this._updateCodecSupport(manifest, mediaElement);
-                    _this.trigger("manifestUpdate", msgData.value.updates);
-                    break;
-                }
-                case "update-playback-rate" /* CoreMessageType.UpdatePlaybackRate */:
-                    if (((_13 = _this._currentContentInfo) === null || _13 === void 0 ? void 0 : _13.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    playbackObserver.setPlaybackRate(msgData.value);
-                    break;
-                case "bitrate-estimate-change" /* CoreMessageType.BitrateEstimateChange */:
-                    if (((_14 = _this._currentContentInfo) === null || _14 === void 0 ? void 0 : _14.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    _this.trigger("bitrateEstimateChange", {
-                        type: msgData.value.bufferType,
-                        bitrate: msgData.value.bitrate,
-                    });
-                    break;
-                case "inband-event" /* CoreMessageType.InbandEvent */:
-                    if (((_15 = _this._currentContentInfo) === null || _15 === void 0 ? void 0 : _15.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    _this.trigger("inbandEvents", msgData.value);
-                    break;
-                case "locked-stream" /* CoreMessageType.LockedStream */: {
-                    if (((_16 = _this._currentContentInfo) === null || _16 === void 0 ? void 0 : _16.contentId) !== msgData.contentId ||
-                        _this._currentContentInfo.manifest === null) {
-                        return;
-                    }
-                    var period = (0, array_find_1.default)(_this._currentContentInfo.manifest.periods, function (p) { return p.id === msgData.value.periodId; });
-                    if (period === undefined) {
-                        return;
-                    }
-                    (_17 = _this._currentContentInfo.rebufferingController) === null || _17 === void 0 ? void 0 : _17.onLockedStream(msgData.value.bufferType, period);
-                    break;
-                }
-                case "period-stream-ready" /* CoreMessageType.PeriodStreamReady */: {
-                    if (((_18 = _this._currentContentInfo) === null || _18 === void 0 ? void 0 : _18.contentId) !== msgData.contentId ||
-                        _this._currentContentInfo.manifest === null) {
-                        return;
-                    }
-                    var period = (0, array_find_1.default)(_this._currentContentInfo.manifest.periods, function (p) { return p.id === msgData.value.periodId; });
-                    if (period === undefined) {
-                        return;
-                    }
-                    var ref_1 = new reference_1.default(undefined);
-                    ref_1.onUpdate(function (adapChoice) {
-                        if (_this._currentContentInfo === null) {
-                            ref_1.finish();
-                            return;
-                        }
-                        if (!(0, is_null_or_undefined_1.default)(adapChoice)) {
-                            adapChoice.representations.onUpdate(function (repChoice, stopListening) {
-                                if (_this._currentContentInfo === null) {
-                                    stopListening();
-                                    return;
-                                }
-                                _this._settings.coreInterface.sendMessage({
-                                    type: "rep-update" /* MainThreadMessageType.RepresentationUpdate */,
-                                    contentId: _this._currentContentInfo.contentId,
-                                    value: {
-                                        periodId: msgData.value.periodId,
-                                        adaptationId: adapChoice.adaptationId,
-                                        bufferType: msgData.value.bufferType,
-                                        choice: repChoice,
-                                    },
-                                });
-                            }, { clearSignal: _this._initCanceller.signal });
-                        }
-                        _this._settings.coreInterface.sendMessage({
-                            type: "track-update" /* MainThreadMessageType.TrackUpdate */,
-                            contentId: _this._currentContentInfo.contentId,
-                            value: {
-                                periodId: msgData.value.periodId,
-                                bufferType: msgData.value.bufferType,
-                                choice: (0, is_null_or_undefined_1.default)(adapChoice)
-                                    ? adapChoice
-                                    : {
-                                        adaptationId: adapChoice.adaptationId,
-                                        switchingMode: adapChoice.switchingMode,
-                                        initialRepresentations: adapChoice.representations.getValue(),
-                                        relativeResumingPosition: adapChoice.relativeResumingPosition,
-                                    },
-                            },
-                        });
-                    }, { clearSignal: _this._initCanceller.signal });
-                    _this.trigger("periodStreamReady", {
-                        period: period,
-                        type: msgData.value.bufferType,
-                        adaptationRef: ref_1,
+                },
+                needsManifestRefresh: function () {
+                    return self._manifestFetcher.scheduleManualRefresh({
+                        enablePartialRefresh: true,
+                        canUseUnsafeMode: true,
                     });
-                    break;
-                }
-                case "period-stream-cleared" /* CoreMessageType.PeriodStreamCleared */: {
-                    if (((_19 = _this._currentContentInfo) === null || _19 === void 0 ? void 0 : _19.contentId) !== msgData.contentId ||
-                        _this._currentContentInfo.manifest === null) {
-                        return;
-                    }
-                    _this.trigger("periodStreamCleared", {
-                        periodId: msgData.value.periodId,
-                        type: msgData.value.bufferType,
+                },
+                manifestMightBeOufOfSync: function () {
+                    var OUT_OF_SYNC_MANIFEST_REFRESH_DELAY = config_1.default.getCurrent().OUT_OF_SYNC_MANIFEST_REFRESH_DELAY;
+                    self._manifestFetcher.scheduleManualRefresh({
+                        enablePartialRefresh: false,
+                        canUseUnsafeMode: false,
+                        delay: OUT_OF_SYNC_MANIFEST_REFRESH_DELAY,
                     });
-                    break;
-                }
-                case "discontinuity-update" /* CoreMessageType.DiscontinuityUpdate */: {
-                    if (((_20 = _this._currentContentInfo) === null || _20 === void 0 ? void 0 : _20.contentId) !== msgData.contentId ||
-                        _this._currentContentInfo.manifest === null) {
-                        return;
+                },
+                lockedStream: function (value) {
+                    return rebufferingController.onLockedStream(value.bufferType, value.period);
+                },
+                adaptationChange: function (value) {
+                    self.trigger("adaptationChange", value);
+                    if (cancelSignal.isCancelled()) {
+                        return; // Previous call has stopped streams due to a side-effect
                     }
-                    var period = (0, array_find_1.default)(_this._currentContentInfo.manifest.periods, function (p) { return p.id === msgData.value.periodId; });
-                    if (period === undefined) {
-                        log_1.default.warn("Init", "Discontinuity's Period not found", {
-                            periodId: msgData.value.periodId,
-                        });
-                        return;
+                    contentTimeBoundariesObserver.onAdaptationChange(value.type, value.period, value.adaptation);
+                },
+                representationChange: function (value) {
+                    self.trigger("representationChange", value);
+                    if (cancelSignal.isCancelled()) {
+                        return; // Previous call has stopped streams due to a side-effect
                     }
-                    (_21 = _this._currentContentInfo.rebufferingController) === null || _21 === void 0 ? void 0 : _21.updateDiscontinuityInfo({
-                        period: period,
-                        bufferType: msgData.value.bufferType,
-                        discontinuity: msgData.value.discontinuity,
-                        position: msgData.value.position,
+                    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) {
+                    contentTimeBoundariesObserver.onPeriodCleared(value.type, value.period);
+                    if (cancelSignal.isCancelled()) {
+                        return; // Previous call has stopped streams due to a side-effect
+                    }
+                    self.trigger("periodStreamCleared", {
+                        type: value.type,
+                        periodId: value.period.id,
                     });
-                    break;
-                }
-                case "push-text-data" /* CoreMessageType.PushTextData */: {
-                    if (((_22 = _this._currentContentInfo) === null || _22 === void 0 ? void 0 : _22.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    if (textDisplayer === null) {
-                        log_1.default.warn("text", "Received AddTextData message but no text displayer exists");
-                    }
-                    else {
-                        try {
-                            var ranges = textDisplayer.pushTextData(msgData.value);
-                            _this._settings.coreInterface.sendMessage({
-                                type: "add-text-success" /* MainThreadMessageType.PushTextDataSuccess */,
-                                contentId: msgData.contentId,
-                                value: { ranges: ranges },
-                            });
-                        }
-                        catch (err) {
-                            var message = err instanceof Error ? err.message : "Unknown error";
-                            _this._settings.coreInterface.sendMessage({
-                                type: "push-text-error" /* MainThreadMessageType.PushTextDataError */,
-                                contentId: msgData.contentId,
-                                value: { message: message },
-                            });
-                        }
-                    }
-                    break;
-                }
-                case "remove-text-data" /* CoreMessageType.RemoveTextData */: {
-                    if (((_23 = _this._currentContentInfo) === null || _23 === void 0 ? void 0 : _23.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    if (textDisplayer === null) {
-                        log_1.default.warn("text", "Received RemoveTextData message but no text displayer exists");
+                },
+                bitrateEstimateChange: function (value) {
+                    var _a;
+                    (_a = self._cmcdDataBuilder) === null || _a === void 0 ? void 0 : _a.updateThroughput(value.type, value.bitrate);
+                    self.trigger("bitrateEstimateChange", value);
+                },
+                needsMediaSourceReload: function (payload) {
+                    reloadMediaSource(payload.timeOffset, payload.minimumPosition, payload.maximumPosition);
+                },
+                needsDecipherabilityFlush: function () {
+                    var _a, _b, _c, _d;
+                    var keySystem = (0, decrypt_1.getKeySystemConfiguration)(mediaElement);
+                    if ((0, should_reload_media_source_on_decipherability_update_1.default)(keySystem === null || keySystem === void 0 ? void 0 : keySystem[0])) {
+                        var lastObservation = coreObserver.getReference().getValue();
+                        var position = lastObservation.position.isAwaitingFuturePosition()
+                            ? lastObservation.position.getWanted()
+                            : ((_a = coreObserver.getCurrentTime()) !== null && _a !== void 0 ? _a : lastObservation.position.getPolled());
+                        var isPaused = (_c = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : coreObserver.getIsPaused()) !== null && _c !== void 0 ? _c : lastObservation.paused.last;
+                        onReloadOrder({ position: position, autoPlay: !isPaused });
                     }
                     else {
-                        try {
-                            var ranges = textDisplayer.removeBuffer(msgData.value.start, msgData.value.end);
-                            _this._settings.coreInterface.sendMessage({
-                                type: "remove-text-success" /* MainThreadMessageType.RemoveTextDataSuccess */,
-                                contentId: msgData.contentId,
-                                value: { ranges: ranges },
-                            });
+                        var lastObservation = coreObserver.getReference().getValue();
+                        var position = lastObservation.position.isAwaitingFuturePosition()
+                            ? lastObservation.position.getWanted()
+                            : ((_d = coreObserver.getCurrentTime()) !== null && _d !== void 0 ? _d : lastObservation.position.getPolled());
+                        // simple seek close to the current position
+                        // to flush the buffers
+                        if (position + 0.001 < lastObservation.duration) {
+                            playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
                         }
-                        catch (err) {
-                            var message = err instanceof Error ? err.message : "Unknown error";
-                            _this._settings.coreInterface.sendMessage({
-                                type: "remove-text-error" /* MainThreadMessageType.RemoveTextDataError */,
-                                contentId: msgData.contentId,
-                                value: { message: message },
-                            });
+                        else {
+                            playbackObserver.setCurrentTime(position);
                         }
                     }
-                    break;
-                }
-                case "reset-text-displayer" /* CoreMessageType.ResetTextDisplayer */: {
-                    if (((_24 = _this._currentContentInfo) === null || _24 === void 0 ? void 0 : _24.contentId) !== msgData.contentId) {
+                },
+                encryptionDataEncountered: function (value) {
+                    var e_1, _a;
+                    if (self._decryptionCapabilities.status === "disabled") {
+                        self._onFatalError(self._decryptionCapabilities.value);
                         return;
                     }
-                    if (textDisplayer === null) {
-                        log_1.default.warn("text", "Received ResetTextDisplayer message but no text displayer exists");
-                    }
-                    else {
-                        textDisplayer.reset();
-                    }
-                    break;
-                }
-                case "stop-text-displayer" /* CoreMessageType.StopTextDisplayer */: {
-                    if (((_25 = _this._currentContentInfo) === null || _25 === void 0 ? void 0 : _25.contentId) !== msgData.contentId) {
+                    else if (self._decryptionCapabilities.status === "uninitialized") {
+                        // Should never happen
+                        log_1.default.error("Init", "received encryption data without known decryption capabilities");
                         return;
                     }
-                    if (textDisplayer === null) {
-                        log_1.default.warn("text", "Received StopTextDisplayer message but no text displayer exists");
-                    }
-                    else {
-                        textDisplayer.stop();
-                    }
-                    break;
-                }
-                case "reloading-media-source" /* CoreMessageType.ReloadingMediaSource */:
-                    {
-                        if (_this._currentContentInfo === null ||
-                            _this._currentContentInfo.mediaSourceInfo === null) {
-                            return;
-                        }
-                        var mediaSourceId = _this._currentContentInfo.mediaSourceInfo.type === "main"
-                            ? _this._currentContentInfo.mediaSourceInfo.mediaSource.id
-                            : _this._currentContentInfo.mediaSourceInfo.mediaSourceId;
-                        if (mediaSourceId !== msgData.mediaSourceId) {
-                            return;
-                        }
-                        reloadMediaSource(msgData.value.timeOffset, msgData.value.minimumPosition, msgData.value.maximumPosition);
-                    }
-                    break;
-                case "needs-decipherability-flush" /* CoreMessageType.NeedsDecipherabilityFlush */:
-                    {
-                        if (((_26 = _this._currentContentInfo) === null || _26 === void 0 ? void 0 : _26.contentId) !== msgData.contentId) {
-                            return;
-                        }
-                        var keySystem = (0, decrypt_1.getKeySystemConfiguration)(mediaElement);
-                        if ((0, should_reload_media_source_on_decipherability_update_1.default)(keySystem === null || keySystem === void 0 ? void 0 : keySystem[0])) {
-                            notifyAndStartMediaSourceReload(0, undefined, undefined);
-                        }
-                        else {
-                            var lastObservation = playbackObserver.getReference().getValue();
-                            var currentPosition = lastObservation.position.getWanted();
-                            // simple seek close to the current position
-                            // to flush the buffers
-                            if (currentPosition + 0.001 < lastObservation.duration) {
-                                playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
-                            }
-                            else {
-                                playbackObserver.setCurrentTime(currentPosition);
+                    try {
+                        for (var value_1 = __values(value), value_1_1 = value_1.next(); !value_1_1.done; value_1_1 = value_1.next()) {
+                            var protectionData = value_1_1.value;
+                            self._decryptionCapabilities.value.onInitializationData(protectionData);
+                            if (cancelSignal.isCancelled()) {
+                                return; // Previous call has stopped streams due to a side-effect
                             }
                         }
                     }
-                    break;
-                case "segment-sink-store-update" /* CoreMessageType.SegmentSinkStoreUpdate */: {
-                    if (((_27 = _this._currentContentInfo) === null || _27 === void 0 ? void 0 : _27.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    var sinkObj = _this._awaitingRequests.pendingSinkMetrics.get(msgData.value.requestId);
-                    if (sinkObj !== undefined) {
-                        sinkObj.resolve(msgData.value.segmentSinkMetrics);
-                    }
-                    else {
-                        log_1.default.error("Init", "Failed to send segment sink store update");
-                    }
-                    break;
-                }
-                case "init-success" /* CoreMessageType.InitSuccess */:
-                case "init-error" /* CoreMessageType.InitError */:
-                    // Should already be handled by the API
-                    break;
-                case "log" /* CoreMessageType.LogMessage */:
-                    // Already handled by prepare's handler
-                    break;
-                case "thumbnail-response" /* CoreMessageType.ThumbnailDataResponse */: {
-                    if (((_28 = _this._currentContentInfo) === null || _28 === void 0 ? void 0 : _28.contentId) !== msgData.contentId) {
-                        return;
-                    }
-                    var tObj = _this._awaitingRequests.pendingThumbnailFetching.get(msgData.value.requestId);
-                    if (tObj !== undefined) {
-                        if (msgData.value.status === "error") {
-                            tObj.reject(formatCoreError(msgData.value.error));
-                        }
-                        else {
-                            tObj.resolve(msgData.value.data);
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (value_1_1 && !value_1_1.done && (_a = value_1.return)) _a.call(value_1);
                         }
+                        finally { if (e_1) throw e_1.error; }
                     }
-                    else {
-                        log_1.default.error("Init", "Failed to send segment sink store update");
-                    }
-                    break;
-                }
-                default:
-                    (0, assert_1.assertUnreachable)(msgData);
-            }
-        };
-        log_1.default.debug("Init", "addEventListener for core message");
-        if (this._queuedCoreMessages !== null) {
-            var bufferedMessages = this._queuedCoreMessages.slice();
-            log_1.default.debug("Init", "Processing buffered messages", {
-                ammount: bufferedMessages.length,
-            });
-            try {
-                for (var bufferedMessages_1 = __values(bufferedMessages), bufferedMessages_1_1 = bufferedMessages_1.next(); !bufferedMessages_1_1.done; bufferedMessages_1_1 = bufferedMessages_1.next()) {
-                    var message = bufferedMessages_1_1.value;
-                    onmessage(message);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (bufferedMessages_1_1 && !bufferedMessages_1_1.done && (_a = bufferedMessages_1.return)) _a.call(bufferedMessages_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            this._queuedCoreMessages = null;
-        }
-        this._settings.coreInterface.addMessageListener(onmessage);
-        this._initCanceller.signal.register(function () {
-            log_1.default.debug("Init", "removeEventListener for core message");
-            _this._settings.coreInterface.removeMessageListener(onmessage);
-        });
-    };
-    MediaSourceContentInitializer.prototype.dispose = function () {
-        var _a;
-        this._initCanceller.cancel();
-        if (this._currentContentInfo !== null) {
-            if (((_a = this._currentContentInfo.mediaSourceInfo) === null || _a === void 0 ? void 0 : _a.type) === "main") {
-                this._currentContentInfo.mediaSourceInfo.mediaSource.dispose();
-            }
-            this._currentContentInfo = null;
-        }
-    };
-    MediaSourceContentInitializer.prototype._onFatalError = function (err) {
-        if (this._initCanceller.isUsed()) {
-            return;
-        }
-        this._initCanceller.cancel();
-        this.trigger("error", err);
-    };
-    MediaSourceContentInitializer.prototype._initializeContentDecryption = function (mediaElement, lastContentProtection, mediaSourceStatus, reloadMediaSource, cancelSignal) {
-        var _this = this;
-        var _a;
-        var keySystems = this._settings.keySystems;
-        // TODO private?
-        var createEmeDisabledReference = function (errMsg) {
-            mediaSourceStatus.setValue(1 /* MediaSourceInitializationStatus.AttachNow */);
-            lastContentProtection.onUpdate(function (data, stopListening) {
-                if (data === null) {
-                    // initial value
-                    return;
-                }
-                stopListening();
-                var err = new errors_1.EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg, {
-                    keyStatuses: undefined,
-                    keySystemConfiguration: undefined,
-                    keySystem: undefined,
-                });
-                _this._onFatalError(err);
-            }, { clearSignal: cancelSignal });
-            var ref = new reference_1.default({
-                initializationState: {
-                    type: "initialized",
-                    value: null,
                 },
-                contentDecryptor: null,
-                drmSystemId: undefined,
-            });
-            ref.finish(); // We know that no new value will be triggered
-            return { statusRef: ref, contentDecryptor: null };
-        };
-        if (keySystems.length === 0) {
-            return createEmeDisabledReference("No `keySystems` option given.");
-        }
-        else if (features_1.default.decrypt === null) {
-            return createEmeDisabledReference("EME feature not activated.");
-        }
-        var emeApi = (_a = mediaElement.FORCED_EME_API) !== null && _a !== void 0 ? _a : (0, eme_1.default)("auto");
-        if (emeApi === null) {
-            return createEmeDisabledReference("EME API not available on the current page.");
+                error: function (err) { return self._onFatalError(err); },
+            };
         }
-        log_1.default.debug("Init", "Creating ContentDecryptor");
-        var ContentDecryptor = features_1.default.decrypt;
-        var contentDecryptor = new ContentDecryptor(emeApi, mediaElement, keySystems);
-        var drmStatusRef = new reference_1.default({
-            initializationState: { type: "uninitialized", value: null },
-            drmSystemId: undefined,
-        }, cancelSignal);
-        var updateCodecSupportOnStateChange = function (state) {
-            var _a;
-            if (state > decrypt_1.ContentDecryptorState.Initializing) {
-                var manifest = (_a = _this._currentContentInfo) === null || _a === void 0 ? void 0 : _a.manifest;
-                if ((0, is_null_or_undefined_1.default)(manifest)) {
-                    return;
-                }
-                _this._updateCodecSupport(manifest, mediaElement);
-                contentDecryptor.removeEventListener("stateChange", updateCodecSupportOnStateChange);
-            }
-        };
-        contentDecryptor.addEventListener("stateChange", updateCodecSupportOnStateChange);
-        contentDecryptor.addEventListener("keyIdsCompatibilityUpdate", function (updates) {
-            if (_this._currentContentInfo === null ||
-                _this._currentContentInfo.manifest === null) {
-                return;
-            }
-            var manUpdates = (0, manifest_1.updateDecipherabilityFromKeyIds)(_this._currentContentInfo.manifest, updates);
-            if ((0, may_media_element_fail_on_undecipherable_data_1.default)() &&
-                manUpdates.some(function (e) { return e.representation.decipherable !== true; })) {
-                reloadMediaSource();
-            }
-            else {
-                _this._settings.coreInterface.sendMessage({
-                    type: "decipherability-update" /* MainThreadMessageType.DecipherabilityStatusUpdate */,
-                    contentId: _this._currentContentInfo.contentId,
-                    value: manUpdates.map(function (s) { return ({
-                        representationUniqueId: s.representation.uniqueId,
-                        decipherable: s.representation.decipherable,
-                    }); }),
-                });
-            }
-            _this.trigger("decipherabilityUpdate", manUpdates);
-        });
-        contentDecryptor.addEventListener("blackListProtectionData", function (protData) {
-            if (_this._currentContentInfo === null ||
-                _this._currentContentInfo.manifest === null) {
-                return;
-            }
-            var manUpdates = (0, manifest_1.updateDecipherabilityFromProtectionData)(_this._currentContentInfo.manifest, protData);
-            if ((0, may_media_element_fail_on_undecipherable_data_1.default)() &&
-                manUpdates.some(function (e) { return e.representation.decipherable !== true; })) {
-                reloadMediaSource();
-            }
-            else {
-                _this._settings.coreInterface.sendMessage({
-                    type: "decipherability-update" /* MainThreadMessageType.DecipherabilityStatusUpdate */,
-                    contentId: _this._currentContentInfo.contentId,
-                    value: manUpdates.map(function (s) { return ({
-                        representationUniqueId: s.representation.uniqueId,
-                        decipherable: s.representation.decipherable,
-                    }); }),
-                });
-            }
-            _this.trigger("decipherabilityUpdate", manUpdates);
-        });
-        contentDecryptor.addEventListener("stateChange", function (state) {
-            if (state === decrypt_1.ContentDecryptorState.WaitingForAttachment) {
-                mediaSourceStatus.onUpdate(function (currStatus, stopListening) {
-                    if (currStatus === 0 /* MediaSourceInitializationStatus.Nothing */) {
-                        mediaSourceStatus.setValue(1 /* MediaSourceInitializationStatus.AttachNow */);
-                    }
-                    else if (currStatus === 2 /* MediaSourceInitializationStatus.Attached */) {
-                        stopListening();
-                        if (state === decrypt_1.ContentDecryptorState.WaitingForAttachment) {
-                            contentDecryptor.attach();
-                        }
-                    }
-                }, { clearSignal: cancelSignal, emitCurrentValue: true });
-            }
-            else if (state === decrypt_1.ContentDecryptorState.ReadyForContent) {
-                drmStatusRef.setValue({
-                    initializationState: { type: "initialized", value: null },
-                    drmSystemId: contentDecryptor.systemId,
-                });
-                contentDecryptor.removeEventListener("stateChange");
-            }
-        });
-        contentDecryptor.addEventListener("error", function (error) {
-            _this._onFatalError(error);
-        });
-        contentDecryptor.addEventListener("warning", function (error) {
-            _this.trigger("warning", error);
-        });
-        lastContentProtection.onUpdate(function (data) {
-            if (data === null) {
-                return;
+        /**
+         * Callback allowing to reload the current content.
+         * @param {number} deltaPosition - Position you want to seek to after
+         * reloading, as a delta in seconds from the last polled playing position.
+         * @param {number|undefined} minimumPosition - If set, minimum time bound
+         * in seconds after `deltaPosition` has been applied.
+         * @param {number|undefined} maximumPosition - If set, minimum time bound
+         * in seconds after `deltaPosition` has been applied.
+         */
+        function reloadMediaSource(deltaPosition, minimumPosition, maximumPosition) {
+            var _a, _b, _c;
+            var lastObservation = coreObserver.getReference().getValue();
+            var currentPosition = lastObservation.position.isAwaitingFuturePosition()
+                ? lastObservation.position.getWanted()
+                : ((_a = coreObserver.getCurrentTime()) !== null && _a !== void 0 ? _a : lastObservation.position.getPolled());
+            var isPaused = (_c = (_b = lastObservation.paused.pending) !== null && _b !== void 0 ? _b : coreObserver.getIsPaused()) !== null && _c !== void 0 ? _c : lastObservation.paused.last;
+            var position = currentPosition + deltaPosition;
+            if (minimumPosition !== undefined) {
+                position = Math.max(minimumPosition, position);
             }
-            contentDecryptor.onInitializationData(data);
-        }, { clearSignal: cancelSignal });
-        cancelSignal.register(function () {
-            contentDecryptor.dispose();
-        });
-        return { statusRef: drmStatusRef, contentDecryptor: contentDecryptor };
-    };
-    /**
-     * Retrieves all unknown codecs from the current manifest, checks these unknown codecs
-     * to determine if they are supported, updates the manifest with the support
-     * status of these codecs, and forwards the list of supported codecs to core.
-     * @param manifest
-     */
-    MediaSourceContentInitializer.prototype._updateCodecSupport = function (manifest, mediaElement) {
-        var _a, _b, _c, _d;
-        try {
-            var updatedCodecs = (0, update_manifest_codec_support_1.updateManifestCodecSupport)(manifest, (_b = (_a = this._currentContentInfo) === null || _a === void 0 ? void 0 : _a.contentDecryptor) !== null && _b !== void 0 ? _b : null, mediaElement, (_d = (_c = this._currentContentInfo) === null || _c === void 0 ? void 0 : _c.useMseInWorker) !== null && _d !== void 0 ? _d : false);
-            if (updatedCodecs.length > 0) {
-                this._settings.coreInterface.sendMessage({
-                    type: "codec-support-update" /* MainThreadMessageType.CodecSupportUpdate */,
-                    value: updatedCodecs,
-                });
-                // TODO what if one day the core updates codec support by itself?
-                // We wouldn't know...
-                this.trigger("codecSupportUpdate", null);
+            if (maximumPosition !== undefined) {
+                position = Math.min(maximumPosition, position);
             }
+            onReloadOrder({ position: position, autoPlay: !isPaused });
         }
-        catch (err) {
-            this._onFatalError(err);
-        }
-    };
-    MediaSourceContentInitializer.prototype._hasTextBufferFeature = function () {
-        return ((this._settings.textTrackOptions.textTrackMode === "html" &&
-            features_1.default.htmlTextDisplayer !== null) ||
-            features_1.default.nativeTextDisplayer !== null);
-    };
-    MediaSourceContentInitializer.prototype._reload = function (mediaElement, textDisplayer, playbackObserver, mediaSourceStatus, position, autoPlay) {
-        var _this = this;
-        this._currentMediaSourceCanceller.cancel();
-        this._currentMediaSourceCanceller = new task_canceller_1.default();
-        this._currentMediaSourceCanceller.linkToSignal(this._initCanceller.signal);
-        mediaSourceStatus.setValue(1 /* MediaSourceInitializationStatus.AttachNow */);
-        this.trigger("reloadingMediaSource", { position: position, autoPlay: autoPlay });
-        mediaSourceStatus.onUpdate(function (status, stopListeningMSStatusUpdates) {
-            if (status !== 2 /* MediaSourceInitializationStatus.Attached */) {
-                return;
-            }
-            stopListeningMSStatusUpdates();
-            var corePlaybackObserver = _this._setUpModulesOnNewMediaSource({
-                initialTime: position,
-                autoPlay: autoPlay,
-                mediaElement: mediaElement,
-                textDisplayer: textDisplayer,
-                playbackObserver: playbackObserver,
-            }, _this._currentMediaSourceCanceller.signal);
-            if (!_this._currentMediaSourceCanceller.isUsed() &&
-                corePlaybackObserver !== null &&
-                _this._currentContentInfo !== null) {
-                var contentId_1 = _this._currentContentInfo.contentId;
-                corePlaybackObserver.listen(function (obs) {
-                    _this._settings.coreInterface.sendMessage({
-                        type: "observation" /* MainThreadMessageType.PlaybackObservation */,
-                        contentId: contentId_1,
-                        value: (0, object_assign_1.default)(obs, {
-                            position: obs.position.serialize(),
-                        }),
-                    });
-                }, {
-                    includeLastObservation: true,
-                    clearSignal: _this._currentMediaSourceCanceller.signal,
-                });
-            }
-        }, {
-            clearSignal: this._currentMediaSourceCanceller.signal,
-            emitCurrentValue: true,
-        });
     };
     /**
-     * Start-up modules and mechanisms (initial seek, auto-play etc.) needed each
-     * time a content is loaded AND re-loaded on a `HTMLMediaElement`, when the
-     * manifest is known.
+     * Creates a `RebufferingController`, a class trying to avoid various stalling
+     * situations (such as rebuffering periods), and returns it.
      *
-     * Note that this does not include reacting to incoming core messages nor
-     * sending them, those actions have to be handled separately.
+     * Various methods from that class need then to be called at various events
+     * (see `RebufferingController` definition).
      *
-     * @param {Object} parameters
+     * This function also handles the `RebufferingController`'s events:
+     *   - emit "stalled" events when stalling situations cannot be prevented,
+     *   - emit "unstalled" events when we could get out of one,
+     *   - emit "warning" on various rebuffering-related minor issues
+     *     like discontinuity skipping.
+     * @param {Object} playbackObserver
+     * @param {Object} manifest
+     * @param {Object} speed
      * @param {Object} cancelSignal
-     * @returns {Object|null} - Playback Observer created for this content. `null`
-     * only if playback initialization failed (most likely because it has been
-     * cancelled).
+     * @returns {Object}
      */
-    MediaSourceContentInitializer.prototype._setUpModulesOnNewMediaSource = function (parameters, cancelSignal) {
+    MediaSourceContentInitializer.prototype._createRebufferingController = function (playbackObserver, manifest, speed, cancelSignal) {
         var _this = this;
-        if (cancelSignal.isCancelled()) {
-            return null;
-        }
-        if (this._currentContentInfo === null) {
-            log_1.default.error("Init", "Setting up modules without a contentId");
-            return null;
-        }
-        if (this._currentContentInfo.manifest === null) {
-            log_1.default.error("Init", "Setting up modules without a loaded Manifest");
-            return null;
-        }
-        var _a = this._currentContentInfo, manifest = _a.manifest, mediaSourceInfo = _a.mediaSourceInfo;
-        var speed = this._settings.speed;
-        var initialTime = parameters.initialTime, autoPlay = parameters.autoPlay, mediaElement = parameters.mediaElement, textDisplayer = parameters.textDisplayer, playbackObserver = parameters.playbackObserver;
-        this._currentContentInfo.initialTime = initialTime;
-        this._currentContentInfo.autoPlay = autoPlay;
-        var _b = (0, initial_seek_and_play_1.default)({
-            mediaElement: mediaElement,
-            playbackObserver: playbackObserver,
-            startTime: initialTime,
-            mustAutoPlay: autoPlay,
-            onWarning: function (err) { return _this.trigger("warning", err); },
-            isDirectfile: false,
-        }, cancelSignal), autoPlayResult = _b.autoPlayResult, initialPlayPerformed = _b.initialPlayPerformed;
-        this._currentContentInfo.initialPlayPerformed = initialPlayPerformed;
-        var corePlaybackObserver = (0, create_core_playback_observer_1.default)(playbackObserver, {
-            autoPlay: autoPlay,
-            initialPlayPerformed: initialPlayPerformed,
-            manifest: manifest,
-            mediaSource: (mediaSourceInfo === null || mediaSourceInfo === void 0 ? void 0 : mediaSourceInfo.type) === "main" ? mediaSourceInfo.mediaSource : null,
-            speed: speed,
-            textDisplayer: textDisplayer,
-        }, cancelSignal);
-        if (cancelSignal.isCancelled()) {
-            return null;
-        }
-        /**
-         * Class trying to avoid various stalling situations, emitting "stalled"
-         * events when it cannot, as well as "unstalled" events when it get out of one.
-         */
         var rebufferingController = new rebuffering_controller_1.default(playbackObserver, manifest, speed);
+        // Bubble-up events
         rebufferingController.addEventListener("stalled", function (evt) {
             return _this.trigger("stalled", evt);
         });
@@ -1361,355 +872,271 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
         rebufferingController.addEventListener("warning", function (err) {
             return _this.trigger("warning", err);
         });
-        cancelSignal.register(function () {
-            rebufferingController.destroy();
-        });
+        cancelSignal.register(function () { return rebufferingController.destroy(); });
         rebufferingController.start();
-        this._currentContentInfo.rebufferingController = rebufferingController;
-        var currentContentInfo = this._currentContentInfo;
-        initialPlayPerformed.onUpdate(function (isPerformed, stopListening) {
-            if (isPerformed) {
-                stopListening();
-                var streamEventsEmitter_1 = new stream_events_emitter_1.default(manifest, playbackObserver);
-                currentContentInfo.streamEventsEmitter = streamEventsEmitter_1;
-                streamEventsEmitter_1.addEventListener("event", function (payload) {
-                    _this.trigger("streamEvent", payload);
-                }, cancelSignal);
-                streamEventsEmitter_1.addEventListener("eventSkip", function (payload) {
-                    _this.trigger("streamEventSkip", payload);
-                }, cancelSignal);
-                streamEventsEmitter_1.start();
-                cancelSignal.register(function () {
-                    streamEventsEmitter_1.stop();
-                });
+        return rebufferingController;
+    };
+    /**
+     * Evaluates a list of codecs to determine their support status.
+     *
+     * @param {Array} codecsToCheck - The list of codecs to check.
+     * @returns {Array} - The list of evaluated codecs with their support status updated.
+     */
+    MediaSourceContentInitializer.prototype.getCodecsSupportInfo = function (codecsToCheck, mediaElement) {
+        var _this = this;
+        var codecsSupportInfo = codecsToCheck.map(function (codecToCheck) {
+            var _a;
+            var inputCodec = "".concat(codecToCheck.mimeType, ";codecs=\"").concat(codecToCheck.codec, "\"");
+            var isSupported = (0, is_codec_supported_1.default)(mediaElement, inputCodec);
+            if (!isSupported) {
+                return {
+                    mimeType: codecToCheck.mimeType,
+                    codec: codecToCheck.codec,
+                    supported: false,
+                    supportedIfEncrypted: false,
+                };
             }
-        }, { clearSignal: cancelSignal, emitCurrentValue: true });
-        var _getSegmentSinkMetrics = function () { return __awaiter(_this, void 0, void 0, function () {
-            var requestId;
-            var _this = this;
-            return __generator(this, function (_a) {
-                this._awaitingRequests.nextRequestId++;
-                requestId = this._awaitingRequests.nextRequestId;
-                this._settings.coreInterface.sendMessage({
-                    type: "pull-segment-sink-store-infos" /* MainThreadMessageType.PullSegmentSinkStoreInfos */,
-                    value: { requestId: requestId },
-                });
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        var rejectFn = function (err) {
-                            cancelSignal.deregister(rejectFn);
-                            _this._awaitingRequests.pendingSinkMetrics.delete(requestId);
-                            return reject(err);
-                        };
-                        _this._awaitingRequests.pendingSinkMetrics.set(requestId, {
-                            resolve: function (value) {
-                                cancelSignal.deregister(rejectFn);
-                                _this._awaitingRequests.pendingSinkMetrics.delete(requestId);
-                                resolve(value);
-                            },
-                        });
-                        cancelSignal.register(rejectFn);
-                    })];
-            });
-        }); };
-        var _getThumbnailsData = function (periodId, thumbnailTrackId, time) { return __awaiter(_this, void 0, void 0, function () {
-            var requestId;
-            var _this = this;
-            return __generator(this, function (_a) {
-                if (this._currentContentInfo === null) {
-                    return [2 /*return*/, Promise.reject(new Error("Cannot fetch thumbnails: No content loaded."))];
-                }
-                this._awaitingRequests.nextRequestId++;
-                requestId = this._awaitingRequests.nextRequestId;
-                this._settings.coreInterface.sendMessage({
-                    type: "thumbnail-request" /* MainThreadMessageType.ThumbnailDataRequest */,
-                    contentId: this._currentContentInfo.contentId,
-                    value: { requestId: requestId, periodId: periodId, thumbnailTrackId: thumbnailTrackId, time: time },
-                });
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        var rejectFn = function (err) {
-                            cleanUp();
-                            reject(err);
-                        };
-                        var cleanUp = function () {
-                            cancelSignal.deregister(rejectFn);
-                            _this._awaitingRequests.pendingThumbnailFetching.delete(requestId);
-                        };
-                        _this._awaitingRequests.pendingThumbnailFetching.set(requestId, {
-                            resolve: function (value) {
-                                cleanUp();
-                                resolve(value);
-                            },
-                            reject: function (value) {
-                                cleanUp();
-                                reject(value);
-                            },
-                        });
-                        cancelSignal.register(rejectFn);
-                    })];
-            });
-        }); };
-        /**
-         * Emit a "loaded" events once the initial play has been performed and the
-         * media can begin playback.
-         * Also emits warning events if issues arise when doing so.
-         */
-        autoPlayResult
-            .then(function () {
-            (0, get_loaded_reference_1.default)(playbackObserver, false, cancelSignal).onUpdate(function (isLoaded, stopListening) {
-                if (isLoaded) {
-                    stopListening();
-                    _this.trigger("loaded", {
-                        getSegmentSinkMetrics: _getSegmentSinkMetrics,
-                        getThumbnailData: _getThumbnailsData,
-                    });
+            /**
+             * `true` if the codec is supported when encrypted, `false` if it is not
+             * supported, or `undefined` if we cannot obtain that information.
+             */
+            var supportedIfEncrypted;
+            if (_this._decryptionCapabilities.status === "uninitialized") {
+                supportedIfEncrypted = undefined;
+            }
+            else if (_this._decryptionCapabilities.status === "disabled") {
+                // It's ambiguous here, but let's say that no ContentDecryptor means that
+                // the codec is supported by it.
+                supportedIfEncrypted = true;
+            }
+            else {
+                var contentDecryptor = _this._decryptionCapabilities.value;
+                if (contentDecryptor.getState() !== decrypt_1.ContentDecryptorState.Initializing) {
+                    // No information is available regarding the support status.
+                    // Defaulting to assume the codec is supported.
+                    supportedIfEncrypted =
+                        (_a = contentDecryptor.isCodecSupported(codecToCheck.mimeType, codecToCheck.codec)) !== null && _a !== void 0 ? _a : true;
                 }
-            }, { emitCurrentValue: true, clearSignal: cancelSignal });
-        })
-            .catch(function (err) {
-            if (cancelSignal.isCancelled()) {
-                return;
             }
-            _this._onFatalError(err);
+            return {
+                mimeType: codecToCheck.mimeType,
+                codec: codecToCheck.codec,
+                supported: isSupported,
+                supportedIfEncrypted: supportedIfEncrypted,
+            };
         });
-        return corePlaybackObserver;
+        return codecsSupportInfo;
     };
     /**
-     * Initialize content playback if and only if those conditions are filled:
-     *   - The Manifest is fetched and stored in `this._currentContentInfo`.
-     *   - `drmInitializationStatus` indicates that DRM matters are initialized.
-     *   - `mediaSourceStatus` indicates that the MediaSource is attached to the
-     *     `mediaElement`.
-     *
-     * In other cases, this method will do nothing.
+     * Update the support status of all Representations in the Manifest.
      *
-     * To call when any of those conditions might become `true`, to start-up
-     * playback.
-     *
-     * @param {Object} parameters
-     * @returns {boolean} - Returns `true` if all conditions where met for
-     * playback start.
+     * To call anytime either the Manifest is linked to new codecs or new means
+     * to test for codec support are available.
+     * @param {Object} manifest
      */
-    MediaSourceContentInitializer.prototype._startPlaybackIfReady = function (parameters) {
-        var _this = this;
-        if (this._currentContentInfo === null || this._currentContentInfo.manifest === null) {
-            return false;
-        }
-        var drmInitStatus = parameters.drmInitializationStatus.getValue();
-        if (drmInitStatus.initializationState.type !== "initialized") {
-            return false;
-        }
-        var msInitStatus = parameters.mediaSourceStatus.getValue();
-        if (msInitStatus !== 2 /* MediaSourceInitializationStatus.Attached */) {
-            return false;
-        }
-        var _a = this._currentContentInfo, contentId = _a.contentId, manifest = _a.manifest;
-        log_1.default.debug("Init", "Calculating initial time");
-        var initialTime = (0, get_initial_time_1.default)(manifest, this._settings.lowLatencyMode, this._settings.startAt);
-        log_1.default.debug("Init", "Initial time calculated", { initialTime: initialTime });
-        var _b = this._settings.bufferOptions, enableFastSwitching = _b.enableFastSwitching, onCodecSwitch = _b.onCodecSwitch;
-        var corePlaybackObserver = this._setUpModulesOnNewMediaSource({
-            initialTime: initialTime,
-            autoPlay: this._settings.autoPlay,
-            mediaElement: parameters.mediaElement,
-            textDisplayer: parameters.textDisplayer,
-            playbackObserver: parameters.playbackObserver,
-        }, this._currentMediaSourceCanceller.signal);
-        if (this._currentMediaSourceCanceller.isUsed() || corePlaybackObserver === null) {
-            return true;
+    MediaSourceContentInitializer.prototype._refreshManifestCodecSupport = function (manifest, mediaElement) {
+        var codecsToTest = manifest.getCodecsWithUnknownSupport();
+        var codecsSupportInfo = this.getCodecsSupportInfo(codecsToTest, mediaElement);
+        if (codecsSupportInfo.length > 0) {
+            try {
+                manifest.updateCodecSupport(codecsSupportInfo);
+            }
+            catch (err) {
+                this._onFatalError(err);
+            }
         }
-        var initialObservation = corePlaybackObserver.getReference().getValue();
-        var sentInitialObservation = (0, object_assign_1.default)(initialObservation, {
-            position: initialObservation.position.serialize(),
-        });
-        this._settings.coreInterface.sendMessage({
-            type: "start" /* MainThreadMessageType.StartPreparedContent */,
-            contentId: contentId,
-            value: {
-                initialTime: initialTime,
-                initialObservation: sentInitialObservation,
-                drmSystemId: drmInitStatus.drmSystemId,
-                enableFastSwitching: enableFastSwitching,
-                onCodecSwitch: onCodecSwitch,
-            },
-        });
-        corePlaybackObserver.listen(function (obs) {
-            _this._settings.coreInterface.sendMessage({
-                type: "observation" /* MainThreadMessageType.PlaybackObservation */,
-                contentId: contentId,
-                value: (0, object_assign_1.default)(obs, { position: obs.position.serialize() }),
-            });
-        }, {
-            includeLastObservation: false,
-            clearSignal: this._currentMediaSourceCanceller.signal,
-        });
-        this.trigger("manifestReady", manifest);
-        return true;
     };
-    /**
-     * Handles core messages asking to create a MediaSource.
-     * @param {Object} msg - The core's message received.
-     * @param {HTMLMediaElement} mediaElement - HTMLMediaElement on which the
-     * content plays.
-     * @param {Object} coreInterface - The interface to the core.
-     */
-    MediaSourceContentInitializer.prototype._onCreateMediaSourceMessage = function (msg, mediaElement, mediaSourceStatus, coreInterface) {
-        var _this = this;
-        var _a;
-        if (((_a = this._currentContentInfo) === null || _a === void 0 ? void 0 : _a.contentId) !== msg.contentId) {
-            log_1.default.info("Init", "Ignoring MediaSource attachment due to wrong `contentId`");
+    return MediaSourceContentInitializer;
+}(types_1.ContentInitializer));
+exports.default = MediaSourceContentInitializer;
+function createTextDisplayer(mediaElement, textTrackOptions) {
+    if (textTrackOptions.textTrackMode === "html" && features_1.default.htmlTextDisplayer !== null) {
+        return new features_1.default.htmlTextDisplayer(mediaElement, textTrackOptions.textTrackElement);
+    }
+    else if (features_1.default.nativeTextDisplayer !== null) {
+        return new features_1.default.nativeTextDisplayer(mediaElement);
+    }
+    return null;
+}
+/**
+ * Change the decipherability of Representations which have their key id in one
+ * of the given Arrays:
+ *
+ *   - Those who have a key id listed in `whitelistedKeyIds` will have their
+ *     decipherability updated to `true`
+ *
+ *   - Those who have a key id listed in `blacklistedKeyIds` will have their
+ *     decipherability updated to `false`
+ *
+ *   - Those who have a key id listed in `delistedKeyIds` will have their
+ *     decipherability updated to `undefined`.
+ *
+ * @param {Object} manifest
+ * @param {Array.<Uint8Array>} whitelistedKeyIds
+ * @param {Array.<Uint8Array>} blacklistedKeyIds
+ * @param {Array.<Uint8Array>} delistedKeyIds
+ */
+function updateKeyIdsDecipherabilityOnManifest(manifest, whitelistedKeyIds, blacklistedKeyIds, delistedKeyIds) {
+    manifest.updateRepresentationsDeciperability(function (ctx) {
+        var e_2, _a, e_3, _b, e_4, _c, e_5, _d;
+        var representation = ctx.representation;
+        if (representation.contentProtections === undefined) {
+            return representation.decipherable;
         }
-        else {
-            var mediaSourceId_1 = msg.mediaSourceId;
+        var contentKIDs = representation.contentProtections.keyIds;
+        if (contentKIDs !== undefined) {
             try {
-                mediaSourceStatus.onUpdate(function (currStatus, stopListening) {
-                    var _a;
-                    if (_this._currentContentInfo === null) {
-                        stopListening();
-                        return;
+                for (var contentKIDs_1 = __values(contentKIDs), contentKIDs_1_1 = contentKIDs_1.next(); !contentKIDs_1_1.done; contentKIDs_1_1 = contentKIDs_1.next()) {
+                    var elt = contentKIDs_1_1.value;
+                    try {
+                        for (var blacklistedKeyIds_1 = (e_3 = void 0, __values(blacklistedKeyIds)), blacklistedKeyIds_1_1 = blacklistedKeyIds_1.next(); !blacklistedKeyIds_1_1.done; blacklistedKeyIds_1_1 = blacklistedKeyIds_1.next()) {
+                            var blacklistedKeyId = blacklistedKeyIds_1_1.value;
+                            if ((0, are_arrays_of_numbers_equal_1.default)(blacklistedKeyId, elt)) {
+                                return false;
+                            }
+                        }
                     }
-                    if (currStatus === 1 /* MediaSourceInitializationStatus.AttachNow */) {
-                        stopListening();
-                        var mediaSource_3 = new main_media_source_interface_1.default(mediaSourceId_1, "FORCED_MEDIA_SOURCE" in mediaElement
-                            ? mediaElement.FORCED_MEDIA_SOURCE
-                            : undefined);
-                        if (((_a = _this._currentContentInfo.mediaSourceInfo) === null || _a === void 0 ? void 0 : _a.type) === "main") {
-                            _this._currentContentInfo.mediaSourceInfo.mediaSource.dispose();
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (blacklistedKeyIds_1_1 && !blacklistedKeyIds_1_1.done && (_b = blacklistedKeyIds_1.return)) _b.call(blacklistedKeyIds_1);
                         }
-                        _this._currentContentInfo.mediaSourceInfo = {
-                            type: "main",
-                            mediaSource: mediaSource_3,
-                        };
-                        mediaSource_3.addEventListener("mediaSourceOpen", function () {
-                            coreInterface.sendMessage({
-                                type: "media-source-ready-state-change" /* MainThreadMessageType.MediaSourceReadyStateChange */,
-                                mediaSourceId: mediaSourceId_1,
-                                value: "open",
-                            });
-                        });
-                        mediaSource_3.addEventListener("mediaSourceEnded", function () {
-                            coreInterface.sendMessage({
-                                type: "media-source-ready-state-change" /* MainThreadMessageType.MediaSourceReadyStateChange */,
-                                mediaSourceId: mediaSourceId_1,
-                                value: "ended",
-                            });
-                        });
-                        mediaSource_3.addEventListener("mediaSourceClose", function () {
-                            coreInterface.sendMessage({
-                                type: "media-source-ready-state-change" /* MainThreadMessageType.MediaSourceReadyStateChange */,
-                                mediaSourceId: mediaSourceId_1,
-                                value: "closed",
-                            });
-                        });
-                        var url_1 = null;
-                        if (mediaSource_3.handle.type === "handle") {
-                            mediaElement.srcObject = mediaSource_3.handle.value;
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    try {
+                        for (var whitelistedKeyIds_1 = (e_4 = void 0, __values(whitelistedKeyIds)), whitelistedKeyIds_1_1 = whitelistedKeyIds_1.next(); !whitelistedKeyIds_1_1.done; whitelistedKeyIds_1_1 = whitelistedKeyIds_1.next()) {
+                            var whitelistedKeyId = whitelistedKeyIds_1_1.value;
+                            if ((0, are_arrays_of_numbers_equal_1.default)(whitelistedKeyId, elt)) {
+                                return true;
+                            }
                         }
-                        else {
-                            url_1 = URL.createObjectURL(mediaSource_3.handle.value);
-                            mediaElement.src = url_1;
+                    }
+                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    finally {
+                        try {
+                            if (whitelistedKeyIds_1_1 && !whitelistedKeyIds_1_1.done && (_c = whitelistedKeyIds_1.return)) _c.call(whitelistedKeyIds_1);
                         }
-                        _this._currentMediaSourceCanceller.signal.register(function () {
-                            mediaSource_3.dispose();
-                            (0, create_media_source_1.resetMediaElement)(mediaElement, url_1);
-                        });
-                        mediaSourceStatus.setValue(2 /* MediaSourceInitializationStatus.Attached */);
-                        (0, create_media_source_1.disableRemotePlaybackOnManagedMediaSource)(mediaElement, _this._currentMediaSourceCanceller.signal);
+                        finally { if (e_4) throw e_4.error; }
                     }
-                }, {
-                    emitCurrentValue: true,
-                    clearSignal: this._currentMediaSourceCanceller.signal,
-                });
+                    try {
+                        for (var delistedKeyIds_1 = (e_5 = void 0, __values(delistedKeyIds)), delistedKeyIds_1_1 = delistedKeyIds_1.next(); !delistedKeyIds_1_1.done; delistedKeyIds_1_1 = delistedKeyIds_1.next()) {
+                            var delistedKeyId = delistedKeyIds_1_1.value;
+                            if ((0, are_arrays_of_numbers_equal_1.default)(delistedKeyId, elt)) {
+                                return undefined;
+                            }
+                        }
+                    }
+                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                    finally {
+                        try {
+                            if (delistedKeyIds_1_1 && !delistedKeyIds_1_1.done && (_d = delistedKeyIds_1.return)) _d.call(delistedKeyIds_1);
+                        }
+                        finally { if (e_5) throw e_5.error; }
+                    }
+                }
             }
-            catch (_err) {
-                var error = new errors_1.OtherError("NONE", "Unknown error when creating the MediaSource");
-                this._onFatalError(error);
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (contentKIDs_1_1 && !contentKIDs_1_1.done && (_a = contentKIDs_1.return)) _a.call(contentKIDs_1);
+                }
+                finally { if (e_2) throw e_2.error; }
             }
         }
-    };
-    return MediaSourceContentInitializer;
-}(types_1.ContentInitializer));
-exports.default = MediaSourceContentInitializer;
-function bindNumberReferencesToCore(coreInterface, cancellationSignal) {
-    var e_2, _a;
-    var refs = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        refs[_i - 2] = arguments[_i];
-    }
-    var _loop_1 = function (ref) {
-        ref[0].onUpdate(function (newVal) {
-            // NOTE: The TypeScript checks have already been made by this function's
-            // overload, but the body here is not aware of that.
-            coreInterface.sendMessage({
-                type: "ref-update" /* MainThreadMessageType.ReferenceUpdate */,
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
-                value: { name: ref[1], newVal: newVal },
-            });
-        }, { clearSignal: cancellationSignal, emitCurrentValue: true });
-    };
-    try {
-        for (var refs_1 = __values(refs), refs_1_1 = refs_1.next(); !refs_1_1.done; refs_1_1 = refs_1.next()) {
-            var ref = refs_1_1.value;
-            _loop_1(ref);
+        return representation.decipherable;
+    });
+}
+/**
+ * Update decipherability to `false` to any Representation which is linked to
+ * the given initialization data.
+ * @param {Object} manifest
+ * @param {Object} initData
+ */
+function blackListProtectionDataOnManifest(manifest, initData) {
+    manifest.updateRepresentationsDeciperability(function (ctx) {
+        var e_6, _a;
+        var _b, _c;
+        var rep = ctx.representation;
+        if (rep.decipherable === false) {
+            return false;
         }
-    }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
+        var segmentProtections = (_c = (_b = rep.contentProtections) === null || _b === void 0 ? void 0 : _b.initData) !== null && _c !== void 0 ? _c : [];
+        var _loop_1 = function (protection) {
+            if (initData.type === undefined || protection.type === initData.type) {
+                var containedInitData = initData.values
+                    .getFormattedValues()
+                    .every(function (undecipherableVal) {
+                    return protection.values.some(function (currVal) {
+                        return ((undecipherableVal.systemId === undefined ||
+                            currVal.systemId === undecipherableVal.systemId) &&
+                            (0, are_arrays_of_numbers_equal_1.default)(currVal.data, undecipherableVal.data));
+                    });
+                });
+                if (containedInitData) {
+                    return { value: false };
+                }
+            }
+        };
         try {
-            if (refs_1_1 && !refs_1_1.done && (_a = refs_1.return)) _a.call(refs_1);
+            for (var segmentProtections_1 = __values(segmentProtections), segmentProtections_1_1 = segmentProtections_1.next(); !segmentProtections_1_1.done; segmentProtections_1_1 = segmentProtections_1.next()) {
+                var protection = segmentProtections_1_1.value;
+                var state_1 = _loop_1(protection);
+                if (typeof state_1 === "object")
+                    return state_1.value;
+            }
         }
-        finally { if (e_2) throw e_2.error; }
-    }
-}
-function formatCoreError(sentError) {
-    switch (sentError.name) {
-        case "NetworkError":
-            return new errors_1.NetworkError(sentError.code, new request_1.RequestError(sentError.baseError.url, sentError.baseError.status, sentError.baseError.type));
-        case "MediaError":
-            // eslint-disable-next-line
-            return new errors_1.MediaError(sentError.code, sentError.reason, {
-                tracks: sentError.tracks,
-            });
-        case "EncryptedMediaError":
-            // We assume that everything have already been checked Worker-side here
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            return new errors_1.EncryptedMediaError(sentError.code, sentError.reason, {
-                keyStatuses: sentError.keyStatuses,
-                keySystemConfiguration: sentError.keySystemConfiguration,
-                keySystem: sentError.keySystem,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            });
-        case "OtherError":
-            return new errors_1.OtherError(sentError.code, sentError.reason);
-    }
-}
-function formatSourceBufferError(error) {
-    if (error instanceof errors_1.SourceBufferError) {
-        return error;
-    }
-    else if (error instanceof Error) {
-        return new errors_1.SourceBufferError(error.name, error.message, error.name === "QuotaExceededError");
-    }
-    else {
-        return new errors_1.SourceBufferError("Error", "Unknown SourceBufferError Error", false);
-    }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (segmentProtections_1_1 && !segmentProtections_1_1.done && (_a = segmentProtections_1.return)) _a.call(segmentProtections_1);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        return rep.decipherable;
+    });
 }
 /**
- * The Core might send back logs. In that situation, the message might be
- * formatted slightly differently to be able to cross threads (so a
- * serializable format has to be sent).
- *
- * This function translates that Core format to what's expected by the
- * logger.
- *
- * @param {*} arg
- * @returns {*}
+ * Handle accordingly an `IFreezeResolution` object.
+ * @param {Object|null} freezeResolution - The `IFreezeResolution` suggested.
+ * @param {Object} param - Parameters that might be needed to implement the
+ * resolution.
+ * @param {Object} param.manifest - The current content's Manifest object.
+ * @param {Object} param.playbackObserver - Object regularly emitting playback
+ * conditions.
+ * @param {Function} param.triggerReload - Function to call if we need to ask
+ * for a "MediaSource reload".
+ * @param {Boolean} param.enableRepresentationAvoidance - If `true`, this
+ * function is authorized to mark `Representation` as "to avoid" if the
+ * `IFreezeResolution` object suggest it.
  */
-function formatSentLogObject(arg) {
-    if (typeof arg !== "object") {
-        return arg;
-    }
-    if ((arg === null || arg === void 0 ? void 0 : arg.isSerializedError) === true) {
-        return formatCoreError(arg);
+function handleFreezeResolution(freezeResolution, _a) {
+    var playbackObserver = _a.playbackObserver, enableRepresentationAvoidance = _a.enableRepresentationAvoidance, manifest = _a.manifest, triggerReload = _a.triggerReload;
+    switch (freezeResolution.type) {
+        case "reload": {
+            log_1.default.info("Init", "Planning reload due to freeze");
+            triggerReload();
+            break;
+        }
+        case "flush": {
+            log_1.default.info("Init", "Flushing buffer due to freeze");
+            var observation = playbackObserver.getReference().getValue();
+            var currentTime = observation.position.isAwaitingFuturePosition()
+                ? observation.position.getWanted()
+                : playbackObserver.getCurrentTime();
+            var relativeResumingPosition = freezeResolution.value.relativeSeek;
+            var wantedSeekingTime = currentTime + relativeResumingPosition;
+            playbackObserver.setCurrentTime(wantedSeekingTime);
+            break;
+        }
+        case "avoid-representations": {
+            var contents = freezeResolution.value;
+            if (enableRepresentationAvoidance) {
+                manifest.addRepresentationsToAvoid(contents);
+            }
+            triggerReload();
+            break;
+        }
+        default:
+            (0, assert_1.assertUnreachable)(freezeResolution);
     }
-    return arg;
 }