rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

package/dist/commonjs/main_thread/api/public_api.js

@@ -0,0 +1,3094 @@
+"use strict";
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");publicapi
+ * 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 ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var can_rely_on_video_visibility_and_size_1 = require("../../compat/can_rely_on_video_visibility_and_size");
+var event_listeners_1 = require("../../compat/event_listeners");
+var get_start_date_1 = require("../../compat/get_start_date");
+var has_mse_in_worker_1 = require("../../compat/has_mse_in_worker");
+var has_worker_api_1 = require("../../compat/has_worker_api");
+var config_1 = require("../../config");
+var errors_1 = require("../../errors");
+var worker_initialization_error_1 = require("../../errors/worker_initialization_error");
+var features_1 = require("../../features");
+var log_1 = require("../../log");
+var manifest_1 = require("../../manifest");
+var media_element_playback_observer_1 = require("../../playback_observer/media_element_playback_observer");
+var array_find_1 = require("../../utils/array_find");
+var array_includes_1 = require("../../utils/array_includes");
+var assert_1 = require("../../utils/assert");
+var event_emitter_1 = require("../../utils/event_emitter");
+var global_scope_1 = require("../../utils/global_scope");
+var id_generator_1 = require("../../utils/id_generator");
+var is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+var monotonic_timestamp_1 = require("../../utils/monotonic_timestamp");
+var object_assign_1 = require("../../utils/object_assign");
+var ranges_1 = require("../../utils/ranges");
+var reference_1 = require("../../utils/reference");
+var task_canceller_1 = require("../../utils/task_canceller");
+var decrypt_1 = require("../decrypt");
+var render_thumbnail_1 = require("../render_thumbnail");
+var tracks_store_1 = require("../tracks_store");
+var option_utils_1 = require("./option_utils");
+var utils_1 = require("./utils");
+/* eslint-disable @typescript-eslint/naming-convention */
+// Enable debug mode as soon as `RX_PLAYER_DEBUG_MODE__` is set to `true`:
+var globals = global_scope_1.default;
+var isDebugModeEnabled = typeof globals.__RX_PLAYER_DEBUG_MODE__ === "boolean" &&
+    globals.__RX_PLAYER_DEBUG_MODE__;
+try {
+    Object.defineProperty(globals, "__RX_PLAYER_DEBUG_MODE__", {
+        get: function () {
+            return isDebugModeEnabled;
+        },
+        set: function (val) {
+            isDebugModeEnabled = val;
+            if (val) {
+                Player.LogLevel = "DEBUG";
+                Player.LogFormat = "full";
+            }
+        },
+    });
+}
+catch (_err) {
+    // Ignore, maybe we're in some jsdom thing, maybe the current target does not
+    // authorize setting globals that way etc.
+}
+if (isDebugModeEnabled) {
+    log_1.default.setLevel("DEBUG", "full");
+}
+else if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
+    log_1.default.setLevel("NONE" /* __LOGGER_LEVEL__.CURRENT_LEVEL */, "standard");
+}
+var generateContentId = (0, id_generator_1.default)();
+/**
+ * @class Player
+ * @extends EventEmitter
+ */
+var Player = /** @class */ (function (_super) {
+    __extends(Player, _super);
+    /**
+     * @constructor
+     * @param {Object} options
+     */
+    function Player(options) {
+        if (options === void 0) { options = {}; }
+        var _this = _super.call(this) || this;
+        var _a = (0, option_utils_1.parseConstructorOptions)(options), baseBandwidth = _a.baseBandwidth, videoResolutionLimit = _a.videoResolutionLimit, maxBufferAhead = _a.maxBufferAhead, maxBufferBehind = _a.maxBufferBehind, throttleVideoBitrateWhenHidden = _a.throttleVideoBitrateWhenHidden, videoElement = _a.videoElement, wantedBufferAhead = _a.wantedBufferAhead, maxVideoBufferSize = _a.maxVideoBufferSize;
+        // Workaround to support Firefox autoplay on FF 42.
+        // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
+        videoElement.preload = "auto";
+        _this.version = /* PLAYER_VERSION */ "4.5.0-dev.2026012302";
+        _this.log = log_1.default;
+        _this.state = "STOPPED";
+        _this.videoElement = videoElement;
+        Player._priv_registerVideoElement(_this.videoElement);
+        var destroyCanceller = new task_canceller_1.default("API");
+        _this._destroyCanceller = destroyCanceller;
+        _this._priv_pictureInPictureRef = (0, event_listeners_1.getPictureOnPictureStateRef)(videoElement, destroyCanceller.signal);
+        _this._priv_speed = new reference_1.default(videoElement.playbackRate, _this._destroyCanceller.signal);
+        _this._priv_preferTrickModeTracks = false;
+        _this._priv_contentLock = new reference_1.default(false, _this._destroyCanceller.signal);
+        _this._priv_bufferOptions = {
+            wantedBufferAhead: new reference_1.default(wantedBufferAhead, _this._destroyCanceller.signal),
+            maxBufferAhead: new reference_1.default(maxBufferAhead, _this._destroyCanceller.signal),
+            maxBufferBehind: new reference_1.default(maxBufferBehind, _this._destroyCanceller.signal),
+            maxVideoBufferSize: new reference_1.default(maxVideoBufferSize, _this._destroyCanceller.signal),
+        };
+        _this._priv_bitrateInfos = {
+            lastBitrates: { audio: baseBandwidth, video: baseBandwidth },
+        };
+        _this._priv_throttleVideoBitrateWhenHidden = throttleVideoBitrateWhenHidden;
+        _this._priv_videoResolutionLimit = videoResolutionLimit;
+        _this._priv_currentError = null;
+        _this._priv_contentInfos = null;
+        _this._priv_contentEventsMemory = {};
+        _this._priv_reloadingMetadata = {};
+        _this._priv_lastAutoPlay = false;
+        _this._priv_workerData = null;
+        var onVolumeChange = function () {
+            _this.trigger("volumeChange", {
+                volume: videoElement.volume,
+                muted: videoElement.muted,
+            });
+        };
+        videoElement.addEventListener("volumechange", onVolumeChange);
+        destroyCanceller.signal.register(function () {
+            videoElement.removeEventListener("volumechange", onVolumeChange);
+        });
+        return _this;
+    }
+    Object.defineProperty(Player, "ErrorTypes", {
+        /** All possible Error types emitted by the RxPlayer. */
+        get: function () {
+            return errors_1.ErrorTypes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Player, "ErrorCodes", {
+        /** All possible Error codes emitted by the RxPlayer. */
+        get: function () {
+            return errors_1.ErrorCodes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Player, "LogLevel", {
+        /**
+         * Current log level.
+         * Update current log level.
+         * Should be either (by verbosity ascending):
+         *   - "NONE"
+         *   - "ERROR"
+         *   - "WARNING"
+         *   - "INFO"
+         *   - "DEBUG"
+         * Any other value will be translated to "NONE".
+         */
+        get: function () {
+            return log_1.default.getLevel();
+        },
+        set: function (logLevel) {
+            log_1.default.setLevel(logLevel, log_1.default.getFormat());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Player, "LogFormat", {
+        /**
+         * Current log format.
+         * Should be either (by verbosity ascending):
+         *   - "standard": Regular log messages.
+         *   - "full": More verbose format, including a timestamp and a namespace.
+         * Any other value will be translated to "standard".
+         */
+        get: function () {
+            return log_1.default.getFormat();
+        },
+        set: function (format) {
+            log_1.default.setLevel(log_1.default.getLevel(), format);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Add feature(s) to the RxPlayer.
+     * @param {Array.<Object>} featureList - Features wanted.
+     */
+    Player.addFeatures = function (featureList) {
+        (0, features_1.addFeatures)(featureList);
+    };
+    /**
+     * Register the video element to the set of elements currently in use.
+     * @param videoElement the video element to register.
+     * @throws Error - Throws if the element is already used by another player instance.
+     */
+    Player._priv_registerVideoElement = function (videoElement) {
+        if (Player._priv_currentlyUsedVideoElements.has(videoElement)) {
+            var errorMessage = "The video element is already attached to another RxPlayer instance." +
+                "\nMake sure to dispose the previous instance with player.dispose() before creating" +
+                " a new player instance attaching that video element.";
+            // eslint-disable-next-line no-console
+            console.warn(errorMessage);
+            /*
+             * TODO: for next major version 5.0: this need to throw an error instead of just logging
+             * this was not done for minor version as it could be considerated a breaking change.
+             *
+             * throw new Error(errorMessage);
+             */
+        }
+        Player._priv_currentlyUsedVideoElements.add(videoElement);
+    };
+    /**
+     * Deregister the video element of the set of elements currently in use.
+     * @param videoElement the video element to deregister.
+     */
+    Player._priv_deregisterVideoElement = function (videoElement) {
+        if (Player._priv_currentlyUsedVideoElements.has(videoElement)) {
+            Player._priv_currentlyUsedVideoElements.delete(videoElement);
+        }
+    };
+    /**
+     * TODO returns promise?
+     * @param {Object} workerSettings
+     */
+    Player.prototype.attachWorker = function (workerSettings) {
+        var _this = this;
+        return new Promise(function (res, rej) {
+            var _a;
+            if (!(0, has_worker_api_1.default)()) {
+                log_1.default.warn("API", "Cannot rely on a WebWorker: Worker API unavailable");
+                return rej(new worker_initialization_error_1.default("INCOMPATIBLE_ERROR", "Worker unavailable"));
+            }
+            // check if the user already attach worker before
+            // terminate the previous worker to release the resources
+            if (_this._priv_workerData !== null) {
+                if (_this.state !== "STOPPED") {
+                    log_1.default.warn("API", "Cannot attach a new worker while a content is playing, please stop the player first.");
+                    return rej(new worker_initialization_error_1.default("SETUP_ERROR", "Cannot attach a new worker while a content is playing"));
+                }
+                else {
+                    _this._priv_workerData.worker.terminate();
+                    _this._priv_workerData.messageListeners.clear();
+                    _this._priv_workerData = null;
+                }
+            }
+            var workerData;
+            if (typeof workerSettings.workerUrl === "string") {
+                workerData = {
+                    worker: new Worker(workerSettings.workerUrl),
+                    messageListeners: new Map(),
+                };
+            }
+            else if ("postMessage" in workerSettings.workerUrl) {
+                workerData = {
+                    worker: workerSettings.workerUrl,
+                    messageListeners: new Map(),
+                };
+            }
+            else {
+                var blobUrl = URL.createObjectURL(workerSettings.workerUrl);
+                workerData = {
+                    worker: new Worker(blobUrl),
+                    messageListeners: new Map(),
+                };
+                URL.revokeObjectURL(blobUrl);
+            }
+            _this._priv_workerData = workerData;
+            _this._priv_workerData.worker.onerror = function (evt) {
+                if (_this._priv_workerData !== null) {
+                    _this._priv_workerData.worker.terminate();
+                    _this._priv_workerData.messageListeners.clear();
+                    _this._priv_workerData = null;
+                }
+                log_1.default.error("API", "Unexpected worker error", evt.error instanceof Error ? evt.error : undefined);
+                rej(new worker_initialization_error_1.default("UNKNOWN_ERROR", 'Unexpected Worker "error" event'));
+            };
+            var handleInitMessages = function (msg) {
+                var msgData = msg.data;
+                if (msgData.type === "init-error" /* CoreMessageType.InitError */) {
+                    log_1.default.warn("API", "Processing InitError worker message: detaching worker");
+                    if (_this._priv_workerData !== null) {
+                        _this._priv_workerData.worker.removeEventListener("message", handleInitMessages);
+                        _this._priv_workerData.worker.terminate();
+                        _this._priv_workerData.messageListeners.clear();
+                        _this._priv_workerData = null;
+                    }
+                    rej(new worker_initialization_error_1.default("SETUP_ERROR", "Worker parser initialization failed: " + msgData.value.errorMessage));
+                }
+                else if (msgData.type === "init-success" /* CoreMessageType.InitSuccess */) {
+                    log_1.default.info("API", "InitSuccess received from worker.");
+                    if (_this._priv_workerData !== null) {
+                        _this._priv_workerData.worker.removeEventListener("message", handleInitMessages);
+                    }
+                    res();
+                }
+            };
+            var onAppDefinedMessage = function (evt) {
+                var e_1, _a;
+                if (evt.data.type !== "app-defined" /* CoreMessageType.AppDefined */) {
+                    return;
+                }
+                var _b = evt.data.value, name = _b.name, payload = _b.payload;
+                var listeners = workerData.messageListeners.get(name);
+                if (listeners === undefined) {
+                    return;
+                }
+                try {
+                    for (var _c = __values(listeners.slice()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var listener = _d.value;
+                        try {
+                            listener(payload);
+                        }
+                        catch (err) {
+                            log_1.default.error("API", "A message listener failed with an error:", err instanceof Error ? err : "Unknown Error");
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            };
+            _this._priv_workerData.worker.addEventListener("message", handleInitMessages);
+            _this._priv_workerData.worker.addEventListener("message", onAppDefinedMessage);
+            log_1.default.debug("M-->C", "Sending message", { name: "init" /* MainThreadMessageType.Init */ });
+            _this._priv_workerData.worker.postMessage({
+                type: "init" /* MainThreadMessageType.Init */,
+                value: {
+                    dashWasmUrl: workerSettings.dashWasmUrl,
+                    logLevel: log_1.default.getLevel(),
+                    logFormat: log_1.default.getFormat(),
+                    sendBackLogs: isDebugModeEnabled,
+                    date: Date.now(),
+                    timestamp: (0, monotonic_timestamp_1.default)(),
+                    hasVideo: ((_a = _this.videoElement) === null || _a === void 0 ? void 0 : _a.nodeName.toLowerCase()) === "video",
+                },
+            });
+            log_1.default.addEventListener("onLogLevelChange", function (logInfo) {
+                if (_this._priv_workerData === null) {
+                    return;
+                }
+                log_1.default.debug("M-->C", "Sending message", {
+                    name: "log-level-update" /* MainThreadMessageType.LogLevelUpdate */,
+                });
+                _this._priv_workerData.worker.postMessage({
+                    type: "log-level-update" /* MainThreadMessageType.LogLevelUpdate */,
+                    value: {
+                        logLevel: logInfo.level,
+                        logFormat: logInfo.format,
+                        sendBackLogs: isDebugModeEnabled,
+                    },
+                });
+            }, _this._destroyCanceller.signal);
+            var sendConfigUpdates = function (updates) {
+                if (_this._priv_workerData === null) {
+                    return;
+                }
+                log_1.default.debug("M-->C", "Sending message:", {
+                    name: "config-update" /* MainThreadMessageType.ConfigUpdate */,
+                });
+                _this._priv_workerData.worker.postMessage({
+                    type: "config-update" /* MainThreadMessageType.ConfigUpdate */,
+                    value: updates,
+                });
+            };
+            if (config_1.default.updated) {
+                sendConfigUpdates(config_1.default.getCurrent());
+            }
+            config_1.default.addEventListener("update", sendConfigUpdates, _this._destroyCanceller.signal);
+        });
+    };
+    /**
+     * Construct Object allowing to exchange message with the worker associated to
+     * this RxPlayer instance.
+     * @returns {Object|null} Object allowing communication with the Worker
+     * associated to an `RxPlayer`'s instance.
+     * `null` if no worker is attached currently.
+     */
+    Player.prototype.getWorkerInterface = function () {
+        if (this._priv_workerData === null) {
+            return null;
+        }
+        var workerData = this._priv_workerData;
+        /** @see IWorkerInterface */
+        return {
+            sendMessage: function (messageName, payload) {
+                workerData.worker.postMessage({
+                    type: "app-defined" /* MainThreadMessageType.AppDefined */,
+                    value: {
+                        name: messageName,
+                        payload: payload,
+                    },
+                });
+            },
+            addMessageListener: function (messageName, callback) {
+                var prev = workerData.messageListeners.get(messageName);
+                if (prev === undefined) {
+                    workerData.messageListeners.set(messageName, [callback]);
+                }
+                else {
+                    workerData.messageListeners.set(messageName, __spreadArray(__spreadArray([], __read(prev), false), [callback], false));
+                }
+            },
+            removeMessageListener: function (messageName, callback) {
+                var prev = workerData.messageListeners.get(messageName);
+                if (prev === undefined) {
+                    return;
+                }
+                while (true) {
+                    var indexOf = prev.indexOf(callback);
+                    if (indexOf < 0) {
+                        return;
+                    }
+                    prev.splice(indexOf, 1);
+                    if (prev.length === 0) {
+                        workerData.messageListeners.delete(messageName);
+                        return;
+                    }
+                }
+            },
+        };
+    };
+    /**
+     * Returns information on which "mode" the RxPlayer is running for the current
+     * content (e.g. main logic running in a WebWorker or not, are we in
+     * directfile mode...).
+     *
+     * Returns `null` if no content is loaded.
+     * @returns {Object|null}
+     */
+    Player.prototype.getCurrentModeInformation = function () {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        return {
+            isDirectFile: this._priv_contentInfos.isDirectFile,
+            useWorker: this._priv_contentInfos.useWorker,
+        };
+    };
+    /**
+     * Register a new callback for a player event event.
+     *
+     * @param {string} evt - The event to register a callback to
+     * @param {Function} fn - The callback to call as that event is triggered.
+     * The callback will take as argument the eventual payload of the event
+     * (single argument).
+     */
+    Player.prototype.addEventListener = function (evt, fn) {
+        // The EventEmitter's `addEventListener` method takes an optional third
+        // argument that we do not want to expose in the public API.
+        // We thus overwrite that function to remove any possible usage of that
+        // third argument.
+        return _super.prototype.addEventListener.call(this, evt, fn);
+    };
+    /**
+     * Stop the playback for the current content.
+     */
+    Player.prototype.stop = function () {
+        if (this._priv_contentInfos !== null) {
+            this._priv_contentInfos.currentContentCanceller.cancel("API stop");
+        }
+        this._priv_cleanUpCurrentContentState();
+        if (this.state !== "STOPPED" /* PLAYER_STATES.STOPPED */) {
+            this._priv_setPlayerState("STOPPED" /* PLAYER_STATES.STOPPED */);
+        }
+    };
+    /**
+     * Free the resources used by the player.
+     * /!\ The player cannot be "used" anymore after this method has been called.
+     */
+    Player.prototype.dispose = function () {
+        // free resources linked to the loaded content
+        this.stop();
+        if (this.videoElement !== null) {
+            Player._priv_deregisterVideoElement(this.videoElement);
+            // free resources used for decryption management
+            (0, decrypt_1.disposeDecryptionResources)(this.videoElement).catch(function (err) {
+                var message = err instanceof Error ? err.message : "Unknown error";
+                log_1.default.error("API", "Could not dispose decryption resources: " + message);
+            });
+        }
+        // free resources linked to the Player instance
+        this._destroyCanceller.cancel("API destroy");
+        this._priv_reloadingMetadata = {};
+        // un-attach video element
+        this.videoElement = null;
+        if (this._priv_workerData !== null) {
+            this._priv_workerData.worker.terminate();
+            this._priv_workerData.messageListeners.clear();
+            this._priv_workerData = null;
+        }
+    };
+    /**
+     * Load a new video.
+     * @param {Object} opts
+     */
+    Player.prototype.loadVideo = function (opts) {
+        var options = (0, option_utils_1.parseLoadVideoOptions)(opts);
+        log_1.default.info("API", "Calling loadvideo", {
+            url: options.url,
+            transport: options.transport,
+        });
+        this._priv_reloadingMetadata = { options: options };
+        this._priv_initializeContentPlayback(options);
+        this._priv_lastAutoPlay = options.autoPlay;
+    };
+    /**
+     * Reload the last loaded content.
+     * @param {Object} reloadOpts
+     */
+    Player.prototype.reload = function (reloadOpts) {
+        var _a, _b, _c;
+        var _d = this._priv_reloadingMetadata, options = _d.options, manifest = _d.manifest, reloadPosition = _d.reloadPosition, reloadInPause = _d.reloadInPause;
+        if (options === undefined) {
+            throw new Error("API: Can't reload without having previously loaded a content.");
+        }
+        (0, option_utils_1.checkReloadOptions)(reloadOpts);
+        var startAt;
+        if (((_a = reloadOpts === null || reloadOpts === void 0 ? void 0 : reloadOpts.reloadAt) === null || _a === void 0 ? void 0 : _a.position) !== undefined) {
+            startAt = { position: reloadOpts.reloadAt.position };
+        }
+        else if (((_b = reloadOpts === null || reloadOpts === void 0 ? void 0 : reloadOpts.reloadAt) === null || _b === void 0 ? void 0 : _b.relative) !== undefined) {
+            if (reloadPosition === undefined) {
+                log_1.default.warn("API", "reload API > reloadAt.relative option given but we don't know the previous content's position");
+            }
+            else {
+                startAt = { position: reloadOpts.reloadAt.relative + reloadPosition };
+            }
+        }
+        else if (reloadPosition !== undefined) {
+            startAt = { position: reloadPosition };
+        }
+        var autoPlay;
+        if ((reloadOpts === null || reloadOpts === void 0 ? void 0 : reloadOpts.autoPlay) !== undefined) {
+            autoPlay = reloadOpts.autoPlay;
+        }
+        else if (reloadInPause !== undefined) {
+            autoPlay = !reloadInPause;
+        }
+        var keySystems;
+        if ((reloadOpts === null || reloadOpts === void 0 ? void 0 : reloadOpts.keySystems) !== undefined) {
+            keySystems = reloadOpts.keySystems;
+        }
+        else if (((_c = this._priv_reloadingMetadata.options) === null || _c === void 0 ? void 0 : _c.keySystems) !== undefined) {
+            keySystems = this._priv_reloadingMetadata.options.keySystems;
+        }
+        var newOptions = __assign(__assign({}, options), { initialManifest: manifest });
+        if (startAt !== undefined) {
+            newOptions.startAt = startAt;
+        }
+        if (autoPlay !== undefined) {
+            newOptions.autoPlay = autoPlay;
+        }
+        if (keySystems !== undefined) {
+            newOptions.keySystems = keySystems;
+        }
+        this._priv_initializeContentPlayback(newOptions);
+    };
+    Player.prototype.createDebugElement = function (element) {
+        if (features_1.default.createDebugElement === null) {
+            throw new Error("Feature `DEBUG_ELEMENT` not added to the RxPlayer");
+        }
+        var canceller = new task_canceller_1.default("API debug element");
+        features_1.default.createDebugElement(element, this, canceller.signal);
+        return {
+            dispose: function () {
+                canceller.cancel("API debug dispose");
+            },
+        };
+    };
+    /**
+     * Returns an array decribing the various thumbnail tracks that can be
+     * encountered at the wanted time or Period.
+     * @param {Object} arg
+     * @param {number|undefined} [arg.time] - The position to check for thumbnail
+     * tracks, in seconds.
+     * @param {string|undefined} [arg.periodId] - The Period to check for
+     * thumbnail tracks.
+     * If not set and if `arg.time` is also not set, the current Period will be
+     * considered.
+     * @returns {Array.<Object>}
+     */
+    Player.prototype.getAvailableThumbnailTracks = function (_a) {
+        var _b = _a === void 0 ? {} : _a, time = _b.time, periodId = _b.periodId;
+        if (this._priv_contentInfos === null || this._priv_contentInfos.manifest === null) {
+            return [];
+        }
+        var manifest = this._priv_contentInfos.manifest;
+        var period;
+        if (time !== undefined) {
+            period = (0, manifest_1.getPeriodForTime)(this._priv_contentInfos.manifest, time);
+            if (period === undefined || period.thumbnailTracks.length === 0) {
+                return [];
+            }
+        }
+        else if (periodId !== undefined) {
+            period = (0, array_find_1.default)(manifest.periods, function (p) { return p.id === periodId; });
+            if (period === undefined) {
+                log_1.default.error("API", "getAvailableThumbnailTracks: periodId not found", { periodId: periodId });
+                return [];
+            }
+        }
+        else {
+            var currentPeriod = this._priv_contentInfos.currentPeriod;
+            if (currentPeriod === null) {
+                return [];
+            }
+            period = currentPeriod;
+        }
+        return period.thumbnailTracks.map(function (t) {
+            return {
+                id: t.id,
+                width: Math.floor(t.width / t.horizontalTiles),
+                height: Math.floor(t.height / t.verticalTiles),
+                mimeType: t.mimeType,
+            };
+        });
+    };
+    /**
+     * Render inside the given `container` the thumbnail corresponding to the
+     * given time.
+     *
+     * If no thumbnail is available at that time or if the RxPlayer does not succeed
+     * to load or render it, reject the corresponding Promise and remove the
+     * potential previous thumbnail from the container.
+     *
+     * If a new `renderThumbnail` call is made with the same `container` before it
+     * had time to finish, the Promise is also rejected but the previous thumbnail
+     * potentially found in the container is untouched.
+     *
+     * @param {Object|undefined} options
+     * @returns {Promise}
+     */
+    Player.prototype.renderThumbnail = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if ((0, is_null_or_undefined_1.default)(options.time)) {
+                    throw new Error("You have to provide a `time` property to `renderThumbnail`, indicating the wanted thumbnail time in seconds.");
+                }
+                if ((0, is_null_or_undefined_1.default)(options.container)) {
+                    throw new Error("You have to provide a `container` property to `renderThumbnail`, specifying the HTML Element in which the thumbnail should be inserted.");
+                }
+                return [2 /*return*/, (0, render_thumbnail_1.default)(this._priv_contentInfos, options)];
+            });
+        });
+    };
+    /**
+     * From given options, initialize content playback.
+     * @param {Object} options
+     */
+    Player.prototype._priv_initializeContentPlayback = function (options) {
+        var _this = this;
+        var _a, _b, _c, _d, _f, _g, _h, _j, _k, _l;
+        var autoPlay = options.autoPlay, cmcd = options.cmcd, defaultAudioTrackSwitchingMode = options.defaultAudioTrackSwitchingMode, enableFastSwitching = options.enableFastSwitching, initialManifest = options.initialManifest, keySystems = options.keySystems, lowLatencyMode = options.lowLatencyMode, minimumManifestUpdateInterval = options.minimumManifestUpdateInterval, requestConfig = options.requestConfig, onCodecSwitch = options.onCodecSwitch, startAt = options.startAt, transport = options.transport, checkMediaSegmentIntegrity = options.checkMediaSegmentIntegrity, checkManifestIntegrity = options.checkManifestIntegrity, manifestLoader = options.manifestLoader, referenceDateTime = options.referenceDateTime, segmentLoader = options.segmentLoader, serverSyncInfos = options.serverSyncInfos, experimentalOptions = options.experimentalOptions, __priv_manifestUpdateUrl = options.__priv_manifestUpdateUrl, __priv_patchLastSegmentInSidx = options.__priv_patchLastSegmentInSidx, url = options.url, onAudioTracksNotPlayable = options.onAudioTracksNotPlayable, onVideoTracksNotPlayable = options.onVideoTracksNotPlayable;
+        // Perform multiple checks on the given options
+        if (this.videoElement === null) {
+            throw new Error("the attached video element is disposed");
+        }
+        var isDirectFile = transport === "directfile";
+        /** Emit to stop the current content. */
+        var currentContentCanceller = new task_canceller_1.default("API current content");
+        var videoElement = this.videoElement;
+        var initializer;
+        var useWorker = false;
+        var mediaElementTracksStore = null;
+        if (!isDirectFile) {
+            /** Interface used to load and refresh the Manifest. */
+            var manifestRequestSettings = {
+                lowLatencyMode: lowLatencyMode,
+                maxRetry: (_a = requestConfig.manifest) === null || _a === void 0 ? void 0 : _a.maxRetry,
+                requestTimeout: (_b = requestConfig.manifest) === null || _b === void 0 ? void 0 : _b.timeout,
+                connectionTimeout: (_c = requestConfig.manifest) === null || _c === void 0 ? void 0 : _c.connectionTimeout,
+                minimumManifestUpdateInterval: minimumManifestUpdateInterval,
+                initialManifest: initialManifest,
+            };
+            var relyOnVideoVisibilityAndSize = (0, can_rely_on_video_visibility_and_size_1.default)();
+            var throttlers = {
+                throttleBitrate: {},
+                limitResolution: {},
+            };
+            if (this._priv_throttleVideoBitrateWhenHidden) {
+                if (!relyOnVideoVisibilityAndSize) {
+                    log_1.default.warn("API", "Can't apply throttleVideoBitrateWhenHidden because " +
+                        "browser can't be trusted for visibility.");
+                }
+                else {
+                    throttlers.throttleBitrate = {
+                        video: (0, reference_1.createMappedReference)((0, event_listeners_1.getVideoVisibilityRef)(this._priv_pictureInPictureRef, currentContentCanceller.signal), function (isActive) { return (isActive ? Infinity : 0); }, currentContentCanceller.signal),
+                    };
+                }
+            }
+            if (this._priv_videoResolutionLimit === "videoElement") {
+                if (!relyOnVideoVisibilityAndSize) {
+                    log_1.default.warn("API", "Can't apply videoResolutionLimit because browser can't be " +
+                        "trusted for video size.");
+                }
+                else {
+                    throttlers.limitResolution = {
+                        video: (0, event_listeners_1.getElementResolutionRef)(videoElement, this._priv_pictureInPictureRef, currentContentCanceller.signal),
+                    };
+                }
+            }
+            else if (this._priv_videoResolutionLimit === "screen") {
+                throttlers.limitResolution = {
+                    video: (0, event_listeners_1.getScreenResolutionRef)(currentContentCanceller.signal),
+                };
+            }
+            /** Options used by the adaptive logic. */
+            var adaptiveOptions = {
+                initialBitrates: this._priv_bitrateInfos.lastBitrates,
+                lowLatencyMode: lowLatencyMode,
+                throttlers: throttlers,
+            };
+            /** Options used by the TextTrack SegmentSink. */
+            var textTrackOptions = options.textTrackMode === "native"
+                ? { textTrackMode: "native" }
+                : {
+                    textTrackMode: "html",
+                    textTrackElement: options.textTrackElement,
+                };
+            var bufferOptions = (0, object_assign_1.default)({ enableFastSwitching: enableFastSwitching, onCodecSwitch: onCodecSwitch }, this._priv_bufferOptions);
+            var segmentRequestOptions = {
+                lowLatencyMode: lowLatencyMode,
+                maxRetry: (_d = requestConfig.segment) === null || _d === void 0 ? void 0 : _d.maxRetry,
+                requestTimeout: (_f = requestConfig.segment) === null || _f === void 0 ? void 0 : _f.timeout,
+                connectionTimeout: (_g = requestConfig.segment) === null || _g === void 0 ? void 0 : _g.connectionTimeout,
+            };
+            var transportOptions = {
+                lowLatencyMode: lowLatencyMode,
+                checkMediaSegmentIntegrity: checkMediaSegmentIntegrity,
+                checkManifestIntegrity: checkManifestIntegrity,
+                referenceDateTime: referenceDateTime,
+                serverSyncInfos: serverSyncInfos,
+                manifestLoader: manifestLoader,
+                segmentLoader: segmentLoader,
+                representationFilter: options.representationFilter,
+                __priv_manifestUpdateUrl: __priv_manifestUpdateUrl,
+                __priv_patchLastSegmentInSidx: __priv_patchLastSegmentInSidx,
+            };
+            if (!this._priv_shouldLoadMultithread(options)) {
+                if (features_1.default.monothread === null) {
+                    throw new Error("Cannot load video, neither in a WebWorker nor with the " +
+                        "`MEDIA_SOURCE_MAIN` feature");
+                }
+                // Small checks, log if some option seems wrong
+                if (typeof ((_h = transportOptions.representationFilter) === null || _h === void 0 ? void 0 : _h.workerId) === "string" &&
+                    ((0, is_null_or_undefined_1.default)(transportOptions.representationFilter.fn) ||
+                        (0, is_null_or_undefined_1.default)(transportOptions.representationFilter.eval))) {
+                    log_1.default.warn("API", "You only set a `workerId` for a `representationFilter` in monothreaded mode. Ignoring it...");
+                }
+                if (typeof ((_j = transportOptions.manifestLoader) === null || _j === void 0 ? void 0 : _j.workerId) === "string" &&
+                    (0, is_null_or_undefined_1.default)(transportOptions.manifestLoader.fn)) {
+                    log_1.default.warn("API", "You only set a `workerId` for a `manifestLoader` in monothreaded mode. Ignoring it...");
+                }
+                if (typeof ((_k = transportOptions.segmentLoader) === null || _k === void 0 ? void 0 : _k.workerId) === "string" &&
+                    (0, is_null_or_undefined_1.default)(transportOptions.segmentLoader.fn)) {
+                    log_1.default.warn("API", "You only set a `workerId` for a `segmentLoader` in monothreaded mode. Ignoring it...");
+                }
+                log_1.default.info("API", "Initializing MediaSource mode in the main thread");
+                var coreInterface = new features_1.default.monothread.coreInterface();
+                var coreInterfaceCallbacks = coreInterface.getCallbacks();
+                features_1.default.monothread.initializeCoreEntry(coreInterfaceCallbacks.setCoreMessageReceiver, coreInterfaceCallbacks.sendCoreMessage, {
+                    // No need for core-side plugins in monothread mode
+                    representationFilters: new Map(),
+                    segmentLoaders: new Map(),
+                    manifestLoaders: new Map(),
+                });
+                coreInterface.sendMessage({
+                    type: "init" /* MainThreadMessageType.Init */,
+                    value: {
+                        dashWasmUrl: undefined,
+                        hasVideo: ((_l = this.videoElement) === null || _l === void 0 ? void 0 : _l.nodeName.toLowerCase()) === "video",
+                        logLevel: log_1.default.getLevel(),
+                        logFormat: log_1.default.getFormat(),
+                        sendBackLogs: false,
+                        date: Date.now(),
+                        timestamp: (0, monotonic_timestamp_1.default)(),
+                    },
+                });
+                initializer = new features_1.default.monothread.init({
+                    coreInterface: coreInterface,
+                    adaptiveOptions: adaptiveOptions,
+                    autoPlay: autoPlay,
+                    bufferOptions: bufferOptions,
+                    cmcd: cmcd,
+                    enableRepresentationAvoidance: experimentalOptions.enableRepresentationAvoidance,
+                    keySystems: keySystems,
+                    lowLatencyMode: lowLatencyMode,
+                    transport: transport,
+                    transportOptions: transportOptions,
+                    manifestRequestSettings: manifestRequestSettings,
+                    segmentRequestOptions: segmentRequestOptions,
+                    speed: this._priv_speed,
+                    startAt: startAt,
+                    textTrackOptions: textTrackOptions,
+                    url: url,
+                    useMseInWorker: false,
+                });
+            }
+            else {
+                if (features_1.default.multithread === null) {
+                    throw new Error("Cannot load video in multithread mode: `MULTI_THREAD` " +
+                        "feature not imported.");
+                }
+                else if (this._priv_workerData === null) {
+                    throw new Error("Cannot load video in multithread mode: `attachWorker` " +
+                        "method not called.");
+                }
+                // Small checks, log if some option seems wrong
+                if (transportOptions.representationFilter !== undefined &&
+                    !(0, is_null_or_undefined_1.default)(transportOptions.representationFilter.fn)) {
+                    transportOptions.representationFilter.fn = undefined;
+                    if ((0, is_null_or_undefined_1.default)(transportOptions.representationFilter.workerId) &&
+                        (0, is_null_or_undefined_1.default)(transportOptions.representationFilter.eval)) {
+                        log_1.default.warn("API", "You only set a representationFilter function in a mulithreaded mode, ignoring it...");
+                    }
+                }
+                if (transportOptions.manifestLoader !== undefined &&
+                    !(0, is_null_or_undefined_1.default)(transportOptions.manifestLoader.workerId)) {
+                    transportOptions.manifestLoader.fn = undefined;
+                    if ((0, is_null_or_undefined_1.default)(transportOptions.manifestLoader.fn)) {
+                        log_1.default.warn("API", "You only set a manifestLoader function in a mulithreaded mode, ignoring it...");
+                    }
+                }
+                if (transportOptions.segmentLoader !== undefined &&
+                    !(0, is_null_or_undefined_1.default)(transportOptions.segmentLoader.workerId)) {
+                    transportOptions.segmentLoader.fn = undefined;
+                    if ((0, is_null_or_undefined_1.default)(transportOptions.segmentLoader.fn)) {
+                        log_1.default.warn("API", "You only set a segmentLoader function in a mulithreaded mode, ignoring it...");
+                    }
+                }
+                // `initialManifest` is not supported in multithread mode.
+                manifestRequestSettings.initialManifest = undefined;
+                useWorker = true;
+                log_1.default.info("API", "Initializing MediaSource mode in a WebWorker");
+                initializer = new features_1.default.multithread.init({
+                    coreInterface: new features_1.default.multithread.coreInterface(this._priv_workerData.worker),
+                    adaptiveOptions: adaptiveOptions,
+                    autoPlay: autoPlay,
+                    bufferOptions: bufferOptions,
+                    cmcd: cmcd,
+                    enableRepresentationAvoidance: experimentalOptions.enableRepresentationAvoidance,
+                    keySystems: keySystems,
+                    lowLatencyMode: lowLatencyMode,
+                    transport: transport,
+                    transportOptions: transportOptions,
+                    manifestRequestSettings: manifestRequestSettings,
+                    segmentRequestOptions: segmentRequestOptions,
+                    speed: this._priv_speed,
+                    startAt: startAt,
+                    textTrackOptions: textTrackOptions,
+                    url: url,
+                    useMseInWorker: has_mse_in_worker_1.default,
+                });
+            }
+        }
+        else {
+            if (features_1.default.directfile === null) {
+                this.stop();
+                this._priv_currentError = null;
+                throw new Error("DirectFile feature not activated in your build.");
+            }
+            else if ((0, is_null_or_undefined_1.default)(url)) {
+                throw new Error("No URL for a DirectFile content");
+            }
+            log_1.default.info("API", "Initializing DirectFile mode in the main thread");
+            mediaElementTracksStore = this._priv_initializeMediaElementTracksStore(currentContentCanceller.signal);
+            if (currentContentCanceller.isUsed()) {
+                return;
+            }
+            initializer = new features_1.default.directfile.initDirectFile({
+                autoPlay: autoPlay,
+                keySystems: keySystems,
+                speed: this._priv_speed,
+                startAt: startAt,
+                url: url,
+            });
+        }
+        /** Global "playback observer" which will emit playback conditions */
+        var playbackObserver = new media_element_playback_observer_1.default({
+            withMediaSource: !isDirectFile,
+            lowLatencyMode: lowLatencyMode,
+        });
+        /*
+         * We want to block seeking operations until we know the media element is
+         * ready for it.
+         */
+        playbackObserver.blockSeeking();
+        currentContentCanceller.signal.register(function (err) {
+            playbackObserver.stop(err.reason);
+        });
+        /** Future `this._priv_contentInfos` related to this content. */
+        var contentInfos = {
+            contentId: generateContentId(),
+            originalUrl: url,
+            playbackObserver: playbackObserver,
+            currentContentCanceller: currentContentCanceller,
+            defaultAudioTrackSwitchingMode: defaultAudioTrackSwitchingMode,
+            initializer: initializer,
+            isDirectFile: isDirectFile,
+            manifest: null,
+            currentPeriod: null,
+            activeAdaptations: null,
+            activeRepresentations: null,
+            tracksStore: null,
+            mediaElementTracksStore: mediaElementTracksStore,
+            useWorker: useWorker,
+            segmentSinkMetricsCallback: null,
+            fetchThumbnailDataCallback: null,
+            thumbnailRequestsInfo: {
+                pendingRequests: new WeakMap(),
+                lastResponse: null,
+            },
+            onAudioTracksNotPlayable: onAudioTracksNotPlayable,
+            onVideoTracksNotPlayable: onVideoTracksNotPlayable,
+        };
+        // Bind events
+        initializer.addEventListener("error", function (error) {
+            _this._priv_onFatalError(error, contentInfos);
+        });
+        initializer.addEventListener("warning", function (error) {
+            var formattedError = (0, errors_1.formatError)(error, {
+                defaultCode: "NONE",
+                defaultReason: "An unknown error happened.",
+            });
+            log_1.default.warn("API", "Sending warning:", formattedError);
+            _this.trigger("warning", formattedError);
+        });
+        initializer.addEventListener("reloadingMediaSource", function (payload) {
+            if (contentInfos.tracksStore !== null) {
+                contentInfos.tracksStore.resetPeriodObjects();
+            }
+            if (_this._priv_contentInfos !== null) {
+                _this._priv_contentInfos.segmentSinkMetricsCallback = null;
+            }
+            _this._priv_lastAutoPlay = payload.autoPlay;
+        });
+        initializer.addEventListener("inbandEvents", function (inbandEvents) {
+            return _this.trigger("inbandEvents", inbandEvents);
+        });
+        initializer.addEventListener("streamEvent", function (streamEvent) {
+            return _this.trigger("streamEvent", streamEvent);
+        });
+        initializer.addEventListener("streamEventSkip", function (streamEventSkip) {
+            return _this.trigger("streamEventSkip", streamEventSkip);
+        });
+        initializer.addEventListener("activePeriodChanged", function (periodInfo) {
+            return _this._priv_onActivePeriodChanged(contentInfos, periodInfo);
+        });
+        initializer.addEventListener("periodStreamReady", function (periodReadyInfo) {
+            return _this._priv_onPeriodStreamReady(contentInfos, periodReadyInfo);
+        });
+        initializer.addEventListener("periodStreamCleared", function (periodClearedInfo) {
+            return _this._priv_onPeriodStreamCleared(contentInfos, periodClearedInfo);
+        });
+        initializer.addEventListener("representationChange", function (representationInfo) {
+            return _this._priv_onRepresentationChange(contentInfos, representationInfo);
+        });
+        initializer.addEventListener("adaptationChange", function (adaptationInfo) {
+            return _this._priv_onAdaptationChange(contentInfos, adaptationInfo);
+        });
+        initializer.addEventListener("bitrateEstimateChange", function (bitrateEstimateInfo) {
+            return _this._priv_onBitrateEstimateChange(bitrateEstimateInfo);
+        });
+        initializer.addEventListener("manifestReady", function (manifest) {
+            return _this._priv_onManifestReady(contentInfos, manifest);
+        });
+        initializer.addEventListener("manifestUpdate", function (updates) {
+            return _this._priv_onManifestUpdate(contentInfos, updates);
+        });
+        initializer.addEventListener("codecSupportUpdate", function () {
+            return _this._priv_onCodecSupportUpdate(contentInfos);
+        });
+        initializer.addEventListener("decipherabilityUpdate", function (updates) {
+            return _this._priv_onDecipherabilityUpdate(contentInfos, updates);
+        });
+        initializer.addEventListener("loaded", function (evt) {
+            if (_this._priv_contentInfos !== null) {
+                _this._priv_contentInfos.segmentSinkMetricsCallback = evt.getSegmentSinkMetrics;
+                _this._priv_contentInfos.fetchThumbnailDataCallback = evt.getThumbnailData;
+            }
+        });
+        // Now, that most events are linked, prepare the next content.
+        initializer.prepare();
+        // Now that the content is prepared, stop previous content and reset state
+        // This is done after content preparation as `stop` could technically have
+        // a long and synchronous blocking time.
+        // Note that this call is done **synchronously** after all events linking.
+        // This is **VERY** important so:
+        //   - the `STOPPED` state is switched to synchronously after loading a new
+        //     content.
+        //   - we can avoid involontarily catching events linked to the previous
+        //     content.
+        this.stop();
+        playbackObserver.attachMediaElement(videoElement);
+        // Update the RxPlayer's state at the right events
+        var playerStateRef = (0, utils_1.constructPlayerStateReference)(initializer, videoElement, playbackObserver, isDirectFile, currentContentCanceller.signal);
+        currentContentCanceller.signal.register(function (err) {
+            initializer.dispose(err.reason);
+        });
+        /**
+         * Function updating `this._priv_reloadingMetadata` in function of the
+         * current state and playback conditions.
+         * To call when either might change.
+         * @param {string} state - The player state we're about to switch to.
+         */
+        var updateReloadingMetadata = function (state) {
+            switch (state) {
+                case "STOPPED":
+                case "RELOADING":
+                case "LOADING":
+                    break; // keep previous metadata
+                case "ENDED":
+                    _this._priv_reloadingMetadata.reloadInPause = true;
+                    _this._priv_reloadingMetadata.reloadPosition = playbackObserver
+                        .getReference()
+                        .getValue()
+                        .position.getPolled();
+                    break;
+                default: {
+                    var o = playbackObserver.getReference().getValue();
+                    _this._priv_reloadingMetadata.reloadInPause = o.paused;
+                    _this._priv_reloadingMetadata.reloadPosition = o.position.getWanted();
+                    break;
+                }
+            }
+        };
+        /**
+         * `TaskCanceller` allowing to stop emitting `"play"` and `"pause"`
+         * events.
+         * `null` when such events are not emitted currently.
+         */
+        var playPauseEventsCanceller = null;
+        /**
+         * Callback emitting `"play"` and `"pause`" events once the content is
+         * loaded, starting from the state indicated in argument.
+         * @param {boolean} willAutoPlay - If `false`, we're currently paused.
+         */
+        var triggerPlayPauseEventsWhenReady = function (willAutoPlay) {
+            if (playPauseEventsCanceller !== null) {
+                playPauseEventsCanceller.cancel("reset"); // cancel previous logic
+                playPauseEventsCanceller = null;
+            }
+            playerStateRef.onUpdate(function (val, stopListeningToStateUpdates) {
+                if (!(0, utils_1.isLoadedState)(val)) {
+                    return; // content not loaded yet: no event
+                }
+                stopListeningToStateUpdates();
+                if (playPauseEventsCanceller !== null) {
+                    playPauseEventsCanceller.cancel("reset");
+                }
+                playPauseEventsCanceller = new task_canceller_1.default("API play/pause events");
+                playPauseEventsCanceller.linkToSignal(currentContentCanceller.signal);
+                if (willAutoPlay !== !videoElement.paused) {
+                    // paused status is not at the expected value on load: emit event
+                    if (videoElement.paused) {
+                        _this.trigger("pause", null);
+                    }
+                    else {
+                        _this.trigger("play", null);
+                    }
+                }
+                (0, utils_1.emitPlayPauseEvents)(videoElement, function () { return _this.trigger("play", null); }, function () { return _this.trigger("pause", null); }, currentContentCanceller.signal);
+            }, {
+                emitCurrentValue: false,
+                clearSignal: currentContentCanceller.signal,
+            });
+        };
+        triggerPlayPauseEventsWhenReady(autoPlay);
+        initializer.addEventListener("reloadingMediaSource", function (payload) {
+            triggerPlayPauseEventsWhenReady(payload.autoPlay);
+        });
+        this._priv_currentError = null;
+        this._priv_contentInfos = contentInfos;
+        /**
+         * `TaskCanceller` allowing to stop emitting `"seeking"` and `"seeked"`
+         * events.
+         * `null` when such events are not emitted currently.
+         */
+        var seekEventsCanceller = null;
+        // React to player state change
+        playerStateRef.onUpdate(function (newState) {
+            updateReloadingMetadata(newState);
+            _this._priv_setPlayerState(newState);
+            if (currentContentCanceller.isUsed()) {
+                return;
+            }
+            if (seekEventsCanceller !== null) {
+                if (!(0, utils_1.isLoadedState)(_this.state)) {
+                    seekEventsCanceller.cancel("Player State Update");
+                    seekEventsCanceller = null;
+                }
+            }
+            else if ((0, utils_1.isLoadedState)(_this.state)) {
+                seekEventsCanceller = new task_canceller_1.default("API seek events");
+                seekEventsCanceller.linkToSignal(currentContentCanceller.signal);
+                (0, utils_1.emitSeekEvents)(playbackObserver, function () { return _this.trigger("seeking", null); }, function () { return _this.trigger("seeked", null); }, seekEventsCanceller.signal);
+            }
+        }, { emitCurrentValue: true, clearSignal: currentContentCanceller.signal });
+        // React to playback conditions change
+        playbackObserver.listen(function (observation) {
+            updateReloadingMetadata(_this.state);
+            _this._priv_triggerPositionUpdate(contentInfos, observation);
+        }, { clearSignal: currentContentCanceller.signal });
+        currentContentCanceller.signal.register(function () {
+            initializer.removeEventListener();
+        });
+        // initialize the content only when the lock is inactive
+        this._priv_contentLock.onUpdate(function (isLocked, stopListeningToLock) {
+            if (!isLocked) {
+                stopListeningToLock();
+                // start playback!
+                initializer.start(videoElement, playbackObserver);
+            }
+        }, { emitCurrentValue: true, clearSignal: currentContentCanceller.signal });
+    };
+    /**
+     * Returns fatal error if one for the current content.
+     * null otherwise.
+     * @returns {Object|null} - The current Error (`null` when no error).
+     */
+    Player.prototype.getError = function () {
+        return this._priv_currentError;
+    };
+    /**
+     * Returns the media DOM element used by the player.
+     * You should not its HTML5 API directly and use the player's method instead,
+     * to ensure a well-behaved player.
+     * @returns {HTMLMediaElement|null} - The HTMLMediaElement used (`null` when
+     * disposed)
+     */
+    // eslint-disable-next-line @typescript-eslint/no-restricted-types
+    Player.prototype.getVideoElement = function () {
+        // eslint-disable-next-line @typescript-eslint/no-restricted-types
+        return this.videoElement;
+    };
+    /**
+     * Returns the player's current state.
+     * @returns {string} - The current Player's state
+     */
+    Player.prototype.getPlayerState = function () {
+        return this.state;
+    };
+    /**
+     * Returns true if a content is loaded.
+     * @returns {Boolean} - `true` if a content is loaded, `false` otherwise.
+     */
+    Player.prototype.isContentLoaded = function () {
+        return !(0, array_includes_1.default)(["LOADING", "RELOADING", "STOPPED"], this.state);
+    };
+    /**
+     * Returns true if the player is buffering.
+     * @returns {Boolean} - `true` if the player is buffering, `false` otherwise.
+     */
+    Player.prototype.isBuffering = function () {
+        return (0, array_includes_1.default)(["BUFFERING", "SEEKING", "LOADING", "RELOADING"], this.state);
+    };
+    /**
+     * Returns the play/pause status of the player :
+     *   - when `LOADING` or `RELOADING`, returns the scheduled play/pause condition
+     *     for when loading is over,
+     *   - in other states, returns the `<video>` element .paused value,
+     *   - if the player is disposed, returns `true`.
+     * @returns {Boolean} - `true` if the player is paused or will be after loading,
+     * `false` otherwise.
+     */
+    Player.prototype.isPaused = function () {
+        if (this.videoElement !== null) {
+            if ((0, array_includes_1.default)(["LOADING", "RELOADING"], this.state)) {
+                return !this._priv_lastAutoPlay;
+            }
+            else {
+                return this.videoElement.paused;
+            }
+        }
+        return true;
+    };
+    /**
+     * Returns true if both:
+     *   - a content is loaded
+     *   - the content loaded is a live content
+     * @returns {Boolean} - `true` if we're playing a live content, `false` otherwise.
+     */
+    Player.prototype.isLive = function () {
+        if (this._priv_contentInfos === null) {
+            return false;
+        }
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, manifest = _a.manifest;
+        if (isDirectFile || manifest === null) {
+            return false;
+        }
+        return manifest.isLive;
+    };
+    /**
+     * Returns `true` if trickmode playback is active (usually through the usage
+     * of the `setPlaybackRate` method), which means that the RxPlayer selects
+     * "trickmode" video tracks in priority.
+     * @returns {Boolean}
+     */
+    Player.prototype.areTrickModeTracksEnabled = function () {
+        return this._priv_preferTrickModeTracks;
+    };
+    /**
+     * Returns the URL(s) of the currently considered Manifest, or of the content for
+     * directfile content.
+     * @returns {Array.<string>|undefined} - Current URL. `undefined` if not known
+     * or no URL yet.
+     */
+    Player.prototype.getContentUrls = function () {
+        if (this._priv_contentInfos === null) {
+            return undefined;
+        }
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, manifest = _a.manifest, originalUrl = _a.originalUrl;
+        if (isDirectFile) {
+            return originalUrl === undefined ? undefined : [originalUrl];
+        }
+        if (manifest !== null) {
+            return manifest.uris;
+        }
+        return undefined;
+    };
+    /**
+     * Update URL of the content currently being played (e.g. DASH's MPD).
+     * @param {Array.<string>|undefined} urls - URLs to reach that content /
+     * Manifest from the most prioritized URL to the least prioritized URL.
+     * @param {Object|undefined} [params]
+     * @param {boolean} params.refresh - If `true` the resource in question
+     * (e.g. DASH's MPD) will be refreshed immediately.
+     */
+    Player.prototype.updateContentUrls = function (urls, params) {
+        if (this._priv_contentInfos === null) {
+            throw new Error("No content loaded");
+        }
+        var refreshNow = (params === null || params === void 0 ? void 0 : params.refresh) === true;
+        this._priv_contentInfos.initializer.updateContentUrls(urls, refreshNow);
+    };
+    /**
+     * Returns the video duration, in seconds.
+     * NaN if no video is playing.
+     * @returns {Number}
+     */
+    Player.prototype.getMediaDuration = function () {
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        return this.videoElement.duration;
+    };
+    /**
+     * Returns in seconds the difference between:
+     *   - the end of the current contiguous loaded range.
+     *   - the current time
+     * @returns {Number}
+     */
+    Player.prototype.getCurrentBufferGap = function () {
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        var videoElement = this.videoElement;
+        var bufferGap = (0, ranges_1.getLeftSizeOfBufferedTimeRange)(videoElement.buffered, videoElement.currentTime);
+        if (bufferGap === Infinity) {
+            return 0;
+        }
+        return bufferGap;
+    };
+    /**
+     * Get the current position, in s, in wall-clock time.
+     * That is:
+     *   - for live content, get a timestamp, in s, of the current played content.
+     *   - for static content, returns the position from beginning in s.
+     *
+     * If you do not know if you want to use this method or getPosition:
+     *   - If what you want is to display the current time to the user, use this
+     *     one.
+     *   - If what you want is to interact with the player's API or perform other
+     *     actions (like statistics) with the real player data, use getPosition.
+     *
+     * @returns {Number}
+     */
+    Player.prototype.getWallClockTime = function () {
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        if (this._priv_contentInfos === null) {
+            return this.videoElement.currentTime;
+        }
+        var wallClockOffset = this.getWallClockOffset();
+        var currentTime = this.videoElement.currentTime;
+        return currentTime + wallClockOffset;
+    };
+    /**
+     * Get value allowing to convert the media position, as returned by
+     * `getPosition` to a "wall-clock time", as returned by `getWallClockTime`, by
+     * additioning the first two:
+     * ```js
+     * player.getPosition() + player.getWallClockOffset() === player.getWallClockTime();
+     * ```
+     *
+     * As most of the RxPlayer API relies on the media position as returned by
+     * `getPosition`, you may want to use this method to simplify conversion if
+     * what you have right now is a wall-clock time. For example:
+     *
+     * ```js
+     * const wallClockTime = player.getWallClockTime();
+     *
+     * // This one is expressed as a media position
+     * const maximumPosition = player.getMaximumPosition();
+     *
+     * // convert wall-clock time to a media position
+     * const currentPosition = wallClockTime - player.getWallClockOffset();
+     *
+     * console.log(
+     *   "delay from maximum position, in seconds",
+     *   maximumPosition - currentPosition
+     * );
+     * ```
+     *
+     * Note that there's nothing guaranteeing that this offset won't evolve over
+     * time for a given content. You should call this method every time you need
+     * to perform the conversion.
+     * @returns {number}
+     */
+    Player.prototype.getWallClockOffset = function () {
+        var _a;
+        if (this.videoElement === null) {
+            return 0;
+        }
+        if (this._priv_contentInfos === null) {
+            return 0;
+        }
+        var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, manifest = _b.manifest;
+        if (isDirectFile) {
+            var startDate = (0, get_start_date_1.default)(this.videoElement);
+            return startDate !== null && startDate !== void 0 ? startDate : 0;
+        }
+        if (manifest !== null) {
+            return (_a = manifest.availabilityStartTime) !== null && _a !== void 0 ? _a : 0;
+        }
+        return 0;
+    };
+    /**
+     * Get the current position, in seconds, of the video element.
+     *
+     * If you do not know if you want to use this method or getWallClockTime:
+     *   - If what you want is to display the current time to the user, use
+     *     getWallClockTime.
+     *   - If what you want is to interact with the player's API or perform other
+     *     actions (like statistics) with the real player data, use this one.
+     *
+     * @returns {Number}
+     */
+    Player.prototype.getPosition = function () {
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        return this.videoElement.currentTime;
+    };
+    /**
+     * Returns the last stored content position, in seconds.
+     *
+     * @returns {number|undefined}
+     */
+    Player.prototype.getLastStoredContentPosition = function () {
+        return this._priv_reloadingMetadata.reloadPosition;
+    };
+    /**
+     * Returns the current playback rate at which the video plays.
+     * @returns {Number}
+     */
+    Player.prototype.getPlaybackRate = function () {
+        return this._priv_speed.getValue();
+    };
+    /**
+     * Update the playback rate of the video.
+     *
+     * This method's effect is persisted from content to content, and can be
+     * called even when no content is playing (it will still have an effect for
+     * the next contents).
+     *
+     * If you want to reverse effects provoked by `setPlaybackRate` before playing
+     * another content, you will have to call `setPlaybackRate` first with the
+     * default settings you want to set.
+     *
+     * As an example, to reset the speed to "normal" (x1) speed and to disable
+     * trickMode video tracks (which may have been enabled by a previous
+     * `setPlaybackRate` call), you can call:
+     * ```js
+     * player.setPlaybackRate(1, { preferTrickModeTracks: false });
+     * ```
+     *
+     * --
+     *
+     * This method can be used to switch to or exit from "trickMode" video tracks,
+     * which are tracks specifically defined to mimic the visual aspect of a VCR's
+     * fast forward/rewind feature, by only displaying a few video frames during
+     * playback.
+     *
+     * This behavior is configurable through the second argument, by adding a
+     * property named `preferTrickModeTracks` to that object.
+     *
+     * You can set that value to `true` to switch to trickMode video tracks when
+     * available, and set it to `false` when you want to disable that logic.
+     * Note that like any configuration given to `setPlaybackRate`, this setting
+     * is persisted through all future contents played by the player.
+     *
+     * If you want to stop enabling trickMode tracks, you will have to call
+     * `setPlaybackRate` again with `preferTrickModeTracks` set to `false`.
+     *
+     * You can know at any moment whether this behavior is enabled by calling
+     * the `areTrickModeTracksEnabled` method. This will only means that the
+     * RxPlayer will select in priority trickmode video tracks, not that the
+     * currently chosen video tracks is a trickmode track (for example, some
+     * contents may have no trickmode tracks available).
+     *
+     * If you want to know about the latter instead, you can call `getVideoTrack`
+     * and/or listen to `videoTrackChange` events. The track returned may have an
+     * `isTrickModeTrack` property set to `true`, indicating that it is a
+     * trickmode track.
+     *
+     * Note that switching to or getting out of a trickmode video track may
+     * lead to the player being a brief instant in a `"RELOADING"` state (notified
+     * through `playerStateChange` events and the `getLoadedContentState` method).
+     * When in that state, a black screen may be displayed and multiple RxPlayer
+     * APIs will not be usable.
+     *
+     * @param {Number} rate
+     * @param {Object} opts
+     */
+    Player.prototype.setPlaybackRate = function (rate, opts) {
+        var _a;
+        if (rate !== this._priv_speed.getValue()) {
+            this._priv_speed.setValue(rate);
+        }
+        var preferTrickModeTracks = opts === null || opts === void 0 ? void 0 : opts.preferTrickModeTracks;
+        if (typeof preferTrickModeTracks !== "boolean") {
+            return;
+        }
+        this._priv_preferTrickModeTracks = preferTrickModeTracks;
+        var tracksStore = (_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.tracksStore;
+        if (!(0, is_null_or_undefined_1.default)(tracksStore)) {
+            if (preferTrickModeTracks && !tracksStore.isTrickModeEnabled()) {
+                tracksStore.enableVideoTrickModeTracks();
+            }
+            else if (!preferTrickModeTracks && tracksStore.isTrickModeEnabled()) {
+                tracksStore.disableVideoTrickModeTracks();
+            }
+        }
+    };
+    /**
+     * Returns video Representation currently considered for the current Period.
+     *
+     * Returns `null` if no video track is playing for the current Period.
+     *
+     * Returns `undefined` either when are not currently playing any Period or
+     * when we don't know which Representation is playing.
+     * @returns {Object|null|undefined}
+     */
+    Player.prototype.getVideoRepresentation = function () {
+        var representations = this.__priv_getCurrentRepresentations();
+        if (representations === null) {
+            return undefined;
+        }
+        return (0, is_null_or_undefined_1.default)(representations.video)
+            ? representations.video
+            : (0, manifest_1.toVideoRepresentation)(representations.video);
+    };
+    /**
+     * Returns audio Representation currently considered for the current Period.
+     *
+     * Returns `null` if no audio track is playing for the current Period.
+     *
+     * Returns `undefined` either when are not currently playing any Period or
+     * when we don't know which Representation is playing.
+     * @returns {Object|null|undefined}
+     */
+    Player.prototype.getAudioRepresentation = function () {
+        var representations = this.__priv_getCurrentRepresentations();
+        if (representations === null) {
+            return undefined;
+        }
+        return (0, is_null_or_undefined_1.default)(representations.audio)
+            ? representations.video
+            : (0, manifest_1.toAudioRepresentation)(representations.audio);
+    };
+    /**
+     * Play/Resume the current video.
+     * @returns {Promise}
+     */
+    Player.prototype.play = function () {
+        var _this = this;
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        var playPromise = this.videoElement.play();
+        if ((0, is_null_or_undefined_1.default)(playPromise) || typeof playPromise.catch !== "function") {
+            return Promise.resolve();
+        }
+        return playPromise.catch(function (error) {
+            if (error.name === "NotAllowedError") {
+                var warning = new errors_1.MediaError("MEDIA_ERR_PLAY_NOT_ALLOWED", error.toString());
+                _this.trigger("warning", warning);
+            }
+            throw error;
+        });
+    };
+    /**
+     * Pause the current video.
+     */
+    Player.prototype.pause = function () {
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        this.videoElement.pause();
+    };
+    /**
+     * Seek to a given absolute position.
+     * @param {Number|Object} time
+     * @returns {Number} - The time the player has seek to
+     */
+    Player.prototype.seekTo = function (time) {
+        var _a;
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        if (this._priv_contentInfos === null) {
+            throw new Error("player: no content loaded");
+        }
+        var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, manifest = _b.manifest;
+        var positionWanted;
+        if (typeof time === "number") {
+            positionWanted = time;
+        }
+        else if (typeof time === "object") {
+            var timeObj = time;
+            var currentTs = this.videoElement.currentTime;
+            if (!(0, is_null_or_undefined_1.default)(timeObj.relative)) {
+                positionWanted = currentTs + timeObj.relative;
+            }
+            else if (!(0, is_null_or_undefined_1.default)(timeObj.position)) {
+                positionWanted = timeObj.position;
+            }
+            else if (!(0, is_null_or_undefined_1.default)(timeObj.wallClockTime)) {
+                if (manifest !== null) {
+                    positionWanted = timeObj.wallClockTime - ((_a = manifest.availabilityStartTime) !== null && _a !== void 0 ? _a : 0);
+                }
+                else if (!isDirectFile) {
+                    throw new Error("Cannot seek: wallClockTime asked but Manifest not yet loaded.");
+                }
+                else if (this.videoElement !== null) {
+                    var startDate = (0, get_start_date_1.default)(this.videoElement);
+                    if (startDate !== undefined) {
+                        positionWanted = timeObj.wallClockTime - startDate;
+                    }
+                }
+                if (positionWanted === undefined) {
+                    positionWanted = timeObj.wallClockTime;
+                }
+            }
+            else {
+                throw new Error("invalid time object. You must set one of the " +
+                    'following properties: "relative", "position" or ' +
+                    '"wallClockTime"');
+            }
+        }
+        if (positionWanted === undefined) {
+            throw new Error("invalid time given");
+        }
+        log_1.default.info("API", "API seekTo", { positionWanted: positionWanted });
+        this._priv_contentInfos.playbackObserver.setCurrentTime(positionWanted, false);
+        return positionWanted;
+    };
+    /**
+     * Returns the current player's audio volume on the media element.
+     * From 0 (no audio) to 1 (maximum volume).
+     * @returns {Number}
+     */
+    Player.prototype.getVolume = function () {
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        return this.videoElement.volume;
+    };
+    /**
+     * Set the player's audio volume. From 0 (no volume) to 1 (maximum volume).
+     * @param {Number} volume
+     */
+    Player.prototype.setVolume = function (volume) {
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        var videoElement = this.videoElement;
+        if (volume !== videoElement.volume) {
+            videoElement.volume = volume;
+        }
+    };
+    /**
+     * Returns `true` if audio is currently muted.
+     * @returns {Boolean}
+     */
+    Player.prototype.isMute = function () {
+        var _a;
+        return ((_a = this.videoElement) === null || _a === void 0 ? void 0 : _a.muted) === true;
+    };
+    /**
+     * Mute audio.
+     */
+    Player.prototype.mute = function () {
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        if (!this.videoElement.muted) {
+            this.videoElement.muted = true;
+        }
+    };
+    /**
+     * Unmute audio.
+     */
+    Player.prototype.unMute = function () {
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        if (this.videoElement.muted) {
+            this.videoElement.muted = false;
+        }
+    };
+    /**
+     * Set the max buffer size for the buffer behind the current position.
+     * Every buffer data before will be removed.
+     * @param {Number} depthInSeconds
+     */
+    Player.prototype.setMaxBufferBehind = function (depthInSeconds) {
+        this._priv_bufferOptions.maxBufferBehind.setValue(depthInSeconds);
+    };
+    /**
+     * Set the max buffer size for the buffer behind the current position.
+     * Every buffer data before will be removed.
+     * @param {Number} depthInSeconds
+     */
+    Player.prototype.setMaxBufferAhead = function (depthInSeconds) {
+        this._priv_bufferOptions.maxBufferAhead.setValue(depthInSeconds);
+    };
+    /**
+     * Set the max buffer size for the buffer ahead of the current position.
+     * The player will stop downloading chunks when this size is reached.
+     * @param {Number} sizeInSeconds
+     */
+    Player.prototype.setWantedBufferAhead = function (sizeInSeconds) {
+        this._priv_bufferOptions.wantedBufferAhead.setValue(sizeInSeconds);
+    };
+    /**
+     * Set the max buffer size the buffer should take in memory
+     * The player . will stop downloading chunks when this size is reached.
+     * @param {Number} sizeInKBytes
+     */
+    Player.prototype.setMaxVideoBufferSize = function (sizeInKBytes) {
+        this._priv_bufferOptions.maxVideoBufferSize.setValue(sizeInKBytes);
+    };
+    /**
+     * Returns the max buffer size for the buffer behind the current position.
+     * @returns {Number}
+     */
+    Player.prototype.getMaxBufferBehind = function () {
+        return this._priv_bufferOptions.maxBufferBehind.getValue();
+    };
+    /**
+     * Returns the max buffer size for the buffer behind the current position.
+     * @returns {Number}
+     */
+    Player.prototype.getMaxBufferAhead = function () {
+        return this._priv_bufferOptions.maxBufferAhead.getValue();
+    };
+    /**
+     * Returns the max buffer size for the buffer ahead of the current position.
+     * @returns {Number}
+     */
+    Player.prototype.getWantedBufferAhead = function () {
+        return this._priv_bufferOptions.wantedBufferAhead.getValue();
+    };
+    /**
+     * Returns the max buffer memory size for the buffer in kilobytes
+     * @returns {Number}
+     */
+    Player.prototype.getMaxVideoBufferSize = function () {
+        return this._priv_bufferOptions.maxVideoBufferSize.getValue();
+    };
+    Player.prototype.getCurrentPeriod = function () {
+        var _a;
+        var currentPeriod = (_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.currentPeriod;
+        if ((0, is_null_or_undefined_1.default)(currentPeriod)) {
+            return null;
+        }
+        return {
+            id: currentPeriod.id,
+            start: currentPeriod.start,
+            end: currentPeriod.end,
+        };
+    };
+    /**
+     * Returns both the name of the key system (e.g. `"com.widevine.alpha"`) and
+     * the `MediaKeySystemConfiguration` currently associated to the
+     * HTMLMediaElement linked to the RxPlayer.
+     *
+     * Returns `null` if no such capabilities is associated or if unknown.
+     * @returns {Object|null}
+     */
+    Player.prototype.getKeySystemConfiguration = function () {
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        var values = (0, decrypt_1.getKeySystemConfiguration)(this.videoElement);
+        if (values === null) {
+            return null;
+        }
+        return { keySystem: values[0], configuration: values[1] };
+    };
+    /**
+     * Returns the list of available Periods for which the current audio, video or
+     * text track can now be changed.
+     * @returns {Array.<Object>}
+     */
+    Player.prototype.getAvailablePeriods = function () {
+        if (this._priv_contentInfos === null) {
+            return [];
+        }
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, tracksStore = _a.tracksStore;
+        if (isDirectFile) {
+            return [];
+        }
+        if (tracksStore === null) {
+            return [];
+        }
+        return tracksStore.getAvailablePeriods().slice();
+    };
+    /**
+     * Returns every available audio tracks for a given Period - or the current
+     * one if no `periodId` is given.
+     * @param {string|Object|undefined} [arg]
+     * @returns {Array.<Object>}
+     */
+    Player.prototype.getAvailableAudioTracks = function (arg) {
+        var _a, _b;
+        if (this._priv_contentInfos === null) {
+            return [];
+        }
+        var _c = this._priv_contentInfos, isDirectFile = _c.isDirectFile, mediaElementTracksStore = _c.mediaElementTracksStore;
+        if (isDirectFile) {
+            return (_a = mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.getAvailableAudioTracks()) !== null && _a !== void 0 ? _a : [];
+        }
+        var periodId;
+        var filterPlayableRepresentations = true;
+        if (typeof arg === "string") {
+            periodId = arg;
+        }
+        else {
+            periodId = arg === null || arg === void 0 ? void 0 : arg.periodId;
+            filterPlayableRepresentations = (_b = arg === null || arg === void 0 ? void 0 : arg.filterPlayableRepresentations) !== null && _b !== void 0 ? _b : true;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, [], function (tcm, periodRef) { var _a; return (_a = tcm.getAvailableAudioTracks(periodRef, filterPlayableRepresentations)) !== null && _a !== void 0 ? _a : []; });
+    };
+    /**
+     * Returns every available text tracks for a given Period - or the current
+     * one if no `periodId` is given.
+     * @param {string|undefined} [periodId]
+     * @returns {Array.<Object>}
+     */
+    Player.prototype.getAvailableTextTracks = function (periodId) {
+        var _a;
+        if (this._priv_contentInfos === null) {
+            return [];
+        }
+        var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, mediaElementTracksStore = _b.mediaElementTracksStore;
+        if (isDirectFile) {
+            return (_a = mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.getAvailableTextTracks()) !== null && _a !== void 0 ? _a : [];
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, [], function (tcm, periodRef) { var _a; return (_a = tcm.getAvailableTextTracks(periodRef)) !== null && _a !== void 0 ? _a : []; });
+    };
+    /**
+     * Returns every available video tracks for the current Period.
+     * @param {string|Object|undefined} [arg]
+     * @returns {Array.<Object>}
+     */
+    Player.prototype.getAvailableVideoTracks = function (arg) {
+        var _a, _b;
+        if (this._priv_contentInfos === null) {
+            return [];
+        }
+        var _c = this._priv_contentInfos, isDirectFile = _c.isDirectFile, mediaElementTracksStore = _c.mediaElementTracksStore;
+        if (isDirectFile) {
+            return (_a = mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.getAvailableVideoTracks()) !== null && _a !== void 0 ? _a : [];
+        }
+        var periodId;
+        var filterPlayableRepresentations = true;
+        if (typeof arg === "string") {
+            periodId = arg;
+        }
+        else {
+            periodId = arg === null || arg === void 0 ? void 0 : arg.periodId;
+            filterPlayableRepresentations = (_b = arg === null || arg === void 0 ? void 0 : arg.filterPlayableRepresentations) !== null && _b !== void 0 ? _b : true;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, [], function (tcm, periodRef) { var _a; return (_a = tcm.getAvailableVideoTracks(periodRef, filterPlayableRepresentations)) !== null && _a !== void 0 ? _a : []; });
+    };
+    /**
+     * Returns currently chosen audio language for the current Period.
+     * @param {string|Object|undefined} [arg]
+     * @returns {Object|null|undefined}
+     */
+    Player.prototype.getAudioTrack = function (arg) {
+        var _a;
+        if (this._priv_contentInfos === null) {
+            return undefined;
+        }
+        var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, mediaElementTracksStore = _b.mediaElementTracksStore;
+        if (isDirectFile) {
+            if (mediaElementTracksStore === null) {
+                return undefined;
+            }
+            return mediaElementTracksStore.getChosenAudioTrack();
+        }
+        var periodId;
+        var filterPlayableRepresentations = true;
+        if (typeof arg === "string") {
+            periodId = arg;
+        }
+        else {
+            periodId = arg === null || arg === void 0 ? void 0 : arg.periodId;
+            filterPlayableRepresentations = (_a = arg === null || arg === void 0 ? void 0 : arg.filterPlayableRepresentations) !== null && _a !== void 0 ? _a : true;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.getChosenAudioTrack(periodRef, filterPlayableRepresentations);
+        });
+    };
+    /**
+     * Returns currently chosen subtitle for the current Period.
+     * @param {string|undefined} [periodId]
+     * @returns {Object|null|undefined}
+     */
+    Player.prototype.getTextTrack = function (periodId) {
+        if (this._priv_contentInfos === null) {
+            return undefined;
+        }
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, mediaElementTracksStore = _a.mediaElementTracksStore;
+        if (isDirectFile) {
+            if (mediaElementTracksStore === null) {
+                return undefined;
+            }
+            return mediaElementTracksStore.getChosenTextTrack();
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.getChosenTextTrack(periodRef);
+        });
+    };
+    /**
+     * Returns currently chosen video track for the current Period.
+     * @param {string|Object|undefined} [arg]
+     * @returns {Object|null|undefined}
+     */
+    Player.prototype.getVideoTrack = function (arg) {
+        var _a;
+        if (this._priv_contentInfos === null) {
+            return undefined;
+        }
+        var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, mediaElementTracksStore = _b.mediaElementTracksStore;
+        if (isDirectFile) {
+            if (mediaElementTracksStore === null) {
+                return undefined;
+            }
+            return mediaElementTracksStore.getChosenVideoTrack();
+        }
+        var periodId;
+        var filterPlayableRepresentations = true;
+        if (typeof arg === "string") {
+            periodId = arg;
+        }
+        else {
+            periodId = arg === null || arg === void 0 ? void 0 : arg.periodId;
+            filterPlayableRepresentations = (_a = arg === null || arg === void 0 ? void 0 : arg.filterPlayableRepresentations) !== null && _a !== void 0 ? _a : true;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.getChosenVideoTrack(periodRef, filterPlayableRepresentations);
+        });
+    };
+    /**
+     * Update the audio language for the current Period.
+     * @param {string | object} arg
+     * @throws Error - the current content has no TracksStore.
+     * @throws Error - the given id is linked to no audio track.
+     */
+    Player.prototype.setAudioTrack = function (arg) {
+        var _a;
+        if (this._priv_contentInfos === null) {
+            throw new Error("No content loaded");
+        }
+        var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, mediaElementTracksStore = _b.mediaElementTracksStore;
+        if (isDirectFile) {
+            try {
+                var audioId = typeof arg === "string" ? arg : arg.trackId;
+                mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.setAudioTrackById(audioId);
+                return;
+            }
+            catch (_e) {
+                throw new Error("player: unknown audio track");
+            }
+        }
+        var periodId;
+        var trackId;
+        var switchingMode;
+        var lockedRepresentations = null;
+        var relativeResumingPosition;
+        if (typeof arg === "string") {
+            trackId = arg;
+        }
+        else {
+            trackId = arg.trackId;
+            periodId = arg.periodId;
+            switchingMode = arg.switchingMode;
+            lockedRepresentations = (_a = arg.lockedRepresentations) !== null && _a !== void 0 ? _a : null;
+            relativeResumingPosition = arg.relativeResumingPosition;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.setAudioTrack({
+                periodRef: periodRef,
+                trackId: trackId,
+                switchingMode: switchingMode,
+                lockedRepresentations: lockedRepresentations,
+                relativeResumingPosition: relativeResumingPosition,
+            });
+        });
+    };
+    /**
+     * Update the text language for the current Period.
+     * @param {string | Object} arg
+     * @throws Error - the current content has no TracksStore.
+     * @throws Error - the given id is linked to no text track.
+     */
+    Player.prototype.setTextTrack = function (arg) {
+        if (this._priv_contentInfos === null) {
+            throw new Error("No content loaded");
+        }
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, mediaElementTracksStore = _a.mediaElementTracksStore;
+        if (isDirectFile) {
+            try {
+                var textId = typeof arg === "string" ? arg : arg.trackId;
+                mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.setTextTrackById(textId);
+                return;
+            }
+            catch (_e) {
+                throw new Error("player: unknown text track");
+            }
+        }
+        var periodId;
+        var trackId;
+        if (typeof arg === "string") {
+            trackId = arg;
+        }
+        else {
+            trackId = arg.trackId;
+            periodId = arg.periodId;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.setTextTrack(periodRef, trackId);
+        });
+    };
+    /**
+     * Disable subtitles for the current content.
+     * @param {string|undefined} [periodId]
+     */
+    Player.prototype.disableTextTrack = function (periodId) {
+        if (this._priv_contentInfos === null) {
+            return;
+        }
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, mediaElementTracksStore = _a.mediaElementTracksStore;
+        if (isDirectFile) {
+            mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.disableTextTrack();
+            return;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.disableTrack(periodRef, "text");
+        });
+    };
+    /**
+     * Update the video track for the current Period.
+     * @param {string | Object} arg
+     * @throws Error - the current content has no TracksStore.
+     * @throws Error - the given id is linked to no video track.
+     */
+    Player.prototype.setVideoTrack = function (arg) {
+        var _a;
+        if (this._priv_contentInfos === null) {
+            throw new Error("No content loaded");
+        }
+        var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, mediaElementTracksStore = _b.mediaElementTracksStore;
+        if (isDirectFile) {
+            try {
+                var videoId = typeof arg === "string" ? arg : arg.trackId;
+                mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.setVideoTrackById(videoId);
+                return;
+            }
+            catch (_e) {
+                throw new Error("player: unknown video track");
+            }
+        }
+        var periodId;
+        var trackId;
+        var switchingMode;
+        var lockedRepresentations = null;
+        var relativeResumingPosition;
+        if (typeof arg === "string") {
+            trackId = arg;
+        }
+        else {
+            trackId = arg.trackId;
+            periodId = arg.periodId;
+            switchingMode = arg.switchingMode;
+            lockedRepresentations = (_a = arg.lockedRepresentations) !== null && _a !== void 0 ? _a : null;
+            relativeResumingPosition = arg.relativeResumingPosition;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.setVideoTrack({
+                periodRef: periodRef,
+                trackId: trackId,
+                switchingMode: switchingMode,
+                lockedRepresentations: lockedRepresentations,
+                relativeResumingPosition: relativeResumingPosition,
+            });
+        });
+    };
+    /**
+     * Disable video track for the current content.
+     * @param {string|undefined} [periodId]
+     */
+    Player.prototype.disableVideoTrack = function (periodId) {
+        if (this._priv_contentInfos === null) {
+            return;
+        }
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, mediaElementTracksStore = _a.mediaElementTracksStore;
+        if (isDirectFile && mediaElementTracksStore !== null) {
+            return mediaElementTracksStore.disableVideoTrack();
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.disableTrack(periodRef, "video");
+        });
+    };
+    Player.prototype.lockVideoRepresentations = function (arg) {
+        if (this._priv_contentInfos === null) {
+            throw new Error("No content loaded");
+        }
+        var isDirectFile = this._priv_contentInfos.isDirectFile;
+        if (isDirectFile) {
+            throw new Error("Cannot lock video Representations in directfile mode.");
+        }
+        var repsId;
+        var periodId;
+        var switchingMode;
+        if (Array.isArray(arg)) {
+            repsId = arg;
+            periodId = undefined;
+        }
+        else {
+            repsId = arg.representations;
+            periodId = arg.periodId;
+            switchingMode = arg.switchingMode;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.lockVideoRepresentations(periodRef, {
+                representations: repsId,
+                switchingMode: switchingMode,
+            });
+        });
+    };
+    /**
+     * Disable audio track for the current content.
+     * @param {string|undefined} [periodId]
+     */
+    Player.prototype.disableAudioTrack = function (periodId) {
+        if (this._priv_contentInfos === null) {
+            return;
+        }
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, mediaElementTracksStore = _a.mediaElementTracksStore;
+        if (isDirectFile && mediaElementTracksStore !== null) {
+            return mediaElementTracksStore.disableAudioTrack();
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.disableTrack(periodRef, "audio");
+        });
+    };
+    Player.prototype.lockAudioRepresentations = function (arg) {
+        if (this._priv_contentInfos === null) {
+            throw new Error("No content loaded");
+        }
+        var isDirectFile = this._priv_contentInfos.isDirectFile;
+        if (isDirectFile) {
+            throw new Error("Cannot lock audio Representations in directfile mode.");
+        }
+        var repsId;
+        var periodId;
+        var switchingMode;
+        if (Array.isArray(arg)) {
+            repsId = arg;
+            periodId = undefined;
+        }
+        else {
+            repsId = arg.representations;
+            periodId = arg.periodId;
+            switchingMode = arg.switchingMode;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.lockAudioRepresentations(periodRef, {
+                representations: repsId,
+                switchingMode: switchingMode,
+            });
+        });
+    };
+    Player.prototype.getLockedVideoRepresentations = function (periodId) {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        var isDirectFile = this._priv_contentInfos.isDirectFile;
+        if (isDirectFile) {
+            return null;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, null, function (tcm, periodRef) {
+            return tcm.getLockedVideoRepresentations(periodRef);
+        });
+    };
+    Player.prototype.getLockedAudioRepresentations = function (periodId) {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        var isDirectFile = this._priv_contentInfos.isDirectFile;
+        if (isDirectFile) {
+            return null;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, null, function (tcm, periodRef) {
+            return tcm.getLockedAudioRepresentations(periodRef);
+        });
+    };
+    Player.prototype.unlockVideoRepresentations = function (periodId) {
+        if (this._priv_contentInfos === null) {
+            return;
+        }
+        var isDirectFile = this._priv_contentInfos.isDirectFile;
+        if (isDirectFile) {
+            return;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.unlockVideoRepresentations(periodRef);
+        });
+    };
+    Player.prototype.unlockAudioRepresentations = function (periodId) {
+        if (this._priv_contentInfos === null) {
+            return;
+        }
+        var isDirectFile = this._priv_contentInfos.isDirectFile;
+        if (isDirectFile) {
+            return;
+        }
+        return this._priv_callTracksStoreGetterSetter(periodId, undefined, function (tcm, periodRef) {
+            return tcm.unlockAudioRepresentations(periodRef);
+        });
+    };
+    /**
+     * Get minimum seek-able position.
+     * @returns {number}
+     */
+    Player.prototype.getMinimumPosition = function () {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        if (this._priv_contentInfos.isDirectFile) {
+            return 0;
+        }
+        var manifest = this._priv_contentInfos.manifest;
+        if (manifest !== null) {
+            return (0, manifest_1.getMinimumSafePosition)(manifest);
+        }
+        return null;
+    };
+    /**
+     * Returns the current position for live contents.
+     *
+     * Returns `null` if no content is loaded or if the current loaded content is
+     * not considered as a live content.
+     * Returns `undefined` if that live position is currently unknown.
+     * @returns {number}
+     */
+    Player.prototype.getLivePosition = function () {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, manifest = _a.manifest;
+        if (isDirectFile) {
+            return undefined;
+        }
+        if ((manifest === null || manifest === void 0 ? void 0 : manifest.isLive) !== true) {
+            return null;
+        }
+        return (0, manifest_1.getLivePosition)(manifest);
+    };
+    /**
+     * Get maximum seek-able position.
+     * @returns {number}
+     */
+    Player.prototype.getMaximumPosition = function () {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, manifest = _a.manifest;
+        if (isDirectFile) {
+            if (this.videoElement === null) {
+                throw new Error("Disposed player");
+            }
+            return this.videoElement.duration;
+        }
+        if (manifest !== null) {
+            if (!manifest.isDynamic && this.videoElement !== null) {
+                return this.videoElement.duration;
+            }
+            return (0, manifest_1.getMaximumSafePosition)(manifest);
+        }
+        return null;
+    };
+    // ---- Undocumented Private methods. ----
+    //
+    // Those methods are just here either to allow some tools relying on the
+    // RxPlayer instance to work or to improve the RxPlayer's demo.
+    //
+    // They should not be used by any external code.
+    /**
+     * Used for the display of segmentSink metrics for the debug element
+     * @param fn
+     * @param cancellationSignal
+     * @returns
+     */
+    Player.prototype.__priv_getSegmentSinkMetrics = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return __generator(this, function (_c) {
+                return [2 /*return*/, (_b = (_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.segmentSinkMetricsCallback) === null || _b === void 0 ? void 0 : _b.call(_a)];
+            });
+        });
+    };
+    /**
+     * /!\ For tools use only! Do not touch!
+     *
+     * Returns manifest/playlist object.
+     * null if the player is STOPPED.
+     * @returns {Manifest|null} - The current Manifest (`null` when not known).
+     */
+    // TODO remove the need for that public method
+    Player.prototype.__priv_getManifest = function () {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        return this._priv_contentInfos.manifest;
+    };
+    // TODO remove the need for that public method
+    Player.prototype.__priv_getCurrentAdaptation = function () {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, activeAdaptations = _a.activeAdaptations;
+        if (currentPeriod === null ||
+            activeAdaptations === null ||
+            (0, is_null_or_undefined_1.default)(activeAdaptations[currentPeriod.id])) {
+            return null;
+        }
+        return activeAdaptations[currentPeriod.id];
+    };
+    // TODO remove the need for that public method
+    Player.prototype.__priv_getCurrentRepresentations = function () {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, activeRepresentations = _a.activeRepresentations;
+        if (currentPeriod === null ||
+            activeRepresentations === null ||
+            (0, is_null_or_undefined_1.default)(activeRepresentations[currentPeriod.id])) {
+            return null;
+        }
+        return activeRepresentations[currentPeriod.id];
+    };
+    // ---- Private methods ----
+    /**
+     * Reset all state properties relative to a playing content.
+     */
+    Player.prototype._priv_cleanUpCurrentContentState = function () {
+        var _this = this;
+        var _a, _b, _c, _d;
+        log_1.default.debug("API", "Locking `contentLock` to clean-up the current content.");
+        // lock playback of new contents while cleaning up is pending
+        this._priv_contentLock.setValue(true);
+        (_b = (_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.tracksStore) === null || _b === void 0 ? void 0 : _b.dispose();
+        (_d = (_c = this._priv_contentInfos) === null || _c === void 0 ? void 0 : _c.mediaElementTracksStore) === null || _d === void 0 ? void 0 : _d.dispose();
+        this._priv_contentInfos = null;
+        this._priv_contentEventsMemory = {};
+        // DRM-related clean-up
+        var freeUpContentLock = function () {
+            if (_this.videoElement !== null) {
+                // If not disposed
+                log_1.default.debug("API", "Unlocking `contentLock`. Next content can begin.");
+                _this._priv_contentLock.setValue(false);
+            }
+        };
+        if (!(0, is_null_or_undefined_1.default)(this.videoElement)) {
+            (0, decrypt_1.clearOnStop)(this.videoElement).then(function () {
+                log_1.default.debug("API", "DRM session cleaned-up with success!");
+                freeUpContentLock();
+            }, function (err) {
+                log_1.default.error("API", "An error arised when trying to clean-up the DRM session:" +
+                    (err instanceof Error ? err.toString() : "Unknown Error"));
+                freeUpContentLock();
+            });
+        }
+        else {
+            freeUpContentLock();
+        }
+    };
+    /**
+     * Triggered when the Manifest has been loaded for the current content.
+     * Initialize various private properties and emit initial event.
+     * @param {Object} contentInfos
+     * @param {Object} manifest
+     */
+    Player.prototype._priv_onManifestReady = function (contentInfos, manifest) {
+        var _this = this;
+        var _a;
+        if (contentInfos.contentId !== ((_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.contentId)) {
+            return; // Event for another content
+        }
+        contentInfos.manifest = manifest;
+        if (manifest.manifestFormat === 0 /* ManifestMetadataFormat.Class */) {
+            this._priv_reloadingMetadata.manifest = manifest;
+        }
+        var tracksStore = new tracks_store_1.default({
+            preferTrickModeTracks: this._priv_preferTrickModeTracks,
+            defaultAudioTrackSwitchingMode: contentInfos.defaultAudioTrackSwitchingMode,
+            onTracksNotPlayableForType: {
+                audio: contentInfos.onAudioTracksNotPlayable,
+                video: contentInfos.onVideoTracksNotPlayable,
+                text: "continue",
+            },
+        });
+        contentInfos.tracksStore = tracksStore;
+        tracksStore.addEventListener("newAvailablePeriods", function (p) {
+            _this.trigger("newAvailablePeriods", p);
+        });
+        tracksStore.addEventListener("brokenRepresentationsLock", function (e) {
+            _this.trigger("brokenRepresentationsLock", e);
+        });
+        tracksStore.addEventListener("trackUpdate", function (e) {
+            var _a, _b;
+            _this.trigger("trackUpdate", e);
+            var currentPeriod = (_b = (_a = _this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.currentPeriod) !== null && _b !== void 0 ? _b : undefined;
+            if (e.reason === "no-playable-representation" &&
+                e.period.id === (currentPeriod === null || currentPeriod === void 0 ? void 0 : currentPeriod.id)) {
+                _this._priv_onAvailableTracksMayHaveChanged(e.trackType);
+            }
+        });
+        tracksStore.addEventListener("warning", function (err) {
+            _this.trigger("warning", err);
+        });
+        tracksStore.addEventListener("error", function (err) {
+            _this._priv_onFatalError(err, contentInfos);
+        });
+        tracksStore.addEventListener("noPlayableTrack", function (noPlayableTrackEvent) {
+            _this.trigger("noPlayableTrack", noPlayableTrackEvent);
+        });
+        tracksStore.onManifestUpdate(manifest);
+    };
+    /**
+     * Triggered when the Manifest has been updated for the current content.
+     * Initialize various private properties and emit initial event.
+     * @param {Object} contentInfos
+     * @param {Object} updates
+     */
+    Player.prototype._priv_onManifestUpdate = function (contentInfos, updates) {
+        var e_2, _a;
+        var _b, _c, _d;
+        if (this._priv_contentInfos === null || this._priv_contentInfos.manifest === null) {
+            return;
+        }
+        // Update the tracks chosen if it changed
+        if (!(0, is_null_or_undefined_1.default)(contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.tracksStore)) {
+            contentInfos.tracksStore.onManifestUpdate(this._priv_contentInfos.manifest);
+        }
+        var currentPeriod = (_c = (_b = this._priv_contentInfos) === null || _b === void 0 ? void 0 : _b.currentPeriod) !== null && _c !== void 0 ? _c : undefined;
+        var currTracksStore = (_d = this._priv_contentInfos) === null || _d === void 0 ? void 0 : _d.tracksStore;
+        if (currentPeriod === undefined || (0, is_null_or_undefined_1.default)(currTracksStore)) {
+            return;
+        }
+        try {
+            for (var _f = __values(updates.updatedPeriods), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var update = _g.value;
+                if (update.period.id === currentPeriod.id) {
+                    if (update.result.addedAdaptations.length > 0 ||
+                        update.result.removedAdaptations.length > 0) {
+                        // We might have new (or less) tracks, send events just to be sure
+                        var periodRef = currTracksStore.getPeriodObjectFromPeriod(currentPeriod);
+                        if (periodRef === undefined) {
+                            return;
+                        }
+                        this._priv_onAvailableTracksMayHaveChanged("audio");
+                        this._priv_onAvailableTracksMayHaveChanged("text");
+                        this._priv_onAvailableTracksMayHaveChanged("video");
+                    }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    /**
+     * Triggered each times the support for a codec has changed in the manifest.
+     * When triggered, the track store may need to consider selecting a new track.
+     *
+     * @param {Object} contentInfos
+     */
+    Player.prototype._priv_onCodecSupportUpdate = function (contentInfos) {
+        var tStore = contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.tracksStore;
+        if ((0, is_null_or_undefined_1.default)(tStore)) {
+            return;
+        }
+        tStore.onManifestCodecSupportUpdate();
+    };
+    Player.prototype._priv_onDecipherabilityUpdate = function (contentInfos, elts) {
+        var e_3, _a;
+        if (contentInfos === null || contentInfos.manifest === null) {
+            return;
+        }
+        if (!(0, is_null_or_undefined_1.default)(contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.tracksStore)) {
+            contentInfos.tracksStore.onDecipherabilityUpdates();
+        }
+        /**
+         * Array of tuples only including once the Period/Track combination, and
+         * only when it concerns the currently-selected track.
+         */
+        var periodsAndTrackTypes = elts.reduce(function (acc, elt) {
+            var _a, _b, _c;
+            var isFound = (0, array_find_1.default)(acc, function (x) { return x[0].id === elt.period.id && x[1] === elt.adaptation.type; }) !== undefined;
+            if (!isFound) {
+                // Only consider the currently-selected tracks.
+                // NOTE: Maybe there's room for optimizations? Unclear.
+                var tStore = contentInfos.tracksStore;
+                if (tStore === null) {
+                    return acc;
+                }
+                var isCurrent = false;
+                var periodRef = tStore.getPeriodObjectFromPeriod(elt.period);
+                if (periodRef === undefined) {
+                    return acc;
+                }
+                switch (elt.adaptation.type) {
+                    case "audio":
+                        isCurrent =
+                            ((_a = tStore.getChosenAudioTrack(periodRef, false)) === null || _a === void 0 ? void 0 : _a.id) === elt.adaptation.id;
+                        break;
+                    case "video":
+                        isCurrent =
+                            ((_b = tStore.getChosenVideoTrack(periodRef, false)) === null || _b === void 0 ? void 0 : _b.id) === elt.adaptation.id;
+                        break;
+                    case "text":
+                        isCurrent = ((_c = tStore.getChosenTextTrack(periodRef)) === null || _c === void 0 ? void 0 : _c.id) === elt.adaptation.id;
+                        break;
+                }
+                if (isCurrent) {
+                    acc.push([elt.period, elt.adaptation.type]);
+                }
+            }
+            return acc;
+        }, []);
+        try {
+            for (var periodsAndTrackTypes_1 = __values(periodsAndTrackTypes), periodsAndTrackTypes_1_1 = periodsAndTrackTypes_1.next(); !periodsAndTrackTypes_1_1.done; periodsAndTrackTypes_1_1 = periodsAndTrackTypes_1.next()) {
+                var _b = __read(periodsAndTrackTypes_1_1.value, 2), period = _b[0], trackType = _b[1];
+                this._priv_triggerEventIfNotStopped("representationListUpdate", {
+                    period: { start: period.start, end: period.end, id: period.id },
+                    trackType: trackType,
+                    reason: "decipherability-update",
+                }, contentInfos.currentContentCanceller.signal);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (periodsAndTrackTypes_1_1 && !periodsAndTrackTypes_1_1.done && (_a = periodsAndTrackTypes_1.return)) _a.call(periodsAndTrackTypes_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+    };
+    /**
+     * Triggered each times the current Period Changed.
+     * Store and emit initial state for the Period.
+     *
+     * @param {Object} contentInfos
+     * @param {Object} periodInfo
+     */
+    Player.prototype._priv_onActivePeriodChanged = function (contentInfos, _a) {
+        var _b, _c, _d, _f, _g, _h;
+        var period = _a.period;
+        if (contentInfos.contentId !== ((_b = this._priv_contentInfos) === null || _b === void 0 ? void 0 : _b.contentId)) {
+            return; // Event for another content
+        }
+        contentInfos.currentPeriod = period;
+        var cancelSignal = contentInfos.currentContentCanceller.signal;
+        if (this._priv_contentEventsMemory.periodChange !== period) {
+            this._priv_contentEventsMemory.periodChange = period;
+            this._priv_triggerEventIfNotStopped("periodChange", { start: period.start, end: period.end, id: period.id }, cancelSignal);
+        }
+        this._priv_triggerEventIfNotStopped("availableAudioTracksChange", this.getAvailableAudioTracks(), cancelSignal);
+        this._priv_triggerEventIfNotStopped("availableTextTracksChange", this.getAvailableTextTracks(), cancelSignal);
+        this._priv_triggerEventIfNotStopped("availableVideoTracksChange", this.getAvailableVideoTracks(), cancelSignal);
+        var tracksStore = (_c = this._priv_contentInfos) === null || _c === void 0 ? void 0 : _c.tracksStore;
+        // Emit initial events for the Period
+        if (!(0, is_null_or_undefined_1.default)(tracksStore)) {
+            var periodRef = tracksStore.getPeriodObjectFromPeriod(period);
+            if (periodRef !== undefined) {
+                var audioTrack = tracksStore.getChosenAudioTrack(periodRef, true);
+                this._priv_triggerEventIfNotStopped("audioTrackChange", audioTrack, cancelSignal);
+                var textTrack = tracksStore.getChosenTextTrack(periodRef);
+                this._priv_triggerEventIfNotStopped("textTrackChange", textTrack, cancelSignal);
+                var videoTrack = tracksStore.getChosenVideoTrack(periodRef, true);
+                this._priv_triggerEventIfNotStopped("videoTrackChange", videoTrack, cancelSignal);
+            }
+        }
+        else {
+            this._priv_triggerEventIfNotStopped("audioTrackChange", null, cancelSignal);
+            this._priv_triggerEventIfNotStopped("textTrackChange", null, cancelSignal);
+            this._priv_triggerEventIfNotStopped("videoTrackChange", null, cancelSignal);
+        }
+        var audioRepresentation = (_f = (_d = this.__priv_getCurrentRepresentations()) === null || _d === void 0 ? void 0 : _d.audio) !== null && _f !== void 0 ? _f : null;
+        this._priv_triggerEventIfNotStopped("audioRepresentationChange", (0, is_null_or_undefined_1.default)(audioRepresentation)
+            ? audioRepresentation
+            : (0, manifest_1.toVideoRepresentation)(audioRepresentation), cancelSignal);
+        var videoRepresentation = (_h = (_g = this.__priv_getCurrentRepresentations()) === null || _g === void 0 ? void 0 : _g.video) !== null && _h !== void 0 ? _h : null;
+        this._priv_triggerEventIfNotStopped("videoRepresentationChange", (0, is_null_or_undefined_1.default)(videoRepresentation)
+            ? videoRepresentation
+            : (0, manifest_1.toVideoRepresentation)(videoRepresentation), cancelSignal);
+    };
+    /**
+     * Triggered each times a new "PeriodStream" is ready.
+     * Choose the right Adaptation for the Period and emit it.
+     * @param {Object} contentInfos
+     * @param {Object} value
+     */
+    Player.prototype._priv_onPeriodStreamReady = function (contentInfos, value) {
+        var _a;
+        if (contentInfos.contentId !== ((_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.contentId)) {
+            return; // Event for another content
+        }
+        var type = value.type, period = value.period, adaptationRef = value.adaptationRef;
+        var tracksStore = contentInfos.tracksStore;
+        switch (type) {
+            case "video":
+            case "audio":
+            case "text":
+                if ((0, is_null_or_undefined_1.default)(tracksStore)) {
+                    log_1.default.error("API", "TracksStore not instanciated for a new ".concat(type, " period"));
+                    adaptationRef.setValue(null);
+                }
+                else {
+                    tracksStore.addTrackReference(type, period, adaptationRef);
+                }
+                break;
+            default:
+                (0, assert_1.assertUnreachable)(type);
+        }
+    };
+    /**
+     * Triggered each times we "remove" a PeriodStream.
+     * @param {Object} contentInfos
+     * @param {Object} value
+     */
+    Player.prototype._priv_onPeriodStreamCleared = function (contentInfos, value) {
+        var _a;
+        if (contentInfos.contentId !== ((_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.contentId)) {
+            return; // Event for another content
+        }
+        var type = value.type, periodId = value.periodId;
+        var tracksStore = contentInfos.tracksStore;
+        // Clean-up track choices from TracksStore
+        switch (type) {
+            case "audio":
+            case "text":
+            case "video":
+                if (!(0, is_null_or_undefined_1.default)(tracksStore)) {
+                    tracksStore.removeTrackReference(type, periodId);
+                }
+                break;
+        }
+        // Clean-up stored Representation and Adaptation information
+        var activeAdaptations = contentInfos.activeAdaptations, activeRepresentations = contentInfos.activeRepresentations;
+        if (!(0, is_null_or_undefined_1.default)(activeAdaptations) &&
+            !(0, is_null_or_undefined_1.default)(activeAdaptations[periodId])) {
+            var activePeriodAdaptations = activeAdaptations[periodId];
+            delete activePeriodAdaptations[type];
+            if (Object.keys(activePeriodAdaptations).length === 0) {
+                delete activeAdaptations[periodId];
+            }
+        }
+        if (!(0, is_null_or_undefined_1.default)(activeRepresentations) &&
+            !(0, is_null_or_undefined_1.default)(activeRepresentations[periodId])) {
+            var activePeriodRepresentations = activeRepresentations[periodId];
+            delete activePeriodRepresentations[type];
+            if (Object.keys(activePeriodRepresentations).length === 0) {
+                delete activeRepresentations[periodId];
+            }
+        }
+    };
+    /**
+     * Triggered each times a new Adaptation is considered for the current
+     * content.
+     * Store given Adaptation and emit it if from the current Period.
+     * @param {Object} contentInfos
+     * @param {Object} value
+     */
+    Player.prototype._priv_onAdaptationChange = function (contentInfos, _a) {
+        var _b;
+        var _c;
+        var type = _a.type, adaptation = _a.adaptation, period = _a.period;
+        if (contentInfos.contentId !== ((_c = this._priv_contentInfos) === null || _c === void 0 ? void 0 : _c.contentId)) {
+            return; // Event for another content
+        }
+        // lazily create contentInfos.activeAdaptations
+        if (contentInfos.activeAdaptations === null) {
+            contentInfos.activeAdaptations = {};
+        }
+        var activeAdaptations = contentInfos.activeAdaptations, currentPeriod = contentInfos.currentPeriod;
+        var activePeriodAdaptations = activeAdaptations[period.id];
+        if ((0, is_null_or_undefined_1.default)(activePeriodAdaptations)) {
+            activeAdaptations[period.id] = (_b = {}, _b[type] = adaptation, _b);
+        }
+        else {
+            activePeriodAdaptations[type] = adaptation;
+        }
+        var tracksStore = contentInfos.tracksStore;
+        var cancelSignal = contentInfos.currentContentCanceller.signal;
+        if (tracksStore !== null &&
+            currentPeriod !== null &&
+            !(0, is_null_or_undefined_1.default)(period) &&
+            period.id === currentPeriod.id) {
+            var periodRef = tracksStore.getPeriodObjectFromPeriod(period);
+            if (periodRef === undefined) {
+                return;
+            }
+            switch (type) {
+                case "audio": {
+                    var audioTrack = tracksStore.getChosenAudioTrack(periodRef, true);
+                    this._priv_triggerEventIfNotStopped("audioTrackChange", audioTrack, cancelSignal);
+                    break;
+                }
+                case "text": {
+                    var textTrack = tracksStore.getChosenTextTrack(periodRef);
+                    this._priv_triggerEventIfNotStopped("textTrackChange", textTrack, cancelSignal);
+                    break;
+                }
+                case "video": {
+                    var videoTrack = tracksStore.getChosenVideoTrack(periodRef, true);
+                    this._priv_triggerEventIfNotStopped("videoTrackChange", videoTrack, cancelSignal);
+                    break;
+                }
+            }
+        }
+    };
+    /**
+     * Triggered each times a new Representation is considered during playback.
+     *
+     * Store given Representation and emit it if from the current Period.
+     *
+     * @param {Object} contentInfos
+     * @param {Object} obj
+     */
+    Player.prototype._priv_onRepresentationChange = function (contentInfos, _a) {
+        var _b;
+        var _c;
+        var type = _a.type, period = _a.period, representation = _a.representation;
+        if (contentInfos.contentId !== ((_c = this._priv_contentInfos) === null || _c === void 0 ? void 0 : _c.contentId)) {
+            return; // Event for another content
+        }
+        // lazily create contentInfos.activeRepresentations
+        if (contentInfos.activeRepresentations === null) {
+            contentInfos.activeRepresentations = {};
+        }
+        var activeRepresentations = contentInfos.activeRepresentations, currentPeriod = contentInfos.currentPeriod;
+        var activePeriodRepresentations = activeRepresentations[period.id];
+        if ((0, is_null_or_undefined_1.default)(activePeriodRepresentations)) {
+            activeRepresentations[period.id] = (_b = {}, _b[type] = representation, _b);
+        }
+        else {
+            activePeriodRepresentations[type] = representation;
+        }
+        if (!(0, is_null_or_undefined_1.default)(period) &&
+            currentPeriod !== null &&
+            currentPeriod.id === period.id) {
+            var cancelSignal = this._priv_contentInfos.currentContentCanceller.signal;
+            if (type === "video") {
+                this._priv_triggerEventIfNotStopped("videoRepresentationChange", (0, is_null_or_undefined_1.default)(representation)
+                    ? representation
+                    : (0, manifest_1.toVideoRepresentation)(representation), cancelSignal);
+            }
+            else if (type === "audio") {
+                this._priv_triggerEventIfNotStopped("audioRepresentationChange", (0, is_null_or_undefined_1.default)(representation)
+                    ? representation
+                    : (0, manifest_1.toAudioRepresentation)(representation), cancelSignal);
+            }
+        }
+    };
+    /**
+     * Triggered each time a bitrate estimate is calculated.
+     *
+     * Emit it.
+     *
+     * @param {Object} value
+     */
+    Player.prototype._priv_onBitrateEstimateChange = function (_a) {
+        var type = _a.type, bitrate = _a.bitrate;
+        if (bitrate !== undefined) {
+            this._priv_bitrateInfos.lastBitrates[type] = bitrate;
+        }
+        this.trigger(
+        // !!! undocumented API :O !!!
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        "__priv_bitrateEstimateChange", 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        { type: type, bitrate: bitrate });
+    };
+    /**
+     * Triggered each time the player state updates.
+     *
+     * Trigger the right Player Event.
+     *
+     * @param {string} newState
+     */
+    Player.prototype._priv_setPlayerState = function (newState) {
+        if (this.state !== newState) {
+            this.state = newState;
+            log_1.default.info("API", "playerStateChange event", { newState: newState });
+            this.trigger("playerStateChange", newState);
+        }
+    };
+    /**
+     * Triggered each time a playback observation.
+     *
+     * Trigger the right Player Event
+     *
+     * @param {Object} contentInfos
+     * @param {Object} observation
+     */
+    Player.prototype._priv_triggerPositionUpdate = function (contentInfos, observation) {
+        var _a, _b;
+        if (contentInfos.contentId !== ((_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.contentId)) {
+            return; // Event for another content
+        }
+        var isDirectFile = contentInfos.isDirectFile, manifest = contentInfos.manifest;
+        if ((!isDirectFile && manifest === null) || (0, is_null_or_undefined_1.default)(observation)) {
+            return;
+        }
+        var maximumPosition = manifest !== null ? (0, manifest_1.getMaximumSafePosition)(manifest) : undefined;
+        var positionData = {
+            position: observation.position.getPolled(),
+            duration: observation.duration,
+            playbackRate: observation.playbackRate,
+            maximumPosition: maximumPosition,
+            // TODO bufferGap may be undefined
+            bufferGap: observation.bufferGap === undefined || !isFinite(observation.bufferGap)
+                ? 0
+                : observation.bufferGap,
+        };
+        if (manifest !== null && manifest.isLive && observation.position.getPolled() > 0) {
+            var ast = (_b = manifest.availabilityStartTime) !== null && _b !== void 0 ? _b : 0;
+            positionData.wallClockTime = observation.position.getPolled() + ast;
+            var livePosition = (0, manifest_1.getLivePosition)(manifest);
+            if (livePosition !== undefined) {
+                positionData.liveGap = livePosition - observation.position.getPolled();
+            }
+        }
+        else if (isDirectFile && this.videoElement !== null) {
+            var startDate = (0, get_start_date_1.default)(this.videoElement);
+            if (startDate !== undefined) {
+                positionData.wallClockTime = startDate + observation.position.getPolled();
+            }
+        }
+        this.trigger("positionUpdate", positionData);
+    };
+    /**
+     * @param {string} evt
+     * @param {*} arg
+     * @param {Object} currentContentCancelSignal
+     */
+    Player.prototype._priv_triggerEventIfNotStopped = function (evt, arg, currentContentCancelSignal) {
+        if (!currentContentCancelSignal.isCancelled()) {
+            this.trigger(evt, arg);
+        }
+    };
+    /**
+     * @param {Object} cancelSignal
+     * @returns {Object}
+     */
+    Player.prototype._priv_initializeMediaElementTracksStore = function (cancelSignal) {
+        var _this = this;
+        var _a, _b, _c;
+        (0, assert_1.default)(features_1.default.directfile !== null, "Initializing `MediaElementTracksStore` without Directfile feature");
+        (0, assert_1.default)(this.videoElement !== null, "Initializing `MediaElementTracksStore` on a disposed RxPlayer");
+        var mediaElementTracksStore = new features_1.default.directfile.mediaElementTracksStore(this.videoElement);
+        this._priv_triggerEventIfNotStopped("availableAudioTracksChange", mediaElementTracksStore.getAvailableAudioTracks(), cancelSignal);
+        this._priv_triggerEventIfNotStopped("availableVideoTracksChange", mediaElementTracksStore.getAvailableVideoTracks(), cancelSignal);
+        this._priv_triggerEventIfNotStopped("availableTextTracksChange", mediaElementTracksStore.getAvailableTextTracks(), cancelSignal);
+        this._priv_triggerEventIfNotStopped("audioTrackChange", (_a = mediaElementTracksStore.getChosenAudioTrack()) !== null && _a !== void 0 ? _a : null, cancelSignal);
+        this._priv_triggerEventIfNotStopped("textTrackChange", (_b = mediaElementTracksStore.getChosenTextTrack()) !== null && _b !== void 0 ? _b : null, cancelSignal);
+        this._priv_triggerEventIfNotStopped("videoTrackChange", (_c = mediaElementTracksStore.getChosenVideoTrack()) !== null && _c !== void 0 ? _c : null, cancelSignal);
+        mediaElementTracksStore.addEventListener("availableVideoTracksChange", function (val) {
+            return _this.trigger("availableVideoTracksChange", val);
+        });
+        mediaElementTracksStore.addEventListener("availableAudioTracksChange", function (val) {
+            return _this.trigger("availableAudioTracksChange", val);
+        });
+        mediaElementTracksStore.addEventListener("availableTextTracksChange", function (val) {
+            return _this.trigger("availableTextTracksChange", val);
+        });
+        mediaElementTracksStore.addEventListener("audioTrackChange", function (val) {
+            return _this.trigger("audioTrackChange", val);
+        });
+        mediaElementTracksStore.addEventListener("videoTrackChange", function (val) {
+            return _this.trigger("videoTrackChange", val);
+        });
+        mediaElementTracksStore.addEventListener("textTrackChange", function (val) {
+            return _this.trigger("textTrackChange", val);
+        });
+        return mediaElementTracksStore;
+    };
+    Player.prototype._priv_callTracksStoreGetterSetter = function (periodId, defaultValue, cb) {
+        var _a, _b;
+        if (this._priv_contentInfos === null ||
+            this._priv_contentInfos.tracksStore === null) {
+            log_1.default.warn("API", "Trying to call track API too soon");
+            return defaultValue;
+        }
+        var tracksStore = this._priv_contentInfos.tracksStore;
+        var currentPeriod = (_b = (_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.currentPeriod) !== null && _b !== void 0 ? _b : undefined;
+        var wantedPeriodId = periodId !== null && periodId !== void 0 ? periodId : currentPeriod === null || currentPeriod === void 0 ? void 0 : currentPeriod.id;
+        if (wantedPeriodId === undefined) {
+            return defaultValue;
+        }
+        var periodRef = wantedPeriodId === (currentPeriod === null || currentPeriod === void 0 ? void 0 : currentPeriod.id)
+            ? tracksStore.getPeriodObjectFromPeriod(currentPeriod)
+            : tracksStore.getPeriodObjectFromId(wantedPeriodId);
+        if (periodRef === undefined) {
+            return defaultValue;
+        }
+        return cb(tracksStore, periodRef);
+    };
+    /**
+     * Method to call when some event lead to a high for possibility that the
+     * available tracks for the given type have changed.
+     * Send the corresponding `available*Tracks` change event with the last
+     * available tracks.
+     *
+     * @param {string} trackType
+     * @param {Object|undefined} [oPeriodRef] - optional period object used by the
+     * `tracksStore` API, allows to optimize the method by bypassing this step.
+     */
+    Player.prototype._priv_onAvailableTracksMayHaveChanged = function (trackType, oPeriodRef) {
+        var contentInfos = this._priv_contentInfos;
+        if (contentInfos === null) {
+            return;
+        }
+        var currentPeriod = contentInfos.currentPeriod, tracksStore = contentInfos.tracksStore, currentContentCanceller = contentInfos.currentContentCanceller;
+        var cancelSignal = currentContentCanceller.signal;
+        if ((0, is_null_or_undefined_1.default)(currentPeriod) || tracksStore === null) {
+            return;
+        }
+        var periodRef = oPeriodRef !== null && oPeriodRef !== void 0 ? oPeriodRef : tracksStore.getPeriodObjectFromPeriod(currentPeriod);
+        if (periodRef === undefined) {
+            return;
+        }
+        switch (trackType) {
+            case "video": {
+                var videoTracks = tracksStore.getAvailableVideoTracks(periodRef, true);
+                this._priv_triggerEventIfNotStopped("availableVideoTracksChange", videoTracks !== null && videoTracks !== void 0 ? videoTracks : [], cancelSignal);
+                break;
+            }
+            case "audio": {
+                var audioTracks = tracksStore.getAvailableAudioTracks(periodRef, true);
+                this._priv_triggerEventIfNotStopped("availableAudioTracksChange", audioTracks !== null && audioTracks !== void 0 ? audioTracks : [], cancelSignal);
+                break;
+            }
+            case "text": {
+                var textTracks = tracksStore.getAvailableTextTracks(periodRef);
+                this._priv_triggerEventIfNotStopped("availableTextTracksChange", textTracks !== null && textTracks !== void 0 ? textTracks : [], cancelSignal);
+                break;
+            }
+            default:
+                (0, assert_1.assertUnreachable)(trackType);
+        }
+    };
+    /**
+     * Method to call when a fatal error lead to the stopping of the current
+     * content.
+     *
+     * @param {*} err - The error encountered.
+     * @param {Object} contentInfos - The `IPublicApiContentInfos` object linked
+     * to the content for which the error was received.
+     */
+    Player.prototype._priv_onFatalError = function (err, contentInfos) {
+        var formattedError = (0, errors_1.formatError)(err, {
+            defaultCode: "NONE",
+            defaultReason: "An unknown error stopped content playback.",
+        });
+        formattedError.fatal = true;
+        contentInfos.currentContentCanceller.cancel("fatal err");
+        this._priv_cleanUpCurrentContentState();
+        this._priv_currentError = formattedError;
+        log_1.default.error("API", "The player stopped because of an error", formattedError);
+        this._priv_setPlayerState("STOPPED" /* PLAYER_STATES.STOPPED */);
+        // TODO This condition is here because the eventual callback called when the
+        // player state is updated can launch a new content, thus the error will not
+        // be here anymore, in which case triggering the "error" event is unwanted.
+        // This is very ugly though, and we should probable have a better solution
+        if (this._priv_currentError === formattedError) {
+            this.trigger("error", formattedError);
+        }
+    };
+    /**
+     * Returns `true` if the content concerned by those options should load in
+     * multithread mode.
+     * Returns `false` if it should load in main thread.
+     * @param {Object} options - The `loadVideo` options for that content.
+     * @returns {boolean} - `true` if the content should be loaded in multithread
+     * mode.
+     */
+    Player.prototype._priv_shouldLoadMultithread = function (options) {
+        var _a;
+        if (options.mode === "main") {
+            return false;
+        }
+        if (options.mode === "multithread") {
+            return true;
+        }
+        if (options.transport === "directfile") {
+            return false;
+        }
+        if (features_1.default.multithread === null || this._priv_workerData === null) {
+            // No possibility for multithread
+            return false;
+        }
+        if (!(0, is_null_or_undefined_1.default)((_a = this.videoElement) === null || _a === void 0 ? void 0 : _a.FORCED_MEDIA_SOURCE)) {
+            // Special case: Dummy Media Element only in main thread for now
+            // TODO: Make it work with multithread?
+            return false;
+        }
+        if (options.transport !== "dash" && options.transport !== "local") {
+            return false;
+        }
+        if (features_1.default.monothread === null ||
+            typeof features_1.default.transports[options.transport] !== "function") {
+            // We cannot play in monothread anyway, but we may be able to in
+            // multithread
+            return true;
+        }
+        if (options.manifestLoader !== undefined &&
+            typeof options.manifestLoader.fn === "function" &&
+            (0, is_null_or_undefined_1.default)(options.manifestLoader.workerId)) {
+            return false;
+        }
+        if (options.segmentLoader !== undefined &&
+            typeof options.segmentLoader.fn === "function" &&
+            (0, is_null_or_undefined_1.default)(options.segmentLoader.workerId)) {
+            return false;
+        }
+        if (options.representationFilter !== undefined &&
+            typeof options.representationFilter.fn === "function" &&
+            (0, is_null_or_undefined_1.default)(options.representationFilter.workerId) &&
+            (0, is_null_or_undefined_1.default)(options.representationFilter.eval)) {
+            return false;
+        }
+        return true;
+    };
+    /**
+     * Store all video elements currently in use by an RxPlayer instance.
+     * This is used to check that a video element is not shared between multiple instances.
+     * Use of a WeakSet ensure the object is garbage collected if it's not used anymore.
+     */
+    Player._priv_currentlyUsedVideoElements = new WeakSet();
+    return Player;
+}(event_emitter_1.default));
+Player.version = /* PLAYER_VERSION */ "4.5.0-dev.2026012302";
+exports.default = Player;