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

package/dist/_esm5.processed/utils/request/xhr.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,25 +14,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { RequestError } from "../../errors";
-import isNonEmptyString from "../is_non_empty_string";
-import isNullOrUndefined from "../is_null_or_undefined";
-import getMonotonicTimeStamp from "../monotonic_timestamp";
-var DEFAULT_RESPONSE_TYPE = "json";
-export default function request(options) {
-    var requestOptions = {
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../errors");
+const is_non_empty_string_1 = require("../is_non_empty_string");
+const is_null_or_undefined_1 = require("../is_null_or_undefined");
+const monotonic_timestamp_1 = require("../monotonic_timestamp");
+const DEFAULT_RESPONSE_TYPE = "json";
+function request(options) {
+    const requestOptions = {
         url: options.url,
         headers: options.headers,
-        responseType: isNullOrUndefined(options.responseType) ? DEFAULT_RESPONSE_TYPE :
+        responseType: (0, is_null_or_undefined_1.default)(options.responseType) ? DEFAULT_RESPONSE_TYPE :
             options.responseType,
         timeout: options.timeout,
     };
-    return new Promise(function (resolve, reject) {
-        var onProgress = options.onProgress, cancelSignal = options.cancelSignal;
-        var url = requestOptions.url, headers = requestOptions.headers, responseType = requestOptions.responseType, timeout = requestOptions.timeout;
-        var xhr = new XMLHttpRequest();
+    return new Promise((resolve, reject) => {
+        const { onProgress, cancelSignal } = options;
+        const { url, headers, responseType, timeout } = requestOptions;
+        const xhr = new XMLHttpRequest();
         xhr.open("GET", url, true);
-        var timeoutId;
+        let timeoutId;
         if (timeout !== undefined) {
             xhr.timeout = timeout;
             // We've seen on some browser (mainly on some LG TVs), that `xhr.timeout`
@@ -40,31 +42,31 @@ export default function request(options) {
             // That's why we also start a manual timeout. We do this a little later
             // than the "native one" performed on the xhr assuming that the latter
             // is more precise, it might also be more efficient.
-            timeoutId = setTimeout(function () {
+            timeoutId = setTimeout(() => {
                 clearCancellingProcess();
-                reject(new RequestError(url, xhr.status, "TIMEOUT"));
+                reject(new errors_1.RequestError(url, xhr.status, "TIMEOUT"));
             }, timeout + 3000);
         }
         xhr.responseType = responseType;
         if (xhr.responseType === "document") {
             xhr.overrideMimeType("text/xml");
         }
-        if (!isNullOrUndefined(headers)) {
-            var _headers = headers;
-            for (var key in _headers) {
+        if (!(0, is_null_or_undefined_1.default)(headers)) {
+            const _headers = headers;
+            for (const key in _headers) {
                 if (_headers.hasOwnProperty(key)) {
                     xhr.setRequestHeader(key, _headers[key]);
                 }
             }
         }
-        var sendingTime = getMonotonicTimeStamp();
+        const sendingTime = (0, monotonic_timestamp_1.default)();
         // Handle request cancellation
-        var deregisterCancellationListener = null;
+        let deregisterCancellationListener = null;
         if (cancelSignal !== undefined) {
             deregisterCancellationListener = cancelSignal
                 .register(function abortRequest(err) {
                 clearCancellingProcess();
-                if (!isNullOrUndefined(xhr) && xhr.readyState !== 4) {
+                if (!(0, is_null_or_undefined_1.default)(xhr) && xhr.readyState !== 4) {
                     xhr.abort();
                 }
                 reject(err);
@@ -75,16 +77,20 @@ export default function request(options) {
         }
         xhr.onerror = function onXHRError() {
             clearCancellingProcess();
-            reject(new RequestError(url, xhr.status, "ERROR_EVENT"));
+            reject(new errors_1.RequestError(url, xhr.status, "ERROR_EVENT"));
         };
         xhr.ontimeout = function onXHRTimeout() {
             clearCancellingProcess();
-            reject(new RequestError(url, xhr.status, "TIMEOUT"));
+            reject(new errors_1.RequestError(url, xhr.status, "TIMEOUT"));
         };
         if (onProgress !== undefined) {
             xhr.onprogress = function onXHRProgress(event) {
-                var currentTime = getMonotonicTimeStamp();
-                onProgress({ url: url, duration: currentTime - sendingTime, sendingTime: sendingTime, currentTime: currentTime, size: event.loaded,
+                const currentTime = (0, monotonic_timestamp_1.default)();
+                onProgress({ url,
+                    duration: currentTime - sendingTime,
+                    sendingTime,
+                    currentTime,
+                    size: event.loaded,
                     totalSize: event.total });
             };
         }
@@ -92,15 +98,15 @@ export default function request(options) {
             if (xhr.readyState === 4) {
                 clearCancellingProcess();
                 if (xhr.status >= 200 && xhr.status < 300) {
-                    var receivedTime = getMonotonicTimeStamp();
-                    var totalSize = xhr.response instanceof
+                    const receivedTime = (0, monotonic_timestamp_1.default)();
+                    const totalSize = xhr.response instanceof
                         ArrayBuffer ? xhr.response.byteLength :
                         event.total;
-                    var status_1 = xhr.status;
-                    var loadedResponseType = xhr.responseType;
-                    var _url = isNonEmptyString(xhr.responseURL) ? xhr.responseURL :
+                    const status = xhr.status;
+                    const loadedResponseType = xhr.responseType;
+                    const _url = (0, is_non_empty_string_1.default)(xhr.responseURL) ? xhr.responseURL :
                         url;
-                    var responseData = void 0;
+                    let responseData;
                     if (loadedResponseType === "json") {
                         // IE bug where response is string with responseType json
                         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -112,16 +118,21 @@ export default function request(options) {
                         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
                         responseData = xhr.response;
                     }
-                    if (isNullOrUndefined(responseData)) {
-                        reject(new RequestError(url, xhr.status, "PARSE_ERROR"));
+                    if ((0, is_null_or_undefined_1.default)(responseData)) {
+                        reject(new errors_1.RequestError(url, xhr.status, "PARSE_ERROR"));
                         return;
                     }
-                    resolve({ status: status_1, url: _url,
-                        responseType: loadedResponseType, sendingTime: sendingTime, receivedTime: receivedTime, requestDuration: receivedTime - sendingTime,
-                        size: totalSize, responseData: responseData });
+                    resolve({ status,
+                        url: _url,
+                        responseType: loadedResponseType,
+                        sendingTime,
+                        receivedTime,
+                        requestDuration: receivedTime - sendingTime,
+                        size: totalSize,
+                        responseData });
                 }
                 else {
-                    reject(new RequestError(url, xhr.status, "ERROR_HTTP_CODE"));
+                    reject(new errors_1.RequestError(url, xhr.status, "ERROR_HTTP_CODE"));
                 }
             }
         };
@@ -139,6 +150,7 @@ export default function request(options) {
         }
     });
 }
+exports.default = request;
 /**
  * @param {string} data
  * @returns {Object|null}

package/dist/_esm5.processed/utils/resolve_url.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,10 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilenameIndexInUrl = void 0;
 // Scheme part of an url (e.g. "http://").
-var schemeRe = /^(?:[a-z]+:)?\/\//i;
+const schemeRe = /^(?:[a-z]+:)?\/\//i;
 // Captures "/../" or "/./".
-var selfDirRe = /\/\.{1,2}\//;
+const selfDirRe = /\/\.{1,2}\//;
 /**
  * Resolve self directory and previous directory references to obtain a
  * "normalized" url.
@@ -29,9 +32,9 @@ function _normalizeUrl(url) {
     if (!selfDirRe.test(url)) {
         return url;
     }
-    var newUrl = [];
-    var oldUrl = url.split("/");
-    for (var i = 0, l = oldUrl.length; i < l; i++) {
+    const newUrl = [];
+    const oldUrl = url.split("/");
+    for (let i = 0, l = oldUrl.length; i < l; i++) {
         if (oldUrl[i] === "..") {
             newUrl.pop();
         }
@@ -53,18 +56,14 @@ function _normalizeUrl(url) {
  * @param {...string|undefined} args
  * @returns {string}
  */
-export default function resolveURL() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    var len = args.length;
+function resolveURL(...args) {
+    const len = args.length;
     if (len === 0) {
         return "";
     }
-    var base = "";
-    for (var i = 0; i < len; i++) {
-        var part = args[i];
+    let base = "";
+    for (let i = 0; i < len; i++) {
+        let part = args[i];
         if (typeof part !== "string" || part === "") {
             continue;
         }
@@ -85,6 +84,7 @@ export default function resolveURL() {
     }
     return _normalizeUrl(base);
 }
+exports.default = resolveURL;
 /**
  * In a given URL, find the index at which the filename begins.
  * That is, this function finds the index of the last `/` character and returns
@@ -94,19 +94,19 @@ export default function resolveURL() {
  * @returns {number}
  */
 function getFilenameIndexInUrl(url) {
-    var indexOfLastSlash = url.lastIndexOf("/");
+    const indexOfLastSlash = url.lastIndexOf("/");
     if (indexOfLastSlash < 0) {
         return url.length;
     }
     if (schemeRe.test(url)) {
-        var firstSlashIndex = url.indexOf("/");
+        const firstSlashIndex = url.indexOf("/");
         if (firstSlashIndex >= 0 && indexOfLastSlash === firstSlashIndex + 1) {
             // The "/" detected is actually the one from the protocol part of the URL
             // ("https://")
             return url.length;
         }
     }
-    var indexOfQuestionMark = url.indexOf("?");
+    const indexOfQuestionMark = url.indexOf("?");
     if (indexOfQuestionMark >= 0 && indexOfQuestionMark < indexOfLastSlash) {
         // There are query parameters. Let's ignore them and re-run the logic
         // without
@@ -114,4 +114,4 @@ function getFilenameIndexInUrl(url) {
     }
     return indexOfLastSlash + 1;
 }
-export { getFilenameIndexInUrl };
+exports.getFilenameIndexInUrl = getFilenameIndexInUrl;

package/dist/_esm5.processed/utils/retry_promise_with_backoff.js

@@ -1,42 +1,8 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import getFuzzedDelay from "./get_fuzzed_delay";
-import isNullOrUndefined from "./is_null_or_undefined";
-import sleep from "./sleep";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_fuzzed_delay_1 = require("./get_fuzzed_delay");
+const is_null_or_undefined_1 = require("./is_null_or_undefined");
+const sleep_1 = require("./sleep");
 /**
  * Retry the given Promise (if it rejects) with an exponential
  * backoff.
@@ -72,48 +38,35 @@ import sleep from "./sleep";
  * TODO Take errorSelector out. Should probably be entirely managed in the
  * calling code via a catch (much simpler to use and to understand).
  */
-export default function retryPromiseWithBackoff(runProm, options, cancelSignal) {
-    var baseDelay = options.baseDelay, maxDelay = options.maxDelay, totalRetry = options.totalRetry, shouldRetry = options.shouldRetry, onRetry = options.onRetry;
-    var retryCount = 0;
+function retryPromiseWithBackoff(runProm, options, cancelSignal) {
+    const { baseDelay, maxDelay, totalRetry, shouldRetry, onRetry } = options;
+    let retryCount = 0;
     return iterate();
-    function iterate() {
-        return __awaiter(this, void 0, void 0, function () {
-            var res, error_1, delay, fuzzedDelay, res;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (cancelSignal.cancellationError !== null) {
-                            throw cancelSignal.cancellationError;
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 5]);
-                        return [4 /*yield*/, runProm()];
-                    case 2:
-                        res = _a.sent();
-                        return [2 /*return*/, res];
-                    case 3:
-                        error_1 = _a.sent();
-                        if (cancelSignal.cancellationError !== null) {
-                            throw cancelSignal.cancellationError;
-                        }
-                        if ((!isNullOrUndefined(shouldRetry) && !shouldRetry(error_1)) ||
-                            retryCount++ >= totalRetry) {
-                            throw error_1;
-                        }
-                        if (typeof onRetry === "function") {
-                            onRetry(error_1, retryCount);
-                        }
-                        delay = Math.min(baseDelay * Math.pow(2, retryCount - 1), maxDelay);
-                        fuzzedDelay = getFuzzedDelay(delay);
-                        return [4 /*yield*/, sleep(fuzzedDelay)];
-                    case 4:
-                        _a.sent();
-                        res = iterate();
-                        return [2 /*return*/, res];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
+    async function iterate() {
+        if (cancelSignal.cancellationError !== null) {
+            throw cancelSignal.cancellationError;
+        }
+        try {
+            const res = await runProm();
+            return res;
+        }
+        catch (error) {
+            if (cancelSignal.cancellationError !== null) {
+                throw cancelSignal.cancellationError;
+            }
+            if ((!(0, is_null_or_undefined_1.default)(shouldRetry) && !shouldRetry(error)) ||
+                retryCount++ >= totalRetry) {
+                throw error;
+            }
+            if (typeof onRetry === "function") {
+                onRetry(error, retryCount);
+            }
+            const delay = Math.min(baseDelay * Math.pow(2, retryCount - 1), maxDelay);
+            const fuzzedDelay = (0, get_fuzzed_delay_1.default)(delay);
+            await (0, sleep_1.default)(fuzzedDelay);
+            const res = iterate();
+            return res;
+        }
     }
 }
+exports.default = retryPromiseWithBackoff;

package/dist/_esm5.processed/utils/sleep.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Convert a setTimeout to a Promise.
  *
@@ -7,8 +9,9 @@
  * @param {number} timeInMs
  * @returns {Promise}
  */
-export default function sleep(timeInMs) {
-    return new Promise(function (res) {
+function sleep(timeInMs) {
+    return new Promise((res) => {
         setTimeout(res, timeInMs);
     });
 }
+exports.default = sleep;

package/dist/_esm5.processed/utils/slice_uint8array.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 });
 /**
  * @param {Uint8Array} arr - The Uint8Array you want to slice
  * @param {number} start - The starting byte index from the beginning
@@ -37,6 +39,6 @@ function arraySlice(arr, start, end) {
 function uint8ArraySlice(arr, start, end) {
     return arr.slice(start, end);
 }
-export default typeof Uint8Array.prototype.slice === "function" ?
+exports.default = typeof Uint8Array.prototype.slice === "function" ?
     uint8ArraySlice :
     arraySlice;

package/dist/_esm5.processed/utils/sorted_list.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 "./array_find";
-import arrayIncludes from "./array_includes";
+Object.defineProperty(exports, "__esModule", { value: true });
+const array_find_1 = require("./array_find");
+const array_includes_1 = require("./array_includes");
 /**
  * Creates an Array automatically sorted with the sorting function given to the
  * constructor when the add method is called.
@@ -39,11 +41,11 @@ import arrayIncludes from "./array_includes";
  * ```
  * @class SortedList
  */
-var SortedList = /** @class */ (function () {
+class SortedList {
     /**
      * @param {Function} sortingFunction
      */
-    function SortedList(sortingFunction) {
+    constructor(sortingFunction) {
         this._array = [];
         this._sortingFn = sortingFunction;
     }
@@ -56,16 +58,12 @@ var SortedList = /** @class */ (function () {
      * You can still re-force the sorting to happen by calling forceSort.
      * @param {...*} elements
      */
-    SortedList.prototype.add = function () {
-        var elements = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            elements[_i] = arguments[_i];
-        }
+    add(...elements) {
         elements.sort(this._sortingFn);
-        var j = 0;
-        for (var i = 0; i < elements.length; i++) {
-            var element = elements[i];
-            var inserted = false;
+        let j = 0;
+        for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            let inserted = false;
             while (!inserted && j < this._array.length) {
                 if (this._sortingFn(element, this._array[j]) < 0) {
                     this._array.splice(j, 0, element);
@@ -79,14 +77,14 @@ var SortedList = /** @class */ (function () {
                 this._array.push(element);
             }
         }
-    };
+    }
     /**
      * Returns the current length of the list.
      * @returns {number}
      */
-    SortedList.prototype.length = function () {
+    length() {
         return this._array.length;
-    };
+    }
     /**
      * Returns the nth element. Throws if the index does not exist.
      *
@@ -98,15 +96,15 @@ var SortedList = /** @class */ (function () {
      * @param {number} index
      * @returns {*}
      */
-    SortedList.prototype.get = function (index) {
+    get(index) {
         if (index < 0 || index >= this._array.length) {
             throw new Error("Invalid index.");
         }
         return this._array[index];
-    };
-    SortedList.prototype.toArray = function () {
+    }
+    toArray() {
         return this._array.slice();
-    };
+    }
     /**
      * Find the first element corresponding to the given predicate.
      *
@@ -116,30 +114,30 @@ var SortedList = /** @class */ (function () {
      * @param {Function} fn
      * @returns {*}
      */
-    SortedList.prototype.findFirst = function (fn) {
-        return arrayFind(this._array, fn);
-    };
+    findFirst(fn) {
+        return (0, array_find_1.default)(this._array, fn);
+    }
     /**
      * Returns true if the List contains the given element.
      * @param {*} element
      * @returns {Boolean}
      */
-    SortedList.prototype.has = function (element) {
-        return arrayIncludes(this._array, element);
-    };
+    has(element) {
+        return (0, array_includes_1.default)(this._array, element);
+    }
     /**
      * Remove the first occurence of the given element.
      * Returns the index of the removed element. Undefined if not found.
      * @returns {number|undefined}
      */
-    SortedList.prototype.removeElement = function (element) {
-        var indexOf = this._array.indexOf(element);
+    removeElement(element) {
+        const indexOf = this._array.indexOf(element);
         if (indexOf >= 0) {
             this._array.splice(indexOf, 1);
             return indexOf;
         }
         return undefined;
-    };
+    }
     /**
      * Returns the first element.
      *
@@ -148,9 +146,9 @@ var SortedList = /** @class */ (function () {
      * You can still re-force the sorting to happen by calling forceSort.
      * @returns {*}
      */
-    SortedList.prototype.head = function () {
+    head() {
         return this._array[0];
-    };
+    }
     /**
      * Returns the last element.
      *
@@ -159,25 +157,24 @@ var SortedList = /** @class */ (function () {
      * You can still re-force the sorting to happen by calling forceSort.
      * @returns {*}
      */
-    SortedList.prototype.last = function () {
+    last() {
         return this._array[this._array.length - 1];
-    };
+    }
     /**
      * Remove the first element.
      * Returns the element removed or undefined if no element were removed.
      * @returns {*}
      */
-    SortedList.prototype.shift = function () {
+    shift() {
         return this._array.shift();
-    };
+    }
     /**
      * Remove the last element.
      * Returns the element removed or undefined if no element were removed.
      * @returns {*}
      */
-    SortedList.prototype.pop = function () {
+    pop() {
         return this._array.pop();
-    };
-    return SortedList;
-}());
-export default SortedList;
+    }
+}
+exports.default = SortedList;

package/dist/_esm5.processed/utils/starts_with.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 });
 /**
  * String.prototype.startsWith ponyfill.
  * Indicates Whether a string starts with another substring.
@@ -23,14 +25,15 @@
  * @param {number} [position]
  * @returns {boolean}
  */
-export default function startsWith(completeString, searchString, position) {
+function startsWith(completeString, searchString, position) {
     // eslint-disable-next-line @typescript-eslint/unbound-method
     // eslint-disable-next-line no-restricted-properties
     if (typeof String.prototype.startsWith === "function") {
         // eslint-disable-next-line no-restricted-properties
         return completeString.startsWith(searchString, position);
     }
-    var initialPosition = typeof position === "number" ? Math.max(position, 0) :
+    const initialPosition = typeof position === "number" ? Math.max(position, 0) :
         0;
     return completeString.substring(initialPosition, initialPosition + searchString.length) === searchString;
 }
+exports.default = startsWith;