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

package/dist/_esm5.processed/core/adaptive/network_analyzer.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,11 +14,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../config";
-import log from "../../log";
-import arrayFind from "../../utils/array_find";
-import getMonotonicTimeStamp from "../../utils/monotonic_timestamp";
-import EWMA from "./utils/ewma";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateRequestBandwidth = void 0;
+const config_1 = require("../../config");
+const log_1 = require("../../log");
+const array_find_1 = require("../../utils/array_find");
+const is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+const monotonic_timestamp_1 = require("../../utils/monotonic_timestamp");
+const ewma_1 = require("./utils/ewma");
 /**
  * Get pending segment request(s) starting with the asked segment position.
  * @param {Object} requests - Every requests pending, in a chronological
@@ -27,13 +31,13 @@ import EWMA from "./utils/ewma";
  */
 function getConcernedRequests(requests, neededPosition) {
     /** Index of the request for the next needed segment, in `requests`. */
-    var nextSegmentIndex = -1;
-    for (var i = 0; i < requests.length; i++) {
-        var segment = requests[i].content.segment;
+    let nextSegmentIndex = -1;
+    for (let i = 0; i < requests.length; i++) {
+        const { segment } = requests[i].content;
         if (segment.duration <= 0) {
             continue;
         }
-        var segmentEnd = segment.time + segment.duration;
+        const segmentEnd = segment.time + segment.duration;
         if (!segment.complete) {
             if (i === requests.length - 1 && neededPosition - segment.time > -1.2) {
                 nextSegmentIndex = i;
@@ -48,11 +52,11 @@ function getConcernedRequests(requests, neededPosition) {
     if (nextSegmentIndex < 0) { // Not found
         return [];
     }
-    var nextRequest = requests[nextSegmentIndex];
-    var segmentTime = nextRequest.content.segment.time;
-    var filteredRequests = [nextRequest];
+    const nextRequest = requests[nextSegmentIndex];
+    const segmentTime = nextRequest.content.segment.time;
+    const filteredRequests = [nextRequest];
     // Get the possibly multiple requests for that segment's position
-    for (var i = nextSegmentIndex + 1; i < requests.length; i++) {
+    for (let i = nextSegmentIndex + 1; i < requests.length; i++) {
         if (requests[i].content.segment.time === segmentTime) {
             filteredRequests.push(requests[i]);
         }
@@ -69,23 +73,24 @@ function getConcernedRequests(requests, neededPosition) {
  * @param {Object} request
  * @returns {number|undefined}
  */
-export function estimateRequestBandwidth(request) {
+function estimateRequestBandwidth(request) {
     if (request.progress.length < 5) { // threshold from which we can consider
         // progress events reliably
         return undefined;
     }
     // try to infer quickly the current bitrate based on the
     // progress events
-    var ewma1 = new EWMA(2);
-    var progress = request.progress;
-    for (var i = 1; i < progress.length; i++) {
-        var bytesDownloaded = progress[i].size - progress[i - 1].size;
-        var timeElapsed = progress[i].timestamp - progress[i - 1].timestamp;
-        var reqBitrate = (bytesDownloaded * 8) / (timeElapsed / 1000);
+    const ewma1 = new ewma_1.default(2);
+    const { progress } = request;
+    for (let i = 1; i < progress.length; i++) {
+        const bytesDownloaded = progress[i].size - progress[i - 1].size;
+        const timeElapsed = progress[i].timestamp - progress[i - 1].timestamp;
+        const reqBitrate = (bytesDownloaded * 8) / (timeElapsed / 1000);
         ewma1.addSample(timeElapsed / 1000, reqBitrate);
     }
     return ewma1.getEstimate();
 }
+exports.estimateRequestBandwidth = estimateRequestBandwidth;
 /**
  * Estimate remaining time for a pending request from a progress event.
  * @param {Object} lastProgressEvent
@@ -93,7 +98,7 @@ export function estimateRequestBandwidth(request) {
  * @returns {number}
  */
 function estimateRemainingTime(lastProgressEvent, bandwidthEstimate) {
-    var remainingData = (lastProgressEvent.totalSize - lastProgressEvent.size) * 8;
+    const remainingData = (lastProgressEvent.totalSize - lastProgressEvent.size) * 8;
     return Math.max(remainingData / bandwidthEstimate, 0);
 }
 /**
@@ -116,34 +121,34 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
         // TODO Skip only for newer segments?
         return undefined;
     }
-    var bufferGap = playbackInfo.bufferGap, speed = playbackInfo.speed, position = playbackInfo.position;
-    var realBufferGap = isFinite(bufferGap) ? bufferGap :
+    const { bufferGap, speed, position } = playbackInfo;
+    const realBufferGap = isFinite(bufferGap) ? bufferGap :
         0;
-    var nextNeededPosition = position.last + realBufferGap;
-    var concernedRequests = getConcernedRequests(pendingRequests, nextNeededPosition);
+    const nextNeededPosition = position.last + realBufferGap;
+    const concernedRequests = getConcernedRequests(pendingRequests, nextNeededPosition);
     if (concernedRequests.length !== 1) { // 0  == no request
         // 2+ == too complicated to calculate
         return undefined;
     }
-    var concernedRequest = concernedRequests[0];
-    var now = getMonotonicTimeStamp();
-    var minimumRequestTime = concernedRequest.content.segment.duration * 1.5;
+    const concernedRequest = concernedRequests[0];
+    const now = (0, monotonic_timestamp_1.default)();
+    let minimumRequestTime = concernedRequest.content.segment.duration * 1.5;
     minimumRequestTime = Math.min(minimumRequestTime, 3000);
     minimumRequestTime = Math.max(minimumRequestTime, 12000);
     if (now - concernedRequest.requestTimestamp < minimumRequestTime) {
         return undefined;
     }
-    var lastProgressEvent = concernedRequest.progress.length > 0 ?
+    const lastProgressEvent = concernedRequest.progress.length > 0 ?
         concernedRequest.progress[concernedRequest.progress.length - 1] :
         undefined;
     // first, try to do a quick estimate from progress events
-    var bandwidthEstimate = estimateRequestBandwidth(concernedRequest);
+    const bandwidthEstimate = estimateRequestBandwidth(concernedRequest);
     if (lastProgressEvent !== undefined && bandwidthEstimate !== undefined) {
-        var remainingTime = estimateRemainingTime(lastProgressEvent, bandwidthEstimate);
+        const remainingTime = estimateRemainingTime(lastProgressEvent, bandwidthEstimate);
         // if the remaining time does seem reliable
         if ((now - lastProgressEvent.timestamp) / 1000 <= remainingTime) {
             // Calculate estimated time spent rebuffering if we continue doing that request.
-            var expectedRebufferingTime = remainingTime -
+            const expectedRebufferingTime = remainingTime -
                 (realBufferGap / speed);
             if (expectedRebufferingTime > 2500) {
                 return bandwidthEstimate;
@@ -153,16 +158,16 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
     if (!concernedRequest.content.segment.complete) {
         return undefined;
     }
-    var chunkDuration = concernedRequest.content.segment.duration;
-    var requestElapsedTime = (now - concernedRequest.requestTimestamp) / 1000;
-    var reasonableElapsedTime = requestElapsedTime <=
+    const chunkDuration = concernedRequest.content.segment.duration;
+    const requestElapsedTime = (now - concernedRequest.requestTimestamp) / 1000;
+    const reasonableElapsedTime = requestElapsedTime <=
         ((chunkDuration * 1.5 + 2) / speed);
     if (currentRepresentation == null || reasonableElapsedTime) {
         return undefined;
     }
     // calculate a reduced bitrate from the current one
-    var factor = chunkDuration / requestElapsedTime;
-    var reducedBitrate = currentRepresentation.bitrate * Math.min(0.7, factor);
+    const factor = chunkDuration / requestElapsedTime;
+    const reducedBitrate = currentRepresentation.bitrate * Math.min(0.7, factor);
     if (lastEstimatedBitrate === undefined ||
         reducedBitrate < lastEstimatedBitrate) {
         return reducedBitrate;
@@ -185,31 +190,28 @@ function shouldDirectlySwitchToLowBitrate(playbackInfo, requests, lowLatencyMode
         // TODO only when playing close to the live edge?
         return true;
     }
-    var realBufferGap = isFinite(playbackInfo.bufferGap) ? playbackInfo.bufferGap :
+    const realBufferGap = isFinite(playbackInfo.bufferGap) ? playbackInfo.bufferGap :
         0;
-    var nextNeededPosition = playbackInfo.position.last + realBufferGap;
-    var nextRequest = arrayFind(requests, function (_a) {
-        var content = _a.content;
-        return content.segment.duration > 0 &&
-            (content.segment.time + content.segment.duration) > nextNeededPosition;
-    });
+    const nextNeededPosition = playbackInfo.position.last + realBufferGap;
+    const nextRequest = (0, array_find_1.default)(requests, ({ content }) => content.segment.duration > 0 &&
+        (content.segment.time + content.segment.duration) > nextNeededPosition);
     if (nextRequest === undefined) {
         return true;
     }
-    var now = getMonotonicTimeStamp();
-    var lastProgressEvent = nextRequest.progress.length > 0 ?
+    const now = (0, monotonic_timestamp_1.default)();
+    const lastProgressEvent = nextRequest.progress.length > 0 ?
         nextRequest.progress[nextRequest.progress.length - 1] :
         undefined;
     // first, try to do a quick estimate from progress events
-    var bandwidthEstimate = estimateRequestBandwidth(nextRequest);
+    const bandwidthEstimate = estimateRequestBandwidth(nextRequest);
     if (lastProgressEvent === undefined || bandwidthEstimate === undefined) {
         return true;
     }
-    var remainingTime = estimateRemainingTime(lastProgressEvent, bandwidthEstimate);
+    const remainingTime = estimateRemainingTime(lastProgressEvent, bandwidthEstimate);
     if ((now - lastProgressEvent.timestamp) / 1000 > (remainingTime * 1.2)) {
         return true;
     }
-    var expectedRebufferingTime = remainingTime -
+    const expectedRebufferingTime = remainingTime -
         (realBufferGap / playbackInfo.speed);
     return expectedRebufferingTime > -1.5;
 }
@@ -218,9 +220,9 @@ function shouldDirectlySwitchToLowBitrate(playbackInfo, requests, lowLatencyMode
  * as a maximum bitrate a Representation should be.
  * @class NetworkAnalyzer
  */
-var NetworkAnalyzer = /** @class */ (function () {
-    function NetworkAnalyzer(initialBitrate, lowLatencyMode) {
-        var _a = config.getCurrent(), ABR_STARVATION_GAP = _a.ABR_STARVATION_GAP, OUT_OF_STARVATION_GAP = _a.OUT_OF_STARVATION_GAP, ABR_STARVATION_FACTOR = _a.ABR_STARVATION_FACTOR, ABR_REGULAR_FACTOR = _a.ABR_REGULAR_FACTOR;
+class NetworkAnalyzer {
+    constructor(initialBitrate, lowLatencyMode) {
+        const { ABR_STARVATION_GAP, OUT_OF_STARVATION_GAP, ABR_STARVATION_FACTOR, ABR_REGULAR_FACTOR } = config_1.default.getCurrent();
         this._initialBitrate = initialBitrate;
         this._inStarvationMode = false;
         this._lowLatencyMode = lowLatencyMode;
@@ -253,29 +255,29 @@ var NetworkAnalyzer = /** @class */ (function () {
      * last estimate.
      * @returns {Object}
      */
-    NetworkAnalyzer.prototype.getBandwidthEstimate = function (playbackInfo, bandwidthEstimator, currentRepresentation, currentRequests, lastEstimatedBitrate) {
-        var newBitrateCeil; // bitrate ceil for the chosen Representation
-        var bandwidthEstimate;
-        var localConf = this._config;
-        var bufferGap = playbackInfo.bufferGap, position = playbackInfo.position, duration = playbackInfo.duration;
-        var realBufferGap = isFinite(bufferGap) ? bufferGap :
+    getBandwidthEstimate(playbackInfo, bandwidthEstimator, currentRepresentation, currentRequests, lastEstimatedBitrate) {
+        let newBitrateCeil; // bitrate ceil for the chosen Representation
+        let bandwidthEstimate;
+        const localConf = this._config;
+        const { bufferGap, position, duration } = playbackInfo;
+        const realBufferGap = isFinite(bufferGap) ? bufferGap :
             0;
-        var ABR_STARVATION_DURATION_DELTA = config.getCurrent().ABR_STARVATION_DURATION_DELTA;
+        const { ABR_STARVATION_DURATION_DELTA } = config_1.default.getCurrent();
         // check if should get in/out of starvation mode
         if (isNaN(duration) ||
             realBufferGap + position.last < duration - ABR_STARVATION_DURATION_DELTA) {
             if (!this._inStarvationMode && realBufferGap <= localConf.starvationGap) {
-                log.info("ABR: enter starvation mode.");
+                log_1.default.info("ABR: enter starvation mode.");
                 this._inStarvationMode = true;
             }
             else if (this._inStarvationMode &&
                 realBufferGap >= localConf.outOfStarvationGap) {
-                log.info("ABR: exit starvation mode.");
+                log_1.default.info("ABR: exit starvation mode.");
                 this._inStarvationMode = false;
             }
         }
         else if (this._inStarvationMode) {
-            log.info("ABR: exit starvation mode.");
+            log_1.default.info("ABR: exit starvation mode.");
             this._inStarvationMode = false;
         }
         // If in starvation mode, check if a quick new estimate can be done
@@ -283,10 +285,10 @@ var NetworkAnalyzer = /** @class */ (function () {
         // If so, cancel previous estimates and replace it by the new one
         if (this._inStarvationMode) {
             bandwidthEstimate = estimateStarvationModeBitrate(currentRequests, playbackInfo, currentRepresentation, this._lowLatencyMode, lastEstimatedBitrate);
-            if (bandwidthEstimate != null) {
-                log.info("ABR: starvation mode emergency estimate:", bandwidthEstimate);
+            if (bandwidthEstimate !== undefined) {
+                log_1.default.info("ABR: starvation mode emergency estimate:", bandwidthEstimate);
                 bandwidthEstimator.reset();
-                newBitrateCeil = currentRepresentation == null ?
+                newBitrateCeil = (0, is_null_or_undefined_1.default)(currentRepresentation) ?
                     bandwidthEstimate :
                     Math.min(bandwidthEstimate, currentRepresentation.bitrate);
             }
@@ -294,12 +296,12 @@ var NetworkAnalyzer = /** @class */ (function () {
         // if newBitrateCeil is not yet defined, do the normal estimation
         if (newBitrateCeil == null) {
             bandwidthEstimate = bandwidthEstimator.getEstimate();
-            if (bandwidthEstimate != null) {
+            if (bandwidthEstimate !== undefined) {
                 newBitrateCeil = bandwidthEstimate *
                     (this._inStarvationMode ? localConf.starvationBitrateFactor :
                         localConf.regularBitrateFactor);
             }
-            else if (lastEstimatedBitrate != null) {
+            else if (lastEstimatedBitrate !== undefined) {
                 newBitrateCeil = lastEstimatedBitrate *
                     (this._inStarvationMode ? localConf.starvationBitrateFactor :
                         localConf.regularBitrateFactor);
@@ -311,8 +313,8 @@ var NetworkAnalyzer = /** @class */ (function () {
         if (playbackInfo.speed > 1) {
             newBitrateCeil /= playbackInfo.speed;
         }
-        return { bandwidthEstimate: bandwidthEstimate, bitrateChosen: newBitrateCeil };
-    };
+        return { bandwidthEstimate, bitrateChosen: newBitrateCeil };
+    }
     /**
      * For a given wanted bitrate, tells if should switch urgently.
      * @param {number} bitrate - The new estimated bitrate.
@@ -323,7 +325,7 @@ var NetworkAnalyzer = /** @class */ (function () {
      * @param {Object} playbackInfo - Information on the current playback.
      * @returns {boolean}
      */
-    NetworkAnalyzer.prototype.isUrgent = function (bitrate, currentRepresentation, currentRequests, playbackInfo) {
+    isUrgent(bitrate, currentRepresentation, currentRequests, playbackInfo) {
         if (currentRepresentation === null) {
             return true;
         }
@@ -331,7 +333,6 @@ var NetworkAnalyzer = /** @class */ (function () {
             return false;
         }
         return shouldDirectlySwitchToLowBitrate(playbackInfo, currentRequests, this._lowLatencyMode);
-    };
-    return NetworkAnalyzer;
-}());
-export default NetworkAnalyzer;
+    }
+}
+exports.default = NetworkAnalyzer;

package/dist/_esm5.processed/core/adaptive/utils/bandwidth_estimator.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,18 +14,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../config";
-import EWMA from "./ewma";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../config");
+const ewma_1 = require("./ewma");
 /**
  * Calculate a mean bandwidth based on the bytes downloaded and the amount
  * of time needed to do so.
  * @class BandwidthEstimator
  */
-var BandwidthEstimator = /** @class */ (function () {
-    function BandwidthEstimator() {
-        var _a = config.getCurrent(), ABR_FAST_EMA = _a.ABR_FAST_EMA, ABR_SLOW_EMA = _a.ABR_SLOW_EMA;
-        this._fastEWMA = new EWMA(ABR_FAST_EMA);
-        this._slowEWMA = new EWMA(ABR_SLOW_EMA);
+class BandwidthEstimator {
+    constructor() {
+        const { ABR_FAST_EMA, ABR_SLOW_EMA } = config_1.default.getCurrent();
+        this._fastEWMA = new ewma_1.default(ABR_FAST_EMA);
+        this._slowEWMA = new ewma_1.default(ABR_SLOW_EMA);
         this._bytesSampled = 0;
     }
     /**
@@ -34,37 +36,36 @@ var BandwidthEstimator = /** @class */ (function () {
      * @param {number} numberOfBytes - The total number of bytes transferred in
      * that request.
      */
-    BandwidthEstimator.prototype.addSample = function (durationInMs, numberOfBytes) {
-        var ABR_MINIMUM_CHUNK_SIZE = config.getCurrent().ABR_MINIMUM_CHUNK_SIZE;
+    addSample(durationInMs, numberOfBytes) {
+        const { ABR_MINIMUM_CHUNK_SIZE } = config_1.default.getCurrent();
         if (numberOfBytes < ABR_MINIMUM_CHUNK_SIZE) {
             return;
         }
-        var bandwidth = numberOfBytes * 8000 / durationInMs;
-        var weight = durationInMs / 1000;
+        const bandwidth = numberOfBytes * 8000 / durationInMs;
+        const weight = durationInMs / 1000;
         this._bytesSampled += numberOfBytes;
         this._fastEWMA.addSample(weight, bandwidth);
         this._slowEWMA.addSample(weight, bandwidth);
-    };
+    }
     /**
      * Get estimate of the bandwidth, in bits per seconds.
      * @returns {Number|undefined}
      */
-    BandwidthEstimator.prototype.getEstimate = function () {
-        var ABR_MINIMUM_TOTAL_BYTES = config.getCurrent().ABR_MINIMUM_TOTAL_BYTES;
+    getEstimate() {
+        const { ABR_MINIMUM_TOTAL_BYTES } = config_1.default.getCurrent();
         if (this._bytesSampled < ABR_MINIMUM_TOTAL_BYTES) {
             return undefined;
         }
         // Take the minimum of these two estimates.
         // This should have the effect of adapting down quickly, but up more slowly.
         return Math.min(this._fastEWMA.getEstimate(), this._slowEWMA.getEstimate());
-    };
+    }
     /** Reset the bandwidth estimation. */
-    BandwidthEstimator.prototype.reset = function () {
-        var _a = config.getCurrent(), ABR_FAST_EMA = _a.ABR_FAST_EMA, ABR_SLOW_EMA = _a.ABR_SLOW_EMA;
-        this._fastEWMA = new EWMA(ABR_FAST_EMA);
-        this._slowEWMA = new EWMA(ABR_SLOW_EMA);
+    reset() {
+        const { ABR_FAST_EMA, ABR_SLOW_EMA } = config_1.default.getCurrent();
+        this._fastEWMA = new ewma_1.default(ABR_FAST_EMA);
+        this._slowEWMA = new ewma_1.default(ABR_SLOW_EMA);
         this._bytesSampled = 0;
-    };
-    return BandwidthEstimator;
-}());
-export default BandwidthEstimator;
+    }
+}
+exports.default = BandwidthEstimator;

package/dist/_esm5.processed/core/adaptive/utils/ewma.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,15 +14,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Tweaked implementation of an exponential weighted Moving Average.
  * @class EWMA
  */
-var EWMA = /** @class */ (function () {
+class EWMA {
     /**
      * @param {number} halfLife
      */
-    function EWMA(halfLife) {
+    constructor(halfLife) {
         // (half-life = log(1/2) / log(Decay Factor)
         this._alpha = Math.exp(Math.log(0.5) / halfLife);
         this._lastEstimate = 0;
@@ -31,22 +33,21 @@ var EWMA = /** @class */ (function () {
      * @param {number} weight
      * @param {number} value
      */
-    EWMA.prototype.addSample = function (weight, value) {
-        var adjAlpha = Math.pow(this._alpha, weight);
-        var newEstimate = value * (1 - adjAlpha) +
+    addSample(weight, value) {
+        const adjAlpha = Math.pow(this._alpha, weight);
+        const newEstimate = value * (1 - adjAlpha) +
             adjAlpha * this._lastEstimate;
         if (!isNaN(newEstimate)) {
             this._lastEstimate = newEstimate;
             this._totalWeight += weight;
         }
-    };
+    }
     /**
      * @returns {number} value
      */
-    EWMA.prototype.getEstimate = function () {
-        var zeroFactor = 1 - Math.pow(this._alpha, this._totalWeight);
+    getEstimate() {
+        const zeroFactor = 1 - Math.pow(this._alpha, this._totalWeight);
         return this._lastEstimate / zeroFactor;
-    };
-    return EWMA;
-}());
-export default EWMA;
+    }
+}
+exports.default = EWMA;

package/dist/_esm5.processed/core/adaptive/utils/filter_by_bitrate.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,7 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import arrayFindIndex from "../../../utils/array_find_index";
+Object.defineProperty(exports, "__esModule", { value: true });
+const array_find_index_1 = require("../../../utils/array_find_index");
 /**
  * Get only representations lower or equal to a given bitrate.
  * If no representation is lower than the given bitrate, returns an array containing
@@ -22,16 +24,17 @@ import arrayFindIndex from "../../../utils/array_find_index";
  * @param {Number} bitrate
  * @returns {Array.<Object>}
  */
-export default function filterByBitrate(representations, bitrate) {
+function filterByBitrate(representations, bitrate) {
     if (representations.length === 0) {
         return [];
     }
-    representations.sort(function (ra, rb) { return ra.bitrate - rb.bitrate; });
-    var minimumBitrate = representations[0].bitrate;
-    var bitrateCeil = Math.max(bitrate, minimumBitrate);
-    var firstSuperiorBitrateIndex = arrayFindIndex(representations, function (representation) { return representation.bitrate > bitrateCeil; });
+    representations.sort((ra, rb) => ra.bitrate - rb.bitrate);
+    const minimumBitrate = representations[0].bitrate;
+    const bitrateCeil = Math.max(bitrate, minimumBitrate);
+    const firstSuperiorBitrateIndex = (0, array_find_index_1.default)(representations, (representation) => representation.bitrate > bitrateCeil);
     if (firstSuperiorBitrateIndex === -1) {
         return representations; // All representations have lower bitrates.
     }
     return representations.slice(0, firstSuperiorBitrateIndex);
 }
+exports.default = filterByBitrate;

package/dist/_esm5.processed/core/adaptive/utils/filter_by_resolution.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 arrayFind from "../../../utils/array_find";
-import takeFirstSet from "../../../utils/take_first_set";
+Object.defineProperty(exports, "__esModule", { value: true });
+const array_find_1 = require("../../../utils/array_find");
+const take_first_set_1 = require("../../../utils/take_first_set");
 /**
  * Filter representations based on their resolution.
  *   - the highest resolution considered will be the one linked to the first
@@ -24,29 +26,26 @@ import takeFirstSet from "../../../utils/take_first_set";
  * @param {Object} resolution
  * @returns {Array.<Object>}
  */
-export default function filterByResolution(representations, resolution) {
+function filterByResolution(representations, resolution) {
     if (resolution.width === undefined || resolution.height === undefined) {
         return representations;
     }
-    var width = resolution.width * resolution.pixelRatio;
-    var height = resolution.height * resolution.pixelRatio;
-    var sortedRepsByWidth = representations
+    const width = resolution.width * resolution.pixelRatio;
+    const height = resolution.height * resolution.pixelRatio;
+    const sortedRepsByWidth = representations
         .slice() // clone
-        .sort(function (a, b) { return takeFirstSet(a.width, 0) -
-        takeFirstSet(b.width, 0); });
-    var repWithMaxWidth = arrayFind(sortedRepsByWidth, function (representation) {
-        return typeof representation.width === "number" &&
-            representation.width >= width &&
-            typeof representation.height === "number" &&
-            representation.height >= height;
-    });
+        .sort((a, b) => (0, take_first_set_1.default)(a.width, 0) -
+        (0, take_first_set_1.default)(b.width, 0));
+    const repWithMaxWidth = (0, array_find_1.default)(sortedRepsByWidth, (representation) => typeof representation.width === "number" &&
+        representation.width >= width &&
+        typeof representation.height === "number" &&
+        representation.height >= height);
     if (repWithMaxWidth === undefined) {
         return representations;
     }
-    var maxWidth = typeof repWithMaxWidth.width === "number" ? repWithMaxWidth.width :
+    const maxWidth = typeof repWithMaxWidth.width === "number" ? repWithMaxWidth.width :
         0;
-    return representations.filter(function (representation) {
-        return typeof representation.width === "number" ? representation.width <= maxWidth :
-            true;
-    });
+    return representations.filter(representation => typeof representation.width === "number" ? representation.width <= maxWidth :
+        true);
 }
+exports.default = filterByResolution;

package/dist/_esm5.processed/core/adaptive/utils/get_buffer_levels.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Return "Buffer Levels" which are steps of available buffers from which we
  * are normally able switch safely to the next available bitrate.
@@ -21,12 +23,12 @@
  * ascending order.
  * @returns {Array.<number>}
  */
-export default function getBufferLevels(bitrates) {
-    var logs = bitrates.map(function (b) { return Math.log(b / bitrates[0]); });
-    var utilities = logs.map(function (l) { return l - logs[0] + 1; }); // normalize
-    var gp = (utilities[utilities.length - 1] - 1) / ((bitrates.length * 2) + 10);
-    var Vp = 1 / gp;
-    return bitrates.map(function (_, i) { return minBufferLevelForBitrate(i); });
+function getBufferLevels(bitrates) {
+    const logs = bitrates.map((b) => Math.log(b / bitrates[0]));
+    const utilities = logs.map(l => l - logs[0] + 1); // normalize
+    const gp = (utilities[utilities.length - 1] - 1) / ((bitrates.length * 2) + 10);
+    const Vp = 1 / gp;
+    return bitrates.map((_, i) => minBufferLevelForBitrate(i));
     /**
      * Get minimum buffer we should keep ahead to pick this bitrate.
      * @param {number} index
@@ -36,7 +38,7 @@ export default function getBufferLevels(bitrates) {
         if (index === 0) {
             return 0;
         }
-        var boundedIndex = Math.min(Math.max(1, index), bitrates.length - 1);
+        const boundedIndex = Math.min(Math.max(1, index), bitrates.length - 1);
         if (bitrates[boundedIndex] === bitrates[boundedIndex - 1]) {
             return minBufferLevelForBitrate(index - 1);
         }
@@ -45,3 +47,4 @@ export default function getBufferLevels(bitrates) {
             bitrates[boundedIndex - 1])) + 4;
     }
 }
+exports.default = getBufferLevels;

package/dist/_esm5.processed/core/adaptive/utils/last_estimate_storage.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,9 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /** Stores the last estimate made by the `RepresentationEstimator`. */
-var LastEstimateStorage = /** @class */ (function () {
-    function LastEstimateStorage() {
+class LastEstimateStorage {
+    constructor() {
         this.bandwidth = undefined;
         this.representation = null;
         this.algorithmType = 3 /* ABRAlgorithmType.None */;
@@ -27,11 +29,10 @@ var LastEstimateStorage = /** @class */ (function () {
      * @param {number} algorithmType - The type of algorithm used to produce that
      * estimate.
      */
-    LastEstimateStorage.prototype.update = function (representation, bandwidth, algorithmType) {
+    update(representation, bandwidth, algorithmType) {
         this.representation = representation;
         this.bandwidth = bandwidth;
         this.algorithmType = algorithmType;
-    };
-    return LastEstimateStorage;
-}());
-export default LastEstimateStorage;
+    }
+}
+exports.default = LastEstimateStorage;