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

package/dist/_esm5.processed/core/stream/representation/utils/downloading_queue.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,28 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import log from "../../../../log";
-import assert from "../../../../utils/assert";
-import EventEmitter from "../../../../utils/event_emitter";
-import noop from "../../../../utils/noop";
-import objectAssign from "../../../../utils/object_assign";
-import SharedReference from "../../../../utils/reference";
-import TaskCanceller from "../../../../utils/task_canceller";
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../../../log");
+const assert_1 = require("../../../../utils/assert");
+const event_emitter_1 = require("../../../../utils/event_emitter");
+const noop_1 = require("../../../../utils/noop");
+const object_assign_1 = require("../../../../utils/object_assign");
+const reference_1 = require("../../../../utils/reference");
+const task_canceller_1 = require("../../../../utils/task_canceller");
 /**
  * Class scheduling segment downloads for a single Representation.
  *
@@ -43,8 +30,7 @@ import TaskCanceller from "../../../../utils/task_canceller";
  * an utilis of the `RepresentationStream` like here.
  * @class DownloadingQueue
  */
-var DownloadingQueue = /** @class */ (function (_super) {
-    __extends(DownloadingQueue, _super);
+class DownloadingQueue extends event_emitter_1.default {
     /**
      * Create a new `DownloadingQueue`.
      *
@@ -66,97 +52,95 @@ var DownloadingQueue = /** @class */ (function (_super) {
      * that it should not wait for an initialization segment before parsing a
      * media segment.
      */
-    function DownloadingQueue(content, downloadQueue, segmentFetcher, hasInitSegment) {
-        var _this = _super.call(this) || this;
-        _this._content = content;
-        _this._currentCanceller = null;
-        _this._downloadQueue = downloadQueue;
-        _this._initSegmentRequest = null;
-        _this._mediaSegmentRequest = null;
-        _this._segmentFetcher = segmentFetcher;
-        _this._initSegmentInfoRef = new SharedReference(undefined);
-        _this._mediaSegmentAwaitingInitMetadata = null;
+    constructor(content, downloadQueue, segmentFetcher, hasInitSegment) {
+        super();
+        this._content = content;
+        this._currentCanceller = null;
+        this._downloadQueue = downloadQueue;
+        this._initSegmentRequest = null;
+        this._mediaSegmentRequest = null;
+        this._segmentFetcher = segmentFetcher;
+        this._initSegmentInfoRef = new reference_1.default(undefined);
+        this._mediaSegmentAwaitingInitMetadata = null;
         if (!hasInitSegment) {
-            _this._initSegmentInfoRef.setValue(null);
+            this._initSegmentInfoRef.setValue(null);
         }
-        return _this;
     }
     /**
      * Returns the initialization segment currently being requested.
      * Returns `null` if no initialization segment request is pending.
      * @returns {Object | null}
      */
-    DownloadingQueue.prototype.getRequestedInitSegment = function () {
+    getRequestedInitSegment() {
         return this._initSegmentRequest === null ? null :
             this._initSegmentRequest.segment;
-    };
+    }
     /**
      * Returns the media segment currently being requested.
      * Returns `null` if no media segment request is pending.
      * @returns {Object | null}
      */
-    DownloadingQueue.prototype.getRequestedMediaSegment = function () {
+    getRequestedMediaSegment() {
         return this._mediaSegmentRequest === null ? null :
             this._mediaSegmentRequest.segment;
-    };
+    }
     /**
      * Start the current downloading queue, emitting events as it loads and parses
      * initialization and media segments.
      */
-    DownloadingQueue.prototype.start = function () {
-        var _this = this;
+    start() {
         if (this._currentCanceller !== null) {
             return;
         }
-        this._currentCanceller = new TaskCanceller();
+        this._currentCanceller = new task_canceller_1.default();
         // Listen for asked media segments
-        this._downloadQueue.onUpdate(function (queue) {
-            var segmentQueue = queue.segmentQueue;
+        this._downloadQueue.onUpdate((queue) => {
+            const { segmentQueue } = queue;
             if (segmentQueue.length > 0 &&
-                segmentQueue[0].segment.id === _this._mediaSegmentAwaitingInitMetadata) {
+                segmentQueue[0].segment.id === this._mediaSegmentAwaitingInitMetadata) {
                 // The most needed segment is still the same one, and there's no need to
                 // update its priority as the request already ended, just quit.
                 return;
             }
-            var currentSegmentRequest = _this._mediaSegmentRequest;
+            const currentSegmentRequest = this._mediaSegmentRequest;
             if (segmentQueue.length === 0) {
                 if (currentSegmentRequest === null) {
                     // There's nothing to load but there's already no request pending.
                     return;
                 }
-                log.debug("Stream: no more media segment to request. Cancelling queue.", _this._content.adaptation.type);
-                _this._restartMediaSegmentDownloadingQueue();
+                log_1.default.debug("Stream: no more media segment to request. Cancelling queue.", this._content.adaptation.type);
+                this._restartMediaSegmentDownloadingQueue();
                 return;
             }
             else if (currentSegmentRequest === null) {
                 // There's no request although there are needed segments: start requests
-                log.debug("Stream: Media segments now need to be requested. Starting queue.", _this._content.adaptation.type, segmentQueue.length);
-                _this._restartMediaSegmentDownloadingQueue();
+                log_1.default.debug("Stream: Media segments now need to be requested. Starting queue.", this._content.adaptation.type, segmentQueue.length);
+                this._restartMediaSegmentDownloadingQueue();
                 return;
             }
             else {
-                var nextItem = segmentQueue[0];
+                const nextItem = segmentQueue[0];
                 if (currentSegmentRequest.segment.id !== nextItem.segment.id) {
                     // The most important request if for another segment, request it
-                    log.debug("Stream: Next media segment changed, cancelling previous", _this._content.adaptation.type);
-                    _this._restartMediaSegmentDownloadingQueue();
+                    log_1.default.debug("Stream: Next media segment changed, cancelling previous", this._content.adaptation.type);
+                    this._restartMediaSegmentDownloadingQueue();
                     return;
                 }
                 if (currentSegmentRequest.priority !== nextItem.priority) {
                     // The priority of the most important request has changed, update it
-                    log.debug("Stream: Priority of next media segment changed, updating", _this._content.adaptation.type, currentSegmentRequest.priority, nextItem.priority);
-                    _this._segmentFetcher.updatePriority(currentSegmentRequest.request, nextItem.priority);
+                    log_1.default.debug("Stream: Priority of next media segment changed, updating", this._content.adaptation.type, currentSegmentRequest.priority, nextItem.priority);
+                    this._segmentFetcher.updatePriority(currentSegmentRequest.request, nextItem.priority);
                 }
                 return;
             }
         }, { emitCurrentValue: true, clearSignal: this._currentCanceller.signal });
         // Listen for asked init segment
-        this._downloadQueue.onUpdate(function (next) {
+        this._downloadQueue.onUpdate((next) => {
             var _a;
-            var initSegmentRequest = _this._initSegmentRequest;
+            const initSegmentRequest = this._initSegmentRequest;
             if (next.initSegment !== null && initSegmentRequest !== null) {
                 if (next.initSegment.priority !== initSegmentRequest.priority) {
-                    _this._segmentFetcher.updatePriority(initSegmentRequest.request, next.initSegment.priority);
+                    this._segmentFetcher.updatePriority(initSegmentRequest.request, next.initSegment.priority);
                 }
                 return;
             }
@@ -164,72 +148,71 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 return;
             }
             if (next.initSegment === null) {
-                log.debug("Stream: no more init segment to request. Cancelling queue.", _this._content.adaptation.type);
+                log_1.default.debug("Stream: no more init segment to request. Cancelling queue.", this._content.adaptation.type);
             }
-            _this._restartInitSegmentDownloadingQueue(next.initSegment);
+            this._restartInitSegmentDownloadingQueue(next.initSegment);
         }, { emitCurrentValue: true, clearSignal: this._currentCanceller.signal });
-    };
-    DownloadingQueue.prototype.stop = function () {
+    }
+    stop() {
         var _a;
         (_a = this._currentCanceller) === null || _a === void 0 ? void 0 : _a.cancel();
         this._currentCanceller = null;
-    };
+    }
     /**
      * Internal logic performing media segment requests.
      */
-    DownloadingQueue.prototype._restartMediaSegmentDownloadingQueue = function () {
-        var _this = this;
+    _restartMediaSegmentDownloadingQueue() {
         if (this._mediaSegmentRequest !== null) {
             this._mediaSegmentRequest.canceller.cancel();
         }
-        var segmentQueue = this._downloadQueue.getValue().segmentQueue;
-        var currentNeededSegment = segmentQueue[0];
-        var recursivelyRequestSegments = function (startingSegment) {
-            if (_this._currentCanceller !== null && _this._currentCanceller.isUsed()) {
-                _this._mediaSegmentRequest = null;
+        const { segmentQueue } = this._downloadQueue.getValue();
+        const currentNeededSegment = segmentQueue[0];
+        const recursivelyRequestSegments = (startingSegment) => {
+            if (this._currentCanceller !== null && this._currentCanceller.isUsed()) {
+                this._mediaSegmentRequest = null;
                 return;
             }
             if (startingSegment === undefined) {
-                _this._mediaSegmentRequest = null;
-                _this.trigger("emptyQueue", null);
+                this._mediaSegmentRequest = null;
+                this.trigger("emptyQueue", null);
                 return;
             }
-            var canceller = new TaskCanceller();
-            var unlinkCanceller = _this._currentCanceller === null ?
-                noop :
-                canceller.linkToSignal(_this._currentCanceller.signal);
-            var segment = startingSegment.segment, priority = startingSegment.priority;
-            var context = objectAssign({ segment: segment }, _this._content);
+            const canceller = new task_canceller_1.default();
+            const unlinkCanceller = this._currentCanceller === null ?
+                noop_1.default :
+                canceller.linkToSignal(this._currentCanceller.signal);
+            const { segment, priority } = startingSegment;
+            const context = (0, object_assign_1.default)({ segment }, this._content);
             /**
              * If `true` , the current task has either errored, finished, or was
              * cancelled.
              */
-            var isComplete = false;
+            let isComplete = false;
             /**
              * If true, we're currently waiting for the initialization segment to be
              * parsed before parsing a received chunk.
              */
-            var isWaitingOnInitSegment = false;
-            canceller.signal.register(function () {
-                _this._mediaSegmentRequest = null;
+            let isWaitingOnInitSegment = false;
+            canceller.signal.register(() => {
+                this._mediaSegmentRequest = null;
                 if (isComplete) {
                     return;
                 }
-                if (_this._mediaSegmentAwaitingInitMetadata === segment.id) {
-                    _this._mediaSegmentAwaitingInitMetadata = null;
+                if (this._mediaSegmentAwaitingInitMetadata === segment.id) {
+                    this._mediaSegmentAwaitingInitMetadata = null;
                 }
                 isComplete = true;
                 isWaitingOnInitSegment = false;
             });
-            var emitChunk = function (parsed) {
-                assert(parsed.segmentType === "media", "Should have loaded a media segment.");
-                _this.trigger("parsedMediaSegment", objectAssign({}, parsed, { segment: segment }));
+            const emitChunk = (parsed) => {
+                (0, assert_1.default)(parsed.segmentType === "media", "Should have loaded a media segment.");
+                this.trigger("parsedMediaSegment", (0, object_assign_1.default)({}, parsed, { segment }));
             };
-            var continueToNextSegment = function () {
-                var lastQueue = _this._downloadQueue.getValue().segmentQueue;
+            const continueToNextSegment = () => {
+                const lastQueue = this._downloadQueue.getValue().segmentQueue;
                 if (lastQueue.length === 0) {
                     isComplete = true;
-                    _this.trigger("emptyQueue", null);
+                    this.trigger("emptyQueue", null);
                     return;
                 }
                 else if (lastQueue[0].segment.id === segment.id) {
@@ -239,27 +222,27 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 recursivelyRequestSegments(lastQueue[0]);
             };
             /** Scheduled actual segment request. */
-            var request = _this._segmentFetcher.createRequest(context, priority, {
+            const request = this._segmentFetcher.createRequest(context, priority, {
                 /**
                  * Callback called when the request has to be retried.
                  * @param {Error} error
                  */
-                onRetry: function (error) {
-                    _this.trigger("requestRetry", { segment: segment, error: error });
+                onRetry: (error) => {
+                    this.trigger("requestRetry", { segment, error });
                 },
                 /**
                  * Callback called when the request has to be interrupted and
                  * restarted later.
                  */
-                beforeInterrupted: function () {
-                    log.info("Stream: segment request interrupted temporarly.", segment.id, segment.time);
+                beforeInterrupted() {
+                    log_1.default.info("Stream: segment request interrupted temporarly.", segment.id, segment.time);
                 },
                 /**
                  * Callback called when a decodable chunk of the segment is available.
                  * @param {Function} parse - Function allowing to parse the segment.
                  */
-                onChunk: function (parse) {
-                    var initTimescale = _this._initSegmentInfoRef.getValue();
+                onChunk: (parse) => {
+                    const initTimescale = this._initSegmentInfoRef.getValue();
                     if (initTimescale !== undefined) {
                         emitChunk(parse(initTimescale !== null && initTimescale !== void 0 ? initTimescale : undefined));
                     }
@@ -269,22 +252,22 @@ var DownloadingQueue = /** @class */ (function (_super) {
                         // but I found it globally clearer to segregate the two cases,
                         // especially to always have a meaningful `isWaitingOnInitSegment`
                         // boolean which is a very important variable.
-                        _this._initSegmentInfoRef.waitUntilDefined(function (actualTimescale) {
+                        this._initSegmentInfoRef.waitUntilDefined((actualTimescale) => {
                             emitChunk(parse(actualTimescale !== null && actualTimescale !== void 0 ? actualTimescale : undefined));
                         }, { clearSignal: canceller.signal });
                     }
                 },
                 /** Callback called after all chunks have been sent. */
-                onAllChunksReceived: function () {
+                onAllChunksReceived: () => {
                     if (!isWaitingOnInitSegment) {
-                        _this.trigger("fullyLoadedSegment", segment);
+                        this.trigger("fullyLoadedSegment", segment);
                     }
                     else {
-                        _this._mediaSegmentAwaitingInitMetadata = segment.id;
-                        _this._initSegmentInfoRef.waitUntilDefined(function () {
-                            _this._mediaSegmentAwaitingInitMetadata = null;
+                        this._mediaSegmentAwaitingInitMetadata = segment.id;
+                        this._initSegmentInfoRef.waitUntilDefined(() => {
+                            this._mediaSegmentAwaitingInitMetadata = null;
                             isWaitingOnInitSegment = false;
-                            _this.trigger("fullyLoadedSegment", segment);
+                            this.trigger("fullyLoadedSegment", segment);
                         }, { clearSignal: canceller.signal });
                     }
                 },
@@ -292,35 +275,34 @@ var DownloadingQueue = /** @class */ (function (_super) {
                  * Callback called right after the request ended but before the next
                  * requests are scheduled. It is used to schedule the next segment.
                  */
-                beforeEnded: function () {
+                beforeEnded: () => {
                     unlinkCanceller();
-                    _this._mediaSegmentRequest = null;
+                    this._mediaSegmentRequest = null;
                     if (isWaitingOnInitSegment) {
-                        _this._initSegmentInfoRef.waitUntilDefined(continueToNextSegment, { clearSignal: canceller.signal });
+                        this._initSegmentInfoRef.waitUntilDefined(continueToNextSegment, { clearSignal: canceller.signal });
                     }
                     else {
                         continueToNextSegment();
                     }
                 },
             }, canceller.signal);
-            request.catch(function (error) {
+            request.catch((error) => {
                 unlinkCanceller();
                 if (!isComplete) {
                     isComplete = true;
-                    _this.stop();
-                    _this.trigger("error", error);
+                    this.stop();
+                    this.trigger("error", error);
                 }
             });
-            _this._mediaSegmentRequest = { segment: segment, priority: priority, request: request, canceller: canceller };
+            this._mediaSegmentRequest = { segment, priority, request, canceller };
         };
         recursivelyRequestSegments(currentNeededSegment);
-    };
+    }
     /**
      * Internal logic performing initialization segment requests.
      * @param {Object} queuedInitSegment
      */
-    DownloadingQueue.prototype._restartInitSegmentDownloadingQueue = function (queuedInitSegment) {
-        var _this = this;
+    _restartInitSegmentDownloadingQueue(queuedInitSegment) {
         if (this._currentCanceller !== null && this._currentCanceller.isUsed()) {
             return;
         }
@@ -330,59 +312,58 @@ var DownloadingQueue = /** @class */ (function (_super) {
         if (queuedInitSegment === null) {
             return;
         }
-        var canceller = new TaskCanceller();
-        var unlinkCanceller = this._currentCanceller === null ?
-            noop :
+        const canceller = new task_canceller_1.default();
+        const unlinkCanceller = this._currentCanceller === null ?
+            noop_1.default :
             canceller.linkToSignal(this._currentCanceller.signal);
-        var segment = queuedInitSegment.segment, priority = queuedInitSegment.priority;
-        var context = objectAssign({ segment: segment }, this._content);
+        const { segment, priority } = queuedInitSegment;
+        const context = (0, object_assign_1.default)({ segment }, this._content);
         /**
          * If `true` , the current task has either errored, finished, or was
          * cancelled.
          */
-        var isComplete = false;
-        var request = this._segmentFetcher.createRequest(context, priority, {
-            onRetry: function (err) {
-                _this.trigger("requestRetry", { segment: segment, error: err });
+        let isComplete = false;
+        const request = this._segmentFetcher.createRequest(context, priority, {
+            onRetry: (err) => {
+                this.trigger("requestRetry", { segment, error: err });
             },
-            beforeInterrupted: function () {
-                log.info("Stream: init segment request interrupted temporarly.", segment.id);
+            beforeInterrupted: () => {
+                log_1.default.info("Stream: init segment request interrupted temporarly.", segment.id);
             },
-            beforeEnded: function () {
+            beforeEnded: () => {
                 unlinkCanceller();
-                _this._initSegmentRequest = null;
+                this._initSegmentRequest = null;
                 isComplete = true;
             },
-            onChunk: function (parse) {
+            onChunk: (parse) => {
                 var _a;
-                var parsed = parse(undefined);
-                assert(parsed.segmentType === "init", "Should have loaded an init segment.");
-                _this.trigger("parsedInitSegment", objectAssign({}, parsed, { segment: segment }));
+                const parsed = parse(undefined);
+                (0, assert_1.default)(parsed.segmentType === "init", "Should have loaded an init segment.");
+                this.trigger("parsedInitSegment", (0, object_assign_1.default)({}, parsed, { segment }));
                 if (parsed.segmentType === "init") {
-                    _this._initSegmentInfoRef.setValue((_a = parsed.initTimescale) !== null && _a !== void 0 ? _a : null);
+                    this._initSegmentInfoRef.setValue((_a = parsed.initTimescale) !== null && _a !== void 0 ? _a : null);
                 }
             },
-            onAllChunksReceived: function () {
-                _this.trigger("fullyLoadedSegment", segment);
+            onAllChunksReceived: () => {
+                this.trigger("fullyLoadedSegment", segment);
             },
         }, canceller.signal);
-        request.catch(function (error) {
+        request.catch((error) => {
             unlinkCanceller();
             if (!isComplete) {
                 isComplete = true;
-                _this.stop();
-                _this.trigger("error", error);
+                this.stop();
+                this.trigger("error", error);
             }
         });
-        canceller.signal.register(function () {
-            _this._initSegmentRequest = null;
+        canceller.signal.register(() => {
+            this._initSegmentRequest = null;
             if (isComplete) {
                 return;
             }
             isComplete = true;
         });
-        this._initSegmentRequest = { segment: segment, priority: priority, request: request, canceller: canceller };
-    };
-    return DownloadingQueue;
-}(EventEmitter));
-export default DownloadingQueue;
+        this._initSegmentRequest = { segment, priority, request, canceller };
+    }
+}
+exports.default = DownloadingQueue;

package/dist/_esm5.processed/core/stream/representation/utils/force_garbage_collection.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,45 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
-    return g = { next: verb(0), "throw": verb(1), "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 };
-    }
-};
-import config from "../../../../config";
-import log from "../../../../log";
-import { getInnerAndOuterRangesFromBufferedTimeRanges } from "../../../../utils/ranges";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../../config");
+const log_1 = require("../../../../log");
+const ranges_1 = require("../../../../utils/ranges");
 /**
  * Run the garbage collector.
  *
@@ -63,47 +29,28 @@ import { getInnerAndOuterRangesFromBufferedTimeRanges } from "../../../../utils/
  * @param {Object} cancellationSignal
  * @returns {Promise}
  */
-export default function forceGarbageCollection(currentPosition, bufferingQueue, cancellationSignal) {
-    return __awaiter(this, void 0, void 0, function () {
-        var GC_GAP_CALM, GC_GAP_BEEFY, buffered, cleanedupRanges, _i, cleanedupRanges_1, range, start, end;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    GC_GAP_CALM = config.getCurrent().BUFFER_GC_GAPS.CALM;
-                    GC_GAP_BEEFY = config.getCurrent().BUFFER_GC_GAPS.BEEFY;
-                    log.warn("Stream: Running garbage collector");
-                    buffered = bufferingQueue.getBufferedRanges();
-                    cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_CALM);
-                    // more aggressive GC if we could not find any range to clean
-                    if (cleanedupRanges.length === 0) {
-                        cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_BEEFY);
-                    }
-                    if (log.hasLevel("DEBUG")) {
-                        log.debug("Stream: GC cleaning", cleanedupRanges.map(function (_a) {
-                            var start = _a.start, end = _a.end;
-                            return "start: ".concat(start, " - end ").concat(end);
-                        })
-                            .join(", "));
-                    }
-                    _i = 0, cleanedupRanges_1 = cleanedupRanges;
-                    _a.label = 1;
-                case 1:
-                    if (!(_i < cleanedupRanges_1.length)) return [3 /*break*/, 4];
-                    range = cleanedupRanges_1[_i];
-                    start = range.start, end = range.end;
-                    if (!(start < end)) return [3 /*break*/, 3];
-                    return [4 /*yield*/, bufferingQueue.removeBuffer(start, end, cancellationSignal)];
-                case 2:
-                    _a.sent();
-                    _a.label = 3;
-                case 3:
-                    _i++;
-                    return [3 /*break*/, 1];
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
+async function forceGarbageCollection(currentPosition, bufferingQueue, cancellationSignal) {
+    const GC_GAP_CALM = config_1.default.getCurrent().BUFFER_GC_GAPS.CALM;
+    const GC_GAP_BEEFY = config_1.default.getCurrent().BUFFER_GC_GAPS.BEEFY;
+    log_1.default.warn("Stream: Running garbage collector");
+    const buffered = bufferingQueue.getBufferedRanges();
+    let cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_CALM);
+    // more aggressive GC if we could not find any range to clean
+    if (cleanedupRanges.length === 0) {
+        cleanedupRanges = selectGCedRanges(currentPosition, buffered, GC_GAP_BEEFY);
+    }
+    if (log_1.default.hasLevel("DEBUG")) {
+        log_1.default.debug("Stream: GC cleaning", cleanedupRanges.map(({ start, end }) => `start: ${start} - end ${end}`)
+            .join(", "));
+    }
+    for (const range of cleanedupRanges) {
+        const { start, end } = range;
+        if (start < end) {
+            await bufferingQueue.removeBuffer(start, end, cancellationSignal);
+        }
+    }
 }
+exports.default = forceGarbageCollection;
 /**
  * Buffer garbage collector algorithm.
  *
@@ -118,23 +65,20 @@ export default function forceGarbageCollection(currentPosition, bufferingQueue,
  * @returns {Array.<Object>} - Ranges selected for clean up
  */
 function selectGCedRanges(position, buffered, gcGap) {
-    var _a = getInnerAndOuterRangesFromBufferedTimeRanges(buffered, position), innerRange = _a.innerRange, outerRanges = _a.outerRanges;
-    var cleanedupRanges = [];
+    const { innerRange, outerRanges } = (0, ranges_1.getInnerAndOuterRangesFromBufferedTimeRanges)(buffered, position);
+    const cleanedupRanges = [];
     // start by trying to remove all ranges that do not contain the
     // current time and respect the gcGap
-    for (var i = 0; i < outerRanges.length; i++) {
-        var outerRange = outerRanges[i];
+    for (let i = 0; i < outerRanges.length; i++) {
+        const outerRange = outerRanges[i];
         if ((position - gcGap > outerRange.end) || (position + gcGap < outerRange.start)) {
             cleanedupRanges.push(outerRange);
         }
     }
     // try to clean up some space in the current range
     if (innerRange !== null) {
-        if (log.hasLevel("DEBUG")) {
-            log.debug("Stream: GC removing part of inner range", cleanedupRanges.map(function (_a) {
-                var start = _a.start, end = _a.end;
-                return "start: ".concat(start, " - end ").concat(end);
-            })
+        if (log_1.default.hasLevel("DEBUG")) {
+            log_1.default.debug("Stream: GC removing part of inner range", cleanedupRanges.map(({ start, end }) => `start: ${start} - end ${end}`)
                 .join(", "));
         }
         if (position - gcGap > innerRange.start) {