rx-player 4.0.0-beta.2 → 4.0.0-beta.3

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,55 +14,46 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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 { constructRepresentationUrl } from "../tokens";
-import { getSegmentTimeRoundingError } from "../utils";
-import constructTimelineFromElements from "./construct_timeline_from_elements";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../../../../config");
+const errors_1 = require("../../../../../../errors");
+const log_1 = require("../../../../../../log");
+const assert_1 = require("../../../../../../utils/assert");
+const monotonic_timestamp_1 = require("../../../../../../utils/monotonic_timestamp");
+const clear_timeline_from_position_1 = require("../../../../utils/clear_timeline_from_position");
+const index_helpers_1 = require("../../../../utils/index_helpers");
+const is_segment_still_available_1 = require("../../../../utils/is_segment_still_available");
+const update_segment_timeline_1 = require("../../../../utils/update_segment_timeline");
+const get_init_segment_1 = require("../get_init_segment");
+const get_segments_from_timeline_1 = require("../get_segments_from_timeline");
+const tokens_1 = require("../tokens");
+const utils_1 = require("../utils");
+const construct_timeline_from_elements_1 = require("./construct_timeline_from_elements");
 // eslint-disable-next-line max-len
-import constructTimelineFromPreviousTimeline from "./construct_timeline_from_previous_timeline";
-var TimelineRepresentationIndex = /** @class */ (function () {
+const construct_timeline_from_previous_timeline_1 = require("./construct_timeline_from_previous_timeline");
+class TimelineRepresentationIndex {
     /**
      * @param {Object} index
      * @param {Object} context
      */
-    function TimelineRepresentationIndex(index, context) {
+    constructor(index, context) {
         var _a, _b, _c;
         if (!TimelineRepresentationIndex.isTimelineIndexArgument(index)) {
             throw new Error("The given index is not compatible with a " +
                 "TimelineRepresentationIndex.");
         }
-        var availabilityTimeComplete = context.availabilityTimeComplete, manifestBoundsCalculator = context.manifestBoundsCalculator, isDynamic = context.isDynamic, isLastPeriod = context.isLastPeriod, representationId = context.representationId, representationBitrate = context.representationBitrate, periodStart = context.periodStart, periodEnd = context.periodEnd, isEMSGWhitelisted = context.isEMSGWhitelisted;
-        var timescale = (_a = index.timescale) !== null && _a !== void 0 ? _a : 1;
-        var presentationTimeOffset = index.presentationTimeOffset != null ?
+        const { availabilityTimeComplete, manifestBoundsCalculator, isDynamic, isLastPeriod, representationId, representationBitrate, periodStart, periodEnd, isEMSGWhitelisted } = context;
+        const timescale = (_a = index.timescale) !== null && _a !== void 0 ? _a : 1;
+        const presentationTimeOffset = index.presentationTimeOffset != null ?
             index.presentationTimeOffset :
             0;
-        var scaledStart = periodStart * timescale;
-        var indexTimeOffset = presentationTimeOffset - scaledStart;
+        const scaledStart = periodStart * timescale;
+        const indexTimeOffset = presentationTimeOffset - scaledStart;
         this._manifestBoundsCalculator = manifestBoundsCalculator;
         this._isEMSGWhitelisted = isEMSGWhitelisted;
         this._isLastPeriod = isLastPeriod;
         this._lastUpdate = context.receivedTime == null ?
-            performance.now() :
+            (0, monotonic_timestamp_1.default)() :
             context.receivedTime;
         this._unsafelyBaseOnPreviousIndex = null;
         if (context.unsafelyBaseOnPreviousRepresentation !== null &&
@@ -75,98 +67,109 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         }
         this._isDynamic = isDynamic;
         this._parseTimeline = (_b = index.timelineParser) !== null && _b !== void 0 ? _b : null;
-        var initializationUrl = ((_c = index.initialization) === null || _c === void 0 ? void 0 : _c.media) === undefined ?
+        const initializationUrl = ((_c = index.initialization) === null || _c === void 0 ? void 0 : _c.media) === undefined ?
             null :
-            constructRepresentationUrl(index.initialization.media, representationId, representationBitrate);
-        var segmentUrlTemplate = index.media === undefined ?
+            (0, tokens_1.constructRepresentationUrl)(index.initialization.media, representationId, representationBitrate);
+        const segmentUrlTemplate = index.media === undefined ?
             null :
-            constructRepresentationUrl(index.media, representationId, representationBitrate);
-        this._index = { availabilityTimeComplete: availabilityTimeComplete, indexRange: index.indexRange, indexTimeOffset: indexTimeOffset, initialization: index.initialization == null ?
+            (0, tokens_1.constructRepresentationUrl)(index.media, representationId, representationBitrate);
+        this._index = { availabilityTimeComplete,
+            indexRange: index.indexRange,
+            indexTimeOffset,
+            initialization: index.initialization == null ?
                 undefined :
                 {
                     url: initializationUrl,
                     range: index.initialization.range,
-                }, segmentUrlTemplate: segmentUrlTemplate, startNumber: index.startNumber,
+                },
+            segmentUrlTemplate,
+            startNumber: index.startNumber,
             endNumber: index.endNumber,
             timeline: index.timeline === undefined ?
                 null :
-                updateTimelineFromEndNumber(index.timeline, index.startNumber, index.endNumber), timescale: timescale };
-        this._scaledPeriodStart = toIndexTime(periodStart, this._index);
+                updateTimelineFromEndNumber(index.timeline, index.startNumber, index.endNumber),
+            timescale };
+        this._scaledPeriodStart = (0, index_helpers_1.toIndexTime)(periodStart, this._index);
         this._scaledPeriodEnd = periodEnd === undefined ? undefined :
-            toIndexTime(periodEnd, this._index);
+            (0, index_helpers_1.toIndexTime)(periodEnd, this._index);
     }
     /**
      * Construct init Segment.
      * @returns {Object}
      */
-    TimelineRepresentationIndex.prototype.getInitSegment = function () {
-        return getInitSegment(this._index, this._isEMSGWhitelisted);
-    };
+    getInitSegment() {
+        return (0, get_init_segment_1.default)(this._index, this._isEMSGWhitelisted);
+    }
     /**
      * Asks for segments to download for a given time range.
      * @param {Number} from - Beginning of the time wanted, in seconds
      * @param {Number} duration - duration wanted, in seconds
      * @returns {Array.<Object>}
      */
-    TimelineRepresentationIndex.prototype.getSegments = function (from, duration) {
+    getSegments(from, duration) {
         this._refreshTimeline(); // clear timeline if needed
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
         // destructuring to please TypeScript
-        var _a = this._index, segmentUrlTemplate = _a.segmentUrlTemplate, startNumber = _a.startNumber, endNumber = _a.endNumber, timeline = _a.timeline, timescale = _a.timescale, indexTimeOffset = _a.indexTimeOffset;
-        return getSegmentsFromTimeline({ segmentUrlTemplate: segmentUrlTemplate, startNumber: startNumber, endNumber: endNumber, timeline: timeline, timescale: timescale, indexTimeOffset: indexTimeOffset }, from, duration, this._isEMSGWhitelisted, this._scaledPeriodEnd);
-    };
+        const { segmentUrlTemplate, startNumber, endNumber, timeline, timescale, indexTimeOffset } = this._index;
+        return (0, get_segments_from_timeline_1.default)({ segmentUrlTemplate,
+            startNumber,
+            endNumber,
+            timeline,
+            timescale,
+            indexTimeOffset }, from, duration, this._isEMSGWhitelisted, this._scaledPeriodEnd);
+    }
     /**
      * Returns true if the index should be refreshed.
      * @returns {Boolean}
      */
-    TimelineRepresentationIndex.prototype.shouldRefresh = function () {
+    shouldRefresh() {
         // DASH Manifest based on a SegmentTimeline should have minimumUpdatePeriod
         // attribute which should be sufficient to know when to refresh it.
         return false;
-    };
+    }
     /**
      * Returns the starting time, in seconds, of the earliest segment currently
      * available.
      * Returns null if nothing is in the index
      * @returns {Number|null}
      */
-    TimelineRepresentationIndex.prototype.getFirstAvailablePosition = function () {
+    getFirstAvailablePosition() {
         this._refreshTimeline();
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
-        var timeline = this._index.timeline;
+        const timeline = this._index.timeline;
         return timeline.length === 0 ? null :
-            fromIndexTime(Math.max(this._scaledPeriodStart, timeline[0].start), this._index);
-    };
+            (0, index_helpers_1.fromIndexTime)(Math.max(this._scaledPeriodStart, timeline[0].start), this._index);
+    }
     /**
      * Returns the ending time, in seconds, of the last segment currently
      * available.
      * Returns null if nothing is in the index
      * @returns {Number|null}
      */
-    TimelineRepresentationIndex.prototype.getLastAvailablePosition = function () {
+    getLastAvailablePosition() {
         this._refreshTimeline();
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
-        var lastTime = TimelineRepresentationIndex.getIndexEnd(this._index.timeline, this._scaledPeriodEnd);
+        const lastTime = TimelineRepresentationIndex.getIndexEnd(this._index.timeline, this._scaledPeriodEnd);
         return lastTime === null ? null :
-            fromIndexTime(lastTime, this._index);
-    };
+            (0, index_helpers_1.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 () {
+    getEnd() {
         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
@@ -178,9 +181,9 @@ var TimelineRepresentationIndex = /** @class */ (function () {
      * @param {number} end
      * @returns {boolean|undefined}
      */
-    TimelineRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
+    awaitSegmentBetween(start, end) {
         var _a;
-        assert(start <= end);
+        (0, assert_1.default)(start <= end);
         if (!this._isDynamic || !this._isLastPeriod) {
             return false;
         }
@@ -188,13 +191,13 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         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);
+        const { timeline, timescale } = this._index;
+        const segmentTimeRounding = (0, utils_1.getSegmentTimeRoundingError)(timescale);
+        const scaledEnd = (0, index_helpers_1.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;
+            const lastTimelineElement = timeline[timeline.length - 1];
+            const lastSegmentEnd = (0, index_helpers_1.getIndexSegmentEnd)(lastTimelineElement, null, this._scaledPeriodEnd);
+            const roundedEnd = lastSegmentEnd + segmentTimeRounding;
             if (roundedEnd >= Math.min(scaledEnd, (_a = this._scaledPeriodEnd) !== null && _a !== void 0 ? _a : Infinity)) {
                 return false; // already loaded
             }
@@ -203,10 +206,10 @@ var TimelineRepresentationIndex = /** @class */ (function () {
             return (scaledEnd + segmentTimeRounding) > this._scaledPeriodStart ? undefined :
                 false;
         }
-        var scaledStart = toIndexTime(start, this._index);
+        const scaledStart = (0, index_helpers_1.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.
@@ -215,7 +218,7 @@ var TimelineRepresentationIndex = /** @class */ (function () {
      * @param {Object} segment
      * @returns {Boolean|undefined}
      */
-    TimelineRepresentationIndex.prototype.isSegmentStillAvailable = function (segment) {
+    isSegmentStillAvailable(segment) {
         if (segment.isInit) {
             return true;
         }
@@ -223,9 +226,9 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
-        var _a = this._index, timeline = _a.timeline, timescale = _a.timescale, indexTimeOffset = _a.indexTimeOffset;
-        return isSegmentStillAvailable(segment, timeline, timescale, indexTimeOffset);
-    };
+        const { timeline, timescale, indexTimeOffset } = this._index;
+        return (0, is_segment_still_available_1.default)(segment, timeline, timescale, indexTimeOffset);
+    }
     /**
      * Checks if the time given is in a discontinuity. That is:
      *   - We're on the upper bound of the current range (end of the range - time
@@ -234,33 +237,34 @@ var TimelineRepresentationIndex = /** @class */ (function () {
      * @param {Number} time
      * @returns {Number|null}
      */
-    TimelineRepresentationIndex.prototype.checkDiscontinuity = function (time) {
+    checkDiscontinuity(time) {
         this._refreshTimeline();
-        var timeline = this._index.timeline;
+        let timeline = this._index.timeline;
         if (timeline === null) {
             timeline = this._getTimeline();
             this._index.timeline = timeline;
         }
-        return checkDiscontinuity({ timeline: timeline, timescale: this._index.timescale,
+        return (0, index_helpers_1.checkDiscontinuity)({ timeline,
+            timescale: this._index.timescale,
             indexTimeOffset: this._index.indexTimeOffset }, time, this._scaledPeriodEnd);
-    };
+    }
     /**
      * @param {Error} error
      * @returns {Boolean}
      */
-    TimelineRepresentationIndex.prototype.canBeOutOfSyncError = function (error) {
+    canBeOutOfSyncError(error) {
         if (!this._isDynamic) {
             return false;
         }
-        return error instanceof NetworkError &&
+        return error instanceof errors_1.NetworkError &&
             error.isHttpError(404);
-    };
+    }
     /**
      * Replace this RepresentationIndex with one from a new version of the
      * Manifest.
      * @param {Object} newIndex
      */
-    TimelineRepresentationIndex.prototype._replace = function (newIndex) {
+    _replace(newIndex) {
         this._parseTimeline = newIndex._parseTimeline;
         this._index = newIndex._index;
         this._isDynamic = newIndex._isDynamic;
@@ -269,20 +273,20 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         this._lastUpdate = newIndex._lastUpdate;
         this._manifestBoundsCalculator = newIndex._manifestBoundsCalculator;
         this._isLastPeriod = newIndex._isLastPeriod;
-    };
+    }
     /**
      * Update this RepresentationIndex with a shorter version of it coming from a
      * new version of the MPD.
      * @param {Object} newIndex
      */
-    TimelineRepresentationIndex.prototype._update = function (newIndex) {
+    _update(newIndex) {
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
         if (newIndex._index.timeline === null) {
             newIndex._index.timeline = newIndex._getTimeline();
         }
-        var hasReplaced = updateSegmentTimeline(this._index.timeline, newIndex._index.timeline);
+        const hasReplaced = (0, update_segment_timeline_1.default)(this._index.timeline, newIndex._index.timeline);
         if (hasReplaced) {
             this._index.startNumber = newIndex._index.startNumber;
         }
@@ -292,14 +296,14 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         this._scaledPeriodEnd = newIndex._scaledPeriodEnd;
         this._lastUpdate = newIndex._lastUpdate;
         this._isLastPeriod = newIndex._isLastPeriod;
-    };
+    }
     /**
      * Returns `true` if this RepresentationIndex currently contains its last
      * segment.
      * Returns `false` if it's still pending.
      * @returns {Boolean}
      */
-    TimelineRepresentationIndex.prototype.isFinished = function () {
+    isFinished() {
         if (!this._isDynamic || !this._isLastPeriod) {
             // Either the content is not dynamic, in which case no new segment will
             // be generated, either it is but this index is not linked to the current
@@ -312,67 +316,67 @@ var TimelineRepresentationIndex = /** @class */ (function () {
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
-        var timeline = this._index.timeline;
+        const { timeline } = this._index;
         if (this._scaledPeriodEnd === undefined || timeline.length === 0) {
             return false;
         }
-        var lastTimelineElement = timeline[timeline.length - 1];
-        var lastTime = getIndexSegmentEnd(lastTimelineElement, null, this._scaledPeriodEnd);
-        var segmentTimeRounding = getSegmentTimeRoundingError(this._index.timescale);
+        const lastTimelineElement = timeline[timeline.length - 1];
+        const lastTime = (0, index_helpers_1.getIndexSegmentEnd)(lastTimelineElement, null, this._scaledPeriodEnd);
+        const segmentTimeRounding = (0, utils_1.getSegmentTimeRoundingError)(this._index.timescale);
         return (lastTime + segmentTimeRounding) >= this._scaledPeriodEnd;
-    };
+    }
     /**
      * @returns {Boolean}
      */
-    TimelineRepresentationIndex.prototype.isInitialized = function () {
+    isInitialized() {
         return true;
-    };
-    TimelineRepresentationIndex.prototype.initialize = function () {
-        log.error("A `TimelineRepresentationIndex` does not need to be initialized");
-    };
-    TimelineRepresentationIndex.prototype.addPredictedSegments = function () {
-        log.warn("Cannot add predicted segments to a `TimelineRepresentationIndex`");
-    };
+    }
+    initialize() {
+        log_1.default.error("A `TimelineRepresentationIndex` does not need to be initialized");
+    }
+    addPredictedSegments() {
+        log_1.default.warn("Cannot add predicted segments to a `TimelineRepresentationIndex`");
+    }
     /**
      * Returns `true` if the given object can be used as an "index" argument to
      * create a new `TimelineRepresentationIndex`.
      * @param {Object} index
      * @returns {boolean}
      */
-    TimelineRepresentationIndex.isTimelineIndexArgument = function (index) {
+    static isTimelineIndexArgument(index) {
         return typeof index.timelineParser === "function" ||
             Array.isArray(index.timeline);
-    };
+    }
     /**
      * Clean-up timeline to remove segment information which should not be
      * available due to timeshifting.
      */
-    TimelineRepresentationIndex.prototype._refreshTimeline = function () {
+    _refreshTimeline() {
         if (this._index.timeline === null) {
             this._index.timeline = this._getTimeline();
         }
         if (!this._isDynamic) {
             return;
         }
-        var firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
+        const firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
         if (firstPosition == null) {
             return; // we don't know yet
         }
-        var scaledFirstPosition = toIndexTime(firstPosition, this._index);
-        var nbEltsRemoved = clearTimelineFromPosition(this._index.timeline, scaledFirstPosition);
+        const scaledFirstPosition = (0, index_helpers_1.toIndexTime)(firstPosition, this._index);
+        const nbEltsRemoved = (0, clear_timeline_from_position_1.default)(this._index.timeline, scaledFirstPosition);
         if (this._index.startNumber !== undefined) {
             this._index.startNumber += nbEltsRemoved;
         }
         else if (this._index.endNumber !== undefined) {
             this._index.startNumber = nbEltsRemoved + 1;
         }
-    };
-    TimelineRepresentationIndex.getIndexEnd = function (timeline, scaledPeriodEnd) {
+    }
+    static getIndexEnd(timeline, scaledPeriodEnd) {
         if (timeline.length <= 0) {
             return null;
         }
-        return Math.min(getIndexSegmentEnd(timeline[timeline.length - 1], null, scaledPeriodEnd), scaledPeriodEnd !== null && scaledPeriodEnd !== void 0 ? scaledPeriodEnd : Infinity);
-    };
+        return Math.min((0, index_helpers_1.getIndexSegmentEnd)(timeline[timeline.length - 1], null, scaledPeriodEnd), scaledPeriodEnd !== null && scaledPeriodEnd !== void 0 ? scaledPeriodEnd : Infinity);
+    }
     /**
      * Allows to generate the "timeline" for this RepresentationIndex.
      * Call this function when the timeline is unknown.
@@ -395,24 +399,24 @@ var TimelineRepresentationIndex = /** @class */ (function () {
      * stream anymore.
      * @returns {Array.<Object>}
      */
-    TimelineRepresentationIndex.prototype._getTimeline = function () {
+    _getTimeline() {
         if (this._parseTimeline === null) {
             if (this._index.timeline !== null) {
                 return this._index.timeline;
             }
-            log.error("DASH: Timeline already lazily parsed.");
+            log_1.default.error("DASH: Timeline already lazily parsed.");
             return [];
         }
-        var newElements = this._parseTimeline();
+        const newElements = this._parseTimeline();
         this._parseTimeline = null; // Free memory
-        var MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY = config.getCurrent().MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY;
+        const { MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY } = config_1.default.getCurrent();
         if (this._unsafelyBaseOnPreviousIndex === null ||
             newElements.length < MIN_DASH_S_ELEMENTS_TO_PARSE_UNSAFELY) {
             // Just completely parse the current timeline
-            return updateTimelineFromEndNumber(constructTimelineFromElements(newElements), this._index.startNumber, this._index.endNumber);
+            return updateTimelineFromEndNumber((0, construct_timeline_from_elements_1.default)(newElements), this._index.startNumber, this._index.endNumber);
         }
         // Construct previously parsed timeline if not already done
-        var prevTimeline;
+        let prevTimeline;
         if (this._unsafelyBaseOnPreviousIndex._index.timeline === null) {
             prevTimeline = this._unsafelyBaseOnPreviousIndex._getTimeline();
             this._unsafelyBaseOnPreviousIndex._index.timeline = prevTimeline;
@@ -421,11 +425,10 @@ var TimelineRepresentationIndex = /** @class */ (function () {
             prevTimeline = this._unsafelyBaseOnPreviousIndex._index.timeline;
         }
         this._unsafelyBaseOnPreviousIndex = null; // Free memory
-        return updateTimelineFromEndNumber(constructTimelineFromPreviousTimeline(newElements, prevTimeline), this._index.startNumber, this._index.endNumber);
-    };
-    return TimelineRepresentationIndex;
-}());
-export default TimelineRepresentationIndex;
+        return updateTimelineFromEndNumber((0, construct_timeline_from_previous_timeline_1.default)(newElements, prevTimeline), this._index.startNumber, this._index.endNumber);
+    }
+}
+exports.default = TimelineRepresentationIndex;
 /**
  * Take the original SegmentTimeline's parsed timeline and, if an `endNumber` is
  * specified, filter segments which possess a number superior to that number.
@@ -442,18 +445,18 @@ function updateTimelineFromEndNumber(timeline, startNumber, endNumber) {
     if (endNumber === undefined) {
         return timeline;
     }
-    var currNumber = startNumber !== null && startNumber !== void 0 ? startNumber : 1;
-    for (var idx = 0; idx < timeline.length; idx++) {
-        var seg = timeline[idx];
+    let currNumber = startNumber !== null && startNumber !== void 0 ? startNumber : 1;
+    for (let idx = 0; idx < timeline.length; idx++) {
+        const seg = timeline[idx];
         currNumber += seg.repeatCount + 1;
         if (currNumber > endNumber) {
             if (currNumber === endNumber + 1) {
                 return timeline.slice(0, idx + 1);
             }
             else {
-                var newTimeline = timeline.slice(0, idx);
-                var lastElt = __assign({}, seg);
-                var beginningNumber = currNumber - seg.repeatCount - 1;
+                const newTimeline = timeline.slice(0, idx);
+                const lastElt = Object.assign({}, seg);
+                const beginningNumber = currNumber - seg.repeatCount - 1;
                 lastElt.repeatCount = Math.max(0, endNumber - beginningNumber);
                 newTimeline.push(lastElt);
                 return newTimeline;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,7 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNonEmptyString from "../../../../../utils/is_non_empty_string";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDashUrlDetokenizer = exports.replaceRepresentationDASHTokens = exports.constructRepresentationUrl = void 0;
+const is_non_empty_string_1 = require("../../../../../utils/is_non_empty_string");
 /**
  * Pad with 0 in the left of the given n argument to reach l length
  * @param {Number|string} n
@@ -21,11 +24,11 @@ import isNonEmptyString from "../../../../../utils/is_non_empty_string";
  * @returns {string}
  */
 function padLeftWithZeros(n, l) {
-    var nToString = n.toString();
+    const nToString = n.toString();
     if (nToString.length >= l) {
         return nToString;
     }
-    var arr = new Array(l + 1).join("0") + nToString;
+    const arr = new Array(l + 1).join("0") + nToString;
     return arr.slice(-l);
 }
 /**
@@ -33,8 +36,8 @@ function padLeftWithZeros(n, l) {
  * @returns {Function}
  */
 function processFormatedToken(replacer) {
-    return function (_match, _format, widthStr) {
-        var width = isNonEmptyString(widthStr) ? parseInt(widthStr, 10) :
+    return (_match, _format, widthStr) => {
+        const width = (0, is_non_empty_string_1.default)(widthStr) ? parseInt(widthStr, 10) :
             1;
         return padLeftWithZeros(String(replacer), width);
     };
@@ -45,9 +48,10 @@ function processFormatedToken(replacer) {
  * @param {number|undefined} bitrate
  * @returns {string}
  */
-export function constructRepresentationUrl(urlTemplate, representationId, bitrate) {
+function constructRepresentationUrl(urlTemplate, representationId, bitrate) {
     return replaceRepresentationDASHTokens(urlTemplate, representationId, bitrate);
 }
+exports.constructRepresentationUrl = constructRepresentationUrl;
 /**
  * Replace "tokens" written in a given path (e.g. $RepresentationID$) by the corresponding
  * infos, taken from the given segment.
@@ -56,7 +60,7 @@ export function constructRepresentationUrl(urlTemplate, representationId, bitrat
  * @param {number|undefined} bitrate
  * @returns {string}
  */
-export function replaceRepresentationDASHTokens(path, id, bitrate) {
+function replaceRepresentationDASHTokens(path, id, bitrate) {
     if (path.indexOf("$") === -1) {
         return path;
     }
@@ -68,6 +72,7 @@ export function replaceRepresentationDASHTokens(path, id, bitrate) {
             bitrate));
     }
 }
+exports.replaceRepresentationDASHTokens = replaceRepresentationDASHTokens;
 /**
  * Create function allowing to replace "tokens" in a given DASH segment URL
  * (e.g. $Time$, which has to be replaced by the segment's start time) by the
@@ -76,7 +81,7 @@ export function replaceRepresentationDASHTokens(path, id, bitrate) {
  * @param {number|undefined} nb
  * @returns {Function}
  */
-export function createDashUrlDetokenizer(time, nb) {
+function createDashUrlDetokenizer(time, nb) {
     /**
      * Replace the tokens in the given `url` by the segment information defined
      * by the outer function.
@@ -92,13 +97,13 @@ export function createDashUrlDetokenizer(time, nb) {
         else {
             return url
                 .replace(/\$\$/g, "$")
-                .replace(/\$Number(\%0(\d+)d)?\$/g, function (_x, _y, widthStr) {
+                .replace(/\$Number(\%0(\d+)d)?\$/g, (_x, _y, widthStr) => {
                 if (nb === undefined) {
                     throw new Error("Segment number not defined in a $Number$ scheme");
                 }
                 return processFormatedToken(nb)(_x, _y, widthStr);
             })
-                .replace(/\$Time(\%0(\d+)d)?\$/g, function (_x, _y, widthStr) {
+                .replace(/\$Time(\%0(\d+)d)?\$/g, (_x, _y, widthStr) => {
                 if (time === undefined) {
                     throw new Error("Segment time not defined in a $Time$ scheme");
                 }
@@ -107,3 +112,4 @@ export function createDashUrlDetokenizer(time, nb) {
         }
     };
 }
+exports.createDashUrlDetokenizer = createDashUrlDetokenizer;