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

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,48 +14,55 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../../../config";
-import log from "../../../../../log";
-import assert from "../../../../../utils/assert";
-import isNullOrUndefined from "../../../../../utils/is_null_or_undefined";
-import getInitSegment from "./get_init_segment";
-import { createDashUrlDetokenizer, constructRepresentationUrl, } from "./tokens";
-import { getSegmentTimeRoundingError } from "./utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../../../config");
+const log_1 = require("../../../../../log");
+const assert_1 = require("../../../../../utils/assert");
+const is_null_or_undefined_1 = require("../../../../../utils/is_null_or_undefined");
+const get_init_segment_1 = require("./get_init_segment");
+const tokens_1 = require("./tokens");
+const utils_1 = require("./utils");
 /**
  * IRepresentationIndex implementation for DASH' SegmentTemplate without a
  * SegmentTimeline.
  * @class TemplateRepresentationIndex
  */
-var TemplateRepresentationIndex = /** @class */ (function () {
+class TemplateRepresentationIndex {
     /**
      * @param {Object} index
      * @param {Object} context
      */
-    function TemplateRepresentationIndex(index, context) {
+    constructor(index, context) {
         var _a, _b;
-        var availabilityTimeOffset = context.availabilityTimeOffset, manifestBoundsCalculator = context.manifestBoundsCalculator, isDynamic = context.isDynamic, periodEnd = context.periodEnd, periodStart = context.periodStart, representationId = context.representationId, representationBitrate = context.representationBitrate, isEMSGWhitelisted = context.isEMSGWhitelisted;
-        var timescale = (_a = index.timescale) !== null && _a !== void 0 ? _a : 1;
+        const { availabilityTimeOffset, manifestBoundsCalculator, isDynamic, periodEnd, periodStart, representationId, representationBitrate, isEMSGWhitelisted } = context;
+        const timescale = (_a = index.timescale) !== null && _a !== void 0 ? _a : 1;
         this._availabilityTimeOffset = availabilityTimeOffset;
         this._manifestBoundsCalculator = manifestBoundsCalculator;
-        var presentationTimeOffset = index.presentationTimeOffset != null ?
+        const presentationTimeOffset = index.presentationTimeOffset != null ?
             index.presentationTimeOffset :
             0;
-        var scaledStart = periodStart * timescale;
-        var indexTimeOffset = presentationTimeOffset - scaledStart;
+        const scaledStart = periodStart * timescale;
+        const indexTimeOffset = presentationTimeOffset - scaledStart;
         if (index.duration === undefined) {
             throw new Error("Invalid SegmentTemplate: no duration");
         }
-        var initializationUrl = ((_b = index.initialization) === null || _b === void 0 ? void 0 : _b.media) === undefined ?
+        const initializationUrl = ((_b = index.initialization) === null || _b === void 0 ? void 0 : _b.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 = { duration: index.duration, timescale: timescale, indexRange: index.indexRange, indexTimeOffset: indexTimeOffset, initialization: index.initialization == null ?
+            (0, tokens_1.constructRepresentationUrl)(index.media, representationId, representationBitrate);
+        this._index = { duration: index.duration,
+            timescale,
+            indexRange: index.indexRange,
+            indexTimeOffset,
+            initialization: index.initialization == null ?
                 undefined :
                 { url: initializationUrl,
                     range: index.initialization.range },
-            url: segmentUrlTemplate, presentationTimeOffset: presentationTimeOffset, startNumber: index.startNumber,
+            url: segmentUrlTemplate,
+            presentationTimeOffset,
+            startNumber: index.startNumber,
             endNumber: index.endNumber };
         this._isDynamic = isDynamic;
         this._periodStart = periodStart;
@@ -67,55 +75,55 @@ var TemplateRepresentationIndex = /** @class */ (function () {
      * Construct init Segment.
      * @returns {Object}
      */
-    TemplateRepresentationIndex.prototype.getInitSegment = function () {
-        return getInitSegment(this._index, this._isEMSGWhitelisted);
-    };
+    getInitSegment() {
+        return (0, get_init_segment_1.default)(this._index, this._isEMSGWhitelisted);
+    }
     /**
      * @param {Number} fromTime
      * @param {Number} dur
      * @returns {Array.<Object>}
      */
-    TemplateRepresentationIndex.prototype.getSegments = function (fromTime, dur) {
-        var index = this._index;
-        var duration = index.duration, startNumber = index.startNumber, endNumber = index.endNumber, timescale = index.timescale, url = index.url;
-        var scaledStart = this._periodStart * timescale;
-        var scaledEnd = this._scaledRelativePeriodEnd;
+    getSegments(fromTime, dur) {
+        const index = this._index;
+        const { duration, startNumber, endNumber, timescale, url } = index;
+        const scaledStart = this._periodStart * timescale;
+        const 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;
-        var toFromPeriodStart = (fromTime + dur) * timescale - scaledStart;
-        var firstSegmentStart = this._getFirstSegmentStart();
-        var lastSegmentStart = this._getLastSegmentStart();
+        const upFromPeriodStart = fromTime * timescale - scaledStart;
+        const toFromPeriodStart = (fromTime + dur) * timescale - scaledStart;
+        const firstSegmentStart = this._getFirstSegmentStart();
+        const lastSegmentStart = this._getLastSegmentStart();
         if (firstSegmentStart == null || lastSegmentStart == null) {
             return [];
         }
-        var startPosition = Math.max(firstSegmentStart, upFromPeriodStart);
-        var lastWantedStartPosition = Math.min(lastSegmentStart, toFromPeriodStart);
+        const startPosition = Math.max(firstSegmentStart, upFromPeriodStart);
+        const lastWantedStartPosition = Math.min(lastSegmentStart, toFromPeriodStart);
         if ((lastWantedStartPosition + duration) <= startPosition) {
             return [];
         }
-        var segments = [];
+        const segments = [];
         // number corresponding to the Period's start
-        var numberOffset = startNumber !== null && startNumber !== void 0 ? startNumber : 1;
+        const numberOffset = startNumber !== null && startNumber !== void 0 ? startNumber : 1;
         // calcul initial time from Period start, where the first segment would have
         // the `0` number
-        var numberIndexedToZero = Math.floor(startPosition / duration);
-        for (var timeFromPeriodStart = numberIndexedToZero * duration; timeFromPeriodStart <= lastWantedStartPosition; timeFromPeriodStart += duration) {
+        let numberIndexedToZero = Math.floor(startPosition / duration);
+        for (let timeFromPeriodStart = numberIndexedToZero * duration; timeFromPeriodStart <= lastWantedStartPosition; timeFromPeriodStart += duration) {
             // To obtain the real number, adds the real number from the Period's start
-            var realNumber = numberIndexedToZero + numberOffset;
+            const realNumber = numberIndexedToZero + numberOffset;
             if (endNumber !== undefined && realNumber > endNumber) {
                 return segments;
             }
-            var realDuration = scaledEnd != null &&
+            const realDuration = scaledEnd != null &&
                 timeFromPeriodStart + duration > scaledEnd ?
                 scaledEnd - timeFromPeriodStart :
                 duration;
-            var realTime = timeFromPeriodStart + scaledStart;
-            var manifestTime = timeFromPeriodStart + this._index.presentationTimeOffset;
-            var detokenizedURL = url === null ?
+            const realTime = timeFromPeriodStart + scaledStart;
+            const manifestTime = timeFromPeriodStart + this._index.presentationTimeOffset;
+            const detokenizedURL = url === null ?
                 null :
-                createDashUrlDetokenizer(manifestTime, realNumber)(url);
-            var args = { id: String(realNumber),
+                (0, tokens_1.createDashUrlDetokenizer)(manifestTime, realNumber)(url);
+            const args = { id: String(realNumber),
                 number: realNumber,
                 time: realTime / timescale,
                 end: (realTime + realDuration) / timescale,
@@ -133,52 +141,52 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             numberIndexedToZero++;
         }
         return segments;
-    };
+    }
     /**
      * Returns first possible position in the index, in seconds.
      * @returns {number|null|undefined}
      */
-    TemplateRepresentationIndex.prototype.getFirstAvailablePosition = function () {
-        var firstSegmentStart = this._getFirstSegmentStart();
+    getFirstAvailablePosition() {
+        const firstSegmentStart = this._getFirstSegmentStart();
         if (firstSegmentStart == null) {
             return firstSegmentStart; // return undefined or null
         }
         return (firstSegmentStart / this._index.timescale) + this._periodStart;
-    };
+    }
     /**
      * Returns last possible position in the index, in seconds.
      * @returns {number|null}
      */
-    TemplateRepresentationIndex.prototype.getLastAvailablePosition = function () {
-        var lastSegmentStart = this._getLastSegmentStart();
-        if (isNullOrUndefined(lastSegmentStart)) {
+    getLastAvailablePosition() {
+        const lastSegmentStart = this._getLastSegmentStart();
+        if ((0, is_null_or_undefined_1.default)(lastSegmentStart)) {
             // 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 scaledRelativeIndexEnd = this._estimateRelativeScaledEnd();
-        var lastSegmentEnd = Math.min(lastSegmentStart + this._index.duration, scaledRelativeIndexEnd !== null && scaledRelativeIndexEnd !== void 0 ? scaledRelativeIndexEnd : Infinity);
+        const scaledRelativeIndexEnd = this._estimateRelativeScaledEnd();
+        const lastSegmentEnd = Math.min(lastSegmentStart + this._index.duration, scaledRelativeIndexEnd !== null && scaledRelativeIndexEnd !== void 0 ? scaledRelativeIndexEnd : 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 () {
+    getEnd() {
         if (!this._isDynamic) {
             return this.getLastAvailablePosition();
         }
-        var scaledRelativeIndexEnd = this._estimateRelativeScaledEnd();
+        const scaledRelativeIndexEnd = this._estimateRelativeScaledEnd();
         if (scaledRelativeIndexEnd === undefined) {
             return undefined;
         }
-        var timescale = this._index.timescale;
-        var absoluteScaledIndexEnd = (scaledRelativeIndexEnd +
+        const { timescale } = this._index;
+        const absoluteScaledIndexEnd = (scaledRelativeIndexEnd +
             this._periodStart * timescale);
         return absoluteScaledIndexEnd / timescale;
-    };
+    }
     /**
      * Returns:
      *   - `true` if in the given time interval, at least one new segment is
@@ -191,37 +199,37 @@ var TemplateRepresentationIndex = /** @class */ (function () {
      * be directly available.
      * @returns {boolean}
      */
-    TemplateRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
-        assert(start <= end);
+    awaitSegmentBetween(start, end) {
+        (0, assert_1.default)(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;
-        var relativeScaledIndexEnd = this._estimateRelativeScaledEnd();
+        const { timescale } = this._index;
+        const segmentTimeRounding = (0, utils_1.getSegmentTimeRoundingError)(timescale);
+        const scaledPeriodStart = this._periodStart * timescale;
+        const scaledRelativeEnd = end * timescale - scaledPeriodStart;
+        const relativeScaledIndexEnd = this._estimateRelativeScaledEnd();
         if (relativeScaledIndexEnd === undefined) {
             return (scaledRelativeEnd + segmentTimeRounding) >= 0;
         }
-        var scaledRelativeStart = start * timescale - scaledPeriodStart;
+        const scaledRelativeStart = start * timescale - scaledPeriodStart;
         return (scaledRelativeStart - segmentTimeRounding) < relativeScaledIndexEnd;
-    };
+    }
     /**
      * Returns true if, based on the arguments, the index should be refreshed.
      * We never have to refresh a SegmentTemplate-based manifest.
      * @returns {Boolean}
      */
-    TemplateRepresentationIndex.prototype.shouldRefresh = function () {
+    shouldRefresh() {
         return false;
-    };
+    }
     /**
      * We cannot check for discontinuity in SegmentTemplate-based indexes.
      * @returns {null}
      */
-    TemplateRepresentationIndex.prototype.checkDiscontinuity = function () {
+    checkDiscontinuity() {
         return null;
-    };
+    }
     /**
      * Returns `true` if the given segment should still be available as of now
      * (not removed since and still request-able).
@@ -230,25 +238,25 @@ var TemplateRepresentationIndex = /** @class */ (function () {
      * @param {Object} segment
      * @returns {boolean|undefined}
      */
-    TemplateRepresentationIndex.prototype.isSegmentStillAvailable = function (segment) {
+    isSegmentStillAvailable(segment) {
         if (segment.isInit) {
             return true;
         }
-        var segmentsForTime = this.getSegments(segment.time, 0.1);
+        const segmentsForTime = this.getSegments(segment.time, 0.1);
         if (segmentsForTime.length === 0) {
             return false;
         }
         return segmentsForTime[0].time === segment.time &&
             segmentsForTime[0].end === segment.end &&
             segmentsForTime[0].number === segment.number;
-    };
+    }
     /**
      * SegmentTemplate without a SegmentTimeline should not be updated.
      * @returns {Boolean}
      */
-    TemplateRepresentationIndex.prototype.canBeOutOfSyncError = function () {
+    canBeOutOfSyncError() {
         return false;
-    };
+    }
     /**
      * Returns `true` if the last segments in this index have already been
      * generated so that we can freely go to the next period.
@@ -256,61 +264,61 @@ var TemplateRepresentationIndex = /** @class */ (function () {
      * generated.
      * @returns {Boolean}
      */
-    TemplateRepresentationIndex.prototype.isFinished = function () {
+    isFinished() {
         if (!this._isDynamic) {
             return true;
         }
-        var scaledRelativeIndexEnd = this._estimateRelativeScaledEnd();
+        const scaledRelativeIndexEnd = this._estimateRelativeScaledEnd();
         if (scaledRelativeIndexEnd === undefined) {
             return false;
         }
-        var timescale = this._index.timescale;
-        var lastSegmentStart = this._getLastSegmentStart();
+        const { timescale } = this._index;
+        const lastSegmentStart = this._getLastSegmentStart();
         // As last segment start is null if live time is before
         // current period, consider the index not to be finished.
-        if (isNullOrUndefined(lastSegmentStart)) {
+        if ((0, is_null_or_undefined_1.default)(lastSegmentStart)) {
             return false;
         }
-        var lastSegmentEnd = lastSegmentStart + this._index.duration;
-        var segmentTimeRounding = getSegmentTimeRoundingError(timescale);
+        const lastSegmentEnd = lastSegmentStart + this._index.duration;
+        const segmentTimeRounding = (0, utils_1.getSegmentTimeRoundingError)(timescale);
         return (lastSegmentEnd + segmentTimeRounding) >= scaledRelativeIndexEnd;
-    };
+    }
     /**
      * @returns {Boolean}
      */
-    TemplateRepresentationIndex.prototype.isInitialized = function () {
+    isInitialized() {
         return true;
-    };
-    TemplateRepresentationIndex.prototype.initialize = function () {
-        log.error("A `TemplateRepresentationIndex` does not need to be initialized");
-    };
-    TemplateRepresentationIndex.prototype.addPredictedSegments = function () {
-        log.warn("Cannot add predicted segments to a `TemplateRepresentationIndex`");
-    };
+    }
+    initialize() {
+        log_1.default.error("A `TemplateRepresentationIndex` does not need to be initialized");
+    }
+    addPredictedSegments() {
+        log_1.default.warn("Cannot add predicted segments to a `TemplateRepresentationIndex`");
+    }
     /**
      * @param {Object} newIndex
      */
-    TemplateRepresentationIndex.prototype._replace = function (newIndex) {
+    _replace(newIndex) {
         this._index = newIndex._index;
         this._isDynamic = newIndex._isDynamic;
         this._periodStart = newIndex._periodStart;
         this._scaledRelativePeriodEnd = newIndex._scaledRelativePeriodEnd;
         this._manifestBoundsCalculator = newIndex._manifestBoundsCalculator;
-    };
+    }
     /**
      * @param {Object} newIndex
      */
-    TemplateRepresentationIndex.prototype._update = function (newIndex) {
+    _update(newIndex) {
         // As segments are not declared individually, as long as this Representation
         // is present, we have every information we need
         this._replace(newIndex);
-    };
+    }
     /**
      * Returns the timescaled start of the first segment that should be available,
      * relatively to the start of the Period.
      * @returns {number | null | undefined}
      */
-    TemplateRepresentationIndex.prototype._getFirstSegmentStart = function () {
+    _getFirstSegmentStart() {
         if (!this._isDynamic) {
             return 0; // it is the start of the Period
         }
@@ -320,42 +328,42 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             // /!\ The scaled max position augments continuously and might not
             // reflect exactly the real server-side value. As segments are
             // generated discretely.
-            var maximumBound = this._manifestBoundsCalculator.estimateMaximumBound();
+            const maximumBound = this._manifestBoundsCalculator.estimateMaximumBound();
             if (maximumBound !== undefined && maximumBound < this._periodStart) {
                 // Maximum position is before this period.
                 // No segment is yet available here
                 return null;
             }
         }
-        var _a = this._index, duration = _a.duration, timescale = _a.timescale;
-        var firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
+        const { duration, timescale } = this._index;
+        const firstPosition = this._manifestBoundsCalculator.estimateMinimumBound();
         if (firstPosition === undefined) {
             return undefined;
         }
-        var segmentTime = firstPosition > this._periodStart ?
+        const segmentTime = firstPosition > this._periodStart ?
             (firstPosition - this._periodStart) * timescale :
             0;
-        var numberIndexedToZero = Math.floor(segmentTime / duration);
+        const numberIndexedToZero = Math.floor(segmentTime / duration);
         return numberIndexedToZero * duration;
-    };
+    }
     /**
      * Returns the timescaled start of the last segment that should be available,
      * relatively to the start of the Period.
      * Returns null if live time is before current period.
      * @returns {number|null|undefined}
      */
-    TemplateRepresentationIndex.prototype._getLastSegmentStart = function () {
+    _getLastSegmentStart() {
         var _a;
-        var _b = this._index, duration = _b.duration, timescale = _b.timescale, endNumber = _b.endNumber, _c = _b.startNumber, startNumber = _c === void 0 ? 1 : _c;
+        const { duration, timescale, endNumber, startNumber = 1 } = this._index;
         if (this._isDynamic) {
-            var lastPos = this._manifestBoundsCalculator.estimateMaximumBound();
+            const lastPos = this._manifestBoundsCalculator.estimateMaximumBound();
             if (lastPos === undefined) {
                 return undefined;
             }
             if (this._scaledRelativePeriodEnd !== undefined &&
                 this._scaledRelativePeriodEnd <
                     (lastPos - this._periodStart) * this._index.timescale) {
-                var numberOfSegments = Math.ceil(this._scaledRelativePeriodEnd / duration);
+                let numberOfSegments = Math.ceil(this._scaledRelativePeriodEnd / duration);
                 if (endNumber !== undefined && (endNumber - startNumber + 1) < numberOfSegments) {
                     numberOfSegments = endNumber - startNumber + 1;
                 }
@@ -364,15 +372,15 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             // /!\ The scaled last position augments continuously and might not
             // reflect exactly the real server-side value. As segments are
             // generated discretely.
-            var scaledLastPosition = (lastPos - this._periodStart) * timescale;
+            const scaledLastPosition = (lastPos - this._periodStart) * timescale;
             // Maximum position is before this period.
             // No segment is yet available here
             if (scaledLastPosition < 0) {
                 return null;
             }
-            var availabilityTimeOffset = ((this._availabilityTimeOffset !== undefined ? this._availabilityTimeOffset : 0))
+            const availabilityTimeOffset = ((this._availabilityTimeOffset !== undefined ? this._availabilityTimeOffset : 0))
                 * timescale;
-            var numberOfSegmentsAvailable = Math.floor((scaledLastPosition + availabilityTimeOffset) / duration);
+            let numberOfSegmentsAvailable = Math.floor((scaledLastPosition + availabilityTimeOffset) / duration);
             if (endNumber !== undefined &&
                 (endNumber - startNumber + 1) < numberOfSegmentsAvailable) {
                 numberOfSegmentsAvailable = endNumber - startNumber + 1;
@@ -382,17 +390,17 @@ var TemplateRepresentationIndex = /** @class */ (function () {
                 (numberOfSegmentsAvailable - 1) * duration;
         }
         else {
-            var maximumTime = (_a = this._scaledRelativePeriodEnd) !== null && _a !== void 0 ? _a : 0;
-            var numberOfSegments = Math.ceil(maximumTime / duration);
+            const maximumTime = (_a = this._scaledRelativePeriodEnd) !== null && _a !== void 0 ? _a : 0;
+            let numberOfSegments = Math.ceil(maximumTime / duration);
             if (endNumber !== undefined && (endNumber - startNumber + 1) < numberOfSegments) {
                 numberOfSegments = endNumber - startNumber + 1;
             }
-            var regularLastSegmentStart = (numberOfSegments - 1) * duration;
+            const regularLastSegmentStart = (numberOfSegments - 1) * duration;
             // In some SegmentTemplate, we could think that there is one more
             // segment that there actually is due to a very little difference between
             // the period's duration and a multiple of a segment's duration.
             // Check that we're within a good margin
-            var minimumDuration = config.getCurrent().MINIMUM_SEGMENT_SIZE * timescale;
+            const minimumDuration = config_1.default.getCurrent().MINIMUM_SEGMENT_SIZE * timescale;
             if (endNumber !== undefined ||
                 maximumTime - regularLastSegmentStart > minimumDuration ||
                 numberOfSegments < 2) {
@@ -400,7 +408,7 @@ var TemplateRepresentationIndex = /** @class */ (function () {
             }
             return (numberOfSegments - 2) * duration;
         }
-    };
+    }
     /**
      * Returns an estimate of the last available position in this
      * `RepresentationIndex` based on attributes such as the Period's end and
@@ -409,17 +417,16 @@ var TemplateRepresentationIndex = /** @class */ (function () {
      * generated and its end is yet unknown), returns `undefined`.
      * @returns {number|undefined}
      */
-    TemplateRepresentationIndex.prototype._estimateRelativeScaledEnd = function () {
+    _estimateRelativeScaledEnd() {
         var _a, _b;
         if (this._index.endNumber !== undefined) {
-            var numberOfSegments = this._index.endNumber - ((_a = this._index.startNumber) !== null && _a !== void 0 ? _a : 1) + 1;
+            const numberOfSegments = this._index.endNumber - ((_a = this._index.startNumber) !== null && _a !== void 0 ? _a : 1) + 1;
             return Math.max(Math.min(numberOfSegments * this._index.duration, (_b = this._scaledRelativePeriodEnd) !== null && _b !== void 0 ? _b : Infinity), 0);
         }
         if (this._scaledRelativePeriodEnd === undefined) {
             return undefined;
         }
         return Math.max(this._scaledRelativePeriodEnd, 0);
-    };
-    return TemplateRepresentationIndex;
-}());
-export default TemplateRepresentationIndex;
+    }
+}
+exports.default = TemplateRepresentationIndex;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,8 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import convertElementsToIndexSegment from "./convert_element_to_index_segment";
-import parseSElement from "./parse_s_element";
+Object.defineProperty(exports, "__esModule", { value: true });
+const convert_element_to_index_segment_1 = require("./convert_element_to_index_segment");
+const parse_s_element_1 = require("./parse_s_element");
 /**
  * Allows to generate the "timeline" for the "Timeline" RepresentationIndex.
  * Call this function when the timeline is unknown.
@@ -24,24 +26,25 @@ import parseSElement from "./parse_s_element";
  * SegmentTimeline node.
  * @returns {Array.<Object>}
  */
-export default function constructTimelineFromElements(elements) {
-    var initialTimeline = [];
-    for (var i = 0; i < elements.length; i++) {
-        initialTimeline.push(parseSElement(elements[i]));
+function constructTimelineFromElements(elements) {
+    const initialTimeline = [];
+    for (let i = 0; i < elements.length; i++) {
+        initialTimeline.push((0, parse_s_element_1.default)(elements[i]));
     }
-    var timeline = [];
-    for (var i = 0; i < initialTimeline.length; i++) {
-        var item = initialTimeline[i];
-        var previousItem = timeline[timeline.length - 1] === undefined ?
+    const timeline = [];
+    for (let i = 0; i < initialTimeline.length; i++) {
+        const item = initialTimeline[i];
+        const previousItem = timeline[timeline.length - 1] === undefined ?
             null :
             timeline[timeline.length - 1];
-        var nextItem = initialTimeline[i + 1] === undefined ?
+        const nextItem = initialTimeline[i + 1] === undefined ?
             null :
             initialTimeline[i + 1];
-        var timelineElement = convertElementsToIndexSegment(item, previousItem, nextItem);
+        const timelineElement = (0, convert_element_to_index_segment_1.default)(item, previousItem, nextItem);
         if (timelineElement !== null) {
             timeline.push(timelineElement);
         }
     }
     return timeline;
 }
+exports.default = constructTimelineFromElements;