rx-player 3.26.2 → 3.27.0-dev.20220317

package/dist/_esm5.processed/core/{eme → decrypt/utils}/clean_old_stored_persistent_info.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../log";
+import log from "../../../log";
 /**
  * Remove old information from a PersistentSessionsStore so that it respects the
  * given `limit` as a maximum size. This can be used to prevent its size from
@@ -35,6 +35,6 @@ export default function cleanOldStoredPersistentInfo(persistentSessionsStore, li
     }
     var numberOfPersistentSessions = persistentSessionsStore.getLength();
     var toDelete = numberOfPersistentSessions - limit;
-    log.info("EME: Too many stored persistent sessions, removing some.", numberOfPersistentSessions, toDelete);
+    log.info("DRM: Too many stored persistent sessions, removing some.", numberOfPersistentSessions, toDelete);
     persistentSessionsStore.deleteOldSessions(toDelete);
 }

package/dist/_esm5.processed/core/{eme → decrypt/utils}/get_drm_system_id.js

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import startsWith from "../../utils/starts_with";
+import startsWith from "../../../utils/starts_with";
 /**
  * @param {string} keySystem
  * @returns {string|undefined}

package/dist/_esm5.processed/core/decrypt/utils/init_data_values_container.d.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 { IInitDataValue } from "../types";
+/**
+ * Wrap initialization data values and reformat it so it becomes easier to check
+ * compatibility with other `InitDataValuesContainer`.
+ * @class InitDataValuesContainer
+ */
+export default class InitDataValuesContainer {
+    private readonly _innerValues;
+    private _lazyFormattedValues;
+    /**
+     * Construct a new `InitDataValuesContainer`.
+     * Note that the data is not formatted right away.
+     * It is only really formatted lazily the first time we need it.
+     *
+     * @param {Array.<Object>} initDataValues
+     */
+    constructor(initDataValues: IInitDataValue[]);
+    /**
+     * Construct data that should be given to the `generateRequest` EME API.
+     * @returns {Uint8Array}
+     */
+    constructRequestData(): Uint8Array;
+    /**
+     * Returns `true` if the given `InitDataValuesContainer` seems to be
+     * "compatible" with the one stored in this instance.
+     * Returns `false` if not.
+     *
+     * By "compatible" we mean that it will generate the same key request.
+     * @param {InitDataValuesContainer | Object} initDataValues
+     * @returns {boolean}
+     */
+    isCompatibleWith(initDataValues: InitDataValuesContainer | IFormattedInitDataValue[]): boolean;
+    /**
+     * Return the stored initialization data values, with added niceties:
+     *   - they are sorted always the same way for similar
+     *     `InitDataValuesContainer`
+     *   - each value is associated to its hash, which is always done with  the
+     *     same hashing function than for all other InitDataValuesContainer).
+     *
+     * The main point being to be able to compare much faster multiple
+     * `InitDataValuesContainer`, though that data can also be used in any
+     * other way.
+     * @returns {Array.<Object>}
+     */
+    getFormattedValues(): IFormattedInitDataValue[];
+}
+/**
+ * Formatted initialization data value, so it is faster to compare to others.
+ */
+export interface IFormattedInitDataValue {
+    systemId: string | undefined;
+    hash: number;
+    data: Uint8Array;
+}

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

@@ -0,0 +1,99 @@
+/**
+ * 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 { concat } from "../../../utils/byte_parsing";
+import hashBuffer from "../../../utils/hash_buffer";
+import areInitializationValuesCompatible from "./are_init_values_compatible";
+/**
+ * Wrap initialization data values and reformat it so it becomes easier to check
+ * compatibility with other `InitDataValuesContainer`.
+ * @class InitDataValuesContainer
+ */
+var InitDataValuesContainer = /** @class */ (function () {
+    /**
+     * Construct a new `InitDataValuesContainer`.
+     * Note that the data is not formatted right away.
+     * It is only really formatted lazily the first time we need it.
+     *
+     * @param {Array.<Object>} initDataValues
+     */
+    function InitDataValuesContainer(initDataValues) {
+        this._innerValues = initDataValues;
+        this._lazyFormattedValues = null;
+    }
+    /**
+     * Construct data that should be given to the `generateRequest` EME API.
+     * @returns {Uint8Array}
+     */
+    InitDataValuesContainer.prototype.constructRequestData = function () {
+        // `generateKeyRequest` awaits a single Uint8Array containing all
+        // initialization data.
+        return concat.apply(void 0, this._innerValues.map(function (i) { return i.data; }));
+    };
+    /**
+     * Returns `true` if the given `InitDataValuesContainer` seems to be
+     * "compatible" with the one stored in this instance.
+     * Returns `false` if not.
+     *
+     * By "compatible" we mean that it will generate the same key request.
+     * @param {InitDataValuesContainer | Object} initDataValues
+     * @returns {boolean}
+     */
+    InitDataValuesContainer.prototype.isCompatibleWith = function (initDataValues) {
+        var formatted = initDataValues instanceof InitDataValuesContainer ?
+            initDataValues.getFormattedValues() :
+            initDataValues;
+        return areInitializationValuesCompatible(this.getFormattedValues(), formatted);
+    };
+    /**
+     * Return the stored initialization data values, with added niceties:
+     *   - they are sorted always the same way for similar
+     *     `InitDataValuesContainer`
+     *   - each value is associated to its hash, which is always done with  the
+     *     same hashing function than for all other InitDataValuesContainer).
+     *
+     * The main point being to be able to compare much faster multiple
+     * `InitDataValuesContainer`, though that data can also be used in any
+     * other way.
+     * @returns {Array.<Object>}
+     */
+    InitDataValuesContainer.prototype.getFormattedValues = function () {
+        if (this._lazyFormattedValues === null) {
+            this._lazyFormattedValues = formatInitDataValues(this._innerValues);
+        }
+        return this._lazyFormattedValues;
+    };
+    return InitDataValuesContainer;
+}());
+export default InitDataValuesContainer;
+/**
+ * Format given initializationData's values so they are faster to compare:
+ *   - sort them by systemId
+ *   - add hash for each initialization data encountered.
+ * @param {Array.<Object>} initialValues
+ * @returns {Array.<Object>}
+ */
+function formatInitDataValues(initialValues) {
+    return initialValues.slice()
+        .sort(function (a, b) { return a.systemId === b.systemId ? 0 :
+        a.systemId === undefined ? 1 :
+            b.systemId === undefined ? -1 :
+                a.systemId < b.systemId ? -1 :
+                    1; })
+        .map(function (_a) {
+        var systemId = _a.systemId, data = _a.data;
+        return ({ systemId: systemId, data: data, hash: hashBuffer(data) });
+    });
+}

package/dist/_esm5.processed/core/{eme → decrypt}/utils/is_session_usable.d.ts

@@ -18,7 +18,6 @@ import { ICustomMediaKeySession } from "../../../compat";
  * If all key statuses attached to session are valid (either not
  * "expired" or "internal-error"), return true.
  * If not, return false.
- * @param {Uint8Array} initData
  * @param {MediaKeySession} loadedSession
  * @returns {MediaKeySession}
  */

package/dist/_esm5.processed/core/{eme → decrypt}/utils/is_session_usable.js

@@ -19,7 +19,6 @@ import arrayIncludes from "../../../utils/array_includes";
  * If all key statuses attached to session are valid (either not
  * "expired" or "internal-error"), return true.
  * If not, return false.
- * @param {Uint8Array} initData
  * @param {MediaKeySession} loadedSession
  * @returns {MediaKeySession}
  */
@@ -33,18 +32,18 @@ export default function isSessionUsable(loadedSession) {
         keyStatuses.push(keyStatus);
     });
     if (keyStatuses.length <= 0) {
-        log.debug("EME: isSessionUsable: MediaKeySession given has an empty keyStatuses", loadedSession.sessionId);
+        log.debug("DRM: isSessionUsable: MediaKeySession given has an empty keyStatuses", loadedSession.sessionId);
         return false;
     }
     if (arrayIncludes(keyStatuses, "expired")) {
-        log.debug("EME: isSessionUsable: MediaKeySession given has an expired key", loadedSession.sessionId);
+        log.debug("DRM: isSessionUsable: MediaKeySession given has an expired key", loadedSession.sessionId);
         return false;
     }
     if (arrayIncludes(keyStatuses, "internal-error")) {
-        log.debug("EME: isSessionUsable: MediaKeySession given has a key with an " +
+        log.debug("DRM: isSessionUsable: MediaKeySession given has a key with an " +
             "internal-error", loadedSession.sessionId);
         return false;
     }
-    log.debug("EME: isSessionUsable: MediaKeySession is usable", loadedSession.sessionId);
+    log.debug("DRM: isSessionUsable: MediaKeySession is usable", loadedSession.sessionId);
     return true;
 }

package/dist/_esm5.processed/core/decrypt/utils/key_id_comparison.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+/**
+ * Returns `true` if both given key id appear to be equal.
+ * @param {Uint8Array} keyId1
+ * @param {Uint8Array} keyId2
+ * @returns {boolean}
+ */
+export declare function areKeyIdsEqual(keyId1: Uint8Array, keyId2: Uint8Array): boolean;
+/**
+ * @param {Uint8Array} wantedKeyId
+ * @param {Array.<Uint8Array>} keyIdsArr
+ * @returns {boolean}
+ */
+export declare function isKeyIdContainedIn(wantedKeyId: Uint8Array, keyIdsArr: Uint8Array[]): boolean;
+/**
+ * Returns `true` if all key ids in `wantedKeyIds` are present in the
+ * `keyIdsArr` array.
+ * @param {Array.<Uint8Array>} wantedKeyIds
+ * @param {Array.<Uint8Array>} keyIdsArr
+ * @returns {boolean}
+ */
+export declare function areAllKeyIdsContainedIn(wantedKeyIds: Uint8Array[], keyIdsArr: Uint8Array[]): boolean;
+/**
+ * Returns `true` if at least one key id in `wantedKeyIds` is present in the
+ * `keyIdsArr` array.
+ * @param {Array.<Uint8Array>} wantedKeyIds
+ * @param {Array.<Uint8Array>} keyIdsArr
+ * @returns {boolean}
+ */
+export declare function areSomeKeyIdsContainedIn(wantedKeyIds: Uint8Array[], keyIdsArr: Uint8Array[]): boolean;

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

@@ -0,0 +1,77 @@
+/**
+ * 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 areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
+/**
+ * Returns `true` if both given key id appear to be equal.
+ * @param {Uint8Array} keyId1
+ * @param {Uint8Array} keyId2
+ * @returns {boolean}
+ */
+export function areKeyIdsEqual(keyId1, keyId2) {
+    return keyId1 === keyId2 || areArraysOfNumbersEqual(keyId1, keyId2);
+}
+/**
+ * @param {Uint8Array} wantedKeyId
+ * @param {Array.<Uint8Array>} keyIdsArr
+ * @returns {boolean}
+ */
+export function isKeyIdContainedIn(wantedKeyId, keyIdsArr) {
+    return keyIdsArr.some(function (k) { return areKeyIdsEqual(k, wantedKeyId); });
+}
+/**
+ * Returns `true` if all key ids in `wantedKeyIds` are present in the
+ * `keyIdsArr` array.
+ * @param {Array.<Uint8Array>} wantedKeyIds
+ * @param {Array.<Uint8Array>} keyIdsArr
+ * @returns {boolean}
+ */
+export function areAllKeyIdsContainedIn(wantedKeyIds, keyIdsArr) {
+    var _loop_1 = function (keyId) {
+        var found = keyIdsArr.some(function (k) { return areKeyIdsEqual(k, keyId); });
+        if (!found) {
+            return { value: false };
+        }
+    };
+    for (var _i = 0, wantedKeyIds_1 = wantedKeyIds; _i < wantedKeyIds_1.length; _i++) {
+        var keyId = wantedKeyIds_1[_i];
+        var state_1 = _loop_1(keyId);
+        if (typeof state_1 === "object")
+            return state_1.value;
+    }
+    return true;
+}
+/**
+ * Returns `true` if at least one key id in `wantedKeyIds` is present in the
+ * `keyIdsArr` array.
+ * @param {Array.<Uint8Array>} wantedKeyIds
+ * @param {Array.<Uint8Array>} keyIdsArr
+ * @returns {boolean}
+ */
+export function areSomeKeyIdsContainedIn(wantedKeyIds, keyIdsArr) {
+    var _loop_2 = function (keyId) {
+        var found = keyIdsArr.some(function (k) { return areKeyIdsEqual(k, keyId); });
+        if (found) {
+            return { value: true };
+        }
+    };
+    for (var _i = 0, wantedKeyIds_2 = wantedKeyIds; _i < wantedKeyIds_2.length; _i++) {
+        var keyId = wantedKeyIds_2[_i];
+        var state_2 = _loop_2(keyId);
+        if (typeof state_2 === "object")
+            return state_2.value;
+    }
+    return false;
+}

package/dist/_esm5.processed/core/decrypt/utils/key_session_record.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 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 { IProcessedProtectionData } from "../types";
+/**
+ * Class storing key-related information linked to a created `MediaKeySession`.
+ *
+ * This class allows to regroup one or multiple key ids and can be linked to a
+ * single MediaKeySession so you can know which key that MediaKeySession
+ * handles.
+ *
+ * The main use case behind the complexities of this `KeySessionRecord` is to
+ * better handle the `singleLicensePer` RxPlayer option, which allows the
+ * recuperation of a license containing multiple keys, even if only one of
+ * those keys was asked for (which in turn allows to reduce the number of
+ * requests and to improve performance).
+ * Here, the `KeySessionRecord` will regroup all those key's id and can be
+ * linked to the corresponding MediaKeySession.
+ * That way, you can later check if another encrypted content is compatible with
+ * that session through the `KeySessionRecord`'s `isCompatibleWith` method.
+ *
+ * @example
+ * ```js
+ * const record = new KeySessionRecord(initData);
+ *
+ * // Create a MediaKeySession linked to that initialization data and fetch the
+ * // license
+ * // ...
+ *
+ * // Once the license has been loaded to the MediaKeySession linked to that
+ - // initialization data, associate the license's key Ids with the latter.
+ * record.associateKeyIds(someKeyIds);
+ *
+ * // Function called when new initialization data is encountered
+ * function onNewInitializationData(newInitializationData) {
+ *   if (record.isCompatibleWith(newInitializationData)) {
+ *     console.log("This initialization data should already be handled, ignored.");
+ *   } else {
+ *     console.log("This initialization data is not handled yet.";
+ *   }
+ * }
+ * ```
+ * @class KeySessionRecord
+ */
+export default class KeySessionRecord {
+    private readonly _initializationData;
+    private _keyIds;
+    /**
+     * Create a new `KeySessionRecord`, linked to its corresponding initialization
+     * data,
+     * @param {Object} initializationData
+     */
+    constructor(initializationData: IProcessedProtectionData);
+    /**
+     * Associate supplementary key ids to this `KeySessionRecord` so it becomes
+     * "compatible" to them.
+     *
+     * After this call, new initialization data linked to subsets of those key
+     * ids will be considered compatible  to this `KeySessionRecord` (calls to
+     * `isCompatibleWith` with the corresponding initialization data will return
+     * `true`).
+     * @param {Array.<Uint8Array>} keyIds
+     */
+    associateKeyIds(keyIds: Uint8Array[] | IterableIterator<Uint8Array>): void;
+    /**
+     * @param {Uint8Array} keyId
+     * @returns {boolean}
+     */
+    isAssociatedWithKeyId(keyId: Uint8Array): boolean;
+    /**
+     * @returns {Array.<Uint8Array>}
+     */
+    getAssociatedKeyIds(): Uint8Array[];
+    /**
+     * Check if that `KeySessionRecord` is compatible to the initialization data
+     * given.
+     *
+     * If it returns `true`, it means that this `KeySessionRecord` is already
+     * linked to that initialization data's key. As such, if that
+     * `KeySessionRecord` is already associated to an active MediaKeySession for
+     * example, the content linked to that initialization data should already be
+     * handled.
+     *
+     * If it returns `false`, it means that this `KeySessionRecord` has no
+     * relation with the given initialization data.
+     *
+     * @param {Object} initializationData
+     * @returns {boolean}
+     */
+    isCompatibleWith(initializationData: IProcessedProtectionData): boolean;
+    private _checkInitializationDataCompatibility;
+}

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

@@ -0,0 +1,155 @@
+/**
+ * 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 { areKeyIdsEqual, areAllKeyIdsContainedIn, } from "./key_id_comparison";
+/**
+ * Class storing key-related information linked to a created `MediaKeySession`.
+ *
+ * This class allows to regroup one or multiple key ids and can be linked to a
+ * single MediaKeySession so you can know which key that MediaKeySession
+ * handles.
+ *
+ * The main use case behind the complexities of this `KeySessionRecord` is to
+ * better handle the `singleLicensePer` RxPlayer option, which allows the
+ * recuperation of a license containing multiple keys, even if only one of
+ * those keys was asked for (which in turn allows to reduce the number of
+ * requests and to improve performance).
+ * Here, the `KeySessionRecord` will regroup all those key's id and can be
+ * linked to the corresponding MediaKeySession.
+ * That way, you can later check if another encrypted content is compatible with
+ * that session through the `KeySessionRecord`'s `isCompatibleWith` method.
+ *
+ * @example
+ * ```js
+ * const record = new KeySessionRecord(initData);
+ *
+ * // Create a MediaKeySession linked to that initialization data and fetch the
+ * // license
+ * // ...
+ *
+ * // Once the license has been loaded to the MediaKeySession linked to that
+ - // initialization data, associate the license's key Ids with the latter.
+ * record.associateKeyIds(someKeyIds);
+ *
+ * // Function called when new initialization data is encountered
+ * function onNewInitializationData(newInitializationData) {
+ *   if (record.isCompatibleWith(newInitializationData)) {
+ *     console.log("This initialization data should already be handled, ignored.");
+ *   } else {
+ *     console.log("This initialization data is not handled yet.";
+ *   }
+ * }
+ * ```
+ * @class KeySessionRecord
+ */
+var KeySessionRecord = /** @class */ (function () {
+    /**
+     * Create a new `KeySessionRecord`, linked to its corresponding initialization
+     * data,
+     * @param {Object} initializationData
+     */
+    function KeySessionRecord(initializationData) {
+        this._initializationData = initializationData;
+        this._keyIds = null;
+    }
+    /**
+     * Associate supplementary key ids to this `KeySessionRecord` so it becomes
+     * "compatible" to them.
+     *
+     * After this call, new initialization data linked to subsets of those key
+     * ids will be considered compatible  to this `KeySessionRecord` (calls to
+     * `isCompatibleWith` with the corresponding initialization data will return
+     * `true`).
+     * @param {Array.<Uint8Array>} keyIds
+     */
+    KeySessionRecord.prototype.associateKeyIds = function (keyIds) {
+        if (this._keyIds === null) {
+            this._keyIds = [];
+        }
+        var keyIdsArr = Array.from(keyIds);
+        for (var _i = 0, keyIdsArr_1 = keyIdsArr; _i < keyIdsArr_1.length; _i++) {
+            var keyId = keyIdsArr_1[_i];
+            if (!this.isAssociatedWithKeyId(keyId)) {
+                this._keyIds.push(keyId);
+            }
+        }
+    };
+    /**
+     * @param {Uint8Array} keyId
+     * @returns {boolean}
+     */
+    KeySessionRecord.prototype.isAssociatedWithKeyId = function (keyId) {
+        if (this._keyIds === null) {
+            return false;
+        }
+        for (var _i = 0, _a = this._keyIds; _i < _a.length; _i++) {
+            var storedKeyId = _a[_i];
+            if (areKeyIdsEqual(storedKeyId, keyId)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    /**
+     * @returns {Array.<Uint8Array>}
+     */
+    KeySessionRecord.prototype.getAssociatedKeyIds = function () {
+        if (this._keyIds === null) {
+            return [];
+        }
+        return this._keyIds;
+    };
+    /**
+     * Check if that `KeySessionRecord` is compatible to the initialization data
+     * given.
+     *
+     * If it returns `true`, it means that this `KeySessionRecord` is already
+     * linked to that initialization data's key. As such, if that
+     * `KeySessionRecord` is already associated to an active MediaKeySession for
+     * example, the content linked to that initialization data should already be
+     * handled.
+     *
+     * If it returns `false`, it means that this `KeySessionRecord` has no
+     * relation with the given initialization data.
+     *
+     * @param {Object} initializationData
+     * @returns {boolean}
+     */
+    KeySessionRecord.prototype.isCompatibleWith = function (initializationData) {
+        var keyIds = initializationData.keyIds;
+        if (keyIds !== undefined) {
+            if (this._keyIds !== null && areAllKeyIdsContainedIn(keyIds, this._keyIds)) {
+                return true;
+            }
+            if (this._initializationData.keyIds !== undefined) {
+                return areAllKeyIdsContainedIn(keyIds, this._initializationData.keyIds);
+            }
+        }
+        return this._checkInitializationDataCompatibility(initializationData);
+    };
+    KeySessionRecord.prototype._checkInitializationDataCompatibility = function (initializationData) {
+        if (initializationData.keyIds !== undefined &&
+            this._initializationData.keyIds !== undefined) {
+            return areAllKeyIdsContainedIn(initializationData.keyIds, this._initializationData.keyIds);
+        }
+        if (this._initializationData.type !== initializationData.type) {
+            return false;
+        }
+        return this._initializationData.values
+            .isCompatibleWith(initializationData.values);
+    };
+    return KeySessionRecord;
+}());
+export default KeySessionRecord;