rx-player 4.5.0 → 4.6.0-dev.2026100600

package/dist/commonjs/core/stream/orchestrator/stream_orchestrator.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,105 +12,11 @@
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = StreamOrchestrator;
-var config_1 = require("../../../config");
-var errors_1 = require("../../../errors");
-var log_1 = require("../../../log");
-var is_null_or_undefined_1 = require("../../../utils/is_null_or_undefined");
-var queue_microtask_1 = require("../../../utils/queue_microtask");
-var reference_1 = require("../../../utils/reference");
-var sorted_list_1 = require("../../../utils/sorted_list");
-var task_canceller_1 = require("../../../utils/task_canceller");
-var weak_map_memory_1 = require("../../../utils/weak_map_memory");
-var segment_sinks_1 = require("../../segment_sinks");
-var period_1 = require("../period");
-var get_time_ranges_for_content_1 = require("./get_time_ranges_for_content");
-/**
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
  * Create and manage the various "Streams" needed for the content to
  * play:
  *
@@ -152,45 +57,227 @@ var get_time_ranges_for_content_1 = require("./get_time_ranges_for_content");
  * @param {Object} orchestratorCancelSignal - `CancellationSignal` allowing,
  * when triggered, to immediately stop all operations the `PeriodStream` is
  * doing.
- */
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return StreamOrchestrator;
+    }
+});
+var _config = /*#__PURE__*/ _interop_require_default(require("../../../config.js"));
+var _index = require("../../../errors/index.js");
+var _log = /*#__PURE__*/ _interop_require_default(require("../../../log.js"));
+var _is_null_or_undefined = /*#__PURE__*/ _interop_require_default(require("../../../utils/is_null_or_undefined.js"));
+var _queue_microtask = /*#__PURE__*/ _interop_require_default(require("../../../utils/queue_microtask.js"));
+var _reference = require("../../../utils/reference.js");
+var _sorted_list = /*#__PURE__*/ _interop_require_default(require("../../../utils/sorted_list.js"));
+var _task_canceller = /*#__PURE__*/ _interop_require_default(require("../../../utils/task_canceller.js"));
+var _weak_map_memory = /*#__PURE__*/ _interop_require_default(require("../../../utils/weak_map_memory.js"));
+var _index1 = require("../../segment_sinks/index.js");
+var _index2 = /*#__PURE__*/ _interop_require_default(require("../period/index.js"));
+var _get_time_ranges_for_content = /*#__PURE__*/ _interop_require_default(require("./get_time_ranges_for_content.js"));
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 function StreamOrchestrator(content, playbackObserver, representationEstimator, segmentSinksStore, segmentQueueCreator, options, callbacks, orchestratorCancelSignal) {
-    var e_1, _a;
     var manifest = content.manifest, initialPeriod = content.initialPeriod;
     var maxBufferAhead = options.maxBufferAhead, maxBufferBehind = options.maxBufferBehind, wantedBufferAhead = options.wantedBufferAhead, maxVideoBufferSize = options.maxVideoBufferSize;
-    var _b = config_1.default.getCurrent(), MINIMUM_MAX_BUFFER_AHEAD = _b.MINIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_AHEAD = _b.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND = _b.MAXIMUM_MAX_BUFFER_BEHIND;
+    var _config_getCurrent = _config.default.getCurrent(), MINIMUM_MAX_BUFFER_AHEAD = _config_getCurrent.MINIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_AHEAD = _config_getCurrent.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND = _config_getCurrent.MAXIMUM_MAX_BUFFER_BEHIND;
     // Keep track of a unique BufferGarbageCollector created per
     // SegmentSink.
-    var garbageCollectors = new weak_map_memory_1.default(function (segmentSink) {
+    var garbageCollectors = new _weak_map_memory.default(function(segmentSink) {
         var _a, _b;
         var bufferType = segmentSink.bufferType;
         var defaultMaxBehind = (_a = MAXIMUM_MAX_BUFFER_BEHIND[bufferType]) !== null && _a !== void 0 ? _a : Infinity;
         var maxAheadHigherBound = (_b = MAXIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _b !== void 0 ? _b : Infinity;
-        return function (gcCancelSignal) {
-            (0, segment_sinks_1.BufferGarbageCollector)({
+        return function(gcCancelSignal) {
+            (0, _index1.BufferGarbageCollector)({
                 segmentSink: segmentSink,
                 playbackObserver: playbackObserver,
-                maxBufferBehind: (0, reference_1.createMappedReference)(maxBufferBehind, function (val) { return Math.min(val, defaultMaxBehind); }, gcCancelSignal),
-                maxBufferAhead: (0, reference_1.createMappedReference)(maxBufferAhead, function (val) {
+                maxBufferBehind: (0, _reference.createMappedReference)(maxBufferBehind, function(val) {
+                    return Math.min(val, defaultMaxBehind);
+                }, gcCancelSignal),
+                maxBufferAhead: (0, _reference.createMappedReference)(maxBufferAhead, function(val) {
                     var _a;
                     var lowerBound = Math.max(val, (_a = MINIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _a !== void 0 ? _a : 0);
                     return Math.min(lowerBound, maxAheadHigherBound);
-                }, gcCancelSignal),
+                }, gcCancelSignal)
             }, gcCancelSignal);
         };
     });
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
         // Create automatically the right `PeriodStream` for every possible types
-        for (var _c = __values(segmentSinksStore.getBufferTypes()), _d = _c.next(); !_d.done; _d = _c.next()) {
-            var bufferType = _d.value;
+        for(var _iterator = segmentSinksStore.getBufferTypes()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var bufferType = _step.value;
             manageEveryStreams(bufferType, initialPeriod);
         }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
         try {
-            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
         }
-        finally { if (e_1) throw e_1.error; }
     }
     /**
      * Manage creation and removal of Streams for every Periods for a given type.
@@ -200,61 +287,72 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
      * current position goes out of the bounds of these Streams.
      * @param {string} bufferType - e.g. "audio" or "video"
      * @param {Period} basePeriod - Initial Period downloaded.
-     */
-    function manageEveryStreams(bufferType, basePeriod) {
-        /** Each Period for which there is currently a Stream, chronologically */
-        var periodList = new sorted_list_1.default(function (a, b) { return a.start - b.start; });
+     */ function manageEveryStreams(bufferType, basePeriod) {
+        /** Each Period for which there is currently a Stream, chronologically */ var periodList = new _sorted_list.default(function(a, b) {
+            return a.start - b.start;
+        });
         /**
          * When set to `true`, all the currently active PeriodStream will be destroyed
          * and re-created from the new current position if we detect it to be out of
          * their bounds.
          * This is set to false when we're in the process of creating the first
          * PeriodStream, to avoid interferences while no PeriodStream is available.
-         */
-        var enableOutOfBoundsCheck = false;
-        /** Cancels all currently created `PeriodStream`s. */
-        var allStreamsCanceller = new task_canceller_1.default("StreamOrchestrator Streams for " + bufferType);
+         */ var enableOutOfBoundsCheck = false;
+        /** Cancels all currently created `PeriodStream`s. */ var allStreamsCanceller = new _task_canceller.default("StreamOrchestrator Streams for " + bufferType);
         allStreamsCanceller.linkToSignal(orchestratorCancelSignal);
         // Restart the current Stream when the wanted time is in another period
         // than the ones already considered
-        playbackObserver.listen(function (_a) {
-            var position = _a.position;
+        playbackObserver.listen(function(param) {
+            var position = param.position;
             var time = position.getWanted();
             if (!enableOutOfBoundsCheck || !isOutOfPeriodList(time)) {
                 return;
             }
-            var getNewBasePeriod = function () { var _a; return (_a = manifest.getPeriodForTime(time)) !== null && _a !== void 0 ? _a : manifest.getNextPeriod(time); };
+            var getNewBasePeriod = function getNewBasePeriod() {
+                var _a;
+                return (_a = manifest.getPeriodForTime(time)) !== null && _a !== void 0 ? _a : manifest.getNextPeriod(time);
+            };
             var nextPeriod = getNewBasePeriod();
-            if (!(0, is_null_or_undefined_1.default)(nextPeriod) && periodList.has(nextPeriod)) {
+            if (!(0, _is_null_or_undefined.default)(nextPeriod) && periodList.has(nextPeriod)) {
                 // Last check just for resilience reasons that the wanted Period is
                 // not one of the already-handled ones
                 return;
             }
-            log_1.default.info("Stream", "Destroying all PeriodStreams due to out of bounds situation", { bufferType: bufferType, time: time });
+            _log.default.info("Stream", "Destroying all PeriodStreams due to out of bounds situation", {
+                bufferType: bufferType,
+                time: time
+            });
             enableOutOfBoundsCheck = false;
-            while (periodList.length() > 0) {
+            while(periodList.length() > 0){
                 var period = periodList.get(periodList.length() - 1);
                 periodList.removeElement(period);
-                callbacks.periodStreamCleared({ type: bufferType, manifest: manifest, period: period });
+                callbacks.periodStreamCleared({
+                    type: bufferType,
+                    manifest: manifest,
+                    period: period
+                });
             }
             allStreamsCanceller.cancel("PeriodStream is out of bounds");
-            allStreamsCanceller = new task_canceller_1.default("StreamOrchestrator Streams for " + bufferType);
+            allStreamsCanceller = new _task_canceller.default("StreamOrchestrator Streams for " + bufferType);
             allStreamsCanceller.linkToSignal(orchestratorCancelSignal);
             // As previous callbacks may have performed unknown side-effects, just
             // re-compute the next Period now.
             nextPeriod = getNewBasePeriod();
             if (nextPeriod === undefined) {
-                log_1.default.warn("Stream", "The wanted position is not found in the Manifest.");
+                _log.default.warn("Stream", "The wanted position is not found in the Manifest.");
                 enableOutOfBoundsCheck = true;
                 return;
             }
             launchConsecutiveStreamsForPeriod(nextPeriod);
-        }, { clearSignal: orchestratorCancelSignal, includeLastObservation: true });
-        manifest.addEventListener("decipherabilityUpdate", function (evt) {
+        }, {
+            clearSignal: orchestratorCancelSignal,
+            includeLastObservation: true
+        });
+        manifest.addEventListener("decipherabilityUpdate", function(evt) {
             if (orchestratorCancelSignal.isCancelled()) {
                 return;
             }
-            onDecipherabilityUpdates(evt).catch(function (err) {
+            onDecipherabilityUpdates(evt).catch(function(err) {
                 if (orchestratorCancelSignal.isCancelled()) {
                     return;
                 }
@@ -265,36 +363,39 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
         return launchConsecutiveStreamsForPeriod(basePeriod);
         /**
          * @param {Object} period
-         */
-        function launchConsecutiveStreamsForPeriod(period) {
-            var consecutivePeriodStreamCb = __assign(__assign({}, callbacks), { waitingMediaSourceReload: function (payload) {
+         */ function launchConsecutiveStreamsForPeriod(period) {
+            var consecutivePeriodStreamCb = Object.assign(Object.assign({}, callbacks), {
+                waitingMediaSourceReload: function waitingMediaSourceReload(payload) {
                     // Only reload the MediaSource when the more immediately required
                     // Period is the one it is asked for
                     var firstPeriod = periodList.head();
                     if (firstPeriod === undefined || firstPeriod.id !== payload.period.id) {
                         callbacks.lockedStream({
                             bufferType: payload.bufferType,
-                            period: payload.period,
+                            period: payload.period
                         });
-                    }
-                    else {
+                    } else {
                         callbacks.needsMediaSourceReload({
                             timeOffset: payload.timeOffset,
                             minimumPosition: payload.stayInPeriod ? payload.period.start : undefined,
-                            maximumPosition: payload.stayInPeriod ? payload.period.end : undefined,
+                            maximumPosition: payload.stayInPeriod ? payload.period.end : undefined
                         });
                     }
-                }, periodStreamReady: function (payload) {
+                },
+                periodStreamReady: function periodStreamReady(payload) {
                     enableOutOfBoundsCheck = true;
                     periodList.add(payload.period);
                     callbacks.periodStreamReady(payload);
-                }, periodStreamCleared: function (payload) {
+                },
+                periodStreamCleared: function periodStreamCleared(payload) {
                     periodList.removeElement(payload.period);
                     callbacks.periodStreamCleared(payload);
-                }, error: function (err) {
+                },
+                error: function error(err) {
                     allStreamsCanceller.cancel("PeriodStream err callback");
                     callbacks.error(err);
-                } });
+                }
+            });
             manageConsecutivePeriodStreams(bufferType, period, consecutivePeriodStreamCb, allStreamsCanceller.signal);
         }
         /**
@@ -303,97 +404,153 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
          *   - more than the end of the chronologically last Period
          * @param {number} time
          * @returns {boolean}
-         */
-        function isOutOfPeriodList(time) {
+         */ function isOutOfPeriodList(time) {
             var head = periodList.head();
             var last = periodList.last();
             if (head === undefined || last === undefined) {
                 // if no period
                 return true;
             }
-            return (head.start > time || ((0, is_null_or_undefined_1.default)(last.end) ? Infinity : last.end) < time);
+            return head.start > time || ((0, _is_null_or_undefined.default)(last.end) ? Infinity : last.end) < time;
         }
         /**
          * React to a Manifest's `decipherabilityUpdate` event.
          * @param {Array.<Object>} updates
          * @returns {Promise}
-         */
-        function onDecipherabilityUpdates(updates) {
-            return __awaiter(this, void 0, void 0, function () {
-                var segmentSinkStatus, ofCurrentType, segmentSink, resettedContent, undecipherableContent, undecipherableRanges, rangesToRemove, period, restartCanceller, _a, _b, _c, start, end, e_2_1;
-                var e_2, _d;
-                return __generator(this, function (_e) {
-                    switch (_e.label) {
+         */ function onDecipherabilityUpdates(updates) {
+            return _async_to_generator(function() {
+                var segmentSinkStatus, ofCurrentType, segmentSink, resettedContent, undecipherableContent, undecipherableRanges, rangesToRemove, period, restartCanceller, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, start, end, err;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
                         case 0:
                             segmentSinkStatus = segmentSinksStore.getStatus(bufferType);
-                            ofCurrentType = updates.filter(function (update) { return update.adaptation.type === bufferType; });
-                            if (
-                            // No update concerns the current type of data
-                            ofCurrentType.length === 0 ||
-                                segmentSinkStatus.type !== "initialized" ||
-                                // The update only notifies of now-decipherable streams
-                                ofCurrentType.every(function (x) { return x.representation.decipherable === true; })) {
+                            ofCurrentType = updates.filter(function(update) {
+                                return update.adaptation.type === bufferType;
+                            });
+                            if (// No update concerns the current type of data
+                            ofCurrentType.length === 0 || segmentSinkStatus.type !== "initialized" || // The update only notifies of now-decipherable streams
+                            ofCurrentType.every(function(x) {
+                                return x.representation.decipherable === true;
+                            })) {
                                 // Data won't have to be removed from the buffers, no need to stop the
                                 // current Streams.
-                                return [2 /*return*/];
+                                return [
+                                    2
+                                ];
                             }
                             segmentSink = segmentSinkStatus.value;
-                            resettedContent = ofCurrentType.filter(function (update) { return update.representation.decipherable === undefined; });
-                            undecipherableContent = ofCurrentType.filter(function (update) { return update.representation.decipherable === false; });
-                            undecipherableRanges = (0, get_time_ranges_for_content_1.default)(segmentSink, undecipherableContent);
-                            rangesToRemove = (0, get_time_ranges_for_content_1.default)(segmentSink, resettedContent);
+                            resettedContent = ofCurrentType.filter(function(update) {
+                                return update.representation.decipherable === undefined;
+                            });
+                            undecipherableContent = ofCurrentType.filter(function(update) {
+                                return update.representation.decipherable === false;
+                            });
+                            /**
+             * Time ranges now containing undecipherable content.
+             * Those should first be removed and, depending on the platform, may
+             * need Supplementary actions as playback issues may remain even after
+             * removal.
+             */ undecipherableRanges = (0, _get_time_ranges_for_content.default)(segmentSink, undecipherableContent);
+                            /**
+             * Time ranges now containing content whose decipherability status came
+             * back to being unknown.
+             * To simplify its handling, those are just removed from the buffer.
+             * Less considerations have to be taken than for the `undecipherableRanges`.
+             */ rangesToRemove = (0, _get_time_ranges_for_content.default)(segmentSink, resettedContent);
                             // First close all Stream currently active so they don't continue to
                             // load and push segments.
-                            log_1.default.info("Stream", "Destroying all PeriodStreams for decipherability matters", {
-                                bufferType: bufferType,
+                            _log.default.info("Stream", "Destroying all PeriodStreams for decipherability matters", {
+                                bufferType: bufferType
                             });
                             enableOutOfBoundsCheck = false;
-                            while (periodList.length() > 0) {
+                            while(periodList.length() > 0){
                                 period = periodList.get(periodList.length() - 1);
                                 periodList.removeElement(period);
-                                callbacks.periodStreamCleared({ type: bufferType, manifest: manifest, period: period });
+                                callbacks.periodStreamCleared({
+                                    type: bufferType,
+                                    manifest: manifest,
+                                    period: period
+                                });
                             }
                             allStreamsCanceller.cancel("decipherability update");
-                            allStreamsCanceller = new task_canceller_1.default("StreamOrchestrator Streams for " + bufferType);
+                            allStreamsCanceller = new _task_canceller.default("StreamOrchestrator Streams for " + bufferType);
                             allStreamsCanceller.linkToSignal(orchestratorCancelSignal);
-                            restartCanceller = allStreamsCanceller;
-                            _e.label = 1;
+                            /**
+             * Re-capture of this new `allStreamsCanceller` in a local context, to be
+             * able to re-check specifically it after asynchronous tasks or side-effects
+             */ restartCanceller = allStreamsCanceller;
+                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                            _state.label = 1;
                         case 1:
-                            _e.trys.push([1, 6, 7, 8]);
-                            _a = __values(__spreadArray(__spreadArray([], __read(undecipherableRanges), false), __read(rangesToRemove), false)), _b = _a.next();
-                            _e.label = 2;
+                            _state.trys.push([
+                                1,
+                                6,
+                                7,
+                                8
+                            ]);
+                            _iterator = _to_consumable_array(undecipherableRanges).concat(_to_consumable_array(rangesToRemove))[Symbol.iterator]();
+                            _state.label = 2;
                         case 2:
-                            if (!!_b.done) return [3 /*break*/, 5];
-                            _c = _b.value, start = _c.start, end = _c.end;
+                            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                3,
+                                5
+                            ];
+                            _step_value = _step.value, start = _step_value.start, end = _step_value.end;
                             // NOTE: This check is **voluntarily** inside the loop, as side-effects
                             // might happen during it
                             if (restartCanceller.isUsed()) {
-                                return [2 /*return*/];
+                                return [
+                                    2
+                                ];
                             }
-                            if (!(start < end)) return [3 /*break*/, 4];
-                            return [4 /*yield*/, segmentSink.removeBuffer(start, end)];
+                            if (!(start < end)) return [
+                                3,
+                                4
+                            ];
+                            return [
+                                4,
+                                segmentSink.removeBuffer(start, end)
+                            ];
                         case 3:
-                            _e.sent();
-                            _e.label = 4;
+                            _state.sent();
+                            _state.label = 4;
                         case 4:
-                            _b = _a.next();
-                            return [3 /*break*/, 2];
-                        case 5: return [3 /*break*/, 8];
+                            _iteratorNormalCompletion = true;
+                            return [
+                                3,
+                                2
+                            ];
+                        case 5:
+                            return [
+                                3,
+                                8
+                            ];
                         case 6:
-                            e_2_1 = _e.sent();
-                            e_2 = { error: e_2_1 };
-                            return [3 /*break*/, 8];
+                            err = _state.sent();
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                            return [
+                                3,
+                                8
+                            ];
                         case 7:
                             try {
-                                if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
                             }
-                            finally { if (e_2) throw e_2.error; }
-                            return [7 /*endfinally*/];
+                            return [
+                                7
+                            ];
                         case 8:
                             // Schedule micro task before checking the last playback observation
                             // to reduce the risk of race conditions where the next observation
                             // was going to be emitted synchronously.
-                            (0, queue_microtask_1.default)(function () {
+                            (0, _queue_microtask.default)(function() {
                                 if (restartCanceller.signal.isCancelled()) {
                                     return;
                                 }
@@ -404,8 +561,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                                     if (restartCanceller.isUsed()) {
                                         return;
                                     }
-                                }
-                                else if (needsFlushingAfterClean(observation, rangesToRemove)) {
+                                } else if (needsFlushingAfterClean(observation, rangesToRemove)) {
                                     callbacks.needsBufferFlush();
                                     if (restartCanceller.isUsed()) {
                                         return;
@@ -416,30 +572,32 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
                                 if (newInitialPeriod === undefined) {
                                     // If there's no Period for the current position exactly, select the next one
                                     newInitialPeriod = manifest.getNextPeriod(lastPosition);
-                                    log_1.default.warn("Stream", "No Period found for the reloading position, selecting next one instead", {
+                                    _log.default.warn("Stream", "No Period found for the reloading position, selecting next one instead", {
                                         reloadPosition: lastPosition,
-                                        nextPeriodStart: newInitialPeriod === null || newInitialPeriod === void 0 ? void 0 : newInitialPeriod.start,
+                                        nextPeriodStart: newInitialPeriod === null || newInitialPeriod === void 0 ? void 0 : newInitialPeriod.start
                                     });
                                 }
                                 if (newInitialPeriod === undefined) {
                                     // If there's no Period after the current position, select the last one
                                     newInitialPeriod = manifest.periods[manifest.periods.length - 1];
-                                    log_1.default.warn("Stream", "No Period found for of after the reloading position, selecting the last one", {
+                                    _log.default.warn("Stream", "No Period found for of after the reloading position, selecting the last one", {
                                         reloadPosition: lastPosition,
                                         nextPeriodStart: newInitialPeriod === null || newInitialPeriod === void 0 ? void 0 : newInitialPeriod.start,
-                                        nextPeriodEnd: newInitialPeriod === null || newInitialPeriod === void 0 ? void 0 : newInitialPeriod.end,
+                                        nextPeriodEnd: newInitialPeriod === null || newInitialPeriod === void 0 ? void 0 : newInitialPeriod.end
                                     });
                                 }
                                 if (newInitialPeriod === undefined) {
-                                    callbacks.error(new errors_1.MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest."));
+                                    callbacks.error(new _index.MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest."));
                                     return;
                                 }
                                 launchConsecutiveStreamsForPeriod(newInitialPeriod);
                             });
-                            return [2 /*return*/];
+                            return [
+                                2
+                            ];
                     }
                 });
-            });
+            })();
         }
     }
     /**
@@ -472,48 +630,51 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
      * everything that this function was doing. Callbacks in
      * `consecutivePeriodStreamCb` might still be sent as a consequence of this
      * signal emitting.
-     */
-    function manageConsecutivePeriodStreams(bufferType, basePeriod, consecutivePeriodStreamCb, cancelSignal) {
-        log_1.default.info("Stream", "Creating new PeriodStream", {
+     */ function manageConsecutivePeriodStreams(bufferType, basePeriod, consecutivePeriodStreamCb, cancelSignal) {
+        _log.default.info("Stream", "Creating new PeriodStream", {
             bufferType: bufferType,
-            periodStart: basePeriod.start,
+            periodStart: basePeriod.start
         });
         /**
          * Contains properties linnked to the next chronological `PeriodStream` that
          * may be created here.
-         */
-        var nextStreamInfo = null;
-        /** Emits when the `PeriodStream` linked to `basePeriod` should be destroyed. */
-        var currentStreamCanceller = new task_canceller_1.default("StreamOrchestrator current consecutive Streams " + bufferType);
+         */ var nextStreamInfo = null;
+        /** Emits when the `PeriodStream` linked to `basePeriod` should be destroyed. */ var currentStreamCanceller = new _task_canceller.default("StreamOrchestrator current consecutive Streams " + bufferType);
         currentStreamCanceller.linkToSignal(cancelSignal);
         // Stop current PeriodStream when the current position goes over the end of
         // that Period.
-        playbackObserver.listen(function (_a, stopListeningObservations) {
-            var position = _a.position;
+        playbackObserver.listen(function(param, stopListeningObservations) {
+            var position = param.position;
             if (basePeriod.end !== undefined && position.getWanted() >= basePeriod.end) {
                 var nextPeriod = manifest.getPeriodAfter(basePeriod);
                 // Handle special wantedPosition === basePeriod.end cases
                 if (basePeriod.containsTime(position.getWanted(), nextPeriod)) {
                     return;
                 }
-                log_1.default.info("Stream", "Destroying PeriodStream as the current playhead moved above it", {
+                _log.default.info("Stream", "Destroying PeriodStream as the current playhead moved above it", {
                     bufferType: bufferType,
                     periodStart: basePeriod.start,
                     periodEnd: basePeriod.end,
-                    position: position.getWanted(),
+                    position: position.getWanted()
                 });
                 stopListeningObservations();
                 consecutivePeriodStreamCb.periodStreamCleared({
                     type: bufferType,
                     manifest: manifest,
-                    period: basePeriod,
+                    period: basePeriod
                 });
                 currentStreamCanceller.cancel("Position ahead of PeriodStream");
             }
-        }, { clearSignal: cancelSignal, includeLastObservation: true });
+        }, {
+            clearSignal: cancelSignal,
+            includeLastObservation: true
+        });
         var periodStreamArgs = {
             bufferType: bufferType,
-            content: { manifest: manifest, period: basePeriod },
+            content: {
+                manifest: manifest,
+                period: basePeriod
+            },
             garbageCollectors: garbageCollectors,
             maxVideoBufferSize: maxVideoBufferSize,
             segmentQueueCreator: segmentQueueCreator,
@@ -521,65 +682,69 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
             options: options,
             playbackObserver: playbackObserver,
             representationEstimator: representationEstimator,
-            wantedBufferAhead: wantedBufferAhead,
+            wantedBufferAhead: wantedBufferAhead
         };
-        var periodStreamCallbacks = __assign(__assign({}, consecutivePeriodStreamCb), { streamStatusUpdate: function (value) {
+        var periodStreamCallbacks = Object.assign(Object.assign({}, consecutivePeriodStreamCb), {
+            streamStatusUpdate: function streamStatusUpdate(value) {
                 if (value.hasFinishedLoading) {
                     var nextPeriod = manifest.getPeriodAfter(basePeriod);
                     if (nextPeriod !== null) {
                         // current Stream is full, create the next one if not
                         checkOrCreateNextPeriodStream(nextPeriod);
                     }
-                }
-                else if (nextStreamInfo !== null) {
+                } else if (nextStreamInfo !== null) {
                     // current Stream is active, destroy next Stream if created
-                    log_1.default.info("Stream", "Destroying next PeriodStream due to current one being active", {
+                    _log.default.info("Stream", "Destroying next PeriodStream due to current one being active", {
                         bufferType: bufferType,
                         periodStart: basePeriod.start,
-                        nextPeriodStart: nextStreamInfo.period.start,
+                        nextPeriodStart: nextStreamInfo.period.start
                     });
                     consecutivePeriodStreamCb.periodStreamCleared({
                         type: bufferType,
                         manifest: manifest,
-                        period: nextStreamInfo.period,
+                        period: nextStreamInfo.period
                     });
                     nextStreamInfo.canceller.cancel("previous PeriodStream is active");
                     nextStreamInfo = null;
                 }
                 consecutivePeriodStreamCb.streamStatusUpdate(value);
-            }, error: function (err) {
+            },
+            error: function error(err) {
                 if (nextStreamInfo !== null) {
                     nextStreamInfo.canceller.cancel("previous PeriodStream err");
                     nextStreamInfo = null;
                 }
                 currentStreamCanceller.cancel("PeriodStream err");
                 consecutivePeriodStreamCb.error(err);
-            } });
-        (0, period_1.default)(periodStreamArgs, periodStreamCallbacks, currentStreamCanceller.signal);
+            }
+        });
+        (0, _index2.default)(periodStreamArgs, periodStreamCallbacks, currentStreamCanceller.signal);
         handleUnexpectedManifestUpdates(currentStreamCanceller.signal);
         /**
          * Create `PeriodStream` for the next Period, specified under `nextPeriod`.
          * @param {Object} nextPeriod
-         */
-        function checkOrCreateNextPeriodStream(nextPeriod) {
+         */ function checkOrCreateNextPeriodStream(nextPeriod) {
             if (nextStreamInfo !== null) {
                 if (nextStreamInfo.period.id === nextPeriod.id) {
                     return;
                 }
-                log_1.default.warn("Stream", "Creating next `PeriodStream` while one was already created.", {
+                _log.default.warn("Stream", "Creating next `PeriodStream` while one was already created.", {
                     bufferType: bufferType,
-                    nextPeriodStart: nextPeriod.start,
+                    nextPeriodStart: nextPeriod.start
                 });
                 consecutivePeriodStreamCb.periodStreamCleared({
                     type: bufferType,
                     manifest: manifest,
-                    period: nextStreamInfo.period,
+                    period: nextStreamInfo.period
                 });
                 nextStreamInfo.canceller.cancel("PeriodStream recreation");
             }
-            var nextStreamCanceller = new task_canceller_1.default("StreamOrchestrator next PeriodStream " + bufferType);
+            var nextStreamCanceller = new _task_canceller.default("StreamOrchestrator next PeriodStream " + bufferType);
             nextStreamCanceller.linkToSignal(cancelSignal);
-            nextStreamInfo = { canceller: nextStreamCanceller, period: nextPeriod };
+            nextStreamInfo = {
+                canceller: nextStreamCanceller,
+                period: nextPeriod
+            };
             manageConsecutivePeriodStreams(bufferType, nextPeriod, consecutivePeriodStreamCb, nextStreamInfo.canceller.signal);
         }
         /**
@@ -588,59 +753,62 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
          * handling cases where it does not.
          * @param {Object} innerCancelSignal - When that cancel signal emits, stop
          * performing checks.
-         */
-        function handleUnexpectedManifestUpdates(innerCancelSignal) {
-            manifest.addEventListener("manifestUpdate", function (updates) {
-                var e_3, _a;
+         */ function handleUnexpectedManifestUpdates(innerCancelSignal) {
+            manifest.addEventListener("manifestUpdate", function(updates) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                 try {
                     // If current period has been unexpectedly removed, ask to reload
-                    for (var _b = __values(updates.removedPeriods), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var period = _c.value;
+                    for(var _iterator = updates.removedPeriods[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var period = _step.value;
                         if (period.id === basePeriod.id) {
                             // Check that this was not just one  of the earliests Periods that
                             // was removed, in which case this is a normal cleanup scenario
-                            if (manifest.periods.length > 0 &&
-                                manifest.periods[0].start <= period.start) {
+                            if (manifest.periods.length > 0 && manifest.periods[0].start <= period.start) {
                                 // We begin by scheduling a micro-task to reduce the possibility of race
                                 // conditions where the inner logic would be called synchronously before
                                 // the next observation (which may reflect very different playback
                                 // conditions) is actually received.
-                                return (0, queue_microtask_1.default)(function () {
+                                return (0, _queue_microtask.default)(function() {
                                     if (innerCancelSignal.isCancelled()) {
                                         return;
                                     }
                                     return callbacks.needsMediaSourceReload({
                                         timeOffset: 0,
                                         minimumPosition: undefined,
-                                        maximumPosition: undefined,
+                                        maximumPosition: undefined
                                     });
                                 });
                             }
-                        }
-                        else if (period.start > basePeriod.start) {
+                        } else if (period.start > basePeriod.start) {
                             break;
                         }
                     }
-                }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                finally {
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
                     try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
                     }
-                    finally { if (e_3) throw e_3.error; }
                 }
                 // If the next period changed, cancel the next created one if one
                 if (nextStreamInfo !== null) {
                     var newNextPeriod = manifest.getPeriodAfter(basePeriod);
                     if (newNextPeriod === null || nextStreamInfo.period.id !== newNextPeriod.id) {
-                        log_1.default.warn("Stream", "Destroying next PeriodStream due to manifest update", {
+                        _log.default.warn("Stream", "Destroying next PeriodStream due to manifest update", {
                             bufferType: bufferType,
-                            nextPeriodStart: nextStreamInfo.period.start,
+                            nextPeriodStart: nextStreamInfo.period.start
                         });
                         consecutivePeriodStreamCb.periodStreamCleared({
                             type: bufferType,
                             manifest: manifest,
-                            period: nextStreamInfo.period,
+                            period: nextStreamInfo.period
                         });
                         nextStreamInfo.canceller.cancel("Next Period changed");
                         nextStreamInfo = null;
@@ -657,8 +825,7 @@ function StreamOrchestrator(content, playbackObserver, representationEstimator,
  * @param {Object} observation
  * @param {Array.<Object>} cleanedRanges
  * @returns {boolean}
- */
-function needsFlushingAfterClean(observation, cleanedRanges) {
+ */ function needsFlushingAfterClean(observation, cleanedRanges) {
     if (cleanedRanges.length === 0) {
         return false;
     }
@@ -667,7 +834,5 @@ function needsFlushingAfterClean(observation, cleanedRanges) {
     // the corresponding ranges, without seeking or re-switching playback
     // direction which is expected to lead to a low-level flush anyway.
     // There's a 5 seconds security, just to be sure.
-    return observation.speed >= 0
-        ? cleanedRanges[cleanedRanges.length - 1].end >= curPos - 5
-        : cleanedRanges[0].start <= curPos + 5;
+    return observation.speed >= 0 ? cleanedRanges[cleanedRanges.length - 1].end >= curPos - 5 : cleanedRanges[0].start <= curPos + 5;
 }