rx-player 3.26.3-dev.2022021400 → 3.27.0-dev.20220317

package/dist/_esm5.processed/core/eme/find_key_system.js

@@ -1,253 +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 { catchError, defer as observableDefer, map, of as observableOf, throwError as observableThrow, } from "rxjs";
-import { requestMediaKeySystemAccess, shouldRenewMediaKeys, } from "../../compat";
-import config from "../../config";
-import { EncryptedMediaError } from "../../errors";
-import log from "../../log";
-import arrayIncludes from "../../utils/array_includes";
-import flatMap from "../../utils/flat_map";
-import MediaKeysInfosStore from "./media_keys_infos_store";
-var EME_DEFAULT_WIDEVINE_ROBUSTNESSES = config.EME_DEFAULT_WIDEVINE_ROBUSTNESSES, EME_KEY_SYSTEMS = config.EME_KEY_SYSTEMS;
-/**
- * @param {Array.<Object>} keySystems
- * @param {MediaKeySystemAccess} currentKeySystemAccess
- * @param {Object} currentKeySystemOptions
- * @returns {null|Object}
- */
-function checkCachedMediaKeySystemAccess(keySystems, currentKeySystemAccess, currentKeySystemOptions) {
-    var mksConfiguration = currentKeySystemAccess.getConfiguration();
-    if (shouldRenewMediaKeys() || mksConfiguration == null) {
-        return null;
-    }
-    var firstCompatibleOption = keySystems.filter(function (ks) {
-        // TODO Do it with MediaKeySystemAccess.prototype.keySystem instead
-        if (ks.type !== currentKeySystemOptions.type) {
-            return false;
-        }
-        if ((ks.persistentLicense === true || ks.persistentStateRequired === true) &&
-            mksConfiguration.persistentState !== "required") {
-            return false;
-        }
-        if (ks.distinctiveIdentifierRequired === true &&
-            mksConfiguration.distinctiveIdentifier !== "required") {
-            return false;
-        }
-        return true;
-    })[0];
-    if (firstCompatibleOption != null) {
-        return { keySystemOptions: firstCompatibleOption,
-            keySystemAccess: currentKeySystemAccess };
-    }
-    return null;
-}
-/**
- * Find key system canonical name from key system type.
- * @param {string} ksType - Obtained via inversion
- * @returns {string|undefined} - Either the canonical name, or undefined.
- */
-function findKeySystemCanonicalName(ksType) {
-    for (var _i = 0, _a = Object.keys(EME_KEY_SYSTEMS); _i < _a.length; _i++) {
-        var ksName = _a[_i];
-        if (arrayIncludes(EME_KEY_SYSTEMS[ksName], ksType)) {
-            return ksName;
-        }
-    }
-    return undefined;
-}
-/**
- * Build configuration for the requestMediaKeySystemAccess EME API, based
- * on the current keySystem object.
- * @param {string} [ksName] - Generic name for the key system. e.g. "clearkey",
- * "widevine", "playready". Can be used to make exceptions depending on it.
- * @param {Object} keySystem
- * @returns {Array.<Object>} - Configuration to give to the
- * requestMediaKeySystemAccess API.
- */
-function buildKeySystemConfigurations(ksName, keySystem) {
-    var sessionTypes = ["temporary"];
-    var persistentState = "optional";
-    var distinctiveIdentifier = "optional";
-    if (keySystem.persistentLicense === true) {
-        persistentState = "required";
-        sessionTypes.push("persistent-license");
-    }
-    if (keySystem.persistentStateRequired === true) {
-        persistentState = "required";
-    }
-    if (keySystem.distinctiveIdentifierRequired === true) {
-        distinctiveIdentifier = "required";
-    }
-    // Set robustness, in order of consideration:
-    //   1. the user specified its own robustnesses
-    //   2. a "widevine" key system is used, in that case set the default widevine
-    //      robustnesses as defined in the config
-    //   3. set an undefined robustness
-    var videoRobustnesses = keySystem.videoRobustnesses != null ?
-        keySystem.videoRobustnesses :
-        (ksName === "widevine" ? EME_DEFAULT_WIDEVINE_ROBUSTNESSES :
-            []);
-    var audioRobustnesses = keySystem.audioRobustnesses != null ?
-        keySystem.audioRobustnesses :
-        (ksName === "widevine" ? EME_DEFAULT_WIDEVINE_ROBUSTNESSES :
-            []);
-    if (videoRobustnesses.length === 0) {
-        videoRobustnesses.push(undefined);
-    }
-    if (audioRobustnesses.length === 0) {
-        audioRobustnesses.push(undefined);
-    }
-    // From the W3 EME spec, we have to provide videoCapabilities and
-    // audioCapabilities.
-    // These capabilities must specify a codec (even though you can use a
-    // completely different codec afterward).
-    // It is also strongly recommended to specify the required security
-    // robustness. As we do not want to forbide any security level, we specify
-    // every existing security level from highest to lowest so that the best
-    // security level is selected.
-    // More details here:
-    // https://storage.googleapis.com/wvdocs/Chrome_EME_Changes_and_Best_Practices.pdf
-    // https://www.w3.org/TR/encrypted-media/#get-supported-configuration-and-consent
-    var videoCapabilities = flatMap(audioRobustnesses, function (robustness) {
-        return ["video/mp4;codecs=\"avc1.4d401e\"",
-            "video/mp4;codecs=\"avc1.42e01e\"",
-            "video/webm;codecs=\"vp8\""].map(function (contentType) {
-            return robustness !== undefined ? { contentType: contentType, robustness: robustness } :
-                { contentType: contentType };
-        });
-    });
-    var audioCapabilities = flatMap(audioRobustnesses, function (robustness) {
-        return ["audio/mp4;codecs=\"mp4a.40.2\"",
-            "audio/webm;codecs=opus"].map(function (contentType) {
-            return robustness !== undefined ? { contentType: contentType, robustness: robustness } :
-                { contentType: contentType };
-        });
-    });
-    // TODO Re-test with a set contentType but an undefined robustness on the
-    // STBs on which this problem was found.
-    //
-    // add another with no {audio,video}Capabilities for some legacy browsers.
-    // As of today's spec, this should return NotSupported but the first
-    // candidate configuration should be good, so we should have no downside
-    // doing that.
-    // initDataTypes: ["cenc"],
-    // videoCapabilities: undefined,
-    // audioCapabilities: undefined,
-    // distinctiveIdentifier,
-    // persistentState,
-    // sessionTypes,
-    return [{ initDataTypes: ["cenc"], videoCapabilities: videoCapabilities, audioCapabilities: audioCapabilities, distinctiveIdentifier: distinctiveIdentifier, persistentState: persistentState, sessionTypes: sessionTypes }];
-}
-/**
- * Try to find a compatible key system from the keySystems array given.
- *
- * Returns an Observable which, when subscribed to, will request a
- * MediaKeySystemAccess based on the various keySystems provided. This
- * Observable will:
- *   - emit the MediaKeySystemAccess and the keySystems as an object, when
- *     found. The object is under this form:
- *     {
- *       keySystemAccess {MediaKeySystemAccess}
- *       keySystem {Object}
- *     }
- *   - complete immediately after emitting.
- *   - throw if no  compatible key system has been found.
- *
- * @param {HTMLMediaElement} mediaElement
- * @param {Array.<Object>} keySystems - The keySystems you want to test.
- * @returns {Observable}
- */
-export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs) {
-    return observableDefer(function () {
-        log.info("EME: Searching for compatible MediaKeySystemAccess");
-        var currentState = MediaKeysInfosStore.getState(mediaElement);
-        if (currentState != null) {
-            // Fast way to find a compatible keySystem if the currently loaded
-            // one as exactly the same compatibility options.
-            var cachedKeySystemAccess = checkCachedMediaKeySystemAccess(keySystemsConfigs, currentState.mediaKeySystemAccess, currentState.keySystemOptions);
-            if (cachedKeySystemAccess !== null) {
-                log.info("EME: Found cached compatible keySystem");
-                return observableOf({
-                    type: "reuse-media-key-system-access",
-                    value: { mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
-                        options: cachedKeySystemAccess.keySystemOptions },
-                });
-            }
-        }
-        /**
-         * Array of set keySystems for this content.
-         * Each item of this array is an object containing the following keys:
-         *   - keyName {string}: keySystem canonical name (e.g. "widevine")
-         *   - keyType {string}: keySystem type (e.g. "com.widevine.alpha")
-         *   - keySystem {Object}: the original keySystem object
-         * @type {Array.<Object>}
-         */
-        var keySystemsType = keySystemsConfigs.reduce(function (arr, keySystemOptions) {
-            var managedRDNs = EME_KEY_SYSTEMS[keySystemOptions.type];
-            var ksType;
-            if (managedRDNs != null) {
-                ksType = managedRDNs.map(function (keyType) {
-                    var keyName = keySystemOptions.type;
-                    return { keyName: keyName, keyType: keyType, keySystemOptions: keySystemOptions };
-                });
-            }
-            else {
-                var keyName = findKeySystemCanonicalName(keySystemOptions.type);
-                var keyType = keySystemOptions.type;
-                ksType = [{ keyName: keyName, keyType: keyType, keySystemOptions: keySystemOptions }];
-            }
-            return arr.concat(ksType);
-        }, []);
-        return recursivelyTestKeySystems(0);
-        /**
-         * Test all key system configuration stored in `keySystemsType` one by one
-         * recursively.
-         * Returns an Observable which emit the MediaKeySystemAccess if one was
-         * found compatible with one of the configurations or just throws if none
-         * were found to be compatible.
-         * @param {Number} index - The index in `keySystemsType` to start from.
-         * Should be set to `0` when calling directly.
-         * @returns {Observable}
-         */
-        function recursivelyTestKeySystems(index) {
-            // if we iterated over the whole keySystemsType Array, quit on error
-            if (index >= keySystemsType.length) {
-                var error_1 = new EncryptedMediaError("INCOMPATIBLE_KEYSYSTEMS", "No key system compatible with your " +
-                    "wanted configuration has been found " +
-                    "in the current browser.");
-                return observableThrow(function () { return error_1; });
-            }
-            if (requestMediaKeySystemAccess == null) {
-                var error_2 = Error("requestMediaKeySystemAccess is not " +
-                    "implemented in your browser.");
-                return observableThrow(function () { return error_2; });
-            }
-            var _a = keySystemsType[index], keyName = _a.keyName, keyType = _a.keyType, keySystemOptions = _a.keySystemOptions;
-            var keySystemConfigurations = buildKeySystemConfigurations(keyName, keySystemOptions);
-            log.debug("EME: Request keysystem access ".concat(keyType, ",") +
-                "".concat(index + 1, " of ").concat(keySystemsType.length), keySystemConfigurations);
-            return requestMediaKeySystemAccess(keyType, keySystemConfigurations).pipe(map(function (keySystemAccess) {
-                log.info("EME: Found compatible keysystem", keyType, keySystemConfigurations);
-                return { type: "create-media-key-system-access",
-                    value: { options: keySystemOptions,
-                        mediaKeySystemAccess: keySystemAccess } };
-            }), catchError(function () {
-                log.debug("EME: Rejected access to keysystem", keyType, keySystemConfigurations);
-                return recursivelyTestKeySystems(index + 1);
-            }));
-        }
-    });
-}

package/dist/_esm5.processed/core/eme/get_media_keys.js

@@ -1,85 +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 { catchError, map, mergeMap, of as observableOf, } from "rxjs";
-import { EncryptedMediaError } from "../../errors";
-import log from "../../log";
-import castToObservable from "../../utils/cast_to_observable";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import tryCatch from "../../utils/rx-try_catch";
-import getMediaKeySystemAccess from "./find_key_system";
-import MediaKeysInfosStore from "./media_keys_infos_store";
-import ServerCertificateStore from "./server_certificate_store";
-import LoadedSessionsStore from "./utils/loaded_sessions_store";
-import PersistentSessionsStore from "./utils/persistent_sessions_store";
-/**
- * @throws {EncryptedMediaError}
- * @param {Object} keySystemOptions
- * @returns {Object|null}
- */
-function createPersistentSessionsStorage(keySystemOptions) {
-    if (keySystemOptions.persistentLicense !== true) {
-        return null;
-    }
-    var licenseStorage = keySystemOptions.licenseStorage;
-    if (licenseStorage == null) {
-        throw new EncryptedMediaError("INVALID_KEY_SYSTEM", "No license storage found for persistent license.");
-    }
-    log.debug("EME: Set the given license storage");
-    return new PersistentSessionsStore(licenseStorage);
-}
-/**
- * @param {HTMLMediaElement} mediaElement
- * @param {Array.<Object>} keySystemsConfigs
- * @returns {Observable}
- */
-export default function getMediaKeysInfos(mediaElement, keySystemsConfigs) {
-    return getMediaKeySystemAccess(mediaElement, keySystemsConfigs).pipe(mergeMap(function (evt) {
-        var _a = evt.value, options = _a.options, mediaKeySystemAccess = _a.mediaKeySystemAccess;
-        var currentState = MediaKeysInfosStore.getState(mediaElement);
-        var persistentSessionsStore = createPersistentSessionsStorage(options);
-        if (currentState !== null && evt.type === "reuse-media-key-system-access") {
-            var mediaKeys = currentState.mediaKeys, loadedSessionsStore = currentState.loadedSessionsStore;
-            // We might just rely on the currently attached MediaKeys instance.
-            // First check if server certificate parameters are the same than in the
-            // current MediaKeys instance. If not, re-create MediaKeys from scratch.
-            if (ServerCertificateStore.hasOne(mediaKeys) === false ||
-                (!isNullOrUndefined(options.serverCertificate) &&
-                    ServerCertificateStore.has(mediaKeys, options.serverCertificate))) {
-                return observableOf({ mediaKeys: mediaKeys, mediaKeySystemAccess: mediaKeySystemAccess, stores: { loadedSessionsStore: loadedSessionsStore, persistentSessionsStore: persistentSessionsStore }, options: options });
-            }
-        }
-        return createMediaKeys(mediaKeySystemAccess).pipe(map(function (mediaKeys) {
-            log.info("EME: MediaKeys created with success");
-            var loadedSessionsStore = new LoadedSessionsStore(mediaKeys);
-            return { mediaKeys: mediaKeys, mediaKeySystemAccess: mediaKeySystemAccess, stores: { loadedSessionsStore: loadedSessionsStore, persistentSessionsStore: persistentSessionsStore }, options: options };
-        }));
-    }));
-}
-/**
- * Create `MediaKeys` from the `MediaKeySystemAccess` given.
- * Throws the right formatted error if it fails.
- * @param {MediaKeySystemAccess} mediaKeySystemAccess
- * @returns {Observable.<MediaKeys>}
- */
-function createMediaKeys(mediaKeySystemAccess) {
-    log.info("EME: Calling createMediaKeys on the MediaKeySystemAccess");
-    return tryCatch(function () { return castToObservable(mediaKeySystemAccess.createMediaKeys()); }, undefined).pipe(catchError(function (error) {
-        var message = error instanceof Error ?
-            error.message :
-            "Unknown error when creating MediaKeys.";
-        throw new EncryptedMediaError("CREATE_MEDIA_KEYS_ERROR", message);
-    }));
-}

package/dist/_esm5.processed/core/eme/get_session.js

@@ -1,68 +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 { concat as observableConcat, defer as observableDefer, map, mergeMap, of as observableOf, } from "rxjs";
-import log from "../../log";
-import cleanOldLoadedSessions from "./clean_old_loaded_sessions";
-import createSession from "./create_session";
-import isSessionUsable from "./utils/is_session_usable";
-/**
- * Handle MediaEncryptedEvents sent by a HTMLMediaElement:
- * Either create a MediaKeySession, recuperate a previous MediaKeySession or
- * load a persistent session.
- *
- * Some previously created MediaKeySession can be closed in this process to
- * respect the maximum limit of concurrent MediaKeySession, as defined by the
- * `EME_MAX_SIMULTANEOUS_MEDIA_KEY_SESSIONS` config property.
- *
- * You can refer to the events emitted to know about the current situation.
- * @param {Event} initializationDataInfo
- * @param {Object} handledInitData
- * @param {Object} mediaKeysInfos
- * @returns {Observable}
- */
-export default function getSession(initializationData, stores, wantedSessionType, maxSessionCacheSize) {
-    return observableDefer(function () {
-        /**
-         * Store previously-loaded MediaKeySession with the same initialization data, if one.
-         */
-        var previousLoadedSession = null;
-        var loadedSessionsStore = stores.loadedSessionsStore, persistentSessionsStore = stores.persistentSessionsStore;
-        var entry = loadedSessionsStore.getAndReuse(initializationData);
-        if (entry !== null) {
-            previousLoadedSession = entry.mediaKeySession;
-            if (isSessionUsable(previousLoadedSession)) {
-                log.info("EME: Reuse loaded session", previousLoadedSession.sessionId);
-                return observableOf({ type: "loaded-open-session",
-                    value: { mediaKeySession: previousLoadedSession,
-                        sessionType: entry.sessionType, initializationData: initializationData } });
-            }
-            else if (persistentSessionsStore !== null) {
-                // If the session is not usable anymore, we can also remove it from the
-                // PersistentSessionsStore.
-                // TODO Are we sure this is always what we want?
-                persistentSessionsStore.delete(initializationData);
-            }
-        }
-        return (previousLoadedSession != null ?
-            loadedSessionsStore.closeSession(initializationData) :
-            observableOf(null)).pipe(mergeMap(function () {
-            return observableConcat(cleanOldLoadedSessions(loadedSessionsStore, maxSessionCacheSize), createSession(stores, initializationData, wantedSessionType)
-                .pipe(map(function (evt) { return ({ type: evt.type,
-                value: { mediaKeySession: evt.value.mediaKeySession,
-                    sessionType: evt.value.sessionType, initializationData: initializationData } }); })));
-        }));
-    });
-}

package/dist/_esm5.processed/core/eme/init_media_keys.js

@@ -1,66 +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 { filter, mapTo, mergeMap, of as observableOf, startWith, take, } from "rxjs";
-import log from "../../log";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import createSharedReference from "../../utils/reference";
-import attachMediaKeys, { disableMediaKeys, } from "./attach_media_keys";
-import getDrmSystemId from "./get_drm_system_id";
-import getMediaKeysInfos from "./get_media_keys";
-/**
- * Get media keys infos from key system configs then attach media keys to media element.
- * @param {HTMLMediaElement} mediaElement
- * @param {Array.<Object>} keySystemsConfigs
- * @returns {Observable}
- */
-export default function initMediaKeys(mediaElement, keySystemsConfigs) {
-    return getMediaKeysInfos(mediaElement, keySystemsConfigs)
-        .pipe(mergeMap(function (_a) {
-        var mediaKeys = _a.mediaKeys, mediaKeySystemAccess = _a.mediaKeySystemAccess, stores = _a.stores, options = _a.options;
-        /**
-         * String identifying the key system, allowing the rest of the code to
-         * only advertise the required initialization data for license requests.
-         *
-         * Note that we only set this value if retro-compatibility to older
-         * persistent logic in the RxPlayer is not important, as the optimizations
-         * this property unlocks can break the loading of MediaKeySessions
-         * persisted in older RxPlayer's versions.
-         */
-        var initializationDataSystemId;
-        if (isNullOrUndefined(options.licenseStorage) ||
-            options.licenseStorage.disableRetroCompatibility === true) {
-            initializationDataSystemId = getDrmSystemId(mediaKeySystemAccess.keySystem);
-        }
-        var canAttachMediaKeys = createSharedReference(false);
-        var shouldDisableOldMediaKeys = mediaElement.mediaKeys !== null &&
-            mediaElement.mediaKeys !== undefined &&
-            mediaKeys !== mediaElement.mediaKeys;
-        var disableOldMediaKeys$ = observableOf(null);
-        if (shouldDisableOldMediaKeys) {
-            log.debug("EME: Disabling old MediaKeys");
-            disableOldMediaKeys$ = disableMediaKeys(mediaElement);
-        }
-        return disableOldMediaKeys$.pipe(mergeMap(function () {
-            log.debug("EME: Attaching current MediaKeys");
-            return canAttachMediaKeys.asObservable().pipe(filter(function (canAttach) { return canAttach; }), mergeMap(function () {
-                var stateToAttatch = { loadedSessionsStore: stores.loadedSessionsStore, mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, keySystemOptions: options };
-                return attachMediaKeys(mediaElement, stateToAttatch);
-            }), take(1), mapTo({ type: "attached-media-keys",
-                value: { mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, stores: stores, options: options } }), startWith({ type: "created-media-keys",
-                value: { mediaKeySystemAccess: mediaKeySystemAccess, initializationDataSystemId: initializationDataSystemId, mediaKeys: mediaKeys, stores: stores, options: options, canAttachMediaKeys: canAttachMediaKeys } }));
-        }));
-    }));
-}

package/dist/_esm5.processed/core/eme/session_events_listener.d.ts

@@ -1,41 +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 { Observable } from "rxjs";
-import { ICustomMediaKeySession } from "../../compat";
-import { ICustomError } from "../../errors";
-import { IInitializationDataInfo, IEMEWarningEvent, IKeySystemOption, IKeysUpdateEvent, INoUpdateEvent, ISessionMessageEvent, ISessionUpdatedEvent } from "./types";
-/**
- * Error thrown when the MediaKeySession is blacklisted.
- * Such MediaKeySession should not be re-used but other MediaKeySession for the
- * same content can still be used.
- * @class BlacklistedSessionError
- * @extends Error
- */
-export declare class BlacklistedSessionError extends Error {
-    sessionError: ICustomError;
-    constructor(sessionError: ICustomError);
-}
-/**
- * listen to various events from a MediaKeySession and react accordingly
- * depending on the configuration given.
- * @param {MediaKeySession} session - The MediaKeySession concerned.
- * @param {Object} keySystemOptions - The key system options.
- * @param {String} keySystem - The configuration keySystem used for deciphering
- * @param {Object} initializationData - The initialization data linked to that
- * session.
- * @returns {Observable}
- */
-export default function SessionEventsListener(session: MediaKeySession | ICustomMediaKeySession, keySystemOptions: IKeySystemOption, keySystem: string, initializationData: IInitializationDataInfo): Observable<IEMEWarningEvent | ISessionMessageEvent | INoUpdateEvent | IKeysUpdateEvent | ISessionUpdatedEvent>;

package/dist/_esm5.processed/core/eme/set_server_certificate.js

@@ -1,85 +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 { catchError, defer as observableDefer, EMPTY, ignoreElements, tap, of as observableOf, } from "rxjs";
-import { EncryptedMediaError } from "../../errors";
-import log from "../../log";
-import castToObservable from "../../utils/cast_to_observable";
-import tryCatch from "../../utils/rx-try_catch";
-import ServerCertificateStore from "./server_certificate_store";
-/**
- * Call the setServerCertificate API with the given certificate.
- * Complete observable on success, throw when failed.
- *
- * TODO Handle returned value?
- * From the spec:
- *   - setServerCertificate resolves with true if everything worked
- *   - it resolves with false if the CDM does not support server
- *     certificates.
- *
- * @param {MediaKeys} mediaKeys
- * @param {ArrayBuffer} serverCertificate
- * @returns {Observable}
- */
-function setServerCertificate(mediaKeys, serverCertificate) {
-    return observableDefer(function () {
-        return tryCatch(function () {
-            return castToObservable(mediaKeys.setServerCertificate(serverCertificate));
-        }, undefined).pipe(catchError(function (error) {
-            log.warn("EME: mediaKeys.setServerCertificate returned an error", error);
-            var reason = error instanceof Error ? error.toString() :
-                "`setServerCertificate` error";
-            throw new EncryptedMediaError("LICENSE_SERVER_CERTIFICATE_ERROR", reason);
-        }));
-    });
-}
-/**
- * Call the setCertificate API. If it fails just emit the error as warning
- * and complete.
- * @param {MediaKeys} mediaKeys
- * @param {ArrayBuffer} serverCertificate
- * @returns {Observable}
- */
-export default function trySettingServerCertificate(mediaKeys, serverCertificate) {
-    return observableDefer(function () {
-        if (typeof mediaKeys.setServerCertificate !== "function") {
-            log.warn("EME: Could not set the server certificate." +
-                " mediaKeys.setServerCertificate is not a function");
-            return EMPTY;
-        }
-        if (ServerCertificateStore.hasOne(mediaKeys) === true) {
-            log.info("EME: The MediaKeys already has a server certificate, skipping...");
-            return EMPTY;
-        }
-        log.info("EME: Setting server certificate on the MediaKeys");
-        // Because of browser errors, or a user action that can lead to interrupting
-        // server certificate setting, we might be left in a status where we don't
-        // know if we attached the server certificate or not.
-        // Calling `prepare` allow to invalidate temporarily that status.
-        ServerCertificateStore.prepare(mediaKeys);
-        return setServerCertificate(mediaKeys, serverCertificate).pipe(tap(function () { ServerCertificateStore.set(mediaKeys, serverCertificate); }), 
-        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
-        // first type parameter as `any` instead of the perfectly fine `unknown`,
-        // leading to linter issues, as it forbids the usage of `any`.
-        // This is why we're disabling the eslint rule.
-        /* eslint-disable @typescript-eslint/no-unsafe-argument */
-        ignoreElements(), catchError(function (error) { return observableOf({
-            type: "warning",
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            value: error,
-        }); }));
-    });
-}
-export { trySettingServerCertificate, setServerCertificate, };