rx-player 3.30.1-dev.2023032800 → 3.31.0-dev.2023052200

package/VERSION

@@ -1 +1 @@
-3.30.1-dev.2023032800
+3.31.0-dev.2023052200

package/dist/_esm5.processed/compat/browser_detection.d.ts

@@ -37,4 +37,6 @@ declare let isWebOs2021: boolean;
 declare let isWebOs2022: boolean;
 /** `true` for Panasonic devices. */
 declare let isPanasonic: boolean;
-export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };
+/** `true` for the PlayStation 5 game console. */
+declare let isPlayStation5: boolean;
+export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isPlayStation5, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };

package/dist/_esm5.processed/compat/browser_detection.js

@@ -38,6 +38,8 @@ var isWebOs2021 = false;
 var isWebOs2022 = false;
 /** `true` for Panasonic devices. */
 var isPanasonic = false;
+/** `true` for the PlayStation 5 game console. */
+var isPlayStation5 = false;
 ((function findCurrentBrowser() {
     var _a, _b;
     if (isNode) {
@@ -74,7 +76,10 @@ var isPanasonic = false;
     if (/SamsungBrowser/.test(navigator.userAgent)) {
         isSamsungBrowser = true;
     }
-    if (/Tizen/.test(navigator.userAgent)) {
+    if (navigator.userAgent.indexOf("PlayStation 5") !== -1) {
+        isPlayStation5 = true;
+    }
+    else if (/Tizen/.test(navigator.userAgent)) {
         isTizen = true;
         // Inspired form: http://webostv.developer.lge.com/discover/specifications/web-engine/
         // Note: even that page doesn't correspond to what we've actually seen in the
@@ -95,4 +100,4 @@ var isPanasonic = false;
         isPanasonic = true;
     }
 })());
-export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };
+export { isEdgeChromium, isIE11, isIEOrEdge, isFirefox, isPanasonic, isPlayStation5, isSafariDesktop, isSafariMobile, isSamsungBrowser, isTizen, isWebOs, isWebOs2021, isWebOs2022, };

package/dist/_esm5.processed/compat/has_issues_with_high_media_source_duration.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Some platforms have issues when the `MediaSource`'s `duration` property
+ * is set to a very high value (playback freezes) but not when setting it
+ * to `Infinity`, which is what the HTML spec as of now (2023-05-15) recommends
+ * for live contents.
+ *
+ * However setting the `MediaSource`'s `duration` property to `Infinity` seems
+ * more risky, considering all platforms we now support, than setting it at a
+ * relatively high ~2**32 value which is what we do generally.
+ *
+ * Moreover, setting it to `Infinity` require us to use another MSE API,
+ * `setLiveSeekableRange` to properly allow seeking. We're used to MSE issues so
+ * I'm not too confident of using another MSE API for all platforms directly.
+ *
+ * So this methods just return `true` based on a whitelist of platform for which
+ * it has been detected that high `duration` values cause issues but setting it
+ * to Infinity AND playing with `setLiveSeekableRange` does not.
+ *
+ * @returns {boolean}
+ */
+export default function hasIssuesWithHighMediaSourceDuration(): boolean;

package/dist/_esm5.processed/compat/has_issues_with_high_media_source_duration.js

@@ -0,0 +1,26 @@
+import { isPlayStation5 } from "./browser_detection";
+/**
+ * Some platforms have issues when the `MediaSource`'s `duration` property
+ * is set to a very high value (playback freezes) but not when setting it
+ * to `Infinity`, which is what the HTML spec as of now (2023-05-15) recommends
+ * for live contents.
+ *
+ * However setting the `MediaSource`'s `duration` property to `Infinity` seems
+ * more risky, considering all platforms we now support, than setting it at a
+ * relatively high ~2**32 value which is what we do generally.
+ *
+ * Moreover, setting it to `Infinity` require us to use another MSE API,
+ * `setLiveSeekableRange` to properly allow seeking. We're used to MSE issues so
+ * I'm not too confident of using another MSE API for all platforms directly.
+ *
+ * So this methods just return `true` based on a whitelist of platform for which
+ * it has been detected that high `duration` values cause issues but setting it
+ * to Infinity AND playing with `setLiveSeekableRange` does not.
+ *
+ * @returns {boolean}
+ */
+export default function hasIssuesWithHighMediaSourceDuration() {
+    // For now only seen on the Webkit present in the PlayStation 5, for which the
+    // alternative is known to work.
+    return isPlayStation5;
+}

package/dist/_esm5.processed/core/adaptive/adaptive_representation_selector.js

@@ -210,8 +210,7 @@ function getEstimateReference(_a, stopAllEstimates) {
             var timeRanges = val.buffered;
             var bufferGap = getLeftSizeOfRange(timeRanges, position.last);
             var representation = val.content.representation;
-            var scoreData = scoreCalculator.getEstimate(representation);
-            var currentScore = scoreData === null || scoreData === void 0 ? void 0 : scoreData[0];
+            var currentScore = scoreCalculator.getEstimate(representation);
             var currentBitrate = representation.bitrate;
             var observation = { bufferGap: bufferGap, currentBitrate: currentBitrate, currentScore: currentScore, speed: speed };
             currentBufferBasedEstimate = bufferBasedChooser.getEstimate(observation);

package/dist/_esm5.processed/core/adaptive/buffer_based_chooser.d.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { IRepresentationMaintainabilityScore } from "./utils/representation_score_calculator";
 /**
  * Choose a bitrate based on the currently available buffer.
  *
@@ -24,11 +25,27 @@
  * "maintanable" or not.
  * If so, we may switch to a better quality, or conversely to a worse quality.
  *
+ * It also rely on mechanisms to avoid fluctuating too much between qualities.
+ *
  * @class BufferBasedChooser
  */
 export default class BufferBasedChooser {
     private _levelsMap;
     private _bitrates;
+    /**
+     * Laast timestamp, in terms of `performance.now`, at which the current
+     * quality was seen as too high by this algorithm.
+     * Begins at `undefined`.
+     */
+    private _lastUnsuitableQualityTimestamp;
+    /**
+     * After lowering in quality, we forbid raising during a set amount of time.
+     * This amount is adaptive may continue to raise if it seems that quality
+     * is switching too much between low and high qualities.
+     *
+     * `_blockRaiseDelay` represents this time in milliseconds.
+     */
+    private _blockRaiseDelay;
     /**
      * @param {Array.<number>} bitrates
      */
@@ -50,7 +67,7 @@ export interface IBufferBasedChooserPlaybackObservation {
     /** The bitrate of the currently downloaded segments, in bps. */
     currentBitrate?: number | undefined;
     /** The "maintainability score" of the currently downloaded segments. */
-    currentScore?: number | undefined;
+    currentScore?: IRepresentationMaintainabilityScore | undefined;
     /** Playback rate wanted (e.g. `1` is regular playback, `2` is double speed etc.). */
     speed: number;
 }

package/dist/_esm5.processed/core/adaptive/buffer_based_chooser.js

@@ -16,6 +16,45 @@
 import log from "../../log";
 import arrayFindIndex from "../../utils/array_find_index";
 import getBufferLevels from "./utils/get_buffer_levels";
+/**
+ * Minimum amount of time, in milliseconds, during which we are blocked from
+ * raising in quality after it had been considered as too high.
+ */
+var MINIMUM_BLOCK_RAISE_DELAY = 6000;
+/**
+ * Maximum amount of time, in milliseconds, during which we are blocked from
+ * raising in quality after it had been considered as too high.
+ */
+var MAXIMUM_BLOCK_RAISE_DELAY = 15000;
+/**
+ * Amount of time, in milliseconds, with which the blocking time in raising
+ * the quality will be incremented if the current quality estimate is seen
+ * as too unstable.
+ */
+var RAISE_BLOCKING_DELAY_INCREMENT = 3000;
+/**
+ * Amount of time, in milliseconds, with which the blocking time in raising
+ * the quality will be dcremented if the current quality estimate is seen
+ * as relatively stable, until `MINIMUM_BLOCK_RAISE_DELAY` is reached.
+ */
+var RAISE_BLOCKING_DELAY_DECREMENT = 1000;
+/**
+ * Amount of time, in milliseconds, after the "raise blocking delay" currently
+ * in place (during which it is forbidden to raise up in quality), during which
+ * we might want to raise the "raise blocking delay" if the last chosen quality
+ * seems unsuitable.
+ *
+ * For example, let's consider that the current raise blocking delay is at
+ * `4000`, or 4 seconds, and that this `STABILITY_CHECK_DELAY` is at `5000`, or
+ * 5 seconds.
+ * Here it means that if the estimated quality is found to be unsuitable less
+ * than 4+5 = 9 seconds after it last was, we will increment the raise blocking
+ * delay by `RAISE_BLOCKING_DELAY_INCREMENT` (unless `MAXIMUM_BLOCK_RAISE_DELAY`
+ * is reached).
+ * Else, if takes more than 9 seconds, the raise blocking delay might be
+ * decremented.
+ */
+var STABILITY_CHECK_DELAY = 9000;
 /**
  * Choose a bitrate based on the currently available buffer.
  *
@@ -27,6 +66,8 @@ import getBufferLevels from "./utils/get_buffer_levels";
  * "maintanable" or not.
  * If so, we may switch to a better quality, or conversely to a worse quality.
  *
+ * It also rely on mechanisms to avoid fluctuating too much between qualities.
+ *
  * @class BufferBasedChooser
  */
 var BufferBasedChooser = /** @class */ (function () {
@@ -34,8 +75,13 @@ var BufferBasedChooser = /** @class */ (function () {
      * @param {Array.<number>} bitrates
      */
     function BufferBasedChooser(bitrates) {
-        this._levelsMap = getBufferLevels(bitrates);
+        this._levelsMap = getBufferLevels(bitrates).map(function (bl) {
+            return bl + 4; // Add some buffer security as it will be used conjointly with
+            // other algorithms anyway
+        });
         this._bitrates = bitrates;
+        this._lastUnsuitableQualityTimestamp = undefined;
+        this._blockRaiseDelay = MINIMUM_BLOCK_RAISE_DELAY;
         log.debug("ABR: Steps for buffer based chooser.", this._levelsMap.map(function (l, i) { return "bufferLevel: ".concat(l, ", bitrate: ").concat(bitrates[i]); })
             .join(" ,"));
     }
@@ -50,40 +96,75 @@ var BufferBasedChooser = /** @class */ (function () {
         if (currentBitrate == null) {
             return bitrates[0];
         }
-        var currentBitrateIndex = arrayFindIndex(bitrates, function (b) { return b === currentBitrate; });
+        var currentBitrateIndex = -1;
+        for (var i = 0; i < bitrates.length; i++) {
+            // There could be bitrate duplicates. Only take the last one to simplify
+            var bitrate = bitrates[i];
+            if (bitrate === currentBitrate) {
+                currentBitrateIndex = i;
+            }
+            else if (bitrate > currentBitrate) {
+                break;
+            }
+        }
         if (currentBitrateIndex < 0 || bitrates.length !== bufferLevels.length) {
             log.error("ABR: Current Bitrate not found in the calculated levels");
             return bitrates[0];
         }
         var scaledScore;
         if (currentScore !== undefined) {
-            scaledScore = speed === 0 ? currentScore : (currentScore / speed);
+            scaledScore = speed === 0 ? currentScore.score : (currentScore.score / speed);
         }
-        if (scaledScore !== undefined && scaledScore > 1) {
-            var currentBufferLevel_1 = bufferLevels[currentBitrateIndex];
-            var nextIndex = (function () {
-                for (var i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
-                    if (bufferLevels[i] > currentBufferLevel_1) {
-                        return i;
-                    }
-                }
-            })();
-            if (nextIndex !== undefined) {
-                var nextBufferLevel = bufferLevels[nextIndex];
-                if (bufferGap >= nextBufferLevel) {
-                    return bitrates[nextIndex];
+        var actualBufferGap = isFinite(bufferGap) ?
+            bufferGap :
+            0;
+        var now = performance.now();
+        if (actualBufferGap < bufferLevels[currentBitrateIndex] ||
+            (scaledScore !== undefined && scaledScore < 1 &&
+                (currentScore === null || currentScore === void 0 ? void 0 : currentScore.confidenceLevel) === 1 /* ScoreConfidenceLevel.HIGH */)) {
+            var timeSincePrev = this._lastUnsuitableQualityTimestamp === undefined ?
+                -1 :
+                now - this._lastUnsuitableQualityTimestamp;
+            if (timeSincePrev < this._blockRaiseDelay + STABILITY_CHECK_DELAY) {
+                var newDelay = this._blockRaiseDelay + RAISE_BLOCKING_DELAY_INCREMENT;
+                this._blockRaiseDelay = Math.min(newDelay, MAXIMUM_BLOCK_RAISE_DELAY);
+                log.debug("ABR: Incrementing blocking raise in BufferBasedChooser due " +
+                    "to unstable quality", this._blockRaiseDelay);
+            }
+            else {
+                var newDelay = this._blockRaiseDelay - RAISE_BLOCKING_DELAY_DECREMENT;
+                this._blockRaiseDelay = Math.max(MINIMUM_BLOCK_RAISE_DELAY, newDelay);
+                log.debug("ABR: Lowering quality in BufferBasedChooser", this._blockRaiseDelay);
+            }
+            this._lastUnsuitableQualityTimestamp = now;
+            // Security if multiple bitrates are equal, we now take the first one
+            var baseIndex = arrayFindIndex(bitrates, function (b) { return b === currentBitrate; });
+            for (var i = baseIndex - 1; i >= 0; i--) {
+                if (actualBufferGap >= bufferLevels[i]) {
+                    return bitrates[i];
                 }
             }
+            return bitrates[0];
         }
-        if (scaledScore === undefined || scaledScore < 1.15) {
-            var currentBufferLevel = bufferLevels[currentBitrateIndex];
-            if (bufferGap < currentBufferLevel) {
-                for (var i = currentBitrateIndex - 1; i >= 0; i--) {
-                    if (bitrates[i] < currentBitrate) {
-                        return bitrates[i];
-                    }
+        if ((this._lastUnsuitableQualityTimestamp !== undefined &&
+            now - this._lastUnsuitableQualityTimestamp < this._blockRaiseDelay) ||
+            scaledScore === undefined || scaledScore < 1.15 ||
+            (currentScore === null || currentScore === void 0 ? void 0 : currentScore.confidenceLevel) !== 1 /* ScoreConfidenceLevel.HIGH */) {
+            return currentBitrate;
+        }
+        var currentBufferLevel = bufferLevels[currentBitrateIndex];
+        var nextIndex = (function () {
+            for (var i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
+                if (bufferLevels[i] > currentBufferLevel) {
+                    return i;
                 }
-                return currentBitrate;
+            }
+        })();
+        if (nextIndex !== undefined) {
+            var nextBufferLevel = bufferLevels[nextIndex];
+            if (bufferGap >= nextBufferLevel) {
+                log.debug("ABR: Raising quality in BufferBasedChooser", bitrates[nextIndex]);
+                return bitrates[nextIndex];
             }
         }
         return currentBitrate;

package/dist/_esm5.processed/core/adaptive/guess_based_chooser.js

@@ -127,10 +127,10 @@ var GuessBasedChooser = /** @class */ (function () {
      * @returns {boolean}
      */
     GuessBasedChooser.prototype._canGuessHigher = function (bufferGap, speed, _a) {
-        var score = _a[0], scoreConfidenceLevel = _a[1];
+        var score = _a.score, confidenceLevel = _a.confidenceLevel;
         return isFinite(bufferGap) && bufferGap >= 2.5 &&
             performance.now() > this._blockGuessesUntil &&
-            scoreConfidenceLevel === 1 /* ScoreConfidenceLevel.HIGH */ &&
+            confidenceLevel === 1 /* ScoreConfidenceLevel.HIGH */ &&
             score / speed > 1.01;
     };
     /**
@@ -143,10 +143,10 @@ var GuessBasedChooser = /** @class */ (function () {
      * @returns {boolean}
      */
     GuessBasedChooser.prototype._shouldStopGuess = function (lastGuess, scoreData, bufferGap, requests) {
-        if (scoreData !== undefined && scoreData[0] < 1.01) {
+        if (scoreData !== undefined && scoreData.score < 1.01) {
             return true;
         }
-        else if ((scoreData === undefined || scoreData[0] < 1.2) && bufferGap < 0.6) {
+        else if ((scoreData === undefined || scoreData.score < 1.2) && bufferGap < 0.6) {
             return true;
         }
         var guessedRepresentationRequests = requests.filter(function (req) {
@@ -175,8 +175,8 @@ var GuessBasedChooser = /** @class */ (function () {
     };
     GuessBasedChooser.prototype._isLastGuessValidated = function (lastGuess, incomingBestBitrate, scoreData) {
         if (scoreData !== undefined &&
-            scoreData[1] === 1 /* ScoreConfidenceLevel.HIGH */ &&
-            scoreData[0] > 1.5) {
+            scoreData.confidenceLevel === 1 /* ScoreConfidenceLevel.HIGH */ &&
+            scoreData.score > 1.5) {
             return true;
         }
         return incomingBestBitrate >= lastGuess.bitrate &&

package/dist/_esm5.processed/core/adaptive/utils/representation_score_calculator.d.ts

@@ -14,6 +14,24 @@
  * limitations under the License.
  */
 import { Representation } from "../../../manifest";
+/**
+ * Object representing a maintainability score as calculated by the
+ * `RepresentationScoreCalculator`.
+ */
+export interface IRepresentationMaintainabilityScore {
+    /**
+     * Weighted mean of dividing the loaded segment's duration by the time to make
+     * their request.
+     */
+    score: number;
+    /**
+     * The confidence we have on the calculated `score` in reflecting a useful
+     * maintainability hint for the concerned Representation.
+     *
+     * Basically, the more segments have been loaded, the higher the confidence.
+     */
+    confidenceLevel: ScoreConfidenceLevel;
+}
 /**
  * Calculate the "maintainability score" of a given Representation:
  *   - A score higher than 1 means that the Representation can theorically
@@ -62,7 +80,7 @@ export default class RepresentationScoreCalculator {
      * @param {Representation} representation
      * @returns {number|undefined}
      */
-    getEstimate(representation: Representation): [number, ScoreConfidenceLevel] | undefined;
+    getEstimate(representation: Representation): IRepresentationMaintainabilityScore | undefined;
     /**
      * Returns last Representation which had reached a score superior to 1.
      * This Representation is the last known one which could be maintained.

package/dist/_esm5.processed/core/adaptive/utils/representation_score_calculator.js

@@ -96,7 +96,7 @@ var RepresentationScoreCalculator = /** @class */ (function () {
         var confidenceLevel = loadedSegments >= 5 &&
             loadedDuration >= 10 ? 1 /* ScoreConfidenceLevel.HIGH */ :
             0 /* ScoreConfidenceLevel.LOW */;
-        return [estimate, confidenceLevel];
+        return { score: estimate, confidenceLevel: confidenceLevel };
     };
     /**
      * Returns last Representation which had reached a score superior to 1.

package/dist/_esm5.processed/core/api/debug/render.js

@@ -21,7 +21,7 @@ export default function renderDebugElement(parentElt, instance, cancelSignal) {
     debugWrapperElt.style.backgroundColor = "#00000099";
     debugWrapperElt.style.padding = "7px";
     debugWrapperElt.style.fontSize = "13px";
-    debugWrapperElt.style.fontFamily = "mono";
+    debugWrapperElt.style.fontFamily = "mono, monospace";
     debugWrapperElt.style.color = "white";
     debugWrapperElt.style.display = "inline-block";
     debugWrapperElt.style.bottom = "0px";

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

@@ -89,7 +89,7 @@ var Player = /** @class */ (function (_super) {
         // 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 */ "3.30.1-dev.2023032800";
+        _this.version = /* PLAYER_VERSION */ "3.31.0-dev.2023052200";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -2340,5 +2340,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.30.1-dev.2023032800";
+Player.version = /* PLAYER_VERSION */ "3.31.0-dev.2023052200";
 export default Player;

package/dist/_esm5.processed/core/api/tracks_management/media_element_track_choice_manager.js

@@ -101,7 +101,14 @@ function createTextTracks(textTracks) {
             "_" +
             occurences.toString();
         languagesOccurences[language] = occurences + 1;
-        var track = { language: textTrack.language, id: id, normalized: normalizeLanguage(textTrack.language),
+        // Safari seems to be indicating that the subtitles track is a forced
+        // subtitles track by setting the `kind` attribute to `"forced"`.
+        // As of now (2023-04-04), this is not standard.
+        // @see https://github.com/whatwg/html/issues/4472
+        var forced = textTrack.kind === "forced" ?
+            true :
+            undefined;
+        var track = { language: textTrack.language, forced: forced, label: textTrack.label, id: id, normalized: normalizeLanguage(textTrack.language),
             closedCaption: textTrack.kind === "captions" };
         newTextTracks.push({ track: track, nativeTrack: textTrack });
     }
@@ -337,6 +344,8 @@ var MediaElementTrackChoiceManager = /** @class */ (function (_super) {
         return this._textTracks.map(function (_a) {
             var track = _a.track, nativeTrack = _a.nativeTrack;
             return { id: track.id,
+                label: track.label,
+                forced: track.forced,
                 language: track.language,
                 normalized: track.normalized,
                 closedCaption: track.closedCaption,

package/dist/_esm5.processed/core/api/tracks_management/track_choice_manager.js

@@ -22,6 +22,7 @@ import arrayFind from "../../../utils/array_find";
 import arrayIncludes from "../../../utils/array_includes";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import normalizeLanguage from "../../../utils/languages";
+import objectAssign from "../../../utils/object_assign";
 import SortedList from "../../../utils/sorted_list";
 import takeFirstSet from "../../../utils/take_first_set";
 /**
@@ -426,18 +427,7 @@ var TrackChoiceManager = /** @class */ (function () {
         if (isNullOrUndefined(chosenTrack)) {
             return null;
         }
-        var audioTrack = {
-            language: takeFirstSet(chosenTrack.language, ""),
-            normalized: takeFirstSet(chosenTrack.normalizedLanguage, ""),
-            audioDescription: chosenTrack.isAudioDescription === true,
-            id: chosenTrack.id,
-            representations: chosenTrack.representations.map(parseAudioRepresentation),
-            label: chosenTrack.label,
-        };
-        if (chosenTrack.isDub === true) {
-            audioTrack.dub = true;
-        }
-        return audioTrack;
+        return chosenTrack.toAudioTrack();
     };
     /**
      * Returns an object describing the chosen text track for the given text
@@ -460,17 +450,7 @@ var TrackChoiceManager = /** @class */ (function () {
         if (isNullOrUndefined(chosenTextAdaptation)) {
             return null;
         }
-        var formatted = {
-            language: takeFirstSet(chosenTextAdaptation.language, ""),
-            normalized: takeFirstSet(chosenTextAdaptation.normalizedLanguage, ""),
-            closedCaption: chosenTextAdaptation.isClosedCaption === true,
-            id: chosenTextAdaptation.id,
-            label: chosenTextAdaptation.label,
-        };
-        if (chosenTextAdaptation.isForcedSubtitles !== undefined) {
-            formatted.forced = chosenTextAdaptation.isForcedSubtitles;
-        }
-        return formatted;
+        return chosenTextAdaptation.toTextTrack();
     };
     /**
      * Returns an object describing the chosen video track for the given video
@@ -494,32 +474,7 @@ var TrackChoiceManager = /** @class */ (function () {
             return null;
         }
         var currAdaptation = chosenVideoAdaptation.adaptation;
-        var trickModeTracks = currAdaptation.trickModeTracks !== undefined ?
-            currAdaptation.trickModeTracks.map(function (trickModeAdaptation) {
-                var representations = trickModeAdaptation.representations
-                    .map(parseVideoRepresentation);
-                var trickMode = { id: trickModeAdaptation.id, representations: representations, isTrickModeTrack: true };
-                if (trickModeAdaptation.isSignInterpreted === true) {
-                    trickMode.signInterpreted = true;
-                }
-                return trickMode;
-            }) :
-            undefined;
-        var videoTrack = {
-            id: currAdaptation.id,
-            representations: currAdaptation.representations.map(parseVideoRepresentation),
-            label: currAdaptation.label,
-        };
-        if (currAdaptation.isSignInterpreted === true) {
-            videoTrack.signInterpreted = true;
-        }
-        if (currAdaptation.isTrickModeTrack === true) {
-            videoTrack.isTrickModeTrack = true;
-        }
-        if (trickModeTracks !== undefined) {
-            videoTrack.trickModeTracks = trickModeTracks;
-        }
-        return videoTrack;
+        return currAdaptation.toVideoTrack();
     };
     /**
      * Returns all available audio tracks for a given Period, as an array of
@@ -540,20 +495,9 @@ var TrackChoiceManager = /** @class */ (function () {
             null;
         return audioInfos.adaptations
             .map(function (adaptation) {
-            var formatted = {
-                language: takeFirstSet(adaptation.language, ""),
-                normalized: takeFirstSet(adaptation.normalizedLanguage, ""),
-                audioDescription: adaptation.isAudioDescription === true,
-                id: adaptation.id,
-                active: currentId === null ? false :
-                    currentId === adaptation.id,
-                representations: adaptation.representations.map(parseAudioRepresentation),
-                label: adaptation.label,
-            };
-            if (adaptation.isDub === true) {
-                formatted.dub = true;
-            }
-            return formatted;
+            var active = currentId === null ? false :
+                currentId === adaptation.id;
+            return objectAssign(adaptation.toAudioTrack(), { active: active });
         });
     };
     /**
@@ -576,19 +520,9 @@ var TrackChoiceManager = /** @class */ (function () {
             null;
         return textInfos.adaptations
             .map(function (adaptation) {
-            var formatted = {
-                language: takeFirstSet(adaptation.language, ""),
-                normalized: takeFirstSet(adaptation.normalizedLanguage, ""),
-                closedCaption: adaptation.isClosedCaption === true,
-                id: adaptation.id,
-                active: currentId === null ? false :
-                    currentId === adaptation.id,
-                label: adaptation.label,
-            };
-            if (adaptation.isForcedSubtitles !== undefined) {
-                formatted.forced = adaptation.isForcedSubtitles;
-            }
-            return formatted;
+            var active = currentId === null ? false :
+                currentId === adaptation.id;
+            return objectAssign(adaptation.toTextTrack(), { active: active });
         });
     };
     /**
@@ -611,34 +545,21 @@ var TrackChoiceManager = /** @class */ (function () {
             (_a = chosenVideoAdaptation === null || chosenVideoAdaptation === void 0 ? void 0 : chosenVideoAdaptation.adaptation.id) !== null && _a !== void 0 ? _a : undefined;
         return videoInfos.adaptations
             .map(function (adaptation) {
-            var trickModeTracks = adaptation.trickModeTracks !== undefined ?
-                adaptation.trickModeTracks.map(function (trickModeAdaptation) {
+            var active = currentId === null ? false :
+                currentId === adaptation.id;
+            var track = adaptation.toVideoTrack();
+            var trickModeTracks = track.trickModeTracks !== undefined ?
+                track.trickModeTracks.map(function (trickModeAdaptation) {
                     var isActive = currentId === null ? false :
                         currentId === trickModeAdaptation.id;
-                    var representations = trickModeAdaptation.representations
-                        .map(parseVideoRepresentation);
-                    var trickMode = { id: trickModeAdaptation.id, representations: representations, isTrickModeTrack: true,
-                        active: isActive };
-                    if (trickModeAdaptation.isSignInterpreted === true) {
-                        trickMode.signInterpreted = true;
-                    }
-                    return trickMode;
+                    return objectAssign(trickModeAdaptation, { active: isActive });
                 }) :
-                undefined;
-            var formatted = {
-                id: adaptation.id,
-                active: currentId === null ? false :
-                    currentId === adaptation.id,
-                representations: adaptation.representations.map(parseVideoRepresentation),
-                label: adaptation.label,
-            };
-            if (adaptation.isSignInterpreted === true) {
-                formatted.signInterpreted = true;
-            }
+                [];
+            var availableTrack = objectAssign(track, { active: active });
             if (trickModeTracks !== undefined) {
-                formatted.trickModeTracks = trickModeTracks;
+                availableTrack.trickModeTracks = trickModeTracks;
             }
-            return formatted;
+            return availableTrack;
         });
     };
     /**
@@ -1058,24 +979,6 @@ function getPeriodItem(periods, period) {
         }
     }
 }
-/**
- * Parse video Representation into a IVideoRepresentation.
- * @param {Object} representation
- * @returns {Object}
- */
-function parseVideoRepresentation(_a) {
-    var id = _a.id, bitrate = _a.bitrate, frameRate = _a.frameRate, width = _a.width, height = _a.height, codec = _a.codec, hdrInfo = _a.hdrInfo;
-    return { id: id, bitrate: bitrate, frameRate: frameRate, width: width, height: height, codec: codec, hdrInfo: hdrInfo };
-}
-/**
- * Parse audio Representation into a ITMAudioRepresentation.
- * @param {Object} representation
- * @returns {Object}
- */
-function parseAudioRepresentation(_a) {
-    var id = _a.id, bitrate = _a.bitrate, codec = _a.codec;
-    return { id: id, bitrate: bitrate, codec: codec };
-}
 function getRightVideoTrack(adaptation, isTrickModeEnabled) {
     var _a;
     if (isTrickModeEnabled &&