rx-player 3.33.4-dev.2024083000 → 3.33.4

package/dist/_esm5.processed/core/stream/representation/representation_stream.js

@@ -25,7 +25,7 @@ import config from "../../../config";
 import log from "../../../log";
 import objectAssign from "../../../utils/object_assign";
 import SharedReference from "../../../utils/reference";
-import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
+import TaskCanceller, { CancellationError } from "../../../utils/task_canceller";
 import DownloadingQueue from "./utils/downloading_queue";
 import getBufferStatus from "./utils/get_buffer_status";
 import getSegmentPriority from "./utils/get_segment_priority";
@@ -116,7 +116,8 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
         var encryptionData = representation.getEncryptionData(drmSystemId);
         // If some key ids are not known yet, it may be safer to wait for this initialization
         // segment to be loaded first
-        if (encryptionData.length > 0 && encryptionData.every(function (e) { return e.keyIds !== undefined; })) {
+        if (encryptionData.length > 0 &&
+            encryptionData.every(function (e) { return e.keyIds !== undefined; })) {
             hasSentEncryptionData = true;
             callbacks.encryptionDataEncountered(encryptionData.map(function (d) { return objectAssign({ content: content }, d); }));
             if (globalCanceller.isUsed()) {
@@ -151,7 +152,8 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
         }
     });
     downloadingQueue.addEventListener("fullyLoadedSegment", function (segment) {
-        segmentBuffer.endOfSegment(objectAssign({ segment: segment }, content), globalCanceller.signal)
+        segmentBuffer
+            .endOfSegment(objectAssign({ segment: segment }, content), globalCanceller.signal)
             .catch(onFatalBufferError);
     });
     downloadingQueue.start();
@@ -204,21 +206,27 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
             }
             else {
                 var wantedStart = (_b = observation.position.pending) !== null && _b !== void 0 ? _b : observation.position.last;
-                neededInitSegment = { segment: initSegmentState.segment,
-                    priority: getSegmentPriority(period.start, wantedStart) };
+                neededInitSegment = {
+                    segment: initSegmentState.segment,
+                    priority: getSegmentPriority(period.start, wantedStart),
+                };
             }
         }
         else if (neededSegments.length > 0 &&
             !initSegmentState.isLoaded &&
             initSegmentState.segment !== null) {
             var initSegmentPriority = neededSegments[0].priority;
-            neededInitSegment = { segment: initSegmentState.segment,
-                priority: initSegmentPriority };
+            neededInitSegment = {
+                segment: initSegmentState.segment,
+                priority: initSegmentPriority,
+            };
         }
         var terminateVal = terminate.getValue();
         if (terminateVal === null) {
-            lastSegmentQueue.setValue({ initSegment: neededInitSegment,
-                segmentQueue: neededSegments });
+            lastSegmentQueue.setValue({
+                initSegment: neededInitSegment,
+                segmentQueue: neededSegments,
+            });
         }
         else if (terminateVal.urgent) {
             log.debug("Stream: Urgent switch, terminate now.", bufferType);
@@ -238,13 +246,11 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
             var currentSegmentRequest = downloadingQueue.getRequestedMediaSegment();
             var nextQueue = currentSegmentRequest === null ||
                 mostNeededSegment === undefined ||
-                currentSegmentRequest.id !== mostNeededSegment.segment.id ?
-                [] :
-                [mostNeededSegment];
-            var nextInit = initSegmentRequest === null ? null :
-                neededInitSegment;
-            lastSegmentQueue.setValue({ initSegment: nextInit,
-                segmentQueue: nextQueue });
+                currentSegmentRequest.id !== mostNeededSegment.segment.id
+                ? []
+                : [mostNeededSegment];
+            var nextInit = initSegmentRequest === null ? null : neededInitSegment;
+            lastSegmentQueue.setValue({ initSegment: nextInit, segmentQueue: nextQueue });
             if (nextQueue.length === 0 && nextInit === null) {
                 log.debug("Stream: No request left, terminate", bufferType);
                 lastSegmentQueue.finish();
@@ -253,10 +259,15 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
                 return;
             }
         }
-        callbacks.streamStatusUpdate({ period: period, position: observation.position.last, bufferType: bufferType, imminentDiscontinuity: status.imminentDiscontinuity,
+        callbacks.streamStatusUpdate({
+            period: period,
+            position: observation.position.last,
+            bufferType: bufferType,
+            imminentDiscontinuity: status.imminentDiscontinuity,
             isEmptyStream: false,
             hasFinishedLoading: status.hasFinishedLoading,
-            neededSegments: status.neededSegments });
+            neededSegments: status.neededSegments,
+        });
         if (segmentsLoadingCanceller.signal.isCancelled()) {
             return; // previous callback has stopped loading operations by side-effect
         }
@@ -264,7 +275,8 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
         if (status.isBufferFull) {
             var gcedPosition = Math.max(0, initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
             if (gcedPosition > 0) {
-                segmentBuffer.removeBuffer(0, gcedPosition, globalCanceller.signal)
+                segmentBuffer
+                    .removeBuffer(0, gcedPosition, globalCanceller.signal)
                     .catch(onFatalBufferError);
             }
         }
@@ -301,8 +313,14 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
                 var initSegmentUniqueId = representation.uniqueId;
                 initSegmentState.uniqueId = initSegmentUniqueId;
                 segmentBuffer.declareInitSegment(initSegmentUniqueId, evt.initializationData);
-                pushInitSegment({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, segment: evt.segment,
-                    segmentData: evt.initializationData, segmentBuffer: segmentBuffer }, globalCanceller.signal)
+                pushInitSegment({
+                    playbackObserver: playbackObserver,
+                    content: content,
+                    initSegmentUniqueId: initSegmentUniqueId,
+                    segment: evt.segment,
+                    segmentData: evt.initializationData,
+                    segmentBuffer: segmentBuffer,
+                }, globalCanceller.signal)
                     .then(function (result) {
                     if (result !== null) {
                         callbacks.addedSegment(result);
@@ -340,8 +358,14 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
                 }
             }
             var initSegmentUniqueId = initSegmentState.uniqueId;
-            pushMediaSegment({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, parsedSegment: evt,
-                segment: evt.segment, segmentBuffer: segmentBuffer }, globalCanceller.signal)
+            pushMediaSegment({
+                playbackObserver: playbackObserver,
+                content: content,
+                initSegmentUniqueId: initSegmentUniqueId,
+                parsedSegment: evt,
+                segment: evt.segment,
+                segmentBuffer: segmentBuffer,
+            }, globalCanceller.signal)
                 .then(function (result) {
                 if (result !== null) {
                     callbacks.addedSegment(result);

package/dist/_esm5.processed/core/stream/representation/types.d.ts

@@ -1,11 +1,12 @@
-import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
-import { IEMSG } from "../../../parsers/containers/isobmff";
-import { IPlayerError } from "../../../public_types";
-import { IReadOnlySharedReference } from "../../../utils/reference";
-import { IReadOnlyPlaybackObserver } from "../../api";
-import { IContentProtection } from "../../decrypt";
-import { IPrioritizedSegmentFetcher } from "../../fetchers";
-import { IBufferType, SegmentBuffer } from "../../segment_buffers";
+import type { Adaptation, ISegment, Period, Representation } from "../../../manifest";
+import type Manifest from "../../../manifest";
+import type { IEMSG } from "../../../parsers/containers/isobmff";
+import type { IPlayerError } from "../../../public_types";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type { IReadOnlyPlaybackObserver } from "../../api";
+import type { IContentProtection } from "../../decrypt";
+import type { IPrioritizedSegmentFetcher } from "../../fetchers";
+import type { IBufferType, SegmentBuffer } from "../../segment_buffers";
 /** Callbacks called by the `RepresentationStream` on various events. */
 export interface IRepresentationStreamCallbacks<TSegmentDataType> {
     /**

package/dist/_esm5.processed/core/stream/representation/utils/append_segment_to_buffer.d.ts

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CancellationSignal } from "../../../../utils/task_canceller";
-import { IReadOnlyPlaybackObserver } from "../../../api";
-import { IInsertedChunkInfos, IPushChunkInfos, SegmentBuffer } from "../../../segment_buffers";
-import { IRepresentationStreamPlaybackObservation } from "../types";
+import type { CancellationSignal } from "../../../../utils/task_canceller";
+import type { IReadOnlyPlaybackObserver } from "../../../api";
+import type { IInsertedChunkInfos, IPushChunkInfos, SegmentBuffer } from "../../../segment_buffers";
+import type { IRepresentationStreamPlaybackObservation } from "../types";
 /**
  * Append a segment to the given segmentBuffer.
  * If it leads to a QuotaExceededError, try to run our custom range

package/dist/_esm5.processed/core/stream/representation/utils/append_segment_to_buffer.js

@@ -85,10 +85,12 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                     }
                     else if (!(appendError_1 instanceof Error) ||
                         appendError_1.name !== "QuotaExceededError") {
-                        reason = appendError_1 instanceof Error ?
-                            appendError_1.toString() :
-                            "An unknown error happened when pushing content";
-                        throw new MediaError("BUFFER_APPEND_ERROR", reason, { adaptation: dataInfos.inventoryInfos.adaptation });
+                        reason = appendError_1 instanceof Error
+                            ? appendError_1.toString()
+                            : "An unknown error happened when pushing content";
+                        throw new MediaError("BUFFER_APPEND_ERROR", reason, {
+                            adaptation: dataInfos.inventoryInfos.adaptation,
+                        });
                     }
                     position = playbackObserver.getReference().getValue().position;
                     currentPos = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
@@ -110,9 +112,10 @@ export default function appendSegmentToBuffer(playbackObserver, segmentBuffer, d
                     return [3 /*break*/, 8];
                 case 7:
                     err2_1 = _b.sent();
-                    reason = err2_1 instanceof Error ? err2_1.toString() :
-                        "Could not clean the buffer";
-                    throw new MediaError("BUFFER_FULL_ERROR", reason, { adaptation: dataInfos.inventoryInfos.adaptation });
+                    reason = err2_1 instanceof Error ? err2_1.toString() : "Could not clean the buffer";
+                    throw new MediaError("BUFFER_FULL_ERROR", reason, {
+                        adaptation: dataInfos.inventoryInfos.adaptation,
+                    });
                 case 8: return [3 /*break*/, 9];
                 case 9: return [2 /*return*/];
             }

package/dist/_esm5.processed/core/stream/representation/utils/check_for_discontinuity.d.ts

@@ -13,9 +13,10 @@
  * 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 { Adaptation, Period, Representation } from "../../../../manifest";
+import type Manifest from "../../../../manifest";
+import type { IBufferedChunk } from "../../../segment_buffers";
+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.

package/dist/_esm5.processed/core/stream/representation/utils/check_for_discontinuity.js

@@ -49,7 +49,8 @@ export default function checkForDiscontinuity(content, checkedRange, nextSegment
     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 &&
@@ -57,11 +58,9 @@ export default function checkForDiscontinuity(content, checkedRange, nextSegment
                 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;
@@ -77,12 +76,12 @@ export default function checkForDiscontinuity(content, checkedRange, nextSegment
             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.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);
@@ -93,8 +92,8 @@ export default function checkForDiscontinuity(content, checkedRange, nextSegment
         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;
@@ -106,8 +105,10 @@ export default function checkForDiscontinuity(content, checkedRange, nextSegment
     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
@@ -118,8 +119,7 @@ export default function checkForDiscontinuity(content, checkedRange, nextSegment
                 if (lastSegment.bufferedEnd !== undefined &&
                     lastSegment.bufferedEnd < period.end) {
                     log.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 };
                 }
             }
         }
@@ -136,11 +136,9 @@ export default function checkForDiscontinuity(content, checkedRange, nextSegment
             }
             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/_esm5.processed/core/stream/representation/utils/downloading_queue.d.ts

@@ -13,13 +13,14 @@
  * 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 { Adaptation, ISegment, Period, Representation } from "../../../../manifest";
+import type Manifest 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.
  *

package/dist/_esm5.processed/core/stream/representation/utils/downloading_queue.js

@@ -87,8 +87,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.
@@ -96,8 +95,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
@@ -195,9 +193,9 @@ var DownloadingQueue = /** @class */ (function (_super) {
                 return;
             }
             var canceller = new TaskCanceller();
-            var unlinkCanceller = _this._currentCanceller === null ?
-                noop :
-                canceller.linkToSignal(_this._currentCanceller.signal);
+            var unlinkCanceller = _this._currentCanceller === null
+                ? noop
+                : canceller.linkToSignal(_this._currentCanceller.signal);
             var segment = startingSegment.segment, priority = startingSegment.priority;
             var context = objectAssign({ segment: segment }, _this._content);
             /**
@@ -296,7 +294,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();
@@ -331,9 +331,9 @@ var DownloadingQueue = /** @class */ (function (_super) {
             return;
         }
         var canceller = new TaskCanceller();
-        var unlinkCanceller = this._currentCanceller === null ?
-            noop :
-            canceller.linkToSignal(this._currentCanceller.signal);
+        var unlinkCanceller = this._currentCanceller === null
+            ? noop
+            : canceller.linkToSignal(this._currentCanceller.signal);
         var segment = queuedInitSegment.segment, priority = queuedInitSegment.priority;
         var context = objectAssign({ segment: segment }, this._content);
         /**

package/dist/_esm5.processed/core/stream/representation/utils/force_garbage_collection.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { CancellationSignal } from "../../../../utils/task_canceller";
-import { SegmentBuffer } from "../../../segment_buffers";
+import type { CancellationSignal } from "../../../../utils/task_canceller";
+import type { SegmentBuffer } from "../../../segment_buffers";
 /**
  * Run the garbage collector.
  *

package/dist/_esm5.processed/core/stream/representation/utils/force_garbage_collection.js

@@ -82,8 +82,7 @@ export default function forceGarbageCollection(currentPosition, bufferingQueue,
                         log.debug("Stream: GC cleaning", cleanedupRanges.map(function (_a) {
                             var start = _a.start, end = _a.end;
                             return "start: ".concat(start, " - end ").concat(end);
-                        })
-                            .join(", "));
+                        }).join(", "));
                     }
                     _i = 0, cleanedupRanges_1 = cleanedupRanges;
                     _a.label = 1;
@@ -124,26 +123,25 @@ function selectGCedRanges(position, buffered, gcGap) {
     // current time and respect the gcGap
     for (var i = 0; i < outerRanges.length; i++) {
         var outerRange = outerRanges[i];
-        if ((position - gcGap > outerRange.end) || (position + gcGap < outerRange.start)) {
+        if (position - gcGap > outerRange.end || position + gcGap < outerRange.start) {
             cleanedupRanges.push(outerRange);
         }
     }
     // try to clean up some space in the current range
     if (innerRange !== null) {
         if (log.hasLevel("DEBUG")) {
-            log.debug("Stream: GC removing part of inner range", cleanedupRanges.map(function (_a) {
+            log.debug("Stream: GC removing part of inner range", cleanedupRanges
+                .map(function (_a) {
                 var start = _a.start, end = _a.end;
                 return "start: ".concat(start, " - end ").concat(end);
             })
                 .join(", "));
         }
         if (position - gcGap > innerRange.start) {
-            cleanedupRanges.push({ start: innerRange.start,
-                end: position - gcGap });
+            cleanedupRanges.push({ start: innerRange.start, end: position - gcGap });
         }
         if (position + gcGap < innerRange.end) {
-            cleanedupRanges.push({ start: position + gcGap,
-                end: innerRange.end });
+            cleanedupRanges.push({ start: position + gcGap, end: innerRange.end });
         }
     }
     return cleanedupRanges;

package/dist/_esm5.processed/core/stream/representation/utils/get_buffer_status.d.ts

@@ -13,10 +13,11 @@
  * 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, IQueuedSegment } from "../types";
+import type { Adaptation, Period, Representation } from "../../../../manifest";
+import type Manifest from "../../../../manifest";
+import type { IReadOnlyPlaybackObserver } from "../../../api";
+import type { SegmentBuffer } from "../../../segment_buffers";
+import type { IBufferDiscontinuity, IQueuedSegment } from "../types";
 /** Analysis of the current buffer's status. */
 export interface IBufferStatus {
     /**

package/dist/_esm5.processed/core/stream/representation/utils/get_buffer_status.js

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
-import SegmentBuffersStore, { SegmentBufferOperation, } from "../../../segment_buffers";
+import SegmentBuffersStore, { SegmentBufferOperation } from "../../../segment_buffers";
 import checkForDiscontinuity from "./check_for_discontinuity";
 import getNeededSegments from "./get_needed_segments";
 import getSegmentPriority from "./get_segment_priority";
@@ -37,27 +37,37 @@ import getSegmentPriority from "./get_segment_priority";
 export default function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer) {
     segmentBuffer.synchronizeInventory();
     var representation = content.representation;
-    var askedStart = playbackObserver.getIsPaused() ||
-        playbackObserver.getPlaybackRate() <= 0 ?
-        initialWantedTime - 0.1 :
-        initialWantedTime;
+    var askedStart = playbackObserver.getIsPaused() || playbackObserver.getPlaybackRate() <= 0
+        ? initialWantedTime - 0.1
+        : initialWantedTime;
     var neededRange = getRangeOfNeededSegments(content, askedStart, bufferGoal);
     var shouldRefreshManifest = representation.index.shouldRefresh(neededRange.start, neededRange.end);
     /**
      * Every segment awaiting an "EndOfSegment" operation, which indicates that a
      * completely-loaded segment is still being pushed to the SegmentBuffer.
      */
-    var segmentsBeingPushed = segmentBuffer.getPendingOperations()
+    var segmentsBeingPushed = segmentBuffer
+        .getPendingOperations()
         .filter(function (operation) {
         return operation.type === SegmentBufferOperation.EndOfSegment;
-    }).map(function (operation) { return operation.value; });
+    })
+        .map(function (operation) { return operation.value; });
     /** Data on every segments buffered around `neededRange`. */
     var bufferedSegments = segmentBuffer.getInventory();
     var currentPlaybackTime = playbackObserver.getCurrentTime();
     /** Callback allowing to retrieve a segment's history in the buffer. */
     var getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
     /** List of segments we will need to download. */
-    var _a = getNeededSegments({ content: content, bufferedSegments: bufferedSegments, currentPlaybackTime: currentPlaybackTime, fastSwitchThreshold: fastSwitchThreshold, getBufferedHistory: getBufferedHistory, neededRange: neededRange, segmentsBeingPushed: segmentsBeingPushed, maxBufferSize: maxBufferSize }), segmentsToLoad = _a.segmentsToLoad, segmentsOnHold = _a.segmentsOnHold, isBufferFull = _a.isBufferFull;
+    var _a = getNeededSegments({
+        content: content,
+        bufferedSegments: bufferedSegments,
+        currentPlaybackTime: currentPlaybackTime,
+        fastSwitchThreshold: fastSwitchThreshold,
+        getBufferedHistory: getBufferedHistory,
+        neededRange: neededRange,
+        segmentsBeingPushed: segmentsBeingPushed,
+        maxBufferSize: maxBufferSize,
+    }), segmentsToLoad = _a.segmentsToLoad, segmentsOnHold = _a.segmentsOnHold, isBufferFull = _a.isBufferFull;
     var prioritizedNeededSegments = segmentsToLoad.map(function (segment) { return ({
         priority: getSegmentPriority(segment.time, askedStart),
         segment: segment,
@@ -80,17 +90,25 @@ export default function getBufferStatus(content, initialWantedTime, playbackObse
         nextSegmentStart = Math.min.apply(Math, segmentsBeingPushed.map(function (info) { return info.segment.time; }));
     }
     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 = checkForDiscontinuity(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,
+    };
 }
 /**
  * Returns both the time range of segments that should be loaded (from a
@@ -146,8 +164,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:
@@ -162,7 +183,7 @@ 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));
 }

package/dist/_esm5.processed/core/stream/representation/utils/get_needed_segments.d.ts

@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../../manifest";
-import { IBufferedChunk, IEndOfSegmentInfos } from "../../../segment_buffers";
-import { IBufferedHistoryEntry, IChunkContext } from "../../../segment_buffers/inventory";
+import type { Adaptation, ISegment, Period, Representation } from "../../../../manifest";
+import type Manifest from "../../../../manifest";
+import type { IBufferedChunk, IEndOfSegmentInfos } from "../../../segment_buffers";
+import type { IBufferedHistoryEntry, IChunkContext } from "../../../segment_buffers/inventory";
 interface IContentContext {
     adaptation: Adaptation;
     manifest: Manifest;