rx-player 3.26.2 → 3.27.0-dev.20220317

package/src/utils/request/fetch.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import config from "../../config";
 import {
   NetworkErrorTypes,
@@ -61,14 +60,14 @@ export interface IFetchedDataObject {
    * Value of the "Content-Length" header, which should (yet also might not be)
    * the size of the complete data that will be fetched.
    */
-  totalSize? : number;
+  totalSize : number | undefined;
   /**
    * Current available chunk, which might only be a sub-part of the whole
    * data.
    * To retrieve the whole data, all `chunk` received from `fetchRequest` can be
    * concatenated.
    */
-  chunk: ArrayBuffer;
+  chunk : ArrayBuffer;
 }
 
 /** Options for the `fetchRequest` utils function. */
@@ -88,16 +87,15 @@ export interface IFetchOptions {
    */
   cancelSignal : CancellationSignal;
   /** Optional headers for the HTTP GET request perfomed by `fetchRequest`. */
-  headers? : { [ header: string ] : string }|null;
+  headers? : { [ header: string ] : string } | undefined | null;
   /**
    * Optional timeout for the HTTP GET request perfomed by `fetchRequest`.
    * This timeout is just enabled until the HTTP response from the server, even
    * if not all data has been received yet.
    */
-  timeout? : number;
+  timeout? : number | undefined;
 }
 
-const { DEFAULT_REQUEST_TIMEOUT } = config;
 
 type IHeadersConstructor = new() => Headers;
 type IAbortControllerConstructor = new() => AbortController;
@@ -112,7 +110,7 @@ const _AbortController : IAbortControllerConstructor|null =
 
 export default function fetchRequest(
   options : IFetchOptions
-) : PPromise<IFetchedStreamComplete> {
+) : Promise<IFetchedStreamComplete> {
   let headers : Headers | { [key : string ] : string } | undefined;
   if (!isNullOrUndefined(options.headers)) {
     if (isNullOrUndefined(_Headers)) {
@@ -148,7 +146,7 @@ export default function fetchRequest(
   }
 
   const requestTimeout = isNullOrUndefined(options.timeout) ?
-    DEFAULT_REQUEST_TIMEOUT :
+    config.getCurrent().DEFAULT_REQUEST_TIMEOUT :
     options.timeout;
   const timeout = window.setTimeout(() => {
     timeouted = true;
@@ -161,12 +159,16 @@ export default function fetchRequest(
       abortFetch();
     });
 
-  return fetch(options.url,
-               { headers,
-                 method: "GET",
-                 signal: !isNullOrUndefined(abortController) ? abortController.signal :
-                                                               undefined }
-  ).then((response : Response) : PPromise<IFetchedStreamComplete> => {
+  const fetchOpts : RequestInit = { method: "GET" };
+  if (headers !== undefined) {
+    fetchOpts.headers = headers;
+  }
+  fetchOpts.signal = !isNullOrUndefined(abortController) ? abortController.signal :
+                                                           null;
+  return fetch(
+    options.url,
+    fetchOpts
+  ).then((response : Response) : Promise<IFetchedStreamComplete> => {
     if (!isNullOrUndefined(timeout)) {
       clearTimeout(timeout);
     }
@@ -192,7 +194,7 @@ export default function fetchRequest(
 
     return readBufferAndSendEvents();
 
-    async function readBufferAndSendEvents() : PPromise<IFetchedStreamComplete> {
+    async function readBufferAndSendEvents() : Promise<IFetchedStreamComplete> {
       const data = await reader.read();
 
       if (!data.done && !isNullOrUndefined(data.value)) {

package/src/utils/request/xhr.ts

@@ -18,12 +18,12 @@ import config from "../../config";
 import { RequestError } from "../../errors";
 import isNonEmptyString from "../is_non_empty_string";
 import isNullOrUndefined from "../is_null_or_undefined";
+import PPromise from "../promise";
 import {
   CancellationError,
   CancellationSignal,
 } from "../task_canceller";
 
-const { DEFAULT_REQUEST_TIMEOUT } = config;
 
 const DEFAULT_RESPONSE_TYPE : XMLHttpRequestResponseType = "json";
 
@@ -129,6 +129,8 @@ export default function request(
 export default function request<T>(
   options : IRequestOptions< XMLHttpRequestResponseType | null | undefined >
 ) : Promise<IRequestResponse< T, XMLHttpRequestResponseType >> {
+
+  const { DEFAULT_REQUEST_TIMEOUT } = config.getCurrent();
   const requestOptions = {
     url: options.url,
     headers: options.headers,
@@ -138,7 +140,7 @@ export default function request<T>(
                                                   options.timeout,
   };
 
-  return new Promise((resolve, reject) => {
+  return new PPromise((resolve, reject) => {
     const { onProgress, cancelSignal } = options;
     const { url,
             headers,
@@ -279,25 +281,26 @@ export interface IRequestOptions<ResponseType> {
   url : string;
   /** Dictionary of headers you want to set. `null` or `undefined` for no header. */
   headers? : { [ header: string ] : string } |
-             null;
+             null |
+             undefined;
   /** Wanted format for the response */
-  responseType? : ResponseType;
+  responseType? : ResponseType | undefined;
   /**
    * Optional timeout, in milliseconds, after which we will cancel a request.
    * Set to DEFAULT_REQUEST_TIMEOUT by default.
    */
-  timeout? : number;
+  timeout? : number | undefined;
   /**
    * "Cancelation token" used to be able to cancel the request.
    * When this token is "cancelled", the request will be aborted and the Promise
    * returned by `request` will be rejected.
    */
-  cancelSignal? : CancellationSignal;
+  cancelSignal? : CancellationSignal | undefined;
   /**
    * When defined, this callback will be called on each XHR "progress" event
    * with data related to this request's progress.
    */
-  onProgress? : (info : IProgressInfo) => void;
+  onProgress? : ((info : IProgressInfo) => void) | undefined;
 }
 
 /** Data emitted by `request`'s Promise when the request succeeded. */
@@ -330,5 +333,5 @@ export interface IProgressInfo {
   size : number;
   sendingTime : number;
   url : string;
-  totalSize? : number;
+  totalSize? : number | undefined;
 }

package/src/utils/rx-from_cancellable_promise.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import { Observable } from "rxjs";
 import TaskCanceller from "./task_canceller";
 
@@ -41,27 +40,32 @@ import TaskCanceller from "./task_canceller";
  */
 export default function fromCancellablePromise<T>(
   canceller : TaskCanceller,
-  fn : () => PPromise<T>
+  fn : () => Promise<T>
 ) : Observable<T> {
   return new Observable((obs) => {
     let isUnsubscribedFrom = false;
+    let isComplete = false;
     fn().then(
       (i) => {
         if (isUnsubscribedFrom) {
           return;
         }
+        isComplete = true;
         obs.next(i);
         obs.complete();
       },
       (err) => {
+        isComplete = true;
         if (isUnsubscribedFrom) {
           return;
         }
         obs.error(err);
       });
     return () => {
-      isUnsubscribedFrom = true;
-      canceller.cancel();
+      if (!isComplete) {
+        isUnsubscribedFrom = true;
+        canceller.cancel();
+      }
     };
   });
 }

package/src/utils/task_canceller.ts

@@ -153,14 +153,14 @@ export default class TaskCanceller {
    * An optional CancellationError can be given in argument for when this
    * cancellation is actually triggered as a chain reaction from a previous
    * cancellation.
-   * @param {Error} [originError]
+   * @param {Error} [srcError]
    */
-  public cancel(originError? : CancellationError) : void {
+  public cancel(srcError? : CancellationError) : void {
     if (this.isUsed) {
       return ;
     }
     this.isUsed = true;
-    const cancellationError = originError ?? new CancellationError();
+    const cancellationError = srcError ?? new CancellationError();
     this._trigger(cancellationError);
   }
 
@@ -188,7 +188,9 @@ export class CancellationSignal {
    */
   public isCancelled : boolean;
   /**
-   * Error associated to the cancellation.
+   * Error associated to the cancellation, only set if the `CancellationSignal`
+   * has been used (which means that the task has been cancelled).
+   *
    * Can be used to notify to a caller that this task was aborted (for example
    * by rejecting it through the Promise associated to that task).
    *

package/tsconfig.json

@@ -4,8 +4,7 @@
     "allowJs": true,
     "target": "es2017",
     "lib": ["es2017", "dom"],
-    // TODO
-    // "exactOptionalPropertyTypes": true,
+    "exactOptionalPropertyTypes": true,
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": false,
     "noImplicitAny": true,

package/tsconfig.modules.json

@@ -4,8 +4,7 @@
     "declaration": true,
     "target": "es5",
     "lib": ["es2017", "dom"],
-    // TODO
-    // "exactOptionalPropertyTypes": true,
+    "exactOptionalPropertyTypes": true,
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": false,
     "noImplicitAny": true,

package/dist/_esm5.processed/core/abr/get_estimate_from_buffer_levels.d.ts

@@ -1,29 +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.
- */
-export interface IBufferBasedChooserPlaybackObservation {
-    bufferGap: number;
-    currentBitrate?: number;
-    currentScore?: number;
-    speed: number;
-}
-/**
- * From the buffer gap, choose a representation.
- * @param {Object} playbackObservation
- * @param {Array.<Number>} bitrates
- * @param {Array.<Number>} bufferLevels
- * @returns {Object|undefined}
- */
-export default function getEstimateFromBufferLevels(playbackObservation: IBufferBasedChooserPlaybackObservation, bitrates: number[], bufferLevels: number[]): number | undefined;

package/dist/_esm5.processed/core/abr/get_estimate_from_buffer_levels.js

@@ -1,67 +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 log from "../../log";
-import arrayFindIndex from "../../utils/array_find_index";
-/**
- * From the buffer gap, choose a representation.
- * @param {Object} playbackObservation
- * @param {Array.<Number>} bitrates
- * @param {Array.<Number>} bufferLevels
- * @returns {Object|undefined}
- */
-export default function getEstimateFromBufferLevels(playbackObservation, bitrates, bufferLevels) {
-    var bufferGap = playbackObservation.bufferGap, currentBitrate = playbackObservation.currentBitrate, currentScore = playbackObservation.currentScore, speed = playbackObservation.speed;
-    if (currentBitrate == null) {
-        return bitrates[0];
-    }
-    var currentBitrateIndex = arrayFindIndex(bitrates, function (b) { return b === currentBitrate; });
-    if (currentBitrateIndex < 0 || bitrates.length !== bufferLevels.length) {
-        log.error("ABR: Current Bitrate not found in the calculated levels");
-        return bitrates[0];
-    }
-    var scaledScore;
-    if (currentScore != null) {
-        scaledScore = speed === 0 ? currentScore : (currentScore / speed);
-    }
-    if (scaledScore != null && scaledScore > 1) {
-        var currentBufferLevel_1 = bufferLevels[currentBitrateIndex];
-        var nextIndex = (function () {
-            for (var i = currentBitrateIndex + 1; i < bufferLevels.length; i++) {
-                if (bufferLevels[i] > currentBufferLevel_1) {
-                    return i;
-                }
-            }
-        })();
-        if (nextIndex != null) {
-            var nextBufferLevel = bufferLevels[nextIndex];
-            if (bufferGap >= nextBufferLevel) {
-                return bitrates[nextIndex];
-            }
-        }
-    }
-    if (scaledScore == null || scaledScore < 1.15) {
-        var currentBufferLevel = bufferLevels[currentBitrateIndex];
-        if (bufferGap < currentBufferLevel) {
-            for (var i = currentBitrateIndex - 1; i >= 0; i--) {
-                if (bitrates[i] < currentBitrate) {
-                    return bitrates[i];
-                }
-            }
-            return currentBitrate;
-        }
-    }
-    return currentBitrate;
-}

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

@@ -1,57 +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 { defer as observableDefer, mergeMap, tap, of as observableOf, } from "rxjs";
-import { setMediaKeys, } from "../../compat";
-import log from "../../log";
-import MediaKeysInfosStore from "./media_keys_infos_store";
-/**
- * Dispose the media keys on media element.
- * @param {Object} mediaElement
- * @returns {Observable}
- */
-export function disableMediaKeys(mediaElement) {
-    return observableDefer(function () {
-        MediaKeysInfosStore.setState(mediaElement, null);
-        return setMediaKeys(mediaElement, null);
-    });
-}
-/**
- * Attach MediaKeys and its associated state to an HTMLMediaElement.
- *
- * /!\ Mutates heavily MediaKeysInfosStore
- * @param {Object} mediaKeysInfos
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-export default function attachMediaKeys(mediaElement, _a) {
-    var keySystemOptions = _a.keySystemOptions, loadedSessionsStore = _a.loadedSessionsStore, mediaKeySystemAccess = _a.mediaKeySystemAccess, mediaKeys = _a.mediaKeys;
-    return observableDefer(function () {
-        var previousState = MediaKeysInfosStore.getState(mediaElement);
-        var closeAllSessions$ = previousState !== null &&
-            previousState.loadedSessionsStore !== loadedSessionsStore ?
-            previousState.loadedSessionsStore.closeAllSessions() :
-            observableOf(null);
-        return closeAllSessions$.pipe(mergeMap(function () {
-            MediaKeysInfosStore.setState(mediaElement, { keySystemOptions: keySystemOptions, mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, loadedSessionsStore: loadedSessionsStore });
-            if (mediaElement.mediaKeys === mediaKeys) {
-                return observableOf(null);
-            }
-            log.info("EME: Attaching MediaKeys to the media element");
-            return setMediaKeys(mediaElement, mediaKeys)
-                .pipe(tap(function () { log.info("EME: MediaKeys attached with success"); }));
-        }));
-    });
-}

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

@@ -1,59 +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 { IInitializationDataInfo } from "./types";
-import LoadedSessionsStore from "./utils/loaded_sessions_store";
-/**
- * Event emitted when an old MediaKeySession has been closed to respect the
- * maximum limit of concurrent MediaKeySession active.
- */
-export interface ICleanedOldSessionEvent {
-    type: "cleaned-old-session";
-    value: {
-        /** The MediaKeySession cleaned. */
-        mediaKeySession: MediaKeySession | ICustomMediaKeySession;
-        /** The type of MediaKeySession (e.g. "temporary"). */
-        sessionType: MediaKeySessionType;
-        /** Initialization data assiociated to this MediaKeySession. */
-        initializationData: IInitializationDataInfo;
-    };
-}
-/**
- * Event emitted when we are beginning to close an old MediaKeySession to
- * respect the maximum limit of concurrent MediaKeySession active.
- */
-export interface ICleaningOldSessionEvent {
-    type: "cleaning-old-session";
-    value: {
-        /** The MediaKeySession that we are currently cleaning. */
-        mediaKeySession: MediaKeySession | ICustomMediaKeySession;
-        /** The type of MediaKeySession (e.g. "temporary"). */
-        sessionType: MediaKeySessionType;
-        /** Initialization data assiociated to this MediaKeySession. */
-        initializationData: IInitializationDataInfo;
-    };
-}
-/**
- * Close sessions from the loadedSessionsStore to allow at maximum `limit`
- * stored MediaKeySessions in it.
- *
- * Emit event when a MediaKeySession begin to be closed and another when the
- * MediaKeySession is closed.
- * @param {Object} loadedSessionsStore
- * @returns {Observable}
- */
-export default function cleanOldLoadedSessions(loadedSessionsStore: LoadedSessionsStore, limit: number): Observable<ICleaningOldSessionEvent | ICleanedOldSessionEvent>;

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

@@ -1,50 +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 { defer as observableDefer, EMPTY, ignoreElements, } from "rxjs";
-import { shouldUnsetMediaKeys } from "../../compat/";
-import log from "../../log";
-import disposeMediaKeys from "./dispose_media_keys";
-import MediaKeysInfosStore from "./media_keys_infos_store";
-/**
- * Clear EME ressources that should be cleared when the current content stops
- * its playback.
- * @param {HTMLMediaElement} mediaElement
- * @returns {Observable}
- */
-export default function clearEMESession(mediaElement) {
-    return observableDefer(function () {
-        log.info("EME: Clearing-up EME session.");
-        if (shouldUnsetMediaKeys()) {
-            log.info("EME: disposing current MediaKeys.");
-            return disposeMediaKeys(mediaElement)
-                .pipe(ignoreElements());
-        }
-        var currentState = MediaKeysInfosStore.getState(mediaElement);
-        if (currentState !== null &&
-            currentState.keySystemOptions.closeSessionsOnStop === true) {
-            log.info("EME: closing all current sessions.");
-            return currentState.loadedSessionsStore.closeAllSessions()
-                // 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-next-line @typescript-eslint/no-unsafe-argument */
-                .pipe(ignoreElements());
-        }
-        log.info("EME: Nothing to clear. Returning right away. No state =", currentState === null);
-        return EMPTY;
-    });
-}

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

@@ -1,126 +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, mergeMap, of as observableOf, } from "rxjs";
-import { loadSession, } from "../../compat";
-import log from "../../log";
-import isSessionUsable from "./utils/is_session_usable";
-/**
- * Create a new Session on the given MediaKeys, corresponding to the given
- * initializationData.
- * If session creating fails, remove the oldest MediaKeySession loaded and
- * retry.
- *
- * /!\ This only creates new sessions.
- * It will fail if loadedSessionsStore already has a MediaKeySession with
- * the given initializationData.
- * @param {Uint8Array} initData
- * @param {string|undefined} initDataType
- * @param {Object} mediaKeysInfos
- * @returns {Observable}
- */
-export default function createSession(stores, initializationData, wantedSessionType) {
-    return observableDefer(function () {
-        var loadedSessionsStore = stores.loadedSessionsStore, persistentSessionsStore = stores.persistentSessionsStore;
-        if (wantedSessionType === "temporary") {
-            return createTemporarySession(loadedSessionsStore, initializationData);
-        }
-        else if (persistentSessionsStore === null) {
-            log.warn("EME: Cannot create persistent MediaKeySession, " +
-                "PersistentSessionsStore not created.");
-            return createTemporarySession(loadedSessionsStore, initializationData);
-        }
-        return createAndTryToRetrievePersistentSession(loadedSessionsStore, persistentSessionsStore, initializationData);
-    });
-}
-/**
- * Create a new temporary MediaKeySession linked to the given initData and
- * initDataType.
- * @param {Object} loadedSessionsStore
- * @param {Object} initData
- * @returns {Observable}
- */
-function createTemporarySession(loadedSessionsStore, initData) {
-    return observableDefer(function () {
-        log.info("EME: Creating a new temporary session");
-        var session = loadedSessionsStore.createSession(initData, "temporary");
-        return observableOf({ type: "created-session",
-            value: { mediaKeySession: session,
-                sessionType: "temporary" } });
-    });
-}
-/**
- * Create a persistent MediaKeySession and try to load on it a previous
- * MediaKeySession linked to the same initData and initDataType.
- * @param {Object} loadedSessionsStore
- * @param {Object} persistentSessionsStore
- * @param {Object} initData
- * @returns {Observable}
- */
-function createAndTryToRetrievePersistentSession(loadedSessionsStore, persistentSessionsStore, initData) {
-    return observableDefer(function () {
-        log.info("EME: Creating persistent MediaKeySession");
-        var session = loadedSessionsStore
-            .createSession(initData, "persistent-license");
-        var storedEntry = persistentSessionsStore.getAndReuse(initData);
-        if (storedEntry === null) {
-            return observableOf({ type: "created-session",
-                value: { mediaKeySession: session,
-                    sessionType: "persistent-license" } });
-        }
-        /**
-         * Helper function to close and restart the current persistent session
-         * considered, and re-create it from scratch.
-         * @returns {Observable}
-         */
-        var recreatePersistentSession = function () {
-            log.info("EME: Removing previous persistent session.");
-            if (persistentSessionsStore.get(initData) !== null) {
-                persistentSessionsStore.delete(initData);
-            }
-            return loadedSessionsStore.closeSession(initData)
-                .pipe(map(function () {
-                var newSession = loadedSessionsStore.createSession(initData, "persistent-license");
-                return { type: "created-session",
-                    value: { mediaKeySession: newSession,
-                        sessionType: "persistent-license" } };
-            }));
-        };
-        return loadSession(session, storedEntry.sessionId).pipe(mergeMap(function (hasLoadedSession) {
-            if (!hasLoadedSession) {
-                log.warn("EME: No data stored for the loaded session");
-                persistentSessionsStore.delete(initData);
-                return observableOf({ type: "created-session",
-                    value: { mediaKeySession: session,
-                        sessionType: "persistent-license" } });
-            }
-            if (hasLoadedSession && isSessionUsable(session)) {
-                persistentSessionsStore.add(initData, session);
-                log.info("EME: Succeeded to load persistent session.");
-                return observableOf({ type: "loaded-persistent-session",
-                    value: { mediaKeySession: session,
-                        sessionType: "persistent-license" } });
-            }
-            // Unusable persistent session: recreate a new session from scratch.
-            log.warn("EME: Previous persistent session not usable anymore.");
-            return recreatePersistentSession();
-        }), catchError(function (err) {
-            log.warn("EME: Unable to load persistent session: " +
-                (err instanceof Error ? err.toString() :
-                    "Unknown Error"));
-            return recreatePersistentSession();
-        }));
-    });
-}

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

@@ -1,23 +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 noop from "../../utils/noop";
-import disposeMediaKeys from "./dispose_media_keys";
-/**
- * Free up all ressources taken by the EME management.
- */
-export default function disposeEME(mediaElement) {
-    disposeMediaKeys(mediaElement).subscribe(noop);
-}