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

package/dist/_esm5.processed/core/decrypt/session_events_listener.js

@@ -86,12 +86,13 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
     log.info("DRM: Binding session events", session.sessionId);
     var _a = keySystemOptions.getLicenseConfig, getLicenseConfig = _a === void 0 ? {} : _a;
     /** Allows to manually cancel everything the `SessionEventsListener` is doing. */
-    var manualCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var manualCanceller = new TaskCanceller();
+    manualCanceller.linkToSignal(cancelSignal);
     if (!isNullOrUndefined(session.closed)) {
         session.closed
             .then(function () { return manualCanceller.cancel(); })
             .catch(function (err) {
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
                 return;
             }
             manualCanceller.cancel();
@@ -104,8 +105,8 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
     }, manualCanceller.signal);
     onKeyStatusesChange(session, function (keyStatusesEvent) {
         handleKeyStatusesChangeEvent(keyStatusesEvent).catch(function (error) {
-            if (cancelSignal.isCancelled ||
-                (manualCanceller.isUsed && error instanceof CancellationSignal)) {
+            if (cancelSignal.isCancelled() ||
+                (manualCanceller.isUsed() && error instanceof CancellationSignal)) {
                 return;
             }
             manualCanceller.cancel();
@@ -122,7 +123,7 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
         var backoffOptions = getLicenseBackoffOptions(getLicenseConfig.retry);
         retryPromiseWithBackoff(function () { return runGetLicense(message, messageType); }, backoffOptions, manualCanceller.signal)
             .then(function (licenseObject) {
-            if (manualCanceller.isUsed) {
+            if (manualCanceller.isUsed()) {
                 return Promise.resolve();
             }
             if (isNullOrUndefined(licenseObject)) {
@@ -133,7 +134,7 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
             }
         })
             .catch(function (err) {
-            if (manualCanceller.isUsed) {
+            if (manualCanceller.isUsed()) {
                 return;
             }
             manualCanceller.cancel();
@@ -150,6 +151,8 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
             callbacks.onError(formattedError);
         });
     }, manualCanceller.signal);
+    checkAndHandleCurrentKeyStatuses();
+    return;
     /**
      * @param {Event} keyStatusesEvent
      * @returns {Promise}
@@ -162,7 +165,7 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
                     return __generator(this, function (_a) {
                         switch (_a.label) {
                             case 0:
-                                if (manualCanceller.isUsed) {
+                                if (manualCanceller.isUsed()) {
                                     return [2 /*return*/];
                                 }
                                 if (!(typeof keySystemOptions.onKeyStatusesChange === "function")) return [3 /*break*/, 7];
@@ -173,13 +176,13 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
                                 return [4 /*yield*/, keySystemOptions.onKeyStatusesChange(keyStatusesEvent, session)];
                             case 2:
                                 ret = _a.sent();
-                                if (manualCanceller.isUsed) {
+                                if (manualCanceller.isUsed()) {
                                     return [2 /*return*/];
                                 }
                                 return [3 /*break*/, 4];
                             case 3:
                                 error_1 = _a.sent();
-                                if (cancelSignal.isCancelled) {
+                                if (cancelSignal.isCancelled()) {
                                     return [2 /*return*/];
                                 }
                                 err = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "Unknown `onKeyStatusesChange` error");
@@ -201,32 +204,13 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
                     });
                 });
             }
-            /**
-             * Check current MediaKeyStatus for each key in the given MediaKeySession and:
-             *   - throw if at least one status is a non-recoverable error
-             *   - call warning callback for recoverable errors
-             *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
-             */
-            function handleKeyStatusEvent() {
-                if (manualCanceller.isUsed || session.keyStatuses.size === 0) {
-                    return;
-                }
-                var _a = checkKeyStatuses(session, keySystemOptions, keySystem), warning = _a.warning, blacklistedKeyIds = _a.blacklistedKeyIds, whitelistedKeyIds = _a.whitelistedKeyIds;
-                if (warning !== undefined) {
-                    callbacks.onWarning(warning);
-                    if (manualCanceller.isUsed) {
-                        return;
-                    }
-                }
-                callbacks.onKeyUpdate({ whitelistedKeyIds: whitelistedKeyIds, blacklistedKeyIds: blacklistedKeyIds });
-            }
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         log.info("DRM: keystatuseschange event received", session.sessionId);
                         return [4 /*yield*/, Promise.all([
                                 runOnKeyStatusesChangeCallback(),
-                                Promise.resolve(handleKeyStatusEvent()),
+                                Promise.resolve(checkAndHandleCurrentKeyStatuses()),
                             ])];
                     case 1:
                         _a.sent();
@@ -235,36 +219,42 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
             });
         });
     }
+    /**
+     * Check current MediaKeyStatus for each key in the given MediaKeySession and:
+     *   - throw if at least one status is a non-recoverable error
+     *   - call warning callback for recoverable errors
+     *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
+     */
+    function checkAndHandleCurrentKeyStatuses() {
+        if (manualCanceller.isUsed() || session.keyStatuses.size === 0) {
+            return;
+        }
+        var _a = checkKeyStatuses(session, keySystemOptions, keySystem), warning = _a.warning, blacklistedKeyIds = _a.blacklistedKeyIds, whitelistedKeyIds = _a.whitelistedKeyIds;
+        if (warning !== undefined) {
+            callbacks.onWarning(warning);
+            if (manualCanceller.isUsed()) {
+                return;
+            }
+        }
+        callbacks.onKeyUpdate({ whitelistedKeyIds: whitelistedKeyIds, blacklistedKeyIds: blacklistedKeyIds });
+    }
     function runGetLicense(message, messageType) {
+        var timeoutId;
         return new Promise(function (res, rej) {
             log.debug("DRM: Calling `getLicense`", messageType);
             var getLicense = keySystemOptions.getLicense(message, messageType);
             var getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
                 10 * 1000 :
                 getLicenseConfig.timeout;
-            var timeoutId;
             if (getLicenseTimeout >= 0) {
                 timeoutId = setTimeout(function () {
                     rej(new GetLicenseTimeoutError("\"getLicense\" timeout exceeded (".concat(getLicenseTimeout, " ms)")));
                 }, getLicenseTimeout);
             }
-            try {
-                Promise.resolve(getLicense).then(function (val) {
-                    clearTimeoutIfOne();
-                    res(val);
-                }, function (err) {
-                    clearTimeoutIfOne();
-                    rej(err);
-                });
-            }
-            catch (err) {
-                clearTimeoutIfOne();
-                rej(err);
-            }
-            function clearTimeoutIfOne() {
-                if (timeoutId !== undefined) {
-                    clearTimeout(timeoutId);
-                }
+            Promise.resolve(getLicense).then(res, rej);
+        }).finally(function () {
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
             }
         });
     }

package/dist/_esm5.processed/core/decrypt/utils/check_key_statuses.js

@@ -40,6 +40,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 /* eslint-disable-next-line max-len */
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
+import log from "../../../log";
 import assertUnreachable from "../../../utils/assert_unreachable";
 import { bytesToHex } from "../../../utils/string_parsing";
 /**
@@ -95,6 +96,9 @@ export default function checkKeyStatuses(session, options, keySystem) {
         })(), keyStatus = _a[0], keyStatusKeyId = _a[1];
         var keyId = getUUIDKidFromKeyStatusKID(keySystem, new Uint8Array(keyStatusKeyId));
         var keyStatusObj = { keyId: keyId.buffer, keyStatus: keyStatus };
+        if (log.hasLevel("DEBUG")) {
+            log.debug("DRM: key status update (".concat(bytesToHex(keyId), "): ").concat(keyStatus));
+        }
         switch (keyStatus) {
             case KEY_STATUSES.EXPIRED: {
                 var error = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "A decryption key expired (".concat(bytesToHex(keyId), ")"), { keyStatuses: __spreadArray([keyStatusObj], badKeyStatuses, true) });

package/dist/_esm5.processed/core/fetchers/cdn_prioritizer.d.ts

@@ -14,17 +14,20 @@
  * limitations under the License.
  */
 import { ICdnMetadata } from "../../parsers/manifest";
-import { IPlayerError } from "../../public_types";
 import EventEmitter from "../../utils/event_emitter";
 import { CancellationSignal } from "../../utils/task_canceller";
 /**
- * Class signaling the priority between multiple CDN available for any given
- * resource.
+ * Class storing and signaling the priority between multiple CDN available for
+ * any given resource.
  *
- * This class might perform requests and schedule timeouts by itself to keep its
- * internal list of CDN priority up-to-date.
- * When it is not needed anymore, you should call the `dispose` method to clear
- * all resources.
+ * This class was first created to implement the complexities behind
+ * Content Steering features, though its handling hasn't been added yet as we
+ * wait for its specification to be both standardized and relied on in the wild.
+ * In the meantime, it acts as an abstraction for the simple concept of
+ * avoiding to request a CDN for any segment when an issue is encountered with
+ * one (e.g. HTTP 500 statuses) and several CDN exist for a given resource. It
+ * should be noted that this is also one of the planified features of the
+ * Content Steering specification.
  *
  * @class CdnPrioritizer
  */
@@ -92,7 +95,13 @@ export default class CdnPrioritizer extends EventEmitter<ICdnPrioritizerEvents>
      */
     private _removeIndexFromDowngradeList;
 }
+/** Events sent by a `CdnPrioritizer` */
 export interface ICdnPrioritizerEvents {
-    warnings: IPlayerError[];
+    /**
+     * The priority of one or several CDN changed.
+     *
+     * You might want to re-check if a CDN should still be used when this event
+     * is triggered.
+     */
     priorityChange: null;
 }

package/dist/_esm5.processed/core/fetchers/cdn_prioritizer.js

@@ -32,13 +32,17 @@ import config from "../../config";
 import arrayFindIndex from "../../utils/array_find_index";
 import EventEmitter from "../../utils/event_emitter";
 /**
- * Class signaling the priority between multiple CDN available for any given
- * resource.
+ * Class storing and signaling the priority between multiple CDN available for
+ * any given resource.
  *
- * This class might perform requests and schedule timeouts by itself to keep its
- * internal list of CDN priority up-to-date.
- * When it is not needed anymore, you should call the `dispose` method to clear
- * all resources.
+ * This class was first created to implement the complexities behind
+ * Content Steering features, though its handling hasn't been added yet as we
+ * wait for its specification to be both standardized and relied on in the wild.
+ * In the meantime, it acts as an abstraction for the simple concept of
+ * avoiding to request a CDN for any segment when an issue is encountered with
+ * one (e.g. HTTP 500 statuses) and several CDN exist for a given resource. It
+ * should be noted that this is also one of the planified features of the
+ * Content Steering specification.
  *
  * @class CdnPrioritizer
  */

package/dist/_esm5.processed/core/fetchers/manifest/manifest_fetcher.js

@@ -145,7 +145,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
         manifestProm
             .then(function (val) {
             _this.trigger("manifestReady", val.manifest);
-            if (!_this._canceller.isUsed) {
+            if (!_this._canceller.isUsed()) {
                 _this._recursivelyRefreshManifest(val.manifest, val);
             }
         })
@@ -311,7 +311,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
             function onWarnings(warnings) {
                 for (var _i = 0, warnings_1 = warnings; _i < warnings_1.length; _i++) {
                     var warning = warnings_1[_i];
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return;
                     }
                     var formattedError = formatError(warning, {
@@ -430,7 +430,8 @@ var ManifestFetcher = /** @class */ (function (_super) {
          * be effectively considered.
          * `nextRefreshCanceller` will allow to cancel every other when one is triggered.
          */
-        var nextRefreshCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+        var nextRefreshCanceller = new TaskCanceller();
+        nextRefreshCanceller.linkToSignal(this._canceller.signal);
         /* Function to manually schedule a Manifest refresh */
         this.scheduleManualRefresh = function (settings) {
             var enablePartialRefresh = settings.enablePartialRefresh, delay = settings.delay, canUseUnsafeMode = settings.canUseUnsafeMode;
@@ -603,7 +604,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
         });
     };
     ManifestFetcher.prototype._onFatalError = function (err) {
-        if (this._canceller.isUsed) {
+        if (this._canceller.isUsed()) {
             return;
         }
         this.trigger("error", err);

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.d.ts

@@ -26,10 +26,22 @@ import CdnPrioritizer from "../cdn_prioritizer";
  * 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<TLoadedFormat, TSegmentDataType>(bufferType: IBufferType, pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>, cdnPrioritizer: CdnPrioritizer | null, lifecycleCallbacks: ISegmentFetcherLifecycleCallbacks, options: ISegmentFetcherOptions): ISegmentFetcher<TSegmentDataType>;
@@ -59,10 +71,15 @@ export interface ISegmentFetcherCallbacks<TSegmentDataType> {
     /**
      * Callback called when all decodable chunks of the loaded segment have been
      * communicated through the `onChunk` callback.
+     *
+     * This callback is called before the corresponding `ISegmentFetcher`'s
+     * returned Promise is resolved.
      */
     onAllChunksReceived(): void;
     /**
-     * Callback called when the segment request has to restart from scratch. */
+     * Callback called when the segment request has to restart from scratch, e.g.
+     * due to a request error.
+     */
     onRetry(error: IPlayerError): void;
 }
 /** Content used by the segment loader as a context to load a new segment. */

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,12 +323,13 @@ 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) {
@@ -342,7 +343,7 @@ export function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, op
                 }, canceller.signal);
                 cancellableSleep(blockedFor, canceller.signal)
                     .then(function () { return requestCdn(nextWantedCdn).then(res, rej); }, noop);
-            });
+            }).finally(unlinkCanceller);
         }
         /**
          * Takes in input the list of CDN that can be used to request the resource, in

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);
             }
         });