rx-player 3.28.0-dev.2022063000 → 3.28.1-dev.2022083000

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/list.js

@@ -60,7 +60,7 @@ var ListRepresentationIndex = /** @class */ (function () {
     };
     /**
      * @param {Number} fromTime
-     * @param {Number} duration
+     * @param {Number} dur
      * @returns {Array.<Object>}
      */
     ListRepresentationIndex.prototype.getSegments = function (fromTime, dur) {
@@ -104,23 +104,45 @@ var ListRepresentationIndex = /** @class */ (function () {
      * Returns first position in this index, in seconds.
      * @returns {Number}
      */
-    ListRepresentationIndex.prototype.getFirstPosition = function () {
+    ListRepresentationIndex.prototype.getFirstAvailablePosition = function () {
         return this._periodStart;
     };
     /**
      * Returns last position in this index, in seconds.
      * @returns {Number}
      */
-    ListRepresentationIndex.prototype.getLastPosition = function () {
+    ListRepresentationIndex.prototype.getLastAvailablePosition = function () {
         var _a;
         var index = this._index;
         var duration = index.duration, list = index.list;
         return Math.min(((list.length * duration) / index.timescale) + this._periodStart, (_a = this._periodEnd) !== null && _a !== void 0 ? _a : Infinity);
     };
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    ListRepresentationIndex.prototype.getEnd = function () {
+        return this.getLastAvailablePosition();
+    };
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     *
+     * Always `false` in a `ListRepresentationIndex` because all segments should
+     * be directly available.
+     * @returns {boolean}
+     */
+    ListRepresentationIndex.prototype.awaitSegmentBetween = function () {
+        return false;
+    };
     /**
      * Returns true if a Segment returned by this index is still considered
      * available.
-     * @param {Object} segment
      * @returns {Boolean}
      */
     ListRepresentationIndex.prototype.isSegmentStillAvailable = function () {
@@ -133,12 +155,6 @@ var ListRepresentationIndex = /** @class */ (function () {
     ListRepresentationIndex.prototype.checkDiscontinuity = function () {
         return null;
     };
-    /**
-     * @returns {boolean}
-     */
-    ListRepresentationIndex.prototype.areSegmentsChronologicallyGenerated = function () {
-        return true;
-    };
     /**
      * SegmentList should not be updated.
      * @returns {Boolean}
@@ -164,9 +180,6 @@ var ListRepresentationIndex = /** @class */ (function () {
     ListRepresentationIndex.prototype._replace = function (newIndex) {
         this._index = newIndex._index;
     };
-    /**
-     * @param {Object} newIndex
-     */
     ListRepresentationIndex.prototype._update = function () {
         log.error("List RepresentationIndex: Cannot update a SegmentList");
     };

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/template.d.ts

@@ -46,6 +46,7 @@ export interface ITemplateIndex {
     /**
      * URL base to access any segment.
      * Can contain token to replace to convert it to real URLs.
+     * `null` if no URL exists.
      */
     mediaURLs: string[] | null;
     /**
@@ -134,7 +135,7 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
     /** Absolute start of the Period, in seconds. */
     private _periodStart;
     /** Difference between the end time of the Period and its start time, in timescale. */
-    private _scaledPeriodEnd;
+    private _scaledRelativePeriodEnd;
     /** Minimum availabilityTimeOffset concerning the segments of this Representation. */
     private _availabilityTimeOffset;
     /** Whether the corresponding Manifest can be updated and changed. */
@@ -160,12 +161,31 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
      * Returns first possible position in the index, in seconds.
      * @returns {number|null|undefined}
      */
-    getFirstPosition(): number | null | undefined;
+    getFirstAvailablePosition(): number | null | undefined;
     /**
      * Returns last possible position in the index, in seconds.
      * @returns {number|null}
      */
-    getLastPosition(): number | null | undefined;
+    getLastAvailablePosition(): number | null | undefined;
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    getEnd(): number | null | undefined;
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     *
+     * Always `false` in a `BaseRepresentationIndex` because all segments should
+     * be directly available.
+     * @returns {boolean}
+     */
+    awaitSegmentBetween(start: number, end: number): boolean | undefined;
     /**
      * Returns true if, based on the arguments, the index should be refreshed.
      * We never have to refresh a SegmentTemplate-based manifest.
@@ -177,10 +197,6 @@ export default class TemplateRepresentationIndex implements IRepresentationIndex
      * @returns {null}
      */
     checkDiscontinuity(): null;
-    /**
-     * @returns {Boolean}
-     */
-    areSegmentsChronologicallyGenerated(): true;
     /**
      * Returns `true` if the given segment should still be available as of now
      * (not removed since and still request-able).

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/template.js

@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 import config from "../../../../../config";
+import assert from "../../../../../utils/assert";
 import getInitSegment from "./get_init_segment";
-import isPeriodFulfilled from "./is_period_fulfilled";
 import { createDashUrlDetokenizer, createIndexURLs, } from "./tokens";
+import { getSegmentTimeRoundingError } from "./utils";
 /**
  * IRepresentationIndex implementation for DASH' SegmentTemplate without a
  * SegmentTimeline.
@@ -55,7 +56,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             mediaURLs: createIndexURLs(urlSources, index.media, representationId, representationBitrate), presentationTimeOffset: presentationTimeOffset, startNumber: index.startNumber };
         this._isDynamic = isDynamic;
         this._periodStart = periodStart;
-        this._scaledPeriodEnd = periodEnd === undefined ?
+        this._scaledRelativePeriodEnd = periodEnd === undefined ?
             undefined :
             (periodEnd - periodStart) * timescale;
         this._isEMSGWhitelisted = isEMSGWhitelisted;
@@ -76,7 +77,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
         var index = this._index;
         var duration = index.duration, startNumber = index.startNumber, timescale = index.timescale, mediaURLs = index.mediaURLs;
         var scaledStart = this._periodStart * timescale;
-        var scaledEnd = this._scaledPeriodEnd;
+        var scaledEnd = this._scaledRelativePeriodEnd;
         // Convert the asked position to the right timescales, and consider them
         // relatively to the Period's start.
         var upFromPeriodStart = fromTime * timescale - scaledStart;
@@ -132,7 +133,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
      * Returns first possible position in the index, in seconds.
      * @returns {number|null|undefined}
      */
-    TemplateRepresentationIndex.prototype.getFirstPosition = function () {
+    TemplateRepresentationIndex.prototype.getFirstAvailablePosition = function () {
         var firstSegmentStart = this._getFirstSegmentStart();
         if (firstSegmentStart == null) {
             return firstSegmentStart; // return undefined or null
@@ -143,18 +144,64 @@ var TemplateRepresentationIndex = /** @class */ (function () {
      * Returns last possible position in the index, in seconds.
      * @returns {number|null}
      */
-    TemplateRepresentationIndex.prototype.getLastPosition = function () {
+    TemplateRepresentationIndex.prototype.getLastAvailablePosition = function () {
         var _a;
         var lastSegmentStart = this._getLastSegmentStart();
         if (lastSegmentStart == null) {
-            // In that case (null or undefined), getLastPosition should reflect
+            // In that case (null or undefined), getLastAvailablePosition should reflect
             // the result of getLastSegmentStart, as the meaning is the same for
             // the two functions. So, we return the result of the latter.
             return lastSegmentStart;
         }
-        var lastSegmentEnd = Math.min(lastSegmentStart + this._index.duration, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
+        var lastSegmentEnd = Math.min(lastSegmentStart + this._index.duration, (_a = this._scaledRelativePeriodEnd) !== null && _a !== void 0 ? _a : Infinity);
         return (lastSegmentEnd / this._index.timescale) + this._periodStart;
     };
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    TemplateRepresentationIndex.prototype.getEnd = function () {
+        if (!this._isDynamic) {
+            return this.getLastAvailablePosition();
+        }
+        if (this._scaledRelativePeriodEnd === undefined) {
+            return undefined;
+        }
+        var timescale = this._index.timescale;
+        var absoluteScaledPeriodEnd = (this._scaledRelativePeriodEnd +
+            this._periodStart * timescale);
+        return absoluteScaledPeriodEnd / this._index.timescale;
+    };
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     *
+     * Always `false` in a `BaseRepresentationIndex` because all segments should
+     * be directly available.
+     * @returns {boolean}
+     */
+    TemplateRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
+        assert(start <= end);
+        if (!this._isDynamic) {
+            return false;
+        }
+        var timescale = this._index.timescale;
+        var segmentTimeRounding = getSegmentTimeRoundingError(timescale);
+        var scaledPeriodStart = this._periodStart * timescale;
+        var scaledRelativeEnd = end * timescale - scaledPeriodStart;
+        if (this._scaledRelativePeriodEnd === undefined) {
+            return (scaledRelativeEnd + segmentTimeRounding) >= 0;
+        }
+        var scaledRelativePeriodEnd = this._scaledRelativePeriodEnd;
+        var scaledRelativeStart = start * timescale - scaledPeriodStart;
+        return (scaledRelativeStart - segmentTimeRounding) < scaledRelativePeriodEnd &&
+            (scaledRelativeEnd + segmentTimeRounding) >= 0;
+    };
     /**
      * Returns true if, based on the arguments, the index should be refreshed.
      * We never have to refresh a SegmentTemplate-based manifest.
@@ -170,12 +217,6 @@ var TemplateRepresentationIndex = /** @class */ (function () {
     TemplateRepresentationIndex.prototype.checkDiscontinuity = function () {
         return null;
     };
-    /**
-     * @returns {Boolean}
-     */
-    TemplateRepresentationIndex.prototype.areSegmentsChronologicallyGenerated = function () {
-        return true;
-    };
     /**
      * Returns `true` if the given segment should still be available as of now
      * (not removed since and still request-able).
@@ -210,7 +251,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
         if (!this._isDynamic) {
             return true;
         }
-        if (this._scaledPeriodEnd === undefined) {
+        if (this._scaledRelativePeriodEnd === undefined) {
             return false;
         }
         var timescale = this._index.timescale;
@@ -221,7 +262,8 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             return false;
         }
         var lastSegmentEnd = lastSegmentStart + this._index.duration;
-        return isPeriodFulfilled(timescale, lastSegmentEnd, this._scaledPeriodEnd);
+        var segmentTimeRounding = getSegmentTimeRoundingError(timescale);
+        return (lastSegmentEnd + segmentTimeRounding) >= this._scaledRelativePeriodEnd;
     };
     /**
      * @returns {Boolean}
@@ -237,7 +279,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
         this._aggressiveMode = newIndex._aggressiveMode;
         this._isDynamic = newIndex._isDynamic;
         this._periodStart = newIndex._periodStart;
-        this._scaledPeriodEnd = newIndex._scaledPeriodEnd;
+        this._scaledRelativePeriodEnd = newIndex._scaledRelativePeriodEnd;
         this._manifestBoundsCalculator = newIndex._manifestBoundsCalculator;
     };
     /**
@@ -258,7 +300,8 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             return 0; // it is the start of the Period
         }
         // 1 - check that this index is already available
-        if (this._scaledPeriodEnd === 0 || this._scaledPeriodEnd === undefined) {
+        if (this._scaledRelativePeriodEnd === 0 ||
+            this._scaledRelativePeriodEnd === undefined) {
             // /!\ The scaled max position augments continuously and might not
             // reflect exactly the real server-side value. As segments are
             // generated discretely.
@@ -296,13 +339,13 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             }
             var agressiveModeOffset = this._aggressiveMode ? (duration / timescale) :
                 0;
-            if (this._scaledPeriodEnd != null &&
-                this._scaledPeriodEnd <
+            if (this._scaledRelativePeriodEnd != null &&
+                this._scaledRelativePeriodEnd <
                     (lastPos + agressiveModeOffset - this._periodStart) * this._index.timescale) {
-                if (this._scaledPeriodEnd < duration) {
+                if (this._scaledRelativePeriodEnd < duration) {
                     return null;
                 }
-                return (Math.floor(this._scaledPeriodEnd / duration) - 1) * duration;
+                return (Math.floor(this._scaledRelativePeriodEnd / duration) - 1) * duration;
             }
             // /!\ The scaled last position augments continuously and might not
             // reflect exactly the real server-side value. As segments are
@@ -321,7 +364,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
                 (numberOfSegmentsAvailable - 1) * duration;
         }
         else {
-            var maximumTime = (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : 0;
+            var maximumTime = (_a = this._scaledRelativePeriodEnd) !== null && _a !== void 0 ? _a : 0;
             var numberIndexedToZero = Math.ceil(maximumTime / duration) - 1;
             var regularLastSegmentStart = numberIndexedToZero * duration;
             // In some SegmentTemplate, we could think that there is one more

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.d.ts

@@ -219,14 +219,32 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      * Returns null if nothing is in the index
      * @returns {Number|null}
      */
-    getFirstPosition(): number | null;
+    getFirstAvailablePosition(): number | null;
     /**
      * Returns the ending time, in seconds, of the last segment currently
      * available.
      * Returns null if nothing is in the index
      * @returns {Number|null}
      */
-    getLastPosition(): number | null;
+    getLastAvailablePosition(): number | null;
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    getEnd(): number | undefined | null;
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    awaitSegmentBetween(start: number, end: number): boolean | undefined;
     /**
      * Returns true if a Segment returned by this index is still considered
      * available.
@@ -250,7 +268,6 @@ export default class TimelineRepresentationIndex implements IRepresentationIndex
      * @returns {Boolean}
      */
     canBeOutOfSyncError(error: IPlayerError): boolean;
-    areSegmentsChronologicallyGenerated(): boolean;
     /**
      * Replace this RepresentationIndex with one from a new version of the
      * Manifest.

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/timeline/timeline_representation_index.js

@@ -16,14 +16,15 @@
 import config from "../../../../../../config";
 import { NetworkError } from "../../../../../../errors";
 import log from "../../../../../../log";
+import assert from "../../../../../../utils/assert";
 import clearTimelineFromPosition from "../../../../utils/clear_timeline_from_position";
 import { checkDiscontinuity, fromIndexTime, getIndexSegmentEnd, toIndexTime, } from "../../../../utils/index_helpers";
 import isSegmentStillAvailable from "../../../../utils/is_segment_still_available";
 import updateSegmentTimeline from "../../../../utils/update_segment_timeline";
 import getInitSegment from "../get_init_segment";
 import getSegmentsFromTimeline from "../get_segments_from_timeline";
-import isPeriodFulfilled from "../is_period_fulfilled";
 import { createIndexURLs } from "../tokens";
+import { getSegmentTimeRoundingError } from "../utils";
 import constructTimelineFromElements from "./construct_timeline_from_elements";
 // eslint-disable-next-line max-len
 import constructTimelineFromPreviousTimeline from "./construct_timeline_from_previous_timeline";
@@ -116,7 +117,7 @@ var TimelineRepresentationIndex = /** @class */ (function () {
      * Returns null if nothing is in the index
      * @returns {Number|null}
      */
-    TimelineRepresentationIndex.prototype.getFirstPosition = function () {
+    TimelineRepresentationIndex.prototype.getFirstAvailablePosition = function () {
         this._refreshTimeline();
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
@@ -131,7 +132,7 @@ var TimelineRepresentationIndex = /** @class */ (function () {
      * Returns null if nothing is in the index
      * @returns {Number|null}
      */
-    TimelineRepresentationIndex.prototype.getLastPosition = function () {
+    TimelineRepresentationIndex.prototype.getLastAvailablePosition = function () {
         this._refreshTimeline();
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
@@ -140,6 +141,57 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         return lastTime === null ? null :
             fromIndexTime(lastTime, this._index);
     };
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    TimelineRepresentationIndex.prototype.getEnd = function () {
+        if (!this._isDynamic || !this._isLastPeriod) { // @see isFinished
+            return this.getLastAvailablePosition();
+        }
+        return undefined;
+    };
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    TimelineRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
+        var _a;
+        assert(start <= end);
+        if (!this._isDynamic || !this._isLastPeriod) {
+            return false;
+        }
+        this._refreshTimeline();
+        if (this._index.timeline === null) {
+            this._index.timeline = this._getTimeline();
+        }
+        var _b = this._index, timeline = _b.timeline, timescale = _b.timescale;
+        var segmentTimeRounding = getSegmentTimeRoundingError(timescale);
+        var scaledEnd = toIndexTime(end, this._index);
+        if (timeline.length > 0) {
+            var lastTimelineElement = timeline[timeline.length - 1];
+            var lastSegmentEnd = getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd);
+            var roundedEnd = lastSegmentEnd + segmentTimeRounding;
+            if (roundedEnd >= Math.min(scaledEnd, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity)) {
+                return false; // already loaded
+            }
+        }
+        if (this._scaledPeriodEnd === undefined) {
+            return (scaledEnd + segmentTimeRounding) > this._scaledPeriodStart ? undefined :
+                false;
+        }
+        var scaledStart = toIndexTime(start, this._index);
+        return (scaledStart - segmentTimeRounding) < this._scaledPeriodEnd &&
+            (scaledEnd + segmentTimeRounding) > this._scaledPeriodStart;
+    };
     /**
      * Returns true if a Segment returned by this index is still considered
      * available.
@@ -188,9 +240,6 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         return error instanceof NetworkError &&
             error.isHttpError(404);
     };
-    TimelineRepresentationIndex.prototype.areSegmentsChronologicallyGenerated = function () {
-        return true;
-    };
     /**
      * Replace this RepresentationIndex with one from a new version of the
      * Manifest.
@@ -253,7 +302,8 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         }
         var lastTimelineElement = timeline[timeline.length - 1];
         var lastTime = getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd);
-        return isPeriodFulfilled(this._index.timescale, lastTime, this._scaledPeriodEnd);
+        var segmentTimeRounding = getSegmentTimeRoundingError(this._index.timescale);
+        return (lastTime + segmentTimeRounding) >= this._scaledPeriodEnd;
     };
     /**
      * @returns {Boolean}

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/{is_period_fulfilled.d.ts → utils.d.ts}

@@ -17,12 +17,9 @@
  * In Javascript, numbers are encoded in a way that a floating number may be
  * represented internally with a rounding error.
  *
- * As the period end is the result of a multiplication between a floating or integer
- * number (period end * timescale), this function takes into account the potential
- * rounding error to tell if the period is fulfilled with content.
+ * This function returns a small number allowing to accound for rounding many
+ * rounding errors.
  * @param {number} timescale
- * @param {number} lastSegmentEnd
- * @param {number} periodEnd
  * @returns {boolean}
  */
-export default function isPeriodFulfilled(timescale: number, lastSegmentEnd: number, periodEnd: number): boolean;
+export declare function getSegmentTimeRoundingError(timescale: number): number;

package/dist/_esm5.processed/parsers/manifest/dash/common/indexes/{is_period_fulfilled.js → utils.js}

@@ -18,15 +18,11 @@ import config from "../../../../../config";
  * In Javascript, numbers are encoded in a way that a floating number may be
  * represented internally with a rounding error.
  *
- * As the period end is the result of a multiplication between a floating or integer
- * number (period end * timescale), this function takes into account the potential
- * rounding error to tell if the period is fulfilled with content.
+ * This function returns a small number allowing to accound for rounding many
+ * rounding errors.
  * @param {number} timescale
- * @param {number} lastSegmentEnd
- * @param {number} periodEnd
  * @returns {boolean}
  */
-export default function isPeriodFulfilled(timescale, lastSegmentEnd, periodEnd) {
-    var scaledRoundingError = config.getCurrent().DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR * timescale;
-    return (lastSegmentEnd + scaledRoundingError) >= periodEnd;
+export function getSegmentTimeRoundingError(timescale) {
+    return config.getCurrent().DEFAULT_MAXIMUM_TIME_ROUNDING_ERROR * timescale;
 }

package/dist/_esm5.processed/parsers/manifest/dash/common/parse_periods.js

@@ -186,7 +186,7 @@ function getMaximumLastPosition(adaptationsPerType) {
         var representations = adaptation.representations;
         for (var _a = 0, representations_1 = representations; _a < representations_1.length; _a++) {
             var representation = representations_1[_a];
-            var position = representation.index.getLastPosition();
+            var position = representation.index.getLastAvailablePosition();
             if (position !== null) {
                 allIndexAreEmpty = false;
                 if (typeof position === "number") {

package/dist/_esm5.processed/parsers/manifest/local/parse_local_manifest.js

@@ -30,12 +30,12 @@ export default function parseLocalManifest(localManifest) {
     var periodIdGenerator = idGenerator();
     var minimumPosition = localManifest.minimumPosition, maximumPosition = localManifest.maximumPosition, isFinished = localManifest.isFinished;
     var parsedPeriods = localManifest.periods
-        .map(function (period) { return parsePeriod(period, { periodIdGenerator: periodIdGenerator, isFinished: isFinished }); });
+        .map(function (period) { return parsePeriod(period, { periodIdGenerator: periodIdGenerator }); });
     return { availabilityStartTime: 0,
         expired: localManifest.expired,
         transportType: "local",
         isDynamic: !isFinished,
-        isLastPeriodKnown: isFinished,
+        isLastPeriodKnown: true,
         isLive: false,
         uris: [],
         timeBounds: { minimumSafePosition: minimumPosition !== null && minimumPosition !== void 0 ? minimumPosition : 0,
@@ -52,7 +52,6 @@ export default function parseLocalManifest(localManifest) {
  * @returns {Object}
  */
 function parsePeriod(period, ctxt) {
-    var isFinished = ctxt.isFinished;
     var adaptationIdGenerator = idGenerator();
     return {
         id: "period-" + ctxt.periodIdGenerator(),
@@ -67,7 +66,7 @@ function parsePeriod(period, ctxt) {
                 adaps = [];
                 acc[type] = adaps;
             }
-            adaps.push(parseAdaptation(ada, { adaptationIdGenerator: adaptationIdGenerator, isFinished: isFinished }));
+            adaps.push(parseAdaptation(ada, { adaptationIdGenerator: adaptationIdGenerator }));
             return acc;
         }, {}),
     };
@@ -78,7 +77,6 @@ function parsePeriod(period, ctxt) {
  * @returns {Object}
  */
 function parseAdaptation(adaptation, ctxt) {
-    var isFinished = ctxt.isFinished;
     var representationIdGenerator = idGenerator();
     return {
         id: "adaptation-" + ctxt.adaptationIdGenerator(),
@@ -87,7 +85,7 @@ function parseAdaptation(adaptation, ctxt) {
         closedCaption: adaptation.closedCaption,
         language: adaptation.language,
         representations: adaptation.representations.map(function (representation) {
-            return parseRepresentation(representation, { representationIdGenerator: representationIdGenerator, isFinished: isFinished });
+            return parseRepresentation(representation, { representationIdGenerator: representationIdGenerator });
         }),
     };
 }
@@ -96,7 +94,6 @@ function parseAdaptation(adaptation, ctxt) {
  * @returns {Object}
  */
 function parseRepresentation(representation, ctxt) {
-    var isFinished = ctxt.isFinished;
     var id = "representation-" + ctxt.representationIdGenerator();
     var contentProtections = representation.contentProtections === undefined ?
         undefined :
@@ -106,7 +103,7 @@ function parseRepresentation(representation, ctxt) {
         width: representation.width,
         codecs: representation.codecs,
         mimeType: representation.mimeType,
-        index: new LocalRepresentationIndex(representation.index, id, isFinished), contentProtections: contentProtections };
+        index: new LocalRepresentationIndex(representation.index, id), contentProtections: contentProtections };
 }
 /**
  * Translate Local Manifest's `contentProtections` attribute to the one defined

package/dist/_esm5.processed/parsers/manifest/local/representation_index.d.ts

@@ -18,8 +18,7 @@ import { ILocalIndex } from "./types";
 export default class LocalRepresentationIndex implements IRepresentationIndex {
     private _index;
     private _representationId;
-    private _isFinished;
-    constructor(index: ILocalIndex, representationId: string, isFinished: boolean);
+    constructor(index: ILocalIndex, representationId: string);
     /**
      * @returns {Object}
      */
@@ -33,11 +32,29 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
     /**
      * @returns {Number|undefined}
      */
-    getFirstPosition(): number | undefined;
+    getFirstAvailablePosition(): number | undefined;
     /**
      * @returns {Number|undefined}
      */
-    getLastPosition(): number | undefined;
+    getLastAvailablePosition(): number | undefined;
+    /**
+     * Returns the expected ending position of this RepresentationIndex.
+     * `undefined` if unknown.
+     * @returns {number|undefined}
+     */
+    getEnd(): number | undefined;
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    awaitSegmentBetween(start: number, end: number): boolean | undefined;
     /**
      * @returns {Boolean}
      */
@@ -55,10 +72,6 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
      * @returns {null}
      */
     checkDiscontinuity(): null;
-    /**
-     * @returns {boolean}
-     */
-    areSegmentsChronologicallyGenerated(): boolean;
     /**
      * @returns {Boolean}
      */