rx-player 3.33.4-dev.2024083000 → 3.33.4

package/dist/_esm5.processed/core/stream/orchestrator/get_time_ranges_for_content.d.ts

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Adaptation, Period, Representation } from "../../../manifest";
-import { IRange } from "../../../utils/ranges";
-import { SegmentBuffer } from "../../segment_buffers";
+import type { Adaptation, Period, Representation } from "../../../manifest";
+import type { IRange } from "../../../utils/ranges";
+import type { SegmentBuffer } from "../../segment_buffers";
 /**
  * Returns the buffered ranges which hold the given content.
  * Returns the whole buffered ranges if some of it is unknown.

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

@@ -31,9 +31,9 @@ export default function getTimeRangesForContent(segmentBuffer, contents) {
     var _loop_1 = function (i) {
         var chunk = inventory[i];
         var hasContent = contents.some(function (content) {
-            return chunk.infos.period.id === content.period.id &&
+            return (chunk.infos.period.id === content.period.id &&
                 chunk.infos.adaptation.id === content.adaptation.id &&
-                chunk.infos.representation.id === content.representation.id;
+                chunk.infos.representation.id === content.representation.id);
         });
         if (hasContent) {
             var bufferedStart = chunk.bufferedStart, bufferedEnd = chunk.bufferedEnd;

package/dist/_esm5.processed/core/stream/orchestrator/index.d.ts

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import StreamOrchestrator, { INeedsMediaSourceReloadPayload, IStreamOrchestratorCallbacks, IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation } from "./stream_orchestrator";
+import type { INeedsMediaSourceReloadPayload, IStreamOrchestratorCallbacks, IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation } from "./stream_orchestrator";
+import StreamOrchestrator from "./stream_orchestrator";
 export default StreamOrchestrator;
-export { INeedsMediaSourceReloadPayload, IStreamOrchestratorCallbacks, IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation, };
+export type { INeedsMediaSourceReloadPayload, IStreamOrchestratorCallbacks, IStreamOrchestratorOptions, IStreamOrchestratorPlaybackObservation, };

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.d.ts

@@ -13,14 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import Manifest, { Period } from "../../../manifest";
-import { IReadOnlySharedReference } from "../../../utils/reference";
-import { CancellationSignal } from "../../../utils/task_canceller";
-import { IRepresentationEstimator } from "../../adaptive";
+import type { Period } from "../../../manifest";
+import type Manifest from "../../../manifest";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { IRepresentationEstimator } from "../../adaptive";
 import type { IReadOnlyPlaybackObserver } from "../../api";
-import { SegmentFetcherCreator } from "../../fetchers";
-import SegmentBuffersStore, { IBufferType } from "../../segment_buffers";
-import { IPeriodStreamCallbacks, IPeriodStreamOptions, IPeriodStreamPlaybackObservation } from "../period";
+import type { SegmentFetcherCreator } from "../../fetchers";
+import type { IBufferType } from "../../segment_buffers";
+import type SegmentBuffersStore from "../../segment_buffers";
+import type { IPeriodStreamCallbacks, IPeriodStreamOptions, IPeriodStreamPlaybackObservation } from "../period";
 /**
  * Create and manage the various "Streams" needed for the content to
  * play:

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

@@ -73,11 +73,11 @@ import nextTick from "next-tick";
 import config from "../../../config";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
-import { createMappedReference, } from "../../../utils/reference";
+import { createMappedReference } from "../../../utils/reference";
 import SortedList from "../../../utils/sorted_list";
 import TaskCanceller from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
-import { BufferGarbageCollector, } from "../../segment_buffers";
+import { BufferGarbageCollector } from "../../segment_buffers";
 import PeriodStream from "../period";
 import getTimeRangesForContent from "./get_time_ranges_for_content";
 /**
@@ -134,14 +134,16 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         var defaultMaxBehind = (_a = MAXIMUM_MAX_BUFFER_BEHIND[bufferType]) !== null && _a !== void 0 ? _a : Infinity;
         var maxAheadHigherBound = (_b = MAXIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _b !== void 0 ? _b : Infinity;
         return function (gcCancelSignal) {
-            BufferGarbageCollector({ segmentBuffer: segmentBuffer, playbackObserver: playbackObserver, maxBufferBehind: createMappedReference(maxBufferBehind, function (val) {
-                    return Math.min(val, defaultMaxBehind);
-                }, gcCancelSignal),
+            BufferGarbageCollector({
+                segmentBuffer: segmentBuffer,
+                playbackObserver: playbackObserver,
+                maxBufferBehind: createMappedReference(maxBufferBehind, function (val) { return Math.min(val, defaultMaxBehind); }, gcCancelSignal),
                 maxBufferAhead: createMappedReference(maxBufferAhead, function (val) {
                     var _a;
                     var lowerBound = Math.max(val, (_a = MINIMUM_MAX_BUFFER_AHEAD[bufferType]) !== null && _a !== void 0 ? _a : 0);
                     return Math.min(lowerBound, maxAheadHigherBound);
-                }, gcCancelSignal) }, gcCancelSignal);
+                }, gcCancelSignal),
+            }, gcCancelSignal);
         };
     });
     // Create automatically the right `PeriodStream` for every possible types
@@ -214,10 +216,11 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                     // Only reload the MediaSource when the more immediately required
                     // Period is the one asking for it
                     var firstPeriod = periodList.head();
-                    if (firstPeriod === undefined ||
-                        firstPeriod.id !== payload.period.id) {
-                        callbacks.lockedStream({ bufferType: payload.bufferType,
-                            period: payload.period });
+                    if (firstPeriod === undefined || firstPeriod.id !== payload.period.id) {
+                        callbacks.lockedStream({
+                            bufferType: payload.bufferType,
+                            period: payload.period,
+                        });
                     }
                     else {
                         callbacks.needsMediaSourceReload({
@@ -249,12 +252,11 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         function isOutOfPeriodList(time) {
             var head = periodList.head();
             var last = periodList.last();
-            if (head == null || last == null) { // if no period
+            if (head == null || last == null) {
+                // if no period
                 return true;
             }
-            return head.start > time ||
-                (last.end == null ? Infinity :
-                    last.end) < time;
+            return head.start > time || (last.end == null ? Infinity : last.end) < time;
         }
         /**
          * React to a Manifest's decipherability updates.
@@ -268,8 +270,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                     switch (_c.label) {
                         case 0:
                             segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
-                            ofCurrentType = updates
-                                .filter(function (update) { return update.adaptation.type === bufferType; });
+                            ofCurrentType = updates.filter(function (update) { return update.adaptation.type === bufferType; });
                             if (
                             // No update concerns the current type of data
                             ofCurrentType.length === 0 ||
@@ -281,12 +282,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                                 return [2 /*return*/];
                             }
                             segmentBuffer = segmentBufferStatus.value;
-                            resettedContent = ofCurrentType.filter(function (update) {
-                                return update.representation.decipherable === undefined;
-                            });
-                            undecipherableContent = ofCurrentType.filter(function (update) {
-                                return update.representation.decipherable === false;
-                            });
+                            resettedContent = ofCurrentType.filter(function (update) { return update.representation.decipherable === undefined; });
+                            undecipherableContent = ofCurrentType.filter(function (update) { return update.representation.decipherable === false; });
                             undecipherableRanges = getTimeRangesForContent(segmentBuffer, undecipherableContent);
                             rangesToRemove = getTimeRangesForContent(segmentBuffer, resettedContent);
                             // First close all Stream currently active so they don't continue to
@@ -409,12 +406,25 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 }
                 log.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, (_c = position.pending) !== null && _c !== void 0 ? _c : position.last, basePeriod.end);
                 stopListeningObservations();
-                consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,
-                    period: basePeriod });
+                consecutivePeriodStreamCb.periodStreamCleared({
+                    type: bufferType,
+                    period: basePeriod,
+                });
                 currentStreamCanceller.cancel();
             }
         }, { clearSignal: cancelSignal, includeLastObservation: true });
-        var periodStreamArgs = { bufferType: bufferType, content: { manifest: manifest, period: basePeriod }, garbageCollectors: garbageCollectors, maxVideoBufferSize: maxVideoBufferSize, segmentFetcherCreator: segmentFetcherCreator, segmentBuffersStore: segmentBuffersStore, options: options, playbackObserver: playbackObserver, representationEstimator: representationEstimator, wantedBufferAhead: wantedBufferAhead };
+        var periodStreamArgs = {
+            bufferType: bufferType,
+            content: { manifest: manifest, period: basePeriod },
+            garbageCollectors: garbageCollectors,
+            maxVideoBufferSize: maxVideoBufferSize,
+            segmentFetcherCreator: segmentFetcherCreator,
+            segmentBuffersStore: segmentBuffersStore,
+            options: options,
+            playbackObserver: playbackObserver,
+            representationEstimator: representationEstimator,
+            wantedBufferAhead: wantedBufferAhead,
+        };
         var periodStreamCallbacks = __assign(__assign({}, consecutivePeriodStreamCb), { streamStatusUpdate: function (value) {
                 if (value.hasFinishedLoading) {
                     var nextPeriod = manifest.getPeriodAfter(basePeriod);
@@ -426,8 +436,10 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 else if (nextStreamInfo !== null) {
                     // current Stream is active, destroy next Stream if created
                     log.info("Stream: Destroying next PeriodStream due to current one being active", bufferType, nextStreamInfo.period.start);
-                    consecutivePeriodStreamCb
-                        .periodStreamCleared({ type: bufferType, period: nextStreamInfo.period });
+                    consecutivePeriodStreamCb.periodStreamCleared({
+                        type: bufferType,
+                        period: nextStreamInfo.period,
+                    });
                     nextStreamInfo.canceller.cancel();
                     nextStreamInfo = null;
                 }
@@ -451,14 +463,15 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                     return;
                 }
                 log.warn("Stream: Creating next `PeriodStream` while one was already created.", bufferType, nextPeriod.id, nextStreamInfo.period.id);
-                consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,
-                    period: nextStreamInfo.period });
+                consecutivePeriodStreamCb.periodStreamCleared({
+                    type: bufferType,
+                    period: nextStreamInfo.period,
+                });
                 nextStreamInfo.canceller.cancel();
             }
             var nextStreamCanceller = new TaskCanceller();
             nextStreamCanceller.linkToSignal(cancelSignal);
-            nextStreamInfo = { canceller: nextStreamCanceller,
-                period: nextPeriod };
+            nextStreamInfo = { canceller: nextStreamCanceller, period: nextPeriod };
             manageConsecutivePeriodStreams(bufferType, nextPeriod, consecutivePeriodStreamCb, nextStreamInfo.canceller.signal);
         }
     }
@@ -480,7 +493,7 @@ function needsFlushingAfterClean(observation, cleanedRanges) {
     // the corresponding ranges, without seeking or re-switching playback
     // direction which is expected to lead to a low-level flush anyway.
     // There's a 5 seconds security, just to be sure.
-    return observation.speed >= 0 ?
-        cleanedRanges[cleanedRanges.length - 1].end >= curPos - 5 :
-        cleanedRanges[0].start <= curPos + 5;
+    return observation.speed >= 0
+        ? cleanedRanges[cleanedRanges.length - 1].end >= curPos - 5
+        : cleanedRanges[0].start <= curPos + 5;
 }

package/dist/_esm5.processed/core/stream/period/period_stream.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 { IPeriodStreamArguments, IPeriodStreamCallbacks } from "./types";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { IPeriodStreamArguments, IPeriodStreamCallbacks } from "./types";
 /**
  * Create a single PeriodStream:
  *   - Lazily create (or reuse) a SegmentBuffer for the given type.
@@ -46,4 +46,4 @@ import { IPeriodStreamArguments, IPeriodStreamCallbacks } from "./types";
  * triggered, to immediately stop all operations the `PeriodStream` is
  * doing.
  */
-export default function PeriodStream({ bufferType, content, garbageCollectors, playbackObserver, representationEstimator, segmentFetcherCreator, segmentBuffersStore, options, wantedBufferAhead, maxVideoBufferSize }: IPeriodStreamArguments, callbacks: IPeriodStreamCallbacks, parentCancelSignal: CancellationSignal): void;
+export default function PeriodStream({ bufferType, content, garbageCollectors, playbackObserver, representationEstimator, segmentFetcherCreator, segmentBuffersStore, options, wantedBufferAhead, maxVideoBufferSize, }: IPeriodStreamArguments, callbacks: IPeriodStreamCallbacks, parentCancelSignal: CancellationSignal): void;

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

@@ -62,12 +62,12 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import nextTick from "next-tick";
 import config from "../../../config";
-import { formatError, MediaError, } from "../../../errors";
+import { formatError, MediaError } from "../../../errors";
 import log from "../../../log";
 import objectAssign from "../../../utils/object_assign";
 import { getLeftSizeOfRange } from "../../../utils/ranges";
 import SharedReference from "../../../utils/reference";
-import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
+import TaskCanceller, { CancellationError } from "../../../utils/task_canceller";
 import SegmentBuffersStore from "../../segment_buffers";
 import AdaptationStream from "../adaptation";
 import getAdaptationSwitchStrategy from "./utils/get_adaptation_switch_strategy";
@@ -134,6 +134,7 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         currentStreamCanceller === null || currentStreamCanceller === void 0 ? void 0 : currentStreamCanceller.cancel(); // Cancel oreviously created stream if one
                         currentStreamCanceller = streamCanceller;
                         if (!(adaptation === null)) return [3 /*break*/, 7];
+                        // Current type is disabled for that Period
                         log.info("Stream: Set no ".concat(bufferType, " Adaptation. P:"), period.start);
                         segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
                         if (!(segmentBufferStatus.type === "initialized")) return [3 /*break*/, 5];
@@ -169,10 +170,13 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         return [2 /*return*/, createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period: period }, callbacks, streamCanceller.signal)];
                     case 7:
                         DELTA_POSITION_AFTER_RELOAD = config.getCurrent().DELTA_POSITION_AFTER_RELOAD;
-                        relativePosAfterSwitch = isFirstAdaptationSwitch ? 0 :
-                            bufferType === "audio" ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.audio :
-                                bufferType === "video" ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.video :
-                                    DELTA_POSITION_AFTER_RELOAD.trackSwitch.other;
+                        relativePosAfterSwitch = isFirstAdaptationSwitch
+                            ? 0
+                            : bufferType === "audio"
+                                ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.audio
+                                : bufferType === "video"
+                                    ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.video
+                                    : DELTA_POSITION_AFTER_RELOAD.trackSwitch.other;
                         isFirstAdaptationSwitch = false;
                         if (SegmentBuffersStore.isNative(bufferType) &&
                             segmentBuffersStore.getStatus(bufferType).type === "disabled") {
@@ -185,7 +189,10 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                         }
                         readyState = playbackObserver.getReadyState();
                         segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation, options);
-                        playbackInfos = { currentTime: playbackObserver.getCurrentTime(), readyState: readyState };
+                        playbackInfos = {
+                            currentTime: playbackObserver.getCurrentTime(),
+                            readyState: readyState,
+                        };
                         strategy = getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, playbackInfos, options);
                         if (strategy.type === "needs-reload") {
                             return [2 /*return*/, askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal)];
@@ -242,7 +249,16 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
     function createAdaptationStream(adaptation, segmentBuffer, cancelSignal) {
         var manifest = content.manifest;
         var adaptationPlaybackObserver = createAdaptationStreamPlaybackObserver(playbackObserver, segmentBuffer);
-        AdaptationStream({ content: { manifest: manifest, period: period, adaptation: adaptation }, options: options, playbackObserver: adaptationPlaybackObserver, representationEstimator: representationEstimator, segmentBuffer: segmentBuffer, segmentFetcherCreator: segmentFetcherCreator, wantedBufferAhead: wantedBufferAhead, maxVideoBufferSize: maxVideoBufferSize }, __assign(__assign({}, callbacks), { error: onAdaptationStreamError }), cancelSignal);
+        AdaptationStream({
+            content: { manifest: manifest, period: period, adaptation: adaptation },
+            options: options,
+            playbackObserver: adaptationPlaybackObserver,
+            representationEstimator: representationEstimator,
+            segmentBuffer: segmentBuffer,
+            segmentFetcherCreator: segmentFetcherCreator,
+            wantedBufferAhead: wantedBufferAhead,
+            maxVideoBufferSize: maxVideoBufferSize,
+        }, __assign(__assign({}, callbacks), { error: onAdaptationStreamError }), cancelSignal);
         function onAdaptationStreamError(error) {
             // Stream linked to a non-native media buffer should not impact the
             // stability of the player. ie: if a text buffer sends an error, we want
@@ -291,7 +307,12 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
         // the same event that triggers the playback observation to be emitted.
         nextTick(function () {
             playbackObserver.listen(function () {
-                callbacks.waitingMediaSourceReload({ bufferType: bufferType, period: period, timeOffset: timeOffset, stayInPeriod: stayInPeriod });
+                callbacks.waitingMediaSourceReload({
+                    bufferType: bufferType,
+                    period: period,
+                    timeOffset: timeOffset,
+                    stayInPeriod: stayInPeriod,
+                });
             }, { includeLastObservation: true, clearSignal: cancelSignal });
         });
     }
@@ -322,8 +343,7 @@ function createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation,
 function getFirstDeclaredMimeType(adaptation) {
     var representations = adaptation.getPlayableRepresentations();
     if (representations.length === 0) {
-        var noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " +
-            adaptation.type + " Adaptation can be played", { adaptation: adaptation });
+        var noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " + adaptation.type + " Adaptation can be played", { adaptation: adaptation });
         throw noRepErr;
     }
     return representations[0].getMimeTypeString();
@@ -367,18 +387,31 @@ function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, segment
 function createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, content, callbacks, cancelSignal) {
     var period = content.period;
     var hasFinishedLoading = false;
-    wantedBufferAhead.onUpdate(sendStatus, { emitCurrentValue: false, clearSignal: cancelSignal });
-    playbackObserver.listen(sendStatus, { includeLastObservation: false, clearSignal: cancelSignal });
+    wantedBufferAhead.onUpdate(sendStatus, {
+        emitCurrentValue: false,
+        clearSignal: cancelSignal,
+    });
+    playbackObserver.listen(sendStatus, {
+        includeLastObservation: false,
+        clearSignal: cancelSignal,
+    });
     sendStatus();
     function sendStatus() {
         var observation = playbackObserver.getReference().getValue();
         var wba = wantedBufferAhead.getValue();
         var position = observation.position.last;
         if (period.end !== undefined && position + wba >= period.end) {
-            log.debug("Stream: full \"empty\" AdaptationStream", bufferType);
+            log.debug('Stream: full "empty" AdaptationStream', bufferType);
             hasFinishedLoading = true;
         }
-        callbacks.streamStatusUpdate({ period: period, bufferType: bufferType, position: position, imminentDiscontinuity: null,
-            isEmptyStream: true, hasFinishedLoading: hasFinishedLoading, neededSegments: [] });
+        callbacks.streamStatusUpdate({
+            period: period,
+            bufferType: bufferType,
+            position: position,
+            imminentDiscontinuity: null,
+            isEmptyStream: true,
+            hasFinishedLoading: hasFinishedLoading,
+            neededSegments: [],
+        });
     }
 }

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

@@ -1,14 +1,17 @@
-import Manifest, { Adaptation, Period } from "../../../manifest";
-import { IAudioTrackSwitchingMode } from "../../../public_types";
-import SharedReference, { IReadOnlySharedReference } from "../../../utils/reference";
-import { CancellationSignal } from "../../../utils/task_canceller";
-import WeakMapMemory from "../../../utils/weak_map_memory";
-import { IRepresentationEstimator } from "../../adaptive";
-import { IReadOnlyPlaybackObserver } from "../../api";
-import { SegmentFetcherCreator } from "../../fetchers";
-import SegmentBuffersStore, { IBufferType, ITextTrackSegmentBufferOptions, SegmentBuffer } from "../../segment_buffers";
-import { IAdaptationStreamCallbacks, IAdaptationStreamOptions, IPausedPlaybackObservation } from "../adaptation";
-import { IPositionPlaybackObservation } from "../representation";
+import type { Adaptation, Period } from "../../../manifest";
+import type Manifest from "../../../manifest";
+import type { IAudioTrackSwitchingMode } from "../../../public_types";
+import type { IReadOnlySharedReference } from "../../../utils/reference";
+import type SharedReference from "../../../utils/reference";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type WeakMapMemory from "../../../utils/weak_map_memory";
+import type { IRepresentationEstimator } from "../../adaptive";
+import type { IReadOnlyPlaybackObserver } from "../../api";
+import type { SegmentFetcherCreator } from "../../fetchers";
+import type { IBufferType, ITextTrackSegmentBufferOptions, SegmentBuffer } from "../../segment_buffers";
+import type SegmentBuffersStore from "../../segment_buffers";
+import type { IAdaptationStreamCallbacks, IAdaptationStreamOptions, IPausedPlaybackObservation } from "../adaptation";
+import type { IPositionPlaybackObservation } from "../representation";
 /** Callbacks called by the `AdaptationStream` on various events. */
 export interface IPeriodStreamCallbacks extends IAdaptationStreamCallbacks<unknown> {
     /**
@@ -107,4 +110,4 @@ export type IPeriodStreamOptions = IAdaptationStreamOptions & {
     /** Options specific to the text SegmentBuffer. */
     textTrackOptions?: ITextTrackSegmentBufferOptions;
 };
-export { IAudioTrackSwitchingMode } from "../../../public_types";
+export type { IAudioTrackSwitchingMode } from "../../../public_types";

package/dist/_esm5.processed/core/stream/period/utils/get_adaptation_switch_strategy.d.ts

@@ -13,39 +13,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Adaptation, Period } from "../../../../manifest";
-import { IAudioTrackSwitchingMode } from "../../../../public_types";
-import { SegmentBuffer } from "../../../segment_buffers";
+import type { Adaptation, Period } from "../../../../manifest";
+import type { IAudioTrackSwitchingMode } from "../../../../public_types";
+import type { SegmentBuffer } from "../../../segment_buffers";
 export type IAdaptationSwitchStrategy = 
 /** Do nothing special. */
 {
     type: "continue";
     value: undefined;
-} | 
+}
 /**
  * Clean the given ranges of time from the buffer, preferably avoiding time
  * around the current position to continue playback smoothly.
  */
-{
+ | {
     type: "clean-buffer";
     value: Array<{
         start: number;
         end: number;
     }>;
-} | 
+}
 /**
  * Clean the given ranges of time from the buffer and try to flush the buffer
  * so that it is taken in account directly.
  */
-{
+ | {
     type: "flush-buffer";
     value: Array<{
         start: number;
         end: number;
     }>;
-} | 
+}
 /** Reload completely the media buffers. */
-{
+ | {
     type: "needs-reload";
     value: undefined;
 };

package/dist/_esm5.processed/core/stream/period/utils/get_adaptation_switch_strategy.js

@@ -37,8 +37,7 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
     }
     var bufferedRanges = convertToRanges(buffered);
     var start = period.start;
-    var end = period.end == null ? Infinity :
-        period.end;
+    var end = period.end == null ? Infinity : period.end;
     var intersection = keepRangeIntersection(bufferedRanges, [{ start: start, end: end }]);
     if (intersection.length === 0) {
         return { type: "continue", value: undefined };
@@ -46,8 +45,9 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
     segmentBuffer.synchronizeInventory();
     var inventory = segmentBuffer.getInventory();
     // Continue if we have no other Adaptation buffered in the current Period
-    if (!inventory.some(function (buf) { return buf.infos.period.id === period.id &&
-        buf.infos.adaptation.id !== adaptation.id; })) {
+    if (!inventory.some(function (buf) {
+        return buf.infos.period.id === period.id && buf.infos.adaptation.id !== adaptation.id;
+    })) {
         return { type: "continue", value: undefined };
     }
     /** Data already in the right Adaptation */
@@ -69,15 +69,16 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
         // We're playing the current Period
         isTimeInRange({ start: start, end: end }, currentTime) &&
         // There is data for the current position or the codecs are differents
-        (playbackInfo.readyState > 1 || !adaptation.getPlayableRepresentations()
-            .some(function (rep) { var _a; return areCodecsCompatible(rep.getMimeTypeString(), (_a = segmentBuffer.codec) !== null && _a !== void 0 ? _a : ""); })) &&
+        (playbackInfo.readyState > 1 ||
+            !adaptation
+                .getPlayableRepresentations()
+                .some(function (rep) { var _a; return areCodecsCompatible(rep.getMimeTypeString(), (_a = segmentBuffer.codec) !== null && _a !== void 0 ? _a : ""); })) &&
         // We're not playing the current wanted video Adaptation
         !isTimeInRanges(adaptationInBuffer, currentTime)) {
         return { type: "needs-reload", value: undefined };
     }
     // From here, clean-up data from the previous Adaptation, if one
-    var shouldFlush = adaptation.type === "audio" &&
-        audioTrackSwitchingMode === "direct";
+    var shouldFlush = adaptation.type === "audio" && audioTrackSwitchingMode === "direct";
     var rangesToExclude = [];
     // First, we don't want to accidentally remove some segments from the previous
     // Period (which overlap a little with this one)
@@ -85,12 +86,11 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
     var lastSegmentBefore = getLastSegmentBeforePeriod(inventory, period);
     if (lastSegmentBefore !== null &&
         (lastSegmentBefore.bufferedEnd === undefined ||
-            period.start - lastSegmentBefore.bufferedEnd < 1)) // Close to Period's start
-     {
+            period.start - lastSegmentBefore.bufferedEnd < 1)) {
+        // Close to Period's start
         // Exclude data close to the period's start to avoid cleaning
         // to much
-        rangesToExclude.push({ start: 0,
-            end: period.start + 1 });
+        rangesToExclude.push({ start: 0, end: period.start + 1 });
     }
     // Next, exclude data around current position to avoid decoding issues
     var bufferType = adaptation.type;
@@ -105,8 +105,10 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
         paddingAfter = 0;
     }
     if (!shouldFlush) {
-        rangesToExclude.push({ start: currentTime - paddingBefore,
-            end: currentTime + paddingAfter });
+        rangesToExclude.push({
+            start: currentTime - paddingBefore,
+            end: currentTime + paddingAfter,
+        });
     }
     // Now remove possible small range from the end if there is a segment from the
     // next Period
@@ -115,18 +117,18 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
         var firstSegmentAfter = getFirstSegmentAfterPeriod(inventory, period);
         if (firstSegmentAfter !== null &&
             (firstSegmentAfter.bufferedStart === undefined ||
-                (firstSegmentAfter.bufferedStart - period.end) < 1)) // Close to Period's end
-         {
-            rangesToExclude.push({ start: period.end - 1,
-                end: Number.MAX_VALUE });
+                firstSegmentAfter.bufferedStart - period.end < 1)) {
+            // Close to Period's end
+            rangesToExclude.push({ start: period.end - 1, end: Number.MAX_VALUE });
         }
     }
     var toRemove = excludeFromRanges(unwantedRange, rangesToExclude);
     if (toRemove.length === 0) {
         return { type: "continue", value: undefined };
     }
-    return shouldFlush ? { type: "flush-buffer", value: toRemove } :
-        { type: "clean-buffer", value: toRemove };
+    return shouldFlush
+        ? { type: "flush-buffer", value: toRemove }
+        : { type: "clean-buffer", value: toRemove };
 }
 /**
  * Returns `true` if at least one codec of the Representations in the given
@@ -136,9 +138,9 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
  * @returns {boolean}
  */
 function hasCompatibleCodec(adaptation, segmentBufferCodec) {
-    return adaptation.getPlayableRepresentations().some(function (rep) {
-        return areCodecsCompatible(rep.getMimeTypeString(), segmentBufferCodec);
-    });
+    return adaptation
+        .getPlayableRepresentations()
+        .some(function (rep) { return areCodecsCompatible(rep.getMimeTypeString(), segmentBufferCodec); });
 }
 /**
  * Returns buffered ranges of what we know correspond to the given `adaptation`
@@ -178,8 +180,7 @@ function getLastSegmentBeforePeriod(inventory, period) {
             return null;
         }
     }
-    return inventory.length > 0 ? inventory[inventory.length - 1] :
-        null;
+    return inventory.length > 0 ? inventory[inventory.length - 1] : null;
 }
 /**
  * Returns the first segment in the `inventory` which is linked to a Period

package/dist/_esm5.processed/core/stream/representation/representation_stream.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 { IRepresentationStreamArguments, IRepresentationStreamCallbacks } from "./types";
+import type { CancellationSignal } from "../../../utils/task_canceller";
+import type { IRepresentationStreamArguments, IRepresentationStreamCallbacks } from "./types";
 /**
  * Perform the logic to load the right segments for the given Representation and
  * push them to the given `SegmentBuffer`.
@@ -50,4 +50,4 @@ import { IRepresentationStreamArguments, IRepresentationStreamCallbacks } from "
  * triggered, to immediately stop all operations the `RepresentationStream` is
  * doing.
  */
-export default function RepresentationStream<TSegmentDataType>({ content, options, playbackObserver, segmentBuffer, segmentFetcher, terminate }: IRepresentationStreamArguments<TSegmentDataType>, callbacks: IRepresentationStreamCallbacks<TSegmentDataType>, parentCancelSignal: CancellationSignal): void;
+export default function RepresentationStream<TSegmentDataType>({ content, options, playbackObserver, segmentBuffer, segmentFetcher, terminate, }: IRepresentationStreamArguments<TSegmentDataType>, callbacks: IRepresentationStreamCallbacks<TSegmentDataType>, parentCancelSignal: CancellationSignal): void;