rx-player 3.30.0-dev.2023020100 → 3.30.0-dev.2023030200

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.js

@@ -69,10 +69,22 @@ var generateRequestID = idGenerator();
  * An `ISegmentFetcher` also implements a retry mechanism, based on the given
  * `options` argument, which may retry a segment request when it fails.
  *
- * @param {string} bufferType
- * @param {Object} pipeline
- * @param {Object} lifecycleCallbacks
- * @param {Object} options
+ * @param {string} bufferType - Type of  buffer concerned (e.g. `"audio"`,
+ * `"video"`, `"text" etc.)
+ * @param {Object} pipeline - The transport-specific logic allowing to load
+ * segments of the given buffer type and transport protocol (e.g. DASH).
+ * @param {Object|null} cdnPrioritizer - Abstraction allowing to synchronize,
+ * update and keep track of the priorization of the CDN to use to load any given
+ * segment, in cases where multiple ones are available.
+ *
+ * Can be set to `null` in which case a minimal priorization logic will be used
+ * instead.
+ * @param {Object} lifecycleCallbacks - Callbacks that can be registered to be
+ * informed when new requests are made, ended, new metrics are available etc.
+ * This should be mainly useful to implement an adaptive logic relying on those
+ * metrics and events.
+ * @param {Object} options - Various tweaking options allowing to configure the
+ * behavior of the returned `ISegmentFetcher`.
  * @returns {Function}
  */
 export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCallbacks, options) {
@@ -97,8 +109,17 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
      * @returns {Promise}
      */
     return function fetchSegment(content, fetcherCallbacks, cancellationSignal) {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function () {
+            function onCancellation() {
+                var _a;
+                if (requestInfo !== undefined) {
+                    return; // Request already terminated
+                }
+                log.debug("SF: Segment request cancelled", segmentIdString);
+                requestInfo = null;
+                (_a = lifecycleCallbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { id: requestId });
+            }
             /**
              * Call a segment loader for the given URL with the right arguments.
              * @param {Object|null} cdnMetadata
@@ -169,8 +190,8 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
                 }
             }
             var segmentIdString, requestId, requestInfo, parsedChunks, segmentDurationAcc, metricsSent, loaderCallbacks, cached, res, loadedData, err_1;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         segmentIdString = getLoggableSegmentId(content);
                         requestId = generateRequestID();
@@ -216,21 +237,13 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
                         log.debug("SF: Beginning request", segmentIdString);
                         (_a = lifecycleCallbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { requestTimestamp: performance.now(),
                             id: requestId, content: content });
-                        cancellationSignal.register(function () {
-                            var _a;
-                            if (requestInfo !== undefined) {
-                                return; // Request already terminated
-                            }
-                            log.debug("SF: Segment request cancelled", segmentIdString);
-                            requestInfo = null;
-                            (_a = lifecycleCallbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { id: requestId });
-                        });
-                        _c.label = 1;
+                        cancellationSignal.register(onCancellation);
+                        _d.label = 1;
                     case 1:
-                        _c.trys.push([1, 3, , 4]);
+                        _d.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, scheduleRequestWithCdns(content.representation.cdnMetadata, cdnPrioritizer, callLoaderWithUrl, objectAssign({ onRetry: onRetry }, options), cancellationSignal)];
                     case 2:
-                        res = _c.sent();
+                        res = _d.sent();
                         if (res.resultType === "segment-loaded") {
                             loadedData = res.resultData.responseData;
                             if (cache !== undefined) {
@@ -250,21 +263,24 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
                         else {
                             requestInfo = null;
                         }
-                        if (!cancellationSignal.isCancelled) {
+                        if (!cancellationSignal.isCancelled()) {
                             // The current task could have been canceled as a result of one
                             // of the previous callbacks call. In that case, we don't want to send
                             // a "requestEnd" again as it has already been sent on cancellation.
                             (_b = lifecycleCallbacks.onRequestEnd) === null || _b === void 0 ? void 0 : _b.call(lifecycleCallbacks, { id: requestId });
                         }
+                        cancellationSignal.deregister(onCancellation);
                         return [3 /*break*/, 4];
                     case 3:
-                        err_1 = _c.sent();
+                        err_1 = _d.sent();
+                        cancellationSignal.deregister(onCancellation);
                         requestInfo = null;
                         if (err_1 instanceof CancellationError) {
                             log.debug("SF: Segment request aborted", segmentIdString);
                             throw err_1;
                         }
                         log.debug("SF: Segment request failed", segmentIdString);
+                        (_c = lifecycleCallbacks.onRequestEnd) === null || _c === void 0 ? void 0 : _c.call(lifecycleCallbacks, { id: requestId });
                         throw errorSelector(err_1);
                     case 4: return [2 /*return*/];
                 }

package/dist/_esm5.processed/core/fetchers/segment/task_prioritizer.js

@@ -1,5 +1,6 @@
 import log from "../../../log";
 import arrayFindIndex from "../../../utils/array_find_index";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
 var TaskPrioritizer = /** @class */ (function () {
     /**
@@ -41,18 +42,31 @@ var TaskPrioritizer = /** @class */ (function () {
     TaskPrioritizer.prototype.create = function (taskFn, priority, callbacks, cancelSignal) {
         var _this = this;
         var newTask;
-        return new Promise(function (resolve, reject) {
+        return createCancellablePromise(cancelSignal, function (resolve, reject) {
             /** Function allowing to start the underlying Promise. */
             var trigger = function () {
                 if (newTask.hasEnded) {
-                    unregisterCancelSignal();
                     return;
                 }
-                var interrupter = new TaskCanceller({ cancelOn: cancelSignal });
+                var finishTask = function () {
+                    unlinkInterrupter();
+                    _this._endTask(newTask);
+                };
+                var onResolve = function (value) {
+                    callbacks.beforeEnded();
+                    finishTask();
+                    resolve(value);
+                };
+                var onReject = function (err) {
+                    finishTask();
+                    reject(err);
+                };
+                var interrupter = new TaskCanceller();
+                var unlinkInterrupter = interrupter.linkToSignal(cancelSignal);
                 newTask.interrupter = interrupter;
                 interrupter.signal.register(function () {
                     newTask.interrupter = null;
-                    if (!cancelSignal.isCancelled) {
+                    if (!cancelSignal.isCancelled()) {
                         callbacks.beforeInterrupted();
                     }
                 });
@@ -63,31 +77,14 @@ var TaskPrioritizer = /** @class */ (function () {
                 newTask.taskFn(interrupter.signal)
                     .then(onResolve)
                     .catch(function (err) {
-                    if (!cancelSignal.isCancelled &&
-                        interrupter.isUsed &&
+                    if (!cancelSignal.isCancelled() &&
+                        interrupter.isUsed() &&
                         err instanceof CancellationError) {
                         return;
                     }
                     onReject(err);
                 });
             };
-            var unregisterCancelSignal = cancelSignal.register(function (cancellationError) {
-                _this._endTask(newTask);
-                reject(cancellationError);
-            });
-            var finishTask = function () {
-                unregisterCancelSignal();
-                _this._endTask(newTask);
-            };
-            var onResolve = function (value) {
-                callbacks.beforeEnded();
-                finishTask();
-                resolve(value);
-            };
-            var onReject = function (err) {
-                finishTask();
-                reject(err);
-            };
             newTask = {
                 hasEnded: false,
                 priority: priority,
@@ -112,6 +109,7 @@ var TaskPrioritizer = /** @class */ (function () {
                     _this._interruptCancellableTasks();
                 }
             }
+            return function () { return _this._endTask(newTask); };
         });
     };
     TaskPrioritizer.prototype._endTask = function (task) {

package/dist/_esm5.processed/core/fetchers/utils/schedule_request.js

@@ -288,14 +288,14 @@ export function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, op
                 var nextCdn;
                 return __generator(this, function (_a) {
                     nextCdn = getCdnToRequest();
-                    if (cancellationSignal.isCancelled) {
+                    if (cancellationSignal.isCancelled()) {
                         throw cancellationSignal.cancellationError;
                     }
                     if (nextCdn === undefined) {
                         throw prevRequestError;
                     }
                     onRetry(prevRequestError);
-                    if (cancellationSignal.isCancelled) {
+                    if (cancellationSignal.isCancelled()) {
                         throw cancellationSignal.cancellationError;
                     }
                     return [2 /*return*/, waitPotentialBackoffAndRequest(nextCdn, prevRequestError)];
@@ -323,25 +323,35 @@ export function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, op
             if (blockedFor <= 0) {
                 return requestCdn(nextWantedCdn);
             }
-            var canceller = new TaskCanceller({ cancelOn: cancellationSignal });
+            var canceller = new TaskCanceller();
+            var unlinkCanceller = canceller.linkToSignal(cancellationSignal);
             return new Promise(function (res, rej) {
                 /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
                 cdnPrioritizer === null || cdnPrioritizer === void 0 ? void 0 : cdnPrioritizer.addEventListener("priorityChange", function () {
                     var updatedPrioritaryCdn = getCdnToRequest();
-                    if (cancellationSignal.isCancelled) {
+                    if (cancellationSignal.isCancelled()) {
                         throw cancellationSignal.cancellationError;
                     }
                     if (updatedPrioritaryCdn === undefined) {
-                        return rej(prevRequestError);
+                        return cleanAndReject(prevRequestError);
                     }
                     if (updatedPrioritaryCdn !== nextWantedCdn) {
                         canceller.cancel();
                         waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError)
-                            .then(res, rej);
+                            .then(cleanAndResolve, cleanAndReject);
                     }
                 }, canceller.signal);
                 cancellableSleep(blockedFor, canceller.signal)
-                    .then(function () { return requestCdn(nextWantedCdn).then(res, rej); }, noop);
+                    .then(function () { return requestCdn(nextWantedCdn)
+                    .then(cleanAndResolve, cleanAndReject); }, noop);
+                function cleanAndResolve(response) {
+                    unlinkCanceller();
+                    res(response);
+                }
+                function cleanAndReject(err) {
+                    unlinkCanceller();
+                    rej(err);
+                }
             });
         }
         /**

package/dist/_esm5.processed/core/init/directfile_content_initializer.js

@@ -145,7 +145,7 @@ var DirectFileContentInitializer = /** @class */ (function (_super) {
             }, { emitCurrentValue: true, clearSignal: cancelSignal });
         })
             .catch(function (err) {
-            if (!cancelSignal.isCancelled) {
+            if (!cancelSignal.isCancelled()) {
                 _this._onFatalError(err);
             }
         });

package/dist/_esm5.processed/core/init/media_source_content_initializer.js

@@ -69,6 +69,7 @@ import config from "../../config";
 import { MediaError } from "../../errors";
 import log from "../../log";
 import assert from "../../utils/assert";
+import createCancellablePromise from "../../utils/create_cancellable_promise";
 import objectAssign from "../../utils/object_assign";
 import createSharedReference from "../../utils/reference";
 import TaskCanceller from "../../utils/task_canceller";
@@ -127,11 +128,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
         if (this._initialManifestProm !== null) {
             return;
         }
-        this._initialManifestProm = new Promise(function (res, rej) {
-            _this._initCanceller.signal.register(function (err) {
-                _this._manifestFetcher.dispose();
-                rej(err);
-            });
+        this._initialManifestProm = createCancellablePromise(this._initCanceller.signal, function (res, rej) {
             _this._manifestFetcher.addEventListener("warning", function (err) {
                 return _this.trigger("warning", err);
             });
@@ -142,7 +139,10 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             _this._manifestFetcher.addEventListener("manifestReady", function (manifest) {
                 res(manifest);
             });
-            _this._manifestFetcher.start();
+        });
+        this._manifestFetcher.start();
+        this._initCanceller.signal.register(function () {
+            _this._manifestFetcher.dispose();
         });
     };
     /**
@@ -176,7 +176,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
         this._initCanceller.cancel();
     };
     MediaSourceContentInitializer.prototype._onFatalError = function (err) {
-        if (this._initCanceller.isUsed) {
+        if (this._initCanceller.isUsed()) {
             return;
         }
         this._initCanceller.cancel();
@@ -184,12 +184,9 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
     };
     MediaSourceContentInitializer.prototype._initializeMediaSourceAndDecryption = function (mediaElement, protectionRef) {
         var _this = this;
-        return new Promise(function (resolve, reject) {
+        var initCanceller = this._initCanceller;
+        return createCancellablePromise(initCanceller.signal, function (resolve) {
             var keySystems = _this._settings.keySystems;
-            var initCanceller = _this._initCanceller;
-            var unregisterReject = initCanceller.signal.register(function (err) {
-                reject(err);
-            });
             /** Initialize decryption capabilities. */
             var drmInitRef = initializeContentDecryption(mediaElement, keySystems, protectionRef, {
                 onWarning: function (err) { return _this.trigger("warning", err); },
@@ -200,9 +197,8 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                     return;
                 }
                 stopListeningToDrmUpdates();
-                var mediaSourceCanceller = new TaskCanceller({
-                    cancelOn: initCanceller.signal,
-                });
+                var mediaSourceCanceller = new TaskCanceller();
+                mediaSourceCanceller.linkToSignal(initCanceller.signal);
                 openMediaSource(mediaElement, mediaSourceCanceller.signal)
                     .then(function (mediaSource) {
                     var lastDrmStatus = drmInitRef.getValue();
@@ -211,7 +207,6 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                         drmInitRef.onUpdate(function (newDrmStatus, stopListeningToDrmUpdatesAgain) {
                             if (newDrmStatus.initializationState.type === "initialized") {
                                 stopListeningToDrmUpdatesAgain();
-                                unregisterReject();
                                 resolve({ mediaSource: mediaSource, drmSystemId: newDrmStatus.drmSystemId,
                                     unlinkMediaSource: mediaSourceCanceller });
                                 return;
@@ -219,14 +214,13 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                         }, { emitCurrentValue: true, clearSignal: initCanceller.signal });
                     }
                     else if (drmStatus.initializationState.type === "initialized") {
-                        unregisterReject();
                         resolve({ mediaSource: mediaSource, drmSystemId: drmStatus.drmSystemId,
                             unlinkMediaSource: mediaSourceCanceller });
                         return;
                     }
                 })
                     .catch(function (err) {
-                    if (mediaSourceCanceller.isUsed) {
+                    if (mediaSourceCanceller.isUsed()) {
                         return;
                     }
                     _this._onFatalError(err);
@@ -252,20 +246,21 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 bufferOnMediaSource(opts, onReloadMediaSource, currentCanceller.signal);
                 function onReloadMediaSource(reloadOrder) {
                     currentCanceller.cancel();
-                    if (initCanceller.isUsed) {
+                    if (initCanceller.isUsed()) {
                         return;
                     }
                     triggerEvent("reloadingMediaSource", null);
-                    if (initCanceller.isUsed) {
+                    if (initCanceller.isUsed()) {
                         return;
                     }
-                    var newCanceller = new TaskCanceller({ cancelOn: initCanceller.signal });
+                    var newCanceller = new TaskCanceller();
+                    newCanceller.linkToSignal(initCanceller.signal);
                     openMediaSource(mediaElement, newCanceller.signal)
                         .then(function (newMediaSource) {
                         recursivelyLoadOnMediaSource(newMediaSource, reloadOrder.position, reloadOrder.autoPlay, newCanceller);
                     })
                         .catch(function (err) {
-                        if (newCanceller.isUsed) {
+                        if (newCanceller.isUsed()) {
                             return;
                         }
                         onFatalError(err);
@@ -305,7 +300,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                         subBufferOptions = objectAssign({ textTrackOptions: textTrackOptions, drmSystemId: drmSystemId }, bufferOptions);
                         segmentFetcherCreator = new SegmentFetcherCreator(transport, segmentRequestOptions, initCanceller.signal);
                         this.trigger("manifestReady", manifest);
-                        if (initCanceller.isUsed) {
+                        if (initCanceller.isUsed()) {
                             return [2 /*return*/];
                         }
                         bufferOnMediaSource = this._startBufferingOnMediaSource.bind(this);
@@ -339,7 +334,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             segmentBuffersStore.disposeAll();
         });
         var _b = performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, function (err) { return _this.trigger("warning", err); }, cancelSignal), autoPlayResult = _b.autoPlayResult, initialPlayPerformed = _b.initialPlayPerformed, initialSeekPerformed = _b.initialSeekPerformed;
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
             return;
         }
         initialPlayPerformed.onUpdate(function (isPerformed, stopListening) {
@@ -368,7 +363,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             }, { emitCurrentValue: true, clearSignal: cancelSignal });
         })
             .catch(function (err) {
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
                 return; // Current loading cancelled, no need to trigger the error
             }
             _this._onFatalError(err);
@@ -395,7 +390,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                         discontinuity: imminentDiscontinuity,
                         position: position,
                     });
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     // If the status for the last Period indicates that segments are all loaded
@@ -432,14 +427,14 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 },
                 adaptationChange: function (value) {
                     self.trigger("adaptationChange", value);
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     contentTimeBoundariesObserver.onAdaptationChange(value.type, value.period, value.adaptation);
                 },
                 representationChange: function (value) {
                     self.trigger("representationChange", value);
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     contentTimeBoundariesObserver.onRepresentationChange(value.type, value.period);
@@ -449,7 +444,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 periodStreamReady: function (value) { return self.trigger("periodStreamReady", value); },
                 periodStreamCleared: function (value) {
                     contentTimeBoundariesObserver.onPeriodCleared(value.type, value.period);
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     self.trigger("periodStreamCleared", value);
@@ -479,7 +474,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                     for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
                         var protectionData = value_1[_i];
                         protectionRef.setValue(protectionData);
-                        if (cancelSignal.isCancelled) {
+                        if (cancelSignal.isCancelled()) {
                             return; // Previous call has stopped streams due to a side-effect
                         }
                     }
@@ -528,7 +523,8 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
         });
         contentTimeBoundariesObserver.addEventListener("endOfStream", function () {
             if (endOfStreamCanceller === null) {
-                endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+                endOfStreamCanceller = new TaskCanceller();
+                endOfStreamCanceller.linkToSignal(cancelSignal);
                 log.debug("Init: end-of-stream order received.");
                 maintainEndOfStream(mediaSource, endOfStreamCanceller.signal);
             }

package/dist/_esm5.processed/core/init/utils/content_time_boundaries_observer.js

@@ -83,7 +83,7 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
         }, { includeLastObservation: true, clearSignal: cancelSignal });
         manifest.addEventListener("manifestUpdate", function () {
             _this.trigger("durationUpdate", getManifestDuration());
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
                 return;
             }
             _this._checkEndOfStream();
@@ -128,7 +128,7 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
                 }
             }
         }
-        if (this._canceller.isUsed) {
+        if (this._canceller.isUsed()) {
             return;
         }
         if (adaptation === null) {

package/dist/_esm5.processed/core/init/utils/create_media_source.js

@@ -16,8 +16,8 @@
 import { clearElementSrc, events, MediaSource_, } from "../../../compat";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
-import TaskCanceller from "../../../utils/task_canceller";
 /**
  * Dispose of ressources taken by the MediaSource:
  *   - Clear the MediaSource' SourceBuffers
@@ -100,19 +100,10 @@ function createMediaSource(mediaElement, unlinkSignal) {
  * @returns {Promise}
  */
 export default function openMediaSource(mediaElement, unlinkSignal) {
-    return new Promise(function (resolve, reject) {
-        var hasResolved = false;
+    return createCancellablePromise(unlinkSignal, function (resolve) {
         var mediaSource = createMediaSource(mediaElement, unlinkSignal);
-        var eventListenerCanceller = new TaskCanceller({ cancelOn: unlinkSignal });
         events.onSourceOpen(mediaSource, function () {
-            eventListenerCanceller.cancel();
-            hasResolved = true;
             resolve(mediaSource);
-        }, eventListenerCanceller.signal);
-        unlinkSignal.register(function (error) {
-            if (!hasResolved) {
-                reject(error);
-            }
-        });
+        }, unlinkSignal);
     });
 }

package/dist/_esm5.processed/core/init/utils/end_of_stream.js

@@ -55,7 +55,8 @@ export default function triggerEndOfStream(mediaSource, cancelSignal) {
         return;
     }
     log.debug("Init: Waiting SourceBuffers to be updated before calling endOfStream.");
-    var innerCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var innerCanceller = new TaskCanceller();
+    innerCanceller.linkToSignal(cancelSignal);
     for (var _i = 0, updatingSourceBuffers_1 = updatingSourceBuffers; _i < updatingSourceBuffers_1.length; _i++) {
         var sourceBuffer = updatingSourceBuffers_1[_i];
         onSourceBufferUpdate(sourceBuffer, function () {
@@ -75,10 +76,12 @@ export default function triggerEndOfStream(mediaSource, cancelSignal) {
  * @param {Object} cancelSignal
  */
 export function maintainEndOfStream(mediaSource, cancelSignal) {
-    var endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var endOfStreamCanceller = new TaskCanceller();
+    endOfStreamCanceller.linkToSignal(cancelSignal);
     onSourceOpen(mediaSource, function () {
         endOfStreamCanceller.cancel();
-        endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+        endOfStreamCanceller = new TaskCanceller();
+        endOfStreamCanceller.linkToSignal(cancelSignal);
         triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
     }, cancelSignal);
     triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);

package/dist/_esm5.processed/core/init/utils/get_loaded_reference.js

@@ -26,7 +26,8 @@ import TaskCanceller from "../../../utils/task_canceller";
  * @returns {Object}
  */
 export default function getLoadedReference(playbackObserver, mediaElement, isDirectfile, cancelSignal) {
-    var listenCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var listenCanceller = new TaskCanceller();
+    listenCanceller.linkToSignal(cancelSignal);
     var isLoaded = createSharedReference(false, listenCanceller.signal);
     playbackObserver.listen(function (observation) {
         if (observation.rebuffering !== null ||

package/dist/_esm5.processed/core/init/utils/initial_seek_and_play.js

@@ -42,7 +42,7 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
     if (mediaElement.readyState >= READY_STATES.HAVE_METADATA) {
         onLoadedMetadata();
     }
-    cancelSignal.register(function (err) {
+    var deregisterCancellation = cancelSignal.register(function (err) {
         mediaElement.removeEventListener("loadedmetadata", onLoadedMetadata);
         rejectAutoPlay(err);
     });
@@ -60,7 +60,7 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
                 "falsely announced having loaded the content.");
             onWarning(error);
         }
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
             return;
         }
         playbackObserver.listen(function (observation, stopListening) {
@@ -82,6 +82,7 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
             }
             initialPlayPerformed.setValue(true);
             initialPlayPerformed.finish();
+            deregisterCancellation();
             return resolveAutoPlay({ type: "skipped" });
         }
         var playResult;
@@ -89,19 +90,22 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
             playResult = (_a = mediaElement.play()) !== null && _a !== void 0 ? _a : Promise.resolve();
         }
         catch (playError) {
+            deregisterCancellation();
             return rejectAutoPlay(playError);
         }
         playResult
             .then(function () {
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
                 return;
             }
             initialPlayPerformed.setValue(true);
             initialPlayPerformed.finish();
+            deregisterCancellation();
             return resolveAutoPlay({ type: "autoplay" });
         })
             .catch(function (playError) {
-            if (cancelSignal.isCancelled) {
+            deregisterCancellation();
+            if (cancelSignal.isCancelled()) {
                 return;
             }
             if (playError instanceof Error && playError.name === "NotAllowedError") {
@@ -111,7 +115,7 @@ export default function performInitialSeekAndPlay(mediaElement, playbackObserver
                 var error = new MediaError("MEDIA_ERR_BLOCKED_AUTOPLAY", "Cannot trigger auto-play automatically: " +
                     "your browser does not allow it.");
                 onWarning(error);
-                if (cancelSignal.isCancelled) {
+                if (cancelSignal.isCancelled()) {
                     return;
                 }
                 return resolveAutoPlay({ type: "autoplay-blocked" });

package/dist/_esm5.processed/core/init/utils/initialize_content_decryption.js

@@ -62,7 +62,8 @@ export default function initializeContentDecryption(mediaElement, keySystems, pr
         ref.finish(); // We know that no new value will be triggered
         return ref;
     }
-    var decryptorCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var decryptorCanceller = new TaskCanceller();
+    decryptorCanceller.linkToSignal(cancelSignal);
     var drmStatusRef = createSharedReference({
         initializationState: { type: "uninitialized", value: null },
         drmSystemId: undefined,