rx-player 4.5.0 → 4.6.0-dev.2026100600

package/dist/commonjs/core/stream/adaptation/adaptation_stream.js

@@ -1,67 +1,8 @@
 "use strict";
-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.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = AdaptationStream;
-var config_1 = require("../../../config");
-var errors_1 = require("../../../errors");
-var log_1 = require("../../../log");
-var array_includes_1 = require("../../../utils/array_includes");
-var assert_1 = require("../../../utils/assert");
-var cancellable_sleep_1 = require("../../../utils/cancellable_sleep");
-var noop_1 = require("../../../utils/noop");
-var object_assign_1 = require("../../../utils/object_assign");
-var queue_microtask_1 = require("../../../utils/queue_microtask");
-var reference_1 = require("../../../utils/reference");
-var task_canceller_1 = require("../../../utils/task_canceller");
-var representation_1 = require("../representation");
-var get_representations_switch_strategy_1 = require("./get_representations_switch_strategy");
-/**
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
  * Create new `AdaptationStream` whose task will be to download the media data
  * for a given Adaptation (i.e. "track").
  *
@@ -90,12 +31,189 @@ var get_representations_switch_strategy_1 = require("./get_representations_switc
  * @param {Object} parentCancelSignal - `CancellationSignal` allowing, when
  * triggered, to immediately stop all operations the `AdaptationStream` is
  * doing.
- */
-function AdaptationStream(_a, callbacks, parentCancelSignal) {
-    var playbackObserver = _a.playbackObserver, content = _a.content, options = _a.options, representationEstimator = _a.representationEstimator, segmentSink = _a.segmentSink, segmentQueueCreator = _a.segmentQueueCreator, wantedBufferAhead = _a.wantedBufferAhead, maxVideoBufferSize = _a.maxVideoBufferSize;
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return AdaptationStream;
+    }
+});
+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 _array_includes = /*#__PURE__*/ _interop_require_default(require("../../../utils/array_includes.js"));
+var _assert = require("../../../utils/assert.js");
+var _cancellable_sleep = /*#__PURE__*/ _interop_require_default(require("../../../utils/cancellable_sleep.js"));
+var _noop = /*#__PURE__*/ _interop_require_default(require("../../../utils/noop.js"));
+var _object_assign = /*#__PURE__*/ _interop_require_default(require("../../../utils/object_assign.js"));
+var _queue_microtask = /*#__PURE__*/ _interop_require_default(require("../../../utils/queue_microtask.js"));
+var _reference = /*#__PURE__*/ _interop_require_wildcard(require("../../../utils/reference.js"));
+var _task_canceller = /*#__PURE__*/ _interop_require_default(require("../../../utils/task_canceller.js"));
+var _index1 = /*#__PURE__*/ _interop_require_default(require("../representation/index.js"));
+var _get_representations_switch_strategy = /*#__PURE__*/ _interop_require_default(require("./get_representations_switch_strategy.js"));
+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 _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) return obj;
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") return {
+        default: obj
+    };
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) return cache.get(obj);
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) Object.defineProperty(newObj, key, desc);
+            else newObj[key] = obj[key];
+        }
+    }
+    newObj.default = obj;
+    if (cache) cache.set(obj, newObj);
+    return newObj;
+}
+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 AdaptationStream(param, callbacks, parentCancelSignal) {
+    var playbackObserver = param.playbackObserver, content = param.content, options = param.options, representationEstimator = param.representationEstimator, segmentSink = param.segmentSink, segmentQueueCreator = param.segmentQueueCreator, wantedBufferAhead = param.wantedBufferAhead, maxVideoBufferSize = param.maxVideoBufferSize;
     var manifest = content.manifest, period = content.period, adaptation = content.adaptation;
-    /** Allows to cancel everything the `AdaptationStream` is doing. */
-    var adapStreamCanceller = new task_canceller_1.default("AdaptationStream " + adaptation.type);
+    /** Allows to cancel everything the `AdaptationStream` is doing. */ var adapStreamCanceller = new _task_canceller.default("AdaptationStream " + adaptation.type);
     adapStreamCanceller.linkToSignal(parentCancelSignal);
     /**
      * The buffer goal ratio base itself on the value given by `wantedBufferAhead`
@@ -104,45 +222,41 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * It can help in cases such as : the current browser has issues with
      * buffering and tells us that we should try to bufferize less data :
      * https://developers.google.com/web/updates/2017/10/quotaexceedederror
-     */
-    var bufferGoalRatioMap = new Map();
+     */ var bufferGoalRatioMap = new Map();
     /**
      * Emit the currently chosen `Representation`.
      * `null` if no Representation is chosen for now.
-     */
-    var currentRepresentation = new reference_1.default(null, adapStreamCanceller.signal);
-    /** Stores the last emitted bitrate. */
-    var previouslyEmittedBitrate;
+     */ var currentRepresentation = new _reference.default(null, adapStreamCanceller.signal);
+    /** Stores the last emitted bitrate. */ var previouslyEmittedBitrate;
     var initialRepIds = content.representations.getValue().representationIds;
     var initialRepresentations = getRepresentationList(content.adaptation.representations, initialRepIds);
-    /** Emit the list of Representation for the adaptive logic. */
-    var representationsList = new reference_1.default(initialRepresentations, adapStreamCanceller.signal);
+    /** Emit the list of Representation for the adaptive logic. */ var representationsList = new _reference.default(initialRepresentations, adapStreamCanceller.signal);
     // Start-up Adaptive logic
-    var _b = representationEstimator({ manifest: manifest, period: period, adaptation: adaptation }, currentRepresentation, representationsList, playbackObserver, adapStreamCanceller.signal), estimateRef = _b.estimates, abrCallbacks = _b.callbacks;
-    var isMediaSegmentQueueInterrupted = new reference_1.default(false);
-    /** Update the `canLoad` ref on observation update */
-    playbackObserver.listen(function (observation) {
+    var _representationEstimator = representationEstimator({
+        manifest: manifest,
+        period: period,
+        adaptation: adaptation
+    }, currentRepresentation, representationsList, playbackObserver, adapStreamCanceller.signal), estimateRef = _representationEstimator.estimates, abrCallbacks = _representationEstimator.callbacks;
+    var isMediaSegmentQueueInterrupted = new _reference.default(false);
+    /** Update the `canLoad` ref on observation update */ playbackObserver.listen(function(observation) {
         var _a;
         var observationCanStream = (_a = observation.canStream) !== null && _a !== void 0 ? _a : true;
         if (isMediaSegmentQueueInterrupted.getValue() === observationCanStream) {
-            log_1.default.debug("Stream", "isMediaSegmentQueueInterrupted updated to", !observationCanStream);
+            _log.default.debug("Stream", "isMediaSegmentQueueInterrupted updated to", !observationCanStream);
             isMediaSegmentQueueInterrupted.setValue(!observationCanStream);
         }
-    }, { clearSignal: adapStreamCanceller.signal });
-    /** Allows a `RepresentationStream` to easily fetch media segments. */
-    var segmentQueue = segmentQueueCreator.createSegmentQueue(adaptation.type, 
-    /* eslint-disable @typescript-eslint/unbound-method */
-    {
+    }, {
+        clearSignal: adapStreamCanceller.signal
+    });
+    /** Allows a `RepresentationStream` to easily fetch media segments. */ var segmentQueue = segmentQueueCreator.createSegmentQueue(adaptation.type, /* eslint-disable @typescript-eslint/unbound-method */ {
         onRequestBegin: abrCallbacks.requestBegin,
         onRequestEnd: abrCallbacks.requestEnd,
         onProgress: abrCallbacks.requestProgress,
-        onMetrics: abrCallbacks.metrics,
+        onMetrics: abrCallbacks.metrics
     }, isMediaSegmentQueueInterrupted);
-    /* eslint-enable @typescript-eslint/unbound-method */
-    /** Used to determine when "fast-switching" is possible. */
-    var fastSwitchThreshold = new reference_1.default(0);
-    estimateRef.onUpdate(function (_a) {
-        var bitrate = _a.bitrate, knownStableBitrate = _a.knownStableBitrate;
+    /* eslint-enable @typescript-eslint/unbound-method */ /** Used to determine when "fast-switching" is possible. */ var fastSwitchThreshold = new _reference.default(0);
+    estimateRef.onUpdate(function(param) {
+        var bitrate = param.bitrate, knownStableBitrate = param.knownStableBitrate;
         if (options.enableFastSwitching) {
             fastSwitchThreshold.setValueIfChanged(knownStableBitrate);
         }
@@ -150,18 +264,23 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
             return;
         }
         previouslyEmittedBitrate = bitrate;
-        log_1.default.debug("Stream", "new ".concat(adaptation.type, " bitrate estimate received from ABR"), {
-            bitrate: bitrate,
+        _log.default.debug("Stream", "new ".concat(adaptation.type, " bitrate estimate received from ABR"), {
+            bitrate: bitrate
+        });
+        callbacks.bitrateEstimateChange({
+            type: adaptation.type,
+            bitrate: bitrate
         });
-        callbacks.bitrateEstimateChange({ type: adaptation.type, bitrate: bitrate });
-    }, { emitCurrentValue: true, clearSignal: adapStreamCanceller.signal });
+    }, {
+        emitCurrentValue: true,
+        clearSignal: adapStreamCanceller.signal
+    });
     /**
      * When triggered, cancel all `RepresentationStream`s currently created.
      * Set to `undefined` initially.
-     */
-    var cancelCurrentStreams;
+     */ var cancelCurrentStreams;
     // Each time the list of wanted Representations changes, we restart the logic
-    content.representations.onUpdate(function (val) {
+    content.representations.onUpdate(function(val) {
         if (cancelCurrentStreams !== undefined) {
             cancelCurrentStreams.cancel("locked representations changed");
         }
@@ -171,17 +290,20 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
         // decipherability updates, "`Representation` avoidance" etc.
         var newRepresentations = getRepresentationList(content.adaptation.representations, newRepIds);
         representationsList.setValueIfChanged(newRepresentations);
-        var currentStreamCanceller = new task_canceller_1.default("AdaptationStream: RepresentationStream Group " + adaptation.type);
+        var currentStreamCanceller = new _task_canceller.default("AdaptationStream: RepresentationStream Group " + adaptation.type);
         cancelCurrentStreams = currentStreamCanceller;
         currentStreamCanceller.linkToSignal(adapStreamCanceller.signal);
-        onRepresentationsChoiceChange(val, currentStreamCanceller.signal).catch(function (err) {
-            if (currentStreamCanceller.isUsed() && task_canceller_1.default.isCancellationError(err)) {
+        onRepresentationsChoiceChange(val, currentStreamCanceller.signal).catch(function(err) {
+            if (currentStreamCanceller.isUsed() && _task_canceller.default.isCancellationError(err)) {
                 return;
             }
             adapStreamCanceller.cancel("RepresentationStream err");
             callbacks.error(err);
         });
-    }, { clearSignal: adapStreamCanceller.signal, emitCurrentValue: true });
+    }, {
+        clearSignal: adapStreamCanceller.signal,
+        emitCurrentValue: true
+    });
     return;
     /**
      * Function called each time the list of wanted Representations is updated.
@@ -193,89 +315,159 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * made.
      * @param {Object} repsChoiceCancelSignal - `CancellationSignal` allowing to
      * cancel everything this function is doing and free all related resources.
-     */
-    function onRepresentationsChoiceChange(choice, repsChoiceCancelSignal) {
-        return __awaiter(this, void 0, void 0, function () {
-            var switchStrat, _a, _b, _c, range, e_1_1;
-            var e_1, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
+     */ function onRepresentationsChoiceChange(choice, repsChoiceCancelSignal) {
+        return _async_to_generator(function() {
+            var switchStrat, _, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, range, err;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
                     case 0:
-                        switchStrat = (0, get_representations_switch_strategy_1.default)(period, adaptation, choice, segmentSink, playbackObserver);
-                        _a = switchStrat.type;
-                        switch (_a) {
-                            case "continue": return [3 /*break*/, 1];
-                            case "needs-reload": return [3 /*break*/, 2];
-                            case "flush-buffer": return [3 /*break*/, 3];
-                            case "clean-buffer": return [3 /*break*/, 3];
+                        // First check if we should perform any action regarding what was previously
+                        // in the buffer
+                        switchStrat = (0, _get_representations_switch_strategy.default)(period, adaptation, choice, segmentSink, playbackObserver);
+                        _ = switchStrat.type;
+                        switch(_){
+                            case "continue":
+                                return [
+                                    3,
+                                    1
+                                ];
+                            case "needs-reload":
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case "flush-buffer":
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case "clean-buffer":
+                                return [
+                                    3,
+                                    3
+                                ];
                         }
-                        return [3 /*break*/, 11];
-                    case 1: return [3 /*break*/, 12]; // nothing to do
-                    case 2: // Just ask to reload
-                    // 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 [2 /*return*/, (0, queue_microtask_1.default)(function () {
-                            playbackObserver.listen(function () {
-                                if (repsChoiceCancelSignal.isCancelled()) {
-                                    return;
-                                }
-                                var DELTA_POSITION_AFTER_RELOAD = config_1.default.getCurrent().DELTA_POSITION_AFTER_RELOAD;
-                                var timeOffset = DELTA_POSITION_AFTER_RELOAD.bitrateSwitch;
-                                return callbacks.waitingMediaSourceReload({
-                                    bufferType: adaptation.type,
-                                    period: period,
-                                    timeOffset: timeOffset,
-                                    stayInPeriod: true,
+                        return [
+                            3,
+                            12
+                        ];
+                    case 1:
+                        return [
+                            3,
+                            13
+                        ]; // nothing to do
+                    case 2:
+                        // 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 [
+                            2,
+                            (0, _queue_microtask.default)(function() {
+                                playbackObserver.listen(function() {
+                                    if (repsChoiceCancelSignal.isCancelled()) {
+                                        return;
+                                    }
+                                    var DELTA_POSITION_AFTER_RELOAD = _config.default.getCurrent().DELTA_POSITION_AFTER_RELOAD;
+                                    var timeOffset = DELTA_POSITION_AFTER_RELOAD.bitrateSwitch;
+                                    return callbacks.waitingMediaSourceReload({
+                                        bufferType: adaptation.type,
+                                        period: period,
+                                        timeOffset: timeOffset,
+                                        stayInPeriod: true
+                                    });
+                                }, {
+                                    includeLastObservation: true,
+                                    clearSignal: repsChoiceCancelSignal
                                 });
-                            }, { includeLastObservation: true, clearSignal: repsChoiceCancelSignal });
-                        })];
+                            })
+                        ];
                     case 3:
-                        _e.trys.push([3, 8, 9, 10]);
-                        _b = __values(switchStrat.value), _c = _b.next();
-                        _e.label = 4;
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        _state.label = 4;
                     case 4:
-                        if (!!_c.done) return [3 /*break*/, 7];
-                        range = _c.value;
-                        return [4 /*yield*/, segmentSink.removeBuffer(range.start, range.end)];
+                        _state.trys.push([
+                            4,
+                            9,
+                            10,
+                            11
+                        ]);
+                        _iterator = switchStrat.value[Symbol.iterator]();
+                        _state.label = 5;
                     case 5:
-                        _e.sent();
+                        if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                            3,
+                            8
+                        ];
+                        range = _step.value;
+                        return [
+                            4,
+                            segmentSink.removeBuffer(range.start, range.end)
+                        ];
+                    case 6:
+                        _state.sent();
                         if (repsChoiceCancelSignal.isCancelled()) {
-                            return [2 /*return*/];
+                            return [
+                                2
+                            ];
                         }
-                        _e.label = 6;
-                    case 6:
-                        _c = _b.next();
-                        return [3 /*break*/, 4];
-                    case 7: return [3 /*break*/, 10];
+                        _state.label = 7;
+                    case 7:
+                        _iteratorNormalCompletion = true;
+                        return [
+                            3,
+                            5
+                        ];
                     case 8:
-                        e_1_1 = _e.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 10];
+                        return [
+                            3,
+                            11
+                        ];
                     case 9:
+                        err = _state.sent();
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                        return [
+                            3,
+                            11
+                        ];
+                    case 10:
                         try {
-                            if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
                         }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 10:
+                        return [
+                            7
+                        ];
+                    case 11:
                         if (switchStrat.type === "flush-buffer") {
                             callbacks.needsBufferFlush();
                             if (repsChoiceCancelSignal.isCancelled()) {
-                                return [2 /*return*/];
+                                return [
+                                    2
+                                ];
                             }
                         }
-                        return [3 /*break*/, 12];
-                    case 11:
-                        (0, assert_1.assertUnreachable)(switchStrat);
-                        _e.label = 12;
+                        return [
+                            3,
+                            13
+                        ];
                     case 12:
+                        (0, _assert.assertUnreachable)(switchStrat);
+                        _state.label = 13;
+                    case 13:
                         recursivelyCreateRepresentationStreams(repsChoiceCancelSignal);
-                        return [2 /*return*/];
+                        return [
+                            2
+                        ];
                 }
             });
-        });
+        })();
     }
     /**
      * Create `RepresentationStream`s starting with the Representation of the last
@@ -284,14 +476,12 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * `RepresentationStream` corresponding to that new estimate.
      * @param {Object} fnCancelSignal - `CancellationSignal` which will abort
      * anything this function is doing and free allocated resources.
-     */
-    function recursivelyCreateRepresentationStreams(fnCancelSignal) {
+     */ function recursivelyCreateRepresentationStreams(fnCancelSignal) {
         /**
          * `TaskCanceller` triggered when the current `RepresentationStream` is
          * terminating and as such the next one might be immediately created
          * recursively.
-         */
-        var repStreamTerminatingCanceller = new task_canceller_1.default("AdaptationStream: RepresentationStream creation " + adaptation.type);
+         */ var repStreamTerminatingCanceller = new _task_canceller.default("AdaptationStream: RepresentationStream creation " + adaptation.type);
         repStreamTerminatingCanceller.linkToSignal(fnCancelSignal);
         var representation = estimateRef.getValue().representation;
         if (representation === null) {
@@ -301,47 +491,43 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
          * Stores the last estimate emitted, starting with `null`.
          * This allows to easily rely on that value in inner Observables which might also
          * need the last already-considered value.
-         */
-        var terminateCurrentStream = new reference_1.default(null, repStreamTerminatingCanceller.signal);
-        /** Allows to stop listening to estimateRef on the following line. */
-        estimateRef.onUpdate(function (estimate) {
-            if (estimate.representation === null ||
-                estimate.representation.id === representation.id) {
+         */ var terminateCurrentStream = new _reference.default(null, repStreamTerminatingCanceller.signal);
+        /** Allows to stop listening to estimateRef on the following line. */ estimateRef.onUpdate(function(estimate) {
+            if (estimate.representation === null || estimate.representation.id === representation.id) {
                 return;
             }
             if (estimate.urgent) {
-                log_1.default.info("Stream", "urgent Representation switch", {
+                _log.default.info("Stream", "urgent Representation switch", {
                     bufferType: adaptation.type,
                     estimateBitrate: estimate.bitrate,
                     prevRepresentationBitrate: representation.bitrate,
-                    newRepresentationBitrate: estimate.representation.bitrate,
+                    newRepresentationBitrate: estimate.representation.bitrate
                 });
                 return terminateCurrentStream.setValue({
                     urgent: true,
-                    reason: "Urgent Representation switch",
+                    reason: "Urgent Representation switch"
                 });
-            }
-            else {
-                log_1.default.info("Stream", "slow Representation switch", {
+            } else {
+                _log.default.info("Stream", "slow Representation switch", {
                     bufferType: adaptation.type,
                     estimateBitrate: estimate.bitrate,
                     prevRepresentationBitrate: representation.bitrate,
-                    newRepresentationBitrate: estimate.representation.bitrate,
+                    newRepresentationBitrate: estimate.representation.bitrate
                 });
                 return terminateCurrentStream.setValue({
                     urgent: false,
-                    reason: "Non-urgent Representation switch",
+                    reason: "Non-urgent Representation switch"
                 });
             }
         }, {
             clearSignal: repStreamTerminatingCanceller.signal,
-            emitCurrentValue: true,
+            emitCurrentValue: true
         });
         var repInfo = {
             type: adaptation.type,
             adaptation: adaptation,
             period: period,
-            representation: representation,
+            representation: representation
         };
         currentRepresentation.setValue(representation);
         if (fnCancelSignal.isCancelled()) {
@@ -358,20 +544,20 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
             needsManifestRefresh: callbacks.needsManifestRefresh,
             inbandEvent: callbacks.inbandEvent,
             warning: callbacks.warning,
-            error: function (err) {
+            error: function error(err) {
                 adapStreamCanceller.cancel("RepresentationStream err cb");
                 callbacks.error(err);
             },
-            addedSegment: function (segmentInfo) {
+            addedSegment: function addedSegment(segmentInfo) {
                 abrCallbacks.addedSegment(segmentInfo);
             },
-            terminating: function () {
+            terminating: function terminating() {
                 if (repStreamTerminatingCanceller.isUsed()) {
                     return; // Already handled
                 }
                 repStreamTerminatingCanceller.cancel("RepresentationStream terminating");
                 return recursivelyCreateRepresentationStreams(fnCancelSignal);
-            },
+            }
         };
         createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal);
     }
@@ -386,10 +572,8 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * various `RepresentationStream` events.
      * @param {Object} globalCancelSignal - `CancellationSignal` which will
      * immediately clean every resources allocated by this function.
-     */
-    function createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, globalCancelSignal) {
-        /** Set to `true` if we've encountered an error with this `RepresentationStream` */
-        var hasEncounteredError = false;
+     */ function createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, globalCancelSignal) {
+        /** Set to `true` if we've encountered an error with this `RepresentationStream` */ var hasEncounteredError = false;
         /**
          * Construct a `TaskCanceller`, triggered once the `RepresentationStream` we
          * will create here announces that it is "terminating" (implies that it is
@@ -400,22 +584,19 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
          * be much much longer than our `RepresentationStream`'s.
          * Thus it wouldn't be adapted as a canceller for the listeners we're
          * registering here.
-         */
-        var terminatingCanceller = new task_canceller_1.default("RepresentationStream-linked listeners in AdaptationStream - " +
-            "periodStart=".concat(period.start, " type=").concat(adaptation.type));
+         */ var terminatingCanceller = new _task_canceller.default("RepresentationStream-linked listeners in AdaptationStream - " + "periodStart=".concat(period.start, " type=").concat(adaptation.type));
         terminatingCanceller.linkToSignal(globalCancelSignal);
-        /** Actually built buffer size, in seconds. */
-        var bufferGoal = (0, reference_1.createMappedReference)(wantedBufferAhead, function (prev) {
+        /** Actually built buffer size, in seconds. */ var bufferGoal = (0, _reference.createMappedReference)(wantedBufferAhead, function(prev) {
             return getBufferGoal(representation, prev);
         }, terminatingCanceller.signal);
-        var maxBufferSize = adaptation.type === "video" ? maxVideoBufferSize : new reference_1.default(Infinity);
-        log_1.default.info("Stream", "changing representation", {
+        var maxBufferSize = adaptation.type === "video" ? maxVideoBufferSize : new _reference.default(Infinity);
+        _log.default.info("Stream", "changing representation", {
             bufferType: adaptation.type,
             representationId: representation.id,
-            representationBitrate: representation.bitrate,
+            representationBitrate: representation.bitrate
         });
-        var updatedCallbacks = (0, object_assign_1.default)({}, representationStreamCallbacks, {
-            error: function (err) {
+        var updatedCallbacks = (0, _object_assign.default)({}, representationStreamCallbacks, {
+            error: function error(err) {
                 var _a;
                 if (hasEncounteredError) {
                     // A RepresentationStream might trigger multiple Errors (for example
@@ -424,21 +605,20 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
                     //
                     // That could mean that we're hiding legitimate issues but handling
                     // multiple of those errors at once is too hard a task for now.
-                    log_1.default.warn("Stream", "Ignoring RepresentationStream error", err);
+                    _log.default.warn("Stream", "Ignoring RepresentationStream error", err);
                     return;
                 }
                 hasEncounteredError = true;
-                var formattedError = (0, errors_1.formatError)(err, {
+                var formattedError = (0, _index.formatError)(err, {
                     defaultCode: "NONE",
-                    defaultReason: "Unknown `RepresentationStream` error",
+                    defaultReason: "Unknown `RepresentationStream` error"
                 });
                 if (formattedError.code !== "BUFFER_FULL_ERROR") {
                     representationStreamCallbacks.error(err);
-                }
-                else {
-                    log_1.default.warn("Stream", "received BUFFER_FULL_ERROR", {
+                } else {
+                    _log.default.warn("Stream", "received BUFFER_FULL_ERROR", {
                         bufferType: adaptation.type,
-                        representationBitrate: representation.bitrate,
+                        representationBitrate: representation.bitrate
                     });
                     var wba = wantedBufferAhead.getValue();
                     var lastBufferGoalRatio = (_a = bufferGoalRatioMap.get(representation.id)) !== null && _a !== void 0 ? _a : 1;
@@ -452,21 +632,24 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
                     // We wait 4 seconds to let the situation evolve by itself before
                     // retrying loading segments with a lower buffer goal
                     // If the `RepresentationStream` was terminating anyway, just exits
-                    (0, cancellable_sleep_1.default)(4000, terminatingCanceller.signal)
-                        .then(function () {
+                    (0, _cancellable_sleep.default)(4000, terminatingCanceller.signal).then(function() {
                         return createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, globalCancelSignal);
-                    })
-                        .catch(noop_1.default);
+                    }).catch(_noop.default);
                 }
             },
-            terminating: function () {
+            terminating: function terminating() {
                 terminatingCanceller.cancel("Representation terminating");
                 representationStreamCallbacks.terminating();
-            },
+            }
         });
-        (0, representation_1.default)({
+        (0, _index1.default)({
             playbackObserver: playbackObserver,
-            content: { representation: representation, adaptation: adaptation, period: period, manifest: manifest },
+            content: {
+                representation: representation,
+                adaptation: adaptation,
+                period: period,
+                manifest: manifest
+            },
             segmentSink: segmentSink,
             segmentQueue: segmentQueue,
             terminate: terminateCurrentStream,
@@ -474,10 +657,9 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
                 bufferGoal: bufferGoal,
                 maxBufferSize: maxBufferSize,
                 drmSystemId: options.drmSystemId,
-                fastSwitchThreshold: fastSwitchThreshold,
-            },
-        }, updatedCallbacks, 
-        // NOTE: We give the long-lived `globalCancelSignal` here (and not
+                fastSwitchThreshold: fastSwitchThreshold
+            }
+        }, updatedCallbacks, // NOTE: We give the long-lived `globalCancelSignal` here (and not
         // `terminatingCanceller.signal`) on purpose.
         // `RepresentationStream` should clean-up themselves automatically based
         // on their `terminate` parameter.
@@ -488,19 +670,21 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
         // it has just loaded.
         globalCancelSignal);
         // reload if the Representation disappears from the Manifest
-        manifest.addEventListener("manifestUpdate", function (updates) {
-            var e_2, _a, e_3, _b, e_4, _c;
+        manifest.addEventListener("manifestUpdate", function(updates) {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
             try {
-                for (var _d = __values(updates.updatedPeriods), _e = _d.next(); !_e.done; _e = _d.next()) {
-                    var element = _e.value;
+                for(var _iterator = updates.updatedPeriods[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var element = _step.value;
                     if (element.period.id === period.id) {
+                        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
                         try {
-                            for (var _f = (e_3 = void 0, __values(element.result.updatedAdaptations)), _g = _f.next(); !_g.done; _g = _f.next()) {
-                                var updated = _g.value;
+                            for(var _iterator1 = element.result.updatedAdaptations[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                var updated = _step1.value;
                                 if (updated.adaptation === adaptation.id) {
+                                    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
                                     try {
-                                        for (var _h = (e_4 = void 0, __values(updated.removedRepresentations)), _j = _h.next(); !_j.done; _j = _h.next()) {
-                                            var rep = _j.value;
+                                        for(var _iterator2 = updated.removedRepresentations[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                                            var rep = _step2.value;
                                             if (rep === representation.id) {
                                                 if (terminatingCanceller.isUsed()) {
                                                     return;
@@ -509,40 +693,57 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
                                                     bufferType: adaptation.type,
                                                     period: period,
                                                     timeOffset: 0,
-                                                    stayInPeriod: true,
+                                                    stayInPeriod: true
                                                 });
                                             }
                                         }
-                                    }
-                                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                                    finally {
+                                    } catch (err) {
+                                        _didIteratorError2 = true;
+                                        _iteratorError2 = err;
+                                    } finally{
                                         try {
-                                            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+                                            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                                _iterator2.return();
+                                            }
+                                        } finally{
+                                            if (_didIteratorError2) {
+                                                throw _iteratorError2;
+                                            }
                                         }
-                                        finally { if (e_4) throw e_4.error; }
                                     }
                                 }
                             }
-                        }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                        finally {
+                        } catch (err) {
+                            _didIteratorError1 = true;
+                            _iteratorError1 = err;
+                        } finally{
                             try {
-                                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                    _iterator1.return();
+                                }
+                            } finally{
+                                if (_didIteratorError1) {
+                                    throw _iteratorError1;
+                                }
                             }
-                            finally { if (e_3) throw e_3.error; }
                         }
-                    }
-                    else if (element.period.start > period.start) {
+                    } else if (element.period.start > period.start) {
                         break;
                     }
                 }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_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_2) throw e_2.error; }
             }
         }, terminatingCanceller.signal);
     }
@@ -553,8 +754,7 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * @param {Object} representation - The `Representation` you want to buffer.
      * @param {number} wba - The value of `wantedBufferAhead` set by the user.
      * @returns {number}
-     */
-    function getBufferGoal(representation, wba) {
+     */ function getBufferGoal(representation, wba) {
         var oldBufferGoalRatio = bufferGoalRatioMap.get(representation.id);
         var bufferGoalRatio = oldBufferGoalRatio !== undefined ? oldBufferGoalRatio : 1;
         if (oldBufferGoalRatio === undefined) {
@@ -577,16 +777,15 @@ function AdaptationStream(_a, callbacks, parentCancelSignal) {
  * @param {Array.<string>} authorizedRepIds - The subset of `Representation`
  * that the API authorize us to play.
  * @returns {Array.<Object>}
- */
-function getRepresentationList(availableRepresentations, authorizedRepIds) {
-    var filteredRepresentations = availableRepresentations.filter(function (r) {
-        return (0, array_includes_1.default)(authorizedRepIds, r.id) &&
-            !r.shouldBeAvoided &&
-            r.isPlayable() !== false;
+ */ function getRepresentationList(availableRepresentations, authorizedRepIds) {
+    var filteredRepresentations = availableRepresentations.filter(function(r) {
+        return (0, _array_includes.default)(authorizedRepIds, r.id) && !r.shouldBeAvoided && r.isPlayable() !== false;
     });
     if (filteredRepresentations.length > 0) {
         return filteredRepresentations;
     }
     // Retry without "`Representation` avoidance"
-    return availableRepresentations.filter(function (r) { return (0, array_includes_1.default)(authorizedRepIds, r.id) && r.isPlayable() !== false; });
+    return availableRepresentations.filter(function(r) {
+        return (0, _array_includes.default)(authorizedRepIds, r.id) && r.isPlayable() !== false;
+    });
 }