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

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

@@ -40,7 +40,8 @@ var MediaDurationUpdater = /** @class */ (function () {
         this._currentKnownDuration = currentKnownDuration;
         var isMediaSourceOpened = createMediaSourceOpenReference(mediaSource, this._canceller.signal);
         /** TaskCanceller triggered each time the MediaSource open status changes. */
-        var msUpdateCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+        var msUpdateCanceller = new TaskCanceller();
+        msUpdateCanceller.linkToSignal(this._canceller.signal);
         isMediaSourceOpened.onUpdate(onMediaSourceOpenedStatusChanged, { emitCurrentValue: true,
             clearSignal: this._canceller.signal });
         function onMediaSourceOpenedStatusChanged() {
@@ -48,16 +49,15 @@ var MediaDurationUpdater = /** @class */ (function () {
             if (!isMediaSourceOpened.getValue()) {
                 return;
             }
-            msUpdateCanceller = new TaskCanceller({ cancelOn: canceller.signal });
-            /** TaskCanceller triggered each time the content's duration may have change */
-            var durationChangeCanceller = new TaskCanceller({
-                cancelOn: msUpdateCanceller.signal,
-            });
+            msUpdateCanceller = new TaskCanceller();
+            msUpdateCanceller.linkToSignal(canceller.signal);
+            /** TaskCanceller triggered each time the content's duration may have changed */
+            var durationChangeCanceller = new TaskCanceller();
+            durationChangeCanceller.linkToSignal(msUpdateCanceller.signal);
             var reSetDuration = function () {
                 durationChangeCanceller.cancel();
-                durationChangeCanceller = new TaskCanceller({
-                    cancelOn: msUpdateCanceller.signal,
-                });
+                durationChangeCanceller = new TaskCanceller();
+                durationChangeCanceller.linkToSignal(msUpdateCanceller.signal);
                 onDurationMayHaveChanged(durationChangeCanceller.signal);
             };
             currentKnownDuration.onUpdate(reSetDuration, { emitCurrentValue: false,
@@ -68,10 +68,12 @@ var MediaDurationUpdater = /** @class */ (function () {
         function onDurationMayHaveChanged(cancelSignal) {
             var areSourceBuffersUpdating = createSourceBuffersUpdatingReference(mediaSource.sourceBuffers, cancelSignal);
             /** TaskCanceller triggered each time SourceBuffers' updating status changes */
-            var sourceBuffersUpdatingCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+            var sourceBuffersUpdatingCanceller = new TaskCanceller();
+            sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
             return areSourceBuffersUpdating.onUpdate(function (areUpdating) {
                 sourceBuffersUpdatingCanceller.cancel();
-                sourceBuffersUpdatingCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+                sourceBuffersUpdatingCanceller = new TaskCanceller();
+                sourceBuffersUpdatingCanceller.linkToSignal(cancelSignal);
                 if (areUpdating) {
                     return;
                 }
@@ -119,19 +121,21 @@ function setMediaSourceDuration(mediaSource, manifest, knownDuration) {
     var newDuration = knownDuration;
     if (newDuration === undefined) {
         if (manifest.isDynamic) {
-            var maxPotentialPos = (_a = manifest.getLivePosition()) !== null && _a !== void 0 ? _a : manifest.getMaximumSafePosition();
-            // Some targets poorly support setting a very high number for durations.
-            // Yet, in dynamic contents, we would prefer setting a value as high as possible
-            // to still be able to seek anywhere we want to (even ahead of the Manifest if
-            // we want to). As such, we put it at a safe default value of 2^32 excepted
-            // when the maximum position is already relatively close to that value, where
-            // we authorize exceptionally going over it.
-            newDuration = Math.max(Math.pow(2, 32), maxPotentialPos + YEAR_IN_SECONDS);
+            newDuration = (_a = manifest.getLivePosition()) !== null && _a !== void 0 ? _a : manifest.getMaximumSafePosition();
         }
         else {
             newDuration = manifest.getMaximumSafePosition();
         }
     }
+    if (manifest.isDynamic) {
+        // Some targets poorly support setting a very high number for durations.
+        // Yet, in dynamic contents, we would prefer setting a value as high as possible
+        // to still be able to seek anywhere we want to (even ahead of the Manifest if
+        // we want to). As such, we put it at a safe default value of 2^32 excepted
+        // when the maximum position is already relatively close to that value, where
+        // we authorize exceptionally going over it.
+        newDuration = Math.max(Math.pow(2, 32), newDuration + YEAR_IN_SECONDS);
+    }
     var maxBufferedEnd = 0;
     for (var i = 0; i < mediaSource.sourceBuffers.length; i++) {
         var sourceBuffer = mediaSource.sourceBuffers[i];

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

@@ -100,7 +100,7 @@ var RebufferingController = /** @class */ (function (_super) {
         this._canceller.signal.register(function () {
             playbackRateUpdater.dispose();
         });
-        var prevFreezingState;
+        var prevFreezingState = null;
         this._playbackObserver.listen(function (observation) {
             var _a;
             var discontinuitiesStore = _this._discontinuitiesStore;

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

@@ -35,13 +35,15 @@ export default function streamEventsEmitter(manifest, mediaElement, playbackObse
         scheduledEventsRef.setValue(refreshScheduledEventsList(prev, manifest));
     }, cancelSignal);
     var isPollingEvents = false;
-    var cancelCurrentPolling = new TaskCanceller({ cancelOn: cancelSignal });
+    var cancelCurrentPolling = new TaskCanceller();
+    cancelCurrentPolling.linkToSignal(cancelSignal);
     scheduledEventsRef.onUpdate(function (_a) {
         var scheduledEventsLength = _a.length;
         if (scheduledEventsLength === 0) {
             if (isPollingEvents) {
                 cancelCurrentPolling.cancel();
-                cancelCurrentPolling = new TaskCanceller({ cancelOn: cancelSignal });
+                cancelCurrentPolling = new TaskCanceller();
+                cancelCurrentPolling.linkToSignal(cancelSignal);
                 isPollingEvents = false;
             }
             return;
@@ -127,7 +129,7 @@ export default function streamEventsEmitter(manifest, mediaElement, playbackObse
                 else {
                     onEventSkip(event_2.value);
                 }
-                if (stopSignal.isCancelled) {
+                if (stopSignal.isCancelled()) {
                     return;
                 }
             }
@@ -138,7 +140,7 @@ export default function streamEventsEmitter(manifest, mediaElement, playbackObse
                 if (typeof event_3.onExit === "function") {
                     event_3.onExit();
                 }
-                if (stopSignal.isCancelled) {
+                if (stopSignal.isCancelled()) {
                     return;
                 }
             }

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

@@ -21,7 +21,7 @@ import isNullOrUndefined from "../../../utils/is_null_or_undefined";
  * @param {Object} cancelSignal
  */
 export default function listenToMediaError(mediaElement, onError, cancelSignal) {
-    if (cancelSignal.isCancelled) {
+    if (cancelSignal.isCancelled()) {
         return;
     }
     mediaElement.addEventListener("error", onMediaError);

package/dist/_esm5.processed/core/segment_buffers/implementations/audio_video/audio_video_segment_buffer.js

@@ -35,6 +35,7 @@ import { getLoggableSegmentId } from "../../../../manifest";
 import areArraysOfNumbersEqual from "../../../../utils/are_arrays_of_numbers_equal";
 import assertUnreachable from "../../../../utils/assert_unreachable";
 import { toUint8Array } from "../../../../utils/byte_parsing";
+import createCancellablePromise from "../../../../utils/create_cancellable_promise";
 import hashBuffer from "../../../../utils/hash_buffer";
 import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
@@ -227,15 +228,15 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
      */
     AudioVideoSegmentBuffer.prototype._addToQueue = function (operation, cancellationSignal) {
         var _this = this;
-        return new Promise(function (resolve, reject) {
-            if (cancellationSignal.cancellationError !== null) {
-                return reject(cancellationSignal.cancellationError);
-            }
+        return createCancellablePromise(cancellationSignal, function (resolve, reject) {
             var shouldRestartQueue = _this._queue.length === 0 &&
                 _this._pendingTask === null;
             var queueItem = objectAssign({ resolve: resolve, reject: reject }, operation);
             _this._queue.push(queueItem);
-            cancellationSignal.register(function (error) {
+            if (shouldRestartQueue) {
+                _this._flush();
+            }
+            return function () {
                 // Remove the corresponding element from the AudioVideoSegmentBuffer's
                 // queue.
                 // If the operation was a pending task, it should still continue to not
@@ -246,11 +247,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
                 }
                 queueItem.resolve = noop;
                 queueItem.reject = noop;
-                reject(error);
-            });
-            if (shouldRestartQueue) {
-                _this._flush();
-            }
+            };
         });
     };
     /**

package/dist/_esm5.processed/core/segment_buffers/implementations/text/html/html_text_segment_buffer.js

@@ -272,7 +272,8 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         var proportionalCues = this._currentCues
             .filter(function (cue) { return cue.resolution !== null; });
         if (proportionalCues.length > 0) {
-            this._sizeUpdateCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+            this._sizeUpdateCanceller = new TaskCanceller();
+            this._sizeUpdateCanceller.linkToSignal(this._canceller.signal);
             var TEXT_TRACK_SIZE_CHECKS_INTERVAL = config.getCurrent().TEXT_TRACK_SIZE_CHECKS_INTERVAL;
             // update propertionally-sized elements periodically
             var heightWidthRef = onHeightWidthChange(this._textTrackElement, TEXT_TRACK_SIZE_CHECKS_INTERVAL, this._sizeUpdateCanceller.signal);
@@ -297,7 +298,8 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
         var startAutoRefresh = function () {
             stopAutoRefresh();
-            autoRefreshCanceller = new TaskCanceller({ cancelOn: cancellationSignal });
+            autoRefreshCanceller = new TaskCanceller();
+            autoRefreshCanceller.linkToSignal(cancellationSignal);
             var intervalId = setInterval(function () { return _this.refreshSubtitles(); }, MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL);
             autoRefreshCanceller.signal.register(function () {
                 clearInterval(intervalId);

package/dist/_esm5.processed/core/segment_buffers/segment_buffers_store.js

@@ -16,6 +16,7 @@
 import { MediaError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
+import createCancellablePromise from "../../utils/create_cancellable_promise";
 import { AudioVideoSegmentBuffer, } from "./implementations";
 var POSSIBLE_BUFFER_TYPES = ["audio",
     "video",
@@ -141,20 +142,23 @@ var SegmentBuffersStore = /** @class */ (function () {
         if (this._areNativeBuffersUsable()) {
             return Promise.resolve();
         }
-        return new Promise(function (res, rej) {
-            var onAddedOrDisabled = function () {
+        return createCancellablePromise(cancelWaitSignal, function (res) {
+            /* eslint-disable-next-line prefer-const */
+            var onAddedOrDisabled;
+            var removeCallback = function () {
+                var indexOf = _this._onNativeBufferAddedOrDisabled.indexOf(onAddedOrDisabled);
+                if (indexOf >= 0) {
+                    _this._onNativeBufferAddedOrDisabled.splice(indexOf, 1);
+                }
+            };
+            onAddedOrDisabled = function () {
                 if (_this._areNativeBuffersUsable()) {
+                    removeCallback();
                     res();
                 }
             };
             _this._onNativeBufferAddedOrDisabled.push(onAddedOrDisabled);
-            cancelWaitSignal.register(function (error) {
-                var indexOf = _this._onNativeBufferAddedOrDisabled.indexOf(onAddedOrDisabled);
-                if (indexOf >= 0) {
-                    _this._onNativeBufferAddedOrDisabled.splice(indexOf, 1);
-                }
-                rej(error);
-            });
+            return removeCallback;
         });
     };
     /**

package/dist/_esm5.processed/core/stream/adaptation/adaptation_stream.js

@@ -17,6 +17,8 @@ import nextTick from "next-tick";
 import config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
+import cancellableSleep from "../../../utils/cancellable_sleep";
+import noop from "../../../utils/noop";
 import objectAssign from "../../../utils/object_assign";
 import { createMappedReference, createSharedReference, } from "../../../utils/reference";
 import TaskCanceller from "../../../utils/task_canceller";
@@ -57,7 +59,8 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
     var directManualBitrateSwitching = options.manualBitrateSwitchingMode === "direct";
     var manifest = content.manifest, period = content.period, adaptation = content.adaptation;
     /** Allows to cancel everything the `AdaptationStream` is doing. */
-    var adapStreamCanceller = new TaskCanceller({ cancelOn: parentCancelSignal });
+    var adapStreamCanceller = new TaskCanceller();
+    adapStreamCanceller.linkToSignal(parentCancelSignal);
     /**
      * The buffer goal ratio base itself on the value given by `wantedBufferAhead`
      * to determine a more dynamic buffer goal for a given Representation.
@@ -117,9 +120,8 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
          * terminating and as such the next one might be immediately created
          * recursively.
          */
-        var repStreamTerminatingCanceller = new TaskCanceller({
-            cancelOn: adapStreamCanceller.signal,
-        });
+        var repStreamTerminatingCanceller = new TaskCanceller();
+        repStreamTerminatingCanceller.linkToSignal(adapStreamCanceller.signal);
         var _a = estimateRef.getValue(), representation = _a.representation, manual = _a.manual;
         if (representation === null) {
             return;
@@ -188,11 +190,11 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
         }
         var repInfo = { type: adaptation.type, period: period, representation: representation };
         currentRepresentation.setValue(representation);
-        if (adapStreamCanceller.isUsed) {
+        if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
         }
         callbacks.representationChange(repInfo);
-        if (adapStreamCanceller.isUsed) {
+        if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
         }
         var representationStreamCallbacks = {
@@ -208,13 +210,13 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
             },
             addedSegment: function (segmentInfo) {
                 abrCallbacks.addedSegment(segmentInfo);
-                if (adapStreamCanceller.isUsed) {
+                if (adapStreamCanceller.isUsed()) {
                     return;
                 }
                 callbacks.addedSegment(segmentInfo);
             },
             terminating: function () {
-                if (repStreamTerminatingCanceller.isUsed) {
+                if (repStreamTerminatingCanceller.isUsed()) {
                     return; // Already handled
                 }
                 repStreamTerminatingCanceller.cancel();
@@ -236,9 +238,8 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
          * `TaskCanceller` triggered when the `RepresentationStream` calls its
          * `terminating` callback.
          */
-        var terminatingRepStreamCanceller = new TaskCanceller({
-            cancelOn: adapStreamCanceller.signal,
-        });
+        var terminatingRepStreamCanceller = new TaskCanceller();
+        terminatingRepStreamCanceller.linkToSignal(adapStreamCanceller.signal);
         var bufferGoal = createMappedReference(wantedBufferAhead, function (prev) {
             return prev * getBufferGoalRatio(representation);
         }, terminatingRepStreamCanceller.signal);
@@ -253,16 +254,24 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
                     defaultCode: "NONE",
                     defaultReason: "Unknown `RepresentationStream` error",
                 });
-                if (formattedError.code === "BUFFER_FULL_ERROR") {
+                if (formattedError.code !== "BUFFER_FULL_ERROR") {
+                    representationStreamCallbacks.error(err);
+                }
+                else {
                     var wba = wantedBufferAhead.getValue();
                     var lastBufferGoalRatio = (_a = bufferGoalRatioMap.get(representation.id)) !== null && _a !== void 0 ? _a : 1;
-                    if (lastBufferGoalRatio <= 0.25 || wba * lastBufferGoalRatio <= 2) {
+                    // 70%, 49%, 34.3%, 24%, 16.81%, 11.76%, 8.24% and 5.76%
+                    var newBufferGoalRatio = lastBufferGoalRatio * 0.7;
+                    if (newBufferGoalRatio <= 0.05 || wba * newBufferGoalRatio <= 2) {
                         throw formattedError;
                     }
-                    bufferGoalRatioMap.set(representation.id, lastBufferGoalRatio - 0.25);
-                    return createRepresentationStream(representation, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks);
+                    bufferGoalRatioMap.set(representation.id, newBufferGoalRatio);
+                    // We wait 4 seconds to let the situation evolve by itself before
+                    // retrying loading segments with a lower buffer goal
+                    cancellableSleep(4000, adapStreamCanceller.signal).then(function () {
+                        return createRepresentationStream(representation, terminateCurrentStream, fastSwitchThreshold, representationStreamCallbacks);
+                    }).catch(noop);
                 }
-                representationStreamCallbacks.error(err);
             },
             terminating: function () {
                 terminatingRepStreamCanceller.cancel();

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.js

@@ -146,9 +146,10 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         };
     });
     // Create automatically the right `PeriodStream` for every possible types
-    segmentBuffersStore.getBufferTypes().map(function (bufferType) {
+    for (var _i = 0, _b = segmentBuffersStore.getBufferTypes(); _i < _b.length; _i++) {
+        var bufferType = _b[_i];
         manageEveryStreams(bufferType, initialPeriod);
-    });
+    }
     /**
      * Manage creation and removal of Streams for every Periods for a given type.
      *
@@ -170,7 +171,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          */
         var enableOutOfBoundsCheck = false;
         /** Cancels currently created `PeriodStream`s. */
-        var currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+        var currentCanceller = new TaskCanceller();
+        currentCanceller.linkToSignal(orchestratorCancelSignal);
         // Restart the current Stream when the wanted time is in another period
         // than the ones already considered
         playbackObserver.listen(function (_a) {
@@ -188,7 +190,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 callbacks.periodStreamCleared({ type: bufferType, period: period });
             }
             currentCanceller.cancel();
-            currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+            currentCanceller = new TaskCanceller();
+            currentCanceller.linkToSignal(orchestratorCancelSignal);
             var nextPeriod = (_c = manifest.getPeriodForTime(time)) !== null && _c !== void 0 ? _c : manifest.getNextPeriod(time);
             if (nextPeriod === undefined) {
                 log.warn("Stream: The wanted position is not found in the Manifest.");
@@ -264,8 +267,15 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                             segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
                             ofCurrentType = updates
                                 .filter(function (update) { return update.adaptation.type === bufferType; });
-                            if (ofCurrentType.length === 0 || segmentBufferStatus.type !== "initialized") {
-                                return [2 /*return*/]; // no need to stop the current Streams.
+                            if (
+                            // No update concerns the current type of data
+                            ofCurrentType.length === 0 ||
+                                segmentBufferStatus.type !== "initialized" ||
+                                // The update only notifies of now-decipherable streams
+                                ofCurrentType.every(function (x) { return x.representation.decipherable === true; })) {
+                                // Data won't have to be removed from the buffers, no need to stop the
+                                // current Streams.
+                                return [2 /*return*/];
                             }
                             segmentBuffer = segmentBufferStatus.value;
                             resettedContent = ofCurrentType.filter(function (update) {
@@ -286,7 +296,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                                 callbacks.periodStreamCleared({ type: bufferType, period: period });
                             }
                             currentCanceller.cancel();
-                            currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+                            currentCanceller = new TaskCanceller();
+                            currentCanceller.linkToSignal(orchestratorCancelSignal);
                             _i = 0, _a = __spreadArray(__spreadArray([], undecipherableRanges, true), rangesToRemove, true);
                             _c.label = 1;
                         case 1:
@@ -306,7 +317,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                             // was going to be emitted synchronously.
                             nextTick(function () {
                                 var _a, _b;
-                                if (orchestratorCancelSignal.isCancelled) {
+                                if (orchestratorCancelSignal.isCancelled()) {
                                     return;
                                 }
                                 var observation = playbackObserver.getReference().getValue();
@@ -315,13 +326,13 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                                     callbacks.needsDecipherabilityFlush({ position: observation.position.last,
                                         autoPlay: shouldAutoPlay,
                                         duration: observation.duration });
-                                    if (orchestratorCancelSignal.isCancelled) {
+                                    if (orchestratorCancelSignal.isCancelled()) {
                                         return;
                                     }
                                 }
                                 else if (needsFlushingAfterClean(observation, rangesToRemove)) {
                                     callbacks.needsBufferFlush();
-                                    if (orchestratorCancelSignal.isCancelled) {
+                                    if (orchestratorCancelSignal.isCancelled()) {
                                         return;
                                     }
                                 }
@@ -378,7 +389,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          */
         var nextStreamInfo = null;
         /** Emits when the `PeriodStream` linked to `basePeriod` should be destroyed. */
-        var currentStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+        var currentStreamCanceller = new TaskCanceller();
+        currentStreamCanceller.linkToSignal(cancelSignal);
         // Stop current PeriodStream when the current position goes over the end of
         // that Period.
         playbackObserver.listen(function (_a, stopListeningObservations) {
@@ -431,7 +443,9 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                     period: nextStreamInfo.period });
                 nextStreamInfo.canceller.cancel();
             }
-            nextStreamInfo = { canceller: new TaskCanceller({ cancelOn: cancelSignal }),
+            var nextStreamCanceller = new TaskCanceller();
+            nextStreamCanceller.linkToSignal(cancelSignal);
+            nextStreamInfo = { canceller: nextStreamCanceller,
                 period: nextPeriod };
             manageConsecutivePeriodStreams(bufferType, nextPeriod, consecutivePeriodStreamCb, nextStreamInfo.canceller.signal);
         }

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

@@ -113,7 +113,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
      */
     var adaptationRef = createSharedReference(undefined, parentCancelSignal);
     callbacks.periodStreamReady({ type: bufferType, period: period, adaptationRef: adaptationRef });
-    if (parentCancelSignal.isCancelled) {
+    if (parentCancelSignal.isCancelled()) {
         return;
     }
     var currentStreamCanceller;
@@ -129,7 +129,8 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         if (adaptation === undefined) {
                             return [2 /*return*/];
                         }
-                        streamCanceller = new TaskCanceller({ cancelOn: parentCancelSignal });
+                        streamCanceller = new TaskCanceller();
+                        streamCanceller.linkToSignal(parentCancelSignal);
                         currentStreamCanceller === null || currentStreamCanceller === void 0 ? void 0 : currentStreamCanceller.cancel(); // Cancel oreviously created stream if one
                         currentStreamCanceller = streamCanceller;
                         if (!(adaptation === null)) return [3 /*break*/, 7];
@@ -147,7 +148,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                     case 2: return [4 /*yield*/, segmentBufferStatus.value.removeBuffer(period.start, periodEnd, streamCanceller.signal)];
                     case 3:
                         _d.sent();
-                        if (streamCanceller.isUsed) {
+                        if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // The stream has been cancelled
                         }
                         _d.label = 4;
@@ -155,14 +156,14 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                     case 5:
                         if (segmentBufferStatus.type === "uninitialized") {
                             segmentBuffersStore.disableSegmentBuffer(bufferType);
-                            if (streamCanceller.isUsed) {
+                            if (streamCanceller.isUsed()) {
                                 return [2 /*return*/]; // The stream has been cancelled
                             }
                         }
                         _d.label = 6;
                     case 6:
                         callbacks.adaptationChange({ type: bufferType, adaptation: null, period: period });
-                        if (streamCanceller.isUsed) {
+                        if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // Previous call has provoken Stream cancellation by side-effect
                         }
                         return [2 /*return*/, createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period: period }, callbacks, streamCanceller.signal)];
@@ -179,7 +180,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         }
                         log.info("Stream: Updating ".concat(bufferType, " adaptation"), "A: ".concat(adaptation.id), "P: ".concat(period.start));
                         callbacks.adaptationChange({ type: bufferType, adaptation: adaptation, period: period });
-                        if (streamCanceller.isUsed) {
+                        if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // Previous call has provoken cancellation by side-effect
                         }
                         readyState = playbackObserver.getReadyState();
@@ -192,7 +193,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         return [4 /*yield*/, segmentBuffersStore.waitForUsableBuffers(streamCanceller.signal)];
                     case 8:
                         _d.sent();
-                        if (streamCanceller.isUsed) {
+                        if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // The Stream has since been cancelled
                         }
                         if (!(strategy.type === "flush-buffer" || strategy.type === "clean-buffer")) return [3 /*break*/, 13];
@@ -204,7 +205,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         return [4 /*yield*/, segmentBuffer.removeBuffer(start, end, streamCanceller.signal)];
                     case 10:
                         _d.sent();
-                        if (streamCanceller.isUsed) {
+                        if (streamCanceller.isUsed()) {
                             return [2 /*return*/]; // The Stream has since been cancelled
                         }
                         _d.label = 11;
@@ -214,7 +215,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                     case 12:
                         if (strategy.type === "flush-buffer") {
                             callbacks.needsBufferFlush();
-                            if (streamCanceller.isUsed) {
+                            if (streamCanceller.isUsed()) {
                                 return [2 /*return*/]; // Previous callback cancelled the Stream by side-effect
                             }
                         }
@@ -254,7 +255,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                     defaultReason: "Unknown `AdaptationStream` error",
                 });
                 callbacks.warning(formattedError);
-                if (cancelSignal.isCancelled) {
+                if (cancelSignal.isCancelled()) {
                     return; // Previous callback cancelled the Stream by side-effect
                 }
                 return createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period: period }, callbacks, cancelSignal);