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

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,12 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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");
+import config from "../../../config";
+import log from "../../../log";
+import { areSameContent, } from "../../../manifest";
+import BufferedHistory from "./buffered_history";
 /**
  * Keep track of every chunk downloaded and currently in the linked media
  * buffer.
@@ -29,18 +26,18 @@ const buffered_history_1 = require("./buffered_history");
  * since by the browser (and thus may need to be re-loaded).
  * @class SegmentInventory
  */
-class SegmentInventory {
-    constructor() {
-        const { BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES } = config_1.default.getCurrent();
+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;
         this._inventory = [];
-        this._bufferedHistory = new buffered_history_1.default(BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES);
+        this._bufferedHistory = new BufferedHistory(BUFFERED_HISTORY_RETENTION_TIME, BUFFERED_HISTORY_MAXIMUM_ENTRIES);
     }
     /**
      * Reset the whole inventory.
      */
-    reset() {
+    SegmentInventory.prototype.reset = function () {
         this._inventory.length = 0;
-    }
+    };
     /**
      * Infer each segment's `bufferedStart` and `bufferedEnd` properties from the
      * TimeRanges given.
@@ -53,51 +50,53 @@ class SegmentInventory {
      * coming from the same buffer.
      * @param {TimeRanges} buffered
      */
-    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();
+    SegmentInventory.prototype.synchronizeBuffered = function (buffered) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        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;
         /** Type of buffer considered, used for logs */
-        const bufferType = thisSegment === null || thisSegment === void 0 ? void 0 : thisSegment.infos.adaptation.type;
-        const rangesLength = buffered.length;
-        for (let i = 0; i < rangesLength; i++) {
+        var bufferType = thisSegment === null || thisSegment === void 0 ? void 0 : thisSegment.infos.adaptation.type;
+        var rangesLength = buffered.length;
+        for (var i = 0; i < rangesLength; i++) {
             if (thisSegment === undefined) { // we arrived at the end of our inventory
                 return;
             }
             // take the i'nth contiguous buffered TimeRange
-            const rangeStart = buffered.start(i);
-            const rangeEnd = buffered.end(i);
+            var rangeStart = buffered.start(i);
+            var rangeEnd = buffered.end(i);
             if (rangeEnd - rangeStart < MINIMUM_SEGMENT_SIZE) {
-                log_1.default.warn("SI: skipped TimeRange when synchronizing because it was too small", bufferType, rangeStart, rangeEnd);
+                log.warn("SI: skipped TimeRange when synchronizing because it was too small", bufferType, rangeStart, rangeEnd);
                 continue;
             }
-            const indexBefore = inventoryIndex; // keep track of that number
+            var 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 &&
-                ((0, take_first_set_1.default)(thisSegment.bufferedEnd, thisSegment.end)
+                (((_a = thisSegment.bufferedEnd) !== null && _a !== void 0 ? _a : thisSegment.end)
                     - rangeStart) < MINIMUM_SEGMENT_SIZE) {
                 thisSegment = inventory[++inventoryIndex];
             }
             // Contains infos about the last garbage-collected segment before
             // `thisSegment`.
-            let lastDeletedSegmentInfos = null;
+            var lastDeletedSegmentInfos = null;
             // remove garbage-collected segments
             // (Those not in that TimeRange nor in the previous one)
-            const numberOfSegmentToDelete = inventoryIndex - indexBefore;
+            var numberOfSegmentToDelete = inventoryIndex - indexBefore;
             if (numberOfSegmentToDelete > 0) {
-                const lastDeletedSegment = // last garbage-collected segment
+                var lastDeletedSegment = // last garbage-collected segment
                  inventory[indexBefore + numberOfSegmentToDelete - 1];
                 lastDeletedSegmentInfos = {
-                    end: (0, take_first_set_1.default)(lastDeletedSegment.bufferedEnd, lastDeletedSegment.end),
+                    end: (_b = lastDeletedSegment.bufferedEnd) !== null && _b !== void 0 ? _b : lastDeletedSegment.end,
                     precizeEnd: lastDeletedSegment.precizeEnd,
                 };
-                log_1.default.debug(`SI: ${numberOfSegmentToDelete} segments GCed.`, bufferType);
-                const removed = inventory.splice(indexBefore, numberOfSegmentToDelete);
-                for (const seg of removed) {
+                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];
                     if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
                         this._bufferedHistory.addBufferedSegment(seg.infos, null);
                     }
@@ -109,8 +108,7 @@ class SegmentInventory {
             }
             // If the current segment is actually completely outside that range (it
             // is contained in one of the next one), skip that part.
-            if (rangeEnd -
-                (0, take_first_set_1.default)(thisSegment.bufferedStart, thisSegment.start)
+            if (rangeEnd - ((_c = thisSegment.bufferedStart) !== null && _c !== void 0 ? _c : thisSegment.start)
                 >= MINIMUM_SEGMENT_SIZE) {
                 guessBufferedStartFromRangeStart(thisSegment, rangeStart, lastDeletedSegmentInfos, bufferType);
                 if (inventoryIndex === inventory.length - 1) {
@@ -121,32 +119,32 @@ class SegmentInventory {
                 }
                 thisSegment = inventory[++inventoryIndex];
                 // Make contiguous until first segment outside that range
-                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) :
+                var thisSegmentStart = (_d = thisSegment.bufferedStart) !== null && _d !== void 0 ? _d : thisSegment.start;
+                var thisSegmentEnd = (_e = thisSegment.bufferedEnd) !== null && _e !== void 0 ? _e : thisSegment.end;
+                var nextRangeStart = i < rangesLength - 1 ? buffered.start(i + 1) :
                     undefined;
                 while (thisSegment !== undefined &&
                     (rangeEnd - thisSegmentStart) >= MINIMUM_SEGMENT_SIZE &&
                     (nextRangeStart === undefined ||
                         rangeEnd - thisSegmentStart >= thisSegmentEnd - nextRangeStart)) {
-                    const prevSegment = inventory[inventoryIndex - 1];
+                    var 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_1.default.debug("SI: calculating buffered end of contiguous segment", bufferType, prevSegment.bufferedEnd, prevSegment.end);
+                        log.debug("SI: calculating buffered end of contiguous segment", bufferType, prevSegment.bufferedEnd, prevSegment.end);
                     }
                     thisSegment.bufferedStart = prevSegment.bufferedEnd;
                     thisSegment = inventory[++inventoryIndex];
                     if (thisSegment !== undefined) {
-                        thisSegmentStart = (0, take_first_set_1.default)(thisSegment.bufferedStart, thisSegment.start);
-                        thisSegmentEnd = (0, take_first_set_1.default)(thisSegment.bufferedEnd, thisSegment.end);
+                        thisSegmentStart = (_f = thisSegment.bufferedStart) !== null && _f !== void 0 ? _f : thisSegment.start;
+                        thisSegmentEnd = (_g = thisSegment.bufferedEnd) !== null && _g !== void 0 ? _g : thisSegment.end;
                     }
                 }
             }
             // update the bufferedEnd of the last segment in that range
-            const lastSegmentInRange = inventory[inventoryIndex - 1];
+            var lastSegmentInRange = inventory[inventoryIndex - 1];
             if (lastSegmentInRange !== undefined) {
                 guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType);
             }
@@ -154,19 +152,20 @@ class SegmentInventory {
         // 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_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) {
+            log.debug("SI: last segments have been GCed", bufferType, inventoryIndex, inventory.length);
+            var removed = inventory.splice(inventoryIndex, inventory.length - inventoryIndex);
+            for (var _h = 0, removed_2 = removed; _h < removed_2.length; _h++) {
+                var seg = removed_2[_h];
                 if (seg.bufferedStart === undefined && seg.bufferedEnd === undefined) {
                     this._bufferedHistory.addBufferedSegment(seg.infos, null);
                 }
             }
         }
-        if (bufferType !== undefined && log_1.default.hasLevel("DEBUG")) {
-            log_1.default.debug(`SI: current ${bufferType} inventory timeline:\n` +
+        if (bufferType !== undefined && log.hasLevel("DEBUG")) {
+            log.debug("SI: current ".concat(bufferType, " inventory timeline:\n") +
                 prettyPrintInventory(this._inventory));
         }
-    }
+    };
     /**
      * Add a new chunk in the inventory.
      *
@@ -174,29 +173,25 @@ class SegmentInventory {
      * segment have been inserted, you should call the `completeSegment` method.
      * @param {Object} chunkInformation
      */
-    insertChunk({ period, adaptation, representation, segment, chunkSize, start, end }) {
+    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;
         if (segment.isInit) {
             return;
         }
-        const bufferType = adaptation.type;
+        var bufferType = adaptation.type;
         if (start >= end) {
-            log_1.default.warn("SI: Invalid chunked inserted: starts before it ends", bufferType, start, end);
+            log.warn("SI: Invalid chunked inserted: starts before it ends", bufferType, start, end);
             return;
         }
-        const inventory = this._inventory;
-        const newSegment = { partiallyPushed: true,
-            chunkSize,
-            splitted: false,
-            start,
-            end,
-            precizeStart: false,
+        var inventory = this._inventory;
+        var newSegment = { partiallyPushed: true, chunkSize: chunkSize, splitted: false, start: start, end: end, precizeStart: false,
             precizeEnd: false,
             bufferedStart: undefined,
             bufferedEnd: undefined,
-            infos: { segment, period, adaptation, representation } };
+            infos: { segment: segment, period: period, adaptation: adaptation, representation: representation } };
         // begin by the end as in most use cases this will be faster
-        for (let i = inventory.length - 1; i >= 0; i--) {
-            const segmentI = inventory[i];
+        for (var i = inventory.length - 1; i >= 0; i--) {
+            var segmentI = inventory[i];
             if ((segmentI.start) <= start) {
                 if ((segmentI.end) <= start) {
                     // our segment is after, push it after this one
@@ -210,7 +205,7 @@ class SegmentInventory {
                     //   prevSegment  : |------|
                     //   newSegment   :          |======|
                     //   ===>         : |------| |======|
-                    log_1.default.debug("SI: Pushing segment strictly after previous one.", bufferType, start, segmentI.end);
+                    log.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) {
@@ -223,7 +218,7 @@ class SegmentInventory {
                             //   newSegment   :        |======|
                             //   nextSegment  :            |----|
                             //   ===>         : |------|======|-|
-                            log_1.default.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[i].start);
+                            log.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 &&
@@ -244,7 +239,7 @@ class SegmentInventory {
                         //   newSegment   :        |======|
                         //   nextSegment  :          |----|
                         //   ===>         : |------|======|
-                        log_1.default.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
+                        log.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
                         inventory.splice(i, 1);
                     }
                     return;
@@ -263,7 +258,7 @@ class SegmentInventory {
                             //  prevSegment  : |-------|
                             //  newSegment   : |==========|
                             //  ===>         : |==========|
-                            log_1.default.debug("SI: Segment pushed replace another one", bufferType, start, end, segmentI.end);
+                            log.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) {
@@ -275,7 +270,7 @@ class SegmentInventory {
                                     //   newSegment   : |======|
                                     //   nextSegment  :      |----|
                                     //   ===>         : |======|--|
-                                    log_1.default.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[i].start);
+                                    log.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 &&
@@ -294,7 +289,7 @@ class SegmentInventory {
                                 //   newSegment   : |======|
                                 //   nextSegment  :   |----|
                                 //   ===>         : |======|
-                                log_1.default.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
+                                log.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
                                 inventory.splice(i, 1);
                             }
                             return;
@@ -309,7 +304,7 @@ class SegmentInventory {
                             //  prevSegment  : |------------|
                             //  newSegment   : |==========|
                             //  ===>         : |==========|-|
-                            log_1.default.debug("SI: Segment pushed ends before another with the same start", bufferType, start, end, segmentI.end);
+                            log.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;
@@ -332,7 +327,7 @@ class SegmentInventory {
                             //  prevSegment  : |-------|
                             //  newSegment   :    |====|
                             //  ===>         : |--|====|
-                            log_1.default.debug("SI: Segment pushed updates end of previous one", bufferType, start, end, segmentI.start, segmentI.end);
+                            log.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;
@@ -348,7 +343,7 @@ class SegmentInventory {
                                     //   newSegment   : |======|
                                     //   nextSegment  :      |----|
                                     //   ===>         : |======|--|
-                                    log_1.default.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[i].start);
+                                    log.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 &&
@@ -367,7 +362,7 @@ class SegmentInventory {
                                 //   newSegment   : |======|
                                 //   nextSegment  :   |----|
                                 //   ===>         : |======|
-                                log_1.default.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
+                                log.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[i].start, inventory[i].end);
                                 inventory.splice(i, 1);
                             }
                             return;
@@ -381,8 +376,8 @@ class SegmentInventory {
                             //  prevSegment  : |---------|
                             //  newSegment   :    |====|
                             //  ===>         : |--|====|-|
-                            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,
+                            log.warn("SI: Segment pushed is contained in a previous one", bufferType, start, end, segmentI.start, segmentI.end);
+                            var nextSegment = { partiallyPushed: segmentI.partiallyPushed,
                                 /**
                                  * Note: this sadly means we're doing as if
                                  * that chunk is present two times.
@@ -415,9 +410,9 @@ class SegmentInventory {
         }
         // if we got here, we are at the first segment
         // check bounds of the previous first segment
-        const firstSegment = this._inventory[0];
+        var firstSegment = this._inventory[0];
         if (firstSegment === undefined) { // we do not have any segment yet
-            log_1.default.debug("SI: first segment pushed", bufferType, start, end);
+            log.debug("SI: first segment pushed", bufferType, start, end);
             this._inventory.push(newSegment);
             return;
         }
@@ -433,7 +428,7 @@ class SegmentInventory {
             //  firstSegment :        |----|
             //  newSegment   : |====|
             //  ===>         : |====| |----|
-            log_1.default.debug("SI: Segment pushed comes before all previous ones", bufferType, start, end, firstSegment.start);
+            log.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) {
@@ -448,7 +443,7 @@ class SegmentInventory {
             //  firstSegment :   |-----|
             //  newSegment   : |=======|
             //  ===>         : |=======|
-            log_1.default.debug("SI: Segment pushed starts before and completely " +
+            log.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) {
@@ -460,7 +455,7 @@ class SegmentInventory {
                     //   newSegment   : |======|
                     //   nextSegment  :      |----|
                     //   ===>         : |======|--|
-                    log_1.default.debug("SI: Segment pushed updates the start of the next one", bufferType, newSegment.end, inventory[1].start);
+                    log.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;
@@ -478,7 +473,7 @@ class SegmentInventory {
                 //   newSegment   : |======|
                 //   nextSegment  :   |----|
                 //   ===>         : |======|
-                log_1.default.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[1].start, inventory[1].end);
+                log.debug("SI: Segment pushed removes the next one", bufferType, start, end, inventory[1].start, inventory[1].end);
                 inventory.splice(1, 1);
             }
             return;
@@ -491,54 +486,54 @@ class SegmentInventory {
             //  firstSegment :    |------|
             //  newSegment   : |======|
             //  ===>         : |======|--|
-            log_1.default.debug("SI: Segment pushed start of the next one", bufferType, start, end, firstSegment.start, firstSegment.end);
+            log.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
      */
-    completeSegment(content, newBuffered) {
+    SegmentInventory.prototype.completeSegment = function (content, newBuffered) {
         if (content.segment.isInit) {
             return;
         }
-        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;
+        var inventory = this._inventory;
+        var resSegments = [];
+        for (var i = 0; i < inventory.length; i++) {
+            if (areSameContent(inventory[i].infos, content)) {
+                var splitted = false;
                 if (resSegments.length > 0) {
                     splitted = true;
                     if (resSegments.length === 1) {
-                        log_1.default.warn("SI: Completed Segment is splitted.", content.segment.id, content.segment.time, content.segment.end);
+                        log.warn("SI: Completed Segment is splitted.", content.segment.id, content.segment.time, content.segment.end);
                         resSegments[0].splitted = true;
                     }
                 }
-                const firstI = i;
-                let segmentSize = inventory[i].chunkSize;
+                var firstI = i;
+                var segmentSize = inventory[i].chunkSize;
                 i += 1;
                 while (i < inventory.length &&
-                    (0, manifest_1.areSameContent)(inventory[i].infos, content)) {
-                    const chunkSize = inventory[i].chunkSize;
+                    areSameContent(inventory[i].infos, content)) {
+                    var chunkSize = inventory[i].chunkSize;
                     if (segmentSize !== undefined && chunkSize !== undefined) {
                         segmentSize += chunkSize;
                     }
                     i++;
                 }
-                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;
+                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;
                 }
                 this._inventory[firstI].partiallyPushed = false;
                 this._inventory[firstI].chunkSize = segmentSize;
@@ -549,21 +544,22 @@ class SegmentInventory {
             }
         }
         if (resSegments.length === 0) {
-            log_1.default.warn("SI: Completed Segment not found", content.segment.id, content.segment.time);
+            log.warn("SI: Completed Segment not found", content.segment.id, content.segment.time);
         }
         else {
             this.synchronizeBuffered(newBuffered);
-            for (const seg of resSegments) {
+            for (var _i = 0, resSegments_1 = resSegments; _i < resSegments_1.length; _i++) {
+                var seg = resSegments_1[_i];
                 if (seg.bufferedStart !== undefined && seg.bufferedEnd !== undefined) {
                     this._bufferedHistory.addBufferedSegment(seg.infos, { start: seg.bufferedStart,
                         end: seg.bufferedEnd });
                 }
                 else {
-                    log_1.default.debug("SI: buffered range not known after sync. Skipping history.", seg.start, seg.end);
+                    log.debug("SI: buffered range not known after sync. Skipping history.", seg.start, seg.end);
                 }
             }
         }
-    }
+    };
     /**
      * Returns the whole inventory.
      *
@@ -571,9 +567,9 @@ class SegmentInventory {
      * you might want to call `synchronizeBuffered` before calling this method.
      * @returns {Array.<Object>}
      */
-    getInventory() {
+    SegmentInventory.prototype.getInventory = function () {
         return this._inventory;
-    }
+    };
     /**
      * Returns a recent history of registered operations performed and event
      * received linked to the segment given in argument.
@@ -587,11 +583,12 @@ class SegmentInventory {
      * @param {Object} context
      * @returns {Array.<Object>}
      */
-    getHistoryFor(context) {
+    SegmentInventory.prototype.getHistoryFor = function (context) {
         return this._bufferedHistory.getHistoryFor(context);
-    }
-}
-exports.default = SegmentInventory;
+    };
+    return SegmentInventory;
+}());
+export default SegmentInventory;
 /**
  * Returns `true` if the buffered start of the given chunk looks coherent enough
  * relatively to what is announced in the Manifest.
@@ -603,9 +600,9 @@ function bufferedStartLooksCoherent(thisSegment) {
         thisSegment.partiallyPushed) {
         return false;
     }
-    const { start, end } = thisSegment;
-    const duration = end - start;
-    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE } = config_1.default.getCurrent();
+    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;
     return Math.abs(start - thisSegment.bufferedStart) <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
         (thisSegment.bufferedEnd === undefined ||
@@ -624,9 +621,9 @@ function bufferedEndLooksCoherent(thisSegment) {
         thisSegment.partiallyPushed) {
         return false;
     }
-    const { start, end } = thisSegment;
-    const duration = end - start;
-    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE, MAX_MANIFEST_BUFFERED_DURATION_DIFFERENCE } = config_1.default.getCurrent();
+    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;
     return Math.abs(end - thisSegment.bufferedEnd) <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE &&
         thisSegment.bufferedStart != null &&
@@ -642,10 +639,10 @@ function bufferedEndLooksCoherent(thisSegment) {
  * @param {Object} lastDeletedSegmentInfos
  */
 function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastDeletedSegmentInfos, bufferType) {
-    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE } = config_1.default.getCurrent();
+    var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.getCurrent().MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE;
     if (firstSegmentInRange.bufferedStart !== undefined) {
         if (firstSegmentInRange.bufferedStart < rangeStart) {
-            log_1.default.debug("SI: Segment partially GCed at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
+            log.debug("SI: Segment partially GCed at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
             firstSegmentInRange.bufferedStart = rangeStart;
         }
         if (!firstSegmentInRange.precizeStart &&
@@ -655,7 +652,7 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
         }
     }
     else if (firstSegmentInRange.precizeStart) {
-        log_1.default.debug("SI: buffered start is precize start", bufferType, firstSegmentInRange.start);
+        log.debug("SI: buffered start is precize start", bufferType, firstSegmentInRange.start);
         firstSegmentInRange.bufferedStart = firstSegmentInRange.start;
     }
     else if (lastDeletedSegmentInfos !== null &&
@@ -663,7 +660,7 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
         (lastDeletedSegmentInfos.precizeEnd ||
             firstSegmentInRange.start - lastDeletedSegmentInfos.end <=
                 MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE)) {
-        log_1.default.debug("SI: buffered start is end of previous segment", bufferType, rangeStart, firstSegmentInRange.start, lastDeletedSegmentInfos.end);
+        log.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;
@@ -672,7 +669,7 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
     }
     else if (firstSegmentInRange.start - rangeStart <=
         MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE) {
-        log_1.default.debug("SI: found true buffered start", bufferType, rangeStart, firstSegmentInRange.start);
+        log.debug("SI: found true buffered start", bufferType, rangeStart, firstSegmentInRange.start);
         firstSegmentInRange.bufferedStart = rangeStart;
         if (bufferedStartLooksCoherent(firstSegmentInRange)) {
             firstSegmentInRange.start = rangeStart;
@@ -680,11 +677,11 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
         }
     }
     else if (rangeStart < firstSegmentInRange.start) {
-        log_1.default.debug("SI: range start too far from expected start", bufferType, rangeStart, firstSegmentInRange.start);
+        log.debug("SI: range start too far from expected start", bufferType, rangeStart, firstSegmentInRange.start);
         firstSegmentInRange.bufferedStart = firstSegmentInRange.start;
     }
     else {
-        log_1.default.debug("SI: Segment appears immediately garbage collected at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
+        log.debug("SI: Segment appears immediately garbage collected at the start", bufferType, firstSegmentInRange.bufferedStart, rangeStart);
         firstSegmentInRange.bufferedStart = rangeStart;
     }
 }
@@ -696,10 +693,10 @@ function guessBufferedStartFromRangeStart(firstSegmentInRange, rangeStart, lastD
  * @param {string} bufferType
  */
 function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType) {
-    const { MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE } = config_1.default.getCurrent();
+    var MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE = config.getCurrent().MAX_MANIFEST_BUFFERED_START_END_DIFFERENCE;
     if (lastSegmentInRange.bufferedEnd !== undefined) {
         if (lastSegmentInRange.bufferedEnd > rangeEnd) {
-            log_1.default.debug("SI: Segment partially GCed at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
+            log.debug("SI: Segment partially GCed at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
             lastSegmentInRange.bufferedEnd = rangeEnd;
         }
         if (!lastSegmentInRange.precizeEnd &&
@@ -710,12 +707,12 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
         }
     }
     else if (lastSegmentInRange.precizeEnd) {
-        log_1.default.debug("SI: buffered end is precize end", bufferType, lastSegmentInRange.end);
+        log.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_1.default.debug("SI: found true buffered end", bufferType, rangeEnd, lastSegmentInRange.end);
+        log.debug("SI: found true buffered end", bufferType, rangeEnd, lastSegmentInRange.end);
         lastSegmentInRange.bufferedEnd = rangeEnd;
         if (bufferedEndLooksCoherent(lastSegmentInRange)) {
             lastSegmentInRange.end = rangeEnd;
@@ -723,11 +720,11 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
         }
     }
     else if (rangeEnd > lastSegmentInRange.end) {
-        log_1.default.debug("SI: range end too far from expected end", bufferType, rangeEnd, lastSegmentInRange.end);
+        log.debug("SI: range end too far from expected end", bufferType, rangeEnd, lastSegmentInRange.end);
         lastSegmentInRange.bufferedEnd = lastSegmentInRange.end;
     }
     else {
-        log_1.default.debug("SI: Segment appears immediately garbage collected at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
+        log.debug("SI: Segment appears immediately garbage collected at the end", bufferType, lastSegmentInRange.bufferedEnd, rangeEnd);
         lastSegmentInRange.bufferedEnd = rangeEnd;
     }
 }
@@ -764,30 +761,31 @@ function guessBufferedEndFromRangeEnd(lastSegmentInRange, rangeEnd, bufferType)
  * @returns {string}
  */
 function prettyPrintInventory(inventory) {
-    const roundingError = 1 / 60;
-    const encounteredReps = {};
-    const letters = [];
-    let lastChunk = null;
-    let lastLetter = null;
+    var _a;
+    var roundingError = 1 / 60;
+    var encounteredReps = {};
+    var letters = [];
+    var lastChunk = null;
+    var lastLetter = null;
     function generateNewLetter(infos) {
-        const currentLetter = String.fromCharCode(letters.length + 65);
+        var currentLetter = String.fromCharCode(letters.length + 65);
         letters.push({ letter: currentLetter,
             periodId: infos.period.id,
             representationId: infos.representation.id,
             bitrate: infos.representation.bitrate });
         return currentLetter;
     }
-    let str = "";
-    for (let i = 0; i < inventory.length; i++) {
-        const chunk = inventory[i];
+    var str = "";
+    for (var i = 0; i < inventory.length; i++) {
+        var chunk = inventory[i];
         if (chunk.bufferedStart !== undefined && chunk.bufferedEnd !== undefined) {
-            const periodId = chunk.infos.period.id;
-            const representationId = chunk.infos.representation.id;
-            const encounteredPeriod = encounteredReps[periodId];
-            let currentLetter;
+            var periodId = chunk.infos.period.id;
+            var representationId = chunk.infos.representation.id;
+            var encounteredPeriod = encounteredReps[periodId];
+            var currentLetter = void 0;
             if (encounteredPeriod === undefined) {
                 currentLetter = generateNewLetter(chunk.infos);
-                encounteredReps[periodId] = { [representationId]: currentLetter };
+                encounteredReps[periodId] = (_a = {}, _a[representationId] = currentLetter, _a);
             }
             else if (encounteredPeriod[representationId] === undefined) {
                 currentLetter = generateNewLetter(chunk.infos);
@@ -797,17 +795,17 @@ function prettyPrintInventory(inventory) {
                 currentLetter = encounteredPeriod[representationId];
             }
             if (lastChunk === null) {
-                str += `${chunk.bufferedStart.toFixed(2)}|${currentLetter}|`;
+                str += "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
             }
             else if (lastLetter === currentLetter) {
                 if (lastChunk.bufferedEnd + roundingError < chunk.bufferedStart) {
-                    str += `${lastChunk.bufferedEnd.toFixed(2)} ~ ` +
-                        `${chunk.bufferedStart.toFixed(2)}|${currentLetter}|`;
+                    str += "".concat(lastChunk.bufferedEnd.toFixed(2), " ~ ") +
+                        "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
                 }
             }
             else {
-                str += `${lastChunk.bufferedEnd.toFixed(2)} ~ ` +
-                    `${chunk.bufferedStart.toFixed(2)}|${currentLetter}|`;
+                str += "".concat(lastChunk.bufferedEnd.toFixed(2), " ~ ") +
+                    "".concat(chunk.bufferedStart.toFixed(2), "|").concat(currentLetter, "|");
             }
             lastChunk = chunk;
             lastLetter = currentLetter;
@@ -816,11 +814,11 @@ function prettyPrintInventory(inventory) {
     if (lastChunk !== null) {
         str += String(lastChunk.end.toFixed(2));
     }
-    letters.forEach(letterInfo => {
+    letters.forEach(function (letterInfo) {
         var _a;
-        str += `\n[${letterInfo.letter}] ` +
-            `P: ${letterInfo.periodId} || R: ${letterInfo.representationId}` +
-            `(${(_a = letterInfo.bitrate) !== null && _a !== void 0 ? _a : "unknown bitrate"})`;
+        str += "\n[".concat(letterInfo.letter, "] ") +
+            "P: ".concat(letterInfo.periodId, " || R: ").concat(letterInfo.representationId) +
+            "(".concat((_a = letterInfo.bitrate) !== null && _a !== void 0 ? _a : "unknown bitrate", ")");
     });
     return str;
 }