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

package/dist/_esm5.processed/core/api/public_api.js

@@ -1,8 +1,7 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
- * Licensed under the Apache License, Version 2.0 (the "License");publicapi
+ * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
@@ -14,115 +13,211 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
+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);
+};
 /**
  * This file defines the public API for the RxPlayer.
  * It also starts the different sub-parts of the player on various API calls.
  */
-const compat_1 = require("../../compat");
+import { events, exitFullscreen, getStartDate, isFullscreen, requestFullscreen, } from "../../compat";
 /* eslint-disable-next-line max-len */
-const can_rely_on_video_visibility_and_size_1 = require("../../compat/can_rely_on_video_visibility_and_size");
-const config_1 = require("../../config");
-const errors_1 = require("../../errors");
-const features_1 = require("../../features");
-const log_1 = require("../../log");
-const array_find_1 = require("../../utils/array_find");
-const array_includes_1 = require("../../utils/array_includes");
-const assert_1 = require("../../utils/assert");
-const assert_unreachable_1 = require("../../utils/assert_unreachable");
-const event_emitter_1 = require("../../utils/event_emitter");
-const id_generator_1 = require("../../utils/id_generator");
-const is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
-const object_assign_1 = require("../../utils/object_assign");
-const ranges_1 = require("../../utils/ranges");
-const reference_1 = require("../../utils/reference");
-const task_canceller_1 = require("../../utils/task_canceller");
-const decrypt_1 = require("../decrypt");
-const option_utils_1 = require("./option_utils");
-const playback_observer_1 = require("./playback_observer");
-const tracks_store_1 = require("./track_management/tracks_store");
-const utils_1 = require("./utils");
+import canRelyOnVideoVisibilityAndSize from "../../compat/can_rely_on_video_visibility_and_size";
+import config from "../../config";
+import { ErrorCodes, ErrorTypes, formatError, MediaError, } from "../../errors";
+import features, { addFeatures, } from "../../features";
+import log from "../../log";
+import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
+import arrayIncludes from "../../utils/array_includes";
+import assert from "../../utils/assert";
+import EventEmitter from "../../utils/event_emitter";
+import idGenerator from "../../utils/id_generator";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import objectAssign from "../../utils/object_assign";
+import { getLeftSizeOfRange, getPlayedSizeOfRange, getSizeOfRange, } from "../../utils/ranges";
+import SharedReference, { createMappedReference, } from "../../utils/reference";
+import TaskCanceller from "../../utils/task_canceller";
+import warnOnce from "../../utils/warn_once";
+import { clearOnStop, disposeDecryptionResources, getKeySystemConfiguration, getCurrentKeySystem, } from "../decrypt";
+import { checkReloadOptions, parseConstructorOptions, parseLoadVideoOptions, } from "./option_utils";
+import PlaybackObserver from "./playback_observer";
+import TrackChoiceManager from "./tracks_management/track_choice_manager";
+import { constructPlayerStateReference, emitPlayPauseEvents, emitSeekEvents, isLoadedState, } from "./utils";
 /* eslint-disable @typescript-eslint/naming-convention */
-const generateContentId = (0, id_generator_1.default)();
-const { getPictureOnPictureStateRef, getVideoVisibilityRef, getElementResolutionRef, getScreenResolutionRef } = compat_1.events;
+var generateContentId = idGenerator();
+var getPageActivityRef = events.getPageActivityRef, getPictureOnPictureStateRef = events.getPictureOnPictureStateRef, getVideoVisibilityRef = events.getVideoVisibilityRef, getVideoWidthRef = events.getVideoWidthRef, onFullscreenChange = events.onFullscreenChange, onTextTrackAdded = events.onTextTrackAdded, onTextTrackRemoved = events.onTextTrackRemoved;
 /**
  * @class Player
  * @extends EventEmitter
  */
-class Player extends event_emitter_1.default {
-    /** All possible Error types emitted by the RxPlayer. */
-    static get ErrorTypes() {
-        return errors_1.ErrorTypes;
-    }
-    /** All possible Error codes emitted by the RxPlayer. */
-    static get ErrorCodes() {
-        return errors_1.ErrorCodes;
-    }
-    /**
-     * 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".
-     */
-    static get LogLevel() {
-        return log_1.default.getLevel();
-    }
-    static set LogLevel(logLevel) {
-        log_1.default.setLevel(logLevel);
-    }
-    /**
-     * Add feature(s) to the RxPlayer.
-     * @param {Array.<Object>} featureList - Features wanted.
-     */
-    static addFeatures(featureList) {
-        (0, features_1.addFeatures)(featureList);
-    }
+var Player = /** @class */ (function (_super) {
+    __extends(Player, _super);
     /**
      * @constructor
      * @param {Object} options
      */
-    constructor(options = {}) {
-        super();
-        const { baseBandwidth, videoResolutionLimit, maxBufferAhead, maxBufferBehind, throttleVideoBitrateWhenHidden, videoElement, wantedBufferAhead, maxVideoBufferSize } = (0, option_utils_1.parseConstructorOptions)(options);
-        const { DEFAULT_UNMUTED_VOLUME } = config_1.default.getCurrent();
+    function Player(options) {
+        if (options === void 0) { options = {}; }
+        var _a, _b;
+        var _this = _super.call(this) || this;
+        var _c = parseConstructorOptions(options), initialAudioBitrate = _c.initialAudioBitrate, initialVideoBitrate = _c.initialVideoBitrate, limitVideoWidth = _c.limitVideoWidth, minAudioBitrate = _c.minAudioBitrate, minVideoBitrate = _c.minVideoBitrate, maxAudioBitrate = _c.maxAudioBitrate, maxBufferAhead = _c.maxBufferAhead, maxBufferBehind = _c.maxBufferBehind, maxVideoBitrate = _c.maxVideoBitrate, preferredAudioTracks = _c.preferredAudioTracks, preferredTextTracks = _c.preferredTextTracks, preferredVideoTracks = _c.preferredVideoTracks, throttleWhenHidden = _c.throttleWhenHidden, throttleVideoBitrateWhenHidden = _c.throttleVideoBitrateWhenHidden, videoElement = _c.videoElement, wantedBufferAhead = _c.wantedBufferAhead, maxVideoBufferSize = _c.maxVideoBufferSize, stopAtEnd = _c.stopAtEnd;
+        var DEFAULT_UNMUTED_VOLUME = config.getCurrent().DEFAULT_UNMUTED_VOLUME;
         // 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.0.0-dev.2023102700";
-        this.log = log_1.default;
-        this.state = "STOPPED";
-        this.videoElement = videoElement;
-        const destroyCanceller = new task_canceller_1.default();
-        this._destroyCanceller = destroyCanceller;
-        this._priv_pictureInPictureRef = 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.version = /* PLAYER_VERSION */ "3.33.0-canal.2023111400";
+        _this.log = log;
+        _this.state = "STOPPED";
+        _this.videoElement = videoElement;
+        var destroyCanceller = new TaskCanceller();
+        _this._destroyCanceller = destroyCanceller;
+        _this._priv_pictureInPictureRef = getPictureOnPictureStateRef(videoElement, destroyCanceller.signal);
+        /** @deprecated */
+        onFullscreenChange(videoElement, function () {
+            /* eslint-disable import/no-deprecated */
+            _this.trigger("fullscreenChange", _this.isFullscreen());
+            /* eslint-enable import/no-deprecated */
+        }, destroyCanceller.signal);
+        /** Store last known TextTrack array linked to the media element. */
+        var prevTextTracks = [];
+        for (var i = 0; i < ((_a = videoElement.textTracks) === null || _a === void 0 ? void 0 : _a.length); i++) {
+            var textTrack = (_b = videoElement.textTracks) === null || _b === void 0 ? void 0 : _b[i];
+            if (!isNullOrUndefined(textTrack)) {
+                prevTextTracks.push(textTrack);
+            }
+        }
+        /** Callback called when a TextTrack element is added or removed. */
+        var onTextTrackChanges = function (_evt) {
+            var evt = _evt;
+            var target = evt.target;
+            var textTrackArr = [];
+            for (var i = 0; i < target.length; i++) {
+                var textTrack = target[i];
+                textTrackArr.push(textTrack);
+            }
+            var oldTextTracks = prevTextTracks;
+            prevTextTracks = textTrackArr;
+            // We can have two consecutive textTrackChanges with the exact same
+            // payload when we perform multiple texttrack operations before the event
+            // loop is freed.
+            if (oldTextTracks.length !== textTrackArr.length) {
+                _this._priv_onNativeTextTracksNext(textTrackArr);
+                return;
+            }
+            for (var i = 0; i < oldTextTracks.length; i++) {
+                if (oldTextTracks[i] !== textTrackArr[i]) {
+                    _this._priv_onNativeTextTracksNext(textTrackArr);
+                    return;
+                }
+            }
+            return;
         };
-        this._priv_bitrateInfos = {
-            lastBitrates: { audio: baseBandwidth,
-                video: baseBandwidth },
+        if (!isNullOrUndefined(videoElement.textTracks)) {
+            onTextTrackAdded(videoElement.textTracks, onTextTrackChanges, destroyCanceller.signal);
+            onTextTrackRemoved(videoElement.textTracks, onTextTrackChanges, destroyCanceller.signal);
+        }
+        _this._priv_speed = new SharedReference(videoElement.playbackRate, _this._destroyCanceller.signal);
+        _this._priv_preferTrickModeTracks = false;
+        _this._priv_contentLock = new SharedReference(false, _this._destroyCanceller.signal);
+        _this._priv_bufferOptions = {
+            wantedBufferAhead: new SharedReference(wantedBufferAhead, _this._destroyCanceller.signal),
+            maxBufferAhead: new SharedReference(maxBufferAhead, _this._destroyCanceller.signal),
+            maxBufferBehind: new SharedReference(maxBufferBehind, _this._destroyCanceller.signal),
+            maxVideoBufferSize: new SharedReference(maxVideoBufferSize, _this._destroyCanceller.signal),
         };
-        this._priv_throttleVideoBitrateWhenHidden = throttleVideoBitrateWhenHidden;
-        this._priv_videoResolutionLimit = videoResolutionLimit;
-        this._priv_mutedMemory = DEFAULT_UNMUTED_VOLUME;
-        this._priv_currentError = null;
-        this._priv_contentInfos = null;
-        this._priv_contentEventsMemory = {};
-        this._priv_setPlayerState("STOPPED" /* PLAYER_STATES.STOPPED */);
-        this._priv_reloadingMetadata = {};
-        this._priv_lastAutoPlay = false;
-    }
+        _this._priv_bitrateInfos = {
+            lastBitrates: { audio: initialAudioBitrate,
+                video: initialVideoBitrate },
+            minAutoBitrates: { audio: new SharedReference(minAudioBitrate, _this._destroyCanceller.signal),
+                video: new SharedReference(minVideoBitrate, _this._destroyCanceller.signal) },
+            maxAutoBitrates: { audio: new SharedReference(maxAudioBitrate, _this._destroyCanceller.signal),
+                video: new SharedReference(maxVideoBitrate, _this._destroyCanceller.signal) },
+            manualBitrates: { audio: new SharedReference(-1, _this._destroyCanceller.signal),
+                video: new SharedReference(-1, _this._destroyCanceller.signal) },
+        };
+        _this._priv_throttleWhenHidden = throttleWhenHidden;
+        _this._priv_throttleVideoBitrateWhenHidden = throttleVideoBitrateWhenHidden;
+        _this._priv_limitVideoWidth = limitVideoWidth;
+        _this._priv_mutedMemory = DEFAULT_UNMUTED_VOLUME;
+        _this._priv_currentError = null;
+        _this._priv_contentInfos = null;
+        _this._priv_contentEventsMemory = {};
+        _this._priv_stopAtEnd = stopAtEnd;
+        _this._priv_setPlayerState("STOPPED" /* PLAYER_STATES.STOPPED */);
+        _this._priv_preferredAudioTracks = preferredAudioTracks;
+        _this._priv_preferredTextTracks = preferredTextTracks;
+        _this._priv_preferredVideoTracks = preferredVideoTracks;
+        _this._priv_reloadingMetadata = {};
+        _this._priv_lastAutoPlay = false;
+        return _this;
+    }
+    Object.defineProperty(Player, "ErrorTypes", {
+        /** All possible Error types emitted by the RxPlayer. */
+        get: function () {
+            return ErrorTypes;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Player, "ErrorCodes", {
+        /** All possible Error codes emitted by the RxPlayer. */
+        get: function () {
+            return 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.getLevel();
+        },
+        set: function (logLevel) {
+            log.setLevel(logLevel);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Add feature(s) to the RxPlayer.
+     * @param {Array.<Object>} featureList - Features wanted.
+     */
+    Player.addFeatures = function (featureList) {
+        addFeatures(featureList);
+    };
     /**
      * Register a new callback for a player event event.
      *
@@ -131,17 +226,17 @@ class Player extends event_emitter_1.default {
      * The callback will take as argument the eventual payload of the event
      * (single argument).
      */
-    addEventListener(evt, fn) {
+    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.addEventListener(evt, fn);
-    }
+        return _super.prototype.addEventListener.call(this, evt, fn);
+    };
     /**
      * Stop the playback for the current content.
      */
-    stop() {
+    Player.prototype.stop = function () {
         if (this._priv_contentInfos !== null) {
             this._priv_contentInfos.currentContentCanceller.cancel();
         }
@@ -149,21 +244,21 @@ class Player extends event_emitter_1.default {
         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.
      */
-    dispose() {
+    Player.prototype.dispose = function () {
         // free resources linked to the loaded content
         this.stop();
         if (this.videoElement !== null) {
             // free resources used for decryption management
-            (0, decrypt_1.disposeDecryptionResources)(this.videoElement)
-                .catch((err) => {
-                const message = err instanceof Error ? err.message :
+            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);
+                log.error("API: Could not dispose decryption resources: " + message);
             });
         }
         // free resources linked to the Player instance
@@ -171,30 +266,30 @@ class Player extends event_emitter_1.default {
         this._priv_reloadingMetadata = {};
         // un-attach video element
         this.videoElement = null;
-    }
+    };
     /**
      * Load a new video.
      * @param {Object} opts
      */
-    loadVideo(opts) {
-        const options = (0, option_utils_1.parseLoadVideoOptions)(opts);
-        log_1.default.info("API: Calling loadvideo", options.url, options.transport);
-        this._priv_reloadingMetadata = { options };
+    Player.prototype.loadVideo = function (opts) {
+        var options = parseLoadVideoOptions(opts);
+        log.info("API: Calling loadvideo", options.url, options.transport);
+        this._priv_reloadingMetadata = { options: options };
         this._priv_initializeContentPlayback(options);
         this._priv_lastAutoPlay = options.autoPlay;
-    }
+    };
     /**
      * Reload the last loaded content.
      * @param {Object} reloadOpts
      */
-    reload(reloadOpts) {
-        var _a, _b;
-        const { options, manifest, reloadPosition, reloadInPause } = this._priv_reloadingMetadata;
+    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);
-        let startAt;
+        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 };
         }
@@ -209,206 +304,269 @@ class Player extends event_emitter_1.default {
         else if (reloadPosition !== undefined) {
             startAt = { position: reloadPosition };
         }
-        let autoPlay;
+        var autoPlay;
         if ((reloadOpts === null || reloadOpts === void 0 ? void 0 : reloadOpts.autoPlay) !== undefined) {
             autoPlay = reloadOpts.autoPlay;
         }
         else if (reloadInPause !== undefined) {
             autoPlay = !reloadInPause;
         }
-        const newOptions = Object.assign(Object.assign({}, options), { initialManifest: manifest });
+        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);
-    }
-    createDebugElement(element) {
-        if (features_1.default.createDebugElement === null) {
+    };
+    Player.prototype.createDebugElement = function (element) {
+        if (features.createDebugElement === null) {
             throw new Error("Feature `DEBUG_ELEMENT` not added to the RxPlayer");
         }
-        const canceller = new task_canceller_1.default();
-        features_1.default.createDebugElement(element, this, canceller.signal);
+        var canceller = new TaskCanceller();
+        features.createDebugElement(element, this, canceller.signal);
         return {
-            dispose() {
+            dispose: function () {
                 canceller.cancel();
             },
         };
-    }
+    };
     /**
      * From given options, initialize content playback.
      * @param {Object} options
      */
-    _priv_initializeContentPlayback(options) {
-        var _a, _b, _c, _d;
-        const { autoPlay, defaultAudioTrackSwitchingMode, enableFastSwitching, initialManifest, keySystems, lowLatencyMode, minimumManifestUpdateInterval, requestConfig, onCodecSwitch, startAt, transport, checkMediaSegmentIntegrity, manifestLoader, referenceDateTime, representationFilter, segmentLoader, serverSyncInfos, __priv_manifestUpdateUrl, __priv_patchLastSegmentInSidx, url } = options;
+    Player.prototype._priv_initializeContentPlayback = function (options) {
+        var _this = this;
+        var autoPlay = options.autoPlay, audioTrackSwitchingMode = options.audioTrackSwitchingMode, defaultAudioTrack = options.defaultAudioTrack, defaultTextTrack = options.defaultTextTrack, enableFastSwitching = options.enableFastSwitching, initialManifest = options.initialManifest, keySystems = options.keySystems, lowLatencyMode = options.lowLatencyMode, manualBitrateSwitchingMode = options.manualBitrateSwitchingMode, minimumManifestUpdateInterval = options.minimumManifestUpdateInterval, networkConfig = options.networkConfig, onCodecSwitch = options.onCodecSwitch, startAt = options.startAt, transport = options.transport, transportOptions = options.transportOptions, url = options.url;
         // Perform multiple checks on the given options
         if (this.videoElement === null) {
             throw new Error("the attached video element is disposed");
         }
-        const isDirectFile = transport === "directfile";
+        var isDirectFile = transport === "directfile";
         /** Emit to stop the current content. */
-        const currentContentCanceller = new task_canceller_1.default();
-        const videoElement = this.videoElement;
-        let initializer;
-        let mediaElementTracksStore = null;
+        var currentContentCanceller = new TaskCanceller();
+        var videoElement = this.videoElement;
+        var initializer;
+        var mediaElementTrackChoiceManager = null;
         if (!isDirectFile) {
-            const transportFn = features_1.default.transports[transport];
+            var transportFn = features.transports[transport];
             if (typeof transportFn !== "function") {
                 // Stop previous content and reset its state
                 this.stop();
                 this._priv_currentError = null;
-                throw new Error(`transport "${transport}" not supported`);
+                throw new Error("transport \"".concat(transport, "\" not supported"));
             }
-            if (features_1.default.mediaSourceInit === null) {
+            if (features.mediaSourceInit === null) {
                 throw new Error("MediaSource streaming not supported");
             }
-            const transportPipelines = transportFn({ lowLatencyMode,
-                checkMediaSegmentIntegrity,
-                manifestLoader,
-                referenceDateTime,
-                representationFilter,
-                segmentLoader,
-                serverSyncInfos,
-                __priv_manifestUpdateUrl,
-                __priv_patchLastSegmentInSidx });
+            var transportPipelines = transportFn(transportOptions);
+            var offlineRetry = networkConfig.offlineRetry, segmentRetry = networkConfig.segmentRetry, manifestRetry = networkConfig.manifestRetry, manifestRequestTimeout = networkConfig.manifestRequestTimeout, segmentRequestTimeout = networkConfig.segmentRequestTimeout;
             /** Interface used to load and refresh the Manifest. */
-            const manifestRequestSettings = { 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,
-                minimumManifestUpdateInterval,
-                initialManifest };
-            const relyOnVideoVisibilityAndSize = (0, can_rely_on_video_visibility_and_size_1.default)();
-            const throttlers = { throttleBitrate: {},
-                limitResolution: {} };
+            var manifestRequestSettings = { lowLatencyMode: lowLatencyMode, maxRetryRegular: manifestRetry,
+                maxRetryOffline: offlineRetry,
+                requestTimeout: manifestRequestTimeout, minimumManifestUpdateInterval: minimumManifestUpdateInterval, initialManifest: initialManifest };
+            var relyOnVideoVisibilityAndSize = canRelyOnVideoVisibilityAndSize();
+            var throttlers = { throttle: {},
+                throttleBitrate: {},
+                limitWidth: {} };
+            if (this._priv_throttleWhenHidden) {
+                if (!relyOnVideoVisibilityAndSize) {
+                    log.warn("API: Can't apply throttleWhenHidden because " +
+                        "browser can't be trusted for visibility.");
+                }
+                else {
+                    throttlers.throttle = {
+                        video: createMappedReference(getPageActivityRef(currentContentCanceller.signal), function (isActive) { return isActive ? Infinity : 0; }, currentContentCanceller.signal),
+                    };
+                }
+            }
             if (this._priv_throttleVideoBitrateWhenHidden) {
                 if (!relyOnVideoVisibilityAndSize) {
-                    log_1.default.warn("API: Can't apply throttleVideoBitrateWhenHidden because " +
+                    log.warn("API: Can't apply throttleVideoBitrateWhenHidden because " +
                         "browser can't be trusted for visibility.");
                 }
                 else {
                     throttlers.throttleBitrate = {
-                        video: (0, reference_1.createMappedReference)(getVideoVisibilityRef(this._priv_pictureInPictureRef, currentContentCanceller.signal), isActive => isActive ? Infinity : 0, currentContentCanceller.signal),
+                        video: createMappedReference(getVideoVisibilityRef(this._priv_pictureInPictureRef, currentContentCanceller.signal), function (isActive) { return isActive ? Infinity : 0; }, currentContentCanceller.signal),
                     };
                 }
             }
-            if (this._priv_videoResolutionLimit === "videoElement") {
+            if (this._priv_limitVideoWidth) {
                 if (!relyOnVideoVisibilityAndSize) {
-                    log_1.default.warn("API: Can't apply videoResolutionLimit because browser can't be " +
+                    log.warn("API: Can't apply limitVideoWidth because browser can't be " +
                         "trusted for video size.");
                 }
                 else {
-                    throttlers.limitResolution = {
-                        video: getElementResolutionRef(videoElement, this._priv_pictureInPictureRef, currentContentCanceller.signal),
+                    throttlers.limitWidth = {
+                        video: getVideoWidthRef(videoElement, this._priv_pictureInPictureRef, currentContentCanceller.signal),
                     };
                 }
             }
-            else if (this._priv_videoResolutionLimit === "screen") {
-                throttlers.limitResolution = {
-                    video: getScreenResolutionRef(currentContentCanceller.signal),
-                };
-            }
             /** Options used by the adaptive logic. */
-            const adaptiveOptions = {
+            var adaptiveOptions = {
                 initialBitrates: this._priv_bitrateInfos.lastBitrates,
-                lowLatencyMode,
-                throttlers,
+                lowLatencyMode: lowLatencyMode,
+                manualBitrates: this._priv_bitrateInfos.manualBitrates,
+                minAutoBitrates: this._priv_bitrateInfos.minAutoBitrates,
+                maxAutoBitrates: this._priv_bitrateInfos.maxAutoBitrates,
+                throttlers: throttlers,
             };
             /** Options used by the TextTrack SegmentBuffer. */
-            const textTrackOptions = options.textTrackMode === "native" ?
-                { textTrackMode: "native" } :
+            var textTrackOptions = options.textTrackMode === "native" ?
+                { textTrackMode: "native",
+                    hideNativeSubtitle: options.hideNativeSubtitle } :
                 { textTrackMode: "html",
                     textTrackElement: options.textTrackElement };
-            const bufferOptions = (0, object_assign_1.default)({ enableFastSwitching,
-                onCodecSwitch }, this._priv_bufferOptions);
-            const segmentRequestOptions = { lowLatencyMode,
-                maxRetry: (_c = requestConfig.segment) === null || _c === void 0 ? void 0 : _c.maxRetry,
-                requestTimeout: (_d = requestConfig.segment) === null || _d === void 0 ? void 0 : _d.timeout };
-            initializer = new features_1.default.mediaSourceInit({
-                adaptiveOptions,
-                autoPlay,
-                bufferOptions,
-                keySystems,
-                lowLatencyMode,
-                manifestRequestSettings,
+            var bufferOptions = objectAssign({ audioTrackSwitchingMode: audioTrackSwitchingMode, enableFastSwitching: enableFastSwitching, manualBitrateSwitchingMode: manualBitrateSwitchingMode, onCodecSwitch: onCodecSwitch }, this._priv_bufferOptions);
+            var segmentRequestOptions = { lowLatencyMode: lowLatencyMode, maxRetryRegular: segmentRetry,
+                requestTimeout: segmentRequestTimeout,
+                maxRetryOffline: offlineRetry };
+            initializer = new features.mediaSourceInit({
+                adaptiveOptions: adaptiveOptions,
+                autoPlay: autoPlay,
+                bufferOptions: bufferOptions,
+                keySystems: keySystems,
+                lowLatencyMode: lowLatencyMode,
+                manifestRequestSettings: manifestRequestSettings,
                 transport: transportPipelines,
-                segmentRequestOptions,
+                segmentRequestOptions: segmentRequestOptions,
                 speed: this._priv_speed,
-                startAt,
-                textTrackOptions,
-                url,
+                startAt: startAt,
+                textTrackOptions: textTrackOptions,
+                url: url,
             });
         }
         else {
-            if (features_1.default.directfile === null) {
+            if (features.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)) {
+            else if (isNullOrUndefined(url)) {
                 throw new Error("No URL for a DirectFile content");
             }
-            mediaElementTracksStore =
-                this._priv_initializeMediaElementTracksStore(currentContentCanceller.signal);
+            mediaElementTrackChoiceManager =
+                this._priv_initializeMediaElementTrackChoiceManager(defaultAudioTrack, defaultTextTrack, currentContentCanceller.signal);
             if (currentContentCanceller.isUsed()) {
                 return;
             }
-            initializer = new features_1.default.directfile.initDirectFile({ autoPlay,
-                keySystems,
-                speed: this._priv_speed,
-                startAt,
-                url });
+            initializer = new features.directfile.initDirectFile({ autoPlay: autoPlay, keySystems: keySystems, speed: this._priv_speed, startAt: startAt, url: url });
         }
         /** Future `this._priv_contentInfos` related to this content. */
-        const contentInfos = {
+        var contentInfos = {
             contentId: generateContentId(),
             originalUrl: url,
-            currentContentCanceller,
-            defaultAudioTrackSwitchingMode,
-            initializer,
-            isDirectFile,
+            currentContentCanceller: currentContentCanceller,
+            initializer: initializer,
+            isDirectFile: isDirectFile,
             segmentBuffersStore: null,
+            thumbnails: null,
             manifest: null,
             currentPeriod: null,
             activeAdaptations: null,
             activeRepresentations: null,
-            tracksStore: null,
-            mediaElementTracksStore,
+            initialAudioTrack: defaultAudioTrack,
+            initialTextTrack: defaultTextTrack,
+            trackChoiceManager: null,
+            mediaElementTrackChoiceManager: mediaElementTrackChoiceManager,
         };
         // Bind events
-        initializer.addEventListener("error", (error) => {
-            this._priv_onFatalError(error, contentInfos);
+        initializer.addEventListener("error", function (error) {
+            var formattedError = formatError(error, {
+                defaultCode: "NONE",
+                defaultReason: "An unknown error stopped content playback.",
+            });
+            formattedError.fatal = true;
+            contentInfos.currentContentCanceller.cancel();
+            _this._priv_cleanUpCurrentContentState();
+            _this._priv_currentError = formattedError;
+            log.error("API: The player stopped because of an error", error instanceof Error ? error : "");
+            _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);
+            }
         });
-        initializer.addEventListener("warning", (error) => {
-            const formattedError = (0, errors_1.formatError)(error, {
+        initializer.addEventListener("warning", function (error) {
+            var formattedError = formatError(error, {
                 defaultCode: "NONE",
                 defaultReason: "An unknown error happened.",
             });
-            log_1.default.warn("API: Sending warning:", formattedError);
-            this.trigger("warning", formattedError);
+            log.warn("API: Sending warning:", formattedError);
+            _this.trigger("warning", formattedError);
         });
-        initializer.addEventListener("reloadingMediaSource", (payload) => {
+        initializer.addEventListener("reloadingMediaSource", function (payload) {
             contentInfos.segmentBuffersStore = null;
-            if (contentInfos.tracksStore !== null) {
-                contentInfos.tracksStore.resetPeriodObjects();
+            if (contentInfos.trackChoiceManager !== null) {
+                contentInfos.trackChoiceManager.resetPeriods();
             }
-            this._priv_lastAutoPlay = payload.autoPlay;
+            _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("decipherabilityUpdate", function (decipherabilityUpdate) {
+            return _this.trigger("decipherabilityUpdate", decipherabilityUpdate);
         });
-        initializer.addEventListener("inbandEvents", (inbandEvents) => this.trigger("inbandEvents", inbandEvents));
-        initializer.addEventListener("streamEvent", (streamEvent) => this.trigger("streamEvent", streamEvent));
-        initializer.addEventListener("streamEventSkip", (streamEventSkip) => this.trigger("streamEventSkip", streamEventSkip));
-        initializer.addEventListener("activePeriodChanged", (periodInfo) => this._priv_onActivePeriodChanged(contentInfos, periodInfo));
-        initializer.addEventListener("periodStreamReady", (periodReadyInfo) => this._priv_onPeriodStreamReady(contentInfos, periodReadyInfo));
-        initializer.addEventListener("periodStreamCleared", (periodClearedInfo) => this._priv_onPeriodStreamCleared(contentInfos, periodClearedInfo));
-        initializer.addEventListener("representationChange", (representationInfo) => this._priv_onRepresentationChange(contentInfos, representationInfo));
-        initializer.addEventListener("adaptationChange", (adaptationInfo) => this._priv_onAdaptationChange(contentInfos, adaptationInfo));
-        initializer.addEventListener("bitrateEstimateChange", (bitrateEstimateInfo) => this._priv_onBitrateEstimateChange(bitrateEstimateInfo));
-        initializer.addEventListener("manifestReady", (manifest) => this._priv_onManifestReady(contentInfos, manifest));
-        initializer.addEventListener("loaded", (evt) => {
+        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("bitrateEstimationChange", function (bitrateEstimationInfo) {
+            return _this._priv_onBitrateEstimationChange(bitrateEstimationInfo);
+        });
+        initializer.addEventListener("manifestReady", function (manifest) {
+            return _this._priv_onManifestReady(contentInfos, manifest);
+        });
+        initializer.addEventListener("loaded", function (evt) {
             contentInfos.segmentBuffersStore = evt.segmentBuffersStore;
         });
+        initializer.addEventListener("addedSegment", function (evt) {
+            // Manage image tracks
+            // @deprecated
+            var content = evt.content, segmentData = evt.segmentData;
+            if (content.adaptation.type === "image") {
+                if (!isNullOrUndefined(segmentData) &&
+                    segmentData.type === "bif") {
+                    var imageData = segmentData.data;
+                    /* eslint-disable import/no-deprecated */
+                    contentInfos.thumbnails = imageData;
+                    _this.trigger("imageTrackUpdate", { data: contentInfos.thumbnails });
+                    /* eslint-enable import/no-deprecated */
+                }
+            }
+        });
         // Now, that most events are linked, prepare the next content.
         initializer.prepare();
         // Now that the content is prepared, stop previous content and reset state
@@ -422,16 +580,16 @@ class Player extends event_emitter_1.default {
         //     content.
         this.stop();
         /** Global "playback observer" which will emit playback conditions */
-        const playbackObserver = new playback_observer_1.default(videoElement, {
+        var playbackObserver = new PlaybackObserver(videoElement, {
             withMediaSource: !isDirectFile,
-            lowLatencyMode,
+            lowLatencyMode: lowLatencyMode,
         });
-        currentContentCanceller.signal.register(() => {
+        currentContentCanceller.signal.register(function () {
             playbackObserver.stop();
         });
         // Update the RxPlayer's state at the right events
-        const playerStateRef = (0, utils_1.constructPlayerStateReference)(initializer, videoElement, playbackObserver, currentContentCanceller.signal);
-        currentContentCanceller.signal.register(() => {
+        var playerStateRef = constructPlayerStateReference(initializer, videoElement, playbackObserver, currentContentCanceller.signal);
+        currentContentCanceller.signal.register(function () {
             initializer.dispose();
         });
         /**
@@ -440,21 +598,21 @@ class Player extends event_emitter_1.default {
          * To call when either might change.
          * @param {string} state - The player state we're about to switch to.
          */
-        const updateReloadingMetadata = (state) => {
+        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 =
+                    _this._priv_reloadingMetadata.reloadInPause = true;
+                    _this._priv_reloadingMetadata.reloadPosition =
                         playbackObserver.getReference().getValue().position;
                     break;
                 default:
-                    const o = playbackObserver.getReference().getValue();
-                    this._priv_reloadingMetadata.reloadInPause = o.paused;
-                    this._priv_reloadingMetadata.reloadPosition = o.position;
+                    var o = playbackObserver.getReference().getValue();
+                    _this._priv_reloadingMetadata.reloadInPause = o.paused;
+                    _this._priv_reloadingMetadata.reloadPosition = o.position;
                     break;
             }
         };
@@ -463,41 +621,41 @@ class Player extends event_emitter_1.default {
          * events.
          * `null` when such events are not emitted currently.
          */
-        let playPauseEventsCanceller = null;
+        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.
          */
-        const triggerPlayPauseEventsWhenReady = (willAutoPlay) => {
+        var triggerPlayPauseEventsWhenReady = function (willAutoPlay) {
             if (playPauseEventsCanceller !== null) {
                 playPauseEventsCanceller.cancel(); // cancel previous logic
                 playPauseEventsCanceller = null;
             }
-            playerStateRef.onUpdate((val, stopListeningToStateUpdates) => {
-                if (!(0, utils_1.isLoadedState)(val)) {
+            playerStateRef.onUpdate(function (val, stopListeningToStateUpdates) {
+                if (!isLoadedState(val)) {
                     return; // content not loaded yet: no event
                 }
                 stopListeningToStateUpdates();
                 if (playPauseEventsCanceller !== null) {
                     playPauseEventsCanceller.cancel();
                 }
-                playPauseEventsCanceller = new task_canceller_1.default();
+                playPauseEventsCanceller = new TaskCanceller();
                 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);
+                        _this.trigger("pause", null);
                     }
                     else {
-                        this.trigger("play", null);
+                        _this.trigger("play", null);
                     }
                 }
-                (0, utils_1.emitPlayPauseEvents)(videoElement, () => this.trigger("play", null), () => this.trigger("pause", null), currentContentCanceller.signal);
+                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", (payload) => {
+        initializer.addEventListener("reloadingMediaSource", function (payload) {
             triggerPlayPauseEventsWhenReady(payload.autoPlay);
         });
         /**
@@ -505,53 +663,105 @@ class Player extends event_emitter_1.default {
          * events.
          * `null` when such events are not emitted currently.
          */
-        let seekEventsCanceller = null;
+        var seekEventsCanceller = null;
         // React to player state change
-        playerStateRef.onUpdate((newState) => {
+        playerStateRef.onUpdate(function (newState) {
             updateReloadingMetadata(newState);
-            this._priv_setPlayerState(newState);
+            _this._priv_setPlayerState(newState);
             if (currentContentCanceller.isUsed()) {
                 return;
             }
             if (seekEventsCanceller !== null) {
-                if (!(0, utils_1.isLoadedState)(this.state)) {
+                if (!isLoadedState(_this.state)) {
                     seekEventsCanceller.cancel();
                     seekEventsCanceller = null;
                 }
             }
-            else if ((0, utils_1.isLoadedState)(this.state)) {
-                seekEventsCanceller = new task_canceller_1.default();
+            else if (isLoadedState(_this.state)) {
+                seekEventsCanceller = new TaskCanceller();
                 seekEventsCanceller.linkToSignal(currentContentCanceller.signal);
-                (0, utils_1.emitSeekEvents)(videoElement, playbackObserver, () => this.trigger("seeking", null), () => this.trigger("seeked", null), seekEventsCanceller.signal);
+                emitSeekEvents(videoElement, playbackObserver, function () { return _this.trigger("seeking", null); }, function () { return _this.trigger("seeked", null); }, seekEventsCanceller.signal);
+            }
+            // Previous call could have performed all kind of side-effects, thus,
+            // we re-check the current state associated to the RxPlayer
+            if (_this.state === "ENDED" /* PLAYER_STATES.ENDED */ && _this._priv_stopAtEnd) {
+                _this.stop();
             }
         }, { emitCurrentValue: true, clearSignal: currentContentCanceller.signal });
         // React to playback conditions change
-        playbackObserver.listen((observation) => {
-            updateReloadingMetadata(this.state);
-            this._priv_triggerPositionUpdate(contentInfos, observation);
+        playbackObserver.listen(function (observation) {
+            updateReloadingMetadata(_this.state);
+            _this._priv_triggerPositionUpdate(contentInfos, observation);
         }, { clearSignal: currentContentCanceller.signal });
         this._priv_currentError = null;
         this._priv_contentInfos = contentInfos;
-        currentContentCanceller.signal.register(() => {
+        currentContentCanceller.signal.register(function () {
             initializer.removeEventListener();
         });
         // initialize the content only when the lock is inactive
-        this._priv_contentLock.onUpdate((isLocked, stopListeningToLock) => {
+        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).
      */
-    getError() {
+    Player.prototype.getError = function () {
         return this._priv_currentError;
-    }
+    };
+    /**
+     * Returns manifest/playlist object.
+     * null if the player is STOPPED.
+     * @deprecated
+     * @returns {Manifest|null} - The current Manifest (`null` when not known).
+     */
+    Player.prototype.getManifest = function () {
+        warnOnce("getManifest is deprecated." +
+            " Please open an issue if you used this API.");
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        return this._priv_contentInfos.manifest;
+    };
+    /**
+     * Returns Adaptations (tracks) for every currently playing type
+     * (audio/video/text...).
+     * @deprecated
+     * @returns {Object|null} - The current Adaptation objects, per type (`null`
+     * when none is known for now.
+     */
+    Player.prototype.getCurrentAdaptations = function () {
+        warnOnce("getCurrentAdaptations is deprecated." +
+            " Please open an issue if you used this API.");
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, activeAdaptations = _a.activeAdaptations;
+        if (currentPeriod === null ||
+            activeAdaptations === null ||
+            isNullOrUndefined(activeAdaptations[currentPeriod.id])) {
+            return null;
+        }
+        return activeAdaptations[currentPeriod.id];
+    };
+    /**
+     * Returns representations (qualities) for every currently playing type
+     * (audio/video/text...).
+     * @deprecated
+     * @returns {Object|null} - The current Representation objects, per type
+     * (`null` when none is known for now.
+     */
+    Player.prototype.getCurrentRepresentations = function () {
+        warnOnce("getCurrentRepresentations is deprecated." +
+            " Please open an issue if you used this API.");
+        return this._priv_getCurrentRepresentations();
+    };
     /**
      * Returns the media DOM element used by the player.
      * You should not its HTML5 API directly and use the player's method instead,
@@ -559,30 +769,50 @@ class Player extends event_emitter_1.default {
      * @returns {HTMLMediaElement|null} - The HTMLMediaElement used (`null` when
      * disposed)
      */
-    getVideoElement() {
+    Player.prototype.getVideoElement = function () {
         return this.videoElement;
-    }
+    };
+    /**
+     * If one returns the first native text-track element attached to the media element.
+     * @deprecated
+     * @returns {TextTrack} - The native TextTrack attached (`null` when none)
+     */
+    Player.prototype.getNativeTextTrack = function () {
+        warnOnce("getNativeTextTrack is deprecated." +
+            " Please open an issue if you used this API.");
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        var videoElement = this.videoElement;
+        var textTracks = videoElement.textTracks;
+        if (textTracks.length > 0) {
+            return videoElement.textTracks[0];
+        }
+        else {
+            return null;
+        }
+    };
     /**
      * Returns the player's current state.
      * @returns {string} - The current Player's state
      */
-    getPlayerState() {
+    Player.prototype.getPlayerState = function () {
         return this.state;
-    }
+    };
     /**
      * Returns true if a content is loaded.
      * @returns {Boolean} - `true` if a content is loaded, `false` otherwise.
      */
-    isContentLoaded() {
-        return !(0, array_includes_1.default)(["LOADING", "RELOADING", "STOPPED"], this.state);
-    }
+    Player.prototype.isContentLoaded = function () {
+        return !arrayIncludes(["LOADING", "RELOADING", "STOPPED"], this.state);
+    };
     /**
      * Returns true if the player is buffering.
      * @returns {Boolean} - `true` if the player is buffering, `false` otherwise.
      */
-    isBuffering() {
-        return (0, array_includes_1.default)(["BUFFERING", "SEEKING", "LOADING", "RELOADING"], this.state);
-    }
+    Player.prototype.isBuffering = function () {
+        return arrayIncludes(["BUFFERING", "SEEKING", "LOADING", "RELOADING"], this.state);
+    };
     /**
      * Returns the play/pause status of the player :
      *   - when `LOADING` or `RELOADING`, returns the scheduled play/pause condition
@@ -592,9 +822,9 @@ class Player extends event_emitter_1.default {
      * @returns {Boolean} - `true` if the player is paused or will be after loading,
      * `false` otherwise.
      */
-    isPaused() {
+    Player.prototype.isPaused = function () {
         if (this.videoElement) {
-            if ((0, array_includes_1.default)(["LOADING", "RELOADING"], this.state)) {
+            if (arrayIncludes(["LOADING", "RELOADING"], this.state)) {
                 return !this._priv_lastAutoPlay;
             }
             else {
@@ -602,52 +832,51 @@ class Player extends event_emitter_1.default {
             }
         }
         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.
      */
-    isLive() {
+    Player.prototype.isLive = function () {
         if (this._priv_contentInfos === null) {
             return false;
         }
-        const { isDirectFile, manifest } = this._priv_contentInfos;
+        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}
      */
-    areTrickModeTracksEnabled() {
+    Player.prototype.areTrickModeTracksEnabled = function () {
         return this._priv_preferTrickModeTracks;
-    }
+    };
     /**
-     * Returns the URL(s) of the currently considered Manifest, or of the content for
+     * Returns the url 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.
+     * @returns {string|undefined} - Current URL. `undefined` if not known or no
+     * URL yet.
      */
-    getContentUrls() {
+    Player.prototype.getUrl = function () {
         if (this._priv_contentInfos === null) {
             return undefined;
         }
-        const { isDirectFile, manifest, originalUrl } = this._priv_contentInfos;
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, manifest = _a.manifest, originalUrl = _a.originalUrl;
         if (isDirectFile) {
-            return originalUrl === undefined ? undefined :
-                [originalUrl];
+            return originalUrl;
         }
         if (manifest !== null) {
-            return manifest.getUrls();
+            return manifest.getUrl();
         }
         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 /
@@ -656,41 +885,67 @@ class Player extends event_emitter_1.default {
      * @param {boolean} params.refresh - If `true` the resource in question
      * (e.g. DASH's MPD) will be refreshed immediately.
      */
-    updateContentUrls(urls, params) {
+    Player.prototype.updateContentUrls = function (urls, params) {
         if (this._priv_contentInfos === null) {
             throw new Error("No content loaded");
         }
-        const refreshNow = (params === null || params === void 0 ? void 0 : params.refresh) === true;
+        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}
      */
-    getMediaDuration() {
+    Player.prototype.getVideoDuration = 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}
      */
-    getCurrentBufferGap() {
+    Player.prototype.getVideoBufferGap = function () {
         if (this.videoElement === null) {
             throw new Error("Disposed player");
         }
-        const videoElement = this.videoElement;
-        const bufferGap = (0, ranges_1.getLeftSizeOfBufferedTimeRange)(videoElement.buffered, videoElement.currentTime);
-        if (bufferGap === Infinity) {
-            return 0;
+        var videoElement = this.videoElement;
+        return getLeftSizeOfRange(videoElement.buffered, videoElement.currentTime);
+    };
+    /**
+     * Returns in seconds the difference between:
+     *   - the end of the current contiguous loaded range.
+     *   - the start of the current contiguous loaded range.
+     * @returns {Number}
+     */
+    Player.prototype.getVideoLoadedTime = function () {
+        warnOnce("`getVideoLoadedTime` is deprecated and won't be present in the " +
+            "next major version");
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
         }
-        return bufferGap;
-    }
+        var videoElement = this.videoElement;
+        return getSizeOfRange(videoElement.buffered, videoElement.currentTime);
+    };
+    /**
+     * Returns in seconds the difference between:
+     *   - the current time.
+     *   - the start of the current contiguous loaded range.
+     * @returns {Number}
+     */
+    Player.prototype.getVideoPlayedTime = function () {
+        warnOnce("`getVideoPlayedTime` is deprecated and won't be present in the " +
+            "next major version");
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        var videoElement = this.videoElement;
+        return getPlayedSizeOfRange(videoElement.buffered, videoElement.currentTime);
+    };
     /**
      * Get the current position, in s, in wall-clock time.
      * That is:
@@ -705,27 +960,27 @@ class Player extends event_emitter_1.default {
      *
      * @returns {Number}
      */
-    getWallClockTime() {
+    Player.prototype.getWallClockTime = function () {
         if (this.videoElement === null) {
             throw new Error("Disposed player");
         }
         if (this._priv_contentInfos === null) {
             return this.videoElement.currentTime;
         }
-        const { isDirectFile, manifest } = this._priv_contentInfos;
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, manifest = _a.manifest;
         if (isDirectFile) {
-            const startDate = (0, compat_1.getStartDate)(this.videoElement);
+            var startDate = getStartDate(this.videoElement);
             return (startDate !== null && startDate !== void 0 ? startDate : 0) + this.videoElement.currentTime;
         }
         if (manifest !== null) {
-            const currentTime = this.videoElement.currentTime;
-            const ast = manifest.availabilityStartTime !== undefined ?
+            var currentTime = this.videoElement.currentTime;
+            var ast = manifest.availabilityStartTime !== undefined ?
                 manifest.availabilityStartTime :
                 0;
             return currentTime + ast;
         }
         return 0;
-    }
+    };
     /**
      * Get the current position, in seconds, of the video element.
      *
@@ -737,27 +992,27 @@ class Player extends event_emitter_1.default {
      *
      * @returns {Number}
      */
-    getPosition() {
+    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}
      */
-    getLastStoredContentPosition() {
+    Player.prototype.getLastStoredContentPosition = function () {
         return this._priv_reloadingMetadata.reloadPosition;
-    }
+    };
     /**
      * Returns the current playback rate at which the video plays.
      * @returns {Number}
      */
-    getPlaybackRate() {
+    Player.prototype.getPlaybackRate = function () {
         return this._priv_speed.getValue();
-    }
+    };
     /**
      * Update the playback rate of the video.
      *
@@ -814,95 +1069,164 @@ class Player extends event_emitter_1.default {
      * @param {Number} rate
      * @param {Object} opts
      */
-    setPlaybackRate(rate, opts) {
+    Player.prototype.setPlaybackRate = function (rate, opts) {
         var _a;
         if (rate !== this._priv_speed.getValue()) {
             this._priv_speed.setValue(rate);
         }
-        const preferTrickModeTracks = opts === null || opts === void 0 ? void 0 : opts.preferTrickModeTracks;
+        var preferTrickModeTracks = opts === null || opts === void 0 ? void 0 : opts.preferTrickModeTracks;
         if (typeof preferTrickModeTracks !== "boolean") {
             return;
         }
         this._priv_preferTrickModeTracks = preferTrickModeTracks;
-        const 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();
+        var trackChoiceManager = (_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.trackChoiceManager;
+        if (!isNullOrUndefined(trackChoiceManager)) {
+            if (preferTrickModeTracks && !trackChoiceManager.isTrickModeEnabled()) {
+                trackChoiceManager.enableVideoTrickModeTracks();
             }
-            else if (!preferTrickModeTracks && tracksStore.isTrickModeEnabled()) {
-                tracksStore.disableVideoTrickModeTracks();
+            else if (!preferTrickModeTracks && trackChoiceManager.isTrickModeEnabled()) {
+                trackChoiceManager.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}
+     * Returns all available bitrates for the current video Adaptation.
+     * @returns {Array.<Number>}
+     */
+    Player.prototype.getAvailableVideoBitrates = function () {
+        if (this._priv_contentInfos === null) {
+            return [];
+        }
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, activeAdaptations = _a.activeAdaptations;
+        if (currentPeriod === null || activeAdaptations === null) {
+            return [];
+        }
+        var adaptations = activeAdaptations[currentPeriod.id];
+        if (adaptations === undefined || isNullOrUndefined(adaptations.video)) {
+            return [];
+        }
+        return adaptations.video.getAvailableBitrates();
+    };
+    /**
+     * Returns all available bitrates for the current audio Adaptation.
+     * @returns {Array.<Number>}
+     */
+    Player.prototype.getAvailableAudioBitrates = function () {
+        if (this._priv_contentInfos === null) {
+            return [];
+        }
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, activeAdaptations = _a.activeAdaptations;
+        if (currentPeriod === null || activeAdaptations === null) {
+            return [];
+        }
+        var adaptations = activeAdaptations[currentPeriod.id];
+        if (adaptations === undefined || isNullOrUndefined(adaptations.audio)) {
+            return [];
+        }
+        return adaptations.audio.getAvailableBitrates();
+    };
+    /**
+     * Returns the manual audio bitrate set. -1 if in AUTO mode.
+     * @returns {Number}
      */
-    getVideoRepresentation() {
-        const representations = this.__priv_getCurrentRepresentations();
-        if (representations === null) {
+    Player.prototype.getManualAudioBitrate = function () {
+        return this._priv_bitrateInfos.manualBitrates.audio.getValue();
+    };
+    /**
+     * Returns the manual video bitrate set. -1 if in AUTO mode.
+     * @returns {Number}
+     */
+    Player.prototype.getManualVideoBitrate = function () {
+        return this._priv_bitrateInfos.manualBitrates.video.getValue();
+    };
+    /**
+     * Returns currently considered bitrate for video segments.
+     * @returns {Number|undefined}
+     */
+    Player.prototype.getVideoBitrate = function () {
+        var representations = this._priv_getCurrentRepresentations();
+        if (representations === null || isNullOrUndefined(representations.video)) {
             return undefined;
         }
-        return representations.video;
-    }
+        return representations.video.bitrate;
+    };
     /**
-     * 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}
+     * Returns currently considered bitrate for audio segments.
+     * @returns {Number|undefined}
      */
-    getAudioRepresentation() {
-        const representations = this.__priv_getCurrentRepresentations();
-        if (representations === null) {
+    Player.prototype.getAudioBitrate = function () {
+        var representations = this._priv_getCurrentRepresentations();
+        if (representations === null || isNullOrUndefined(representations.audio)) {
             return undefined;
         }
-        return representations.audio;
-    }
+        return representations.audio.bitrate;
+    };
+    /**
+     * Returns minimum wanted video bitrate currently set.
+     * @returns {Number}
+     */
+    Player.prototype.getMinVideoBitrate = function () {
+        return this._priv_bitrateInfos.minAutoBitrates.video.getValue();
+    };
+    /**
+     * Returns minimum wanted audio bitrate currently set.
+     * @returns {Number}
+     */
+    Player.prototype.getMinAudioBitrate = function () {
+        return this._priv_bitrateInfos.minAutoBitrates.audio.getValue();
+    };
+    /**
+     * Returns maximum wanted video bitrate currently set.
+     * @returns {Number}
+     */
+    Player.prototype.getMaxVideoBitrate = function () {
+        return this._priv_bitrateInfos.maxAutoBitrates.video.getValue();
+    };
+    /**
+     * Returns maximum wanted audio bitrate currently set.
+     * @returns {Number}
+     */
+    Player.prototype.getMaxAudioBitrate = function () {
+        return this._priv_bitrateInfos.maxAutoBitrates.audio.getValue();
+    };
     /**
      * Play/Resume the current video.
      * @returns {Promise}
      */
-    play() {
+    Player.prototype.play = function () {
+        var _this = this;
         if (this.videoElement === null) {
             throw new Error("Disposed player");
         }
-        const playPromise = this.videoElement.play();
+        var playPromise = this.videoElement.play();
         /* eslint-disable @typescript-eslint/unbound-method */
-        if ((0, is_null_or_undefined_1.default)(playPromise) || typeof playPromise.catch !== "function") {
+        if (isNullOrUndefined(playPromise) || typeof playPromise.catch !== "function") {
             /* eslint-enable @typescript-eslint/unbound-method */
             return Promise.resolve();
         }
-        return playPromise.catch((error) => {
+        return playPromise.catch(function (error) {
             if (error.name === "NotAllowedError") {
-                const warning = new errors_1.MediaError("MEDIA_ERR_PLAY_NOT_ALLOWED", error.toString());
-                this.trigger("warning", warning);
+                var warning = new MediaError("MEDIA_ERR_PLAY_NOT_ALLOWED", error.toString());
+                _this.trigger("warning", warning);
             }
             throw error;
         });
-    }
+    };
     /**
      * Pause the current video.
      */
-    pause() {
+    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
      */
-    seekTo(time) {
+    Player.prototype.seekTo = function (time) {
         var _a;
         if (this.videoElement === null) {
             throw new Error("Disposed player");
@@ -910,29 +1234,29 @@ class Player extends event_emitter_1.default {
         if (this._priv_contentInfos === null) {
             throw new Error("player: no content loaded");
         }
-        const { isDirectFile, manifest } = this._priv_contentInfos;
+        var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, manifest = _b.manifest;
         if (!isDirectFile && manifest === null) {
             throw new Error("player: the content did not load yet");
         }
-        let positionWanted;
+        var positionWanted;
         if (typeof time === "number") {
             positionWanted = time;
         }
         else if (typeof time === "object") {
-            const timeObj = time;
-            const currentTs = this.videoElement.currentTime;
-            if (!(0, is_null_or_undefined_1.default)(timeObj.relative)) {
+            var timeObj = time;
+            var currentTs = this.videoElement.currentTime;
+            if (!isNullOrUndefined(timeObj.relative)) {
                 positionWanted = currentTs + timeObj.relative;
             }
-            else if (!(0, is_null_or_undefined_1.default)(timeObj.position)) {
+            else if (!isNullOrUndefined(timeObj.position)) {
                 positionWanted = timeObj.position;
             }
-            else if (!(0, is_null_or_undefined_1.default)(timeObj.wallClockTime)) {
+            else if (!isNullOrUndefined(timeObj.wallClockTime)) {
                 if (manifest !== null) {
                     positionWanted = timeObj.wallClockTime - ((_a = manifest.availabilityStartTime) !== null && _a !== void 0 ? _a : 0);
                 }
                 else if (isDirectFile && this.videoElement !== null) {
-                    const startDate = (0, compat_1.getStartDate)(this.videoElement);
+                    var startDate = getStartDate(this.videoElement);
                     if (startDate !== undefined) {
                         positionWanted = timeObj.wallClockTime - startDate;
                     }
@@ -950,129 +1274,241 @@ class Player extends event_emitter_1.default {
         if (positionWanted === undefined) {
             throw new Error("invalid time given");
         }
-        log_1.default.info("API: API Seek to", positionWanted);
+        log.info("API: API Seek to", positionWanted);
         this.videoElement.currentTime = positionWanted;
         return positionWanted;
-    }
+    };
+    /**
+     * Returns true if the media element is full screen.
+     * @deprecated
+     * @returns {Boolean}
+     */
+    Player.prototype.isFullscreen = function () {
+        warnOnce("isFullscreen is deprecated." +
+            " Fullscreen management should now be managed by the application");
+        return isFullscreen();
+    };
+    /**
+     * Set/exit fullScreen.
+     * @deprecated
+     * @param {Boolean} [goFull=true] - if false, exit full screen.
+     */
+    Player.prototype.setFullscreen = function (goFull) {
+        if (goFull === void 0) { goFull = true; }
+        warnOnce("setFullscreen is deprecated." +
+            " Fullscreen management should now be managed by the application");
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
+        }
+        if (goFull) {
+            requestFullscreen(this.videoElement);
+        }
+        else {
+            exitFullscreen();
+        }
+    };
+    /**
+     * Exit from full screen mode.
+     * @deprecated
+     */
+    Player.prototype.exitFullscreen = function () {
+        warnOnce("exitFullscreen is deprecated." +
+            " Fullscreen management should now be managed by the application");
+        exitFullscreen();
+    };
     /**
      * Returns the current player's audio volume on the media element.
      * From 0 (no audio) to 1 (maximum volume).
      * @returns {Number}
      */
-    getVolume() {
+    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
      */
-    setVolume(volume) {
+    Player.prototype.setVolume = function (volume) {
         if (this.videoElement === null) {
             throw new Error("Disposed player");
         }
-        const videoElement = this.videoElement;
+        var videoElement = this.videoElement;
         if (volume !== videoElement.volume) {
             videoElement.volume = volume;
             this.trigger("volumeChange", volume);
         }
-    }
+    };
     /**
      * Returns true if the volume is set to 0. false otherwise.
      * @returns {Boolean}
      */
-    isMute() {
+    Player.prototype.isMute = function () {
         return this.getVolume() === 0;
-    }
+    };
     /**
      * Set the volume to 0 and save current one for when unmuted.
      */
-    mute() {
+    Player.prototype.mute = function () {
         this._priv_mutedMemory = this.getVolume();
         this.setVolume(0);
-    }
+    };
     /**
      * Set the volume back to when it was when mute was last called.
      * If the volume was set to 0, set a default volume instead (see config).
      */
-    unMute() {
-        const { DEFAULT_UNMUTED_VOLUME } = config_1.default.getCurrent();
-        const vol = this.getVolume();
+    Player.prototype.unMute = function () {
+        var DEFAULT_UNMUTED_VOLUME = config.getCurrent().DEFAULT_UNMUTED_VOLUME;
+        var vol = this.getVolume();
         if (vol === 0) {
             this.setVolume(this._priv_mutedMemory === 0 ? DEFAULT_UNMUTED_VOLUME :
                 this._priv_mutedMemory);
         }
-    }
+    };
+    /**
+     * Force the video bitrate to a given value. Act as a ceil.
+     * -1 to set it on AUTO Mode
+     * @param {Number} btr
+     */
+    Player.prototype.setVideoBitrate = function (btr) {
+        this._priv_bitrateInfos.manualBitrates.video.setValue(btr);
+    };
+    /**
+     * Force the audio bitrate to a given value. Act as a ceil.
+     * -1 to set it on AUTO Mode
+     * @param {Number} btr
+     */
+    Player.prototype.setAudioBitrate = function (btr) {
+        this._priv_bitrateInfos.manualBitrates.audio.setValue(btr);
+    };
+    /**
+     * Update the minimum video bitrate the user can switch to.
+     * @param {Number} btr
+     */
+    Player.prototype.setMinVideoBitrate = function (btr) {
+        var maxVideoBitrate = this._priv_bitrateInfos.maxAutoBitrates.video.getValue();
+        if (btr > maxVideoBitrate) {
+            throw new Error("Invalid minimum video bitrate given. " +
+                "Its value, \"".concat(btr, "\" is superior the current maximum ") +
+                "video birate, \"".concat(maxVideoBitrate, "\"."));
+        }
+        this._priv_bitrateInfos.minAutoBitrates.video.setValue(btr);
+    };
+    /**
+     * Update the minimum audio bitrate the user can switch to.
+     * @param {Number} btr
+     */
+    Player.prototype.setMinAudioBitrate = function (btr) {
+        var maxAudioBitrate = this._priv_bitrateInfos.maxAutoBitrates.audio.getValue();
+        if (btr > maxAudioBitrate) {
+            throw new Error("Invalid minimum audio bitrate given. " +
+                "Its value, \"".concat(btr, "\" is superior the current maximum ") +
+                "audio birate, \"".concat(maxAudioBitrate, "\"."));
+        }
+        this._priv_bitrateInfos.minAutoBitrates.audio.setValue(btr);
+    };
+    /**
+     * Update the maximum video bitrate the user can switch to.
+     * @param {Number} btr
+     */
+    Player.prototype.setMaxVideoBitrate = function (btr) {
+        var minVideoBitrate = this._priv_bitrateInfos.minAutoBitrates.video.getValue();
+        if (btr < minVideoBitrate) {
+            throw new Error("Invalid maximum video bitrate given. " +
+                "Its value, \"".concat(btr, "\" is inferior the current minimum ") +
+                "video birate, \"".concat(minVideoBitrate, "\"."));
+        }
+        this._priv_bitrateInfos.maxAutoBitrates.video.setValue(btr);
+    };
+    /**
+     * Update the maximum audio bitrate the user can switch to.
+     * @param {Number} btr
+     */
+    Player.prototype.setMaxAudioBitrate = function (btr) {
+        var minAudioBitrate = this._priv_bitrateInfos.minAutoBitrates.audio.getValue();
+        if (btr < minAudioBitrate) {
+            throw new Error("Invalid maximum audio bitrate given. " +
+                "Its value, \"".concat(btr, "\" is inferior the current minimum ") +
+                "audio birate, \"".concat(minAudioBitrate, "\"."));
+        }
+        this._priv_bitrateInfos.maxAutoBitrates.audio.setValue(btr);
+    };
     /**
      * Set the max buffer size for the buffer behind the current position.
      * Every buffer data before will be removed.
      * @param {Number} depthInSeconds
      */
-    setMaxBufferBehind(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
      */
-    setMaxBufferAhead(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
      */
-    setWantedBufferAhead(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
      */
-    setMaxVideoBufferSize(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}
      */
-    getMaxBufferBehind() {
+    Player.prototype.getMaxBufferBehind = function () {
         return this._priv_bufferOptions.maxBufferBehind.getValue();
-    }
+    };
     /**
      * Returns the max buffer size for the buffer behind the current position.
      * @returns {Number}
      */
-    getMaxBufferAhead() {
+    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}
      */
-    getWantedBufferAhead() {
+    Player.prototype.getWantedBufferAhead = function () {
         return this._priv_bufferOptions.wantedBufferAhead.getValue();
-    }
+    };
     /**
      * Returns the max buffer memory size for the buffer in kilobytes
      * @returns {Number}
      */
-    getMaxVideoBufferSize() {
+    Player.prototype.getMaxVideoBufferSize = function () {
         return this._priv_bufferOptions.maxVideoBufferSize.getValue();
-    }
-    getCurrentPeriod() {
-        var _a;
-        const currentPeriod = (_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.currentPeriod;
-        if ((0, is_null_or_undefined_1.default)(currentPeriod)) {
-            return null;
+    };
+    /**
+     * Returns type of current keysystem (e.g. playready, widevine) if the content
+     * is encrypted. null otherwise.
+     * @deprecated
+     * @returns {string|null}
+     */
+    Player.prototype.getCurrentKeySystem = function () {
+        warnOnce("`getCurrentKeySystem` is deprecated." +
+            "Please use the `getKeySystemConfiguration` method instead.");
+        if (this.videoElement === null) {
+            throw new Error("Disposed player");
         }
-        return { id: currentPeriod.id, start: currentPeriod.start, end: currentPeriod.end };
-    }
+        return getCurrentKeySystem(this.videoElement);
+    };
     /**
      * Returns both the name of the key system (e.g. `"com.widevine.alpha"`) and
      * the `MediaKeySystemConfiguration` currently associated to the
@@ -1081,388 +1517,380 @@ class Player extends event_emitter_1.default {
      * Returns `null` if no such capabilities is associated or if unknown.
      * @returns {Object|null}
      */
-    getKeySystemConfiguration() {
+    Player.prototype.getKeySystemConfiguration = function () {
         if (this.videoElement === null) {
             throw new Error("Disposed player");
         }
-        const values = (0, decrypt_1.getKeySystemConfiguration)(this.videoElement);
+        var values = 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>}
+     * Returns every available audio tracks for the current Period.
+     * @returns {Array.<Object>|null}
      */
-    getAvailablePeriods() {
+    Player.prototype.getAvailableAudioTracks = function () {
+        var _a;
         if (this._priv_contentInfos === null) {
             return [];
         }
-        const { isDirectFile, tracksStore } = this._priv_contentInfos;
+        var _b = this._priv_contentInfos, currentPeriod = _b.currentPeriod, isDirectFile = _b.isDirectFile, trackChoiceManager = _b.trackChoiceManager, mediaElementTrackChoiceManager = _b.mediaElementTrackChoiceManager;
         if (isDirectFile) {
-            return [];
+            return (_a = mediaElementTrackChoiceManager === null || mediaElementTrackChoiceManager === void 0 ? void 0 : mediaElementTrackChoiceManager.getAvailableAudioTracks()) !== null && _a !== void 0 ? _a : [];
         }
-        if (tracksStore === null) {
+        if (trackChoiceManager === null || currentPeriod === null) {
             return [];
         }
-        return tracksStore.getAvailablePeriods().slice();
-    }
+        return trackChoiceManager.getAvailableAudioTracks(currentPeriod);
+    };
     /**
-     * Returns every available audio tracks for a given Period - or the current
-     * one if no `periodId` is given.
-     * @param {string|undefined} [periodId]
-     * @returns {Array.<Object>}
+     * Returns every available text tracks for the current Period.
+     * @returns {Array.<Object>|null}
      */
-    getAvailableAudioTracks(periodId) {
+    Player.prototype.getAvailableTextTracks = function () {
         var _a;
         if (this._priv_contentInfos === null) {
             return [];
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
+        var _b = this._priv_contentInfos, currentPeriod = _b.currentPeriod, isDirectFile = _b.isDirectFile, trackChoiceManager = _b.trackChoiceManager, mediaElementTrackChoiceManager = _b.mediaElementTrackChoiceManager;
         if (isDirectFile) {
-            return (_a = mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.getAvailableAudioTracks()) !== null && _a !== void 0 ? _a : [];
+            return (_a = mediaElementTrackChoiceManager === null || mediaElementTrackChoiceManager === void 0 ? void 0 : mediaElementTrackChoiceManager.getAvailableTextTracks()) !== null && _a !== void 0 ? _a : [];
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, [], (tcm, periodRef) => { var _a; return (_a = tcm.getAvailableAudioTracks(periodRef)) !== 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>}
-     */
-    getAvailableTextTracks(periodId) {
-        var _a;
-        if (this._priv_contentInfos === null) {
+        if (trackChoiceManager === null || currentPeriod === null) {
             return [];
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
-        if (isDirectFile) {
-            return (_a = mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.getAvailableTextTracks()) !== null && _a !== void 0 ? _a : [];
-        }
-        return this._priv_callTracksStoreGetterSetter(periodId, [], (tcm, periodRef) => { var _a; return (_a = tcm.getAvailableTextTracks(periodRef)) !== null && _a !== void 0 ? _a : []; });
-    }
+        return trackChoiceManager.getAvailableTextTracks(currentPeriod);
+    };
     /**
      * Returns every available video tracks for the current Period.
-     * @param {string|undefined} [periodId]
-     * @returns {Array.<Object>}
+     * @returns {Array.<Object>|null}
      */
-    getAvailableVideoTracks(periodId) {
+    Player.prototype.getAvailableVideoTracks = function () {
         var _a;
         if (this._priv_contentInfos === null) {
             return [];
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
+        var _b = this._priv_contentInfos, currentPeriod = _b.currentPeriod, isDirectFile = _b.isDirectFile, trackChoiceManager = _b.trackChoiceManager, mediaElementTrackChoiceManager = _b.mediaElementTrackChoiceManager;
         if (isDirectFile) {
-            return (_a = mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.getAvailableVideoTracks()) !== null && _a !== void 0 ? _a : [];
+            return (_a = mediaElementTrackChoiceManager === null || mediaElementTrackChoiceManager === void 0 ? void 0 : mediaElementTrackChoiceManager.getAvailableVideoTracks()) !== null && _a !== void 0 ? _a : [];
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, [], (tcm, periodRef) => { var _a; return (_a = tcm.getAvailableVideoTracks(periodRef)) !== null && _a !== void 0 ? _a : []; });
-    }
+        if (trackChoiceManager === null || currentPeriod === null) {
+            return [];
+        }
+        return trackChoiceManager.getAvailableVideoTracks(currentPeriod);
+    };
     /**
      * Returns currently chosen audio language for the current Period.
-     * @param {string|undefined} [periodId]
-     * @returns {Object|null|undefined}
+     * @returns {string}
      */
-    getAudioTrack(periodId) {
+    Player.prototype.getAudioTrack = function () {
         if (this._priv_contentInfos === null) {
             return undefined;
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, isDirectFile = _a.isDirectFile, trackChoiceManager = _a.trackChoiceManager, mediaElementTrackChoiceManager = _a.mediaElementTrackChoiceManager;
         if (isDirectFile) {
-            if (mediaElementTracksStore === null) {
+            if (mediaElementTrackChoiceManager === null) {
                 return undefined;
             }
-            return mediaElementTracksStore.getChosenAudioTrack();
+            return mediaElementTrackChoiceManager.getChosenAudioTrack();
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.getChosenAudioTrack(periodRef));
-    }
+        if (trackChoiceManager === null || currentPeriod === null) {
+            return undefined;
+        }
+        return trackChoiceManager.getChosenAudioTrack(currentPeriod);
+    };
     /**
      * Returns currently chosen subtitle for the current Period.
-     * @param {string|undefined} [periodId]
-     * @returns {Object|null|undefined}
+     * @returns {string}
      */
-    getTextTrack(periodId) {
+    Player.prototype.getTextTrack = function () {
         if (this._priv_contentInfos === null) {
             return undefined;
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, isDirectFile = _a.isDirectFile, trackChoiceManager = _a.trackChoiceManager, mediaElementTrackChoiceManager = _a.mediaElementTrackChoiceManager;
         if (isDirectFile) {
-            if (mediaElementTracksStore === null) {
+            if (mediaElementTrackChoiceManager === null) {
                 return undefined;
             }
-            return mediaElementTracksStore.getChosenTextTrack();
+            return mediaElementTrackChoiceManager.getChosenTextTrack();
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.getChosenTextTrack(periodRef));
-    }
+        if (trackChoiceManager === null || currentPeriod === null) {
+            return undefined;
+        }
+        return trackChoiceManager.getChosenTextTrack(currentPeriod);
+    };
     /**
      * Returns currently chosen video track for the current Period.
-     * @param {string|undefined} [periodId]
-     * @returns {Object|null|undefined}
+     * @returns {string}
      */
-    getVideoTrack(periodId) {
+    Player.prototype.getVideoTrack = function () {
         if (this._priv_contentInfos === null) {
             return undefined;
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, isDirectFile = _a.isDirectFile, trackChoiceManager = _a.trackChoiceManager, mediaElementTrackChoiceManager = _a.mediaElementTrackChoiceManager;
         if (isDirectFile) {
-            if (mediaElementTracksStore === null) {
+            if (mediaElementTrackChoiceManager === null) {
                 return undefined;
             }
-            return mediaElementTracksStore.getChosenVideoTrack();
+            return mediaElementTrackChoiceManager.getChosenVideoTrack();
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.getChosenVideoTrack(periodRef));
-    }
+        if (trackChoiceManager === null || currentPeriod === null) {
+            return undefined;
+        }
+        return trackChoiceManager.getChosenVideoTrack(currentPeriod);
+    };
     /**
      * Update the audio language for the current Period.
-     * @param {string | object} arg
-     * @throws Error - the current content has no TracksStore.
+     * @param {string} audioId
+     * @throws Error - the current content has no TrackChoiceManager.
      * @throws Error - the given id is linked to no audio track.
      */
-    setAudioTrack(arg) {
-        var _a;
+    Player.prototype.setAudioTrack = function (audioId) {
         if (this._priv_contentInfos === null) {
             throw new Error("No content loaded");
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, isDirectFile = _a.isDirectFile, trackChoiceManager = _a.trackChoiceManager, mediaElementTrackChoiceManager = _a.mediaElementTrackChoiceManager;
         if (isDirectFile) {
             try {
-                const audioId = typeof arg === "string" ? arg :
-                    arg.trackId;
-                mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.setAudioTrackById(audioId);
+                mediaElementTrackChoiceManager === null || mediaElementTrackChoiceManager === void 0 ? void 0 : mediaElementTrackChoiceManager.setAudioTrackById(audioId);
                 return;
             }
             catch (e) {
                 throw new Error("player: unknown audio track");
             }
         }
-        let periodId;
-        let trackId;
-        let switchingMode;
-        let reprsToLock = null;
-        if (typeof arg === "string") {
-            trackId = arg;
+        if (trackChoiceManager === null || currentPeriod === null) {
+            throw new Error("No compatible content launched.");
         }
-        else {
-            trackId = arg.trackId;
-            periodId = arg.periodId;
-            switchingMode = arg.switchingMode;
-            reprsToLock = (_a = arg.lockedRepresentations) !== null && _a !== void 0 ? _a : null;
+        try {
+            trackChoiceManager.setAudioTrackByID(currentPeriod, audioId);
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.setAudioTrack(periodRef, trackId, switchingMode, reprsToLock));
-    }
+        catch (e) {
+            throw new Error("player: unknown audio track");
+        }
+    };
     /**
      * Update the text language for the current Period.
-     * @param {string | Object} arg
-     * @throws Error - the current content has no TracksStore.
+     * @param {string} sub
+     * @throws Error - the current content has no TrackChoiceManager.
      * @throws Error - the given id is linked to no text track.
      */
-    setTextTrack(arg) {
+    Player.prototype.setTextTrack = function (textId) {
         if (this._priv_contentInfos === null) {
             throw new Error("No content loaded");
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, isDirectFile = _a.isDirectFile, trackChoiceManager = _a.trackChoiceManager, mediaElementTrackChoiceManager = _a.mediaElementTrackChoiceManager;
         if (isDirectFile) {
             try {
-                const textId = typeof arg === "string" ? arg :
-                    arg.trackId;
-                mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.setTextTrackById(textId);
+                mediaElementTrackChoiceManager === null || mediaElementTrackChoiceManager === void 0 ? void 0 : mediaElementTrackChoiceManager.setTextTrackById(textId);
                 return;
             }
             catch (e) {
                 throw new Error("player: unknown text track");
             }
         }
-        let periodId;
-        let trackId;
-        if (typeof arg === "string") {
-            trackId = arg;
+        if (trackChoiceManager === null || currentPeriod === null) {
+            throw new Error("No compatible content launched.");
         }
-        else {
-            trackId = arg.trackId;
-            periodId = arg.periodId;
+        try {
+            trackChoiceManager.setTextTrackByID(currentPeriod, textId);
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.setTextTrack(periodRef, trackId));
-    }
+        catch (e) {
+            throw new Error("player: unknown text track");
+        }
+    };
     /**
      * Disable subtitles for the current content.
-     * @param {string|undefined} [periodId]
      */
-    disableTextTrack(periodId) {
+    Player.prototype.disableTextTrack = function () {
         if (this._priv_contentInfos === null) {
             return;
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, isDirectFile = _a.isDirectFile, trackChoiceManager = _a.trackChoiceManager, mediaElementTrackChoiceManager = _a.mediaElementTrackChoiceManager;
         if (isDirectFile) {
-            mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.disableTextTrack();
+            mediaElementTrackChoiceManager === null || mediaElementTrackChoiceManager === void 0 ? void 0 : mediaElementTrackChoiceManager.disableTextTrack();
             return;
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.disableTrack(periodRef, "text"));
-    }
+        if (trackChoiceManager === null || currentPeriod === null) {
+            return;
+        }
+        return trackChoiceManager.disableTextTrack(currentPeriod);
+    };
     /**
      * Update the video track for the current Period.
-     * @param {string | Object} arg
-     * @throws Error - the current content has no TracksStore.
+     * @param {string} videoId
+     * @throws Error - the current content has no TrackChoiceManager.
      * @throws Error - the given id is linked to no video track.
      */
-    setVideoTrack(arg) {
-        var _a;
+    Player.prototype.setVideoTrack = function (videoId) {
         if (this._priv_contentInfos === null) {
             throw new Error("No content loaded");
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, isDirectFile = _a.isDirectFile, trackChoiceManager = _a.trackChoiceManager, mediaElementTrackChoiceManager = _a.mediaElementTrackChoiceManager;
         if (isDirectFile) {
             try {
-                const videoId = typeof arg === "string" ? arg :
-                    arg.trackId;
-                mediaElementTracksStore === null || mediaElementTracksStore === void 0 ? void 0 : mediaElementTracksStore.setVideoTrackById(videoId);
+                mediaElementTrackChoiceManager === null || mediaElementTrackChoiceManager === void 0 ? void 0 : mediaElementTrackChoiceManager.setVideoTrackById(videoId);
                 return;
             }
             catch (e) {
                 throw new Error("player: unknown video track");
             }
         }
-        let periodId;
-        let trackId;
-        let switchingMode;
-        let reprsToLock = null;
-        if (typeof arg === "string") {
-            trackId = arg;
+        if (trackChoiceManager === null || currentPeriod === null) {
+            throw new Error("No compatible content launched.");
         }
-        else {
-            trackId = arg.trackId;
-            periodId = arg.periodId;
-            switchingMode = arg.switchingMode;
-            reprsToLock = (_a = arg.lockedRepresentations) !== null && _a !== void 0 ? _a : null;
+        try {
+            trackChoiceManager.setVideoTrackByID(currentPeriod, videoId);
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.setVideoTrack(periodRef, trackId, switchingMode, reprsToLock));
-    }
+        catch (e) {
+            throw new Error("player: unknown video track");
+        }
+    };
     /**
      * Disable video track for the current content.
-     * @param {string|undefined} [periodId]
      */
-    disableVideoTrack(periodId) {
+    Player.prototype.disableVideoTrack = function () {
         if (this._priv_contentInfos === null) {
             return;
         }
-        const { isDirectFile, mediaElementTracksStore } = this._priv_contentInfos;
-        if (isDirectFile && mediaElementTracksStore !== null) {
-            return mediaElementTracksStore.disableVideoTrack();
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, isDirectFile = _a.isDirectFile, trackChoiceManager = _a.trackChoiceManager, mediaElementTrackChoiceManager = _a.mediaElementTrackChoiceManager;
+        if (isDirectFile && mediaElementTrackChoiceManager !== null) {
+            return mediaElementTrackChoiceManager.disableVideoTrack();
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.disableTrack(periodRef, "video"));
-    }
-    lockVideoRepresentations(arg) {
-        if (this._priv_contentInfos === null) {
-            throw new Error("No content loaded");
+        if (trackChoiceManager === null || currentPeriod === null) {
+            return;
         }
-        const { isDirectFile } = this._priv_contentInfos;
-        if (isDirectFile) {
-            throw new Error("Cannot lock video Representations in directfile mode.");
+        return trackChoiceManager.disableVideoTrack(currentPeriod);
+    };
+    /**
+     * Returns the current list of preferred audio tracks, in preference order.
+     * @returns {Array.<Object>}
+     */
+    Player.prototype.getPreferredAudioTracks = function () {
+        return this._priv_preferredAudioTracks;
+    };
+    /**
+     * Returns the current list of preferred text tracks, in preference order.
+     * @returns {Array.<Object>}
+     */
+    Player.prototype.getPreferredTextTracks = function () {
+        return this._priv_preferredTextTracks;
+    };
+    /**
+     * Returns the current list of preferred text tracks, in preference order.
+     * @returns {Array.<Object>}
+     */
+    Player.prototype.getPreferredVideoTracks = function () {
+        return this._priv_preferredVideoTracks;
+    };
+    /**
+     * Set the list of preferred audio tracks, in preference order.
+     * @param {Array.<Object>} tracks
+     * @param {boolean} shouldApply - `true` if those preferences should be
+     * applied on the currently loaded Period. `false` if it should only
+     * be applied to new content.
+     */
+    Player.prototype.setPreferredAudioTracks = function (tracks, shouldApply) {
+        if (shouldApply === void 0) { shouldApply = false; }
+        if (!Array.isArray(tracks)) {
+            throw new Error("Invalid `setPreferredAudioTracks` argument. " +
+                "Should have been an Array.");
         }
-        let repsId;
-        let periodId;
-        let switchingMode;
-        if (Array.isArray(arg)) {
-            repsId = arg;
-            periodId = undefined;
+        this._priv_preferredAudioTracks = tracks;
+        var contentInfos = this._priv_contentInfos;
+        if (!isNullOrUndefined(contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.trackChoiceManager)) {
+            contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.trackChoiceManager.setPreferredAudioTracks(tracks, shouldApply);
         }
-        else {
-            repsId = arg.representations;
-            periodId = arg.periodId;
-            switchingMode = arg.switchingMode;
+        else if (!isNullOrUndefined(contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.mediaElementTrackChoiceManager)) {
+            contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.mediaElementTrackChoiceManager.setPreferredAudioTracks(tracks, shouldApply);
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.lockVideoRepresentations(periodRef, { representations: repsId,
-            switchingMode }));
-    }
-    lockAudioRepresentations(arg) {
-        if (this._priv_contentInfos === null) {
-            throw new Error("No content loaded");
+    };
+    /**
+     * Set the list of preferred text tracks, in preference order.
+     * @param {Array.<Object>} tracks
+     * @param {boolean} shouldApply - `true` if those preferences should be
+     * applied on the currently loaded Periods. `false` if it should only
+     * be applied to new content.
+     */
+    Player.prototype.setPreferredTextTracks = function (tracks, shouldApply) {
+        if (shouldApply === void 0) { shouldApply = false; }
+        if (!Array.isArray(tracks)) {
+            throw new Error("Invalid `setPreferredTextTracks` argument. " +
+                "Should have been an Array.");
         }
-        const { isDirectFile } = this._priv_contentInfos;
-        if (isDirectFile) {
-            throw new Error("Cannot lock audio Representations in directfile mode.");
+        this._priv_preferredTextTracks = tracks;
+        var contentInfos = this._priv_contentInfos;
+        if (!isNullOrUndefined(contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.trackChoiceManager)) {
+            contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.trackChoiceManager.setPreferredTextTracks(tracks, shouldApply);
         }
-        let repsId;
-        let periodId;
-        let switchingMode;
-        if (Array.isArray(arg)) {
-            repsId = arg;
-            periodId = undefined;
+        else if (!isNullOrUndefined(contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.mediaElementTrackChoiceManager)) {
+            contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.mediaElementTrackChoiceManager.setPreferredTextTracks(tracks, shouldApply);
         }
-        else {
-            repsId = arg.representations;
-            periodId = arg.periodId;
-            switchingMode = arg.switchingMode;
+    };
+    /**
+     * Set the list of preferred text tracks, in preference order.
+     * @param {Array.<Object>} tracks
+     * @param {boolean} shouldApply - `true` if those preferences should be
+     * applied on the currently loaded Period. `false` if it should only
+     * be applied to new content.
+     */
+    Player.prototype.setPreferredVideoTracks = function (tracks, shouldApply) {
+        if (shouldApply === void 0) { shouldApply = false; }
+        if (!Array.isArray(tracks)) {
+            throw new Error("Invalid `setPreferredVideoTracks` argument. " +
+                "Should have been an Array.");
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.lockAudioRepresentations(periodRef, { representations: repsId,
-            switchingMode }));
-    }
-    getLockedVideoRepresentations(periodId) {
-        if (this._priv_contentInfos === null) {
-            return null;
+        this._priv_preferredVideoTracks = tracks;
+        var contentInfos = this._priv_contentInfos;
+        if (!isNullOrUndefined(contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.trackChoiceManager)) {
+            contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.trackChoiceManager.setPreferredVideoTracks(tracks, shouldApply);
         }
-        const { isDirectFile } = this._priv_contentInfos;
-        if (isDirectFile) {
-            return null;
+        else if (!isNullOrUndefined(contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.mediaElementTrackChoiceManager)) {
+            contentInfos === null || contentInfos === void 0 ? void 0 : contentInfos.mediaElementTrackChoiceManager.setPreferredVideoTracks(tracks, shouldApply);
         }
-        return this._priv_callTracksStoreGetterSetter(periodId, null, (tcm, periodRef) => tcm.getLockedVideoRepresentations(periodRef));
-    }
-    getLockedAudioRepresentations(periodId) {
+    };
+    /**
+     * @returns {Array.<Object>|null}
+     * @deprecated
+     */
+    Player.prototype.getImageTrackData = function () {
+        warnOnce("`getImageTrackData` is deprecated." +
+            "Please use the `parseBifThumbnails` tool instead.");
         if (this._priv_contentInfos === null) {
             return null;
         }
-        const { isDirectFile } = this._priv_contentInfos;
-        if (isDirectFile) {
-            return null;
-        }
-        return this._priv_callTracksStoreGetterSetter(periodId, null, (tcm, periodRef) => tcm.getLockedAudioRepresentations(periodRef));
-    }
-    unlockVideoRepresentations(periodId) {
-        if (this._priv_contentInfos === null) {
-            return;
-        }
-        const { isDirectFile } = this._priv_contentInfos;
-        if (isDirectFile) {
-            return;
-        }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.unlockVideoRepresentations(periodRef));
-    }
-    unlockAudioRepresentations(periodId) {
-        if (this._priv_contentInfos === null) {
-            return;
-        }
-        const { isDirectFile } = this._priv_contentInfos;
-        if (isDirectFile) {
-            return;
-        }
-        return this._priv_callTracksStoreGetterSetter(periodId, undefined, (tcm, periodRef) => tcm.unlockAudioRepresentations(periodRef));
-    }
+        /* eslint-disable import/no-deprecated */
+        return this._priv_contentInfos.thumbnails;
+        /* eslint-enable import/no-deprecated */
+    };
     /**
      * Get minimum seek-able position.
      * @returns {number}
      */
-    getMinimumPosition() {
+    Player.prototype.getMinimumPosition = function () {
         if (this._priv_contentInfos === null) {
             return null;
         }
         if (this._priv_contentInfos.isDirectFile) {
             return 0;
         }
-        const { manifest } = this._priv_contentInfos;
+        var manifest = this._priv_contentInfos.manifest;
         if (manifest !== null) {
             return manifest.getMinimumSafePosition();
         }
         return null;
-    }
+    };
     /**
      * Get maximum seek-able position.
      * @returns {number}
      */
-    getMaximumPosition() {
+    Player.prototype.getMaximumPosition = function () {
         if (this._priv_contentInfos === null) {
             return null;
         }
-        const { isDirectFile, manifest } = this._priv_contentInfos;
+        var _a = this._priv_contentInfos, isDirectFile = _a.isDirectFile, manifest = _a.manifest;
         if (isDirectFile) {
             if (this.videoElement === null) {
                 throw new Error("Disposed player");
@@ -1476,13 +1904,7 @@ class Player extends event_emitter_1.default {
             return manifest.getMaximumSafePosition();
         }
         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.
+    };
     /**
      * /!\ For demo use only! Do not touch!
      *
@@ -1491,83 +1913,42 @@ class Player extends event_emitter_1.default {
      * @param {string} bufferType
      * @returns {Array.<Object>|null}
      */
-    __priv_getSegmentBufferContent(bufferType) {
+    Player.prototype.__priv_getSegmentBufferContent = function (bufferType) {
         if (this._priv_contentInfos === null ||
             this._priv_contentInfos.segmentBuffersStore === null) {
             return null;
         }
-        const segmentBufferStatus = this._priv_contentInfos
+        var segmentBufferStatus = this._priv_contentInfos
             .segmentBuffersStore.getStatus(bufferType);
         return segmentBufferStatus.type === "initialized" ?
             segmentBufferStatus.value.getInventory() :
             null;
-    }
-    /**
-     * /!\ 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
-    __priv_getManifest() {
-        if (this._priv_contentInfos === null) {
-            return null;
-        }
-        return this._priv_contentInfos.manifest;
-    }
-    // TODO remove the need for that public method
-    __priv_getCurrentAdaptation() {
-        if (this._priv_contentInfos === null) {
-            return null;
-        }
-        const { currentPeriod, activeAdaptations } = this._priv_contentInfos;
-        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
-    __priv_getCurrentRepresentations() {
-        if (this._priv_contentInfos === null) {
-            return null;
-        }
-        const { currentPeriod, activeRepresentations } = this._priv_contentInfos;
-        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.
      */
-    _priv_cleanUpCurrentContentState() {
-        var _a, _b, _c, _d;
-        log_1.default.debug("Locking `contentLock` to clean-up the current content.");
+    Player.prototype._priv_cleanUpCurrentContentState = function () {
+        var _this = this;
+        var _a, _b;
+        log.debug("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();
+        (_b = (_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.mediaElementTrackChoiceManager) === null || _b === void 0 ? void 0 : _b.dispose();
         this._priv_contentInfos = null;
         this._priv_contentEventsMemory = {};
         // DRM-related clean-up
-        const freeUpContentLock = () => {
-            if (this.videoElement !== null) { // If not disposed
-                log_1.default.debug("Unlocking `contentLock`. Next content can begin.");
-                this._priv_contentLock.setValue(false);
+        var freeUpContentLock = function () {
+            if (_this.videoElement !== null) { // If not disposed
+                log.debug("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(() => {
-                log_1.default.debug("API: DRM session cleaned-up with success!");
+        if (!isNullOrUndefined(this.videoElement)) {
+            clearOnStop(this.videoElement).then(function () {
+                log.debug("API: DRM session cleaned-up with success!");
                 freeUpContentLock();
-            }, (err) => {
-                log_1.default.error("API: An error arised when trying to clean-up the DRM session:" +
+            }, function (err) {
+                log.error("API: An error arised when trying to clean-up the DRM session:" +
                     (err instanceof Error ? err.toString() :
                         "Unknown Error"));
                 freeUpContentLock();
@@ -1576,121 +1957,65 @@ class Player extends event_emitter_1.default {
         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
      */
-    _priv_onManifestReady(contentInfos, 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;
+        var cancelSignal = contentInfos.currentContentCanceller.signal;
         this._priv_reloadingMetadata.manifest = manifest;
-        const tracksStore = new tracks_store_1.default({
+        var initialAudioTrack = contentInfos.initialAudioTrack, initialTextTrack = contentInfos.initialTextTrack;
+        contentInfos.trackChoiceManager = new TrackChoiceManager({
             preferTrickModeTracks: this._priv_preferTrickModeTracks,
-            defaultAudioTrackSwitchingMode: contentInfos.defaultAudioTrackSwitchingMode,
-        });
-        contentInfos.tracksStore = tracksStore;
-        tracksStore.addEventListener("newAvailablePeriods", (p) => {
-            this.trigger("newAvailablePeriods", p);
-        });
-        tracksStore.addEventListener("brokenRepresentationsLock", (e) => {
-            this.trigger("brokenRepresentationsLock", e);
-        });
-        tracksStore.addEventListener("trackUpdate", (e) => {
-            var _a, _b;
-            this.trigger("trackUpdate", e);
-            const 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);
-            }
-        });
-        contentInfos.tracksStore.addEventListener("warning", (err) => {
-            this.trigger("warning", err);
         });
-        contentInfos.tracksStore.addEventListener("error", (err) => {
-            this._priv_onFatalError(err, contentInfos);
-        });
-        contentInfos.tracksStore.updatePeriodList(manifest);
-        manifest.addEventListener("manifestUpdate", (updates) => {
+        var preferredAudioTracks = initialAudioTrack === undefined ?
+            this._priv_preferredAudioTracks :
+            [initialAudioTrack];
+        contentInfos.trackChoiceManager.setPreferredAudioTracks(preferredAudioTracks, true);
+        var preferredTextTracks = initialTextTrack === undefined ?
+            this._priv_preferredTextTracks :
+            [initialTextTrack];
+        contentInfos.trackChoiceManager.setPreferredTextTracks(preferredTextTracks, true);
+        contentInfos.trackChoiceManager
+            .setPreferredVideoTracks(this._priv_preferredVideoTracks, true);
+        manifest.addEventListener("manifestUpdate", function (updates) {
             var _a, _b, _c;
             // 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.updatePeriodList(manifest);
+            if (contentInfos.trackChoiceManager !== null) {
+                contentInfos.trackChoiceManager.update();
             }
-            const currentPeriod = (_b = (_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.currentPeriod) !== null && _b !== void 0 ? _b : undefined;
-            const currTracksStore = (_c = this._priv_contentInfos) === null || _c === void 0 ? void 0 : _c.tracksStore;
-            if (currentPeriod === undefined || (0, is_null_or_undefined_1.default)(currTracksStore)) {
+            var currentPeriod = (_b = (_a = _this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.currentPeriod) !== null && _b !== void 0 ? _b : undefined;
+            var trackChoiceManager = (_c = _this._priv_contentInfos) === null || _c === void 0 ? void 0 : _c.trackChoiceManager;
+            if (currentPeriod === undefined || isNullOrUndefined(trackChoiceManager)) {
                 return;
             }
-            for (const update of updates.updatedPeriods) {
+            for (var _i = 0, _d = updates.updatedPeriods; _i < _d.length; _i++) {
+                var update = _d[_i];
                 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
-                        const periodRef = currTracksStore.getPeriodObjectFromPeriod(currentPeriod);
-                        if (periodRef === undefined) {
-                            return;
-                        }
-                        this._priv_onAvailableTracksMayHaveChanged("audio");
-                        this._priv_onAvailableTracksMayHaveChanged("text");
-                        this._priv_onAvailableTracksMayHaveChanged("video");
+                        var audioTracks = trackChoiceManager.getAvailableAudioTracks(currentPeriod);
+                        _this._priv_triggerEventIfNotStopped("availableAudioTracksChange", audioTracks !== null && audioTracks !== void 0 ? audioTracks : [], cancelSignal);
+                        var textTracks = trackChoiceManager.getAvailableTextTracks(currentPeriod);
+                        _this._priv_triggerEventIfNotStopped("availableTextTracksChange", textTracks !== null && textTracks !== void 0 ? textTracks : [], cancelSignal);
+                        var videoTracks = trackChoiceManager.getAvailableVideoTracks(currentPeriod);
+                        _this._priv_triggerEventIfNotStopped("availableVideoTracksChange", videoTracks !== null && videoTracks !== void 0 ? videoTracks : [], cancelSignal);
                     }
                 }
                 return;
             }
         }, contentInfos.currentContentCanceller.signal);
-        manifest.addEventListener("decipherabilityUpdate", (elts) => {
-            /**
-             * Array of tuples only including once the Period/Track combination, and
-             * only when it concerns the currently-selected track.
-             */
-            const periodsAndTrackTypes = elts.reduce((acc, elt) => {
-                var _a, _b, _c;
-                const isFound = (0, array_find_1.default)(acc, (x) => 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.
-                    const tStore = contentInfos.tracksStore;
-                    if (tStore === null) {
-                        return acc;
-                    }
-                    let isCurrent = false;
-                    const periodRef = tStore.getPeriodObjectFromPeriod(elt.period);
-                    if (periodRef === undefined) {
-                        return acc;
-                    }
-                    switch (elt.adaptation.type) {
-                        case "audio":
-                            isCurrent = ((_a = tStore
-                                .getChosenAudioTrack(periodRef)) === null || _a === void 0 ? void 0 : _a.id) === elt.adaptation.id;
-                            break;
-                        case "video":
-                            isCurrent = ((_b = tStore
-                                .getChosenVideoTrack(periodRef)) === 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;
-            }, []);
-            for (const [period, trackType] of periodsAndTrackTypes) {
-                this._priv_triggerEventIfNotStopped("representationListUpdate", { period, trackType, reason: "decipherability-update" }, contentInfos.currentContentCanceller.signal);
-            }
-        }, contentInfos.currentContentCanceller.signal);
-    }
+    };
     /**
      * Triggered each times the current Period Changed.
      * Store and emit initial state for the Period.
@@ -1698,115 +2023,148 @@ class Player extends event_emitter_1.default {
      * @param {Object} contentInfos
      * @param {Object} periodInfo
      */
-    _priv_onActivePeriodChanged(contentInfos, { period }) {
-        var _a, _b, _c, _d, _e, _f;
-        if (contentInfos.contentId !== ((_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.contentId)) {
+    Player.prototype._priv_onActivePeriodChanged = function (contentInfos, _a) {
+        var _b, _c, _d, _e, _f, _g, _h, _j;
+        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;
-        const cancelSignal = contentInfos.currentContentCanceller.signal;
+        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("periodChange", period, cancelSignal);
         }
         this._priv_triggerEventIfNotStopped("availableAudioTracksChange", this.getAvailableAudioTracks(), cancelSignal);
         this._priv_triggerEventIfNotStopped("availableTextTracksChange", this.getAvailableTextTracks(), cancelSignal);
         this._priv_triggerEventIfNotStopped("availableVideoTracksChange", this.getAvailableVideoTracks(), cancelSignal);
-        const tracksStore = (_b = this._priv_contentInfos) === null || _b === void 0 ? void 0 : _b.tracksStore;
-        // Emit initial events for the Period
-        if (!(0, is_null_or_undefined_1.default)(tracksStore)) {
-            const periodRef = tracksStore.getPeriodObjectFromPeriod(period);
-            if (periodRef) {
-                const audioTrack = tracksStore.getChosenAudioTrack(periodRef);
-                this._priv_triggerEventIfNotStopped("audioTrackChange", audioTrack, cancelSignal);
-                const textTrack = tracksStore.getChosenTextTrack(periodRef);
-                this._priv_triggerEventIfNotStopped("textTrackChange", textTrack, cancelSignal);
-                const videoTrack = tracksStore.getChosenVideoTrack(periodRef);
-                this._priv_triggerEventIfNotStopped("videoTrackChange", videoTrack, cancelSignal);
-            }
+        var trackChoiceManager = (_c = this._priv_contentInfos) === null || _c === void 0 ? void 0 : _c.trackChoiceManager;
+        // Emit intial events for the Period
+        if (!isNullOrUndefined(trackChoiceManager)) {
+            var audioTrack = trackChoiceManager.getChosenAudioTrack(period);
+            this._priv_triggerEventIfNotStopped("audioTrackChange", audioTrack, cancelSignal);
+            var textTrack = trackChoiceManager.getChosenTextTrack(period);
+            this._priv_triggerEventIfNotStopped("textTrackChange", textTrack, cancelSignal);
+            var videoTrack = trackChoiceManager.getChosenVideoTrack(period);
+            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);
         }
-        const audioRepresentation = (_d = (_c = this.__priv_getCurrentRepresentations()) === null || _c === void 0 ? void 0 : _c.audio) !== null && _d !== void 0 ? _d : null;
-        this._priv_triggerEventIfNotStopped("audioRepresentationChange", audioRepresentation, cancelSignal);
-        const videoRepresentation = (_f = (_e = this.__priv_getCurrentRepresentations()) === null || _e === void 0 ? void 0 : _e.video) !== null && _f !== void 0 ? _f : null;
-        this._priv_triggerEventIfNotStopped("videoRepresentationChange", videoRepresentation, cancelSignal);
-    }
+        this._priv_triggerAvailableBitratesChangeEvent("availableAudioBitratesChange", this.getAvailableAudioBitrates(), cancelSignal);
+        if (contentInfos.currentContentCanceller.isUsed()) {
+            return;
+        }
+        this._priv_triggerAvailableBitratesChangeEvent("availableVideoBitratesChange", this.getAvailableVideoBitrates(), cancelSignal);
+        if (contentInfos.currentContentCanceller.isUsed()) {
+            return;
+        }
+        var audioBitrate = (_f = (_e = (_d = this._priv_getCurrentRepresentations()) === null || _d === void 0 ? void 0 : _d.audio) === null || _e === void 0 ? void 0 : _e.bitrate) !== null && _f !== void 0 ? _f : -1;
+        this._priv_triggerCurrentBitrateChangeEvent("audioBitrateChange", audioBitrate, cancelSignal);
+        if (contentInfos.currentContentCanceller.isUsed()) {
+            return;
+        }
+        var videoBitrate = (_j = (_h = (_g = this._priv_getCurrentRepresentations()) === null || _g === void 0 ? void 0 : _g.video) === null || _h === void 0 ? void 0 : _h.bitrate) !== null && _j !== void 0 ? _j : -1;
+        this._priv_triggerCurrentBitrateChangeEvent("videoBitrateChange", videoBitrate, 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
      */
-    _priv_onPeriodStreamReady(contentInfos, 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
         }
-        const { type, manifest, period, adaptationRef } = value;
-        const tracksStore = contentInfos.tracksStore;
+        var type = value.type, period = value.period, adaptationRef = value.adaptationRef;
+        var trackChoiceManager = contentInfos.trackChoiceManager;
         switch (type) {
             case "video":
+                if (isNullOrUndefined(trackChoiceManager)) {
+                    log.error("API: TrackChoiceManager not instanciated for a new video period");
+                    adaptationRef.setValue(null);
+                }
+                else {
+                    trackChoiceManager.addPeriod(type, period, adaptationRef);
+                    trackChoiceManager.setInitialVideoTrack(period);
+                }
+                break;
             case "audio":
+                if (isNullOrUndefined(trackChoiceManager)) {
+                    log.error("API: TrackChoiceManager not instanciated for a new ".concat(type, " period"));
+                    adaptationRef.setValue(null);
+                }
+                else {
+                    trackChoiceManager.addPeriod(type, period, adaptationRef);
+                    trackChoiceManager.setInitialAudioTrack(period);
+                }
+                break;
             case "text":
-                if ((0, is_null_or_undefined_1.default)(tracksStore)) {
-                    log_1.default.error(`API: TracksStore not instanciated for a new ${type} period`);
+                if (isNullOrUndefined(trackChoiceManager)) {
+                    log.error("API: TrackChoiceManager not instanciated for a new ".concat(type, " period"));
                     adaptationRef.setValue(null);
                 }
                 else {
-                    tracksStore.addTrackReference(type, manifest, period, adaptationRef);
+                    trackChoiceManager.addPeriod(type, period, adaptationRef);
+                    trackChoiceManager.setInitialTextTrack(period);
                 }
                 break;
             default:
-                (0, assert_unreachable_1.default)(type);
+                var adaptations = period.adaptations[type];
+                if (!isNullOrUndefined(adaptations) && adaptations.length > 0) {
+                    adaptationRef.setValue(adaptations[0]);
+                }
+                else {
+                    adaptationRef.setValue(null);
+                }
+                break;
         }
-    }
+    };
     /**
      * Triggered each times we "remove" a PeriodStream.
      * @param {Object} contentInfos
      * @param {Object} value
      */
-    _priv_onPeriodStreamCleared(contentInfos, 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
         }
-        const { type, period } = value;
-        const tracksStore = contentInfos.tracksStore;
-        // Clean-up track choices from TracksStore
+        var type = value.type, period = value.period;
+        var trackChoiceManager = contentInfos.trackChoiceManager;
+        // Clean-up track choice from TrackChoiceManager
         switch (type) {
             case "audio":
             case "text":
             case "video":
-                if (!(0, is_null_or_undefined_1.default)(tracksStore)) {
-                    tracksStore.removeTrackReference(type, period);
+                if (!isNullOrUndefined(trackChoiceManager)) {
+                    trackChoiceManager.removePeriod(type, period);
                 }
                 break;
         }
         // Clean-up stored Representation and Adaptation information
-        const { activeAdaptations, activeRepresentations } = contentInfos;
-        if (!(0, is_null_or_undefined_1.default)(activeAdaptations) &&
-            !(0, is_null_or_undefined_1.default)(activeAdaptations[period.id])) {
-            const activePeriodAdaptations = activeAdaptations[period.id];
+        var activeAdaptations = contentInfos.activeAdaptations, activeRepresentations = contentInfos.activeRepresentations;
+        if (!isNullOrUndefined(activeAdaptations) &&
+            !isNullOrUndefined(activeAdaptations[period.id])) {
+            var activePeriodAdaptations = activeAdaptations[period.id];
             delete activePeriodAdaptations[type];
             if (Object.keys(activePeriodAdaptations).length === 0) {
                 delete activeAdaptations[period.id];
             }
         }
-        if (!(0, is_null_or_undefined_1.default)(activeRepresentations) &&
-            !(0, is_null_or_undefined_1.default)(activeRepresentations[period.id])) {
-            const activePeriodRepresentations = activeRepresentations[period.id];
+        if (!isNullOrUndefined(activeRepresentations) &&
+            !isNullOrUndefined(activeRepresentations[period.id])) {
+            var activePeriodRepresentations = activeRepresentations[period.id];
             delete activePeriodRepresentations[type];
             if (Object.keys(activePeriodRepresentations).length === 0) {
                 delete activeRepresentations[period.id];
             }
         }
-    }
+    };
     /**
      * Triggered each times a new Adaptation is considered for the current
      * content.
@@ -1814,48 +2172,50 @@ class Player extends event_emitter_1.default {
      * @param {Object} contentInfos
      * @param {Object} value
      */
-    _priv_onAdaptationChange(contentInfos, { type, adaptation, period }) {
-        var _a;
-        if (contentInfos.contentId !== ((_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.contentId)) {
+    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 = {};
         }
-        const { activeAdaptations, currentPeriod } = contentInfos;
-        const activePeriodAdaptations = activeAdaptations[period.id];
-        if ((0, is_null_or_undefined_1.default)(activePeriodAdaptations)) {
-            activeAdaptations[period.id] = { [type]: adaptation };
+        var activeAdaptations = contentInfos.activeAdaptations, currentPeriod = contentInfos.currentPeriod;
+        var activePeriodAdaptations = activeAdaptations[period.id];
+        if (isNullOrUndefined(activePeriodAdaptations)) {
+            activeAdaptations[period.id] = (_b = {}, _b[type] = adaptation, _b);
         }
         else {
             activePeriodAdaptations[type] = adaptation;
         }
-        const { tracksStore } = contentInfos;
-        const cancelSignal = contentInfos.currentContentCanceller.signal;
-        if (tracksStore !== null &&
-            currentPeriod !== null && !(0, is_null_or_undefined_1.default)(period) &&
+        var trackChoiceManager = contentInfos.trackChoiceManager;
+        var cancelSignal = contentInfos.currentContentCanceller.signal;
+        if (trackChoiceManager !== null &&
+            currentPeriod !== null && !isNullOrUndefined(period) &&
             period.id === currentPeriod.id) {
-            const periodRef = tracksStore.getPeriodObjectFromPeriod(period);
-            if (periodRef === undefined) {
-                return;
-            }
             switch (type) {
                 case "audio":
-                    const audioTrack = tracksStore.getChosenAudioTrack(periodRef);
+                    var audioTrack = trackChoiceManager.getChosenAudioTrack(currentPeriod);
                     this._priv_triggerEventIfNotStopped("audioTrackChange", audioTrack, cancelSignal);
+                    var availableAudioBitrates = this.getAvailableAudioBitrates();
+                    this._priv_triggerAvailableBitratesChangeEvent("availableAudioBitratesChange", availableAudioBitrates, cancelSignal);
                     break;
                 case "text":
-                    const textTrack = tracksStore.getChosenTextTrack(periodRef);
+                    var textTrack = trackChoiceManager.getChosenTextTrack(currentPeriod);
                     this._priv_triggerEventIfNotStopped("textTrackChange", textTrack, cancelSignal);
                     break;
                 case "video":
-                    const videoTrack = tracksStore.getChosenVideoTrack(periodRef);
+                    var videoTrack = trackChoiceManager.getChosenVideoTrack(currentPeriod);
                     this._priv_triggerEventIfNotStopped("videoTrackChange", videoTrack, cancelSignal);
+                    var availableVideoBitrates = this.getAvailableVideoBitrates();
+                    this._priv_triggerAvailableBitratesChangeEvent("availableVideoBitratesChange", availableVideoBitrates, cancelSignal);
                     break;
             }
         }
-    }
+    };
     /**
      * Triggered each times a new Representation is considered during playback.
      *
@@ -1864,35 +2224,38 @@ class Player extends event_emitter_1.default {
      * @param {Object} contentInfos
      * @param {Object} obj
      */
-    _priv_onRepresentationChange(contentInfos, { type, period, representation }) {
-        var _a;
-        if (contentInfos.contentId !== ((_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.contentId)) {
+    Player.prototype._priv_onRepresentationChange = function (contentInfos, _a) {
+        var _b;
+        var _c, _d;
+        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 = {};
         }
-        const { activeRepresentations, currentPeriod } = contentInfos;
-        const activePeriodRepresentations = activeRepresentations[period.id];
-        if ((0, is_null_or_undefined_1.default)(activePeriodRepresentations)) {
-            activeRepresentations[period.id] = { [type]: representation };
+        var activeRepresentations = contentInfos.activeRepresentations, currentPeriod = contentInfos.currentPeriod;
+        var activePeriodRepresentations = activeRepresentations[period.id];
+        if (isNullOrUndefined(activePeriodRepresentations)) {
+            activeRepresentations[period.id] = (_b = {}, _b[type] = representation, _b);
         }
         else {
             activePeriodRepresentations[type] = representation;
         }
-        if (!(0, is_null_or_undefined_1.default)(period) &&
+        var bitrate = (_d = representation === null || representation === void 0 ? void 0 : representation.bitrate) !== null && _d !== void 0 ? _d : -1;
+        if (!isNullOrUndefined(period) &&
             currentPeriod !== null &&
             currentPeriod.id === period.id) {
-            const cancelSignal = this._priv_contentInfos.currentContentCanceller.signal;
+            var cancelSignal = this._priv_contentInfos.currentContentCanceller.signal;
             if (type === "video") {
-                this._priv_triggerEventIfNotStopped("videoRepresentationChange", representation, cancelSignal);
+                this._priv_triggerCurrentBitrateChangeEvent("videoBitrateChange", bitrate, cancelSignal);
             }
             else if (type === "audio") {
-                this._priv_triggerEventIfNotStopped("audioRepresentationChange", representation, cancelSignal);
+                this._priv_triggerCurrentBitrateChangeEvent("audioBitrateChange", bitrate, cancelSignal);
             }
         }
-    }
+    };
     /**
      * Triggered each time a bitrate estimate is calculated.
      *
@@ -1900,14 +2263,23 @@ class Player extends event_emitter_1.default {
      *
      * @param {Object} value
      */
-    _priv_onBitrateEstimateChange({ type, bitrate, }) {
+    Player.prototype._priv_onBitrateEstimationChange = function (_a) {
+        var type = _a.type, bitrate = _a.bitrate;
         if (bitrate !== undefined) {
             this._priv_bitrateInfos.lastBitrates[type] = bitrate;
         }
-        // !!! undocumented API :O !!!
-        /* eslint-disable-next-line */
-        this.trigger("__priv_bitrateEstimateChange", { type, bitrate });
-    }
+        this.trigger("bitrateEstimationChange", { type: type, bitrate: bitrate });
+    };
+    /**
+     * Triggered each time a textTrack is added to the video DOM Element.
+     *
+     * Trigger the right Player Event.
+     *
+     * @param {Array.<TextTrackElement>} tracks
+     */
+    Player.prototype._priv_onNativeTextTracksNext = function (tracks) {
+        this.trigger("nativeTextTracksChange", tracks);
+    };
     /**
      * Triggered each time the player state updates.
      *
@@ -1915,13 +2287,13 @@ class Player extends event_emitter_1.default {
      *
      * @param {string} newState
      */
-    _priv_setPlayerState(newState) {
+    Player.prototype._priv_setPlayerState = function (newState) {
         if (this.state !== newState) {
             this.state = newState;
-            log_1.default.info("API: playerStateChange event", newState);
+            log.info("API: playerStateChange event", newState);
             this.trigger("playerStateChange", newState);
         }
-    }
+    };
     /**
      * Triggered each time a playback observation.
      *
@@ -1930,22 +2302,22 @@ class Player extends event_emitter_1.default {
      * @param {Object} contentInfos
      * @param {Object} observation
      */
-    _priv_triggerPositionUpdate(contentInfos, 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
         }
-        const { isDirectFile, manifest } = contentInfos;
-        if ((!isDirectFile && manifest === null) || (0, is_null_or_undefined_1.default)(observation)) {
+        var isDirectFile = contentInfos.isDirectFile, manifest = contentInfos.manifest;
+        if ((!isDirectFile && manifest === null) || isNullOrUndefined(observation)) {
             return;
         }
-        const maximumPosition = manifest !== null ? manifest.getMaximumSafePosition() :
+        var maximumPosition = manifest !== null ? manifest.getMaximumSafePosition() :
             undefined;
-        const positionData = {
+        var positionData = {
             position: observation.position,
             duration: observation.duration,
             playbackRate: observation.playbackRate,
-            maximumPosition,
+            maximumBufferTime: maximumPosition,
             // TODO bufferGap may be undefined
             bufferGap: observation.bufferGap === undefined ||
                 !isFinite(observation.bufferGap) ?
@@ -1955,149 +2327,127 @@ class Player extends event_emitter_1.default {
         if (manifest !== null &&
             manifest.isLive &&
             observation.position > 0) {
-            const ast = (_b = manifest.availabilityStartTime) !== null && _b !== void 0 ? _b : 0;
+            var ast = (_b = manifest.availabilityStartTime) !== null && _b !== void 0 ? _b : 0;
             positionData.wallClockTime = observation.position + ast;
-            const livePosition = manifest.getLivePosition();
+            var livePosition = manifest.getLivePosition();
             if (livePosition !== undefined) {
                 positionData.liveGap = livePosition - observation.position;
             }
         }
         else if (isDirectFile && this.videoElement !== null) {
-            const startDate = (0, compat_1.getStartDate)(this.videoElement);
+            var startDate = getStartDate(this.videoElement);
             if (startDate !== undefined) {
                 positionData.wallClockTime = startDate + observation.position;
             }
         }
         this.trigger("positionUpdate", positionData);
-    }
+    };
+    /**
+     * Trigger one of the "availableBitratesChange" event only if it changed from
+     * the previously stored value.
+     * @param {string} event
+     * @param {Array.<number>} newVal
+     * @param {Object} currentContentCancelSignal
+     */
+    Player.prototype._priv_triggerAvailableBitratesChangeEvent = function (event, newVal, currentContentCancelSignal) {
+        var prevVal = this._priv_contentEventsMemory[event];
+        if (!currentContentCancelSignal.isCancelled() &&
+            (prevVal === undefined || !areArraysOfNumbersEqual(newVal, prevVal))) {
+            this._priv_contentEventsMemory[event] = newVal;
+            this.trigger(event, newVal);
+        }
+    };
+    /**
+     * Trigger one of the "bitrateChange" event only if it changed from the
+     * previously stored value.
+     * @param {string} event
+     * @param {number} newVal
+     * @param {Object} currentContentCancelSignal
+     */
+    Player.prototype._priv_triggerCurrentBitrateChangeEvent = function (event, newVal, currentContentCancelSignal) {
+        if (!currentContentCancelSignal.isCancelled() &&
+            newVal !== this._priv_contentEventsMemory[event]) {
+            this._priv_contentEventsMemory[event] = newVal;
+            this.trigger(event, newVal);
+        }
+    };
+    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 ||
+            isNullOrUndefined(activeRepresentations[currentPeriod.id])) {
+            return null;
+        }
+        return activeRepresentations[currentPeriod.id];
+    };
     /**
      * @param {string} evt
      * @param {*} arg
      * @param {Object} currentContentCancelSignal
      */
-    _priv_triggerEventIfNotStopped(evt, arg, currentContentCancelSignal) {
+    Player.prototype._priv_triggerEventIfNotStopped = function (evt, arg, currentContentCancelSignal) {
         if (!currentContentCancelSignal.isCancelled()) {
             this.trigger(evt, arg);
         }
-    }
+    };
     /**
+     * @param {Object} defaultAudioTrack
+     * @param {Object} defaultTextTrack
      * @param {Object} cancelSignal
      * @returns {Object}
      */
-    _priv_initializeMediaElementTracksStore(cancelSignal) {
+    Player.prototype._priv_initializeMediaElementTrackChoiceManager = function (defaultAudioTrack, defaultTextTrack, 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");
-        const 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", (val) => this.trigger("availableVideoTracksChange", val));
-        mediaElementTracksStore
-            .addEventListener("availableAudioTracksChange", (val) => this.trigger("availableAudioTracksChange", val));
-        mediaElementTracksStore
-            .addEventListener("availableTextTracksChange", (val) => this.trigger("availableTextTracksChange", val));
-        mediaElementTracksStore
-            .addEventListener("audioTrackChange", (val) => this.trigger("audioTrackChange", val));
-        mediaElementTracksStore
-            .addEventListener("videoTrackChange", (val) => this.trigger("videoTrackChange", val));
-        mediaElementTracksStore
-            .addEventListener("textTrackChange", (val) => this.trigger("textTrackChange", val));
-        return mediaElementTracksStore;
-    }
-    _priv_callTracksStoreGetterSetter(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;
-        }
-        const { tracksStore } = this._priv_contentInfos;
-        const currentPeriod = (_b = (_a = this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.currentPeriod) !== null && _b !== void 0 ? _b : undefined;
-        const wantedPeriodId = periodId !== null && periodId !== void 0 ? periodId : currentPeriod === null || currentPeriod === void 0 ? void 0 : currentPeriod.id;
-        if (wantedPeriodId === undefined) {
-            return defaultValue;
-        }
-        const 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.
-     */
-    _priv_onAvailableTracksMayHaveChanged(trackType, oPeriodRef) {
-        const contentInfos = this._priv_contentInfos;
-        if (contentInfos === null) {
-            return;
-        }
-        const { currentPeriod, tracksStore, currentContentCanceller } = contentInfos;
-        const cancelSignal = currentContentCanceller.signal;
-        if ((0, is_null_or_undefined_1.default)(currentPeriod) || tracksStore === null) {
-            return;
-        }
-        const periodRef = oPeriodRef !== null && oPeriodRef !== void 0 ? oPeriodRef : tracksStore.getPeriodObjectFromPeriod(currentPeriod);
-        if (periodRef === undefined) {
-            return;
-        }
-        switch (trackType) {
-            case "video":
-                const videoTracks = tracksStore.getAvailableVideoTracks(periodRef);
-                this._priv_triggerEventIfNotStopped("availableVideoTracksChange", videoTracks !== null && videoTracks !== void 0 ? videoTracks : [], cancelSignal);
-                break;
-            case "audio":
-                const audioTracks = tracksStore.getAvailableAudioTracks(periodRef);
-                this._priv_triggerEventIfNotStopped("availableAudioTracksChange", audioTracks !== null && audioTracks !== void 0 ? audioTracks : [], cancelSignal);
-                break;
-            case "text":
-                const textTracks = tracksStore.getAvailableTextTracks(periodRef);
-                this._priv_triggerEventIfNotStopped("availableTextTracksChange", textTracks !== null && textTracks !== void 0 ? textTracks : [], cancelSignal);
-                break;
-            default:
-                (0, assert_unreachable_1.default)(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.
-     */
-    _priv_onFatalError(err, contentInfos) {
-        const formattedError = (0, errors_1.formatError)(err, {
-            defaultCode: "NONE",
-            defaultReason: "An unknown error stopped content playback.",
+        assert(features.directfile !== null, "Initializing `MediaElementTrackChoiceManager` without Directfile feature");
+        assert(this.videoElement !== null, "Initializing `MediaElementTrackChoiceManager` on a disposed RxPlayer");
+        var mediaElementTrackChoiceManager = new features.directfile.mediaElementTrackChoiceManager(this.videoElement);
+        var preferredAudioTracks = defaultAudioTrack === undefined ?
+            this._priv_preferredAudioTracks :
+            [defaultAudioTrack];
+        mediaElementTrackChoiceManager.setPreferredAudioTracks(preferredAudioTracks, true);
+        var preferredTextTracks = defaultTextTrack === undefined ?
+            this._priv_preferredTextTracks :
+            [defaultTextTrack];
+        mediaElementTrackChoiceManager.setPreferredTextTracks(preferredTextTracks, true);
+        mediaElementTrackChoiceManager
+            .setPreferredVideoTracks(this._priv_preferredVideoTracks, true);
+        this._priv_triggerEventIfNotStopped("availableAudioTracksChange", mediaElementTrackChoiceManager.getAvailableAudioTracks(), cancelSignal);
+        this._priv_triggerEventIfNotStopped("availableVideoTracksChange", mediaElementTrackChoiceManager.getAvailableVideoTracks(), cancelSignal);
+        this._priv_triggerEventIfNotStopped("availableTextTracksChange", mediaElementTrackChoiceManager.getAvailableTextTracks(), cancelSignal);
+        this._priv_triggerEventIfNotStopped("audioTrackChange", (_a = mediaElementTrackChoiceManager.getChosenAudioTrack()) !== null && _a !== void 0 ? _a : null, cancelSignal);
+        this._priv_triggerEventIfNotStopped("textTrackChange", (_b = mediaElementTrackChoiceManager.getChosenTextTrack()) !== null && _b !== void 0 ? _b : null, cancelSignal);
+        this._priv_triggerEventIfNotStopped("videoTrackChange", (_c = mediaElementTrackChoiceManager.getChosenVideoTrack()) !== null && _c !== void 0 ? _c : null, cancelSignal);
+        mediaElementTrackChoiceManager
+            .addEventListener("availableVideoTracksChange", function (val) {
+            return _this.trigger("availableVideoTracksChange", val);
         });
-        formattedError.fatal = true;
-        contentInfos.currentContentCanceller.cancel();
-        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);
-        }
-    }
-}
-Player.version = /* PLAYER_VERSION */ "4.0.0-dev.2023102700";
-exports.default = Player;
+        mediaElementTrackChoiceManager
+            .addEventListener("availableAudioTracksChange", function (val) {
+            return _this.trigger("availableAudioTracksChange", val);
+        });
+        mediaElementTrackChoiceManager
+            .addEventListener("availableTextTracksChange", function (val) {
+            return _this.trigger("availableTextTracksChange", val);
+        });
+        mediaElementTrackChoiceManager
+            .addEventListener("audioTrackChange", function (val) {
+            return _this.trigger("audioTrackChange", val);
+        });
+        mediaElementTrackChoiceManager
+            .addEventListener("videoTrackChange", function (val) {
+            return _this.trigger("videoTrackChange", val);
+        });
+        mediaElementTrackChoiceManager
+            .addEventListener("textTrackChange", function (val) {
+            return _this.trigger("textTrackChange", val);
+        });
+        return mediaElementTrackChoiceManager;
+    };
+    return Player;
+}(EventEmitter));
+Player.version = /* PLAYER_VERSION */ "3.33.0-canal.2023111400";
+export default Player;