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

package/dist/_esm5.processed/core/decrypt/utils/media_keys_infos_store.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 });
 // Store the MediaKeys infos attached to a media element.
-var currentMediaState = new WeakMap();
-export default {
+const currentMediaState = new WeakMap();
+exports.default = {
     /**
      * Update MediaKeys infos set on a HMTLMediaElement
      * @param {HTMLMediaElement} mediaElement
      * @param {Object} state
      */
-    setState: function (mediaElement, state) {
+    setState(mediaElement, state) {
         currentMediaState.set(mediaElement, state);
     },
     /**
@@ -29,8 +31,8 @@ export default {
      * @param {HTMLMediaElement} mediaElement
      * @returns {Object}
      */
-    getState: function (mediaElement) {
-        var currentState = currentMediaState.get(mediaElement);
+    getState(mediaElement) {
+        const currentState = currentMediaState.get(mediaElement);
         return currentState === undefined ? null :
             currentState;
     },
@@ -38,7 +40,7 @@ export default {
      * Remove MediaKeys infos currently set on a HMTLMediaElement
      * @param {HTMLMediaElement} mediaElement
      */
-    clearState: function (mediaElement) {
+    clearState(mediaElement) {
         currentMediaState.set(mediaElement, null);
     },
 };

package/dist/_esm5.processed/core/decrypt/utils/persistent_sessions_store.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,21 +14,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../../log";
-import areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
-import { assertInterface } from "../../../utils/assert";
-import { bytesToBase64 } from "../../../utils/base64";
-import hashBuffer from "../../../utils/hash_buffer";
-import isNonEmptyString from "../../../utils/is_non_empty_string";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
-import areInitializationValuesCompatible from "./are_init_values_compatible";
-import SerializableBytes from "./serializable_bytes";
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../../log");
+const are_arrays_of_numbers_equal_1 = require("../../../utils/are_arrays_of_numbers_equal");
+const assert_1 = require("../../../utils/assert");
+const base64_1 = require("../../../utils/base64");
+const hash_buffer_1 = require("../../../utils/hash_buffer");
+const is_non_empty_string_1 = require("../../../utils/is_non_empty_string");
+const is_null_or_undefined_1 = require("../../../utils/is_null_or_undefined");
+const are_init_values_compatible_1 = require("./are_init_values_compatible");
+const serializable_bytes_1 = require("./serializable_bytes");
 /**
  * Throw if the given storage does not respect the right interface.
  * @param {Object} storage
  */
 function checkStorage(storage) {
-    assertInterface(storage, { save: "function", load: "function" }, "persistentLicenseConfig");
+    (0, assert_1.assertInterface)(storage, { save: "function", load: "function" }, "persistentLicenseConfig");
 }
 /**
  * Set representing persisted licenses. Depends on a simple
@@ -38,24 +40,24 @@ function checkStorage(storage) {
  * supported.
  * @class PersistentSessionsStore
  */
-var PersistentSessionsStore = /** @class */ (function () {
+class PersistentSessionsStore {
     /**
      * Create a new PersistentSessionsStore.
      * @param {Object} storage
      */
-    function PersistentSessionsStore(storage) {
+    constructor(storage) {
         checkStorage(storage);
         this._entries = [];
         this._storage = storage;
         try {
-            var entries = this._storage.load();
+            let entries = this._storage.load();
             if (!Array.isArray(entries)) {
                 entries = [];
             }
             this._entries = entries;
         }
         catch (e) {
-            log.warn("DRM-PSS: Could not get entries from license storage", e instanceof Error ? e : "");
+            log_1.default.warn("DRM-PSS: Could not get entries from license storage", e instanceof Error ? e : "");
             this.dispose();
         }
     }
@@ -63,28 +65,28 @@ var PersistentSessionsStore = /** @class */ (function () {
      * Returns the number of stored values.
      * @returns {number}
      */
-    PersistentSessionsStore.prototype.getLength = function () {
+    getLength() {
         return this._entries.length;
-    };
+    }
     /**
      * Returns information about all stored MediaKeySession, in the order in which
      * the MediaKeySession have been created.
      * @returns {Array.<Object>}
      */
-    PersistentSessionsStore.prototype.getAll = function () {
+    getAll() {
         return this._entries;
-    };
+    }
     /**
      * Retrieve an entry based on its initialization data.
      * @param {Object}  initData
      * @param {string|undefined} initDataType
      * @returns {Object|null}
      */
-    PersistentSessionsStore.prototype.get = function (initData) {
-        var index = this._getIndex(initData);
+    get(initData) {
+        const index = this._getIndex(initData);
         return index === -1 ? null :
             this._entries[index];
-    };
+    }
     /**
      * Like `get`, but also move the corresponding value at the end of the store
      * (as returned by `getAll`) if found.
@@ -96,79 +98,83 @@ var PersistentSessionsStore = /** @class */ (function () {
      * @param {string|undefined} initDataType
      * @returns {*}
      */
-    PersistentSessionsStore.prototype.getAndReuse = function (initData) {
-        var index = this._getIndex(initData);
+    getAndReuse(initData) {
+        const index = this._getIndex(initData);
         if (index === -1) {
             return null;
         }
-        var item = this._entries.splice(index, 1)[0];
+        const item = this._entries.splice(index, 1)[0];
         this._entries.push(item);
         return item;
-    };
+    }
     /**
      * Add a new entry in the PersistentSessionsStore.
      * @param {Uint8Array}  initData
      * @param {string|undefined} initDataType
      * @param {MediaKeySession} session
      */
-    PersistentSessionsStore.prototype.add = function (initData, keyIds, session) {
+    add(initData, keyIds, session) {
         var _a;
-        if (isNullOrUndefined(session) || !isNonEmptyString(session.sessionId)) {
-            log.warn("DRM-PSS: Invalid Persisten Session given.");
+        if ((0, is_null_or_undefined_1.default)(session) || !(0, is_non_empty_string_1.default)(session.sessionId)) {
+            log_1.default.warn("DRM-PSS: Invalid Persisten Session given.");
             return;
         }
-        var sessionId = session.sessionId;
-        var currentIndex = this._getIndex(initData);
+        const { sessionId } = session;
+        const currentIndex = this._getIndex(initData);
         if (currentIndex >= 0) {
-            var currVersion = keyIds === undefined ? 3 :
+            const currVersion = keyIds === undefined ? 3 :
                 4;
-            var currentEntry = this._entries[currentIndex];
-            var entryVersion = (_a = currentEntry.version) !== null && _a !== void 0 ? _a : -1;
+            const currentEntry = this._entries[currentIndex];
+            const entryVersion = (_a = currentEntry.version) !== null && _a !== void 0 ? _a : -1;
             if (entryVersion >= currVersion && sessionId === currentEntry.sessionId) {
                 return;
             }
-            log.info("DRM-PSS: Updating session info.", sessionId);
+            log_1.default.info("DRM-PSS: Updating session info.", sessionId);
             this._entries.splice(currentIndex, 1);
         }
         else {
-            log.info("DRM-PSS: Add new session", sessionId);
+            log_1.default.info("DRM-PSS: Add new session", sessionId);
         }
-        var storedValues = prepareValuesForStore(initData.values.getFormattedValues());
+        const storedValues = prepareValuesForStore(initData.values.getFormattedValues());
         if (keyIds === undefined) {
-            this._entries.push({ version: 3, sessionId: sessionId, values: storedValues,
+            this._entries.push({ version: 3,
+                sessionId,
+                values: storedValues,
                 initDataType: initData.type });
         }
         else {
-            this._entries.push({ version: 4, sessionId: sessionId, keyIds: keyIds.map(function (k) { return new SerializableBytes(k); }),
+            this._entries.push({ version: 4,
+                sessionId,
+                keyIds: keyIds.map((k) => new serializable_bytes_1.default(k)),
                 values: storedValues,
                 initDataType: initData.type });
         }
         this._save();
-    };
+    }
     /**
      * Delete stored MediaKeySession information based on its session id.
      * @param {string} sessionId
      */
-    PersistentSessionsStore.prototype.delete = function (sessionId) {
-        var index = -1;
-        for (var i = 0; i < this._entries.length; i++) {
-            var entry_1 = this._entries[i];
-            if (entry_1.sessionId === sessionId) {
+    delete(sessionId) {
+        let index = -1;
+        for (let i = 0; i < this._entries.length; i++) {
+            const entry = this._entries[i];
+            if (entry.sessionId === sessionId) {
                 index = i;
                 break;
             }
         }
         if (index === -1) {
-            log.warn("DRM-PSS: initData to delete not found.");
+            log_1.default.warn("DRM-PSS: initData to delete not found.");
             return;
         }
-        var entry = this._entries[index];
-        log.warn("DRM-PSS: Delete session from store", entry.sessionId);
+        const entry = this._entries[index];
+        log_1.default.warn("DRM-PSS: Delete session from store", entry.sessionId);
         this._entries.splice(index, 1);
         this._save();
-    };
-    PersistentSessionsStore.prototype.deleteOldSessions = function (sessionsToDelete) {
-        log.info("DRM-PSS: Deleting last ".concat(sessionsToDelete, " sessions."));
+    }
+    deleteOldSessions(sessionsToDelete) {
+        log_1.default.info(`DRM-PSS: Deleting last ${sessionsToDelete} sessions.`);
         if (sessionsToDelete <= 0) {
             return;
         }
@@ -176,137 +182,133 @@ var PersistentSessionsStore = /** @class */ (function () {
             this._entries.splice(0, sessionsToDelete);
         }
         else {
-            log.warn("DRM-PSS: Asked to remove more information that it contains", sessionsToDelete, this._entries.length);
+            log_1.default.warn("DRM-PSS: Asked to remove more information that it contains", sessionsToDelete, this._entries.length);
             this._entries = [];
         }
         this._save();
-    };
+    }
     /**
      * Delete all saved entries.
      */
-    PersistentSessionsStore.prototype.dispose = function () {
+    dispose() {
         this._entries = [];
         this._save();
-    };
+    }
     /**
      * Retrieve index of an entry.
      * Returns `-1` if not found.
      * @param {Object} initData
      * @returns {number}
      */
-    PersistentSessionsStore.prototype._getIndex = function (initData) {
+    _getIndex(initData) {
         // Older versions of the format include a concatenation of all
         // initialization data and its hash.
         // This is only computed lazily, the first time it is needed.
-        var lazyConcatenatedData = null;
+        let lazyConcatenatedData = null;
         function getConcatenatedInitDataInfo() {
             if (lazyConcatenatedData === null) {
-                var concatInitData = initData.values.constructRequestData();
+                const concatInitData = initData.values.constructRequestData();
                 lazyConcatenatedData = { initData: concatInitData,
-                    initDataHash: hashBuffer(concatInitData) };
+                    initDataHash: (0, hash_buffer_1.default)(concatInitData) };
             }
             return lazyConcatenatedData;
         }
-        var _loop_1 = function (i) {
-            var entry = this_1._entries[i];
+        for (let i = 0; i < this._entries.length; i++) {
+            const entry = this._entries[i];
             if (entry.initDataType === initData.type) {
                 switch (entry.version) {
                     case 4:
                         if (initData.keyIds !== undefined) {
-                            var foundCompatible = initData.keyIds.every(function (keyId) {
-                                var keyIdB64 = bytesToBase64(keyId);
-                                for (var _i = 0, _a = entry.keyIds; _i < _a.length; _i++) {
-                                    var entryKid = _a[_i];
+                            const foundCompatible = initData.keyIds.every(keyId => {
+                                const keyIdB64 = (0, base64_1.bytesToBase64)(keyId);
+                                for (const entryKid of entry.keyIds) {
                                     if (typeof entryKid === "string") {
                                         if (keyIdB64 === entryKid) {
                                             return true;
                                         }
                                     }
-                                    else if (areArraysOfNumbersEqual(entryKid.initData, keyId)) {
+                                    else if ((0, are_arrays_of_numbers_equal_1.default)(entryKid.initData, keyId)) {
                                         return true;
                                     }
                                 }
                                 return false;
                             });
                             if (foundCompatible) {
-                                return { value: i };
+                                return i;
                             }
                         }
                         else {
-                            var formatted_1 = initData.values.getFormattedValues();
-                            if (areInitializationValuesCompatible(formatted_1, entry.values)) {
-                                return { value: i };
+                            const formatted = initData.values.getFormattedValues();
+                            if ((0, are_init_values_compatible_1.default)(formatted, entry.values)) {
+                                return i;
                             }
                         }
                         break;
                     case 3:
-                        var formatted = initData.values.getFormattedValues();
-                        if (areInitializationValuesCompatible(formatted, entry.values)) {
-                            return { value: i };
+                        const formatted = initData.values.getFormattedValues();
+                        if ((0, are_init_values_compatible_1.default)(formatted, entry.values)) {
+                            return i;
                         }
                         break;
                     case 2: {
-                        var _a = getConcatenatedInitDataInfo(), concatInitData = _a.initData, concatHash = _a.initDataHash;
+                        const { initData: concatInitData, initDataHash: concatHash } = getConcatenatedInitDataInfo();
                         if (entry.initDataHash === concatHash) {
                             try {
-                                var decodedInitData = typeof entry.initData === "string" ?
-                                    SerializableBytes.decode(entry.initData) :
+                                const decodedInitData = typeof entry.initData === "string" ?
+                                    serializable_bytes_1.default.decode(entry.initData) :
                                     entry.initData.initData;
-                                if (areArraysOfNumbersEqual(decodedInitData, concatInitData)) {
-                                    return { value: i };
+                                if ((0, are_arrays_of_numbers_equal_1.default)(decodedInitData, concatInitData)) {
+                                    return i;
                                 }
                             }
                             catch (e) {
-                                log.warn("DRM-PSS: Could not decode initialization data.", e instanceof Error ? e : "");
+                                log_1.default.warn("DRM-PSS: Could not decode initialization data.", e instanceof Error ? e : "");
                             }
                         }
                         break;
                     }
                     case 1: {
-                        var _b = getConcatenatedInitDataInfo(), concatInitData = _b.initData, concatHash = _b.initDataHash;
+                        const { initData: concatInitData, initDataHash: concatHash } = getConcatenatedInitDataInfo();
                         if (entry.initDataHash === concatHash) {
                             if (typeof entry.initData.length === "undefined") {
-                                return { value: i };
+                                // If length is undefined, it has been linearized. We could still
+                                // convert it back to an Uint8Array but this would necessitate some
+                                // ugly unreadable logic for a very very minor possibility.
+                                // Just consider that it is a match based on the hash.
+                                return i;
                             }
-                            else if (areArraysOfNumbersEqual(entry.initData, concatInitData)) {
-                                return { value: i };
+                            else if ((0, are_arrays_of_numbers_equal_1.default)(entry.initData, concatInitData)) {
+                                return i;
                             }
                         }
                         break;
                     }
                     default: {
-                        var concatHash = getConcatenatedInitDataInfo().initDataHash;
+                        const { initDataHash: concatHash } = getConcatenatedInitDataInfo();
                         if (entry.initData === concatHash) {
-                            return { value: i };
+                            return i;
                         }
                     }
                 }
             }
-        };
-        var this_1 = this;
-        for (var i = 0; i < this._entries.length; i++) {
-            var state_1 = _loop_1(i);
-            if (typeof state_1 === "object")
-                return state_1.value;
         }
         return -1;
-    };
+    }
     /**
      * Use the given storage to store the current entries.
      */
-    PersistentSessionsStore.prototype._save = function () {
+    _save() {
         try {
             this._storage.save(this._entries);
         }
         catch (e) {
-            var err = e instanceof Error ? e :
+            const err = e instanceof Error ? e :
                 undefined;
-            log.warn("DRM-PSS: Could not save MediaKeySession information", err);
+            log_1.default.warn("DRM-PSS: Could not save MediaKeySession information", err);
         }
-    };
-    return PersistentSessionsStore;
-}());
-export default PersistentSessionsStore;
+    }
+}
+exports.default = PersistentSessionsStore;
 /**
  * Format given initializationData's values so they are ready to be stored:
  *   - sort them by systemId, so they are faster to compare
@@ -316,8 +318,7 @@ export default PersistentSessionsStore;
  */
 function prepareValuesForStore(initialValues) {
     return initialValues
-        .map(function (_a) {
-        var systemId = _a.systemId, data = _a.data, hash = _a.hash;
-        return ({ systemId: systemId, hash: hash, data: new SerializableBytes(data) });
-    });
+        .map(({ systemId, data, hash }) => ({ systemId,
+        hash,
+        data: new serializable_bytes_1.default(data) }));
 }

package/dist/_esm5.processed/core/decrypt/utils/serializable_bytes.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.
  */
-import { base64ToBytes, bytesToBase64, } from "../../../utils/base64";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base64_1 = require("../../../utils/base64");
 /** Wrap byte-based data and allow serialization of it into base64. */
-var SerializableBytes = /** @class */ (function () {
+class SerializableBytes {
     /**
      * Create a new `SerializableBytes`, wrapping the initialization data
      * given and allowing serialization into base64.
      * @param {Uint8Array}
      */
-    function SerializableBytes(initData) {
+    constructor(initData) {
         this.initData = initData;
     }
     /**
@@ -31,18 +33,17 @@ var SerializableBytes = /** @class */ (function () {
      * https://tc39.es/ecma262/#sec-serializejsonproperty
      * @returns {string}
      */
-    SerializableBytes.prototype.toJSON = function () {
-        return bytesToBase64(this.initData);
-    };
+    toJSON() {
+        return (0, base64_1.bytesToBase64)(this.initData);
+    }
     /**
      * Decode a base64 sequence representing an initialization data back to an
      * Uint8Array.
      * @param {string}
      * @returns {Uint8Array}
      */
-    SerializableBytes.decode = function (base64) {
-        return base64ToBytes(base64);
-    };
-    return SerializableBytes;
-}());
-export default SerializableBytes;
+    static decode(base64) {
+        return (0, base64_1.base64ToBytes)(base64);
+    }
+}
+exports.default = SerializableBytes;

package/dist/_esm5.processed/core/decrypt/utils/server_certificate_store.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 hashBuffer from "../../../utils/hash_buffer";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hash_buffer_1 = require("../../../utils/hash_buffer");
 /**
  * Keep track of server certificate which have been set for a MediaKeys.
  * As it is impossible for a MediaKeys to have his server certificate reset
@@ -27,9 +29,9 @@ import hashBuffer from "../../../utils/hash_buffer";
  * certificate is attached to a MediaKeys instance (most likely because related
  * EME APIs failed or had an unexpected behavior).
  */
-var serverCertificateHashesMap = new WeakMap();
+const serverCertificateHashesMap = new WeakMap();
 /** ServerCertificateStore */
-export default {
+exports.default = {
     /**
      * Tells the ServerCertificateStore that you begin to call the APIs to set a
      * ServerCertificate on `mediaKeys`.
@@ -42,7 +44,7 @@ export default {
      * server certificate attached to this MediaKeys is for now invalid.
      * @param {MediaKeys | Object} mediaKeys
      */
-    prepare: function (mediaKeys) {
+    prepare(mediaKeys) {
         serverCertificateHashesMap.set(mediaKeys, null);
     },
     /**
@@ -56,13 +58,13 @@ export default {
      * @param {MediaKeys | Object} mediaKeys
      * @param {ArrayBufferView | BufferSource} serverCertificate
      */
-    set: function (mediaKeys, serverCertificate) {
-        var formattedServerCertificate = serverCertificate instanceof Uint8Array ?
+    set(mediaKeys, serverCertificate) {
+        const formattedServerCertificate = serverCertificate instanceof Uint8Array ?
             serverCertificate :
             new Uint8Array(serverCertificate instanceof ArrayBuffer ? serverCertificate :
                 serverCertificate.buffer);
-        var hash = hashBuffer(formattedServerCertificate);
-        serverCertificateHashesMap.set(mediaKeys, { hash: hash, serverCertificate: formattedServerCertificate });
+        const hash = (0, hash_buffer_1.default)(formattedServerCertificate);
+        serverCertificateHashesMap.set(mediaKeys, { hash, serverCertificate: formattedServerCertificate });
     },
     /**
      * Returns `true` if the MediaKeys instance has an attached ServerCertificate.
@@ -73,8 +75,8 @@ export default {
      * @param {MediaKeys} mediaKeys
      * @returns {Boolean|undefined}
      */
-    hasOne: function (mediaKeys) {
-        var currentServerCertificate = serverCertificateHashesMap.get(mediaKeys);
+    hasOne(mediaKeys) {
+        const currentServerCertificate = serverCertificateHashesMap.get(mediaKeys);
         return currentServerCertificate === undefined ? false :
             currentServerCertificate === null ? undefined :
                 true;
@@ -87,22 +89,22 @@ export default {
      * @param {ArrayBufferView | BufferSource} serverCertificate
      * @returns {boolean}
      */
-    has: function (mediaKeys, serverCertificate) {
-        var serverCertificateHash = serverCertificateHashesMap.get(mediaKeys);
+    has(mediaKeys, serverCertificate) {
+        const serverCertificateHash = serverCertificateHashesMap.get(mediaKeys);
         if (serverCertificateHash === undefined || serverCertificateHash === null) {
             return false;
         }
-        var oldHash = serverCertificateHash.hash, oldServerCertificate = serverCertificateHash.serverCertificate;
-        var newServerCertificate = serverCertificate instanceof Uint8Array ?
+        const { hash: oldHash, serverCertificate: oldServerCertificate } = serverCertificateHash;
+        const newServerCertificate = serverCertificate instanceof Uint8Array ?
             serverCertificate :
             new Uint8Array(serverCertificate instanceof ArrayBuffer ? serverCertificate :
                 serverCertificate.buffer);
-        var newHash = hashBuffer(newServerCertificate);
+        const newHash = (0, hash_buffer_1.default)(newServerCertificate);
         if (newHash !== oldHash ||
             oldServerCertificate.length !== newServerCertificate.length) {
             return false;
         }
-        for (var i = 0; i < oldServerCertificate.length; i++) {
+        for (let i = 0; i < oldServerCertificate.length; i++) {
             if (oldServerCertificate[i] !== newServerCertificate[i]) {
                 return false;
             }