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

package/dist/_esm5.processed/parsers/manifest/smooth/representation_index.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,14 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-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 index_helpers_1 = require("../utils/index_helpers");
-const is_segment_still_available_1 = require("../utils/is_segment_still_available");
-const tokens_1 = require("./utils/tokens");
+import { NetworkError } from "../../../errors";
+import log from "../../../log";
+import assert from "../../../utils/assert";
+import clearTimelineFromPosition from "../utils/clear_timeline_from_position";
+import { checkDiscontinuity, getIndexSegmentEnd, } from "../utils/index_helpers";
+import isSegmentStillAvailable from "../utils/is_segment_still_available";
+import updateSegmentTimeline from "../utils/update_segment_timeline";
+import addSegmentInfos from "./utils/add_segment_infos";
+import { replaceSegmentSmoothTokens } from "./utils/tokens";
 /**
  * @param {Number} start
  * @param {Number} up
@@ -29,7 +29,7 @@ const tokens_1 = require("./utils/tokens");
  * @returns {Number}
  */
 function getSegmentNumber(start, up, duration) {
-    const diff = up - start;
+    var diff = up - start;
     return diff > 0 ? Math.floor(diff / duration) :
         0;
 }
@@ -43,12 +43,12 @@ function getSegmentNumber(start, up, duration) {
  *   - up {Number}: timescaled timestamp of the beginning time
  *   - to {Number}: timescaled timestamp of the end time (start time + duration)
  */
-function normalizeRange(timescale, start, duration) {
-    const ts = timescale === undefined ||
-        timescale === 0 ? 1 :
-        timescale;
-    return { up: start * ts,
-        to: (start + duration) * ts };
+function normalizeRange(index, start, duration) {
+    var timescale = index.timescale === undefined ||
+        index.timescale === 0 ? 1 :
+        index.timescale;
+    return { up: start * timescale,
+        to: (start + duration) * timescale };
 }
 /**
  * Calculate the number of times a segment repeat based on the next segment.
@@ -57,14 +57,14 @@ function normalizeRange(timescale, start, duration) {
  * @returns {Number}
  */
 function calculateRepeat(segment, nextSegment) {
-    let repeatCount = segment.repeatCount;
+    var repeatCount = segment.repeatCount;
     // A negative value of the @r attribute of the S element indicates
     // that the duration indicated in @d attribute repeats until the
     // start of the next S element, the end of the Period or until the
     // next MPD update.
     // TODO Also for SMOOTH????
-    if (segment.duration !== undefined && repeatCount < 0) {
-        const repeatEnd = nextSegment !== undefined ? nextSegment.start :
+    if (segment.duration != null && repeatCount < 0) {
+        var repeatEnd = nextSegment !== undefined ? nextSegment.start :
             Infinity;
         repeatCount = Math.ceil((repeatEnd - segment.start) / segment.duration) - 1;
     }
@@ -77,40 +77,44 @@ function calculateRepeat(segment, nextSegment) {
  *
  * @class SmoothRepresentationIndex
  */
-class SmoothRepresentationIndex {
+var SmoothRepresentationIndex = /** @class */ (function () {
     /**
      * Creates a new `SmoothRepresentationIndex`.
      * @param {Object} index
      * @param {Object} options
      */
-    constructor(options) {
-        const { isLive, segmentPrivateInfos, media, sharedSmoothTimeline } = options;
-        this._sharedSmoothTimeline = sharedSmoothTimeline;
+    function SmoothRepresentationIndex(index, options) {
+        var aggressiveMode = options.aggressiveMode, isLive = options.isLive, segmentPrivateInfos = options.segmentPrivateInfos, timeShiftBufferDepth = options.timeShiftBufferDepth;
+        var estimatedReceivedTime = options.manifestReceivedTime == null ?
+            performance.now() :
+            options.manifestReceivedTime;
+        this._index = index;
+        this._indexValidityTime = estimatedReceivedTime;
+        this._timeShiftBufferDepth = timeShiftBufferDepth;
         this._initSegmentInfos = { bitsPerSample: segmentPrivateInfos.bitsPerSample,
             channels: segmentPrivateInfos.channels,
             codecPrivateData: segmentPrivateInfos.codecPrivateData,
             packetSize: segmentPrivateInfos.packetSize,
             samplingRate: segmentPrivateInfos.samplingRate,
-            timescale: sharedSmoothTimeline.timescale,
-            height: segmentPrivateInfos.height,
-            width: segmentPrivateInfos.width,
+            timescale: index.timescale,
             protection: segmentPrivateInfos.protection };
+        this._isAggressiveMode = aggressiveMode;
         this._isLive = isLive;
-        this._media = media;
-        if (sharedSmoothTimeline.timeline.length !== 0 && isLive) {
-            const { timeline, validityTime } = sharedSmoothTimeline;
-            const lastItem = timeline[timeline.length - 1];
-            const scaledEnd = (0, index_helpers_1.getIndexSegmentEnd)(lastItem, null);
-            const scaledTimelineValidityTime = (validityTime / 1000) *
-                sharedSmoothTimeline.timescale;
-            this._scaledLiveGap = scaledTimelineValidityTime - scaledEnd;
+        if (index.timeline.length !== 0) {
+            var lastItem = index.timeline[index.timeline.length - 1];
+            var scaledEnd = getIndexSegmentEnd(lastItem, null);
+            this._initialScaledLastPosition = scaledEnd;
+            if (isLive) {
+                var scaledReceivedTime = (estimatedReceivedTime / 1000) * index.timescale;
+                this._scaledLiveGap = scaledReceivedTime - scaledEnd;
+            }
         }
     }
     /**
      * Construct init Segment compatible with a Smooth Manifest.
      * @returns {Object}
      */
-    getInitSegment() {
+    SmoothRepresentationIndex.prototype.getInitSegment = function () {
         return { id: "init",
             isInit: true,
             privateInfos: { smoothInitSegment: this._initSegmentInfos },
@@ -120,7 +124,7 @@ class SmoothRepresentationIndex {
             duration: 0,
             timescale: 1,
             complete: true };
-    }
+    };
     /**
      * Generate a list of Segments for a particular period of time.
      *
@@ -128,43 +132,41 @@ class SmoothRepresentationIndex {
      * @param {Number} dur
      * @returns {Array.<Object>}
      */
-    getSegments(from, dur) {
+    SmoothRepresentationIndex.prototype.getSegments = function (from, dur) {
         this._refreshTimeline();
-        const { timescale, timeline } = this._sharedSmoothTimeline;
-        const { up, to } = normalizeRange(timescale, from, dur);
-        const media = this._media;
-        let currentNumber;
-        const segments = [];
-        const timelineLength = timeline.length;
-        const maxPosition = this._scaledLiveGap === undefined ?
+        var _a = normalizeRange(this._index, from, dur), up = _a.up, to = _a.to;
+        var _b = this._index, timeline = _b.timeline, timescale = _b.timescale, media = _b.media;
+        var isAggressive = this._isAggressiveMode;
+        var currentNumber;
+        var segments = [];
+        var timelineLength = timeline.length;
+        var maxPosition = this._scaledLiveGap == null ?
             undefined :
-            (((0, monotonic_timestamp_1.default)() / 1000) * timescale) - this._scaledLiveGap;
-        for (let i = 0; i < timelineLength; i++) {
-            const segmentRange = timeline[i];
-            const { duration, start } = segmentRange;
-            const repeat = calculateRepeat(segmentRange, timeline[i + 1]);
-            let segmentNumberInCurrentRange = getSegmentNumber(start, up, duration);
-            let segmentTime = start + segmentNumberInCurrentRange * duration;
-            const timeToAddToCheckMaxPosition = duration;
+            ((performance.now() / 1000) * timescale) - this._scaledLiveGap;
+        for (var i = 0; i < timelineLength; i++) {
+            var segmentRange = timeline[i];
+            var duration = segmentRange.duration, start = segmentRange.start;
+            var repeat = calculateRepeat(segmentRange, timeline[i + 1]);
+            var segmentNumberInCurrentRange = getSegmentNumber(start, up, duration);
+            var segmentTime = start + segmentNumberInCurrentRange * duration;
+            var timeToAddToCheckMaxPosition = isAggressive ? 0 :
+                duration;
             while (segmentTime < to &&
                 segmentNumberInCurrentRange <= repeat &&
-                (maxPosition === undefined ||
+                (maxPosition == null ||
                     (segmentTime + timeToAddToCheckMaxPosition) <= maxPosition)) {
-                const time = segmentTime;
-                const number = currentNumber !== undefined ?
+                var time = segmentTime;
+                var number = currentNumber != null ?
                     currentNumber + segmentNumberInCurrentRange :
                     undefined;
-                const segment = { id: String(segmentTime),
+                var segment = { id: String(segmentTime),
                     isInit: false,
                     time: time / timescale,
                     end: (time + duration) / timescale,
                     duration: duration / timescale,
-                    timescale: 1,
-                    number,
-                    url: (0, tokens_1.replaceSegmentSmoothTokens)(media, time),
+                    timescale: 1, number: number, url: replaceSegmentSmoothTokens(media, time),
                     complete: true,
-                    privateInfos: { smoothMediaSegment: { time,
-                            duration } } };
+                    privateInfos: { smoothMediaSegment: { time: time, duration: duration } } };
                 segments.push(segment);
                 // update segment number and segment time for the next segment
                 segmentNumberInCurrentRange++;
@@ -174,12 +176,12 @@ class SmoothRepresentationIndex {
                 // we reached ``to``, we're done
                 return segments;
             }
-            if (currentNumber !== undefined) {
+            if (currentNumber != null) {
                 currentNumber += repeat + 1;
             }
         }
         return segments;
-    }
+    };
     /**
      * Returns true if, based on the arguments, the index should be refreshed.
      * (If we should re-fetch the manifest)
@@ -187,18 +189,18 @@ class SmoothRepresentationIndex {
      * @param {Number} to
      * @returns {Boolean}
      */
-    shouldRefresh(up, to) {
+    SmoothRepresentationIndex.prototype.shouldRefresh = function (up, to) {
         this._refreshTimeline();
         if (!this._isLive) {
             return false;
         }
-        const { timeline, timescale } = this._sharedSmoothTimeline;
-        const lastSegmentInCurrentTimeline = timeline[timeline.length - 1];
+        var _a = this._index, timeline = _a.timeline, timescale = _a.timescale;
+        var lastSegmentInCurrentTimeline = timeline[timeline.length - 1];
         if (lastSegmentInCurrentTimeline === undefined) {
             return false;
         }
-        const repeat = lastSegmentInCurrentTimeline.repeatCount;
-        const endOfLastSegmentInCurrentTimeline = lastSegmentInCurrentTimeline.start + (repeat + 1) *
+        var repeat = lastSegmentInCurrentTimeline.repeatCount;
+        var endOfLastSegmentInCurrentTimeline = lastSegmentInCurrentTimeline.start + (repeat + 1) *
             lastSegmentInCurrentTimeline.duration;
         if (to * timescale < endOfLastSegmentInCurrentTimeline) {
             return false;
@@ -207,58 +209,59 @@ class SmoothRepresentationIndex {
             return true;
         }
         // ----
-        const startOfLastSegmentInCurrentTimeline = lastSegmentInCurrentTimeline.start + repeat *
+        var startOfLastSegmentInCurrentTimeline = lastSegmentInCurrentTimeline.start + repeat *
             lastSegmentInCurrentTimeline.duration;
         return (up * timescale) > startOfLastSegmentInCurrentTimeline;
-    }
+    };
     /**
      * Returns first position available in the index.
      * @returns {Number|null}
      */
-    getFirstAvailablePosition() {
+    SmoothRepresentationIndex.prototype.getFirstAvailablePosition = function () {
         this._refreshTimeline();
-        const { timeline, timescale } = this._sharedSmoothTimeline;
-        if (timeline.length === 0) {
+        var index = this._index;
+        if (index.timeline.length === 0) {
             return null;
         }
-        return timeline[0].start / timescale;
-    }
+        return index.timeline[0].start / index.timescale;
+    };
     /**
      * Returns last position available in the index.
      * @returns {Number}
      */
-    getLastAvailablePosition() {
+    SmoothRepresentationIndex.prototype.getLastAvailablePosition = function () {
         this._refreshTimeline();
-        const { timeline, timescale } = this._sharedSmoothTimeline;
-        if (this._scaledLiveGap === undefined) {
-            const lastTimelineElement = timeline[timeline.length - 1];
-            return (0, index_helpers_1.getIndexSegmentEnd)(lastTimelineElement, null) / timescale;
+        var index = this._index;
+        if (this._scaledLiveGap == null) {
+            var lastTimelineElement = index.timeline[index.timeline.length - 1];
+            return getIndexSegmentEnd(lastTimelineElement, null) / index.timescale;
         }
-        for (let i = timeline.length - 1; i >= 0; i--) {
-            const timelineElt = timeline[i];
-            const timescaledNow = ((0, monotonic_timestamp_1.default)() / 1000) * timescale;
-            const { start, duration, repeatCount } = timelineElt;
-            for (let j = repeatCount; j >= 0; j--) {
-                const end = start + (duration * (j + 1));
-                const positionToReach = end;
+        for (var i = index.timeline.length - 1; i >= 0; i--) {
+            var timelineElt = index.timeline[i];
+            var timescaledNow = (performance.now() / 1000) * index.timescale;
+            var start = timelineElt.start, duration = timelineElt.duration, repeatCount = timelineElt.repeatCount;
+            for (var j = repeatCount; j >= 0; j--) {
+                var end = start + (duration * (j + 1));
+                var positionToReach = this._isAggressiveMode ? end - duration :
+                    end;
                 if (positionToReach <= timescaledNow - this._scaledLiveGap) {
-                    return end / timescale;
+                    return end / index.timescale;
                 }
             }
         }
         return undefined;
-    }
+    };
     /**
      * Returns the absolute end in seconds this RepresentationIndex can reach once
      * all segments are available.
      * @returns {number|null|undefined}
      */
-    getEnd() {
+    SmoothRepresentationIndex.prototype.getEnd = function () {
         if (!this._isLive) {
             return this.getLastAvailablePosition();
         }
         return undefined;
-    }
+    };
     /**
      * Returns:
      *   - `true` if in the given time interval, at least one new segment is
@@ -270,19 +273,19 @@ class SmoothRepresentationIndex {
      * @param {number} end
      * @returns {boolean|undefined}
      */
-    awaitSegmentBetween(start, end) {
+    SmoothRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
         var _a;
-        (0, assert_1.default)(start <= end);
+        assert(start <= end);
         if (this.isFinished()) {
             return false;
         }
-        const lastAvailablePosition = this.getLastAvailablePosition();
+        var lastAvailablePosition = this.getLastAvailablePosition();
         if (lastAvailablePosition !== undefined && end < lastAvailablePosition) {
             return false;
         }
         return end > ((_a = this.getFirstAvailablePosition()) !== null && _a !== void 0 ? _a : 0) ? undefined :
             false;
-    }
+    };
     /**
      * Checks if `timeSec` is in a discontinuity.
      * That is, if there's no segment available for the `timeSec` position.
@@ -292,10 +295,10 @@ class SmoothRepresentationIndex {
      * `time`. If this is a number instead, there is one and that number is the
      * position for which a segment is available in seconds.
      */
-    checkDiscontinuity(timeSec) {
+    SmoothRepresentationIndex.prototype.checkDiscontinuity = function (timeSec) {
         this._refreshTimeline();
-        return (0, index_helpers_1.checkDiscontinuity)(this._sharedSmoothTimeline, timeSec, undefined);
-    }
+        return checkDiscontinuity(this._index, timeSec, undefined);
+    };
     /**
      * Returns `true` if a Segment returned by this index is still considered
      * available.
@@ -304,45 +307,95 @@ class SmoothRepresentationIndex {
      * @param {Object} segment
      * @returns {Boolean|undefined}
      */
-    isSegmentStillAvailable(segment) {
+    SmoothRepresentationIndex.prototype.isSegmentStillAvailable = function (segment) {
         if (segment.isInit) {
             return true;
         }
         this._refreshTimeline();
-        const { timeline, timescale } = this._sharedSmoothTimeline;
-        return (0, is_segment_still_available_1.default)(segment, timeline, timescale, 0);
-    }
+        var _a = this._index, timeline = _a.timeline, timescale = _a.timescale;
+        return isSegmentStillAvailable(segment, timeline, timescale, 0);
+    };
     /**
      * @param {Error} error
      * @returns {Boolean}
      */
-    canBeOutOfSyncError(error) {
+    SmoothRepresentationIndex.prototype.canBeOutOfSyncError = function (error) {
         if (!this._isLive) {
             return false;
         }
-        return error instanceof errors_1.NetworkError &&
+        return error instanceof NetworkError &&
             (error.isHttpError(404) || error.isHttpError(412));
-    }
+    };
     /**
      * Replace this RepresentationIndex by a newly downloaded one.
      * Check if the old index had more information about new segments and re-add
      * them if that's the case.
      * @param {Object} newIndex
      */
-    _replace(newIndex) {
+    SmoothRepresentationIndex.prototype._replace = function (newIndex) {
+        var oldTimeline = this._index.timeline;
+        var newTimeline = newIndex._index.timeline;
+        var oldTimescale = this._index.timescale;
+        var newTimescale = newIndex._index.timescale;
+        this._index = newIndex._index;
         this._initialScaledLastPosition = newIndex._initialScaledLastPosition;
+        this._indexValidityTime = newIndex._indexValidityTime;
         this._scaledLiveGap = newIndex._scaledLiveGap;
-        this._sharedSmoothTimeline.replace(newIndex._sharedSmoothTimeline);
-    }
+        if (oldTimeline.length === 0 ||
+            newTimeline.length === 0 ||
+            oldTimescale !== newTimescale) {
+            return; // don't take risk, if something is off, take the new one
+        }
+        var lastOldTimelineElement = oldTimeline[oldTimeline.length - 1];
+        var lastNewTimelineElement = newTimeline[newTimeline.length - 1];
+        var newEnd = getIndexSegmentEnd(lastNewTimelineElement, null);
+        if (getIndexSegmentEnd(lastOldTimelineElement, null) <= newEnd) {
+            return;
+        }
+        for (var i = 0; i < oldTimeline.length; i++) {
+            var oldTimelineRange = oldTimeline[i];
+            var oldEnd = getIndexSegmentEnd(oldTimelineRange, null);
+            if (oldEnd === newEnd) { // just add the supplementary segments
+                this._index.timeline = this._index.timeline.concat(oldTimeline.slice(i + 1));
+                return;
+            }
+            if (oldEnd > newEnd) { // adjust repeatCount + add supplementary segments
+                if (oldTimelineRange.duration !== lastNewTimelineElement.duration) {
+                    return;
+                }
+                var rangeDuration = newEnd - oldTimelineRange.start;
+                if (rangeDuration === 0) {
+                    log.warn("Smooth Parser: a discontinuity detected in the previous manifest" +
+                        " has been resolved.");
+                    this._index.timeline = this._index.timeline.concat(oldTimeline.slice(i));
+                    return;
+                }
+                if (rangeDuration < 0 || rangeDuration % oldTimelineRange.duration !== 0) {
+                    return;
+                }
+                var repeatWithOld = (rangeDuration / oldTimelineRange.duration) - 1;
+                var relativeRepeat = oldTimelineRange.repeatCount - repeatWithOld;
+                if (relativeRepeat < 0) {
+                    return;
+                }
+                lastNewTimelineElement.repeatCount += relativeRepeat;
+                var supplementarySegments = oldTimeline.slice(i + 1);
+                this._index.timeline = this._index.timeline.concat(supplementarySegments);
+                return;
+            }
+        }
+    };
     /**
      * Update the current index with a new, partial, version.
      * This method might be use to only add information about new segments.
      * @param {Object} newIndex
      */
-    _update(newIndex) {
+    SmoothRepresentationIndex.prototype._update = function (newIndex) {
+        updateSegmentTimeline(this._index.timeline, newIndex._index.timeline);
+        this._initialScaledLastPosition = newIndex._initialScaledLastPosition;
+        this._indexValidityTime = newIndex._indexValidityTime;
         this._scaledLiveGap = newIndex._scaledLiveGap;
-        this._sharedSmoothTimeline.update(newIndex._sharedSmoothTimeline);
-    }
+    };
     /**
      * Returns `true` if the last segments in this index have already been
      * generated.
@@ -354,34 +407,48 @@ class SmoothRepresentationIndex {
      * TODO What about Smooth live content that finishes at some point?
      * @returns {boolean}
      */
-    isFinished() {
+    SmoothRepresentationIndex.prototype.isFinished = function () {
         return !this._isLive;
-    }
+    };
     /**
      * @returns {Boolean}
      */
-    isInitialized() {
+    SmoothRepresentationIndex.prototype.isInitialized = function () {
         return true;
-    }
-    initialize() {
-        log_1.default.error("A `SmoothRepresentationIndex` does not need to be initialized");
-    }
+    };
     /**
-     * Add segments to a `SharedSmoothSegmentTimeline` that were predicted to come
-     * after `currentSegment`.
+     * Add new segments to a `SmoothRepresentationIndex`.
      * @param {Array.<Object>} nextSegments - The segment information parsed.
      * @param {Object} segment - Information on the segment which contained that
      * new segment information.
      */
-    addPredictedSegments(nextSegments, currentSegment) {
-        this._sharedSmoothTimeline.addPredictedSegments(nextSegments, currentSegment);
-    }
+    SmoothRepresentationIndex.prototype.addNewSegments = function (nextSegments, currentSegment) {
+        this._refreshTimeline();
+        for (var i = 0; i < nextSegments.length; i++) {
+            addSegmentInfos(this._index, nextSegments[i], currentSegment);
+        }
+    };
     /**
      * Clean-up timeline to remove segment information which should not be
      * available due to the timeshift window
      */
-    _refreshTimeline() {
-        this._sharedSmoothTimeline.refresh();
-    }
-}
-exports.default = SmoothRepresentationIndex;
+    SmoothRepresentationIndex.prototype._refreshTimeline = function () {
+        // clean segments before time shift buffer depth
+        if (this._initialScaledLastPosition == null) {
+            return;
+        }
+        var index = this._index;
+        var timeShiftBufferDepth = this._timeShiftBufferDepth;
+        var timeSinceLastRealUpdate = (performance.now() -
+            this._indexValidityTime) / 1000;
+        var lastPositionEstimate = timeSinceLastRealUpdate +
+            this._initialScaledLastPosition / index.timescale;
+        if (timeShiftBufferDepth != null) {
+            var minimumPosition = (lastPositionEstimate - timeShiftBufferDepth) *
+                index.timescale;
+            clearTimelineFromPosition(index.timeline, minimumPosition);
+        }
+    };
+    return SmoothRepresentationIndex;
+}());
+export default SmoothRepresentationIndex;

package/dist/_esm5.processed/parsers/manifest/smooth/utils/add_segment_infos.d.ts

@@ -18,17 +18,20 @@ export interface IIndexSegment {
     duration: number;
     repeatCount: number;
 }
+export interface ITimelineIndex {
+    timescale: number;
+    timeline: IIndexSegment[];
+}
 /**
  * Add a new segment to the index.
  *
  * /!\ Mutate the given index
- * @param {Array.<Object>} timeline
- * @param {number} timescale
+ * @param {Object} index
  * @param {Object} newSegment
  * @param {Object} currentSegment
  * @returns {Boolean} - true if the segment has been added
  */
-export default function _addSegmentInfos(timeline: IIndexSegment[], timescale: number, newSegment: {
+export default function _addSegmentInfos(index: ITimelineIndex, newSegment: {
     time: number;
     duration: number;
     timescale: number;

package/dist/_esm5.processed/parsers/manifest/smooth/utils/add_segment_infos.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,22 +13,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_helpers_1 = require("../../utils/index_helpers");
+import { getIndexSegmentEnd } from "../../utils/index_helpers";
 /**
  * Add a new segment to the index.
  *
  * /!\ Mutate the given index
- * @param {Array.<Object>} timeline
- * @param {number} timescale
+ * @param {Object} index
  * @param {Object} newSegment
  * @param {Object} currentSegment
  * @returns {Boolean} - true if the segment has been added
  */
-function _addSegmentInfos(timeline, timescale, newSegment, currentSegment) {
-    const timelineLength = timeline.length;
-    const last = timeline[timelineLength - 1];
-    const scaledNewSegment = newSegment.timescale === timescale ?
+export default function _addSegmentInfos(index, newSegment, currentSegment) {
+    var timeline = index.timeline, timescale = index.timescale;
+    var timelineLength = timeline.length;
+    var last = timeline[timelineLength - 1];
+    var scaledNewSegment = newSegment.timescale === timescale ?
         { time: newSegment.time,
             duration: newSegment.duration } :
         { time: (newSegment.time / newSegment.timescale) * timescale,
@@ -40,11 +38,11 @@ function _addSegmentInfos(timeline, timescale, newSegment, currentSegment) {
     // segment and have the same start.
     // However, we prefer to be sure of the duration of the new segments
     // before adding such segments.
-    const shouldDeductNextSegment = currentSegment.time === scaledNewSegment.time;
+    var shouldDeductNextSegment = currentSegment.time === scaledNewSegment.time;
     if (shouldDeductNextSegment) {
         return false;
     }
-    else if (scaledNewSegment.time >= (0, index_helpers_1.getIndexSegmentEnd)(last, null)) {
+    else if (scaledNewSegment.time >= getIndexSegmentEnd(last, null)) {
         // if the given timing has a timestamp after the timeline end we
         // just need to push a new element in the timeline, or increase
         // the @r attribute of the last element.
@@ -52,7 +50,7 @@ function _addSegmentInfos(timeline, timescale, newSegment, currentSegment) {
             last.repeatCount++;
         }
         else {
-            timeline.push({ duration: scaledNewSegment.duration,
+            index.timeline.push({ duration: scaledNewSegment.duration,
                 start: scaledNewSegment.time,
                 repeatCount: 0 });
         }
@@ -60,4 +58,3 @@ function _addSegmentInfos(timeline, timescale, newSegment, currentSegment) {
     }
     return false;
 }
-exports.default = _addSegmentInfos;

package/dist/_esm5.processed/parsers/manifest/smooth/utils/parseBoolean.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,12 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * @param {*} parseBoolean
  * @returns {Boolean}
  */
-function parseBoolean(val) {
+export default function parseBoolean(val) {
     if (typeof val === "boolean") {
         return val;
     }
@@ -30,4 +28,3 @@ function parseBoolean(val) {
         return false;
     }
 }
-exports.default = parseBoolean;