rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,12 +14,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../../config";
-import isNullOrUndefined from "../../../../utils/is_null_or_undefined";
-import SegmentBuffersStore, { SegmentBufferOperation, } from "../../../segment_buffers";
-import checkForDiscontinuity from "./check_for_discontinuity";
-import getNeededSegments from "./get_needed_segments";
-import getSegmentPriority from "./get_segment_priority";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../../config");
+const is_null_or_undefined_1 = require("../../../../utils/is_null_or_undefined");
+const segment_buffers_1 = require("../../../segment_buffers");
+const check_for_discontinuity_1 = require("./check_for_discontinuity");
+const get_needed_segments_1 = require("./get_needed_segments");
+const get_segment_priority_1 = require("./get_segment_priority");
 /**
  * Checks on the current buffered data for the given type and Period
  * and returns what should be done to fill the buffer according to the buffer
@@ -35,40 +37,45 @@ import getSegmentPriority from "./get_segment_priority";
  * @param {Object} segmentBuffer
  * @returns {Object}
  */
-export default function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer) {
+function getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold, bufferGoal, maxBufferSize, segmentBuffer) {
     segmentBuffer.synchronizeInventory();
-    var representation = content.representation;
-    var askedStart = playbackObserver.getIsPaused() ||
+    const { representation } = content;
+    const 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);
+    const neededRange = getRangeOfNeededSegments(content, askedStart, bufferGoal);
+    const 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()
-        .filter(function (operation) {
-        return operation.type === SegmentBufferOperation.EndOfSegment;
-    }).map(function (operation) { return operation.value; });
+    const segmentsBeingPushed = segmentBuffer.getPendingOperations()
+        .filter((operation) => operation.type === segment_buffers_1.SegmentBufferOperation.EndOfSegment).map(operation => operation.value);
     /** Data on every segments buffered around `neededRange`. */
-    var bufferedSegments = getPlayableBufferedSegments({ start: Math.max(neededRange.start - 0.5, 0),
+    const bufferedSegments = getPlayableBufferedSegments({ start: Math.max(neededRange.start - 0.5, 0),
         end: neededRange.end + 0.5 }, segmentBuffer.getInventory());
-    var currentPlaybackTime = playbackObserver.getCurrentTime();
+    const currentPlaybackTime = playbackObserver.getCurrentTime();
     /** Callback allowing to retrieve a segment's history in the buffer. */
-    var getBufferedHistory = segmentBuffer.getSegmentHistory.bind(segmentBuffer);
+    const 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 prioritizedNeededSegments = segmentsToLoad.map(function (segment) { return ({
-        priority: getSegmentPriority(segment.time, askedStart),
-        segment: segment,
-    }); });
+    const { segmentsToLoad, segmentsOnHold, isBufferFull } = (0, get_needed_segments_1.default)({ content,
+        bufferedSegments,
+        currentPlaybackTime,
+        fastSwitchThreshold,
+        getBufferedHistory,
+        neededRange,
+        segmentsBeingPushed,
+        maxBufferSize });
+    const prioritizedNeededSegments = segmentsToLoad.map((segment) => ({
+        priority: (0, get_segment_priority_1.default)(segment.time, askedStart),
+        segment,
+    }));
     /**
      * `true` if the current `RepresentationStream` has loaded all the
      * needed segments for this Representation until the end of the Period.
      */
-    var hasFinishedLoading = representation.index.isInitialized() &&
+    const hasFinishedLoading = representation.index.isInitialized() &&
         representation.index.isFinished() &&
         neededRange.hasReachedPeriodEnd &&
         prioritizedNeededSegments.length === 0 &&
@@ -77,9 +84,9 @@ export default function getBufferStatus(content, initialWantedTime, playbackObse
      * Start time in seconds of the next available not-yet pushed segment.
      * `null` if no segment is wanted for the current wanted range.
      */
-    var nextSegmentStart = null;
+    let nextSegmentStart = null;
     if (segmentsBeingPushed.length > 0) {
-        nextSegmentStart = Math.min.apply(Math, segmentsBeingPushed.map(function (info) { return info.segment.time; }));
+        nextSegmentStart = Math.min(...segmentsBeingPushed.map(info => info.segment.time));
     }
     if (segmentsOnHold.length > 0) {
         nextSegmentStart = nextSegmentStart !== null ?
@@ -91,9 +98,14 @@ export default function getBufferStatus(content, initialWantedTime, playbackObse
             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 };
+    const imminentDiscontinuity = (0, check_for_discontinuity_1.default)(content, neededRange, nextSegmentStart, hasFinishedLoading, bufferedSegments);
+    return { imminentDiscontinuity,
+        hasFinishedLoading,
+        neededSegments: prioritizedNeededSegments,
+        isBufferFull,
+        shouldRefreshManifest };
 }
+exports.default = getBufferStatus;
 /**
  * Returns both the time range of segments that should be loaded (from a
  * starting position to an ending position) and whether the end of the Period is
@@ -105,18 +117,18 @@ export default function getBufferStatus(content, initialWantedTime, playbackObse
  */
 function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
     var _a;
-    var wantedStartPosition;
-    var manifest = content.manifest, period = content.period, representation = content.representation;
-    var lastIndexPosition = representation.index.getLastAvailablePosition();
-    var representationIndex = representation.index;
+    let wantedStartPosition;
+    const { manifest, period, representation } = content;
+    const lastIndexPosition = representation.index.getLastAvailablePosition();
+    const representationIndex = representation.index;
     // There is an exception for when the current initially wanted time is already
     // after the last position with segments AND when we're playing the absolute
     // last Period in the Manifest.
     // In that case, we want to actually request at least the last segment to
     // avoid ending the last Period - and by extension the content - with a
     // segment which isn't the last one.
-    if (!isNullOrUndefined(lastIndexPosition) &&
-        SegmentBuffersStore.isNative(content.adaptation.type) &&
+    if (!(0, is_null_or_undefined_1.default)(lastIndexPosition) &&
+        segment_buffers_1.default.isNative(content.adaptation.type) &&
         initialWantedTime >= lastIndexPosition &&
         representationIndex.isInitialized() &&
         representationIndex.isFinished() &&
@@ -126,8 +138,8 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
     else {
         wantedStartPosition = initialWantedTime - 0.1;
     }
-    var wantedEndPosition = wantedStartPosition + bufferGoal;
-    var hasReachedPeriodEnd;
+    const wantedEndPosition = wantedStartPosition + bufferGoal;
+    let hasReachedPeriodEnd;
     if (!representation.index.isInitialized() ||
         !representation.index.isFinished() ||
         period.end === undefined) {
@@ -149,7 +161,8 @@ function getRangeOfNeededSegments(content, initialWantedTime, bufferGoal) {
         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 };
+        end: Math.min(wantedEndPosition, (_a = period.end) !== null && _a !== void 0 ? _a : Infinity),
+        hasReachedPeriodEnd };
 }
 /**
  * Returns `true` if the given Period is both:
@@ -176,21 +189,21 @@ function isPeriodTheCurrentAndLastOne(manifest, period, time) {
  * @returns {Array.<Object>}
  */
 function getPlayableBufferedSegments(neededRange, segmentInventory) {
-    var MINIMUM_SEGMENT_SIZE = config.getCurrent().MINIMUM_SEGMENT_SIZE;
-    var segmentRoundingError = Math.max(1 / 60, MINIMUM_SEGMENT_SIZE);
-    var minEnd = neededRange.start + segmentRoundingError;
-    var maxStart = neededRange.end - segmentRoundingError;
-    var overlappingChunks = [];
-    for (var i = segmentInventory.length - 1; i >= 0; i--) {
-        var eltInventory = segmentInventory[i];
-        var representation = eltInventory.infos.representation;
+    const { MINIMUM_SEGMENT_SIZE } = config_1.default.getCurrent();
+    const segmentRoundingError = Math.max(1 / 60, MINIMUM_SEGMENT_SIZE);
+    const minEnd = neededRange.start + segmentRoundingError;
+    const maxStart = neededRange.end - segmentRoundingError;
+    const overlappingChunks = [];
+    for (let i = segmentInventory.length - 1; i >= 0; i--) {
+        const eltInventory = segmentInventory[i];
+        const { representation } = eltInventory.infos;
         if (!eltInventory.partiallyPushed &&
             representation.decipherable !== false &&
             representation.isSupported) {
-            var inventorySegment = eltInventory.infos.segment;
-            var eltInventoryStart = inventorySegment.time /
+            const inventorySegment = eltInventory.infos.segment;
+            const eltInventoryStart = inventorySegment.time /
                 inventorySegment.timescale;
-            var eltInventoryEnd = !inventorySegment.complete ?
+            const eltInventoryEnd = !inventorySegment.complete ?
                 eltInventory.end :
                 eltInventoryStart + inventorySegment.duration / inventorySegment.timescale;
             if ((eltInventoryEnd > minEnd && eltInventoryStart < maxStart) ||

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,10 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../../config";
-import log from "../../../../log";
-import { areSameContent, } from "../../../../manifest";
-import objectAssign from "../../../../utils/object_assign";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../../config");
+const log_1 = require("../../../../log");
+const manifest_1 = require("../../../../manifest");
+const object_assign_1 = require("../../../../utils/object_assign");
 /**
  * Return the list of segments that can currently be downloaded to fill holes
  * in the buffer in the given range, including already-pushed segments currently
@@ -27,59 +29,58 @@ import objectAssign from "../../../../utils/object_assign";
  * @param {Object} args
  * @returns {Array.<Object>}
  */
-export default function getNeededSegments(_a) {
-    var bufferedSegments = _a.bufferedSegments, content = _a.content, currentPlaybackTime = _a.currentPlaybackTime, fastSwitchThreshold = _a.fastSwitchThreshold, getBufferedHistory = _a.getBufferedHistory, neededRange = _a.neededRange, segmentsBeingPushed = _a.segmentsBeingPushed, maxBufferSize = _a.maxBufferSize;
-    var adaptation = content.adaptation, representation = content.representation;
-    var availableBufferSize = getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxBufferSize);
-    var availableSegmentsForRange = representation.index
+function getNeededSegments({ bufferedSegments, content, currentPlaybackTime, fastSwitchThreshold, getBufferedHistory, neededRange, segmentsBeingPushed, maxBufferSize, }) {
+    const { adaptation, representation } = content;
+    let availableBufferSize = getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxBufferSize);
+    const availableSegmentsForRange = representation.index
         .getSegments(neededRange.start, neededRange.end - neededRange.start);
     // Remove from `bufferedSegments` any segments we would prefer to replace:
     //   - segments in the wrong track / bad quality
     //   - garbage-collected segments
-    var segmentsToKeep = bufferedSegments
-        .filter(function (bufferedSegment) { return !shouldContentBeReplaced(bufferedSegment.infos, content, currentPlaybackTime, fastSwitchThreshold); })
-        .filter(function (currentSeg, i, consideredSegments) {
-        var prevSeg = i === 0 ? null :
+    const segmentsToKeep = bufferedSegments
+        .filter((bufferedSegment) => !shouldContentBeReplaced(bufferedSegment.infos, content, currentPlaybackTime, fastSwitchThreshold))
+        .filter((currentSeg, i, consideredSegments) => {
+        const prevSeg = i === 0 ? null :
             consideredSegments[i - 1];
-        var nextSeg = i >= consideredSegments.length - 1 ? null :
+        const nextSeg = i >= consideredSegments.length - 1 ? null :
             consideredSegments[i + 1];
-        var lazySegmentHistory = null;
+        let lazySegmentHistory = null;
         if (doesStartSeemGarbageCollected(currentSeg, prevSeg, neededRange.start)) {
             lazySegmentHistory = getBufferedHistory(currentSeg.infos);
             if (shouldReloadSegmentGCedAtTheStart(lazySegmentHistory, currentSeg.bufferedStart)) {
                 return false;
             }
-            log.debug("Stream: skipping segment gc-ed at the start", currentSeg.start, currentSeg.bufferedStart);
+            log_1.default.debug("Stream: skipping segment gc-ed at the start", currentSeg.start, currentSeg.bufferedStart);
         }
         if (doesEndSeemGarbageCollected(currentSeg, nextSeg, neededRange.end)) {
             lazySegmentHistory = lazySegmentHistory !== null && lazySegmentHistory !== void 0 ? lazySegmentHistory : getBufferedHistory(currentSeg.infos);
             if (shouldReloadSegmentGCedAtTheEnd(lazySegmentHistory, currentSeg.bufferedEnd)) {
                 return false;
             }
-            log.debug("Stream: skipping segment gc-ed at the end", currentSeg.end, currentSeg.bufferedEnd);
+            log_1.default.debug("Stream: skipping segment gc-ed at the end", currentSeg.end, currentSeg.bufferedEnd);
         }
         return true;
     });
-    var _b = config.getCurrent(), MINIMUM_SEGMENT_SIZE = _b.MINIMUM_SEGMENT_SIZE, MIN_BUFFER_AHEAD = _b.MIN_BUFFER_AHEAD;
-    var shouldStopLoadingSegments = false;
+    const { MINIMUM_SEGMENT_SIZE, MIN_BUFFER_AHEAD } = config_1.default.getCurrent();
+    let shouldStopLoadingSegments = false;
     /**
      * Epsilon compensating for rounding errors when comparing the start and end
      * time of multiple segments.
      */
-    var ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
-    var isBufferFull = false;
-    var segmentsOnHold = [];
-    var segmentsToLoad = availableSegmentsForRange.filter(function (segment) {
-        var contentObject = objectAssign({ segment: segment }, content);
+    const ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
+    let isBufferFull = false;
+    const segmentsOnHold = [];
+    const segmentsToLoad = availableSegmentsForRange.filter(segment => {
+        const contentObject = (0, object_assign_1.default)({ segment }, content);
         // First, check that the segment is not already being pushed
         if (segmentsBeingPushed.length > 0) {
-            var isAlreadyBeingPushed = segmentsBeingPushed
-                .some(function (pendingSegment) { return areSameContent(contentObject, pendingSegment); });
+            const isAlreadyBeingPushed = segmentsBeingPushed
+                .some((pendingSegment) => (0, manifest_1.areSameContent)(contentObject, pendingSegment));
             if (isAlreadyBeingPushed) {
                 return false;
             }
         }
-        var duration = segment.duration, time = segment.time, end = segment.end;
+        const { duration, time, end } = segment;
         if (segment.isInit) {
             return true; // never skip initialization segments
         }
@@ -93,12 +94,12 @@ export default function getNeededSegments(_a) {
         // Check if the same segment from another Representation is not already
         // being pushed.
         if (segmentsBeingPushed.length > 0) {
-            var waitForPushedSegment = segmentsBeingPushed.some(function (pendingSegment) {
+            const waitForPushedSegment = segmentsBeingPushed.some((pendingSegment) => {
                 if (pendingSegment.period.id !== content.period.id ||
                     pendingSegment.adaptation.id !== content.adaptation.id) {
                     return false;
                 }
-                var oldSegment = pendingSegment.segment;
+                const { segment: oldSegment } = pendingSegment;
                 if ((oldSegment.time - ROUNDING_ERROR) > time) {
                     return false;
                 }
@@ -112,22 +113,22 @@ export default function getNeededSegments(_a) {
             }
         }
         // check if the segment is already downloaded
-        for (var i = 0; i < segmentsToKeep.length; i++) {
-            var completeSeg = segmentsToKeep[i];
-            var areFromSamePeriod = completeSeg.infos.period.id === content.period.id;
+        for (let i = 0; i < segmentsToKeep.length; i++) {
+            const completeSeg = segmentsToKeep[i];
+            const areFromSamePeriod = completeSeg.infos.period.id === content.period.id;
             // Check if content are from same period, as there can't be overlapping
             // periods, we should consider a segment as already downloaded if
             // it is from same period (but can be from different adaptation or
             // representation)
             if (areFromSamePeriod) {
-                var completeSegInfos = completeSeg.infos.segment;
+                const completeSegInfos = completeSeg.infos.segment;
                 if (time - completeSegInfos.time > -ROUNDING_ERROR &&
                     completeSegInfos.end - end > -ROUNDING_ERROR) {
                     return false; // already downloaded
                 }
             }
         }
-        var estimatedSegmentSize = (duration * content.representation.bitrate); // in bits
+        const estimatedSegmentSize = (duration * content.representation.bitrate); // in bits
         if (availableBufferSize - estimatedSegmentSize < 0) {
             isBufferFull = true;
             if (time > neededRange.start + MIN_BUFFER_AHEAD) {
@@ -137,13 +138,13 @@ export default function getNeededSegments(_a) {
             }
         }
         // check if the browser is not just garbage collecting it
-        var segmentHistory = getBufferedHistory(contentObject);
+        const segmentHistory = getBufferedHistory(contentObject);
         if (segmentHistory.length > 1) {
-            var lastTimeItWasPushed = segmentHistory[segmentHistory.length - 1];
-            var beforeLastTimeItWasPushed = segmentHistory[segmentHistory.length - 2];
+            const lastTimeItWasPushed = segmentHistory[segmentHistory.length - 1];
+            const beforeLastTimeItWasPushed = segmentHistory[segmentHistory.length - 2];
             if (lastTimeItWasPushed.buffered === null &&
                 beforeLastTimeItWasPushed.buffered === null) {
-                log.warn("Stream: Segment GCed multiple times in a row, ignoring it.", "If this happens a lot and lead to unpleasant experience, please " +
+                log_1.default.warn("Stream: Segment GCed multiple times in a row, ignoring it.", "If this happens a lot and lead to unpleasant experience, please " +
                     " check your device's available memory. If it's low when this message " +
                     "is emitted, you might want to update the RxPlayer's settings (" +
                     "`maxBufferAhead`, `maxVideoBufferSize` etc.) so less memory is used " +
@@ -153,12 +154,12 @@ export default function getNeededSegments(_a) {
             }
         }
         // check if there is an hole in place of the segment currently
-        for (var i = 0; i < segmentsToKeep.length; i++) {
-            var completeSeg = segmentsToKeep[i];
+        for (let i = 0; i < segmentsToKeep.length; i++) {
+            const completeSeg = segmentsToKeep[i];
             // For the first already-loaded segment, take the first one ending after
             // this one' s start
             if ((completeSeg.end + ROUNDING_ERROR) > time) {
-                var shouldLoad = completeSeg.start > time + ROUNDING_ERROR ||
+                const shouldLoad = completeSeg.start > time + ROUNDING_ERROR ||
                     getLastContiguousSegment(segmentsToKeep, i).end <
                         end - ROUNDING_ERROR;
                 if (shouldLoad) {
@@ -170,8 +171,9 @@ export default function getNeededSegments(_a) {
         availableBufferSize -= estimatedSegmentSize;
         return true;
     });
-    return { segmentsToLoad: segmentsToLoad, segmentsOnHold: segmentsOnHold, isBufferFull: isBufferFull };
+    return { segmentsToLoad, segmentsOnHold, isBufferFull };
 }
+exports.default = getNeededSegments;
 /**
  * Compute the estimated available buffer size in memory in kilobytes
  * @param bufferedSegments
@@ -180,15 +182,15 @@ export default function getNeededSegments(_a) {
  * @returns availableBufferSize in bits
  */
 function getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxVideoBufferSize) {
-    var availableBufferSize = maxVideoBufferSize * 8000; // in bits
-    availableBufferSize -= segmentsBeingPushed.reduce(function (size, segment) {
-        var bitrate = segment.representation.bitrate;
+    let availableBufferSize = maxVideoBufferSize * 8000; // in bits
+    availableBufferSize -= segmentsBeingPushed.reduce((size, segment) => {
+        const { bitrate } = segment.representation;
         // Not taking into account the fact that the segment
         // can still be generated and the duration not fully exact
-        var duration = segment.segment.duration;
+        const { duration } = segment.segment;
         return size + (bitrate * duration);
     }, 0);
-    return bufferedSegments.reduce(function (size, chunk) {
+    return bufferedSegments.reduce((size, chunk) => {
         if (chunk.chunkSize !== undefined) {
             return size - (chunk.chunkSize * 8); // in bits
         }
@@ -205,13 +207,13 @@ function getAvailableBufferSize(bufferedSegments, segmentsBeingPushed, maxVideoB
  * @returns {Object}
  */
 function getLastContiguousSegment(bufferedSegments, startIndex) {
-    var j = startIndex + 1;
-    var MINIMUM_SEGMENT_SIZE = config.getCurrent().MINIMUM_SEGMENT_SIZE;
+    let j = startIndex + 1;
+    const { MINIMUM_SEGMENT_SIZE } = config_1.default.getCurrent();
     /**
      * Epsilon compensating for rounding errors when comparing the start and end
      * time of multiple segments.
      */
-    var ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
+    const ROUNDING_ERROR = Math.min(1 / 60, MINIMUM_SEGMENT_SIZE);
     // go through all contiguous segments and take the last one
     while (j < bufferedSegments.length - 1 &&
         (bufferedSegments[j - 1].end + ROUNDING_ERROR) >
@@ -231,11 +233,11 @@ function getLastContiguousSegment(bufferedSegments, startIndex) {
  * @returns {boolean}
  */
 function shouldContentBeReplaced(oldContent, currentContent, currentPlaybackTime, fastSwitchThreshold) {
-    var CONTENT_REPLACEMENT_PADDING = config.getCurrent().CONTENT_REPLACEMENT_PADDING;
+    const { CONTENT_REPLACEMENT_PADDING } = config_1.default.getCurrent();
     if (oldContent.period.id !== currentContent.period.id) {
         return false; // keep segments from another Period by default.
     }
-    var segment = oldContent.segment;
+    const { segment } = oldContent;
     if (segment.time < (currentPlaybackTime + CONTENT_REPLACEMENT_PADDING)) {
         return false;
     }
@@ -255,11 +257,11 @@ function shouldContentBeReplaced(oldContent, currentContent, currentPlaybackTime
  * @returns {boolean}
  */
 function canFastSwitch(oldSegmentRepresentation, newSegmentRepresentation, fastSwitchThreshold) {
-    var oldContentBitrate = oldSegmentRepresentation.bitrate;
-    var BITRATE_REBUFFERING_RATIO = config.getCurrent().BITRATE_REBUFFERING_RATIO;
+    const oldContentBitrate = oldSegmentRepresentation.bitrate;
+    const { BITRATE_REBUFFERING_RATIO } = config_1.default.getCurrent();
     if (fastSwitchThreshold === undefined) {
         // only re-load comparatively-poor bitrates for the same Adaptation.
-        var bitrateCeil = oldContentBitrate * BITRATE_REBUFFERING_RATIO;
+        const bitrateCeil = oldContentBitrate * BITRATE_REBUFFERING_RATIO;
         return newSegmentRepresentation.bitrate > bitrateCeil;
     }
     return oldContentBitrate < fastSwitchThreshold &&
@@ -278,9 +280,9 @@ function canFastSwitch(oldSegmentRepresentation, newSegmentRepresentation, fastS
  * that time, we will return `false`.
  */
 function doesStartSeemGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
-    var MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT = config.getCurrent().MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT;
+    const { MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT } = config_1.default.getCurrent();
     if (currentSeg.bufferedStart === undefined) {
-        log.warn("Stream: Start of a segment unknown. " +
+        log_1.default.warn("Stream: Start of a segment unknown. " +
             "Assuming it is garbage collected by default.", currentSeg.start);
         return true;
     }
@@ -291,7 +293,7 @@ function doesStartSeemGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
     if (maximumStartTime < currentSeg.bufferedStart &&
         currentSeg.bufferedStart - currentSeg.start >
             MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT) {
-        log.info("Stream: The start of the wanted segment has been garbage collected", currentSeg.start, currentSeg.bufferedStart);
+        log_1.default.info("Stream: The start of the wanted segment has been garbage collected", currentSeg.start, currentSeg.bufferedStart);
         return true;
     }
     return false;
@@ -309,9 +311,9 @@ function doesStartSeemGarbageCollected(currentSeg, prevSeg, maximumStartTime) {
  * that time, we will return `false`.
  */
 function doesEndSeemGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
-    var MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT = config.getCurrent().MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT;
+    const { MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT } = config_1.default.getCurrent();
     if (currentSeg.bufferedEnd === undefined) {
-        log.warn("Stream: End of a segment unknown. " +
+        log_1.default.warn("Stream: End of a segment unknown. " +
             "Assuming it is garbage collected by default.", currentSeg.end);
         return true;
     }
@@ -321,7 +323,7 @@ function doesEndSeemGarbageCollected(currentSeg, nextSeg, minimumEndTime) {
     }
     if (minimumEndTime > currentSeg.bufferedEnd &&
         currentSeg.end - currentSeg.bufferedEnd > MAX_TIME_MISSING_FROM_COMPLETE_SEGMENT) {
-        log.info("Stream: The end of the wanted segment has been garbage collected", currentSeg.start, currentSeg.bufferedStart);
+        log_1.default.info("Stream: The end of the wanted segment has been garbage collected", currentSeg.start, currentSeg.bufferedStart);
         return true;
     }
     return false;
@@ -348,8 +350,8 @@ function shouldReloadSegmentGCedAtTheStart(segmentEntries, currentBufferedStart)
     if (segmentEntries.length < 2) {
         return true;
     }
-    var lastEntry = segmentEntries[segmentEntries.length - 1];
-    var lastBufferedStart = (_a = lastEntry.buffered) === null || _a === void 0 ? void 0 : _a.start;
+    const lastEntry = segmentEntries[segmentEntries.length - 1];
+    const lastBufferedStart = (_a = lastEntry.buffered) === null || _a === void 0 ? void 0 : _a.start;
     // If the current segment's buffered start is much higher than what it
     // initially was when we pushed it, the segment has a very high chance of
     // having been truly garbage-collected.
@@ -358,8 +360,8 @@ function shouldReloadSegmentGCedAtTheStart(segmentEntries, currentBufferedStart)
         currentBufferedStart - lastBufferedStart > 0.05) {
         return true;
     }
-    var prevEntry = segmentEntries[segmentEntries.length - 2];
-    var prevBufferedStart = (_b = prevEntry.buffered) === null || _b === void 0 ? void 0 : _b.start;
+    const prevEntry = segmentEntries[segmentEntries.length - 2];
+    const prevBufferedStart = (_b = prevEntry.buffered) === null || _b === void 0 ? void 0 : _b.start;
     if (prevBufferedStart === undefined || lastBufferedStart === undefined) {
         return true;
     }
@@ -397,8 +399,8 @@ function shouldReloadSegmentGCedAtTheEnd(segmentEntries, currentBufferedEnd) {
     if (segmentEntries.length < 2) {
         return true;
     }
-    var lastEntry = segmentEntries[segmentEntries.length - 1];
-    var lastBufferedEnd = (_a = lastEntry.buffered) === null || _a === void 0 ? void 0 : _a.end;
+    const lastEntry = segmentEntries[segmentEntries.length - 1];
+    const lastBufferedEnd = (_a = lastEntry.buffered) === null || _a === void 0 ? void 0 : _a.end;
     // If the current segment's buffered end is much lower than what it
     // initially was when we pushed it, the segment has a very high chance of
     // having been truly garbage-collected.
@@ -407,8 +409,8 @@ function shouldReloadSegmentGCedAtTheEnd(segmentEntries, currentBufferedEnd) {
         lastBufferedEnd - currentBufferedEnd > 0.05) {
         return true;
     }
-    var prevEntry = segmentEntries[segmentEntries.length - 2];
-    var prevBufferedEnd = (_b = prevEntry.buffered) === null || _b === void 0 ? void 0 : _b.end;
+    const prevEntry = segmentEntries[segmentEntries.length - 2];
+    const prevBufferedEnd = (_b = prevEntry.buffered) === null || _b === void 0 ? void 0 : _b.end;
     if (prevBufferedEnd === undefined || lastBufferedEnd === undefined) {
         return true;
     }

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,7 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../../config";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../../config");
 /**
  * Calculate the priority number for a given segment start time, in function of
  * the distance with the wanted starting timestamp.
@@ -26,13 +28,14 @@ import config from "../../../../config";
  * @param {Object} wantedStartTimestamp
  * @returns {number}
  */
-export default function getSegmentPriority(segmentTime, wantedStartTimestamp) {
-    var distance = segmentTime - wantedStartTimestamp;
-    var SEGMENT_PRIORITIES_STEPS = config.getCurrent().SEGMENT_PRIORITIES_STEPS;
-    for (var priority = 0; priority < SEGMENT_PRIORITIES_STEPS.length; priority++) {
+function getSegmentPriority(segmentTime, wantedStartTimestamp) {
+    const distance = segmentTime - wantedStartTimestamp;
+    const { SEGMENT_PRIORITIES_STEPS } = config_1.default.getCurrent();
+    for (let priority = 0; priority < SEGMENT_PRIORITIES_STEPS.length; priority++) {
         if (distance < SEGMENT_PRIORITIES_STEPS[priority]) {
             return priority;
         }
     }
     return SEGMENT_PRIORITIES_STEPS.length;
 }
+exports.default = getSegmentPriority;