rx-player 4.5.0-dev.2026012301 → 4.5.0-dev.2026012302

package/dist/es2017/main_thread/decrypt/utils/media_keys_attacher.js

@@ -0,0 +1,184 @@
+/**
+ * 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 { setMediaKeys } from "../../../compat/eme/set_media_keys";
+import { EncryptedMediaError } from "../../../errors";
+import log from "../../../log";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+// Store the MediaKeys infos attached to a media element.
+const currentMediaState = new WeakMap();
+export default {
+    /**
+     * Attach new MediaKeys infos set on a HMTLMediaElement.
+     * @param {HTMLMediaElement} mediaElement
+     * @param {Object} mediaKeysInfo
+     * @returns {Promise}
+     */
+    async attach(mediaElement, mediaKeysInfo) {
+        const previousState = currentMediaState.get(mediaElement);
+        const pendingTask = attachMediaKeys(mediaElement, previousState, mediaKeysInfo).then(() => {
+            currentMediaState.set(mediaElement, {
+                pendingTask: null,
+                mediaKeysState: mediaKeysInfo,
+            });
+        }, () => {
+            currentMediaState.set(mediaElement, {
+                pendingTask: null,
+                mediaKeysState: null,
+            });
+        });
+        currentMediaState.set(mediaElement, {
+            pendingTask,
+            mediaKeysState: mediaKeysInfo,
+        });
+        return pendingTask;
+    },
+    /**
+     * Get MediaKeys information expected to be linked to the given
+     * `HTMLMediaElement`.
+     *
+     * Unlike `getAttachedMediaKeysState`, this method is synchronous and will
+     * also return the expected state when `MediaKeys` attachment is still
+     * pending and thus when that state is not truly applied (and where it
+     * might fail before being applied).
+     *
+     * As such, only call this method if you want the currently expected state,
+     * not the actual one.
+     * @param {HTMLMediaElement} mediaElement
+     * @returns {Array}
+     */
+    getAwaitedState(mediaElement) {
+        var _a;
+        const currentState = currentMediaState.get(mediaElement);
+        return (_a = currentState === null || currentState === void 0 ? void 0 : currentState.mediaKeysState) !== null && _a !== void 0 ? _a : null;
+    },
+    /**
+     * Get MediaKeys information set on a HMTLMediaElement.
+     *
+     * This method is asynchronous because that state may still be in a process
+     * of being attached to the `HTMLMediaElement` (and the state we're
+     * currently setting may not work out).
+     * @param {HTMLMediaElement} mediaElement
+     * @returns {Object|null}
+     */
+    async getAttachedMediaKeysState(mediaElement) {
+        const currentState = currentMediaState.get(mediaElement);
+        if (currentState === undefined) {
+            return null;
+        }
+        if (currentState.pendingTask !== null) {
+            await currentState.pendingTask;
+            return this.getAttachedMediaKeysState(mediaElement);
+        }
+        return currentState.mediaKeysState;
+    },
+    /**
+     * Remove MediaKeys currently set on a HMTLMediaElement and update state
+     * accordingly.
+     * @param {HTMLMediaElement} mediaElement
+     * @returns {Promise}
+     */
+    clearMediaKeys(mediaElement) {
+        const previousState = currentMediaState.get(mediaElement);
+        const pendingTask = clearMediaKeys(mediaElement, previousState).then(() => {
+            currentMediaState.set(mediaElement, {
+                pendingTask: null,
+                mediaKeysState: null,
+            });
+        }, () => {
+            currentMediaState.set(mediaElement, {
+                pendingTask: null,
+                mediaKeysState: null,
+            });
+        });
+        currentMediaState.set(mediaElement, {
+            pendingTask,
+            mediaKeysState: null,
+        });
+        return pendingTask;
+    },
+};
+/**
+ * Ensure that the last `MediaKeys` set on the given HTMLMediaElement is
+ * attached.
+ *
+ * The returned Promise never rejects, it will just log an error if the
+ * previous attachment failed.
+ *
+ * @param {Object} previousState
+ * @returns {Promise.<undefined>}
+ */
+async function awaitMediaKeysAttachment(previousState) {
+    const promise = previousState.pendingTask;
+    if (isNullOrUndefined(promise)) {
+        return;
+    }
+    log.info("DRM", "Awaiting previous MediaKeys attachment operation");
+    try {
+        await previousState.pendingTask;
+    }
+    catch (err) {
+        log.info("DRM", "previous MediaKeys attachment operation failed", err instanceof Error ? err : "Unknown error");
+    }
+}
+async function attachMediaKeys(mediaElement, previousState, mediaKeysInfo) {
+    if (previousState !== undefined) {
+        if (previousState.pendingTask !== null) {
+            // Ensure the `MediaKeys` has been fully attached to the HTMLMediaElement before
+            // resetting things, to avoid browser errors due to an invalid state.
+            await awaitMediaKeysAttachment(previousState);
+        }
+        const closeAllSessions = !isNullOrUndefined(previousState.mediaKeysState) &&
+            previousState.mediaKeysState.loadedSessionsStore !==
+                mediaKeysInfo.loadedSessionsStore
+            ? previousState.mediaKeysState.loadedSessionsStore.closeAllSessions()
+            : Promise.resolve();
+        await closeAllSessions;
+        if (mediaElement.mediaKeys === mediaKeysInfo.mediaKeys) {
+            log.debug("DRM", "Right MediaKeys already set");
+            return;
+        }
+    }
+    log.info("DRM", "Attaching MediaKeys to the media element");
+    try {
+        await setMediaKeys(mediaKeysInfo.emeImplementation, mediaElement, mediaKeysInfo.mediaKeys);
+        log.info("DRM", "MediaKeys attached with success");
+    }
+    catch (err) {
+        const errMessage = err instanceof Error ? err.toString() : "Unknown Error";
+        throw new EncryptedMediaError("MEDIA_KEYS_ATTACHMENT_ERROR", "Could not attach the MediaKeys to the media element: " + errMessage, {
+            keyStatuses: undefined,
+            keySystemConfiguration: mediaKeysInfo.mediaKeySystemAccess.getConfiguration(),
+            keySystem: mediaKeysInfo.mediaKeySystemAccess.keySystem,
+        });
+    }
+}
+async function clearMediaKeys(mediaElement, previousState) {
+    if (previousState === undefined) {
+        return;
+    }
+    if (previousState.pendingTask !== null) {
+        // Ensure the `MediaKeys` has been fully attached to the HTMLMediaElement before
+        // resetting things, to avoid browser errors due to an invalid state.
+        await awaitMediaKeysAttachment(previousState);
+    }
+    if (previousState.mediaKeysState === null) {
+        return;
+    }
+    log.info("DRM", "Disposing of the current MediaKeys");
+    const { loadedSessionsStore } = previousState.mediaKeysState;
+    await loadedSessionsStore.closeAllSessions();
+    return setMediaKeys(previousState.mediaKeysState.emeImplementation, mediaElement, null);
+}

package/dist/es2017/main_thread/decrypt/utils/persistent_sessions_store.d.ts

@@ -0,0 +1,93 @@
+/**
+ * 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 type { IMediaKeySession } from "../../../compat/browser_compatibility_types";
+import type { IPersistentLicenseConfig, IPersistentSessionInfo } from "../../../public_types";
+import type { IProcessedProtectionData } from "../types";
+/**
+ * Set representing persisted licenses. Depends on a simple
+ * implementation with a `save`/`load` synchronous interface
+ * to persist information on persisted sessions.
+ *
+ * This set is used only for a cdm/keysystem with license persistency
+ * supported.
+ * @class PersistentSessionsStore
+ */
+export default class PersistentSessionsStore {
+    private readonly _storage;
+    private _entries;
+    /**
+     * Create a new PersistentSessionsStore.
+     * @param {Object} storage
+     */
+    constructor(storage: IPersistentLicenseConfig);
+    /**
+     * Returns the number of stored values.
+     * @returns {number}
+     */
+    getLength(): number;
+    /**
+     * Returns information about all stored MediaKeySession, in the order in which
+     * the MediaKeySession have been created.
+     * @returns {Array.<Object>}
+     */
+    getAll(): IPersistentSessionInfo[];
+    /**
+     * Retrieve an entry based on its initialization data.
+     * @param {Object}  initData
+     * @returns {Object|null}
+     */
+    get(initData: IProcessedProtectionData): IPersistentSessionInfo | null;
+    /**
+     * Like `get`, but also move the corresponding value at the end of the store
+     * (as returned by `getAll`) if found.
+     * This can be used for example to tell when a previously-stored value is
+     * re-used to then be able to implement a caching replacement algorithm based
+     * on the least-recently-used values by just evicting the first values
+     * returned by `getAll`.
+     * @param {Object} initData
+     * @returns {*}
+     */
+    getAndReuse(initData: IProcessedProtectionData): IPersistentSessionInfo | null;
+    /**
+     * Add a new entry in the PersistentSessionsStore.
+     * @param {Object}  initData
+     * @param {Array.<Uint8Array>|undefined} keyIds
+     * @param {MediaKeySession} session
+     */
+    add(initData: IProcessedProtectionData, keyIds: Uint8Array[] | undefined, session: IMediaKeySession): void;
+    /**
+     * Delete stored MediaKeySession information based on its session id.
+     * @param {string} sessionId
+     */
+    delete(sessionId: string): void;
+    deleteOldSessions(sessionsToDelete: number): void;
+    /**
+     * Delete all saved entries.
+     */
+    dispose(): void;
+    /**
+     * Retrieve index of an entry.
+     * Returns `-1` if not found.
+     * @param {Object} initData
+     * @returns {number}
+     */
+    private _getIndex;
+    /**
+     * Use the given storage to store the current entries.
+     */
+    private _save;
+}
+//# sourceMappingURL=persistent_sessions_store.d.ts.map

package/dist/es2017/main_thread/decrypt/utils/persistent_sessions_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistent_sessions_store.d.ts","sourceRoot":"","sources":["../../../../../src/main_thread/decrypt/utils/persistent_sessions_store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AAEpF,OAAO,KAAK,EACV,wBAAwB,EACxB,sBAAsB,EACvB,MAAM,uBAAuB,CAAC;AAO/B,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAiBzD;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,uBAAuB;IAC1C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2B;IACpD,OAAO,CAAC,QAAQ,CAA2B;IAE3C;;;OAGG;gBACS,OAAO,EAAE,wBAAwB;IAoB7C;;;OAGG;IACI,SAAS,IAAI,MAAM;IAI1B;;;;OAIG;IACI,MAAM,IAAI,sBAAsB,EAAE;IAIzC;;;;OAIG;IACI,GAAG,CAAC,QAAQ,EAAE,wBAAwB,GAAG,sBAAsB,GAAG,IAAI;IAK7E;;;;;;;;;OASG;IACI,WAAW,CAAC,QAAQ,EAAE,wBAAwB,GAAG,sBAAsB,GAAG,IAAI;IAUrF;;;;;OAKG;IACI,GAAG,CACR,QAAQ,EAAE,wBAAwB,EAClC,MAAM,EAAE,UAAU,EAAE,GAAG,SAAS,EAChC,OAAO,EAAE,gBAAgB,GACxB,IAAI;IAwCP;;;OAGG;IACI,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAwB/B,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI;IAmBxD;;OAEG;IACI,OAAO,IAAI,IAAI;IAKtB;;;;;OAKG;IACH,OAAO,CAAC,SAAS;IAwLjB;;OAEG;IACH,OAAO,CAAC,KAAK;CAYd"}

package/dist/es2017/main_thread/decrypt/utils/persistent_sessions_store.js

@@ -0,0 +1,369 @@
+/**
+ * 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 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";
+/**
+ * Throw if the given storage does not respect the right interface.
+ * @param {Object} storage
+ */
+function checkStorage(storage) {
+    assertInterface(storage, { save: "function", load: "function" }, "persistentLicenseConfig");
+}
+/**
+ * Set representing persisted licenses. Depends on a simple
+ * implementation with a `save`/`load` synchronous interface
+ * to persist information on persisted sessions.
+ *
+ * This set is used only for a cdm/keysystem with license persistency
+ * supported.
+ * @class PersistentSessionsStore
+ */
+export default class PersistentSessionsStore {
+    /**
+     * Create a new PersistentSessionsStore.
+     * @param {Object} storage
+     */
+    constructor(storage) {
+        checkStorage(storage);
+        this._entries = [];
+        this._storage = storage;
+        try {
+            let entries = this._storage.load();
+            if (!Array.isArray(entries)) {
+                entries = [];
+            }
+            this._entries = entries;
+        }
+        catch (e) {
+            log.warn("DRM", "Persistent store: Could not get entries from license storage", e instanceof Error ? e : "");
+            this.dispose();
+        }
+    }
+    /**
+     * Returns the number of stored values.
+     * @returns {number}
+     */
+    getLength() {
+        return this._entries.length;
+    }
+    /**
+     * Returns information about all stored MediaKeySession, in the order in which
+     * the MediaKeySession have been created.
+     * @returns {Array.<Object>}
+     */
+    getAll() {
+        return this._entries;
+    }
+    /**
+     * Retrieve an entry based on its initialization data.
+     * @param {Object}  initData
+     * @returns {Object|null}
+     */
+    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.
+     * This can be used for example to tell when a previously-stored value is
+     * re-used to then be able to implement a caching replacement algorithm based
+     * on the least-recently-used values by just evicting the first values
+     * returned by `getAll`.
+     * @param {Object} initData
+     * @returns {*}
+     */
+    getAndReuse(initData) {
+        const index = this._getIndex(initData);
+        if (index === -1) {
+            return null;
+        }
+        const item = this._entries.splice(index, 1)[0];
+        this._entries.push(item);
+        return item;
+    }
+    /**
+     * Add a new entry in the PersistentSessionsStore.
+     * @param {Object}  initData
+     * @param {Array.<Uint8Array>|undefined} keyIds
+     * @param {MediaKeySession} session
+     */
+    add(initData, keyIds, session) {
+        var _a;
+        if (isNullOrUndefined(session) || !isNonEmptyString(session.sessionId)) {
+            log.warn("DRM", "Persistent Store: Invalid Persisten Session given.");
+            return;
+        }
+        const { sessionId } = session;
+        const currentIndex = this._getIndex(initData);
+        if (currentIndex >= 0) {
+            const currVersion = keyIds === undefined ? 3 : 4;
+            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", "Persistent Store: Updating session info.", { sessionId });
+            this._entries.splice(currentIndex, 1);
+        }
+        else {
+            log.info("DRM", "Persistent Store: Add new session", { sessionId });
+        }
+        const storedValues = prepareValuesForStore(initData.values.getFormattedValues());
+        if (keyIds === undefined) {
+            this._entries.push({
+                version: 3,
+                sessionId,
+                values: storedValues,
+                initDataType: initData.type,
+            });
+        }
+        else {
+            this._entries.push({
+                version: 4,
+                sessionId,
+                keyIds: keyIds.map((k) => new SerializableBytes(k)),
+                values: storedValues,
+                initDataType: initData.type,
+            });
+        }
+        this._save();
+    }
+    /**
+     * Delete stored MediaKeySession information based on its session id.
+     * @param {string} 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", "Persistent Store: initData to delete not found in persistent store.");
+            return;
+        }
+        const entry = this._entries[index];
+        log.warn("DRM", "Persistent Store: Delete session from persistent store", {
+            sessionId: entry.sessionId,
+        });
+        this._entries.splice(index, 1);
+        this._save();
+    }
+    deleteOldSessions(sessionsToDelete) {
+        log.info("DRM", "Persistent Store: Deleting last sessions.", { sessionsToDelete });
+        if (sessionsToDelete <= 0) {
+            return;
+        }
+        if (sessionsToDelete <= this._entries.length) {
+            this._entries.splice(0, sessionsToDelete);
+        }
+        else {
+            log.warn("DRM", "Persistent Store: Asked to remove more information that it contains", sessionsToDelete, this._entries.length);
+            this._entries = [];
+        }
+        this._save();
+    }
+    /**
+     * Delete all saved entries.
+     */
+    dispose() {
+        this._entries = [];
+        this._save();
+    }
+    /**
+     * Retrieve index of an entry.
+     * Returns `-1` if not found.
+     * @param {Object} initData
+     * @returns {number}
+     */
+    _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.
+        let lazyConcatenatedData = null;
+        function getConcatenatedInitDataInfo() {
+            if (lazyConcatenatedData === null) {
+                const concatInitData = initData.values.constructRequestData();
+                lazyConcatenatedData = {
+                    initData: concatInitData,
+                    initDataHash: hashBuffer(concatInitData),
+                };
+            }
+            return lazyConcatenatedData;
+        }
+        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 (Array.isArray(initData.keyIds) && initData.keyIds.length > 0) {
+                            const foundCompatible = initData.keyIds.every((keyId) => {
+                                const keyIdB64 = bytesToBase64(keyId);
+                                for (const entryKid of entry.keyIds) {
+                                    if (typeof entryKid === "string") {
+                                        if (keyIdB64 === entryKid) {
+                                            log.debug("DRM", "Persistent Store: Found wanted kid stored on entry", {
+                                                index: i,
+                                                keyId: keyIdB64,
+                                                sessionId: entry.sessionId,
+                                            });
+                                            return true;
+                                        }
+                                    }
+                                    else if (areArraysOfNumbersEqual(entryKid.initData, keyId)) {
+                                        if (log.hasLevel("DEBUG")) {
+                                            log.debug("DRM", "Persistent Store: Found wanted kid stored on entry", {
+                                                index: i,
+                                                keyId: keyIdB64,
+                                                sessionId: entry.sessionId,
+                                            });
+                                        }
+                                        return true;
+                                    }
+                                }
+                                return false;
+                            });
+                            if (foundCompatible) {
+                                log.debug("DRM", "Persistent Store: Found compatible entry of v4", {
+                                    index: i,
+                                    sessionId: entry.sessionId,
+                                });
+                                return i;
+                            }
+                        }
+                        else {
+                            const formatted = initData.values.getFormattedValues();
+                            if (areInitializationValuesCompatible(formatted, entry.values)) {
+                                log.debug("DRM", "Persistent Store: Found compatible entry of v4 without init data", {
+                                    index: i,
+                                    sessionId: entry.sessionId,
+                                });
+                                return i;
+                            }
+                        }
+                        break;
+                    case 3: {
+                        const formatted = initData.values.getFormattedValues();
+                        if (areInitializationValuesCompatible(formatted, entry.values)) {
+                            log.debug("DRM", "Persistent Store: Found compatible entry of v3 - same values", {
+                                index: i,
+                                sessionId: entry.sessionId,
+                            });
+                            return i;
+                        }
+                        break;
+                    }
+                    case 2: {
+                        const { initData: concatInitData, initDataHash: concatHash } = getConcatenatedInitDataInfo();
+                        if (entry.initDataHash === concatHash) {
+                            try {
+                                const decodedInitData = typeof entry.initData === "string"
+                                    ? SerializableBytes.decode(entry.initData)
+                                    : entry.initData.initData;
+                                if (areArraysOfNumbersEqual(decodedInitData, concatInitData)) {
+                                    log.debug("DRM", "Persistent Store: Found compatible entry of v2 - same concatenated init data", {
+                                        index: i,
+                                        sessionId: entry.sessionId,
+                                    });
+                                    return i;
+                                }
+                            }
+                            catch (e) {
+                                log.warn("DRM", "Persistent Store: Could not decode initialization data.", e instanceof Error ? e : "");
+                            }
+                        }
+                        break;
+                    }
+                    case 1: {
+                        const { initData: concatInitData, initDataHash: concatHash } = getConcatenatedInitDataInfo();
+                        if (entry.initDataHash === concatHash) {
+                            if (typeof entry.initData.length === "undefined") {
+                                // 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.
+                                log.debug("DRM", "Persistent Store: Found compatible entry of v1 - same hash only", {
+                                    index: i,
+                                    sessionId: entry.sessionId,
+                                    hash: concatHash,
+                                });
+                                return i;
+                            }
+                            else if (areArraysOfNumbersEqual(entry.initData, concatInitData)) {
+                                log.debug("DRM", "Persistent Store: Found compatible entry of v1 - same hash and initData", {
+                                    index: i,
+                                    sessionId: entry.sessionId,
+                                    hash: concatHash,
+                                });
+                                return i;
+                            }
+                        }
+                        break;
+                    }
+                    default: {
+                        const { initDataHash: concatHash } = getConcatenatedInitDataInfo();
+                        if (entry.initData === concatHash) {
+                            log.debug("DRM", "Persistent Store: Found compatible entry - same hash only", {
+                                index: i,
+                                sessionId: entry.sessionId,
+                                hash: concatHash,
+                            });
+                            return i;
+                        }
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+    /**
+     * Use the given storage to store the current entries.
+     */
+    _save() {
+        try {
+            this._storage.save(this._entries);
+        }
+        catch (e) {
+            const err = e instanceof Error ? e : undefined;
+            log.warn("DRM", "Persistent Store: Could not save MediaKeySession information", err);
+        }
+    }
+}
+/**
+ * Format given initializationData's values so they are ready to be stored:
+ *   - sort them by systemId, so they are faster to compare
+ *   - add hash for each initialization data encountered.
+ * @param {Array.<Object>} initialValues
+ * @returns {Array.<Object>}
+ */
+function prepareValuesForStore(initialValues) {
+    return initialValues.map(({ systemId, data, hash }) => ({
+        systemId,
+        hash,
+        data: new SerializableBytes(data),
+    }));
+}