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

package/dist/_esm5.processed/core/segment_buffers/inventory/segment_inventory.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,11 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../config";
-import log from "../../../log";
-import { areSameContent, } from "../../../manifest";
-import takeFirstSet from "../../../utils/take_first_set";
-import BufferedHistory from "./buffered_history";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../config");
+const log_1 = require("../../../log");
+const manifest_1 = require("../../../manifest");
+const take_first_set_1 = require("../../../utils/take_first_set");
+const buffered_history_1 = require("./buffered_history");
 /**
  * Keep track of every chunk downloaded and currently in the linked media
  * buffer.
@@ -27,18 +29,18 @@ import BufferedHistory from "./buffered_history";
  * since by the browser (and thus may need to be re-loaded).
  * @class SegmentInventory
  */
-var SegmentInventory = /** @class */ (function () {
-    function SegmentInventory() {
-        var _a = config.getCurrent(), BUFFERED_HISTORY_RETENTION_TIME = _a.BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES = _a.BUFFERED_HISTORY_MAXIMUM_ENTRIES;
+class SegmentInventory {
+    constructor() {
+        const { BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES } = config_1.default.getCurrent();
         this._inventory = [];
-        this._bufferedHistory = new BufferedHistory(BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES);
+        this._bufferedHistory = new buffered_history_1.default(BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES);
     }
     /**
      * Reset the whole inventory.
      */
-    SegmentInventory.prototype.reset = function () {
+    reset() {
         this._inventory.length = 0;
-    };
+    }
     /**
      * Infer each segment's `bufferedStart` and `bufferedEnd` properties from the
      * TimeRanges given.
@@ -51,52 +53,51 @@ var SegmentInventory = /** @class */ (function () {
      * coming from the same buffer.
      * @param {TimeRanges} buffered
      */
-    SegmentInventory.prototype.synchronizeBuffered = function (buffered) {
-        var inventory = this._inventory;
-        var inventoryIndex = 0; // Current index considered.
-        var thisSegment = inventory[0]; // Current segmentInfos considered
-        var MINIMUM_SEGMENT_SIZE = config.getCurrent().MINIMUM_SEGMENT_SIZE;
+    synchronizeBuffered(buffered) {
+        const inventory = this._inventory;
+        let inventoryIndex = 0; // Current index considered.
+        let thisSegment = inventory[0]; // Current segmentInfos considered
+        const { MINIMUM_SEGMENT_SIZE } = config_1.default.getCurrent();
         /** Type of buffer considered, used for logs */
-        var bufferType = thisSegment === null || thisSegment === void 0 ? void 0 : thisSegment.infos.adaptation.type;
-        var rangesLength = buffered.length;
-        for (var i = 0; i < rangesLength; i++) {
+        const bufferType = thisSegment === null || thisSegment === void 0 ? void 0 : thisSegment.infos.adaptation.type;
+        const rangesLength = buffered.length;
+        for (let i = 0; i < rangesLength; i++) {
             if (thisSegment === undefined) { // we arrived at the end of our inventory
                 return;
             }
             // take the i'nth contiguous buffered TimeRange
-            var rangeStart = buffered.start(i);
-            var rangeEnd = buffered.end(i);
+            const rangeStart = buffered.start(i);
+            const rangeEnd = buffered.end(i);
             if (rangeEnd - rangeStart < MINIMUM_SEGMENT_SIZE) {
-                log.warn("SI: skipped TimeRange when synchronizing because it was too small", bufferType, rangeStart, rangeEnd);
+                log_1.default.warn("SI: skipped TimeRange when synchronizing because it was too small", bufferType, rangeStart, rangeEnd);
                 continue;
             }
-            var indexBefore = inventoryIndex; // keep track of that number
+            const indexBefore = inventoryIndex; // keep track of that number
             // Find the first segment either within this TimeRange or completely past
             // it:
             // skip until first segment with at least `MINIMUM_SEGMENT_SIZE` past the
             // start of that range.
             while (thisSegment !== undefined &&
-                (takeFirstSet(thisSegment.bufferedEnd, thisSegment.end)
+                ((0, take_first_set_1.default)(thisSegment.bufferedEnd, thisSegment.end)
                     - rangeStart) < MINIMUM_SEGMENT_SIZE) {
                 thisSegment = inventory[++inventoryIndex];
             }
             // Contains infos about the last garbage-collected segment before
             // `thisSegment`.
-            var lastDeletedSegmentInfos = null;
+            let lastDeletedSegmentInfos = null;
             // remove garbage-collected segments
             // (Those not in that TimeRange nor in the previous one)
-            var numberOfSegmentToDelete = inventoryIndex - indexBefore;
+            const numberOfSegmentToDelete = inventoryIndex - indexBefore;
             if (numberOfSegmentToDelete > 0) {
-                var lastDeletedSegment = // last garbage-collected segment
+                const lastDeletedSegment = // last garbage-collected segment
                  inventory[indexBefore + numberOfSegmentToDelete - 1];
                 lastDeletedSegmentInfos = {
-                    end: takeFirstSet(lastDeletedSegment.bufferedEnd, lastDeletedSegment.end),
+                    end: (0, take_first_set_1.default)(lastDeletedSegment.bufferedEnd, lastDeletedSegment.end),
                     precizeEnd: lastDeletedSegment.precizeEnd,
                 };
-                log.debug("SI: ".concat(numberOfSegmentToDelete, " segments GCed."), bufferType);
-                var removed = inventory.splice(indexBefore, numberOfSegmentToDelete);
-                for (var _i = 0, removed_1 = removed; _i < removed_1.length; _i++) {
-                    var seg = removed_1[_i];
+                log_1.default.debug(`SI: ${numberOfSegmentToDelete} segments GCed.`, bufferType);
+                const removed = inventory.splice(indexBefore, numberOfSegmentToDelete);
+                for (const seg of removed) {
                     if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
                         this._bufferedHistory.addBufferedSegment(seg.infos, null);
                     }
@@ -109,7 +110,7 @@ var SegmentInventory = /** @class */ (function () {
             // If the current segment is actually completely outside that range (it
             // is contained in one of the next one), skip that part.
             if (rangeEnd -
-                takeFirstSet(thisSegment.bufferedStart, thisSegment.start)
+                (0, take_first_set_1.default)(thisSegment.bufferedStart, thisSegment.start)
                 >= MINIMUM_SEGMENT_SIZE) {
                 guessBufferedStartFromRangeStart(thisSegment, rangeStart, lastDeletedSegmentInfos, bufferType);
                 if (inventoryIndex === inventory.length - 1) {
@@ -120,32 +121,32 @@ var SegmentInventory = /** @class */ (function () {
                 }
                 thisSegment = inventory[++inventoryIndex];
                 // Make contiguous until first segment outside that range
-                var thisSegmentStart = takeFirstSet(thisSegment.bufferedStart, thisSegment.start);
-                var thisSegmentEnd = takeFirstSet(thisSegment.bufferedEnd, thisSegment.end);
-                var nextRangeStart = i < rangesLength - 1 ? buffered.start(i + 1) :
+                let thisSegmentStart = (0, take_first_set_1.default)(thisSegment.bufferedStart, thisSegment.start);
+                let thisSegmentEnd = (0, take_first_set_1.default)(thisSegment.bufferedEnd, thisSegment.end);
+                const nextRangeStart = i < rangesLength - 1 ? buffered.start(i + 1) :
                     undefined;
                 while (thisSegment !== undefined &&
                     (rangeEnd - thisSegmentStart) >= MINIMUM_SEGMENT_SIZE &&
                     (nextRangeStart === undefined ||
                         rangeEnd - thisSegmentStart >= thisSegmentEnd - nextRangeStart)) {
-                    var prevSegment = inventory[inventoryIndex - 1];
+                    const prevSegment = inventory[inventoryIndex - 1];
                     // those segments are contiguous, we have no way to infer their real
                     // end
                     if (prevSegment.bufferedEnd === undefined) {
                         prevSegment.bufferedEnd = thisSegment.precizeStart ? thisSegment.start :
                             prevSegment.end;
-                        log.debug("SI: calculating buffered end of contiguous segment", bufferType, prevSegment.bufferedEnd, prevSegment.end);
+                        log_1.default.debug("SI: calculating buffered end of contiguous segment", bufferType, prevSegment.bufferedEnd, prevSegment.end);
                     }
                     thisSegment.bufferedStart = prevSegment.bufferedEnd;
                     thisSegment = inventory[++inventoryIndex];
                     if (thisSegment !== undefined) {
-                        thisSegmentStart = takeFirstSet(thisSegment.bufferedStart, thisSegment.start);
-                        thisSegmentEnd = takeFirstSet(thisSegment.bufferedEnd, thisSegment.end);
+                        thisSegmentStart = (0, take_first_set_1.default)(thisSegment.bufferedStart, thisSegment.start);
+                        thisSegmentEnd = (0, take_first_set_1.default)(thisSegment.bufferedEnd, thisSegment.end);
                     }
                 }
             }
             // update the bufferedEnd of the last segment in that range
-            var lastSegmentInRange = inventory[inventoryIndex - 1];
+            const lastSegmentInRange = inventory[inventoryIndex - 1];
             if (lastSegmentInRange !== undefined) {
                 guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType);
             }
@@ -153,20 +154,19 @@ var SegmentInventory = /** @class */ (function () {
         // if we still have segments left, they are not affiliated to any range.
         // They might have been garbage collected, delete them from here.
         if (thisSegment != null) {
-            log.debug("SI: last segments have been GCed", bufferType, inventoryIndex, inventory.length);
-            var removed = inventory.splice(inventoryIndex, inventory.length - inventoryIndex);
-            for (var _a = 0, removed_2 = removed; _a < removed_2.length; _a++) {
-                var seg = removed_2[_a];
+            log_1.default.debug("SI: last segments have been GCed", bufferType, inventoryIndex, inventory.length);
+            const removed = inventory.splice(inventoryIndex, inventory.length - inventoryIndex);
+            for (const seg of removed) {
                 if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
                     this._bufferedHistory.addBufferedSegment(seg.infos, null);
                 }
             }
         }
-        if (bufferType !== undefined && log.hasLevel("DEBUG")) {
-            log.debug("SI: current ".concat(bufferType, " inventory timeline:\n") +
+        if (bufferType !== undefined && log_1.default.hasLevel("DEBUG")) {
+            log_1.default.debug(`SI: current ${bufferType} inventory timeline:\n` +
                 prettyPrintInventory(this._inventory));
         }
-    };
+    }
     /**
      * Add a new chunk in the inventory.
      *
@@ -174,25 +174,29 @@ var SegmentInventory = /** @class */ (function () {
      * segment have been inserted, you should call the `completeSegment` method.
      * @param {Object} chunkInformation
      */
-    SegmentInventory.prototype.insertChunk = function (_a) {
-        var period = _a.period, adaptation = _a.adaptation, representation = _a.representation, segment = _a.segment, chunkSize = _a.chunkSize, start = _a.start, end = _a.end;
+    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }) {
         if (segment.isInit) {
             return;
         }
-        var bufferType = adaptation.type;
+        const bufferType = adaptation.type;
         if (start >= end) {
-            log.warn("SI: Invalid chunked inserted: starts before it ends", bufferType, start, end);
+            log_1.default.warn("SI: Invalid chunked inserted: starts before it ends", bufferType, start, end);
             return;
         }
-        var inventory = this._inventory;
-        var newSegment = { partiallyPushed: true, chunkSize: chunkSize, splitted: false, start: start, end: end, precizeStart: false,
+        const inventory = this._inventory;
+        const newSegment = { partiallyPushed: true,
+            chunkSize,
+            splitted: false,
+            start,
+            end,
+            precizeStart: false,
             precizeEnd: false,
             bufferedStart: undefined,
             bufferedEnd: undefined,
-            infos: { segment: segment, period: period, adaptation: adaptation, representation: representation } };
+            infos: { segment, period, adaptation, representation } };
         // begin by the end as in most use cases this will be faster
-        for (var i = inventory.length - 1; i >= 0; i--) {
-            var segmentI = inventory[i];
+        for (let i = inventory.length - 1; i >= 0; i--) {
+            const segmentI = inventory[i];
             if ((segmentI.start) <= start) {
                 if ((segmentI.end) <= start) {
                     // our segment is after, push it after this one
@@ -206,7 +210,7 @@ var SegmentInventory = /** @class */ (function () {
                     //   prevSegment  : |------|
                     //   newSegment   :          |======|
                     //   ===>         : |------| |======|
-                    log.debug("SI: Pushing segment strictly after previous one.", bufferType, start, segmentI.end);
+                    log_1.default.debug("SI: Pushing segment strictly after previous one.", bufferType, start, segmentI.end);
                     this._inventory.splice(i + 1, 0, newSegment);
                     i += 2; // Go to segment immediately after newSegment
                     while (i < inventory.length && inventory[i].start < newSegment.end) {
@@ -219,7 +223,7 @@ var SegmentInventory = /** @class */ (function () {
                             //   newSegment   :        |======|
                             //   nextSegment  :            |----|
                             //   ===>         : |------|======|-|
-                            log.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[i].start);
+                            log_1.default.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[i].start);
                             inventory[i].start = newSegment.end;
                             inventory[i].bufferedStart = undefined;
                             inventory[i].precizeStart = inventory[i].precizeStart &&
@@ -240,7 +244,7 @@ var SegmentInventory = /** @class */ (function () {
                         //   newSegment   :        |======|
                         //   nextSegment  :          |----|
                         //   ===>         : |------|======|
-                        log.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
+                        log_1.default.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
                         inventory.splice(i, 1);
                     }
                     return;
@@ -259,7 +263,7 @@ var SegmentInventory = /** @class */ (function () {
                             //  prevSegment  : |-------|
                             //  newSegment   : |==========|
                             //  ===>         : |==========|
-                            log.debug("SI: Segment pushed replace another one", bufferType, start, end, segmentI.end);
+                            log_1.default.debug("SI: Segment pushed replace another one", bufferType, start, end, segmentI.end);
                             this._inventory.splice(i, 1, newSegment);
                             i += 1; // Go to segment immediately after newSegment
                             while (i < inventory.length && inventory[i].start < newSegment.end) {
@@ -271,7 +275,7 @@ var SegmentInventory = /** @class */ (function () {
                                     //   newSegment   : |======|
                                     //   nextSegment  :      |----|
                                     //   ===>         : |======|--|
-                                    log.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[i].start);
+                                    log_1.default.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[i].start);
                                     inventory[i].start = newSegment.end;
                                     inventory[i].bufferedStart = undefined;
                                     inventory[i].precizeStart = inventory[i].precizeStart &&
@@ -290,7 +294,7 @@ var SegmentInventory = /** @class */ (function () {
                                 //   newSegment   : |======|
                                 //   nextSegment  :   |----|
                                 //   ===>         : |======|
-                                log.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
+                                log_1.default.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
                                 inventory.splice(i, 1);
                             }
                             return;
@@ -305,7 +309,7 @@ var SegmentInventory = /** @class */ (function () {
                             //  prevSegment  : |------------|
                             //  newSegment   : |==========|
                             //  ===>         : |==========|-|
-                            log.debug("SI: Segment pushed ends before another with the same start", bufferType, start, end, segmentI.end);
+                            log_1.default.debug("SI: Segment pushed ends before another with the same start", bufferType, start, end, segmentI.end);
                             inventory.splice(i, 0, newSegment);
                             segmentI.start = newSegment.end;
                             segmentI.bufferedStart = undefined;
@@ -328,7 +332,7 @@ var SegmentInventory = /** @class */ (function () {
                             //  prevSegment  : |-------|
                             //  newSegment   :    |====|
                             //  ===>         : |--|====|
-                            log.debug("SI: Segment pushed updates end of previous one", bufferType, start, end, segmentI.start, segmentI.end);
+                            log_1.default.debug("SI: Segment pushed updates end of previous one", bufferType, start, end, segmentI.start, segmentI.end);
                             this._inventory.splice(i + 1, 0, newSegment);
                             segmentI.end = newSegment.start;
                             segmentI.bufferedEnd = undefined;
@@ -344,7 +348,7 @@ var SegmentInventory = /** @class */ (function () {
                                     //   newSegment   : |======|
                                     //   nextSegment  :      |----|
                                     //   ===>         : |======|--|
-                                    log.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[i].start);
+                                    log_1.default.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[i].start);
                                     inventory[i].start = newSegment.end;
                                     inventory[i].bufferedStart = undefined;
                                     inventory[i].precizeStart = inventory[i].precizeStart &&
@@ -363,7 +367,7 @@ var SegmentInventory = /** @class */ (function () {
                                 //   newSegment   : |======|
                                 //   nextSegment  :   |----|
                                 //   ===>         : |======|
-                                log.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
+                                log_1.default.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
                                 inventory.splice(i, 1);
                             }
                             return;
@@ -377,8 +381,8 @@ var SegmentInventory = /** @class */ (function () {
                             //  prevSegment  : |---------|
                             //  newSegment   :    |====|
                             //  ===>         : |--|====|-|
-                            log.warn("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
-                            var nextSegment = { partiallyPushed: segmentI.partiallyPushed,
+                            log_1.default.warn("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
+                            const nextSegment = { partiallyPushed: segmentI.partiallyPushed,
                                 /**
                                  * Note: this sadly means we're doing as if
                                  * that chunk is present two times.
@@ -411,9 +415,9 @@ var SegmentInventory = /** @class */ (function () {
         }
         // if we got here, we are at the first segment
         // check bounds of the previous first segment
-        var firstSegment = this._inventory[0];
+        const firstSegment = this._inventory[0];
         if (firstSegment === undefined) { // we do not have any segment yet
-            log.debug("SI: first segment pushed", bufferType, start, end);
+            log_1.default.debug("SI: first segment pushed", bufferType, start, end);
             this._inventory.push(newSegment);
             return;
         }
@@ -429,7 +433,7 @@ var SegmentInventory = /** @class */ (function () {
             //  firstSegment :        |----|
             //  newSegment   : |====|
             //  ===>         : |====| |----|
-            log.debug("SI: Segment pushed comes before all previous ones", bufferType, start, end, firstSegment.start);
+            log_1.default.debug("SI: Segment pushed comes before all previous ones", bufferType, start, end, firstSegment.start);
             this._inventory.splice(0, 0, newSegment);
         }
         else if (firstSegment.end <= end) {
@@ -444,7 +448,7 @@ var SegmentInventory = /** @class */ (function () {
             //  firstSegment :   |-----|
             //  newSegment   : |=======|
             //  ===>         : |=======|
-            log.debug("SI: Segment pushed starts before and completely " +
+            log_1.default.debug("SI: Segment pushed starts before and completely " +
                 "recovers the previous first one", bufferType, start, end, firstSegment.start, firstSegment.end);
             this._inventory.splice(0, 1, newSegment);
             while (inventory.length > 1 && inventory[1].start < newSegment.end) {
@@ -456,7 +460,7 @@ var SegmentInventory = /** @class */ (function () {
                     //   newSegment   : |======|
                     //   nextSegment  :      |----|
                     //   ===>         : |======|--|
-                    log.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[1].start);
+                    log_1.default.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[1].start);
                     inventory[1].start = newSegment.end;
                     inventory[1].bufferedStart = undefined;
                     inventory[1].precizeStart = newSegment.precizeEnd;
@@ -474,7 +478,7 @@ var SegmentInventory = /** @class */ (function () {
                 //   newSegment   : |======|
                 //   nextSegment  :   |----|
                 //   ===>         : |======|
-                log.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[1].start, inventory[1].end);
+                log_1.default.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[1].start, inventory[1].end);
                 inventory.splice(1, 1);
             }
             return;
@@ -487,54 +491,54 @@ var SegmentInventory = /** @class */ (function () {
             //  firstSegment :    |------|
             //  newSegment   : |======|
             //  ===>         : |======|--|
-            log.debug("SI: Segment pushed start of the next one", bufferType, start, end, firstSegment.start, firstSegment.end);
+            log_1.default.debug("SI: Segment pushed start of the next one", bufferType, start, end, firstSegment.start, firstSegment.end);
             firstSegment.start = end;
             firstSegment.bufferedStart = undefined;
             firstSegment.precizeStart = newSegment.precizeEnd;
             this._inventory.splice(0, 0, newSegment);
             return;
         }
-    };
+    }
     /**
      * Indicate that inserted chunks can now be considered as a complete segment.
      * Take in argument the same content than what was given to `insertChunk` for
      * the corresponding chunks.
      * @param {Object} content
      */
-    SegmentInventory.prototype.completeSegment = function (content, newBuffered) {
+    completeSegment(content, newBuffered) {
         if (content.segment.isInit) {
             return;
         }
-        var inventory = this._inventory;
-        var resSegments = [];
-        for (var i = 0; i < inventory.length; i++) {
-            if (areSameContent(inventory[i].infos, content)) {
-                var splitted = false;
+        const inventory = this._inventory;
+        const resSegments = [];
+        for (let i = 0; i < inventory.length; i++) {
+            if ((0, manifest_1.areSameContent)(inventory[i].infos, content)) {
+                let splitted = false;
                 if (resSegments.length > 0) {
                     splitted = true;
                     if (resSegments.length === 1) {
-                        log.warn("SI: Completed Segment is splitted.", content.segment.id, content.segment.time, content.segment.end);
+                        log_1.default.warn("SI: Completed Segment is splitted.", content.segment.id, content.segment.time, content.segment.end);
                         resSegments[0].splitted = true;
                     }
                 }
-                var firstI = i;
-                var segmentSize = inventory[i].chunkSize;
+                const firstI = i;
+                let segmentSize = inventory[i].chunkSize;
                 i += 1;
                 while (i < inventory.length &&
-                    areSameContent(inventory[i].infos, content)) {
-                    var chunkSize = inventory[i].chunkSize;
+                    (0, manifest_1.areSameContent)(inventory[i].infos, content)) {
+                    const chunkSize = inventory[i].chunkSize;
                     if (segmentSize !== undefined && chunkSize !== undefined) {
                         segmentSize += chunkSize;
                     }
                     i++;
                 }
-                var lastI = i - 1;
-                var length_1 = lastI - firstI;
-                var lastEnd = inventory[lastI].end;
-                var lastBufferedEnd = inventory[lastI].bufferedEnd;
-                if (length_1 > 0) {
-                    this._inventory.splice(firstI + 1, length_1);
-                    i -= length_1;
+                const lastI = i - 1;
+                const length = lastI - firstI;
+                const lastEnd = inventory[lastI].end;
+                const lastBufferedEnd = inventory[lastI].bufferedEnd;
+                if (length > 0) {
+                    this._inventory.splice(firstI + 1, length);
+                    i -= length;
                 }
                 this._inventory[firstI].partiallyPushed = false;
                 this._inventory[firstI].chunkSize = segmentSize;
@@ -545,22 +549,21 @@ var SegmentInventory = /** @class */ (function () {
             }
         }
         if (resSegments.length === 0) {
-            log.warn("SI: Completed Segment not found", content.segment.id, content.segment.time);
+            log_1.default.warn("SI: Completed Segment not found", content.segment.id, content.segment.time);
         }
         else {
             this.synchronizeBuffered(newBuffered);
-            for (var _i = 0, resSegments_1 = resSegments; _i < resSegments_1.length; _i++) {
-                var seg = resSegments_1[_i];
+            for (const seg of resSegments) {
                 if (seg.bufferedStart !== undefined && seg.bufferedEnd !== undefined) {
                     this._bufferedHistory.addBufferedSegment(seg.infos, { start: seg.bufferedStart,
                         end: seg.bufferedEnd });
                 }
                 else {
-                    log.debug("SI: buffered range not known after sync. Skipping history.", seg.start, seg.end);
+                    log_1.default.debug("SI: buffered range not known after sync. Skipping history.", seg.start, seg.end);
                 }
             }
         }
-    };
+    }
     /**
      * Returns the whole inventory.
      *
@@ -568,9 +571,9 @@ var SegmentInventory = /** @class */ (function () {
      * you might want to call `synchronizeBuffered` before calling this method.
      * @returns {Array.<Object>}
      */
-    SegmentInventory.prototype.getInventory = function () {
+    getInventory() {
         return this._inventory;
-    };
+    }
     /**
      * Returns a recent history of registered operations performed and event
      * received linked to the segment given in argument.
@@ -584,12 +587,11 @@ var SegmentInventory = /** @class */ (function () {
      * @param {Object} context
      * @returns {Array.<Object>}
      */
-    SegmentInventory.prototype.getHistoryFor = function (context) {
+    getHistoryFor(context) {
         return this._bufferedHistory.getHistoryFor(context);
-    };
-    return SegmentInventory;
-}());
-export default SegmentInventory;
+    }
+}
+exports.default = SegmentInventory;
 /**
  * Returns `true` if the buffered start of the given chunk looks coherent enough
  * relatively to what is announced in the Manifest.
@@ -601,9 +603,9 @@ function bufferedStartLooksCoherent(thisSegment) {
         thisSegment.partiallyPushed) {
         return false;
     }
-    var start = thisSegment.start, end = thisSegment.end;
-    var duration = end - start;
-    var _a = config.getCurrent(), MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE;
+    const { start, end } = thisSegment;
+    const duration = end - start;
+    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE } = config_1.default.getCurrent();
     return Math.abs(start - thisSegment.bufferedStart) <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
         (thisSegment.bufferedEnd === undefined ||
@@ -622,9 +624,9 @@ function bufferedEndLooksCoherent(thisSegment) {
         thisSegment.partiallyPushed) {
         return false;
     }
-    var start = thisSegment.start, end = thisSegment.end;
-    var duration = end - start;
-    var _a = config.getCurrent(), MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE = _a.MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE;
+    const { start, end } = thisSegment;
+    const duration = end - start;
+    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE } = config_1.default.getCurrent();
     return Math.abs(end - thisSegment.bufferedEnd) <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
         thisSegment.bufferedStart != null &&
@@ -640,10 +642,10 @@ function bufferedEndLooksCoherent(thisSegment) {
  * @param {Object} lastDeletedSegmentInfos
  */
 function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastDeletedSegmentInfos, bufferType) {
-    var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.getCurrent().MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE;
+    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE } = config_1.default.getCurrent();
     if (firstSegmentInRange.bufferedStart !== undefined) {
         if (firstSegmentInRange.bufferedStart < rangeStart) {
-            log.debug("SI: Segment partially GCed at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
+            log_1.default.debug("SI: Segment partially GCed at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
             firstSegmentInRange.bufferedStart = rangeStart;
         }
         if (!firstSegmentInRange.precizeStart &&
@@ -653,7 +655,7 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
         }
     }
     else if (firstSegmentInRange.precizeStart) {
-        log.debug("SI: buffered start is precize start", bufferType, firstSegmentInRange.start);
+        log_1.default.debug("SI: buffered start is precize start", bufferType, firstSegmentInRange.start);
         firstSegmentInRange.bufferedStart = firstSegmentInRange.start;
     }
     else if (lastDeletedSegmentInfos !== null &&
@@ -661,7 +663,7 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
         (lastDeletedSegmentInfos.precizeEnd ||
             firstSegmentInRange.start - lastDeletedSegmentInfos.end <=
                 MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE)) {
-        log.debug("SI: buffered start is end of previous segment", bufferType, rangeStart, firstSegmentInRange.start, lastDeletedSegmentInfos.end);
+        log_1.default.debug("SI: buffered start is end of previous segment", bufferType, rangeStart, firstSegmentInRange.start, lastDeletedSegmentInfos.end);
         firstSegmentInRange.bufferedStart = lastDeletedSegmentInfos.end;
         if (bufferedStartLooksCoherent(firstSegmentInRange)) {
             firstSegmentInRange.start = lastDeletedSegmentInfos.end;
@@ -670,7 +672,7 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
     }
     else if (firstSegmentInRange.start - rangeStart <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE) {
-        log.debug("SI: found true buffered start", bufferType, rangeStart, firstSegmentInRange.start);
+        log_1.default.debug("SI: found true buffered start", bufferType, rangeStart, firstSegmentInRange.start);
         firstSegmentInRange.bufferedStart = rangeStart;
         if (bufferedStartLooksCoherent(firstSegmentInRange)) {
             firstSegmentInRange.start = rangeStart;
@@ -678,10 +680,11 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
         }
     }
     else if (rangeStart < firstSegmentInRange.start) {
-        log.debug("SI: range start too far from expected start", bufferType, rangeStart, firstSegmentInRange.start);
+        log_1.default.debug("SI: range start too far from expected start", bufferType, rangeStart, firstSegmentInRange.start);
+        firstSegmentInRange.bufferedStart = firstSegmentInRange.start;
     }
     else {
-        log.debug("SI: Segment appears immediately garbage collected at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
+        log_1.default.debug("SI: Segment appears immediately garbage collected at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
         firstSegmentInRange.bufferedStart = rangeStart;
     }
 }
@@ -693,10 +696,10 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
  * @param {string} bufferType
  */
 function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType) {
-    var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.getCurrent().MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE;
+    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE } = config_1.default.getCurrent();
     if (lastSegmentInRange.bufferedEnd !== undefined) {
         if (lastSegmentInRange.bufferedEnd > rangeEnd) {
-            log.debug("SI: Segment partially GCed at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
+            log_1.default.debug("SI: Segment partially GCed at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
             lastSegmentInRange.bufferedEnd = rangeEnd;
         }
         if (!lastSegmentInRange.precizeEnd &&
@@ -707,12 +710,12 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
         }
     }
     else if (lastSegmentInRange.precizeEnd) {
-        log.debug("SI: buffered end is precize end", bufferType, lastSegmentInRange.end);
+        log_1.default.debug("SI: buffered end is precize end", bufferType, lastSegmentInRange.end);
         lastSegmentInRange.bufferedEnd = lastSegmentInRange.end;
     }
     else if (rangeEnd - lastSegmentInRange.end <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE) {
-        log.debug("SI: found true buffered end", bufferType, rangeEnd, lastSegmentInRange.end);
+        log_1.default.debug("SI: found true buffered end", bufferType, rangeEnd, lastSegmentInRange.end);
         lastSegmentInRange.bufferedEnd = rangeEnd;
         if (bufferedEndLooksCoherent(lastSegmentInRange)) {
             lastSegmentInRange.end = rangeEnd;
@@ -720,11 +723,11 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
         }
     }
     else if (rangeEnd > lastSegmentInRange.end) {
-        log.debug("SI: range end too far from expected end", bufferType, rangeEnd, lastSegmentInRange.end);
+        log_1.default.debug("SI: range end too far from expected end", bufferType, rangeEnd, lastSegmentInRange.end);
         lastSegmentInRange.bufferedEnd = lastSegmentInRange.end;
     }
     else {
-        log.debug("SI: Segment appears immediately garbage collected at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
+        log_1.default.debug("SI: Segment appears immediately garbage collected at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
         lastSegmentInRange.bufferedEnd = rangeEnd;
     }
 }
@@ -761,31 +764,30 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
  * @returns {string}
  */
 function prettyPrintInventory(inventory) {
-    var _a;
-    var roundingError = 1 / 60;
-    var encounteredReps = {};
-    var letters = [];
-    var lastChunk = null;
-    var lastLetter = null;
+    const roundingError = 1 / 60;
+    const encounteredReps = {};
+    const letters = [];
+    let lastChunk = null;
+    let lastLetter = null;
     function generateNewLetter(infos) {
-        var currentLetter = String.fromCharCode(letters.length + 65);
+        const currentLetter = String.fromCharCode(letters.length + 65);
         letters.push({ letter: currentLetter,
             periodId: infos.period.id,
             representationId: infos.representation.id,
             bitrate: infos.representation.bitrate });
         return currentLetter;
     }
-    var str = "";
-    for (var i = 0; i < inventory.length; i++) {
-        var chunk = inventory[i];
+    let str = "";
+    for (let i = 0; i < inventory.length; i++) {
+        const chunk = inventory[i];
         if (chunk.bufferedStart !== undefined && chunk.bufferedEnd !== undefined) {
-            var periodId = chunk.infos.period.id;
-            var representationId = chunk.infos.representation.id;
-            var encounteredPeriod = encounteredReps[periodId];
-            var currentLetter = void 0;
+            const periodId = chunk.infos.period.id;
+            const representationId = chunk.infos.representation.id;
+            const encounteredPeriod = encounteredReps[periodId];
+            let currentLetter;
             if (encounteredPeriod === undefined) {
                 currentLetter = generateNewLetter(chunk.infos);
-                encounteredReps[periodId] = (_a = {}, _a[representationId] = currentLetter, _a);
+                encounteredReps[periodId] = { [representationId]: currentLetter };
             }
             else if (encounteredPeriod[representationId] === undefined) {
                 currentLetter = generateNewLetter(chunk.infos);
@@ -795,17 +797,17 @@ function prettyPrintInventory(inventory) {
                 currentLetter = encounteredPeriod[representationId];
             }
             if (lastChunk === null) {
-                str += "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
+                str += `${chunk.bufferedStart.toFixed(2)}|${currentLetter}|`;
             }
             else if (lastLetter === currentLetter) {
                 if (lastChunk.bufferedEnd + roundingError < chunk.bufferedStart) {
-                    str += "".concat(lastChunk.bufferedEnd.toFixed(2), " ~ ") +
-                        "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
+                    str += `${lastChunk.bufferedEnd.toFixed(2)} ~ ` +
+                        `${chunk.bufferedStart.toFixed(2)}|${currentLetter}|`;
                 }
             }
             else {
-                str += "".concat(lastChunk.bufferedEnd.toFixed(2), " ~ ") +
-                    "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
+                str += `${lastChunk.bufferedEnd.toFixed(2)} ~ ` +
+                    `${chunk.bufferedStart.toFixed(2)}|${currentLetter}|`;
             }
             lastChunk = chunk;
             lastLetter = currentLetter;
@@ -814,11 +816,11 @@ function prettyPrintInventory(inventory) {
     if (lastChunk !== null) {
         str += String(lastChunk.end.toFixed(2));
     }
-    letters.forEach(function (letterInfo) {
+    letters.forEach(letterInfo => {
         var _a;
-        str += "\n[".concat(letterInfo.letter, "] ") +
-            "P: ".concat(letterInfo.periodId, " || R: ").concat(letterInfo.representationId) +
-            "(".concat((_a = letterInfo.bitrate) !== null && _a !== void 0 ? _a : "unknown bitrate", ")");
+        str += `\n[${letterInfo.letter}] ` +
+            `P: ${letterInfo.periodId} || R: ${letterInfo.representationId}` +
+            `(${(_a = letterInfo.bitrate) !== null && _a !== void 0 ? _a : "unknown bitrate"})`;
     });
     return str;
 }