rx-player 3.29.0-dev.2022090500 → 3.29.0-dev.2022091600

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

@@ -0,0 +1,145 @@
+import { CancellationSignal } from "../../../utils/task_canceller";
+export default class TaskPrioritizer<T> {
+    /**
+     * Priority of the most prioritary task currently running.
+     * `null` if no task is currently running.
+     */
+    private _minPendingPriority;
+    /** Queue of tasks currently waiting for more prioritary ones to finish. */
+    private _waitingQueue;
+    /** Tasks currently pending.  */
+    private _pendingTasks;
+    /** @see IPrioritizerPrioritySteps */
+    private _prioritySteps;
+    /**
+     * @param {Options} prioritizerOptions
+     */
+    constructor({ prioritySteps }: IPrioritizerOptions);
+    /**
+     * Create a priorized Promise from a base task.
+     *
+     * This task will immediately have its priority compared to all the
+     * already-running ones created from this class.
+     *
+     * Only if this number is inferior or equal to the priority of the
+     * minimum priority number of all currently-running tasks  will it be
+     * immediately started.
+     * In the opposite case, we will wait for higher-priority tasks to
+     * finish before starting it.
+     *
+     * Note that while this task is waiting for its turn, it is possible
+     * to update its property through the updatePriority method, by providing
+     * the task again and its new priority number.
+     *
+     * @param {Function} taskFn
+     * @param {number} priority
+     * @param {Object} callbacks
+     * @param {Object} cancelSignal
+     * @returns {Promise}
+     */
+    create(taskFn: ITaskFn<T>, priority: number, callbacks: ITaskPrioritizerCallbacks, cancelSignal: CancellationSignal): Promise<T>;
+    private _endTask;
+    /**
+     * Update the priority of a promise given to the TaskPrioritizer.
+     * @param {Object} promise
+     * @param {number} priority
+     */
+    updatePriority(promise: ITaskFn<T>, priority: number): void;
+    /**
+     * Browse the current waiting queue and start all task in it that needs to be
+     * started: start the ones with the lowest priority value below
+     * `_minPendingPriority`.
+     *
+     * Private properties, such as `_minPendingPriority` are updated accordingly
+     * while this method is called.
+     */
+    private _loopThroughWaitingQueue;
+    /**
+     * Interrupt and move back to the waiting queue all pending tasks that are
+     * low priority (having a higher priority number than
+     * `this._prioritySteps.low`).
+     */
+    private _interruptCancellableTasks;
+    /**
+     * Start task which is at the given index in the waiting queue.
+     * The task will be removed from the waiting queue in the process.
+     * @param {number} index
+     */
+    private _findAndRunWaitingQueueTask;
+    /**
+     * Move back pending task to the waiting queue and interrupt it.
+     * @param {object} task
+     */
+    private _interruptPendingTask;
+    /**
+     * Return `true` if the given task can be started immediately based on its
+     * priority.
+     * @param {Object} task
+     * @returns {boolean}
+     */
+    private _canBeStartedNow;
+    /**
+     * Returns `true` if any running task is considered "high priority".
+     * returns `false` otherwise.
+     * @returns {boolean}
+     */
+    private _isRunningHighPriorityTasks;
+}
+/**
+ * Task function as given to the TaskPrioritizer.
+ * The `CancellationSignal` given as argument should be used to directly
+ * interrupt the task.
+ *
+ * A same task might be re-run multiple times.
+ */
+export declare type ITaskFn<T> = (cancellationSignal: CancellationSignal) => Promise<T>;
+/** Options to give to the `TaskPrioritizer`. */
+export interface IPrioritizerOptions {
+    /** @see IPrioritizerPrioritySteps */
+    prioritySteps: IPrioritizerPrioritySteps;
+}
+/**
+ * Define both the `low` and `high` priority steps:
+ *
+ *   - Any task with a priority number that is lower or equal to the
+ *     `high` value will be a task with high priority.
+ *
+ *     When tasks with high priorities are scheduled, they immediately
+ *     abort pending tasks with low priorities (which will have then to
+ *     wait until all higher-priority task have ended before re-starting).
+ *
+ *   - Any task with a priority number that is higher or equal to the
+ *     `low` value will be a task with low priority.
+ *
+ *     Pending tasks with low priorities have the added particularity*
+ *     of being aborted as soon as a high priority task is scheduled.
+ *
+ *     * Other pending tasks are not aborted when a higher-priority
+ *     task is scheduled, as their priorities only affect them before
+ *     they are started (to know when to start them).
+ */
+export interface IPrioritizerPrioritySteps {
+    low: number;
+    high: number;
+}
+/**
+ * Callbacks called by the `TaskPrioritizer` on various events associated to a
+ * single task.
+ */
+export interface ITaskPrioritizerCallbacks {
+    /**
+     * Callback called just before the `TaskPrioritizer` temporarily cancels
+     * a task, to prioritize higher-priority tasks.
+     *
+     * Interrupted tasks are restarted from scratch at a later time.
+     */
+    beforeInterrupted(): void;
+    /**
+     * Callback called when the task ended just before the `TaskPrioritizer`
+     * chooses the next task(s) to run.
+     *
+     * You can use this callback to add yet other tasks just in time before the
+     * `TaskPrioritizer` chooses the next one.
+     */
+    beforeEnded(): void;
+}

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

@@ -0,0 +1,325 @@
+import log from "../../../log";
+import arrayFindIndex from "../../../utils/array_find_index";
+import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
+var TaskPrioritizer = /** @class */ (function () {
+    /**
+     * @param {Options} prioritizerOptions
+     */
+    function TaskPrioritizer(_a) {
+        var prioritySteps = _a.prioritySteps;
+        this._minPendingPriority = null;
+        this._waitingQueue = [];
+        this._pendingTasks = [];
+        this._prioritySteps = prioritySteps;
+        if (this._prioritySteps.high >= this._prioritySteps.low) {
+            throw new Error("TP: the max high level priority should be given a lower" +
+                "priority number than the min low priority.");
+        }
+    }
+    /**
+     * Create a priorized Promise from a base task.
+     *
+     * This task will immediately have its priority compared to all the
+     * already-running ones created from this class.
+     *
+     * Only if this number is inferior or equal to the priority of the
+     * minimum priority number of all currently-running tasks  will it be
+     * immediately started.
+     * In the opposite case, we will wait for higher-priority tasks to
+     * finish before starting it.
+     *
+     * Note that while this task is waiting for its turn, it is possible
+     * to update its property through the updatePriority method, by providing
+     * the task again and its new priority number.
+     *
+     * @param {Function} taskFn
+     * @param {number} priority
+     * @param {Object} callbacks
+     * @param {Object} cancelSignal
+     * @returns {Promise}
+     */
+    TaskPrioritizer.prototype.create = function (taskFn, priority, callbacks, cancelSignal) {
+        var _this = this;
+        var newTask;
+        return new Promise(function (resolve, reject) {
+            /** Function allowing to start the underlying Promise. */
+            var trigger = function () {
+                if (newTask.hasEnded) {
+                    unregisterCancelSignal();
+                    return;
+                }
+                var interrupter = new TaskCanceller({ cancelOn: cancelSignal });
+                newTask.interrupter = interrupter;
+                interrupter.signal.register(function () {
+                    newTask.interrupter = null;
+                    if (!cancelSignal.isCancelled) {
+                        callbacks.beforeInterrupted();
+                    }
+                });
+                _this._minPendingPriority = _this._minPendingPriority === null ?
+                    newTask.priority :
+                    Math.min(_this._minPendingPriority, newTask.priority);
+                _this._pendingTasks.push(newTask);
+                newTask.taskFn(interrupter.signal)
+                    .then(onResolve)
+                    .catch(function (err) {
+                    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,
+                trigger: trigger,
+                taskFn: taskFn,
+                interrupter: null,
+            };
+            if (!_this._canBeStartedNow(newTask)) {
+                _this._waitingQueue.push(newTask);
+            }
+            else {
+                // We can start the task right away
+                newTask.trigger();
+                if (_this._isRunningHighPriorityTasks()) {
+                    // Note: we want to begin interrupting low-priority tasks just
+                    // after starting the current one because the interrupting
+                    // logic can call external code.
+                    // This would mean re-entrancy, itself meaning that some weird
+                    // half-state could be reached unless we're very careful.
+                    // To be sure no harm is done, we put that code at the last
+                    // possible position.
+                    _this._interruptCancellableTasks();
+                }
+            }
+        });
+    };
+    TaskPrioritizer.prototype._endTask = function (task) {
+        task.hasEnded = true;
+        var waitingQueueIndex = _findTaskIndex(task.taskFn, this._waitingQueue);
+        if (waitingQueueIndex >= 0) {
+            // If it was still waiting for its turn
+            this._waitingQueue.splice(waitingQueueIndex, 1);
+        }
+        else {
+            // remove it from pending queue if in it
+            var pendingTasksIndex = _findTaskIndex(task.taskFn, this._pendingTasks);
+            if (pendingTasksIndex < 0) {
+                return;
+            }
+            this._pendingTasks.splice(pendingTasksIndex, 1);
+            if (this._pendingTasks.length > 0) {
+                if (this._minPendingPriority === task.priority) {
+                    this._minPendingPriority = Math.min.apply(Math, this._pendingTasks.map(function (t) { return t.priority; }));
+                }
+            }
+            else {
+                this._minPendingPriority = null;
+            }
+            this._loopThroughWaitingQueue();
+        }
+    };
+    /**
+     * Update the priority of a promise given to the TaskPrioritizer.
+     * @param {Object} promise
+     * @param {number} priority
+     */
+    TaskPrioritizer.prototype.updatePriority = function (promise, priority) {
+        var waitingQueueIndex = _findTaskIndex(promise, this._waitingQueue);
+        if (waitingQueueIndex >= 0) { // If it was still waiting for its turn
+            var waitingQueueElt = this._waitingQueue[waitingQueueIndex];
+            if (waitingQueueElt.priority === priority) {
+                return;
+            }
+            waitingQueueElt.priority = priority;
+            if (!this._canBeStartedNow(waitingQueueElt)) {
+                return;
+            }
+            this._findAndRunWaitingQueueTask(waitingQueueIndex);
+            if (this._isRunningHighPriorityTasks()) {
+                // Re-check to cancel every "cancellable" pending task
+                //
+                // Note: We start the task before interrupting cancellable tasks on
+                // purpose.
+                // Because both `_findAndRunWaitingQueueTask` and
+                // `_interruptCancellableTasks` can emit events and thus call external
+                // code, we could retrieve ourselves in a very weird state at this point
+                //
+                // By starting the task first, we ensure that this is manageable:
+                // `_getMinPendingPriority()` has already been updated to the right value at
+                // the time we reached external code, the priority of the current
+                // Task has just been updated, and `_interruptCancellableTasks`
+                // will ensure that we're basing ourselves on the last `priority` value
+                // each time.
+                // Doing it in the reverse order is an order of magnitude more difficult
+                // to write and to reason about.
+                this._interruptCancellableTasks();
+            }
+            return;
+        }
+        var pendingTasksIndex = _findTaskIndex(promise, this._pendingTasks);
+        if (pendingTasksIndex < 0) {
+            log.warn("TP: request to update the priority of a non-existent task");
+            return;
+        }
+        var task = this._pendingTasks[pendingTasksIndex];
+        if (task.priority === priority) {
+            return;
+        }
+        var prevPriority = task.priority;
+        task.priority = priority;
+        if (this._minPendingPriority === null || priority < this._minPendingPriority) {
+            this._minPendingPriority = priority;
+        }
+        else if (this._minPendingPriority === prevPriority) { // was highest priority
+            if (this._pendingTasks.length === 1) {
+                this._minPendingPriority = priority;
+            }
+            else {
+                this._minPendingPriority = Math.min.apply(Math, this._pendingTasks.map(function (t) { return t.priority; }));
+            }
+            this._loopThroughWaitingQueue();
+        }
+        if (this._isRunningHighPriorityTasks()) {
+            // Always interrupt cancellable tasks after all other side-effects, to
+            // avoid re-entrancy issues
+            this._interruptCancellableTasks();
+        }
+    };
+    /**
+     * Browse the current waiting queue and start all task in it that needs to be
+     * started: start the ones with the lowest priority value below
+     * `_minPendingPriority`.
+     *
+     * Private properties, such as `_minPendingPriority` are updated accordingly
+     * while this method is called.
+     */
+    TaskPrioritizer.prototype._loopThroughWaitingQueue = function () {
+        var minWaitingPriority = this._waitingQueue.reduce(function (acc, elt) {
+            return acc === null || acc > elt.priority ? elt.priority :
+                acc;
+        }, null);
+        if (minWaitingPriority === null ||
+            (this._minPendingPriority !== null &&
+                this._minPendingPriority < minWaitingPriority)) {
+            return;
+        }
+        for (var i = 0; i < this._waitingQueue.length; i++) {
+            var priorityToCheck = this._minPendingPriority === null ?
+                minWaitingPriority :
+                Math.min(this._minPendingPriority, minWaitingPriority);
+            var elt = this._waitingQueue[i];
+            if (elt.priority <= priorityToCheck) {
+                this._findAndRunWaitingQueueTask(i);
+                i--; // previous operation should have removed that element from the
+                // the waiting queue
+            }
+        }
+    };
+    /**
+     * Interrupt and move back to the waiting queue all pending tasks that are
+     * low priority (having a higher priority number than
+     * `this._prioritySteps.low`).
+     */
+    TaskPrioritizer.prototype._interruptCancellableTasks = function () {
+        for (var i = 0; i < this._pendingTasks.length; i++) {
+            var pendingObj = this._pendingTasks[i];
+            if (pendingObj.priority >= this._prioritySteps.low) {
+                this._interruptPendingTask(pendingObj);
+                // The previous call could have a lot of potential side-effects.
+                // It is safer to re-start the function to not miss any pending
+                // task that needs to be cancelled.
+                return this._interruptCancellableTasks();
+            }
+        }
+    };
+    /**
+     * Start task which is at the given index in the waiting queue.
+     * The task will be removed from the waiting queue in the process.
+     * @param {number} index
+     */
+    TaskPrioritizer.prototype._findAndRunWaitingQueueTask = function (index) {
+        if (index >= this._waitingQueue.length || index < 0) {
+            log.warn("TP : Tried to start a non existing task");
+            return false;
+        }
+        var task = this._waitingQueue.splice(index, 1)[0];
+        task.trigger();
+        return true;
+    };
+    /**
+     * Move back pending task to the waiting queue and interrupt it.
+     * @param {object} task
+     */
+    TaskPrioritizer.prototype._interruptPendingTask = function (task) {
+        var _a;
+        var pendingTasksIndex = _findTaskIndex(task.taskFn, this._pendingTasks);
+        if (pendingTasksIndex < 0) {
+            log.warn("TP: Interrupting a non-existent pending task. Aborting...");
+            return;
+        }
+        // Stop task and put it back in the waiting queue
+        this._pendingTasks.splice(pendingTasksIndex, 1);
+        this._waitingQueue.push(task);
+        if (this._pendingTasks.length === 0) {
+            this._minPendingPriority = null;
+        }
+        else if (this._minPendingPriority === task.priority) {
+            this._minPendingPriority = Math.min.apply(Math, this._pendingTasks.map(function (t) { return t.priority; }));
+        }
+        (_a = task.interrupter) === null || _a === void 0 ? void 0 : _a.cancel(); // Interrupt at last step because it calls external code
+    };
+    /**
+     * Return `true` if the given task can be started immediately based on its
+     * priority.
+     * @param {Object} task
+     * @returns {boolean}
+     */
+    TaskPrioritizer.prototype._canBeStartedNow = function (task) {
+        return this._minPendingPriority === null ||
+            task.priority <= this._minPendingPriority;
+    };
+    /**
+     * Returns `true` if any running task is considered "high priority".
+     * returns `false` otherwise.
+     * @returns {boolean}
+     */
+    TaskPrioritizer.prototype._isRunningHighPriorityTasks = function () {
+        return this._minPendingPriority !== null &&
+            this._minPendingPriority <= this._prioritySteps.high;
+    };
+    return TaskPrioritizer;
+}());
+export default TaskPrioritizer;
+/**
+ * Simple utils function allowing to find a given task function in the given
+ * `queue`.
+ *
+ * Returns `-1` if `taskFn` is not found.
+ * @param {Function} taskFn
+ * @param {Array.<Object>} queue
+ * @returns {number}
+ */
+function _findTaskIndex(taskFn, queue) {
+    return arrayFindIndex(queue, function (elt) { return elt.taskFn === taskFn; });
+}

package/dist/_esm5.processed/core/fetchers/utils/try_urls_with_backoff.d.ts

@@ -78,8 +78,8 @@ export declare function tryURLsWithBackoff<T>(urls: Array<string | null>, perfor
 /**
  * Lightweight version of the request algorithm, this time with only a simple
  * Promise given.
- * @param {Function} request$
+ * @param {Function} performRequest
  * @param {Object} options
- * @returns {Observable}
+ * @returns {Promise}
  */
 export declare function tryRequestPromiseWithBackoff<T>(performRequest: () => Promise<T>, options: IBackoffSettings, cancellationSignal: CancellationSignal): Promise<T>;

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

@@ -180,7 +180,7 @@ export function tryURLsWithBackoff(urls, performRequest, options, cancellationSi
      *
      * @param {string|null} url
      * @param {number} index
-     * @returns {Observable}
+     * @returns {Promise}
      */
     function tryURLsRecursively(url, index) {
         return __awaiter(this, void 0, void 0, function () {
@@ -254,9 +254,9 @@ export function tryURLsWithBackoff(urls, performRequest, options, cancellationSi
 /**
  * Lightweight version of the request algorithm, this time with only a simple
  * Promise given.
- * @param {Function} request$
+ * @param {Function} performRequest
  * @param {Object} options
- * @returns {Observable}
+ * @returns {Promise}
  */
 export function tryRequestPromiseWithBackoff(performRequest, options, cancellationSignal) {
     // same than for a single unknown URL

package/dist/_esm5.processed/core/init/create_media_source.d.ts

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
+/**
+ * Dispose of ressources taken by the MediaSource:
+ *   - Clear the MediaSource' SourceBuffers
+ *   - Clear the mediaElement's src (stop the mediaElement)
+ *   - Revoke MediaSource' URL
+ * @param {HTMLMediaElement} mediaElement
+ * @param {MediaSource|null} mediaSource
+ * @param {string|null} mediaSourceURL
+ */
+export declare function resetMediaSource(mediaElement: HTMLMediaElement, mediaSource: MediaSource | null, mediaSourceURL: string | null): void;
 /**
  * Create and open a new MediaSource object on the given media element.
  * Emit the MediaSource when done.

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

@@ -28,7 +28,7 @@ var onSourceOpen$ = events.onSourceOpen$;
  * @param {MediaSource|null} mediaSource
  * @param {string|null} mediaSourceURL
  */
-function resetMediaSource(mediaElement, mediaSource, mediaSourceURL) {
+export function resetMediaSource(mediaElement, mediaSource, mediaSourceURL) {
     if (mediaSource !== null && mediaSource.readyState !== "closed") {
         var readyState = mediaSource.readyState, sourceBuffers = mediaSource.sourceBuffers;
         for (var i = sourceBuffers.length - 1; i >= 0; i--) {

package/dist/_esm5.processed/core/init/stall_avoider.d.ts

@@ -69,7 +69,8 @@ export interface IDiscontinuityTimeInfo {
  * @param {object} playbackObserver - emit the current playback conditions.
  * @param {Object} manifest - The Manifest of the currently-played content.
  * @param {Object} speed - The last speed set by the user
- * @param {Observable} lockedStream$
+ * @param {Observable} lockedStream$ - Emit information on currently "locked"
+ * streams.
  * @param {Observable} discontinuityUpdate$ - Observable emitting encountered
  * discontinuities for loaded Period and buffer types.
  * @returns {Observable}

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

@@ -32,7 +32,8 @@ var EPSILON = 1 / 60;
  * @param {object} playbackObserver - emit the current playback conditions.
  * @param {Object} manifest - The Manifest of the currently-played content.
  * @param {Object} speed - The last speed set by the user
- * @param {Observable} lockedStream$
+ * @param {Observable} lockedStream$ - Emit information on currently "locked"
+ * streams.
  * @param {Observable} discontinuityUpdate$ - Observable emitting encountered
  * discontinuities for loaded Period and buffer types.
  * @returns {Observable}

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

@@ -366,7 +366,7 @@ var AudioVideoSegmentBuffer = /** @class */ (function (_super) {
         var dataToPush = [];
         var codec = data.codec, timestampOffset = data.timestampOffset, appendWindow = data.appendWindow;
         var hasUpdatedSourceBufferType = false;
-        if (codec !== this.codec) {
+        if (codec !== undefined && codec !== this.codec) {
             log.debug("AVSB: updating codec", codec);
             hasUpdatedSourceBufferType = tryToChangeSourceBufferType(this._sourceBuffer, codec);
             if (hasUpdatedSourceBufferType) {

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

@@ -310,6 +310,7 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
         }, cancellationSignal);
         onSeeked(this._videoElement, startAutoRefresh, cancellationSignal);
         onEnded(this._videoElement, startAutoRefresh, cancellationSignal);
+        startAutoRefresh();
         function stopAutoRefresh() {
             if (autoRefreshCanceller !== null) {
                 autoRefreshCanceller.cancel();
@@ -322,11 +323,10 @@ var HTMLTextSegmentBuffer = /** @class */ (function (_super) {
      * position.
      */
     HTMLTextSegmentBuffer.prototype.refreshSubtitles = function () {
-        var videoElt = this._videoElement;
         var MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL = config.getCurrent().MAXIMUM_HTML_TEXT_TRACK_UPDATE_INTERVAL;
         var time;
-        if (videoElt.paused || videoElt.playbackRate <= 0) {
-            time = videoElt.currentTime;
+        if (this._videoElement.paused || this._videoElement.playbackRate <= 0) {
+            time = this._videoElement.currentTime;
         }
         else {
             // to spread the time error, we divide the regular chosen interval.

package/dist/_esm5.processed/core/segment_buffers/implementations/types.d.ts

@@ -179,7 +179,8 @@ export interface IPushedChunkData<T> {
     /**
      * The whole initialization segment's data related to the chunk you want to
      * push.
-     * `null` if none.
+     * To set to `null` either if no initialization data is needed, or if you are
+     * confident that the last pushed one is compatible.
      */
     initSegment: T | null;
     /**
@@ -192,8 +193,11 @@ export interface IPushedChunkData<T> {
     /**
      * String corresponding to the mime-type + codec of the last segment pushed.
      * This might then be used by a SourceBuffer to infer the right codec to use.
+     *
+     * If set to `undefined`, the SegmentBuffer implementation will just rely on
+     * a default codec it is linked to, if one.
      */
-    codec: string;
+    codec: string | undefined;
     /**
      * Time offset in seconds to apply to this segment.
      * A `timestampOffset` set to `5` will mean that the segment will be decoded

package/dist/_esm5.processed/core/stream/orchestrator/{get_blacklisted_ranges.d.ts → get_time_ranges_for_content.d.ts}

@@ -23,7 +23,7 @@ import { SegmentBuffer } from "../../segment_buffers";
  * @param {Array.<Object>} contents
  * @returns {Array.<Object>}
  */
-export default function getBlacklistedRanges(segmentBuffer: SegmentBuffer, contents: Array<{
+export default function getTimeRangesForContent(segmentBuffer: SegmentBuffer, contents: Array<{
     adaptation: Adaptation;
     period: Period;
     representation: Representation;

package/dist/_esm5.processed/core/stream/orchestrator/{get_blacklisted_ranges.js → get_time_ranges_for_content.js}

@@ -21,7 +21,7 @@ import log from "../../../log";
  * @param {Array.<Object>} contents
  * @returns {Array.<Object>}
  */
-export default function getBlacklistedRanges(segmentBuffer, contents) {
+export default function getTimeRangesForContent(segmentBuffer, contents) {
     if (contents.length === 0) {
         return [];
     }