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

package/src/core/stream/adaptation/adaptation_stream.ts

@@ -84,7 +84,8 @@ export default function AdaptationStream<T>(
   const { manifest, period, adaptation } = content;
 
   /** Allows to cancel everything the `AdaptationStream` is doing. */
-  const adapStreamCanceller = new TaskCanceller({ cancelOn: parentCancelSignal });
+  const adapStreamCanceller = new TaskCanceller();
+  adapStreamCanceller.linkToSignal(parentCancelSignal);
 
   /**
    * The buffer goal ratio base itself on the value given by `wantedBufferAhead`
@@ -162,9 +163,8 @@ export default function AdaptationStream<T>(
      * terminating and as such the next one might be immediately created
      * recursively.
      */
-    const repStreamTerminatingCanceller = new TaskCanceller({
-      cancelOn: adapStreamCanceller.signal,
-    });
+    const repStreamTerminatingCanceller = new TaskCanceller();
+    repStreamTerminatingCanceller.linkToSignal(adapStreamCanceller.signal);
     const { representation, manual } = estimateRef.getValue();
     if (representation === null) {
       return;
@@ -247,11 +247,11 @@ export default function AdaptationStream<T>(
 
     const repInfo = { type: adaptation.type, period, 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
     }
 
@@ -268,13 +268,13 @@ export default function AdaptationStream<T>(
       },
       addedSegment(segmentInfo) {
         abrCallbacks.addedSegment(segmentInfo);
-        if (adapStreamCanceller.isUsed) {
+        if (adapStreamCanceller.isUsed()) {
           return;
         }
         callbacks.addedSegment(segmentInfo);
       },
       terminating() {
-        if (repStreamTerminatingCanceller.isUsed) {
+        if (repStreamTerminatingCanceller.isUsed()) {
           return; // Already handled
         }
         repStreamTerminatingCanceller.cancel();
@@ -306,9 +306,8 @@ export default function AdaptationStream<T>(
      * `TaskCanceller` triggered when the `RepresentationStream` calls its
      * `terminating` callback.
      */
-    const terminatingRepStreamCanceller = new TaskCanceller({
-      cancelOn: adapStreamCanceller.signal,
-    });
+    const terminatingRepStreamCanceller = new TaskCanceller();
+    terminatingRepStreamCanceller.linkToSignal(adapStreamCanceller.signal);
     const bufferGoal = createMappedReference(wantedBufferAhead, prev => {
       return prev * getBufferGoalRatio(representation);
     }, terminatingRepStreamCanceller.signal);

package/src/core/stream/orchestrator/stream_orchestrator.ts

@@ -140,9 +140,9 @@ export default function StreamOrchestrator(
     });
 
   // Create automatically the right `PeriodStream` for every possible types
-  segmentBuffersStore.getBufferTypes().map((bufferType) => {
+  for (const bufferType of segmentBuffersStore.getBufferTypes()) {
     manageEveryStreams(bufferType, initialPeriod);
-  });
+  }
 
   /**
    * Manage creation and removal of Streams for every Periods for a given type.
@@ -167,7 +167,8 @@ export default function StreamOrchestrator(
     let enableOutOfBoundsCheck = false;
 
     /** Cancels currently created `PeriodStream`s. */
-    let currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+    let currentCanceller = new TaskCanceller();
+    currentCanceller.linkToSignal(orchestratorCancelSignal);
 
     // Restart the current Stream when the wanted time is in another period
     // than the ones already considered
@@ -186,7 +187,8 @@ export default function StreamOrchestrator(
         callbacks.periodStreamCleared({ type: bufferType, period });
       }
       currentCanceller.cancel();
-      currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+      currentCanceller = new TaskCanceller();
+      currentCanceller.linkToSignal(orchestratorCancelSignal);
 
       const nextPeriod = manifest.getPeriodForTime(time) ??
                          manifest.getNextPeriod(time);
@@ -275,8 +277,16 @@ export default function StreamOrchestrator(
       const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
       const ofCurrentType = updates
         .filter(update => update.adaptation.type === bufferType);
-      if (ofCurrentType.length === 0 || segmentBufferStatus.type !== "initialized") {
-        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(x => x.representation.decipherable === true)
+      ) {
+        // Data won't have to be removed from the buffers, no need to stop the
+        // current Streams.
+        return ;
       }
 
       const segmentBuffer = segmentBufferStatus.value;
@@ -316,7 +326,8 @@ export default function StreamOrchestrator(
       }
 
       currentCanceller.cancel();
-      currentCanceller = new TaskCanceller({ cancelOn: orchestratorCancelSignal });
+      currentCanceller = new TaskCanceller();
+      currentCanceller.linkToSignal(orchestratorCancelSignal);
 
       /** Remove from the `SegmentBuffer` all the concerned time ranges. */
       for (const { start, end } of [...undecipherableRanges, ...rangesToRemove]) {
@@ -329,7 +340,7 @@ export default function StreamOrchestrator(
       // to reduce the risk of race conditions where the next observation
       // was going to be emitted synchronously.
       nextTick(() => {
-        if (orchestratorCancelSignal.isCancelled) {
+        if (orchestratorCancelSignal.isCancelled()) {
           return ;
         }
         const observation = playbackObserver.getReference().getValue();
@@ -339,12 +350,12 @@ export default function StreamOrchestrator(
           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 ;
           }
         }
@@ -417,7 +428,8 @@ export default function StreamOrchestrator(
     } | null = null;
 
     /** Emits when the `PeriodStream` linked to `basePeriod` should be destroyed. */
-    const currentStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    const currentStreamCanceller = new TaskCanceller();
+    currentStreamCanceller.linkToSignal(cancelSignal);
 
     // Stop current PeriodStream when the current position goes over the end of
     // that Period.
@@ -490,7 +502,9 @@ export default function StreamOrchestrator(
                                                         period: nextStreamInfo.period });
         nextStreamInfo.canceller.cancel();
       }
-      nextStreamInfo = { canceller: new TaskCanceller({ cancelOn: cancelSignal }),
+      const nextStreamCanceller = new TaskCanceller();
+      nextStreamCanceller.linkToSignal(cancelSignal);
+      nextStreamInfo = { canceller: nextStreamCanceller,
                          period: nextPeriod };
       manageConsecutivePeriodStreams(bufferType,
                                      nextPeriod,

package/src/core/stream/period/period_stream.ts

@@ -109,7 +109,7 @@ export default function PeriodStream(
   );
 
   callbacks.periodStreamReady({ type: bufferType, period, adaptationRef });
-  if (parentCancelSignal.isCancelled) {
+  if (parentCancelSignal.isCancelled()) {
     return;
   }
 
@@ -122,7 +122,8 @@ export default function PeriodStream(
       if (adaptation === undefined) {
         return;
       }
-      const streamCanceller = new TaskCanceller({ cancelOn: parentCancelSignal });
+      const streamCanceller = new TaskCanceller();
+      streamCanceller.linkToSignal(parentCancelSignal);
       currentStreamCanceller?.cancel(); // Cancel oreviously created stream if one
       currentStreamCanceller = streamCanceller;
 
@@ -142,20 +143,20 @@ export default function PeriodStream(
               await segmentBufferStatus.value.removeBuffer(period.start,
                                                            periodEnd,
                                                            streamCanceller.signal);
-              if (streamCanceller.isUsed) {
+              if (streamCanceller.isUsed()) {
                 return; // The stream has been cancelled
               }
             }
           }
         } else if (segmentBufferStatus.type === "uninitialized") {
           segmentBuffersStore.disableSegmentBuffer(bufferType);
-          if (streamCanceller.isUsed) {
+          if (streamCanceller.isUsed()) {
             return; // The stream has been cancelled
           }
         }
 
         callbacks.adaptationChange({ type: bufferType, adaptation: null, period });
-        if (streamCanceller.isUsed) {
+        if (streamCanceller.isUsed()) {
           return; // Previous call has provoken Stream cancellation by side-effect
         }
 
@@ -193,7 +194,7 @@ export default function PeriodStream(
                `P: ${period.start}`);
 
       callbacks.adaptationChange({ type: bufferType, adaptation, period });
-      if (streamCanceller.isUsed) {
+      if (streamCanceller.isUsed()) {
         return; // Previous call has provoken cancellation by side-effect
       }
 
@@ -214,19 +215,19 @@ export default function PeriodStream(
       }
 
       await segmentBuffersStore.waitForUsableBuffers(streamCanceller.signal);
-      if (streamCanceller.isUsed) {
+      if (streamCanceller.isUsed()) {
         return; // The Stream has since been cancelled
       }
       if (strategy.type === "flush-buffer" || strategy.type === "clean-buffer") {
         for (const { start, end } of strategy.value) {
           await segmentBuffer.removeBuffer(start, end, streamCanceller.signal);
-          if (streamCanceller.isUsed) {
+          if (streamCanceller.isUsed()) {
             return; // The Stream has since been cancelled
           }
         }
         if (strategy.type === "flush-buffer") {
           callbacks.needsBufferFlush();
-          if (streamCanceller.isUsed) {
+          if (streamCanceller.isUsed()) {
             return ; // Previous callback cancelled the Stream by side-effect
           }
         }
@@ -282,7 +283,7 @@ export default function PeriodStream(
           defaultReason: "Unknown `AdaptationStream` error",
         });
         callbacks.warning(formattedError);
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
           return ; // Previous callback cancelled the Stream by side-effect
         }
 

package/src/core/stream/representation/representation_stream.ts

@@ -97,16 +97,16 @@ export default function RepresentationStream<TSegmentDataType>(
   const bufferType = adaptation.type;
 
   /** `TaskCanceller` stopping ALL operations performed by the `RepresentationStream` */
-  const globalCanceller = new TaskCanceller({ cancelOn: parentCancelSignal });
+  const globalCanceller = new TaskCanceller();
+  globalCanceller.linkToSignal(parentCancelSignal);
 
   /**
    * `TaskCanceller` allowing to only stop segment loading and checking operations.
    * This allows to stop only tasks linked to network resource usage, which is
    * often a limited resource, while still letting buffer operations to finish.
    */
-  const segmentsLoadingCanceller = new TaskCanceller({
-    cancelOn: globalCanceller.signal,
-  });
+  const segmentsLoadingCanceller = new TaskCanceller();
+  segmentsLoadingCanceller.linkToSignal(globalCanceller.signal);
 
   /** Saved initialization segment state for this representation. */
   const initSegmentState : IInitSegmentState<TSegmentDataType> = {
@@ -149,7 +149,7 @@ export default function RepresentationStream<TSegmentDataType>(
       callbacks.encryptionDataEncountered(
         encryptionData.map(d => objectAssign({ content }, d))
       );
-      if (globalCanceller.isUsed) {
+      if (globalCanceller.isUsed()) {
         return ; // previous callback has stopped everything by side-effect
       }
     }
@@ -161,7 +161,7 @@ export default function RepresentationStream<TSegmentDataType>(
                                                 segmentFetcher,
                                                 hasInitSegment);
   downloadingQueue.addEventListener("error", (err) => {
-    if (segmentsLoadingCanceller.signal.isCancelled) {
+    if (segmentsLoadingCanceller.signal.isCancelled()) {
       return; // ignore post requests-cancellation loading-related errors,
     }
     globalCanceller.cancel(); // Stop every operations
@@ -172,7 +172,7 @@ export default function RepresentationStream<TSegmentDataType>(
   downloadingQueue.addEventListener("emptyQueue", checkStatus);
   downloadingQueue.addEventListener("requestRetry", (payload) => {
     callbacks.warning(payload.error);
-    if (segmentsLoadingCanceller.signal.isCancelled) {
+    if (segmentsLoadingCanceller.signal.isCancelled()) {
       return; // If the previous callback led to loading operations being stopped, skip
     }
     const retriedSegment = payload.segment;
@@ -218,7 +218,7 @@ export default function RepresentationStream<TSegmentDataType>(
    * issues at the current time, calling the right callbacks if necessary.
    */
   function checkStatus() : void {
-    if (segmentsLoadingCanceller.isUsed) {
+    if (segmentsLoadingCanceller.isUsed()) {
       return ; // Stop all buffer status checking if load operations are stopped
     }
     const observation = playbackObserver.getReference().getValue();
@@ -305,7 +305,7 @@ export default function RepresentationStream<TSegmentDataType>(
                                    isEmptyStream: false,
                                    hasFinishedLoading: status.hasFinishedLoading,
                                    neededSegments: status.neededSegments });
-    if (segmentsLoadingCanceller.signal.isCancelled) {
+    if (segmentsLoadingCanceller.signal.isCancelled()) {
       return ; // previous callback has stopped loading operations by side-effect
     }
     const { UPTO_CURRENT_POSITION_CLEANUP } = config.getCurrent();
@@ -314,7 +314,7 @@ export default function RepresentationStream<TSegmentDataType>(
         0,
         initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
       if (gcedPosition > 0) {
-        segmentBuffer.removeBuffer(0, gcedPosition, segmentsLoadingCanceller.signal)
+        segmentBuffer.removeBuffer(0, gcedPosition, globalCanceller.signal)
           .catch(onFatalBufferError);
       }
     }
@@ -332,7 +332,7 @@ export default function RepresentationStream<TSegmentDataType>(
     evt : IParsedInitSegmentPayload<TSegmentDataType> |
           IParsedSegmentPayload<TSegmentDataType>
   ) : void {
-    if (globalCanceller.isUsed) {
+    if (globalCanceller.isUsed()) {
       // We should not do anything with segments if the `RepresentationStream`
       // is not running anymore.
       return ;
@@ -382,7 +382,7 @@ export default function RepresentationStream<TSegmentDataType>(
           callbacks.encryptionDataEncountered(
             allEncryptionData.map(p => objectAssign({ content }, p))
           );
-          if (globalCanceller.isUsed) {
+          if (globalCanceller.isUsed()) {
             return ; // previous callback has stopped everything by side-effect
           }
         }
@@ -390,13 +390,13 @@ export default function RepresentationStream<TSegmentDataType>(
 
       if (needsManifestRefresh === true) {
         callbacks.needsManifestRefresh();
-        if (globalCanceller.isUsed) {
+        if (globalCanceller.isUsed()) {
           return ; // previous callback has stopped everything by side-effect
         }
       }
       if (inbandEvents !== undefined && inbandEvents.length > 0) {
         callbacks.inbandEvent(inbandEvents);
-        if (globalCanceller.isUsed) {
+        if (globalCanceller.isUsed()) {
           return ; // previous callback has stopped everything by side-effect
         }
       }
@@ -425,7 +425,7 @@ export default function RepresentationStream<TSegmentDataType>(
    * @param {*} err
    */
   function onFatalBufferError(err : unknown) : void {
-    if (globalCanceller.isUsed && err instanceof CancellationError) {
+    if (globalCanceller.isUsed() && err instanceof CancellationError) {
       // The error is linked to cancellation AND we explicitely cancelled buffer
       // operations.
       // We can thus ignore it, it is very unlikely to lead to true buffer issues.

package/src/core/stream/representation/utils/append_segment_to_buffer.ts

@@ -47,7 +47,7 @@ export default async function appendSegmentToBuffer<T>(
   try {
     await segmentBuffer.pushChunk(dataInfos, cancellationSignal);
   } catch (appendError : unknown) {
-    if (cancellationSignal.isCancelled && appendError instanceof CancellationError) {
+    if (cancellationSignal.isCancelled() && appendError instanceof CancellationError) {
       throw appendError;
     } else if (!(appendError instanceof Error) ||
                appendError.name !== "QuotaExceededError")

package/src/core/stream/representation/utils/downloading_queue.ts

@@ -28,6 +28,7 @@ import {
 } from "../../../../transports";
 import assert from "../../../../utils/assert";
 import EventEmitter from "../../../../utils/event_emitter";
+import noop from "../../../../utils/noop";
 import objectAssign from "../../../../utils/object_assign";
 import createSharedReference, {
   IReadOnlySharedReference,
@@ -231,6 +232,7 @@ export default class DownloadingQueue<T>
 
   public stop() {
     this._currentCanceller?.cancel();
+    this._currentCanceller = null;
   }
 
   /**
@@ -245,7 +247,7 @@ export default class DownloadingQueue<T>
     const recursivelyRequestSegments = (
       startingSegment : IQueuedSegment | undefined
     ) : void  => {
-      if (this._currentCanceller !== null && this._currentCanceller.isUsed) {
+      if (this._currentCanceller !== null && this._currentCanceller.isUsed()) {
         this._mediaSegmentRequest = null;
         return;
       }
@@ -254,7 +256,10 @@ export default class DownloadingQueue<T>
         this.trigger("emptyQueue", null);
         return;
       }
-      const canceller = new TaskCanceller({ cancelOn: this._currentCanceller?.signal });
+      const canceller = new TaskCanceller();
+      const unlinkCanceller = this._currentCanceller === null ?
+        noop :
+        canceller.linkToSignal(this._currentCanceller.signal);
 
       const { segment, priority } = startingSegment;
       const context = objectAssign({ segment }, this._content);
@@ -368,6 +373,7 @@ export default class DownloadingQueue<T>
          * requests are scheduled. It is used to schedule the next segment.
          */
         beforeEnded: () : void => {
+          unlinkCanceller();
           this._mediaSegmentRequest = null;
 
           if (isWaitingOnInitSegment) {
@@ -381,6 +387,7 @@ export default class DownloadingQueue<T>
       }, canceller.signal);
 
       request.catch((error : unknown) => {
+        unlinkCanceller();
         if (!isComplete) {
           isComplete = true;
           this.stop();
@@ -400,7 +407,7 @@ export default class DownloadingQueue<T>
   private _restartInitSegmentDownloadingQueue(
     queuedInitSegment : IQueuedSegment | null
   ) : void {
-    if (this._currentCanceller !== null && this._currentCanceller.isUsed) {
+    if (this._currentCanceller !== null && this._currentCanceller.isUsed()) {
       return;
     }
     if (this._initSegmentRequest !== null) {
@@ -410,7 +417,10 @@ export default class DownloadingQueue<T>
       return ;
     }
 
-    const canceller = new TaskCanceller({ cancelOn: this._currentCanceller?.signal });
+    const canceller = new TaskCanceller();
+    const unlinkCanceller = this._currentCanceller === null ?
+      noop :
+      canceller.linkToSignal(this._currentCanceller.signal);
     const { segment, priority } = queuedInitSegment;
     const context = objectAssign({ segment }, this._content);
 
@@ -428,6 +438,7 @@ export default class DownloadingQueue<T>
         log.info("Stream: init segment request interrupted temporarly.", segment.id);
       },
       beforeEnded: () => {
+        unlinkCanceller();
         this._initSegmentRequest = null;
         isComplete = true;
       },
@@ -446,6 +457,7 @@ export default class DownloadingQueue<T>
     }, canceller.signal);
 
     request.catch((error : unknown) => {
+      unlinkCanceller();
       if (!isComplete) {
         isComplete = true;
         this.stop();

package/src/experimental/features/__tests__/debug_element.test.ts

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+
+describe("Features list - DEBUG_ELEMENT", () => {
+  beforeEach(() => {
+    jest.resetModules();
+  });
+
+  it("should add DEBUG_ELEMENT in the current features", () => {
+    const feat = {};
+    jest.mock("../../../core/api/debug", () => ({ __esModule: true as const,
+                                                  default: feat }));
+    const addFeature = jest.requireActual("../debug_element").default;
+
+    const featureObject : {
+      createDebugElement? : unknown;
+    } = {};
+    addFeature(featureObject);
+    expect(featureObject).toEqual({ createDebugElement: {} });
+    expect(featureObject.createDebugElement).toBe(feat);
+  });
+});

package/src/experimental/features/debug_element.ts

@@ -0,0 +1,13 @@
+import createDebugElement from "../../core/api/debug";
+import { IFeaturesObject } from "../../features/types";
+
+/**
+ * Add ability to parse SAMI text tracks in an HTML textrack mode.
+ * @param {Object} features
+ */
+function addDebugElementFeature(features : IFeaturesObject) : void {
+  features.createDebugElement = createDebugElement;
+}
+
+export { addDebugElementFeature as DEBUG_ELEMENT };
+export default addDebugElementFeature;

package/src/experimental/features/index.ts

@@ -15,5 +15,6 @@
  */
 
 export { DASH_WASM } from "./dash_wasm";
+export { DEBUG_ELEMENT } from "./debug_element";
 export { LOCAL_MANIFEST } from "./local";
 export { METAPLAYLIST } from "./metaplaylist";

package/src/experimental/tools/VideoThumbnailLoader/prepare_source_buffer.ts

@@ -18,6 +18,7 @@ import { MediaSource_ } from "../../../compat";
 import { resetMediaSource } from "../../../core/init/utils/create_media_source";
 import { AudioVideoSegmentBuffer } from "../../../core/segment_buffers/implementations";
 import log from "../../../log";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
 import { CancellationSignal } from "../../../utils/task_canceller";
 
@@ -33,7 +34,7 @@ export default function prepareSourceBuffer(
   codec: string,
   cleanUpSignal: CancellationSignal
 ): Promise<AudioVideoSegmentBuffer> {
-  return new Promise((resolve, reject) => {
+  return createCancellablePromise(cleanUpSignal, (resolve, reject) => {
     if (MediaSource_ == null) {
       throw new Error("No MediaSource Object was found in the current browser.");
     }
@@ -49,15 +50,17 @@ export default function prepareSourceBuffer(
 
     log.info("Init: Attaching MediaSource URL to the media element", objectURL);
     videoElement.src = objectURL;
+    cleanUpSignal.register(() => {
+      resetMediaSource(videoElement, mediaSource, objectURL);
+    });
 
     mediaSource.addEventListener("sourceopen", onSourceOpen);
     mediaSource.addEventListener("webkitsourceopen", onSourceOpen);
 
-    cleanUpSignal.register(() => {
+    return () => {
       mediaSource.removeEventListener("sourceopen", onSourceOpen);
       mediaSource.removeEventListener("webkitsourceopen", onSourceOpen);
-      resetMediaSource(videoElement, mediaSource, objectURL);
-    });
+    };
 
     function onSourceOpen() {
       try {

package/src/experimental/tools/VideoThumbnailLoader/video_thumbnail_loader.ts

@@ -243,15 +243,16 @@ export default class VideoThumbnailLoader {
           if (pending !== undefined) {
             promises.push(pending.promise);
           } else {
-            const requestCanceller = new TaskCanceller({
-              cancelOn: lastRepInfo.cleaner.signal,
-            });
+            const requestCanceller = new TaskCanceller();
+            const unlinkSignal = requestCanceller
+              .linkToSignal(lastRepInfo.cleaner.signal);
             const segmentInfo = objectAssign({ segment },
                                              content);
             const prom = loadAndPushSegment(segmentInfo,
                                             segmentBuffer,
                                             lastRepInfo.segmentFetcher,
-                                            requestCanceller.signal);
+                                            requestCanceller.signal)
+              .finally(unlinkSignal);
             const newReq = {
               segmentId: segment.id,
               canceller: requestCanceller,

package/src/features/__tests__/initialize_features.test.ts

@@ -48,6 +48,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -78,6 +79,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 1,
       LOCAL_MANIFEST: 1,
       METAPLAYLIST: 1,
+      DEBUG_ELEMENT: 1,
       NATIVE_SAMI: 1,
       NATIVE_SRT: 1,
       NATIVE_TTML: 1,
@@ -114,6 +116,7 @@ describe("Features - initializeFeaturesObject", () => {
         wasm: null,
       },
       ContentDecryptor: jest.requireActual("../../core/decrypt/index").default,
+      createDebugElement: jest.requireActual("../../core/api/debug").default,
       directfile: {
         initDirectFile: jest.requireActual("../../core/init/directfile_content_initializer").default,
         mediaElementTrackChoiceManager:
@@ -161,6 +164,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 1,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -203,6 +207,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -245,6 +250,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -287,6 +293,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -329,6 +336,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -371,6 +379,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 1,
       NATIVE_SRT: 0,
       NATIVE_TTML: 0,
@@ -413,6 +422,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 0,
       NATIVE_TTML: 1,
@@ -455,6 +465,7 @@ describe("Features - initializeFeaturesObject", () => {
       HTML_VTT: 0,
       LOCAL_MANIFEST: 0,
       METAPLAYLIST: 0,
+      DEBUG_ELEMENT: 0,
       NATIVE_SAMI: 0,
       NATIVE_SRT: 1,
       NATIVE_TTML: 0,

package/src/features/features_object.ts

@@ -22,6 +22,7 @@ import { IFeaturesObject } from "./types";
  */
 const features : IFeaturesObject = { dashParsers: { wasm: null,
                                                     js: null },
+                                     createDebugElement: null,
                                      directfile: null,
                                      ContentDecryptor: null,
                                      htmlTextTracksBuffer: null,