rx-player 4.5.0 → 4.6.0-dev.2026100600

package/dist/commonjs/manifest/utils.js

@@ -1,51 +1,95 @@
 "use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get SUPPORTED_ADAPTATIONS_TYPE () {
+        return SUPPORTED_ADAPTATIONS_TYPE;
+    },
+    get createRepresentationFilterFromFnString () {
+        return createRepresentationFilterFromFnString;
+    },
+    get getAdaptations () {
+        return getAdaptations;
+    },
+    get getLivePosition () {
+        return getLivePosition;
+    },
+    get getMaximumSafePosition () {
+        return getMaximumSafePosition;
+    },
+    get getMinimumSafePosition () {
+        return getMinimumSafePosition;
+    },
+    get getPeriodAfter () {
+        return getPeriodAfter;
+    },
+    get getPeriodForTime () {
+        return getPeriodForTime;
+    },
+    get getSupportedAdaptations () {
+        return getSupportedAdaptations;
+    },
+    get isRepresentationPlayable () {
+        return isRepresentationPlayable;
+    },
+    get periodContainsTime () {
+        return periodContainsTime;
+    },
+    get replicateUpdatesOnManifestMetadata () {
+        return replicateUpdatesOnManifestMetadata;
+    },
+    get toAudioRepresentation () {
+        return toAudioRepresentation;
+    },
+    get toAudioTrack () {
+        return toAudioTrack;
+    },
+    get toTaggedTrack () {
+        return toTaggedTrack;
+    },
+    get toTextTrack () {
+        return toTextTrack;
+    },
+    get toVideoRepresentation () {
+        return toVideoRepresentation;
+    },
+    get toVideoTrack () {
+        return toVideoTrack;
+    },
+    get updateDecipherabilityFromKeyIds () {
+        return updateDecipherabilityFromKeyIds;
+    },
+    get updateDecipherabilityFromProtectionData () {
+        return updateDecipherabilityFromProtectionData;
+    }
+});
+var _log = /*#__PURE__*/ _interop_require_default(require("../log.js"));
+var _are_arrays_of_numbers_equal = /*#__PURE__*/ _interop_require_default(require("../utils/are_arrays_of_numbers_equal.js"));
+var _array_find = /*#__PURE__*/ _interop_require_default(require("../utils/array_find.js"));
+var _is_null_or_undefined = /*#__PURE__*/ _interop_require_default(require("../utils/is_null_or_undefined.js"));
+var _monotonic_timestamp = /*#__PURE__*/ _interop_require_default(require("../utils/monotonic_timestamp.js"));
+var _object_values = require("../utils/object_values.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
     };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUPPORTED_ADAPTATIONS_TYPE = void 0;
-exports.getMinimumSafePosition = getMinimumSafePosition;
-exports.getLivePosition = getLivePosition;
-exports.getMaximumSafePosition = getMaximumSafePosition;
-exports.getSupportedAdaptations = getSupportedAdaptations;
-exports.getPeriodForTime = getPeriodForTime;
-exports.getPeriodAfter = getPeriodAfter;
-exports.periodContainsTime = periodContainsTime;
-exports.getAdaptations = getAdaptations;
-exports.toAudioTrack = toAudioTrack;
-exports.toTextTrack = toTextTrack;
-exports.toVideoTrack = toVideoTrack;
-exports.toAudioRepresentation = toAudioRepresentation;
-exports.toVideoRepresentation = toVideoRepresentation;
-exports.toTaggedTrack = toTaggedTrack;
-exports.isRepresentationPlayable = isRepresentationPlayable;
-exports.updateDecipherabilityFromKeyIds = updateDecipherabilityFromKeyIds;
-exports.updateDecipherabilityFromProtectionData = updateDecipherabilityFromProtectionData;
-exports.replicateUpdatesOnManifestMetadata = replicateUpdatesOnManifestMetadata;
-exports.createRepresentationFilterFromFnString = createRepresentationFilterFromFnString;
-var log_1 = require("../log");
-var are_arrays_of_numbers_equal_1 = require("../utils/are_arrays_of_numbers_equal");
-var array_find_1 = require("../utils/array_find");
-var is_null_or_undefined_1 = require("../utils/is_null_or_undefined");
-var monotonic_timestamp_1 = require("../utils/monotonic_timestamp");
-var object_values_1 = require("../utils/object_values");
-/** List in an array every possible value for the Adaptation's `type` property. */
-exports.SUPPORTED_ADAPTATIONS_TYPE = ["audio", "video", "text"];
-/**
- * Returns the theoretical minimum playable position on the content
- * regardless of the current Adaptation chosen, as estimated at parsing
- * time.
- * @param {Object} manifest
- * @returns {number}
- */
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var SUPPORTED_ADAPTATIONS_TYPE = [
+    "audio",
+    "video",
+    "text"
+];
 function getMinimumSafePosition(manifest) {
     var _a, _b;
     var windowData = manifest.timeBounds;
@@ -56,20 +100,13 @@ function getMinimumSafePosition(manifest) {
     var maximumTime;
     if (!windowData.maximumTimeData.isLinear) {
         maximumTime = maximumTimeData.maximumSafePosition;
-    }
-    else {
-        var timeDiff = (0, monotonic_timestamp_1.default)() - maximumTimeData.time;
+    } else {
+        var timeDiff = (0, _monotonic_timestamp.default)() - maximumTimeData.time;
         maximumTime = maximumTimeData.maximumSafePosition + timeDiff / 1000;
     }
     var theoricalMinimum = maximumTime - windowData.timeshiftDepth;
     return Math.max((_b = windowData.minimumSafePosition) !== null && _b !== void 0 ? _b : 0, theoricalMinimum);
 }
-/**
- * Get the position of the live edge - that is, the position of what is
- * currently being broadcasted, in seconds.
- * @param {Object} manifest
- * @returns {number|undefined}
- */
 function getLivePosition(manifest) {
     var maximumTimeData = manifest.timeBounds.maximumTimeData;
     if (!manifest.isLive || maximumTimeData.livePosition === undefined) {
@@ -78,43 +115,34 @@ function getLivePosition(manifest) {
     if (!maximumTimeData.isLinear) {
         return maximumTimeData.livePosition;
     }
-    var timeDiff = (0, monotonic_timestamp_1.default)() - maximumTimeData.time;
+    var timeDiff = (0, _monotonic_timestamp.default)() - maximumTimeData.time;
     return maximumTimeData.livePosition + timeDiff / 1000;
 }
-/**
- * Returns the theoretical maximum playable position on the content
- * regardless of the current Adaptation chosen, as estimated at parsing
- * time.
- * @param {Object} manifest
- * @returns {number}
- */
 function getMaximumSafePosition(manifest) {
     var maximumTimeData = manifest.timeBounds.maximumTimeData;
     if (!maximumTimeData.isLinear) {
         return maximumTimeData.maximumSafePosition;
     }
-    var timeDiff = (0, monotonic_timestamp_1.default)() - maximumTimeData.time;
+    var timeDiff = (0, _monotonic_timestamp.default)() - maximumTimeData.time;
     return maximumTimeData.maximumSafePosition + timeDiff / 1000;
 }
 function getSupportedAdaptations(period, type) {
     if (type === undefined) {
-        return getAdaptations(period).filter(function (ada) {
-            return (ada.supportStatus.hasSupportedCodec !== false &&
-                ada.supportStatus.isDecipherable !== false);
+        return getAdaptations(period).filter(function(ada) {
+            return ada.supportStatus.hasSupportedCodec !== false && ada.supportStatus.isDecipherable !== false;
         });
     }
     var adaptationsForType = period.adaptations[type];
     if (adaptationsForType === undefined) {
         return [];
     }
-    return adaptationsForType.filter(function (ada) {
-        return (ada.supportStatus.hasSupportedCodec !== false &&
-            ada.supportStatus.isDecipherable !== false);
+    return adaptationsForType.filter(function(ada) {
+        return ada.supportStatus.hasSupportedCodec !== false && ada.supportStatus.isDecipherable !== false;
     });
 }
 function getPeriodForTime(manifest, time) {
     var nextPeriod = null;
-    for (var i = manifest.periods.length - 1; i >= 0; i--) {
+    for(var i = manifest.periods.length - 1; i >= 0; i--){
         var period = manifest.periods[i];
         if (periodContainsTime(period, time, nextPeriod)) {
             return period;
@@ -127,25 +155,15 @@ function getPeriodAfter(manifest, period) {
     if (endOfPeriod === undefined) {
         return null;
     }
-    var nextPeriod = (0, array_find_1.default)(manifest.periods, function (_period) {
+    var nextPeriod = (0, _array_find.default)(manifest.periods, function(_period) {
         return _period.end === undefined || endOfPeriod < _period.end;
     });
     return nextPeriod === undefined ? null : nextPeriod;
 }
-/**
- * Returns true if the give time is in the time boundaries of this `Period`.
- * @param {Object} period - The `Period` which we want to check.
- * @param {number} time
- * @param {object|null} nextPeriod - Period coming chronologically just
- * after in the same Manifest. `null` if this instance is the last `Period`.
- * @returns {boolean}
- */
 function periodContainsTime(period, time, nextPeriod) {
     if (time >= period.start && (period.end === undefined || time < period.end)) {
         return true;
-    }
-    else if (time === period.end &&
-        (nextPeriod === null || nextPeriod.start > period.end)) {
+    } else if (time === period.end && (nextPeriod === null || nextPeriod.start > period.end)) {
         // The last possible timed position of a Period is ambiguous as it is
         // frequently in common with the start of the next one: is it part of
         // the current or of the next Period?
@@ -157,19 +175,11 @@ function periodContainsTime(period, time, nextPeriod) {
 }
 function getAdaptations(period) {
     var adaptationsByType = period.adaptations;
-    return (0, object_values_1.objectValues)(adaptationsByType).reduce(
-    // Note: the second case cannot happen. TS is just being dumb here
-    function (acc, adaptations) {
-        return !(0, is_null_or_undefined_1.default)(adaptations) ? acc.concat(adaptations) : acc;
+    return (0, _object_values.objectValues)(adaptationsByType).reduce(// Note: the second case cannot happen. TS is just being dumb here
+    function(acc, adaptations) {
+        return !(0, _is_null_or_undefined.default)(adaptations) ? acc.concat(adaptations) : acc;
     }, []);
 }
-/**
- * Format an `Adaptation`, generally of type `"audio"`, as an `IAudioTrack`.
- * @param {Object} adaptation
- * @param {boolean} filterPlayable - If `true` only "playable" Representation
- * will be returned.
- * @returns {Object}
- */
 function toAudioTrack(adaptation, filterPlayable) {
     var _a, _b;
     var formatted = {
@@ -177,21 +187,16 @@ function toAudioTrack(adaptation, filterPlayable) {
         normalized: (_b = adaptation.normalizedLanguage) !== null && _b !== void 0 ? _b : "",
         audioDescription: adaptation.isAudioDescription === true,
         id: adaptation.id,
-        representations: (filterPlayable
-            ? adaptation.representations.filter(function (r) { return isRepresentationPlayable(r) === true; })
-            : adaptation.representations).map(toAudioRepresentation),
-        label: adaptation.label,
+        representations: (filterPlayable ? adaptation.representations.filter(function(r) {
+            return isRepresentationPlayable(r) === true;
+        }) : adaptation.representations).map(toAudioRepresentation),
+        label: adaptation.label
     };
     if (adaptation.isDub === true) {
         formatted.dub = true;
     }
     return formatted;
 }
-/**
- * Format an `Adaptation`, generally of type `"audio"`, as an `IAudioTrack`.
- * @param {Object} adaptation
- * @returns {Object}
- */
 function toTextTrack(adaptation) {
     var _a, _b;
     return {
@@ -200,39 +205,30 @@ function toTextTrack(adaptation) {
         closedCaption: adaptation.isClosedCaption === true,
         id: adaptation.id,
         label: adaptation.label,
-        forced: adaptation.isForcedSubtitles,
+        forced: adaptation.isForcedSubtitles
     };
 }
-/**
- * Format an `Adaptation`, generally of type `"video"`, as an `IAudioTrack`.
- * @param {Object} adaptation
- * @param {boolean} filterPlayable - If `true` only "playable" Representation
- * will be returned.
- * @returns {Object}
- */
 function toVideoTrack(adaptation, filterPlayable) {
-    var trickModeTracks = adaptation.trickModeTracks !== undefined
-        ? adaptation.trickModeTracks.map(function (trickModeAdaptation) {
-            var representations = (filterPlayable
-                ? trickModeAdaptation.representations.filter(function (r) { return isRepresentationPlayable(r) === true; })
-                : trickModeAdaptation.representations).map(toVideoRepresentation);
-            var trickMode = {
-                id: trickModeAdaptation.id,
-                representations: representations,
-                isTrickModeTrack: true,
-            };
-            if (trickModeAdaptation.isSignInterpreted === true) {
-                trickMode.signInterpreted = true;
-            }
-            return trickMode;
-        })
-        : undefined;
+    var trickModeTracks = adaptation.trickModeTracks !== undefined ? adaptation.trickModeTracks.map(function(trickModeAdaptation) {
+        var representations = (filterPlayable ? trickModeAdaptation.representations.filter(function(r) {
+            return isRepresentationPlayable(r) === true;
+        }) : trickModeAdaptation.representations).map(toVideoRepresentation);
+        var trickMode = {
+            id: trickModeAdaptation.id,
+            representations: representations,
+            isTrickModeTrack: true
+        };
+        if (trickModeAdaptation.isSignInterpreted === true) {
+            trickMode.signInterpreted = true;
+        }
+        return trickMode;
+    }) : undefined;
     var videoTrack = {
         id: adaptation.id,
-        representations: (filterPlayable
-            ? adaptation.representations.filter(function (r) { return isRepresentationPlayable(r) === true; })
-            : adaptation.representations).map(toVideoRepresentation),
-        label: adaptation.label,
+        representations: (filterPlayable ? adaptation.representations.filter(function(r) {
+            return isRepresentationPlayable(r) === true;
+        }) : adaptation.representations).map(toVideoRepresentation),
+        label: adaptation.label
     };
     if (adaptation.isSignInterpreted === true) {
         videoTrack.signInterpreted = true;
@@ -245,10 +241,6 @@ function toVideoTrack(adaptation, filterPlayable) {
     }
     return videoTrack;
 }
-/**
- * Format Representation as an `IAudioRepresentation`.
- * @returns {Object}
- */
 function toAudioRepresentation(representation) {
     var id = representation.id, bitrate = representation.bitrate, chosenCodec = representation.chosenCodec, isSpatialAudio = representation.isSpatialAudio, isSupported = representation.isSupported, decipherable = representation.decipherable;
     return {
@@ -257,13 +249,9 @@ function toAudioRepresentation(representation) {
         codec: chosenCodec,
         isSpatialAudio: isSpatialAudio,
         isCodecSupported: isSupported,
-        decipherable: decipherable,
+        decipherable: decipherable
     };
 }
-/**
- * Format Representation as an `IVideoRepresentation`.
- * @returns {Object}
- */
 function toVideoRepresentation(representation) {
     var id = representation.id, bitrate = representation.bitrate, frameRate = representation.frameRate, width = representation.width, height = representation.height, chosenCodec = representation.chosenCodec, hdrInfo = representation.hdrInfo, isSupported = representation.isSupported, decipherable = representation.decipherable, contentProtections = representation.contentProtections;
     return {
@@ -276,189 +264,187 @@ function toVideoRepresentation(representation) {
         hdrInfo: hdrInfo,
         isCodecSupported: isSupported,
         decipherable: decipherable,
-        contentProtections: contentProtections !== undefined
-            ? {
-                keyIds: contentProtections.keyIds,
-            }
-            : undefined,
+        contentProtections: contentProtections !== undefined ? {
+            keyIds: contentProtections.keyIds
+        } : undefined
     };
 }
 function toTaggedTrack(adaptation) {
-    switch (adaptation.type) {
+    switch(adaptation.type){
         case "audio":
-            return { type: "audio", track: toAudioTrack(adaptation, false) };
+            return {
+                type: "audio",
+                track: toAudioTrack(adaptation, false)
+            };
         case "video":
-            return { type: "video", track: toVideoTrack(adaptation, false) };
+            return {
+                type: "video",
+                track: toVideoTrack(adaptation, false)
+            };
         case "text":
-            return { type: "text", track: toTextTrack(adaptation) };
+            return {
+                type: "text",
+                track: toTextTrack(adaptation)
+            };
     }
 }
-/**
- * Returns `true` if the `Representation` has a high chance of being playable on
- * the current device (its codec seems supported and we don't consider it to be
- * un-decipherable).
- *
- * Returns `false` if the `Representation` has a high chance of being unplayable
- * on the current device (its codec seems unsupported and/or we consider it to
- * be un-decipherable).
- *
- * Returns `undefined` if we don't know as the codec has not been checked yet.
- *
- * @param {Object} representation
- * @returns {boolean|undefined}
- */
 function isRepresentationPlayable(representation) {
     if (representation.decipherable === false) {
         return false;
     }
     return representation.isSupported;
 }
-/**
- * Change the decipherability of Representations which have their key id in one
- * of the given Arrays:
- *
- *   - Those who have a key id listed in `whitelistedKeyIds` will have their
- *     decipherability updated to `true`
- *
- *   - Those who have a key id listed in `blacklistedKeyIds` will have their
- *     decipherability updated to `false`
- *
- *   - Those who have a key id listed in `delistedKeyIds` will have their
- *     decipherability updated to `undefined`.
- *
- * @param {Object} manifest
- * @param {Object} updates
- * @param {Array.<Uint8Array>} updates.whitelistedKeyIds
- * @param {Array.<Uint8Array>} updates.blacklistedKeyIds
- * @param {Array.<Uint8Array>} updates.delistedKeyIds
- */
 function updateDecipherabilityFromKeyIds(manifest, updates) {
     var whitelistedKeyIds = updates.whitelistedKeyIds, blacklistedKeyIds = updates.blacklistedKeyIds, delistedKeyIds = updates.delistedKeyIds;
-    var isDecipherable = function (representation) {
-        var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+    var isDecipherable = function isDecipherable(representation) {
         if (representation.contentProtections === undefined) {
             return representation.decipherable;
         }
         var contentKIDs = representation.contentProtections.keyIds;
         if (contentKIDs !== undefined) {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
             try {
-                for (var contentKIDs_1 = __values(contentKIDs), contentKIDs_1_1 = contentKIDs_1.next(); !contentKIDs_1_1.done; contentKIDs_1_1 = contentKIDs_1.next()) {
-                    var elt = contentKIDs_1_1.value;
+                for(var _iterator = contentKIDs[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var elt = _step.value;
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
                     try {
-                        for (var blacklistedKeyIds_1 = (e_2 = void 0, __values(blacklistedKeyIds)), blacklistedKeyIds_1_1 = blacklistedKeyIds_1.next(); !blacklistedKeyIds_1_1.done; blacklistedKeyIds_1_1 = blacklistedKeyIds_1.next()) {
-                            var blacklistedKeyId = blacklistedKeyIds_1_1.value;
-                            if ((0, are_arrays_of_numbers_equal_1.default)(blacklistedKeyId, elt)) {
+                        for(var _iterator1 = blacklistedKeyIds[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var blacklistedKeyId = _step1.value;
+                            if ((0, _are_arrays_of_numbers_equal.default)(blacklistedKeyId, elt)) {
                                 return false;
                             }
                         }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
                         try {
-                            if (blacklistedKeyIds_1_1 && !blacklistedKeyIds_1_1.done && (_b = blacklistedKeyIds_1.return)) _b.call(blacklistedKeyIds_1);
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
                         }
-                        finally { if (e_2) throw e_2.error; }
                     }
+                    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
                     try {
-                        for (var whitelistedKeyIds_1 = (e_3 = void 0, __values(whitelistedKeyIds)), whitelistedKeyIds_1_1 = whitelistedKeyIds_1.next(); !whitelistedKeyIds_1_1.done; whitelistedKeyIds_1_1 = whitelistedKeyIds_1.next()) {
-                            var whitelistedKeyId = whitelistedKeyIds_1_1.value;
-                            if ((0, are_arrays_of_numbers_equal_1.default)(whitelistedKeyId, elt)) {
+                        for(var _iterator2 = whitelistedKeyIds[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                            var whitelistedKeyId = _step2.value;
+                            if ((0, _are_arrays_of_numbers_equal.default)(whitelistedKeyId, elt)) {
                                 return true;
                             }
                         }
-                    }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError2 = true;
+                        _iteratorError2 = err;
+                    } finally{
                         try {
-                            if (whitelistedKeyIds_1_1 && !whitelistedKeyIds_1_1.done && (_c = whitelistedKeyIds_1.return)) _c.call(whitelistedKeyIds_1);
+                            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                _iterator2.return();
+                            }
+                        } finally{
+                            if (_didIteratorError2) {
+                                throw _iteratorError2;
+                            }
                         }
-                        finally { if (e_3) throw e_3.error; }
                     }
+                    var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
                     try {
-                        for (var delistedKeyIds_1 = (e_4 = void 0, __values(delistedKeyIds)), delistedKeyIds_1_1 = delistedKeyIds_1.next(); !delistedKeyIds_1_1.done; delistedKeyIds_1_1 = delistedKeyIds_1.next()) {
-                            var delistedKeyId = delistedKeyIds_1_1.value;
-                            if ((0, are_arrays_of_numbers_equal_1.default)(delistedKeyId, elt)) {
+                        for(var _iterator3 = delistedKeyIds[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
+                            var delistedKeyId = _step3.value;
+                            if ((0, _are_arrays_of_numbers_equal.default)(delistedKeyId, elt)) {
                                 return undefined;
                             }
                         }
-                    }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError3 = true;
+                        _iteratorError3 = err;
+                    } finally{
                         try {
-                            if (delistedKeyIds_1_1 && !delistedKeyIds_1_1.done && (_d = delistedKeyIds_1.return)) _d.call(delistedKeyIds_1);
+                            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                                _iterator3.return();
+                            }
+                        } finally{
+                            if (_didIteratorError3) {
+                                throw _iteratorError3;
+                            }
                         }
-                        finally { if (e_4) throw e_4.error; }
                     }
                 }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
                 try {
-                    if (contentKIDs_1_1 && !contentKIDs_1_1.done && (_a = contentKIDs_1.return)) _a.call(contentKIDs_1);
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
                 }
-                finally { if (e_1) throw e_1.error; }
             }
         }
         return representation.decipherable;
     };
-    if (manifest.manifestFormat === 0 /* ManifestMetadataFormat.Class */) {
-        manifest.updateRepresentationsDeciperability(function (_a) {
-            var representation = _a.representation;
+    if (manifest.manifestFormat === 0 /* ManifestMetadataFormat.Class */ ) {
+        manifest.updateRepresentationsDeciperability(function(param) {
+            var representation = param.representation;
             return isDecipherable(representation);
         });
     }
     return updateRepresentationsDeciperability(manifest, isDecipherable);
 }
-/**
- * Update decipherability to `false` to any Representation which is linked to
- * the given initialization data.
- * @param {Object} manifest
- * @param {Object} initData
- */
 function updateDecipherabilityFromProtectionData(manifest, initData) {
-    var isDecipherable = function (representation) {
-        var e_5, _a;
-        var _b, _c;
+    var isDecipherable = function isDecipherable(representation) {
+        var _a, _b;
         if (representation.decipherable === false) {
             return false;
         }
-        var segmentProtections = (_c = (_b = representation.contentProtections) === null || _b === void 0 ? void 0 : _b.initData) !== null && _c !== void 0 ? _c : [];
-        var _loop_1 = function (protection) {
-            if (initData.type === undefined || protection.type === initData.type) {
-                var containedInitData = initData.values
-                    .getFormattedValues()
-                    .every(function (undecipherableVal) {
-                    return protection.values.some(function (currVal) {
-                        return ((undecipherableVal.systemId === undefined ||
-                            currVal.systemId === undecipherableVal.systemId) &&
-                            (0, are_arrays_of_numbers_equal_1.default)(currVal.data, undecipherableVal.data));
+        var segmentProtections = (_b = (_a = representation.contentProtections) === null || _a === void 0 ? void 0 : _a.initData) !== null && _b !== void 0 ? _b : [];
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var protection = _step.value;
+                if (initData.type === undefined || protection.type === initData.type) {
+                    var containedInitData = initData.values.getFormattedValues().every(function(undecipherableVal) {
+                        return protection.values.some(function(currVal) {
+                            return (undecipherableVal.systemId === undefined || currVal.systemId === undecipherableVal.systemId) && (0, _are_arrays_of_numbers_equal.default)(currVal.data, undecipherableVal.data);
+                        });
                     });
-                });
-                if (containedInitData) {
-                    return { value: false };
+                    if (containedInitData) {
+                        return {
+                            v: false
+                        };
+                    }
                 }
+            };
+            for(var _iterator = segmentProtections[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _ret = _loop();
+                if (_type_of(_ret) === "object") return _ret.v;
             }
-        };
-        try {
-            for (var segmentProtections_1 = __values(segmentProtections), segmentProtections_1_1 = segmentProtections_1.next(); !segmentProtections_1_1.done; segmentProtections_1_1 = segmentProtections_1.next()) {
-                var protection = segmentProtections_1_1.value;
-                var state_1 = _loop_1(protection);
-                if (typeof state_1 === "object")
-                    return state_1.value;
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
             try {
-                if (segmentProtections_1_1 && !segmentProtections_1_1.done && (_a = segmentProtections_1.return)) _a.call(segmentProtections_1);
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
             }
-            finally { if (e_5) throw e_5.error; }
         }
         return representation.decipherable;
     };
-    if (manifest.manifestFormat === 0 /* ManifestMetadataFormat.Class */) {
-        manifest.updateRepresentationsDeciperability(function (_a) {
-            var representation = _a.representation;
+    if (manifest.manifestFormat === 0 /* ManifestMetadataFormat.Class */ ) {
+        manifest.updateRepresentationsDeciperability(function(param) {
+            var representation = param.representation;
             return isDecipherable(representation);
         });
     }
@@ -474,24 +460,26 @@ function updateDecipherabilityFromProtectionData(manifest, initData) {
  * @param {Manifest} manifest
  * @param {Function} isDecipherable
  * @returns {Array.<Object>}
- */
-function updateRepresentationsDeciperability(manifest, isDecipherable) {
-    var e_6, _a, e_7, _b, e_8, _c;
+ */ function updateRepresentationsDeciperability(manifest, isDecipherable) {
     var updates = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
-        for (var _d = __values(manifest.periods), _e = _d.next(); !_e.done; _e = _d.next()) {
-            var period = _e.value;
+        for(var _iterator = manifest.periods[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var period = _step.value;
             var adaptationsByType = period.adaptations;
-            var adaptations = (0, object_values_1.objectValues)(adaptationsByType).reduce(
-            // Note: the second case cannot happen. TS is just being dumb here
-            function (acc, adaps) { return (!(0, is_null_or_undefined_1.default)(adaps) ? acc.concat(adaps) : acc); }, []);
+            var adaptations = (0, _object_values.objectValues)(adaptationsByType).reduce(// Note: the second case cannot happen. TS is just being dumb here
+            function(acc, adaps) {
+                return !(0, _is_null_or_undefined.default)(adaps) ? acc.concat(adaps) : acc;
+            }, []);
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
             try {
-                for (var adaptations_1 = (e_7 = void 0, __values(adaptations)), adaptations_1_1 = adaptations_1.next(); !adaptations_1_1.done; adaptations_1_1 = adaptations_1.next()) {
-                    var adaptation = adaptations_1_1.value;
+                for(var _iterator1 = adaptations[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var adaptation = _step1.value;
                     var hasOnlyUndecipherableRepresentations = true;
+                    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
                     try {
-                        for (var _f = (e_8 = void 0, __values(adaptation.representations)), _g = _f.next(); !_g.done; _g = _f.next()) {
-                            var representation = _g.value;
+                        for(var _iterator2 = adaptation.representations[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                            var representation = _step2.value;
                             var result = isDecipherable(representation);
                             if (result !== false) {
                                 hasOnlyUndecipherableRepresentations = false;
@@ -499,343 +487,468 @@ function updateRepresentationsDeciperability(manifest, isDecipherable) {
                             if (result !== representation.decipherable) {
                                 if (result === true) {
                                     adaptation.supportStatus.isDecipherable = true;
-                                }
-                                else if (result === undefined &&
-                                    adaptation.supportStatus.isDecipherable === false) {
+                                } else if (result === undefined && adaptation.supportStatus.isDecipherable === false) {
                                     adaptation.supportStatus.isDecipherable = undefined;
                                 }
-                                updates.push({ manifest: manifest, period: period, adaptation: adaptation, representation: representation });
+                                updates.push({
+                                    manifest: manifest,
+                                    period: period,
+                                    adaptation: adaptation,
+                                    representation: representation
+                                });
                                 representation.decipherable = result;
                             }
                         }
-                    }
-                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError2 = true;
+                        _iteratorError2 = err;
+                    } finally{
                         try {
-                            if (_g && !_g.done && (_c = _f.return)) _c.call(_f);
+                            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                _iterator2.return();
+                            }
+                        } finally{
+                            if (_didIteratorError2) {
+                                throw _iteratorError2;
+                            }
                         }
-                        finally { if (e_8) throw e_8.error; }
                     }
                     if (hasOnlyUndecipherableRepresentations) {
                         adaptation.supportStatus.isDecipherable = false;
                     }
                 }
-            }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
                 try {
-                    if (adaptations_1_1 && !adaptations_1_1.done && (_b = adaptations_1.return)) _b.call(adaptations_1);
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
                 }
-                finally { if (e_7) throw e_7.error; }
             }
         }
-    }
-    catch (e_6_1) { e_6 = { error: e_6_1 }; }
-    finally {
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
         try {
-            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
         }
-        finally { if (e_6) throw e_6.error; }
     }
     return updates;
 }
-/**
- *
- * TODO that function is kind of very ugly, yet should work.
- * Maybe find out a better system for Manifest updates.
- * @param {Object} baseManifest
- * @param {Object} newManifest
- * @param {Array.<Object>} updates
- */
 function replicateUpdatesOnManifestMetadata(baseManifest, newManifest, updates) {
-    var e_9, _a, e_10, _b, e_11, _c, e_12, _d, e_13, _e, e_14, _f, e_15, _g, e_16, _h, e_17, _j, e_18, _k, e_19, _l, e_20, _m, e_21, _o, e_22, _p, e_23, _q, e_24, _r;
-    var _s, _t;
-    if (baseManifest.manifestFormat === 0 /* ManifestMetadataFormat.Class */) {
+    var _a, _b;
+    if (baseManifest.manifestFormat === 0 /* ManifestMetadataFormat.Class */ ) {
         // This function is not intended for and could break a `Manifest` instance, as
         // it might mutate it by adding metadata objects to it, whereas the `Manifest`
         // instance generally expect the "instance versions" of those objects instead.
-        log_1.default.error("manifest", "`replicateUpdatesOnManifestMetadata` called on a Manifest instance");
+        _log.default.error("manifest", "`replicateUpdatesOnManifestMetadata` called on a Manifest instance");
         return;
     }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
-        for (var _u = __values(Object.keys(newManifest)), _v = _u.next(); !_v.done; _v = _u.next()) {
-            var prop = _v.value;
+        for(var _iterator = Object.keys(newManifest)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var prop = _step.value;
             if (prop !== "periods") {
                 // trust me bro
                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
                 baseManifest[prop] = newManifest[prop];
             }
         }
-    }
-    catch (e_9_1) { e_9 = { error: e_9_1 }; }
-    finally {
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
         try {
-            if (_v && !_v.done && (_a = _u.return)) _a.call(_u);
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
         }
-        finally { if (e_9) throw e_9.error; }
     }
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
     try {
-        for (var _w = __values(updates.removedPeriods), _x = _w.next(); !_x.done; _x = _w.next()) {
-            var removedPeriod = _x.value;
-            for (var periodIdx = 0; periodIdx < baseManifest.periods.length; periodIdx++) {
+        for(var _iterator1 = updates.removedPeriods[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+            var removedPeriod = _step1.value;
+            for(var periodIdx = 0; periodIdx < baseManifest.periods.length; periodIdx++){
                 if (baseManifest.periods[periodIdx].id === removedPeriod.id) {
                     baseManifest.periods.splice(periodIdx, 1);
                     break;
                 }
             }
         }
-    }
-    catch (e_10_1) { e_10 = { error: e_10_1 }; }
-    finally {
+    } catch (err) {
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
+    } finally{
         try {
-            if (_x && !_x.done && (_b = _w.return)) _b.call(_w);
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
+            }
+        } finally{
+            if (_didIteratorError1) {
+                throw _iteratorError1;
+            }
         }
-        finally { if (e_10) throw e_10.error; }
     }
+    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
     try {
-        for (var _y = __values(updates.updatedPeriods), _z = _y.next(); !_z.done; _z = _y.next()) {
-            var updatedPeriod = _z.value;
-            for (var periodIdx = 0; periodIdx < baseManifest.periods.length; periodIdx++) {
+        for(var _iterator2 = updates.updatedPeriods[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+            var updatedPeriod = _step2.value;
+            for(var periodIdx1 = 0; periodIdx1 < baseManifest.periods.length; periodIdx1++){
                 var newPeriod = updatedPeriod.period;
-                if (baseManifest.periods[periodIdx].id === updatedPeriod.period.id) {
-                    var basePeriod = baseManifest.periods[periodIdx];
+                if (baseManifest.periods[periodIdx1].id === updatedPeriod.period.id) {
+                    var basePeriod = baseManifest.periods[periodIdx1];
+                    var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
                     try {
-                        for (var _0 = (e_12 = void 0, __values(Object.keys(newPeriod))), _1 = _0.next(); !_1.done; _1 = _0.next()) {
-                            var prop = _1.value;
-                            if (prop !== "adaptations") {
+                        for(var _iterator3 = Object.keys(newPeriod)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
+                            var prop1 = _step3.value;
+                            if (prop1 !== "adaptations") {
                                 // trust me bro
                                 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-                                basePeriod[prop] = newPeriod[prop];
+                                basePeriod[prop1] = newPeriod[prop1];
                             }
                         }
-                    }
-                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError3 = true;
+                        _iteratorError3 = err;
+                    } finally{
                         try {
-                            if (_1 && !_1.done && (_d = _0.return)) _d.call(_0);
+                            if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                                _iterator3.return();
+                            }
+                        } finally{
+                            if (_didIteratorError3) {
+                                throw _iteratorError3;
+                            }
                         }
-                        finally { if (e_12) throw e_12.error; }
                     }
+                    var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
                     try {
-                        for (var _2 = (e_13 = void 0, __values(updatedPeriod.result.removedThumbnailTracks)), _3 = _2.next(); !_3.done; _3 = _2.next()) {
-                            var removedThumbnailTrack = _3.value;
-                            for (var thumbIdx = 0; thumbIdx < basePeriod.thumbnailTracks.length; thumbIdx++) {
+                        for(var _iterator4 = updatedPeriod.result.removedThumbnailTracks[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true){
+                            var removedThumbnailTrack = _step4.value;
+                            for(var thumbIdx = 0; thumbIdx < basePeriod.thumbnailTracks.length; thumbIdx++){
                                 if (basePeriod.thumbnailTracks[thumbIdx].id === removedThumbnailTrack.id) {
                                     basePeriod.thumbnailTracks.splice(thumbIdx, 1);
                                     break;
                                 }
                             }
                         }
-                    }
-                    catch (e_13_1) { e_13 = { error: e_13_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError4 = true;
+                        _iteratorError4 = err;
+                    } finally{
                         try {
-                            if (_3 && !_3.done && (_e = _2.return)) _e.call(_2);
+                            if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                                _iterator4.return();
+                            }
+                        } finally{
+                            if (_didIteratorError4) {
+                                throw _iteratorError4;
+                            }
                         }
-                        finally { if (e_13) throw e_13.error; }
                     }
+                    var _iteratorNormalCompletion5 = true, _didIteratorError5 = false, _iteratorError5 = undefined;
                     try {
-                        for (var _4 = (e_14 = void 0, __values(updatedPeriod.result.updatedThumbnailTracks)), _5 = _4.next(); !_5.done; _5 = _4.next()) {
-                            var updatedThumbnailTrack = _5.value;
+                        for(var _iterator5 = updatedPeriod.result.updatedThumbnailTracks[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true){
+                            var updatedThumbnailTrack = _step5.value;
                             var newThumbnailTrack = updatedThumbnailTrack;
-                            for (var thumbIdx = 0; thumbIdx < basePeriod.thumbnailTracks.length; thumbIdx++) {
-                                if (basePeriod.thumbnailTracks[thumbIdx].id === newThumbnailTrack.id) {
-                                    var baseThumbnailTrack = basePeriod.thumbnailTracks[thumbIdx];
+                            for(var thumbIdx1 = 0; thumbIdx1 < basePeriod.thumbnailTracks.length; thumbIdx1++){
+                                if (basePeriod.thumbnailTracks[thumbIdx1].id === newThumbnailTrack.id) {
+                                    var baseThumbnailTrack = basePeriod.thumbnailTracks[thumbIdx1];
+                                    var _iteratorNormalCompletion6 = true, _didIteratorError6 = false, _iteratorError6 = undefined;
                                     try {
-                                        for (var _6 = (e_15 = void 0, __values(Object.keys(newThumbnailTrack))), _7 = _6.next(); !_7.done; _7 = _6.next()) {
-                                            var prop = _7.value;
+                                        for(var _iterator6 = Object.keys(newThumbnailTrack)[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true){
+                                            var prop2 = _step6.value;
                                             // eslint-disable-next-line
-                                            baseThumbnailTrack[prop] = newThumbnailTrack[prop];
+                                            baseThumbnailTrack[prop2] = newThumbnailTrack[prop2];
                                         }
-                                    }
-                                    catch (e_15_1) { e_15 = { error: e_15_1 }; }
-                                    finally {
+                                    } catch (err) {
+                                        _didIteratorError6 = true;
+                                        _iteratorError6 = err;
+                                    } finally{
                                         try {
-                                            if (_7 && !_7.done && (_g = _6.return)) _g.call(_6);
+                                            if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+                                                _iterator6.return();
+                                            }
+                                        } finally{
+                                            if (_didIteratorError6) {
+                                                throw _iteratorError6;
+                                            }
                                         }
-                                        finally { if (e_15) throw e_15.error; }
                                     }
                                     break;
                                 }
                             }
                         }
-                    }
-                    catch (e_14_1) { e_14 = { error: e_14_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError5 = true;
+                        _iteratorError5 = err;
+                    } finally{
                         try {
-                            if (_5 && !_5.done && (_f = _4.return)) _f.call(_4);
+                            if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+                                _iterator5.return();
+                            }
+                        } finally{
+                            if (_didIteratorError5) {
+                                throw _iteratorError5;
+                            }
                         }
-                        finally { if (e_14) throw e_14.error; }
                     }
+                    var _iteratorNormalCompletion7 = true, _didIteratorError7 = false, _iteratorError7 = undefined;
                     try {
-                        for (var _8 = (e_16 = void 0, __values(updatedPeriod.result.addedThumbnailTracks)), _9 = _8.next(); !_9.done; _9 = _8.next()) {
-                            var addedThumbnailTrack = _9.value;
+                        for(var _iterator7 = updatedPeriod.result.addedThumbnailTracks[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true){
+                            var addedThumbnailTrack = _step7.value;
                             basePeriod.thumbnailTracks.push(addedThumbnailTrack);
                         }
-                    }
-                    catch (e_16_1) { e_16 = { error: e_16_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError7 = true;
+                        _iteratorError7 = err;
+                    } finally{
                         try {
-                            if (_9 && !_9.done && (_h = _8.return)) _h.call(_8);
+                            if (!_iteratorNormalCompletion7 && _iterator7.return != null) {
+                                _iterator7.return();
+                            }
+                        } finally{
+                            if (_didIteratorError7) {
+                                throw _iteratorError7;
+                            }
                         }
-                        finally { if (e_16) throw e_16.error; }
                     }
+                    var _iteratorNormalCompletion8 = true, _didIteratorError8 = false, _iteratorError8 = undefined;
                     try {
-                        for (var _10 = (e_17 = void 0, __values(updatedPeriod.result.removedAdaptations)), _11 = _10.next(); !_11.done; _11 = _10.next()) {
-                            var removedAdaptation = _11.value;
+                        for(var _iterator8 = updatedPeriod.result.removedAdaptations[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true){
+                            var removedAdaptation = _step8.value;
                             var ttype = removedAdaptation.trackType;
-                            var adaptationsForType = (_s = basePeriod.adaptations[ttype]) !== null && _s !== void 0 ? _s : [];
-                            for (var adapIdx = 0; adapIdx < adaptationsForType.length; adapIdx++) {
+                            var adaptationsForType = (_a = basePeriod.adaptations[ttype]) !== null && _a !== void 0 ? _a : [];
+                            for(var adapIdx = 0; adapIdx < adaptationsForType.length; adapIdx++){
                                 if (adaptationsForType[adapIdx].id === removedAdaptation.id) {
                                     adaptationsForType.splice(adapIdx, 1);
                                     break;
                                 }
                             }
                         }
-                    }
-                    catch (e_17_1) { e_17 = { error: e_17_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError8 = true;
+                        _iteratorError8 = err;
+                    } finally{
                         try {
-                            if (_11 && !_11.done && (_j = _10.return)) _j.call(_10);
+                            if (!_iteratorNormalCompletion8 && _iterator8.return != null) {
+                                _iterator8.return();
+                            }
+                        } finally{
+                            if (_didIteratorError8) {
+                                throw _iteratorError8;
+                            }
                         }
-                        finally { if (e_17) throw e_17.error; }
                     }
+                    var _iteratorNormalCompletion9 = true, _didIteratorError9 = false, _iteratorError9 = undefined;
                     try {
-                        for (var _12 = (e_18 = void 0, __values(updatedPeriod.result.updatedAdaptations)), _13 = _12.next(); !_13.done; _13 = _12.next()) {
-                            var updatedAdaptation = _13.value;
+                        for(var _iterator9 = updatedPeriod.result.updatedAdaptations[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true){
+                            var updatedAdaptation = _step9.value;
                             var newAdaptation = updatedAdaptation.adaptation;
-                            var ttype = updatedAdaptation.trackType;
-                            var adaptationsForType = (_t = basePeriod.adaptations[ttype]) !== null && _t !== void 0 ? _t : [];
-                            for (var adapIdx = 0; adapIdx < adaptationsForType.length; adapIdx++) {
-                                if (adaptationsForType[adapIdx].id === newAdaptation) {
-                                    var baseAdaptation = adaptationsForType[adapIdx];
+                            var ttype1 = updatedAdaptation.trackType;
+                            var adaptationsForType1 = (_b = basePeriod.adaptations[ttype1]) !== null && _b !== void 0 ? _b : [];
+                            for(var adapIdx1 = 0; adapIdx1 < adaptationsForType1.length; adapIdx1++){
+                                if (adaptationsForType1[adapIdx1].id === newAdaptation) {
+                                    var baseAdaptation = adaptationsForType1[adapIdx1];
+                                    var _iteratorNormalCompletion10 = true, _didIteratorError10 = false, _iteratorError10 = undefined;
                                     try {
-                                        for (var _14 = (e_19 = void 0, __values(updatedAdaptation.removedRepresentations)), _15 = _14.next(); !_15.done; _15 = _14.next()) {
-                                            var removedRepresentation = _15.value;
-                                            for (var repIdx = 0; repIdx < baseAdaptation.representations.length; repIdx++) {
+                                        for(var _iterator10 = updatedAdaptation.removedRepresentations[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true){
+                                            var removedRepresentation = _step10.value;
+                                            for(var repIdx = 0; repIdx < baseAdaptation.representations.length; repIdx++){
                                                 if (baseAdaptation.representations[repIdx].id === removedRepresentation) {
                                                     baseAdaptation.representations.splice(repIdx, 1);
                                                     break;
                                                 }
                                             }
                                         }
-                                    }
-                                    catch (e_19_1) { e_19 = { error: e_19_1 }; }
-                                    finally {
+                                    } catch (err) {
+                                        _didIteratorError10 = true;
+                                        _iteratorError10 = err;
+                                    } finally{
                                         try {
-                                            if (_15 && !_15.done && (_l = _14.return)) _l.call(_14);
+                                            if (!_iteratorNormalCompletion10 && _iterator10.return != null) {
+                                                _iterator10.return();
+                                            }
+                                        } finally{
+                                            if (_didIteratorError10) {
+                                                throw _iteratorError10;
+                                            }
                                         }
-                                        finally { if (e_19) throw e_19.error; }
                                     }
+                                    var _iteratorNormalCompletion11 = true, _didIteratorError11 = false, _iteratorError11 = undefined;
                                     try {
-                                        for (var _16 = (e_20 = void 0, __values(updatedAdaptation.updatedRepresentations)), _17 = _16.next(); !_17.done; _17 = _16.next()) {
-                                            var newRepresentation = _17.value;
-                                            for (var repIdx = 0; repIdx < baseAdaptation.representations.length; repIdx++) {
-                                                if (baseAdaptation.representations[repIdx].id === newRepresentation.id) {
-                                                    var baseRepresentation = baseAdaptation.representations[repIdx];
+                                        for(var _iterator11 = updatedAdaptation.updatedRepresentations[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true){
+                                            var newRepresentation = _step11.value;
+                                            for(var repIdx1 = 0; repIdx1 < baseAdaptation.representations.length; repIdx1++){
+                                                if (baseAdaptation.representations[repIdx1].id === newRepresentation.id) {
+                                                    var baseRepresentation = baseAdaptation.representations[repIdx1];
+                                                    var _iteratorNormalCompletion12 = true, _didIteratorError12 = false, _iteratorError12 = undefined;
                                                     try {
-                                                        for (var _18 = (e_21 = void 0, __values(Object.keys(newRepresentation))), _19 = _18.next(); !_19.done; _19 = _18.next()) {
-                                                            var prop = _19.value;
-                                                            if (prop !== "decipherable") {
+                                                        for(var _iterator12 = Object.keys(newRepresentation)[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true){
+                                                            var prop3 = _step12.value;
+                                                            if (prop3 !== "decipherable") {
                                                                 // eslint-disable-next-line
-                                                                baseRepresentation[prop] = newRepresentation[prop];
+                                                                baseRepresentation[prop3] = newRepresentation[prop3];
                                                             }
                                                         }
-                                                    }
-                                                    catch (e_21_1) { e_21 = { error: e_21_1 }; }
-                                                    finally {
+                                                    } catch (err) {
+                                                        _didIteratorError12 = true;
+                                                        _iteratorError12 = err;
+                                                    } finally{
                                                         try {
-                                                            if (_19 && !_19.done && (_o = _18.return)) _o.call(_18);
+                                                            if (!_iteratorNormalCompletion12 && _iterator12.return != null) {
+                                                                _iterator12.return();
+                                                            }
+                                                        } finally{
+                                                            if (_didIteratorError12) {
+                                                                throw _iteratorError12;
+                                                            }
                                                         }
-                                                        finally { if (e_21) throw e_21.error; }
                                                     }
                                                     break;
                                                 }
                                             }
                                         }
-                                    }
-                                    catch (e_20_1) { e_20 = { error: e_20_1 }; }
-                                    finally {
+                                    } catch (err) {
+                                        _didIteratorError11 = true;
+                                        _iteratorError11 = err;
+                                    } finally{
                                         try {
-                                            if (_17 && !_17.done && (_m = _16.return)) _m.call(_16);
+                                            if (!_iteratorNormalCompletion11 && _iterator11.return != null) {
+                                                _iterator11.return();
+                                            }
+                                        } finally{
+                                            if (_didIteratorError11) {
+                                                throw _iteratorError11;
+                                            }
                                         }
-                                        finally { if (e_20) throw e_20.error; }
                                     }
+                                    var _iteratorNormalCompletion13 = true, _didIteratorError13 = false, _iteratorError13 = undefined;
                                     try {
-                                        for (var _20 = (e_22 = void 0, __values(updatedAdaptation.addedRepresentations)), _21 = _20.next(); !_21.done; _21 = _20.next()) {
-                                            var addedRepresentation = _21.value;
+                                        for(var _iterator13 = updatedAdaptation.addedRepresentations[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true){
+                                            var addedRepresentation = _step13.value;
                                             baseAdaptation.representations.push(addedRepresentation);
                                         }
-                                    }
-                                    catch (e_22_1) { e_22 = { error: e_22_1 }; }
-                                    finally {
+                                    } catch (err) {
+                                        _didIteratorError13 = true;
+                                        _iteratorError13 = err;
+                                    } finally{
                                         try {
-                                            if (_21 && !_21.done && (_p = _20.return)) _p.call(_20);
+                                            if (!_iteratorNormalCompletion13 && _iterator13.return != null) {
+                                                _iterator13.return();
+                                            }
+                                        } finally{
+                                            if (_didIteratorError13) {
+                                                throw _iteratorError13;
+                                            }
                                         }
-                                        finally { if (e_22) throw e_22.error; }
                                     }
                                     break;
                                 }
                             }
                         }
-                    }
-                    catch (e_18_1) { e_18 = { error: e_18_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError9 = true;
+                        _iteratorError9 = err;
+                    } finally{
                         try {
-                            if (_13 && !_13.done && (_k = _12.return)) _k.call(_12);
+                            if (!_iteratorNormalCompletion9 && _iterator9.return != null) {
+                                _iterator9.return();
+                            }
+                        } finally{
+                            if (_didIteratorError9) {
+                                throw _iteratorError9;
+                            }
                         }
-                        finally { if (e_18) throw e_18.error; }
                     }
+                    var _iteratorNormalCompletion14 = true, _didIteratorError14 = false, _iteratorError14 = undefined;
                     try {
-                        for (var _22 = (e_23 = void 0, __values(updatedPeriod.result.addedAdaptations)), _23 = _22.next(); !_23.done; _23 = _22.next()) {
-                            var addedAdaptation = _23.value;
-                            var ttype = addedAdaptation.type;
-                            var adaptationsForType = basePeriod.adaptations[ttype];
-                            if (adaptationsForType === undefined) {
-                                basePeriod.adaptations[ttype] = [addedAdaptation];
-                            }
-                            else {
-                                adaptationsForType.push(addedAdaptation);
+                        for(var _iterator14 = updatedPeriod.result.addedAdaptations[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true){
+                            var addedAdaptation = _step14.value;
+                            var ttype2 = addedAdaptation.type;
+                            var adaptationsForType2 = basePeriod.adaptations[ttype2];
+                            if (adaptationsForType2 === undefined) {
+                                basePeriod.adaptations[ttype2] = [
+                                    addedAdaptation
+                                ];
+                            } else {
+                                adaptationsForType2.push(addedAdaptation);
                             }
                         }
-                    }
-                    catch (e_23_1) { e_23 = { error: e_23_1 }; }
-                    finally {
+                    } catch (err) {
+                        _didIteratorError14 = true;
+                        _iteratorError14 = err;
+                    } finally{
                         try {
-                            if (_23 && !_23.done && (_q = _22.return)) _q.call(_22);
+                            if (!_iteratorNormalCompletion14 && _iterator14.return != null) {
+                                _iterator14.return();
+                            }
+                        } finally{
+                            if (_didIteratorError14) {
+                                throw _iteratorError14;
+                            }
                         }
-                        finally { if (e_23) throw e_23.error; }
                     }
                     break;
                 }
             }
         }
-    }
-    catch (e_11_1) { e_11 = { error: e_11_1 }; }
-    finally {
+    } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+    } finally{
         try {
-            if (_z && !_z.done && (_c = _y.return)) _c.call(_y);
+            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                _iterator2.return();
+            }
+        } finally{
+            if (_didIteratorError2) {
+                throw _iteratorError2;
+            }
         }
-        finally { if (e_11) throw e_11.error; }
     }
+    var _iteratorNormalCompletion15 = true, _didIteratorError15 = false, _iteratorError15 = undefined;
     try {
-        for (var _24 = __values(updates.addedPeriods), _25 = _24.next(); !_25.done; _25 = _24.next()) {
-            var addedPeriod = _25.value;
-            for (var periodIdx = 0; periodIdx < baseManifest.periods.length; periodIdx++) {
-                if (baseManifest.periods[periodIdx].start > addedPeriod.start) {
-                    baseManifest.periods.splice(periodIdx, 0, addedPeriod);
+        for(var _iterator15 = updates.addedPeriods[Symbol.iterator](), _step15; !(_iteratorNormalCompletion15 = (_step15 = _iterator15.next()).done); _iteratorNormalCompletion15 = true){
+            var addedPeriod = _step15.value;
+            for(var periodIdx2 = 0; periodIdx2 < baseManifest.periods.length; periodIdx2++){
+                if (baseManifest.periods[periodIdx2].start > addedPeriod.start) {
+                    baseManifest.periods.splice(periodIdx2, 0, addedPeriod);
                     break;
                 }
             }
             baseManifest.periods.push(addedPeriod);
         }
-    }
-    catch (e_24_1) { e_24 = { error: e_24_1 }; }
-    finally {
+    } catch (err) {
+        _didIteratorError15 = true;
+        _iteratorError15 = err;
+    } finally{
         try {
-            if (_25 && !_25.done && (_r = _24.return)) _r.call(_24);
+            if (!_iteratorNormalCompletion15 && _iterator15.return != null) {
+                _iterator15.return();
+            }
+        } finally{
+            if (_didIteratorError15) {
+                throw _iteratorError15;
+            }
         }
-        finally { if (e_24) throw e_24.error; }
     }
 }
 function createRepresentationFilterFromFnString(fnString) {