rx-player 3.28.1-dev.2022083000 → 3.29.0-dev.2022090500

package/dist/_esm5.processed/core/stream/period/period_stream.js

@@ -20,6 +20,8 @@ import log from "../../../log";
 import objectAssign from "../../../utils/object_assign";
 import { getLeftSizeOfRange } from "../../../utils/ranges";
 import createSharedReference from "../../../utils/reference";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import SegmentBuffersStore from "../../segment_buffers";
 import AdaptationStream from "../adaptation";
 import EVENTS from "../events_generators";
@@ -57,25 +59,28 @@ export default function PeriodStream(_a) {
                     DELTA_POSITION_AFTER_RELOAD.trackSwitch.other;
         if (adaptation === null) { // Current type is disabled for that Period
             log.info("Stream: Set no ".concat(bufferType, " Adaptation. P:"), period.start);
-            var segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
+            var segmentBufferStatus_1 = segmentBuffersStore.getStatus(bufferType);
             var cleanBuffer$ = void 0;
-            if (segmentBufferStatus.type === "initialized") {
+            if (segmentBufferStatus_1.type === "initialized") {
                 log.info("Stream: Clearing previous ".concat(bufferType, " SegmentBuffer"));
                 if (SegmentBuffersStore.isNative(bufferType)) {
                     return reloadAfterSwitch(period, bufferType, playbackObserver, 0);
                 }
-                if (period.end === undefined) {
-                    cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start, Infinity);
-                }
-                else if (period.end <= period.start) {
-                    cleanBuffer$ = observableOf(null);
-                }
-                else {
-                    cleanBuffer$ = segmentBufferStatus.value.removeBuffer(period.start, period.end);
-                }
+                var canceller_1 = new TaskCanceller();
+                cleanBuffer$ = fromCancellablePromise(canceller_1, function () {
+                    if (period.end === undefined) {
+                        return segmentBufferStatus_1.value.removeBuffer(period.start, Infinity, canceller_1.signal);
+                    }
+                    else if (period.end <= period.start) {
+                        return Promise.resolve();
+                    }
+                    else {
+                        return segmentBufferStatus_1.value.removeBuffer(period.start, period.end, canceller_1.signal);
+                    }
+                });
             }
             else {
-                if (segmentBufferStatus.type === "uninitialized") {
+                if (segmentBufferStatus_1.type === "uninitialized") {
                     segmentBuffersStore.disableSegmentBuffer(bufferType);
                 }
                 cleanBuffer$ = observableOf(null);
@@ -101,7 +106,10 @@ export default function PeriodStream(_a) {
             var cleanBuffer$ = strategy.type === "clean-buffer" || strategy.type === "flush-buffer" ?
                 observableConcat.apply(void 0, strategy.value.map(function (_a) {
                     var start = _a.start, end = _a.end;
-                    return segmentBuffer.removeBuffer(start, end);
+                    var canceller = new TaskCanceller();
+                    return fromCancellablePromise(canceller, function () {
+                        return segmentBuffer.removeBuffer(start, end, canceller.signal);
+                    });
                 })
                 // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
                 // first type parameter as `any` instead of the perfectly fine `unknown`,
@@ -111,7 +119,10 @@ export default function PeriodStream(_a) {
                 ).pipe(ignoreElements()) : EMPTY;
             var bufferGarbageCollector$ = garbageCollectors.get(segmentBuffer);
             var adaptationStream$ = createAdaptationStream(adaptation, segmentBuffer);
-            return segmentBuffersStore.waitForUsableBuffers().pipe(mergeMap(function () {
+            var cancelWait = new TaskCanceller();
+            return fromCancellablePromise(cancelWait, function () {
+                return segmentBuffersStore.waitForUsableBuffers(cancelWait.signal);
+            }).pipe(mergeMap(function () {
                 return observableConcat(cleanBuffer$, needsBufferFlush$, observableMerge(adaptationStream$, bufferGarbageCollector$));
             }));
         });

package/dist/_esm5.processed/core/stream/representation/append_segment_to_buffer.d.ts

@@ -13,10 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * This file allows any Stream to push data to a SegmentBuffer.
- */
-import { Observable } from "rxjs";
+import { CancellationSignal } from "../../../utils/task_canceller";
 import { IReadOnlyPlaybackObserver } from "../../api";
 import { IPushChunkInfos, SegmentBuffer } from "../../segment_buffers";
 import { IRepresentationStreamPlaybackObservation } from "./representation_stream";
@@ -24,10 +21,10 @@ import { IRepresentationStreamPlaybackObservation } from "./representation_strea
  * Append a segment to the given segmentBuffer.
  * If it leads to a QuotaExceededError, try to run our custom range
  * _garbage collector_ then retry.
- *
  * @param {Observable} playbackObserver
  * @param {Object} segmentBuffer
  * @param {Object} dataInfos
- * @returns {Observable}
+ * @param {Object} cancellationSignal
+ * @returns {Promise}
  */
-export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, segmentBuffer: SegmentBuffer, dataInfos: IPushChunkInfos<T>): Observable<unknown>;
+export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, segmentBuffer: SegmentBuffer, dataInfos: IPushChunkInfos<T>, cancellationSignal: CancellationSignal): Promise<void>;

package/dist/_esm5.processed/core/stream/representation/append_segment_to_buffer.js

@@ -13,40 +13,97 @@
  * 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 (_) 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 };
+    }
+};
 /**
  * This file allows any Stream to push data to a SegmentBuffer.
  */
-import { catchError, concat as observableConcat, mergeMap, ignoreElements, take, } from "rxjs";
 import { MediaError } from "../../../errors";
 import forceGarbageCollection from "./force_garbage_collection";
 /**
  * Append a segment to the given segmentBuffer.
  * If it leads to a QuotaExceededError, try to run our custom range
  * _garbage collector_ then retry.
- *
  * @param {Observable} playbackObserver
  * @param {Object} segmentBuffer
  * @param {Object} dataInfos
- * @returns {Observable}
+ * @param {Object} cancellationSignal
+ * @returns {Promise}
  */
-export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos) {
-    var append$ = segmentBuffer.pushChunk(dataInfos);
-    return append$.pipe(catchError(function (appendError) {
-        if (!(appendError instanceof Error) || appendError.name !== "QuotaExceededError") {
-            var reason = appendError instanceof Error ?
-                appendError.toString() :
-                "An unknown error happened when pushing content";
-            throw new MediaError("BUFFER_APPEND_ERROR", reason);
-        }
-        return playbackObserver.getReference().asObservable().pipe(take(1), mergeMap(function (observation) {
-            var _a;
-            var currentPos = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
-            return observableConcat(forceGarbageCollection(currentPos, segmentBuffer).pipe(ignoreElements()), append$).pipe(catchError(function (forcedGCError) {
-                var reason = forcedGCError instanceof Error ?
-                    forcedGCError.toString() :
-                    "Could not clean the buffer";
-                throw new MediaError("BUFFER_FULL_ERROR", reason);
-            }));
-        }));
-    }));
+export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, cancellationSignal) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var appendError_1, reason, position, currentPos, err2_1, reason;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 2, , 8]);
+                    return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos, cancellationSignal)];
+                case 1:
+                    _b.sent();
+                    return [3 /*break*/, 8];
+                case 2:
+                    appendError_1 = _b.sent();
+                    if (!(appendError_1 instanceof Error) || appendError_1.name !== "QuotaExceededError") {
+                        reason = appendError_1 instanceof Error ?
+                            appendError_1.toString() :
+                            "An unknown error happened when pushing content";
+                        throw new MediaError("BUFFER_APPEND_ERROR", reason);
+                    }
+                    position = playbackObserver.getReference().getValue().position;
+                    currentPos = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
+                    _b.label = 3;
+                case 3:
+                    _b.trys.push([3, 6, , 7]);
+                    return [4 /*yield*/, forceGarbageCollection(currentPos, segmentBuffer, cancellationSignal)];
+                case 4:
+                    _b.sent();
+                    return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos, cancellationSignal)];
+                case 5:
+                    _b.sent();
+                    return [3 /*break*/, 7];
+                case 6:
+                    err2_1 = _b.sent();
+                    reason = err2_1 instanceof Error ? err2_1.toString() :
+                        "Could not clean the buffer";
+                    throw new MediaError("BUFFER_FULL_ERROR", reason);
+                case 7: return [3 /*break*/, 8];
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
 }

package/dist/_esm5.processed/core/stream/representation/force_garbage_collection.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
+import { CancellationSignal } from "../../../utils/task_canceller";
 import { SegmentBuffer } from "../../segment_buffers";
 /**
  * Run the garbage collector.
@@ -21,8 +21,9 @@ import { SegmentBuffer } from "../../segment_buffers";
  * Try to clean up buffered ranges from a low gcGap at first.
  * If it does not succeed to clean up space, use a higher gcCap.
  *
- * @param {Observable} timings$
+ * @param {number} currentPosition
  * @param {Object} bufferingQueue
- * @returns {Observable}
+ * @param {Object} cancellationSignal
+ * @returns {Promise}
  */
-export default function forceGarbageCollection(currentPosition: number, bufferingQueue: SegmentBuffer): Observable<unknown>;
+export default function forceGarbageCollection(currentPosition: number, bufferingQueue: SegmentBuffer, cancellationSignal: CancellationSignal): Promise<void>;

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

@@ -13,7 +13,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concatAll, defer as observableDefer, from as observableFrom, of as observableOf, } from "rxjs";
+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 (_) 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 { getInnerAndOuterTimeRanges } from "../../../utils/ranges";
@@ -23,33 +58,50 @@ import { getInnerAndOuterTimeRanges } from "../../../utils/ranges";
  * Try to clean up buffered ranges from a low gcGap at first.
  * If it does not succeed to clean up space, use a higher gcCap.
  *
- * @param {Observable} timings$
+ * @param {number} currentPosition
  * @param {Object} bufferingQueue
- * @returns {Observable}
+ * @param {Object} cancellationSignal
+ * @returns {Promise}
  */
-export default function forceGarbageCollection(currentPosition, bufferingQueue) {
-    return observableDefer(function () {
-        var GC_GAP_CALM = config.getCurrent().BUFFER_GC_GAPS.CALM;
-        var GC_GAP_BEEFY = config.getCurrent().BUFFER_GC_GAPS.BEEFY;
-        log.warn("Stream: Running garbage collector");
-        var buffered = bufferingQueue.getBufferedRanges();
-        var 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(", "));
-        }
-        return observableFrom(cleanedupRanges.map(function (_a) {
-            var start = _a.start, end = _a.end;
-            return start >= end ? observableOf(null) :
-                bufferingQueue.removeBuffer(start, end);
-        })).pipe(concatAll());
+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*/];
+            }
+        });
     });
 }
 /**

package/dist/_esm5.processed/core/stream/representation/get_buffer_status.js

@@ -38,7 +38,11 @@ import getSegmentPriority from "./get_segment_priority";
 export default function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer) {
     segmentBuffer.synchronizeInventory();
     var representation = content.representation;
-    var neededRange = getRangeOfNeededSegments(content, initialWantedTime, bufferGoal);
+    var askedStart = playbackObserver.getIsPaused() ||
+        playbackObserver.getPlaybackRate() <= 0 ?
+        initialWantedTime - 0.1 :
+        initialWantedTime;
+    var neededRange = getRangeOfNeededSegments(content, askedStart, bufferGoal);
     var shouldRefreshManifest = representation.index.shouldRefresh(neededRange.start, neededRange.end);
     /**
      * Every segment awaiting an "EndOfSegment" operation, which indicates that a
@@ -57,7 +61,7 @@ export default function getBufferStatus(content, initialWantedTime, playbackObse
     /** List of segments we will need to download. */
     var _a = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), segmentsToLoad = _a.segmentsToLoad, segmentsOnHold = _a.segmentsOnHold, isBufferFull = _a.isBufferFull;
     var prioritizedNeededSegments = segmentsToLoad.map(function (segment) { return ({
-        priority: getSegmentPriority(segment.time, initialWantedTime),
+        priority: getSegmentPriority(segment.time, askedStart),
         segment: segment,
     }); });
     /**
@@ -119,7 +123,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
         wantedStartPosition = lastIndexPosition - 1;
     }
     else {
-        wantedStartPosition = initialWantedTime;
+        wantedStartPosition = initialWantedTime - 0.1;
     }
     var wantedEndPosition = wantedStartPosition + bufferGoal;
     var hasReachedPeriodEnd;

package/dist/_esm5.processed/core/stream/representation/push_init_segment.js

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 import { defer as observableDefer, EMPTY, map, } from "rxjs";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import EVENTS from "../events_generators";
 import appendSegmentToBuffer from "./append_segment_to_buffer";
 /**
@@ -35,7 +37,11 @@ export default function pushInitSegment(_a) {
             chunk: null,
             timestampOffset: 0,
             appendWindow: [undefined, undefined], codec: codec };
-        return appendSegmentToBuffer(playbackObserver, segmentBuffer, { data: data, inventoryInfos: null }).pipe(map(function () {
+        var canceller = new TaskCanceller();
+        return fromCancellablePromise(canceller, function () {
+            return appendSegmentToBuffer(playbackObserver, segmentBuffer, { data: data, inventoryInfos: null }, canceller.signal);
+        })
+            .pipe(map(function () {
             var buffered = segmentBuffer.getBufferedRanges();
             return EVENTS.addedSegment(content, segment, buffered, segmentData);
         }));

package/dist/_esm5.processed/core/stream/representation/push_media_segment.js

@@ -16,6 +16,8 @@
 import { defer as observableDefer, EMPTY, map, } from "rxjs";
 import config from "../../../config";
 import objectAssign from "../../../utils/object_assign";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import EVENTS from "../events_generators";
 import appendSegmentToBuffer from "./append_segment_to_buffer";
 /**
@@ -62,7 +64,11 @@ export default function pushMediaSegment(_a) {
         }
         var inventoryInfos = objectAssign({ segment: segment, chunkSize: chunkSize, start: estimatedStart,
             end: estimatedEnd }, content);
-        return appendSegmentToBuffer(playbackObserver, segmentBuffer, { data: data, inventoryInfos: inventoryInfos }).pipe(map(function () {
+        var canceller = new TaskCanceller();
+        return fromCancellablePromise(canceller, function () {
+            return appendSegmentToBuffer(playbackObserver, segmentBuffer, { data: data, inventoryInfos: inventoryInfos }, canceller.signal);
+        })
+            .pipe(map(function () {
             var buffered = segmentBuffer.getBufferedRanges();
             return EVENTS.addedSegment(content, segment, buffered, chunkData);
         }));

package/dist/_esm5.processed/core/stream/representation/representation_stream.js

@@ -28,6 +28,8 @@ import log from "../../../log";
 import assertUnreachable from "../../../utils/assert_unreachable";
 import objectAssign from "../../../utils/object_assign";
 import { createSharedReference } from "../../../utils/reference";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import EVENTS from "../events_generators";
 import DownloadingQueue from "./downloading_queue";
 import getBufferStatus from "./get_buffer_status";
@@ -171,12 +173,14 @@ export default function RepresentationStream(_a) {
         var bufferRemoval = EMPTY;
         var UPTO_CURRENT_POSITION_CLEANUP = config.getCurrent().UPTO_CURRENT_POSITION_CLEANUP;
         if (status.isBufferFull) {
-            var gcedPosition = Math.max(0, initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
-            if (gcedPosition > 0) {
-                bufferRemoval = segmentBuffer
-                    .removeBuffer(0, gcedPosition)
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    .pipe(ignoreElements());
+            var gcedPosition_1 = Math.max(0, initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
+            if (gcedPosition_1 > 0) {
+                var removalCanceller_1 = new TaskCanceller();
+                bufferRemoval = fromCancellablePromise(removalCanceller_1, function () {
+                    return segmentBuffer.removeBuffer(0, gcedPosition_1, removalCanceller_1.signal);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                ).pipe(ignoreElements());
             }
         }
         return status.shouldRefreshManifest ?
@@ -207,8 +211,11 @@ export default function RepresentationStream(_a) {
             case "parsed-media":
                 return onParsedChunk(evt);
             case "end-of-segment": {
-                var segment = evt.value.segment;
-                return segmentBuffer.endOfSegment(objectAssign({ segment: segment }, content))
+                var segment_1 = evt.value.segment;
+                var endOfSegmentCanceller_1 = new TaskCanceller();
+                return fromCancellablePromise(endOfSegmentCanceller_1, function () {
+                    return segmentBuffer.endOfSegment(objectAssign({ segment: segment_1 }, content), endOfSegmentCanceller_1.signal);
+                })
                     // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
                     // first type parameter as `any` instead of the perfectly fine `unknown`,
                     // leading to linter issues, as it forbids the usage of `any`.

package/dist/_esm5.processed/default_config.js

@@ -312,7 +312,7 @@ var DEFAULT_CONFIG = {
      * small enough so this (arguably rare) situation won't lead to too much
      * waiting time.
      */
-    FORCE_DISCONTINUITY_SEEK_DELAY: 2000,
+    FORCE_DISCONTINUITY_SEEK_DELAY: 3000,
     /**
      * Ratio used to know if an already loaded segment should be re-buffered.
      * We re-load the given segment if the current one times that ratio is

package/dist/_esm5.processed/errors/custom_loader_error.d.ts

@@ -29,9 +29,10 @@ export default class CustomLoaderError extends Error {
     readonly isOfflineError: boolean;
     readonly xhr: XMLHttpRequest | undefined;
     /**
+     * @param {string} message
+     * @param {boolean} canRetry
+     * @param {boolean} isOfflineError
      * @param {XMLHttpRequest} xhr
-     * @param {string} url
-     * @param {string} type
      */
     constructor(message: string, canRetry: boolean, isOfflineError: boolean, xhr: XMLHttpRequest | undefined);
 }

package/dist/_esm5.processed/errors/custom_loader_error.js

@@ -40,9 +40,10 @@ var __extends = (this && this.__extends) || (function () {
 var CustomLoaderError = /** @class */ (function (_super) {
     __extends(CustomLoaderError, _super);
     /**
+     * @param {string} message
+     * @param {boolean} canRetry
+     * @param {boolean} isOfflineError
      * @param {XMLHttpRequest} xhr
-     * @param {string} url
-     * @param {string} type
      */
     function CustomLoaderError(message, canRetry, isOfflineError, xhr) {
         var _this = _super.call(this) || this;

package/dist/_esm5.processed/experimental/tools/VideoThumbnailLoader/get_initialized_source_buffer.js

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 import { EMPTY, map, merge as observableMerge, mergeMap, of as observableOf, ReplaySubject, Subject, tap, } from "rxjs";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import prepareSourceBuffer from "./prepare_source_buffer";
 var mediaSourceSubscription;
 var sourceBufferContent;
@@ -63,14 +65,15 @@ function loadAndPushInitData(contentInfos, initSegment, sourceBuffer, segmentFet
         var initSegmentData = initializationData instanceof ArrayBuffer ?
             new Uint8Array(initializationData) :
             initializationData;
-        return sourceBuffer
+        var pushCanceller = new TaskCanceller();
+        return fromCancellablePromise(pushCanceller, function () { return sourceBuffer
             .pushChunk({ data: { initSegment: initSegmentData,
                 chunk: null,
                 appendWindow: [undefined, undefined],
                 timestampOffset: 0,
                 codec: contentInfos
                     .representation.getMimeTypeString() },
-            inventoryInfos: null });
+            inventoryInfos: null }, pushCanceller.signal); });
     }));
 }
 /**

package/dist/_esm5.processed/experimental/tools/VideoThumbnailLoader/push_data.js

@@ -1,3 +1,5 @@
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 /**
  * Push data to the video source buffer.
  * @param {Object} inventoryInfos
@@ -10,9 +12,10 @@ export default function pushData(inventoryInfos, parsed, videoSourceBuffer) {
     var chunkData = parsed.chunkData, appendWindow = parsed.appendWindow;
     var segmentData = chunkData instanceof ArrayBuffer ?
         new Uint8Array(chunkData) : chunkData;
-    return videoSourceBuffer
+    var pushCanceller = new TaskCanceller();
+    return fromCancellablePromise(pushCanceller, function () { return videoSourceBuffer
         .pushChunk({ data: { chunk: segmentData,
             timestampOffset: 0, appendWindow: appendWindow, initSegment: null,
             codec: inventoryInfos
-                .representation.getMimeTypeString() }, inventoryInfos: inventoryInfos });
+                .representation.getMimeTypeString() }, inventoryInfos: inventoryInfos }, pushCanceller.signal); });
 }

package/dist/_esm5.processed/experimental/tools/VideoThumbnailLoader/remove_buffer_around_time.js

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 import { combineLatest as observableCombineLatest, of as observableOf, } from "rxjs";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 /**
  * Remove buffer around wanted time, considering a margin around
  * it that defines what must be kept :
@@ -31,11 +33,16 @@ export default function removeBufferAroundTime$(videoElement, sourceBuffer, time
         return observableOf(null);
     }
     var bufferRemovals$ = [];
+    var removalCanceller = new TaskCanceller();
     if ((time - margin) > 0) {
-        bufferRemovals$.push(sourceBuffer.removeBuffer(0, time - margin));
+        bufferRemovals$.push(fromCancellablePromise(removalCanceller, function () {
+            return sourceBuffer.removeBuffer(0, time - margin, removalCanceller.signal);
+        }));
     }
     if ((time + margin) < videoElement.duration) {
-        bufferRemovals$.push(sourceBuffer.removeBuffer(time + margin, videoElement.duration));
+        bufferRemovals$.push(fromCancellablePromise(removalCanceller, function () {
+            return sourceBuffer.removeBuffer(time + margin, videoElement.duration, removalCanceller.signal);
+        }));
     }
     return observableCombineLatest(bufferRemovals$);
 }

package/dist/_esm5.processed/experimental/tools/VideoThumbnailLoader/thumbnail_loader.js

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { catchError, combineLatest, finalize, ignoreElements, lastValueFrom, map, merge as observableMerge, mergeMap, race as observableRace, Subject, take, tap, } from "rxjs";
+import config from "../../../config";
 import createSegmentFetcher from "../../../core/fetchers/segment/segment_fetcher";
 import log from "../../../log";
 import objectAssign from "../../../utils/object_assign";
@@ -146,7 +147,8 @@ var VideoThumbnailLoader = /** @class */ (function () {
         {}, { baseDelay: 0,
             maxDelay: 0,
             maxRetryOffline: 0,
-            maxRetryRegular: 0 });
+            maxRetryRegular: 0,
+            requestTimeout: config.getCurrent().DEFAULT_REQUEST_TIMEOUT });
         var taskPromise = lastValueFrom(observableRace(abortError$, getInitializedSourceBuffer$(contentInfos, this._videoElement, segmentFetcher).pipe(mergeMap(function (videoSourceBuffer) {
             var bufferCleaning$ = removeBufferAroundTime$(_this._videoElement, videoSourceBuffer, time);
             log.debug("VTL: Removing buffer around time.", time);