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

package/dist/_esm5.processed/core/segment_buffers/implementations/text/native/native_text_segment_buffer.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,82 +14,65 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import { addTextTrack, } from "../../../../../compat";
-import removeCue from "../../../../../compat/remove_cue";
-import log from "../../../../../log";
-import { SegmentBuffer, } from "../../types";
-import ManualTimeRanges from "../../utils/manual_time_ranges";
-import parseTextTrackToCues from "./parsers";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compat_1 = require("../../../../../compat");
+const remove_cue_1 = require("../../../../../compat/remove_cue");
+const log_1 = require("../../../../../log");
+const types_1 = require("../../types");
+const manual_time_ranges_1 = require("../../utils/manual_time_ranges");
+const parsers_1 = require("./parsers");
 /**
  * Implementation of an SegmentBuffer for "native" text tracks.
  * "Native" text tracks rely on a `<track>` HTMLElement and its associated
  * expected behavior to display subtitles synchronized to the video.
  * @class NativeTextSegmentBuffer
  */
-var NativeTextSegmentBuffer = /** @class */ (function (_super) {
-    __extends(NativeTextSegmentBuffer, _super);
+class NativeTextSegmentBuffer extends types_1.SegmentBuffer {
     /**
      * @param {HTMLMediaElement} videoElement
      */
-    function NativeTextSegmentBuffer(videoElement) {
-        var _this = this;
-        log.debug("NTSB: Creating NativeTextSegmentBuffer");
-        _this = _super.call(this) || this;
-        var _a = addTextTrack(videoElement), track = _a.track, trackElement = _a.trackElement;
-        _this.bufferType = "text";
-        _this._buffered = new ManualTimeRanges();
-        _this._videoElement = videoElement;
-        _this._track = track;
-        _this._trackElement = trackElement;
-        return _this;
+    constructor(videoElement) {
+        log_1.default.debug("NTSB: Creating NativeTextSegmentBuffer");
+        super();
+        const { track, trackElement } = (0, compat_1.addTextTrack)(videoElement);
+        this.bufferType = "text";
+        this._buffered = new manual_time_ranges_1.default();
+        this._videoElement = videoElement;
+        this._track = track;
+        this._trackElement = trackElement;
     }
     /**
      * @param {string} uniqueId
      */
-    NativeTextSegmentBuffer.prototype.declareInitSegment = function (uniqueId) {
-        log.warn("ISB: Declaring initialization segment for image SegmentBuffer", uniqueId);
-    };
+    declareInitSegment(uniqueId) {
+        log_1.default.warn("ISB: Declaring initialization segment for image SegmentBuffer", uniqueId);
+    }
     /**
      * @param {string} uniqueId
      */
-    NativeTextSegmentBuffer.prototype.freeInitSegment = function (uniqueId) {
-        log.warn("ISB: Freeing initialization segment for image SegmentBuffer", uniqueId);
-    };
+    freeInitSegment(uniqueId) {
+        log_1.default.warn("ISB: Freeing initialization segment for image SegmentBuffer", uniqueId);
+    }
     /**
      * @param {Object} infos
      * @returns {Promise}
      */
-    NativeTextSegmentBuffer.prototype.pushChunk = function (infos) {
+    pushChunk(infos) {
         var _a, _b;
-        log.debug("NTSB: Appending new native text tracks");
+        log_1.default.debug("NTSB: Appending new native text tracks");
         if (infos.data.chunk === null) {
             return Promise.resolve();
         }
-        var _c = infos.data, timestampOffset = _c.timestampOffset, appendWindow = _c.appendWindow, chunk = _c.chunk;
+        const { timestampOffset, appendWindow, chunk } = infos.data;
         assertChunkIsTextTrackSegmentData(chunk);
-        var startTime = chunk.start, endTime = chunk.end, dataString = chunk.data, type = chunk.type, language = chunk.language;
-        var appendWindowStart = (_a = appendWindow[0]) !== null && _a !== void 0 ? _a : 0;
-        var appendWindowEnd = (_b = appendWindow[1]) !== null && _b !== void 0 ? _b : Infinity;
+        const { start: startTime, end: endTime, data: dataString, type, language } = chunk;
+        const appendWindowStart = (_a = appendWindow[0]) !== null && _a !== void 0 ? _a : 0;
+        const appendWindowEnd = (_b = appendWindow[1]) !== null && _b !== void 0 ? _b : Infinity;
         try {
-            var cues = parseTextTrackToCues(type, dataString, timestampOffset, language);
+            const cues = (0, parsers_1.default)(type, dataString, timestampOffset, language);
             if (appendWindowStart !== 0 && appendWindowEnd !== Infinity) {
                 // Removing before window start
-                var i = 0;
+                let i = 0;
                 while (i < cues.length && cues[i].endTime <= appendWindowStart) {
                     i++;
                 }
@@ -110,47 +94,47 @@ var NativeTextSegmentBuffer = /** @class */ (function (_super) {
                     i--;
                 }
             }
-            var start = void 0;
+            let start;
             if (startTime !== undefined) {
                 start = Math.max(appendWindowStart, startTime);
             }
             else {
                 if (cues.length <= 0) {
-                    log.warn("NTSB: Current text tracks have no cues nor start time. Aborting");
+                    log_1.default.warn("NTSB: Current text tracks have no cues nor start time. Aborting");
                     return Promise.resolve();
                 }
-                log.warn("NTSB: No start time given. Guessing from cues.");
+                log_1.default.warn("NTSB: No start time given. Guessing from cues.");
                 start = cues[0].startTime;
             }
-            var end = void 0;
+            let end;
             if (endTime !== undefined) {
                 end = Math.min(appendWindowEnd, endTime);
             }
             else {
                 if (cues.length <= 0) {
-                    log.warn("NTSB: Current text tracks have no cues nor end time. Aborting");
+                    log_1.default.warn("NTSB: Current text tracks have no cues nor end time. Aborting");
                     return Promise.resolve();
                 }
-                log.warn("NTSB: No end time given. Guessing from cues.");
+                log_1.default.warn("NTSB: No end time given. Guessing from cues.");
                 end = cues[cues.length - 1].endTime;
             }
             if (end <= start) {
-                log.warn("NTSB: Invalid text track appended: ", "the start time is inferior or equal to the end time.");
+                log_1.default.warn("NTSB: Invalid text track appended: ", "the start time is inferior or equal to the end time.");
                 return Promise.resolve();
             }
             if (cues.length > 0) {
-                var firstCue = cues[0];
+                const firstCue = cues[0];
                 // NOTE(compat): cleanup all current cues if the newly added
                 // ones are in the past. this is supposed to fix an issue on
                 // IE/Edge.
                 // TODO Move to compat
-                var currentCues = this._track.cues;
+                const currentCues = this._track.cues;
                 if (currentCues !== null && currentCues.length > 0) {
                     if (firstCue.startTime < currentCues[currentCues.length - 1].startTime) {
                         this._removeData(firstCue.startTime, +Infinity);
                     }
                 }
-                for (var i = 0; i < cues.length; i++) {
+                for (let i = 0; i < cues.length; i++) {
                     this._track.addCue(cues[i]);
                 }
             }
@@ -163,67 +147,66 @@ var NativeTextSegmentBuffer = /** @class */ (function (_super) {
             return Promise.reject(err);
         }
         return Promise.resolve();
-    };
+    }
     /**
      * Remove buffered data.
      * @param {number} start - start position, in seconds
      * @param {number} end - end position, in seconds
      * @returns {Promise}
      */
-    NativeTextSegmentBuffer.prototype.removeBuffer = function (start, end) {
+    removeBuffer(start, end) {
         this._removeData(start, end);
         return Promise.resolve();
-    };
+    }
     /**
      * @param {Object} infos
      * @returns {Promise}
      */
-    NativeTextSegmentBuffer.prototype.endOfSegment = function (_infos) {
+    endOfSegment(_infos) {
         this._segmentInventory.completeSegment(_infos, this._buffered);
         return Promise.resolve();
-    };
+    }
     /**
      * Returns the currently buffered data, in a TimeRanges object.
      * @returns {TimeRanges}
      */
-    NativeTextSegmentBuffer.prototype.getBufferedRanges = function () {
+    getBufferedRanges() {
         return this._buffered;
-    };
-    NativeTextSegmentBuffer.prototype.dispose = function () {
-        log.debug("NTSB: Aborting NativeTextSegmentBuffer");
+    }
+    dispose() {
+        log_1.default.debug("NTSB: Aborting NativeTextSegmentBuffer");
         this._removeData(0, Infinity);
-        var _a = this, _trackElement = _a._trackElement, _videoElement = _a._videoElement;
+        const { _trackElement, _videoElement } = this;
         if (_trackElement !== undefined && _videoElement.hasChildNodes()) {
             try {
                 _videoElement.removeChild(_trackElement);
             }
             catch (e) {
-                log.warn("NTSB: Can't remove track element from the video");
+                log_1.default.warn("NTSB: Can't remove track element from the video");
             }
         }
         this._track.mode = "disabled";
         if (this._trackElement !== undefined) {
             this._trackElement.innerHTML = "";
         }
-    };
-    NativeTextSegmentBuffer.prototype._removeData = function (start, end) {
-        log.debug("NTSB: Removing native text track data", start, end);
-        var track = this._track;
-        var cues = track.cues;
+    }
+    _removeData(start, end) {
+        log_1.default.debug("NTSB: Removing native text track data", start, end);
+        const track = this._track;
+        const cues = track.cues;
         if (cues !== null) {
-            for (var i = cues.length - 1; i >= 0; i--) {
-                var cue = cues[i];
-                var startTime = cue.startTime, endTime = cue.endTime;
+            for (let i = cues.length - 1; i >= 0; i--) {
+                const cue = cues[i];
+                const { startTime, endTime } = cue;
                 if (startTime >= start && startTime <= end && endTime <= end) {
-                    removeCue(track, cue);
+                    (0, remove_cue_1.default)(track, cue);
                 }
             }
         }
         this._buffered.remove(start, end);
-    };
-    return NativeTextSegmentBuffer;
-}(SegmentBuffer));
-export default NativeTextSegmentBuffer;
+    }
+}
+exports.default = NativeTextSegmentBuffer;
 /**
  * Throw if the given input is not in the expected format.
  * Allows to enforce runtime type-checking as compile-time type-checking here is

package/dist/_esm5.processed/core/segment_buffers/implementations/text/native/parsers.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,8 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import features from "../../../../../features";
-import log from "../../../../../log";
+Object.defineProperty(exports, "__esModule", { value: true });
+const features_1 = require("../../../../../features");
+const log_1 = require("../../../../../log");
 /**
  * Convert text track data into timed VTT Cues.
  * @param {string} type - Text track format wanted
@@ -24,14 +26,15 @@ import log from "../../../../../log";
  * @returns {Array.<VTTCue>}
  * @throws Error - Throw if no parser is found for the given type
  */
-export default function parseTextTrackToCues(type, data, timestampOffset, language) {
-    log.debug("NTSB: Finding parser for native text tracks:", type);
-    var parser = features.nativeTextTracksParsers[type];
+function parseTextTrackToCues(type, data, timestampOffset, language) {
+    log_1.default.debug("NTSB: Finding parser for native text tracks:", type);
+    const parser = features_1.default.nativeTextTracksParsers[type];
     if (typeof parser !== "function") {
         throw new Error("no parser found for the given text track");
     }
-    log.debug("NTSB: Parser found, parsing...");
-    var parsed = parser(data, timestampOffset, language);
-    log.debug("NTSB: Parsed successfully!", parsed.length);
+    log_1.default.debug("NTSB: Parser found, parsing...");
+    const parsed = parser(data, timestampOffset, language);
+    log_1.default.debug("NTSB: Parsed successfully!", parsed.length);
     return parsed;
 }
+exports.default = parseTextTrackToCues;

package/dist/_esm5.processed/core/segment_buffers/implementations/types.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,7 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import SegmentInventory from "../inventory";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentBufferOperation = exports.SegmentBuffer = void 0;
+const inventory_1 = require("../inventory");
 /**
  * Class allowing to push segments and remove data to a buffer to be able
  * to decode them in the future as well as retrieving information about which
@@ -51,10 +54,10 @@ import SegmentInventory from "../inventory";
  * If operations happens synchronously, this method will just return an empty
  * array.
  */
-var SegmentBuffer = /** @class */ (function () {
-    function SegmentBuffer() {
+class SegmentBuffer {
+    constructor() {
         // Use SegmentInventory by default for inventory purposes
-        this._segmentInventory = new SegmentInventory();
+        this._segmentInventory = new inventory_1.default();
     }
     /**
      * The maintained inventory can fall out of sync from garbage collection or
@@ -64,10 +67,10 @@ var SegmentBuffer = /** @class */ (function () {
      * called before retrieving Segment information from it (e.g. with
      * `getInventory`).
      */
-    SegmentBuffer.prototype.synchronizeInventory = function () {
+    synchronizeInventory() {
         // The default implementation just use the SegmentInventory
         this._segmentInventory.synchronizeBuffered(this.getBufferedRanges());
-    };
+    }
     /**
      * Returns the currently buffered data for which the content is known with
      * the corresponding content information.
@@ -76,20 +79,20 @@ var SegmentBuffer = /** @class */ (function () {
      * synchronized.
      * @returns {Array.<Object>}
      */
-    SegmentBuffer.prototype.getInventory = function () {
+    getInventory() {
         // The default implementation just use the SegmentInventory
         return this._segmentInventory.getInventory();
-    };
+    }
     /**
      * Returns the list of every operations that the `SegmentBuffer` is still
      * processing. From the one with the highest priority (like the one being
      * processed)
      * @returns {Array.<Object>}
      */
-    SegmentBuffer.prototype.getPendingOperations = function () {
+    getPendingOperations() {
         // Return no pending operation by default (for synchronous SegmentBuffers)
         return [];
-    };
+    }
     /**
      * Returns a recent history of registered operations performed and event
      * received linked to the segment given in argument.
@@ -103,19 +106,18 @@ var SegmentBuffer = /** @class */ (function () {
      * @param {Object} context
      * @returns {Array.<Object>}
      */
-    SegmentBuffer.prototype.getSegmentHistory = function (context) {
+    getSegmentHistory(context) {
         return this._segmentInventory.getHistoryFor(context);
-    };
-    return SegmentBuffer;
-}());
-export { SegmentBuffer };
+    }
+}
+exports.SegmentBuffer = SegmentBuffer;
 /**
  * Enum used by a SegmentBuffer as a discriminant in its queue of
  * "operations".
  */
-export var SegmentBufferOperation;
+var SegmentBufferOperation;
 (function (SegmentBufferOperation) {
     SegmentBufferOperation[SegmentBufferOperation["Push"] = 0] = "Push";
     SegmentBufferOperation[SegmentBufferOperation["Remove"] = 1] = "Remove";
     SegmentBufferOperation[SegmentBufferOperation["EndOfSegment"] = 2] = "EndOfSegment";
-})(SegmentBufferOperation || (SegmentBufferOperation = {}));
+})(SegmentBufferOperation || (exports.SegmentBufferOperation = SegmentBufferOperation = {}));

package/dist/_esm5.processed/core/segment_buffers/implementations/utils/manual_time_ranges.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,53 +14,53 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import assert from "../../../../utils/assert";
-import { insertInto, keepRangeIntersection, } from "../../../../utils/ranges";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("../../../../utils/assert");
+const ranges_1 = require("../../../../utils/ranges");
 /**
  * Simulate TimeRanges as returned by SourceBuffer.prototype.buffered.
  * Add an "insert" and "remove" methods to manually update it.
  * @class ManualTimeRanges
  */
-var ManualTimeRanges = /** @class */ (function () {
-    function ManualTimeRanges() {
+class ManualTimeRanges {
+    constructor() {
         this._ranges = [];
         this.length = 0;
     }
-    ManualTimeRanges.prototype.insert = function (start, end) {
+    insert(start, end) {
         if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-            assert(start >= 0, "invalid start time");
-            assert(end - start > 0, "invalid end time");
+            (0, assert_1.default)(start >= 0, "invalid start time");
+            (0, assert_1.default)(end - start > 0, "invalid end time");
         }
-        insertInto(this._ranges, { start: start, end: end });
+        (0, ranges_1.insertInto)(this._ranges, { start, end });
         this.length = this._ranges.length;
-    };
-    ManualTimeRanges.prototype.remove = function (start, end) {
+    }
+    remove(start, end) {
         if (0 /* __ENVIRONMENT__.CURRENT_ENV */ === 1 /* __ENVIRONMENT__.DEV */) {
-            assert(start >= 0, "invalid start time");
-            assert(end - start > 0, "invalid end time");
+            (0, assert_1.default)(start >= 0, "invalid start time");
+            (0, assert_1.default)(end - start > 0, "invalid end time");
         }
-        var rangesToIntersect = [];
+        const rangesToIntersect = [];
         if (start > 0) {
             rangesToIntersect.push({ start: 0, end: start });
         }
         if (end < Infinity) {
             rangesToIntersect.push({ start: end, end: Infinity });
         }
-        this._ranges = keepRangeIntersection(this._ranges, rangesToIntersect);
+        this._ranges = (0, ranges_1.keepRangeIntersection)(this._ranges, rangesToIntersect);
         this.length = this._ranges.length;
-    };
-    ManualTimeRanges.prototype.start = function (index) {
+    }
+    start(index) {
         if (index >= this._ranges.length) {
             throw new Error("INDEX_SIZE_ERROR");
         }
         return this._ranges[index].start;
-    };
-    ManualTimeRanges.prototype.end = function (index) {
+    }
+    end(index) {
         if (index >= this._ranges.length) {
             throw new Error("INDEX_SIZE_ERROR");
         }
         return this._ranges[index].end;
-    };
-    return ManualTimeRanges;
-}());
-export default ManualTimeRanges;
+    }
+}
+exports.default = ManualTimeRanges;

package/dist/_esm5.processed/core/segment_buffers/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import BufferGarbageCollector from "./garbage_collector";
-import { SegmentBuffer, SegmentBufferOperation, } from "./implementations";
-import { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, } from "./inventory";
-import SegmentBuffersStore from "./segment_buffers_store";
-export default SegmentBuffersStore;
-export { BufferGarbageCollector, SegmentBuffer, SegmentBufferOperation, getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastSegmentBeforePeriod = exports.getFirstSegmentAfterPeriod = exports.SegmentBufferOperation = exports.SegmentBuffer = exports.BufferGarbageCollector = void 0;
+const garbage_collector_1 = require("./garbage_collector");
+exports.BufferGarbageCollector = garbage_collector_1.default;
+const implementations_1 = require("./implementations");
+Object.defineProperty(exports, "SegmentBuffer", { enumerable: true, get: function () { return implementations_1.SegmentBuffer; } });
+Object.defineProperty(exports, "SegmentBufferOperation", { enumerable: true, get: function () { return implementations_1.SegmentBufferOperation; } });
+const inventory_1 = require("./inventory");
+Object.defineProperty(exports, "getFirstSegmentAfterPeriod", { enumerable: true, get: function () { return inventory_1.getFirstSegmentAfterPeriod; } });
+Object.defineProperty(exports, "getLastSegmentBeforePeriod", { enumerable: true, get: function () { return inventory_1.getLastSegmentBeforePeriod; } });
+const segment_buffers_store_1 = require("./segment_buffers_store");
+exports.default = segment_buffers_store_1.default;

package/dist/_esm5.processed/core/segment_buffers/inventory/buffered_history.d.ts

@@ -20,7 +20,7 @@ import { IChunkContext } from "./types";
  * low-latency streaming usages) in the buffer becomes known.
  */
 export interface IBufferedHistoryEntry {
-    /** `performance.now()` when the event happened. */
+    /** The RxPlayer's monotonically-raising timestamp when the event happened. */
     date: number;
     /**
      * Timestamps of what has been buffered with that segment.
@@ -83,7 +83,7 @@ export default class BufferedHistory {
     /**
      * If the current history does not satisfy `_lifetime` or `_maxHistoryLength`,
      * clear older entries until it does.
-     * @param {number} now - Current `performance.now()` result.
+     * @param {number} now - Current monotonically-raising timestamp.
      */
     private _cleanHistory;
 }

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,7 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { areSameContent } from "../../../manifest";
+Object.defineProperty(exports, "__esModule", { value: true });
+const manifest_1 = require("../../../manifest");
+const monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
 /**
  * Register a short-lived history of buffer information.
  *
@@ -27,13 +30,13 @@ import { areSameContent } from "../../../manifest";
  *
  * @class BufferedHistory
  */
-var BufferedHistory = /** @class */ (function () {
+class BufferedHistory {
     /**
      * @param {number} lifetime - Maximum time a history entry should be retained.
      * @param {number} maxHistoryLength - Maximum number of entries the history
      * should have.
      */
-    function BufferedHistory(lifetime, maxHistoryLength) {
+    constructor(lifetime, maxHistoryLength) {
         this._history = [];
         this._lifetime = lifetime;
         this._maxHistoryLength = maxHistoryLength;
@@ -47,30 +50,31 @@ var BufferedHistory = /** @class */ (function () {
      * @param {Object} context
      * @param {Array.<number>|null} buffered
      */
-    BufferedHistory.prototype.addBufferedSegment = function (context, buffered) {
-        var now = performance.now();
-        this._history.push({ date: now, buffered: buffered, context: context });
+    addBufferedSegment(context, buffered) {
+        const now = (0, monotonic_timestamp_1.default)();
+        this._history.push({ date: now,
+            buffered,
+            context });
         this._cleanHistory(now);
-    };
+    }
     /**
      * Returns all entries linked to the given segment.
      * @param {Object} context
      * @returns {Array.<Object>}
      */
-    BufferedHistory.prototype.getHistoryFor = function (context) {
-        return this._history.filter(function (el) { return areSameContent(el.context, context); });
-    };
+    getHistoryFor(context) {
+        return this._history.filter(el => (0, manifest_1.areSameContent)(el.context, context));
+    }
     /**
      * If the current history does not satisfy `_lifetime` or `_maxHistoryLength`,
      * clear older entries until it does.
-     * @param {number} now - Current `performance.now()` result.
+     * @param {number} now - Current monotonically-raising timestamp.
      */
-    BufferedHistory.prototype._cleanHistory = function (now) {
-        var historyEarliestLimit = now - this._lifetime;
-        var firstKeptIndex = 0;
-        for (var _i = 0, _a = this._history; _i < _a.length; _i++) {
-            var event_1 = _a[_i];
-            if (event_1.date < historyEarliestLimit) {
+    _cleanHistory(now) {
+        const historyEarliestLimit = now - this._lifetime;
+        let firstKeptIndex = 0;
+        for (const event of this._history) {
+            if (event.date < historyEarliestLimit) {
                 firstKeptIndex++;
             }
             else {
@@ -81,10 +85,9 @@ var BufferedHistory = /** @class */ (function () {
             this._history = this._history.splice(firstKeptIndex);
         }
         if (this._history.length > this._maxHistoryLength) {
-            var toRemove = this._history.length - this._maxHistoryLength;
+            const toRemove = this._history.length - this._maxHistoryLength;
             this._history = this._history.splice(toRemove);
         }
-    };
-    return BufferedHistory;
-}());
-export default BufferedHistory;
+    }
+}
+exports.default = BufferedHistory;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import SegmentInventory from "./segment_inventory";
-export default SegmentInventory;
-export { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, } from "./utils";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastSegmentBeforePeriod = exports.getFirstSegmentAfterPeriod = void 0;
+const segment_inventory_1 = require("./segment_inventory");
+exports.default = segment_inventory_1.default;
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "getFirstSegmentAfterPeriod", { enumerable: true, get: function () { return utils_1.getFirstSegmentAfterPeriod; } });
+Object.defineProperty(exports, "getLastSegmentBeforePeriod", { enumerable: true, get: function () { return utils_1.getLastSegmentBeforePeriod; } });