rx-player 3.33.0 → 3.33.1

package/src/utils/are_codecs_compatible.ts

@@ -1,51 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import arrayFind from "./array_find";
-import startsWith from "./starts_with";
-
-/**
- * This function is a shortcut that helps differentiate two codecs
- * of the form "audio/mp4;codecs=\"av1.40.2\"".
- *
- * @param codecA
- * @param codecB
- * @returns A boolean that tell whether or not those two codecs provided are even.
- */
-function areCodecsCompatible(a: string, b: string): boolean {
-  const [mimeTypeA, ...propsA] = a.split(";");
-  const [mimeTypeB, ...propsB] = b.split(";");
-
-  if (mimeTypeA !== mimeTypeB) {
-    return false;
-  }
-
-  const codecsA = arrayFind(propsA, (prop) => startsWith(prop, "codecs="));
-  const codecsB = arrayFind(propsB, (prop) => startsWith(prop, "codecs="));
-  if (codecsA === undefined || codecsB === undefined) {
-    return false;
-  }
-
-  const codecA = codecsA.substring(7);
-  const codecB = codecsB.substring(7);
-  if (codecA.split(".")[0] !== codecB.split(".")[0]) {
-    return false;
-  }
-
-  return true;
-}
-
-export default areCodecsCompatible;

package/src/utils/array_find.ts

@@ -1,55 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable no-restricted-properties */
-
-// Ugly transitory type to make duck typing work
-type ArrayWithFind<T> = T[] & {
-  find(predicate: (value: T,
-                   index: number,
-                   obj: T[]) => unknown,
-       thisArg?: unknown): T;
-};
-
-/**
- * Array.prototype.find ponyfill.
- * @param {Array} arr
- * @param {Function} predicate
- * @param {*} context
- * @returns {boolean}
- */
-export default function arrayFind<T>(
-  arr : T[],
-  predicate : (arg: T, index : number, fullArray : T[]) => boolean,
-  thisArg? : unknown
-) : T | undefined {
-  if (typeof (Array.prototype as ArrayWithFind<T>).find === "function") {
-    return (arr as ArrayWithFind<T>).find(predicate, thisArg);
-  }
-
-  const len = arr.length >>> 0;
-  for (let i = 0; i < len; i++) {
-    const val = arr[i];
-    if (predicate.call(thisArg, val, i, arr)) {
-      return val;
-    }
-  }
-  return undefined;
-}

package/src/utils/array_find_index.ts

@@ -1,54 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable no-restricted-properties */
-
-// Ugly transitory type to make duck typing work
-type ArrayWithFindIndex<T> = T[] & {
-  findIndex(predicate: (value: T,
-                        index: number,
-                        obj: T[]) => unknown,
-            thisArg?: unknown): number;
-};
-
-/**
- * Array.prototype.find ponyfill.
- * @param {Array} arr
- * @param {Function} predicate
- * @param {*} context
- * @returns {boolean}
- */
-export default function arrayFindIndex<T>(
-  arr : T[],
-  predicate : (arg: T, index : number, fullArray : T[]) => boolean,
-  thisArg? : unknown
-) : number {
-  if (typeof (Array.prototype as ArrayWithFindIndex<T>).findIndex === "function") {
-    return (arr as ArrayWithFindIndex<T>).findIndex(predicate, thisArg);
-  }
-
-  const len = arr.length >>> 0;
-  for (let i = 0; i < len; i++) {
-    if (predicate.call(thisArg, arr[i], i, arr)) {
-      return i;
-    }
-  }
-  return -1;
-}

package/src/utils/array_includes.ts

@@ -1,93 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * Array.prototype.includes ponyfill.
- * Returns ``true`` if the given array ``arr`` contains the element
- * ``searchElement``. false ``otherwise``.
- *
- * Inspired from MDN polyfill, but ponyfilled instead
- *
- * @example
- * ```js
- * arrayIncludes([1, 2, 3], 3);
- * // => true
- *
- * arrayIncludes([1, 2, 3], 7);
- * // => false
- *
- * const obj = { a: 4 };
- * arrayIncludes([obj, { b: 7 }, { a: 3 }], obj);
- * // => true
- *
- * // does not perform deep equality
- * arrayIncludes([{ a: 4 }, { b: 7 }, { a: 3 }], { a: 4 });
- * // => false
- *
- * // the third argument state the starting index. 0 if not set.
- *
- * arrayIncludes([1, 2, 3], 2, 1);
- * // => true
- *
- * arrayIncludes([1, 2, 3], 2, 2);
- * // => false
- * ```
- *
- * @param {Array} arr
- * @param {*} searchElement
- * @param {number} [fromIndex]
- * @returns {boolean}
- */
-export default function arrayIncludes<T>(
-  arr : T[],
-  searchElement : T,
-  fromIndex? : number
-) : boolean {
-  /* eslint-disable @typescript-eslint/unbound-method */
-  // eslint-disable-next-line no-restricted-properties
-  if (typeof Array.prototype.includes === "function") {
-  /* eslint-enable @typescript-eslint/unbound-method */
-    // eslint-disable-next-line no-restricted-properties
-    return arr.includes(searchElement, fromIndex);
-  }
-
-  const len = arr.length >>> 0;
-
-  if (len === 0) {
-    return false;
-  }
-
-  const n = (fromIndex as number) | 0;
-  let k = n >= 0 ?
-    Math.min(n, len - 1) :
-    Math.max(len + n, 0);
-
-  const areTheSame = (x : T, y : T) =>
-    x === y ||
-    // Viva las JavaScriptas!
-    (typeof x === "number" &&
-     typeof y === "number" &&
-     isNaN(x) && isNaN(y));
-
-  while (k < len) {
-    if (areTheSame(arr[k], searchElement)) {
-      return true;
-    }
-    k++;
-  }
-
-  return false;
-}

package/src/utils/assert.ts

@@ -1,65 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { AssertionError } from "../errors";
-import isNullOrUndefined from "./is_null_or_undefined";
-
-/**
- * Throw an AssertionError if the given assertion is false.
- * @param {boolean} assertion
- * @param {string} [message] - Optional message property for the AssertionError.
- * @throws AssertionError - Throws if the assertion given is false
- */
-export default function assert(
-  assertion : boolean,
-  message? : string
-) : asserts assertion {
-  if (
-    __ENVIRONMENT__.DEV as number === __ENVIRONMENT__.CURRENT_ENV as number
-    && !assertion
-  ) {
-    throw new AssertionError(message === undefined ? "invalid assertion" :
-                                                     message);
-  }
-}
-
-type IObjectInterface<T> = Partial<Record<keyof T, string>>;
-
-/**
- * Throws if the given Object does not respect the interface.
- * @param {Object} o
- * @param {Object} iface - Contains the checked keynames of o and link them
- * to their types (obtained through the typeof operator).
- * @param {string} [name="object"] - name of the _interface_
- * @throws AssertionError - The argument o given is not an object
- * @throws AssertionError - The _interface_ is not respected.
- */
-export function assertInterface<T>(
-  o: T,
-  iface: IObjectInterface<T>,
-  name: string = "object"
-) : void {
-  assert(!isNullOrUndefined(o), `${name} should be an object`);
-  for (const k in iface) {
-    if (iface.hasOwnProperty(k)) {
-      /* eslint-disable max-len  */
-      /* eslint-disable @typescript-eslint/restrict-template-expressions */
-      assert(typeof o[k] === iface[k], `${name} should have property ${k} as a ${iface[k]}`);
-      /* eslint-enable max-len */
-      /* eslint-enable @typescript-eslint/restrict-template-expressions */
-    }
-  }
-}

package/src/utils/assert_unreachable.ts

@@ -1,45 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import { AssertionError } from "../errors";
-
-/**
- * TypeScript hack to make sure a code path is never taken.
- *
- * This can for example be used to ensure that a switch statement handle all
- * possible cases by adding a default clause calling assertUnreachable with
- * an argument (it doesn't matter which one).
- *
- * @example
- * function parseBinary(str : "0" | "1") : number {
- *   switch (str) {
- *     case "0:
- *       return 0;
- *     case "1":
- *       return 1;
- *     default:
- *       // branch never taken. If it can be, TypeScript will yell at us because
- *       // its argument (here, `str`) is not of the right type.
- *       assertUnreachable(str);
- *   }
- * }
- * @param {*} _
- * @throws AssertionError - Throw an AssertionError when called. If we're
- * sufficiently strict with how we use TypeScript, this should never happen.
- */
-export default function assertUnreachable(_: never): never {
-  throw new AssertionError("Unreachable path taken");
-}

package/src/utils/base64.ts

@@ -1,153 +0,0 @@
-/* eslint-disable */
-/*
-MIT License
-Copyright (c) 2020 Egor Nepomnyaschih
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-import log from "../log";
-
-/*
-// This constant can also be computed with the following algorithm:
-const base64abc = [],
-  A = "A".charCodeAt(0),
-  a = "a".charCodeAt(0),
-  n = "0".charCodeAt(0);
-for (let i = 0; i < 26; ++i) {
-  base64abc.push(String.fromCharCode(A + i));
-}
-for (let i = 0; i < 26; ++i) {
-  base64abc.push(String.fromCharCode(a + i));
-}
-for (let i = 0; i < 10; ++i) {
-  base64abc.push(String.fromCharCode(n + i));
-}
-base64abc.push("+");
-base64abc.push("/");
- */
-const base64abc = [
-  "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
-  "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
-  "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
-  "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
-  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/",
-];
-
-/*
-// This constant can also be computed with the following algorithm:
-const l = 256, base64codes = new Uint8Array(l);
-for (let i = 0; i < l; ++i) {
-  base64codes[i] = 255; // invalid character
-}
-base64abc.forEach((char, index) => {
-  base64codes[char.charCodeAt(0)] = index;
-});
-base64codes["=".charCodeAt(0)] = 0; // ignored anyway, so we just need to prevent an error
- */
-const base64codes = [
-  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
-  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 0, 255, 255,
-  255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
-  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255,
-  255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-  41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
-];
-
-/**
- * Obtain the value corresponding to a base64 char code.
- * /!\ Can throw if the char code given is invalid.
- * @param {number} charCode
- * @returns {number}
- */
-function getBase64Code(charCode: number) : number {
-  if (charCode >= base64codes.length) {
-    throw new Error("Unable to parse base64 string.");
-  }
-  const code = base64codes[charCode];
-  if (code === 255) {
-    throw new Error("Unable to parse base64 string.");
-  }
-  return code;
-}
-
-/**
- * Convert an array of bytes into a base64 string.
- * @param {Array.<number>|Uint8Array} bytes
- * @returns {string}
- */
-export function bytesToBase64(bytes: number[] | Uint8Array) : string {
-  let result = "";
-  let i;
-  const length = bytes.length;
-  for (i = 2; i < length; i += 3) {
-    result += base64abc[bytes[i - 2] >> 2];
-    result += base64abc[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)];
-    result += base64abc[((bytes[i - 1] & 0x0F) << 2) | (bytes[i] >> 6)];
-    result += base64abc[bytes[i] & 0x3F];
-  }
-  if (i === length + 1) { // 1 octet yet to write
-    result += base64abc[bytes[i - 2] >> 2];
-    result += base64abc[(bytes[i - 2] & 0x03) << 4];
-    result += "==";
-  }
-  if (i === length) { // 2 octets yet to write
-    result += base64abc[bytes[i - 2] >> 2];
-    result += base64abc[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)];
-    result += base64abc[(bytes[i - 1] & 0x0F) << 2];
-    result += "=";
-  }
-  return result;
-}
-
-/**
- * Convert a base64 string into the corresponding Uint8Array containing its
- * corresponding binary data.
- * /!\ Can throw if an invalid base64 string was given.
- * @param {Array.<number>|Uint8Array} bytes
- * @returns {string}
- */
-export function base64ToBytes(str : string) : Uint8Array {
-  const paddingNeeded = str.length % 4;
-  let paddedStr = str;
-  if (paddingNeeded !== 0) {
-    log.warn("base64ToBytes: base64 given miss padding");
-    paddedStr += paddingNeeded === 3 ? "=" :
-                 paddingNeeded === 2 ? "==" :
-                                       "==="; // invalid, but we will catch it
-  }
-  const index = paddedStr.indexOf("=");
-  if (index !== -1 && index < paddedStr.length - 2) {
-    throw new Error("Unable to parse base64 string.");
-  }
-  const missingOctets = paddedStr.endsWith("==") ? 2 :
-                        paddedStr.endsWith("=") ? 1 : 0;
-  const n = paddedStr.length;
-  const result = new Uint8Array((n / 4) * 3);
-  let buffer: number;
-  for (let i = 0, j = 0; i < n; i += 4, j += 3) {
-    buffer = getBase64Code(paddedStr.charCodeAt(i)) << 18 |
-             getBase64Code(paddedStr.charCodeAt(i + 1)) << 12 |
-             getBase64Code(paddedStr.charCodeAt(i + 2)) << 6 |
-             getBase64Code(paddedStr.charCodeAt(i + 3));
-    result[j] = buffer >> 16;
-    result[j + 1] = (buffer >> 8) & 0xFF;
-    result[j + 2] = buffer & 0xFF;
-  }
-  return result.subarray(0, result.length - missingOctets);
-}