rx-player 4.0.0 → 4.1.0-dev.2024031100

package/dist/commonjs/core/stream/representation/utils/append_segment_to_buffer.d.ts

@@ -13,23 +13,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IRange } from "../../../../utils/ranges";
-import { IReadOnlySharedReference } from "../../../../utils/reference";
-import { CancellationSignal } from "../../../../utils/task_canceller";
-import { IReadOnlyPlaybackObserver } from "../../../api";
-import { IInsertedChunkInfos, IPushChunkInfos, SegmentBuffer } from "../../../segment_buffers";
-import { IRepresentationStreamPlaybackObservation } from "../types";
+import type { IReadOnlyPlaybackObserver } from "../../../../playback_observer";
+import type { IRange } from "../../../../utils/ranges";
+import type { IReadOnlySharedReference } from "../../../../utils/reference";
+import type { CancellationSignal } from "../../../../utils/task_canceller";
+import type { IInsertedChunkInfos, IPushChunkInfos, SegmentSink } from "../../../segment_sinks";
+import type { IRepresentationStreamPlaybackObservation } from "../types";
 /**
- * Append a segment to the given segmentBuffer.
+ * Append a segment to the given segmentSink.
  * If it leads to an Error due to a full buffer, try to run our custom range
  * _garbage collector_ then retry.
  * @param {Object} playbackObserver
- * @param {Object} segmentBuffer
+ * @param {Object} segmentSink
  * @param {Object} dataInfos
  * @param {number} bufferGoal
  * @param {Object} cancellationSignal
  * @returns {Promise}
  */
-export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, segmentBuffer: SegmentBuffer, dataInfos: IPushChunkInfos<T> & {
+export default function appendSegmentToBuffer<T>(playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, segmentSink: SegmentSink, dataInfos: IPushChunkInfos<T> & {
     inventoryInfos: IInsertedChunkInfos;
 }, bufferGoal: IReadOnlySharedReference<number>, cancellationSignal: CancellationSignal): Promise<IRange[]>;

package/dist/commonjs/core/stream/representation/utils/append_segment_to_buffer.js

@@ -52,7 +52,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * This file allows any Stream to push data to a SegmentBuffer.
+ * This file allows any Stream to push data to a SegmentSink.
  */
 var errors_1 = require("../../../../errors");
 var log_1 = require("../../../../log");
@@ -60,24 +60,24 @@ var manifest_1 = require("../../../../manifest");
 var sleep_1 = require("../../../../utils/sleep");
 var task_canceller_1 = require("../../../../utils/task_canceller");
 /**
- * Append a segment to the given segmentBuffer.
+ * Append a segment to the given segmentSink.
  * If it leads to an Error due to a full buffer, try to run our custom range
  * _garbage collector_ then retry.
  * @param {Object} playbackObserver
- * @param {Object} segmentBuffer
+ * @param {Object} segmentSink
  * @param {Object} dataInfos
  * @param {number} bufferGoal
  * @param {Object} cancellationSignal
  * @returns {Promise}
  */
-function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, bufferGoal, cancellationSignal) {
+function appendSegmentToBuffer(playbackObserver, segmentSink, dataInfos, bufferGoal, cancellationSignal) {
     return __awaiter(this, void 0, void 0, function () {
         var appendError_1, reason, position, currentPos, start, end, err2_1, reason;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     _a.trys.push([0, 2, , 10]);
-                    return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos)];
+                    return [4 /*yield*/, segmentSink.pushChunk(dataInfos)];
                 case 1: return [2 /*return*/, _a.sent()];
                 case 2:
                     appendError_1 = _a.sent();
@@ -85,9 +85,9 @@ function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, buffe
                         throw appendError_1;
                     }
                     else if (!(appendError_1 instanceof errors_1.SourceBufferError) || !appendError_1.isBufferFull) {
-                        reason = appendError_1 instanceof Error ?
-                            appendError_1.toString() :
-                            "An unknown error happened when pushing content";
+                        reason = appendError_1 instanceof Error
+                            ? appendError_1.toString()
+                            : "An unknown error happened when pushing content";
                         throw new errors_1.MediaError("BUFFER_APPEND_ERROR", reason, {
                             tracks: [(0, manifest_1.toTaggedTrack)(dataInfos.inventoryInfos.adaptation)],
                         });
@@ -100,10 +100,10 @@ function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, buffe
                     log_1.default.warn("Stream: Running garbage collector");
                     start = Math.max(currentPos - 5, 0);
                     end = currentPos + bufferGoal.getValue() + 12;
-                    return [4 /*yield*/, segmentBuffer.removeBuffer(0, start)];
+                    return [4 /*yield*/, segmentSink.removeBuffer(0, start)];
                 case 4:
                     _a.sent();
-                    return [4 /*yield*/, segmentBuffer.removeBuffer(end, Number.MAX_VALUE)];
+                    return [4 /*yield*/, segmentSink.removeBuffer(end, Number.MAX_VALUE)];
                 case 5:
                     _a.sent();
                     return [4 /*yield*/, (0, sleep_1.default)(200)];
@@ -112,15 +112,14 @@ function appendSegmentToBuffer(playbackObserver, segmentBuffer, dataInfos, buffe
                     if (cancellationSignal.cancellationError !== null) {
                         throw cancellationSignal.cancellationError;
                     }
-                    return [4 /*yield*/, segmentBuffer.pushChunk(dataInfos)];
+                    return [4 /*yield*/, segmentSink.pushChunk(dataInfos)];
                 case 7: return [2 /*return*/, _a.sent()];
                 case 8:
                     err2_1 = _a.sent();
                     if (err2_1 instanceof task_canceller_1.CancellationError) {
                         throw err2_1;
                     }
-                    reason = err2_1 instanceof Error ? err2_1.toString() :
-                        "Could not clean the buffer";
+                    reason = err2_1 instanceof Error ? err2_1.toString() : "Could not clean the buffer";
                     throw new errors_1.MediaError("BUFFER_FULL_ERROR", reason, {
                         tracks: [(0, manifest_1.toTaggedTrack)(dataInfos.inventoryInfos.adaptation)],
                     });

package/dist/commonjs/core/stream/representation/utils/check_for_discontinuity.d.ts

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest, { Adaptation, Period, Representation } from "../../../../manifest";
-import { IBufferedChunk } from "../../../segment_buffers";
-import { IBufferDiscontinuity } from "../types";
+import type { IManifest, IAdaptation, IPeriod, IRepresentation } from "../../../../manifest";
+import type { IBufferedChunk } from "../../../segment_sinks";
+import type { IBufferDiscontinuity } from "../types";
 /**
  * Check if there is a soon-to-be-encountered discontinuity in the buffer that
  * won't be filled by any future segment.
@@ -43,10 +43,10 @@ import { IBufferDiscontinuity } from "../types";
  * though the array given can be larger.
  */
 export default function checkForDiscontinuity(content: {
-    adaptation: Adaptation;
-    manifest: Manifest;
-    period: Period;
-    representation: Representation;
+    adaptation: IAdaptation;
+    manifest: IManifest;
+    period: IPeriod;
+    representation: IRepresentation;
 }, checkedRange: {
     start: number;
     end: number;

package/dist/commonjs/core/stream/representation/utils/check_for_discontinuity.js

@@ -51,7 +51,8 @@ function checkForDiscontinuity(content, checkedRange, nextSegmentStart, hasFinis
     var nextBufferedInRangeIdx = getIndexOfFirstChunkInRange(bufferedSegments, checkedRange);
     if (nextBufferedInRangeIdx === null) {
         // There's no segment currently buffered for the current range.
-        if (nextSegmentStart === null) { // No segment to load in that range
+        if (nextSegmentStart === null) {
+            // No segment to load in that range
             // Check if we are in a discontinuity at the end of the current Period
             if (hasFinishedLoading &&
                 period.end !== undefined &&
@@ -59,11 +60,9 @@ function checkForDiscontinuity(content, checkedRange, nextSegmentStart, hasFinis
                 return { start: undefined, end: null }; // discontinuity to Period's end
             }
             // Check that there is a discontinuity announced in the Manifest there
-            var discontinuityEnd = representation.index
-                .checkDiscontinuity(checkedRange.start);
+            var discontinuityEnd = representation.index.checkDiscontinuity(checkedRange.start);
             if (discontinuityEnd !== null) {
-                return { start: undefined,
-                    end: discontinuityEnd };
+                return { start: undefined, end: discontinuityEnd };
             }
         }
         return null;
@@ -79,12 +78,12 @@ function checkForDiscontinuity(content, checkedRange, nextSegmentStart, hasFinis
             nextBufferedSegment.infos.segment.end <= nextSegmentStart)) {
         var discontinuityEnd = nextBufferedSegment.bufferedStart;
         if (!hasFinishedLoading &&
-            representation.index.awaitSegmentBetween(checkedRange.start, discontinuityEnd) !== false) {
+            representation.index.awaitSegmentBetween(checkedRange.start, discontinuityEnd) !==
+                false) {
             return null;
         }
         log_1.default.debug("RS: current discontinuity encountered", adaptation.type, nextBufferedSegment.bufferedStart);
-        return { start: undefined,
-            end: discontinuityEnd };
+        return { start: undefined, end: discontinuityEnd };
     }
     // Check if there's a discontinuity BETWEEN segments of the current range
     var nextHoleIdx = getIndexOfFirstDiscontinuityBetweenChunks(bufferedSegments, checkedRange, nextBufferedInRangeIdx + 1);
@@ -95,8 +94,8 @@ function checkForDiscontinuity(content, checkedRange, nextSegmentStart, hasFinis
         var segmentInfoAfterHole = bufferedSegments[nextHoleIdx];
         if (nextSegmentStart === null ||
             segmentInfoAfterHole.infos.segment.end <= nextSegmentStart) {
-            if (!hasFinishedLoading && representation.index
-                .awaitSegmentBetween(segmentInfoBeforeHole.infos.segment.end, segmentInfoAfterHole.infos.segment.time) !== false) {
+            if (!hasFinishedLoading &&
+                representation.index.awaitSegmentBetween(segmentInfoBeforeHole.infos.segment.end, segmentInfoAfterHole.infos.segment.time) !== false) {
                 return null;
             }
             var start = segmentInfoBeforeHole.bufferedEnd;
@@ -108,8 +107,10 @@ function checkForDiscontinuity(content, checkedRange, nextSegmentStart, hasFinis
     if (nextSegmentStart === null) {
         // If no hole between segments and no segment to load, check for a
         // discontinuity at the end of the Period
-        if (hasFinishedLoading && period.end !== undefined) { // Period is finished
-            if (checkedRange.end < period.end) { // We've not reached the Period's end yet
+        if (hasFinishedLoading && period.end !== undefined) {
+            // Period is finished
+            if (checkedRange.end < period.end) {
+                // We've not reached the Period's end yet
                 return null;
             }
             // Check if the last buffered segment ends before this Period's end
@@ -120,8 +121,7 @@ function checkForDiscontinuity(content, checkedRange, nextSegmentStart, hasFinis
                 if (lastSegment.bufferedEnd !== undefined &&
                     lastSegment.bufferedEnd < period.end) {
                     log_1.default.debug("RS: discontinuity encountered at the end of the current period", adaptation.type, lastSegment.bufferedEnd, period.end);
-                    return { start: lastSegment.bufferedEnd,
-                        end: null };
+                    return { start: lastSegment.bufferedEnd, end: null };
                 }
             }
         }
@@ -138,11 +138,9 @@ function checkForDiscontinuity(content, checkedRange, nextSegmentStart, hasFinis
             }
             if (bufSeg.bufferedStart < checkedRange.end) {
                 if (bufSeg.bufferedEnd !== undefined && bufSeg.bufferedEnd < checkedRange.end) {
-                    var discontinuityEnd = representation.index
-                        .checkDiscontinuity(checkedRange.end);
+                    var discontinuityEnd = representation.index.checkDiscontinuity(checkedRange.end);
                     if (discontinuityEnd !== null) {
-                        return { start: bufSeg.bufferedEnd,
-                            end: discontinuityEnd };
+                        return { start: bufSeg.bufferedEnd, end: discontinuityEnd };
                     }
                 }
                 return null;

package/dist/commonjs/core/stream/representation/utils/downloading_queue.d.ts

@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../../manifest";
-import { IPlayerError } from "../../../../public_types";
-import { ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk } from "../../../../transports";
+import type { IManifest, IAdaptation, ISegment, IPeriod, IRepresentation } from "../../../../manifest";
+import type { IPlayerError } from "../../../../public_types";
+import type { ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk } from "../../../../transports";
 import EventEmitter from "../../../../utils/event_emitter";
-import { IReadOnlySharedReference } from "../../../../utils/reference";
-import { IPrioritizedSegmentFetcher } from "../../../fetchers";
-import { IQueuedSegment } from "../types";
+import type { IReadOnlySharedReference } from "../../../../utils/reference";
+import type { IPrioritizedSegmentFetcher } from "../../../fetchers";
+import type { IQueuedSegment } from "../types";
 /**
  * Class scheduling segment downloads for a single Representation.
  *
@@ -221,11 +221,11 @@ export interface IDownloadQueueItem {
 /** Context for segments downloaded through the DownloadingQueue. */
 export interface IDownloadingQueueContext {
     /** Adaptation linked to the segments you want to load. */
-    adaptation: Adaptation;
+    adaptation: IAdaptation;
     /** Manifest linked to the segments you want to load. */
-    manifest: Manifest;
+    manifest: IManifest;
     /** Period linked to the segments you want to load. */
-    period: Period;
+    period: IPeriod;
     /** Representation linked to the segments you want to load. */
-    representation: Representation;
+    representation: IRepresentation;
 }

package/dist/commonjs/core/stream/representation/utils/downloading_queue.js

@@ -89,8 +89,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
      * @returns {Object | null}
      */
     DownloadingQueue.prototype.getRequestedInitSegment = function () {
-        return this._initSegmentRequest === null ? null :
-            this._initSegmentRequest.segment;
+        return this._initSegmentRequest === null ? null : this._initSegmentRequest.segment;
     };
     /**
      * Returns the media segment currently being requested.
@@ -98,8 +97,7 @@ var DownloadingQueue = /** @class */ (function (_super) {
      * @returns {Object | null}
      */
     DownloadingQueue.prototype.getRequestedMediaSegment = function () {
-        return this._mediaSegmentRequest === null ? null :
-            this._mediaSegmentRequest.segment;
+        return this._mediaSegmentRequest === null ? null : this._mediaSegmentRequest.segment;
     };
     /**
      * Start the current downloading queue, emitting events as it loads and parses
@@ -197,9 +195,9 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 return;
             }
             var canceller = new task_canceller_1.default();
-            var unlinkCanceller = _this._currentCanceller === null ?
-                noop_1.default :
-                canceller.linkToSignal(_this._currentCanceller.signal);
+            var unlinkCanceller = _this._currentCanceller === null
+                ? noop_1.default
+                : canceller.linkToSignal(_this._currentCanceller.signal);
             var segment = startingSegment.segment, priority = startingSegment.priority;
             var context = (0, object_assign_1.default)({ segment: segment }, _this._content);
             /**
@@ -298,7 +296,9 @@ var DownloadingQueue = /** @class */ (function (_super) {
                     unlinkCanceller();
                     _this._mediaSegmentRequest = null;
                     if (isWaitingOnInitSegment) {
-                        _this._initSegmentInfoRef.waitUntilDefined(continueToNextSegment, { clearSignal: canceller.signal });
+                        _this._initSegmentInfoRef.waitUntilDefined(continueToNextSegment, {
+                            clearSignal: canceller.signal,
+                        });
                     }
                     else {
                         continueToNextSegment();
@@ -333,9 +333,9 @@ var DownloadingQueue = /** @class */ (function (_super) {
             return;
         }
         var canceller = new task_canceller_1.default();
-        var unlinkCanceller = this._currentCanceller === null ?
-            noop_1.default :
-            canceller.linkToSignal(this._currentCanceller.signal);
+        var unlinkCanceller = this._currentCanceller === null
+            ? noop_1.default
+            : canceller.linkToSignal(this._currentCanceller.signal);
         var segment = queuedInitSegment.segment, priority = queuedInitSegment.priority;
         var context = (0, object_assign_1.default)({ segment: segment }, this._content);
         /**

package/dist/commonjs/core/stream/representation/utils/get_buffer_status.d.ts

@@ -13,14 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest, { Adaptation, Period, Representation } from "../../../../manifest";
-import { IReadOnlyPlaybackObserver } from "../../../api";
-import { SegmentBuffer } from "../../../segment_buffers";
-import { IBufferDiscontinuity, IRepresentationStreamPlaybackObservation, IQueuedSegment } from "../types";
+import type { IManifest, IAdaptation, IPeriod, IRepresentation } from "../../../../manifest";
+import type { IReadOnlyPlaybackObserver } from "../../../../playback_observer";
+import type { SegmentSink } from "../../../segment_sinks";
+import type { IBufferDiscontinuity, IRepresentationStreamPlaybackObservation, IQueuedSegment } from "../types";
 /** Analysis of the current buffer's status. */
 export interface IBufferStatus {
     /**
-     * Future discontinuity found in the SegmentBuffer's buffer: hole that won't
+     * Future discontinuity found in the SegmentSink's buffer: hole that won't
      * be filled by a segment.
      * `null` if no such discontinuity is found in the near future.
      */
@@ -61,12 +61,12 @@ export interface IBufferStatus {
  * @param {number|undefined} fastSwitchThreshold
  * @param {number} bufferGoal
  * @param {number} maxBufferSize
- * @param {Object} segmentBuffer
+ * @param {Object} segmentSink
  * @returns {Object}
  */
 export default function getBufferStatus(content: {
-    adaptation: Adaptation;
-    manifest: Manifest;
-    period: Period;
-    representation: Representation;
-}, initialWantedTime: number, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, fastSwitchThreshold: number | undefined, bufferGoal: number, maxBufferSize: number, segmentBuffer: SegmentBuffer): IBufferStatus;
+    adaptation: IAdaptation;
+    manifest: IManifest;
+    period: IPeriod;
+    representation: IRepresentation;
+}, initialWantedTime: number, playbackObserver: IReadOnlyPlaybackObserver<IRepresentationStreamPlaybackObservation>, fastSwitchThreshold: number | undefined, bufferGoal: number, maxBufferSize: number, segmentSink: SegmentSink): IBufferStatus;

package/dist/commonjs/core/stream/representation/utils/get_buffer_status.js

@@ -42,7 +42,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var config_1 = require("../../../../config");
 var is_null_or_undefined_1 = require("../../../../utils/is_null_or_undefined");
-var segment_buffers_1 = require("../../../segment_buffers");
+var segment_sinks_1 = require("../../../segment_sinks");
 var check_for_discontinuity_1 = require("./check_for_discontinuity");
 var get_needed_segments_1 = require("./get_needed_segments");
 var get_segment_priority_1 = require("./get_segment_priority");
@@ -59,10 +59,10 @@ var get_segment_priority_1 = require("./get_segment_priority");
  * @param {number|undefined} fastSwitchThreshold
  * @param {number} bufferGoal
  * @param {number} maxBufferSize
- * @param {Object} segmentBuffer
+ * @param {Object} segmentSink
  * @returns {Object}
  */
-function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer) {
+function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentSink) {
     var _a, _b, _c;
     var representation = content.representation;
     var isPaused = (_b = (_a = playbackObserver.getIsPaused()) !== null && _a !== void 0 ? _a : playbackObserver.getReference().getValue().paused.pending) !== null && _b !== void 0 ? _b : playbackObserver.getReference().getValue().paused.last;
@@ -70,7 +70,8 @@ function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitc
     var askedStart = initialWantedTime;
     if (isPaused === undefined ||
         playbackRate === undefined ||
-        (isPaused || playbackRate <= 0)) {
+        isPaused ||
+        playbackRate <= 0) {
         askedStart -= 0.1;
     }
     var neededRange = getRangeOfNeededSegments(content, askedStart, bufferGoal);
@@ -78,24 +79,34 @@ function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitc
     /**
      * Every segment awaiting an "SignalSegmentComplete" operation, which
      * indicates that a completely-loaded segment is still being pushed to the
-     * SegmentBuffer.
+     * SegmentSink.
      */
-    var segmentsBeingPushed = segmentBuffer.getPendingOperations()
+    var segmentsBeingPushed = segmentSink
+        .getPendingOperations()
         .filter(function (operation) {
-        return operation.type === segment_buffers_1.SegmentBufferOperation.SignalSegmentComplete;
-    }).map(function (operation) { return operation.value; });
+        return operation.type === segment_sinks_1.SegmentSinkOperation.SignalSegmentComplete;
+    })
+        .map(function (operation) { return operation.value; });
     /** Data on every segments buffered around `neededRange`. */
-    var bufferedSegments = getPlayableBufferedSegments({ start: Math.max(neededRange.start - 0.5, 0),
-        end: neededRange.end + 0.5 }, segmentBuffer.getLastKnownInventory());
+    var bufferedSegments = getPlayableBufferedSegments({ start: Math.max(neededRange.start - 0.5, 0), end: neededRange.end + 0.5 }, segmentSink.getLastKnownInventory());
     var currentPlaybackTime = playbackObserver.getCurrentTime();
     if (currentPlaybackTime === undefined) {
         // We're in a WebWorker, just consider the last known position
         currentPlaybackTime = playbackObserver.getReference().getValue().position.getWanted();
     }
     /** Callback allowing to retrieve a segment's history in the buffer. */
-    var getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
+    var getBufferedHistory = segmentSink.getSegmentHistory.bind(segmentSink);
     /** List of segments we will need to download. */
-    var _d = (0, get_needed_segments_1.default)({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), segmentsToLoad = _d.segmentsToLoad, segmentsOnHold = _d.segmentsOnHold, isBufferFull = _d.isBufferFull;
+    var _d = (0, get_needed_segments_1.default)({
+        content: content,
+        bufferedSegments: bufferedSegments,
+        currentPlaybackTime: currentPlaybackTime,
+        fastSwitchThreshold: fastSwitchThreshold,
+        getBufferedHistory: getBufferedHistory,
+        neededRange: neededRange,
+        segmentsBeingPushed: segmentsBeingPushed,
+        maxBufferSize: maxBufferSize,
+    }), segmentsToLoad = _d.segmentsToLoad, segmentsOnHold = _d.segmentsOnHold, isBufferFull = _d.isBufferFull;
     var prioritizedNeededSegments = segmentsToLoad.map(function (segment) { return ({
         priority: (0, get_segment_priority_1.default)(segment.time, askedStart),
         segment: segment,
@@ -118,17 +129,25 @@ function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitc
         nextSegmentStart = Math.min.apply(Math, __spreadArray([], __read(segmentsBeingPushed.map(function (info) { return info.segment.time; })), false));
     }
     if (segmentsOnHold.length > 0) {
-        nextSegmentStart = nextSegmentStart !== null ?
-            Math.min(nextSegmentStart, segmentsOnHold[0].time) :
-            segmentsOnHold[0].time;
+        nextSegmentStart =
+            nextSegmentStart !== null
+                ? Math.min(nextSegmentStart, segmentsOnHold[0].time)
+                : segmentsOnHold[0].time;
     }
     if (prioritizedNeededSegments.length > 0) {
-        nextSegmentStart = nextSegmentStart !== null ?
-            Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time) :
-            prioritizedNeededSegments[0].segment.time;
+        nextSegmentStart =
+            nextSegmentStart !== null
+                ? Math.min(nextSegmentStart, prioritizedNeededSegments[0].segment.time)
+                : prioritizedNeededSegments[0].segment.time;
     }
     var imminentDiscontinuity = (0, check_for_discontinuity_1.default)(content, neededRange, nextSegmentStart, hasFinishedLoading, bufferedSegments);
-    return { imminentDiscontinuity: imminentDiscontinuity, hasFinishedLoading: hasFinishedLoading, neededSegments: prioritizedNeededSegments, isBufferFull: isBufferFull, shouldRefreshManifest: shouldRefreshManifest };
+    return {
+        imminentDiscontinuity: imminentDiscontinuity,
+        hasFinishedLoading: hasFinishedLoading,
+        neededSegments: prioritizedNeededSegments,
+        isBufferFull: isBufferFull,
+        shouldRefreshManifest: shouldRefreshManifest,
+    };
 }
 exports.default = getBufferStatus;
 /**
@@ -153,7 +172,7 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
     // avoid ending the last Period - and by extension the content - with a
     // segment which isn't the last one.
     if (!(0, is_null_or_undefined_1.default)(lastIndexPosition) &&
-        segment_buffers_1.default.isNative(content.adaptation.type) &&
+        segment_sinks_1.default.isNative(content.adaptation.type) &&
         initialWantedTime >= lastIndexPosition &&
         representationIndex.isInitialized() &&
         !representationIndex.isStillAwaitingFutureSegments() &&
@@ -185,8 +204,11 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
         // downloaded the last segments and have nothing left to do: full.
         hasReachedPeriodEnd = wantedEndPosition >= lastIndexPosition;
     }
-    return { start: Math.max(wantedStartPosition, period.start),
-        end: Math.min(wantedEndPosition, (_a = period.end) !== null && _a !== void 0 ? _a : Infinity), hasReachedPeriodEnd: hasReachedPeriodEnd };
+    return {
+        start: Math.max(wantedStartPosition, period.start),
+        end: Math.min(wantedEndPosition, (_a = period.end) !== null && _a !== void 0 ? _a : Infinity),
+        hasReachedPeriodEnd: hasReachedPeriodEnd,
+    };
 }
 /**
  * Returns `true` if the given Period is both:
@@ -201,9 +223,9 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
 function isPeriodTheCurrentAndLastOne(manifest, period, time) {
     var _a;
     var nextPeriod = manifest.getPeriodAfter(period);
-    return period.containsTime(time, nextPeriod) &&
+    return (period.containsTime(time, nextPeriod) &&
         manifest.isLastPeriodKnown &&
-        period.id === ((_a = manifest.periods[manifest.periods.length - 1]) === null || _a === void 0 ? void 0 : _a.id);
+        period.id === ((_a = manifest.periods[manifest.periods.length - 1]) === null || _a === void 0 ? void 0 : _a.id));
 }
 /**
  * From the given SegmentInventory, filters the "playable" (in a supported codec
@@ -226,11 +248,10 @@ function getPlayableBufferedSegments(neededRange, segmentInventory) {
             representation.decipherable !== false &&
             representation.isSupported !== false) {
             var inventorySegment = eltInventory.infos.segment;
-            var eltInventoryStart = inventorySegment.time /
-                inventorySegment.timescale;
-            var eltInventoryEnd = !inventorySegment.complete ?
-                eltInventory.end :
-                eltInventoryStart + inventorySegment.duration / inventorySegment.timescale;
+            var eltInventoryStart = inventorySegment.time / inventorySegment.timescale;
+            var eltInventoryEnd = !inventorySegment.complete
+                ? eltInventory.end
+                : eltInventoryStart + inventorySegment.duration / inventorySegment.timescale;
             if ((eltInventoryEnd > minEnd && eltInventoryStart < maxStart) ||
                 (eltInventory.end > minEnd && eltInventory.start < maxStart)) {
                 overlappingChunks.unshift(eltInventory);

package/dist/commonjs/core/stream/representation/utils/get_needed_segments.d.ts

@@ -13,14 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../../manifest";
-import { IBufferedChunk, ICompleteSegmentInfo } from "../../../segment_buffers";
-import { IBufferedHistoryEntry, IChunkContext } from "../../../segment_buffers/inventory";
+import type { IManifest, IAdaptation, ISegment, IPeriod, IRepresentation } from "../../../../manifest";
+import type { IBufferedChunk, ICompleteSegmentInfo, IBufferedHistoryEntry, IChunkContext } from "../../../segment_sinks";
 interface IContentContext {
-    adaptation: Adaptation;
-    manifest: Manifest;
-    period: Period;
-    representation: Representation;
+    adaptation: IAdaptation;
+    manifest: IManifest;
+    period: IPeriod;
+    representation: IRepresentation;
 }
 /** Arguments for `getNeededSegments`. */
 export interface IGetNeededSegmentsArguments {