rx-player 3.26.2 → 3.27.0-dev.20220317

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

@@ -13,13 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ICustomMediaKeys, ICustomMediaKeySession, ICustomMediaKeySystemAccess } from "../../compat";
+import { ICustomMediaKeySession } from "../../compat";
 import { ICustomError } from "../../errors";
-import { ISharedReference } from "../../utils/reference";
+import Manifest, { Adaptation, Period, Representation } from "../../manifest";
+import InitDataValuesContainer from "./utils/init_data_values_container";
 import LoadedSessionsStore from "./utils/loaded_sessions_store";
 import PersistentSessionsStore from "./utils/persistent_sessions_store";
 /** Information about the encryption initialization data. */
-export interface IInitializationDataInfo {
+export interface IProtectionData {
     /**
      * The initialization data type - or the format of the `data` attribute (e.g.
      * "cenc").
@@ -34,229 +35,47 @@ export interface IInitializationDataInfo {
      * `undefined` when not known (different from an empty array - which would
      * just mean that there's no key id involved).
      */
-    keyIds?: Uint8Array[];
+    keyIds?: Uint8Array[] | undefined;
+    /** The content linked to that segment protection data. */
+    content?: IContent;
     /** Every initialization data for that type. */
-    values: Array<{
-        /**
-         * Hex encoded system id, which identifies the key system.
-         * https://dashif.org/identifiers/content_protection/
-         *
-         * If `undefined`, we don't know the system id for that initialization data.
-         * In that case, the initialization data might even be a concatenation of
-         * the initialization data from multiple system ids.
-         */
-        systemId: string | undefined;
-        /**
-         * The initialization data itself for that type and systemId.
-         * For example, with "cenc" initialization data found in an ISOBMFF file,
-         * this will be the whole PSSH box.
-         */
-        data: Uint8Array;
-    }>;
-}
-/** Event emitted when a minor - recoverable - error happened. */
-export interface IEMEWarningEvent {
-    type: "warning";
-    value: ICustomError;
-}
-/**
- * Event emitted when we receive an "encrypted" event from the browser.
- * This is usually sent when pushing an initialization segment, if it stores
- * encryption information.
- */
-export interface IEncryptedEvent {
-    type: "encrypted-event-received";
-    value: IInitializationDataInfo;
-}
-/**
- * Sent when a MediaKeys has been created (or is already created) for the
- * current content.
- * This is necessary before creating a MediaKeySession which will allow
- * encryption keys to be communicated.
- *
- * It carries a shared reference (`canAttachMediaKeys`) that should be setted to
- * `true` to indicate that RxPlayer's EME logic can start to attach the
- * `MediaKeys` instance to the HTMLMediaElement.
- */
-export interface ICreatedMediaKeysEvent {
-    type: "created-media-keys";
-    value: {
-        /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
-        mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
-        /**
-         * Hex-encoded identifier for the key system used.
-         * A list of available IDs can be found here:
-         * https://dashif.org/identifiers/content_protection/
-         *
-         * This ID can be used to select the encryption initialization data to send
-         * to the EMEManager.
-         *
-         * Note that this is only for optimization purposes (e.g. to not
-         * unnecessarily wait for new encryption initialization data to arrive when
-         * those linked to the right key system is already available) as sending all
-         * available encryption initialization data should also work in all cases.
-         *
-         * Can be `undefined` in two cases:
-         *
-         *   - the current system ID is not known
-         *
-         *   - the current system ID is known, but we don't want to communicate it
-         *     to ensure all encryption initialization data is still sent.
-         *     This is usually done to work-around retro-compatibility issues with
-         *     older persisted decryption session.
-         */
-        initializationDataSystemId: string | undefined;
-        /** The MediaKeys instance. */
-        mediaKeys: MediaKeys | ICustomMediaKeys;
-        /** Stores allowing to cache MediaKeySession instances. */
-        stores: IMediaKeySessionStores;
-        /** key system options considered. */
-        options: IKeySystemOption;
-        /**
-         * Shared reference that should be set to `true` once the `MediaKeys`
-         * instance can be attached to the HTMLMediaElement.
-         */
-        canAttachMediaKeys: ISharedReference<boolean>;
-    };
-}
-/**
- * Sent when the created (or already created) MediaKeys is attached to the
- * current HTMLMediaElement element.
- * On some peculiar devices, we have to wait for that step before the first
- * media segments are to be pushed to avoid issues.
- * Because this event is sent after a MediaKeys is created, you will always have
- * a "created-media-keys" event before an "attached-media-keys" event.
- */
-export interface IAttachedMediaKeysEvent {
-    type: "attached-media-keys";
-    value: {
-        /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
-        mediaKeySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
-        /** The MediaKeys instance. */
-        mediaKeys: MediaKeys | ICustomMediaKeys;
-        stores: IMediaKeySessionStores;
-        options: IKeySystemOption;
-    };
+    values: IInitDataValue[];
 }
-/**
- * Emitted when the initialization data received through an encrypted event or
- * through the EMEManager argument can already be decipherable without going
- * through the usual license-fetching logic.
- * This is usually because the MediaKeySession for this encryption key has
- * already been created.
- */
-export interface IInitDataIgnoredEvent {
-    type: "init-data-ignored";
-    value: {
-        initializationData: IInitializationDataInfo;
-    };
+/** Protection initialization data actually processed by the `ContentDecryptor`. */
+export interface IProcessedProtectionData extends Omit<IProtectionData, "values"> {
+    values: InitDataValuesContainer;
 }
 /**
- * Emitted when a "message" event is sent.
- * Those events generally allows the CDM to ask for data such as the license or
- * a server certificate.
- * As such, we will call the corresponding `getLicense` callback immediately
- * after this event is sent.
- *
- * Depending on the return of the getLicense call, we will then either emit a
- * "warning" event and retry the call (for when it failed but will be retried),
- * throw (when it failed with no retry left and no fallback policy is set), emit
- * a "blacklist-protection-data-event" (for when it failed with no retry left
- * but a fallback policy is set), emit a "session-updated" event (for when the
- * call resolved with some data) or emit a "no-update" event (for when the call
- * resolved with `null`).
- */
-export interface ISessionMessageEvent {
-    type: "session-message";
-    value: {
-        messageType: string;
-        initializationData: IInitializationDataInfo;
-    };
-}
-/**
- * Emitted when a `getLicense` call resolves with null.
- * In that case, we do not call `MediaKeySession.prototype.update` and no
- * `session-updated` event will be sent.
- */
-export interface INoUpdateEvent {
-    type: "no-update";
-    value: {
-        initializationData: IInitializationDataInfo;
-    };
-}
-/**
- * Some key ids have updated their status.
- *
- * We put them in two different list:
- *
- *   - `blacklistedKeyIDs`: Those key ids won't be used for decryption and the
- *     corresponding media it decrypts should not be pushed to the buffer
- *     Note that a blacklisted key id can become whitelisted in the future.
- *
- *   - `whitelistedKeyIds`: Those key ids were found and their corresponding
- *     keys are now being considered for decryption.
- *     Note that a whitelisted key id can become blacklisted in the future.
- *
- * Note that each `IKeysUpdateEvent` is independent of any other.
- *
- * A new `IKeysUpdateEvent` does not completely replace a previously emitted
- * one, as it can for example be linked to a whole other decryption session.
- *
- * However, if a key id is encountered in both an older and a newer
- * `IKeysUpdateEvent`, only the older status should be considered.
+ * Represent the initialization data linked to a key system that can be used to
+ * generate the license request.
  */
-export interface IKeysUpdateEvent {
-    type: "keys-update";
-    value: IKeyUpdateValue;
-}
-/** Information on key ids linked to a MediaKeySession. */
-export interface IKeyUpdateValue {
+export interface IInitDataValue {
     /**
-     * The list of key ids that are blacklisted.
-     * As such, their corresponding keys won't be used by that session, despite
-     * the fact that they were part of the pushed license.
+     * Hex encoded system id, which identifies the key system.
+     * https://dashif.org/identifiers/content_protection/
      *
-     * Reasons for blacklisting a keys depend on options, but mainly involve unmet
-     * output restrictions and CDM internal errors linked to that key id.
+     * If `undefined`, we don't know the system id for that initialization data.
+     * In that case, the initialization data might even be a concatenation of
+     * the initialization data from multiple system ids.
      */
-    blacklistedKeyIDs: Uint8Array[];
-    whitelistedKeyIds: Uint8Array[];
-}
-/**
- * Emitted after the `MediaKeySession.prototype.update` function resolves.
- * This function is called when the `getLicense` callback resolves with a data
- * different than `null`.
- */
-export interface ISessionUpdatedEvent {
-    type: "session-updated";
-    value: {
-        session: MediaKeySession | ICustomMediaKeySession;
-        license: ILicense | null;
-        initializationData: IInitializationDataInfo;
-    };
+    systemId: string | undefined;
+    /**
+     * The initialization data itself for that type and systemId.
+     * For example, with "cenc" initialization data found in an ISOBMFF file,
+     * this will be the whole PSSH box.
+     */
+    data: Uint8Array;
 }
-/**
- * Event Emitted when specific "protection data" cannot be deciphered and is thus
- * blacklisted.
- *
- * The linked value is the initialization data linked to the content that cannot
- * be deciphered.
- */
-export interface IBlacklistProtectionDataEvent {
-    type: "blacklist-protection-data";
-    value: IInitializationDataInfo;
+/** Event emitted when a minor - recoverable - error happened. */
+export interface IEMEWarningEvent {
+    type: "warning";
+    value: ICustomError;
 }
-export declare type IEMEManagerEvent = IEMEWarningEvent | // minor error
-IEncryptedEvent | // browser's "encrypted" event
-ICreatedMediaKeysEvent | IAttachedMediaKeysEvent | IInitDataIgnoredEvent | // initData already handled
-ISessionMessageEvent | // MediaKeySession event
-INoUpdateEvent | // `getLicense` returned `null`
-IKeysUpdateEvent | // Status of keys changed
-ISessionUpdatedEvent | // `update` call resolved
-IBlacklistProtectionDataEvent;
 export declare type ILicense = BufferSource | ArrayBuffer;
-/** Segment protection sent by the RxPlayer to the EMEManager. */
+/** Segment protection sent by the RxPlayer to the `ContentDecryptor`. */
 export interface IContentProtection {
+    /** The content linked to that segment protection data. */
+    content: IContent;
     /**
      * Initialization data type.
      * String describing the format of the initialization data sent through this
@@ -272,7 +91,7 @@ export interface IContentProtection {
      * `undefined` when not known (different from an empty array - which would
      * just mean that there's no key id involved).
      */
-    keyIds?: Uint8Array[];
+    keyIds: Uint8Array[] | undefined;
     /** Every initialization data for that type. */
     values: Array<{
         /**
@@ -288,23 +107,16 @@ export interface IContentProtection {
         data: Uint8Array;
     }>;
 }
-export interface IKeyStatusChangeHandledEvent {
-    type: "key-status-change-handled";
-    value: {
-        session: MediaKeySession | ICustomMediaKeySession;
-        license: ILicense | null;
-    };
-}
-export interface IKeyMessageHandledEvent {
-    type: "key-message-handled";
-    value: {
-        session: MediaKeySession | ICustomMediaKeySession;
-        license: ILicense | null;
-    };
-}
-export interface IKeySystemAccessInfos {
-    keySystemAccess: MediaKeySystemAccess | ICustomMediaKeySystemAccess;
-    keySystemOptions: IKeySystemOption;
+/** Content linked to protection data. */
+export interface IContent {
+    /** Manifest object associated to the protection data. */
+    manifest: Manifest;
+    /** Period object associated to the protection data. */
+    period: Period;
+    /** Adaptation object associated to the protection data. */
+    adaptation: Adaptation;
+    /** Representation object associated to the protection data. */
+    representation: Representation;
 }
 /** Stores helping to create and retrieve MediaKeySessions. */
 export interface IMediaKeySessionStores {
@@ -313,15 +125,40 @@ export interface IMediaKeySessionStores {
     /** Retrieve persistent MediaKeySessions already created. */
     persistentSessionsStore: PersistentSessionsStore | null;
 }
+/** Enum identifying the way a new MediaKeySession has been loaded. */
+export declare const enum MediaKeySessionLoadingType {
+    /**
+     * This MediaKeySession has just been created.
+     * This means that it will necessitate a new license request to be generated
+     * and performed.
+     */
+    Created = "created-session",
+    /**
+     * This MediaKeySession was an already-opened one that is being reused.
+     * Such session had already their license loaded and pushed.
+     */
+    LoadedOpenSession = "loaded-open-session",
+    /**
+     * This MediaKeySession was a persistent MediaKeySession that has been
+     * re-loaded.
+     * Such session are linked to a persistent license which should have already
+     * been fetched.
+     */
+    LoadedPersistentSession = "loaded-persistent-session"
+}
 /**
  * Data stored in a persistent MediaKeySession storage.
  * Has to be versioned to be able to play MediaKeySessions persisted in an old
  * RxPlayer version when in a new one.
  */
-export declare type IPersistentSessionInfo = IPersistentSessionInfoV3 | IPersistentSessionInfoV2 | IPersistentSessionInfoV1 | IPersistentSessionInfoV0;
-/** Wrap initialization data and allow linearization of it into base64. */
-interface IInitDataContainer {
-    /** The initData itself. */
+export declare type IPersistentSessionInfo = IPersistentSessionInfoV4 | IPersistentSessionInfoV3 | IPersistentSessionInfoV2 | IPersistentSessionInfoV1 | IPersistentSessionInfoV0;
+/** Wrap an Uint8Array and allow serialization of it into base64. */
+interface ByteArrayContainer {
+    /**
+     * The wrapped data.
+     * Here named `initData` even when it's not always initialization data for
+     * backward-compatible reasons.
+     */
     initData: Uint8Array;
     /**
      * Convert it to base64.
@@ -333,7 +170,48 @@ interface IInitDataContainer {
 }
 /**
  * Stored information about a single persistent `MediaKeySession`, when created
- * since the v3.24.0 RxPlayer version included.
+ * since the v3.27.0 RxPlayer version included.
+ */
+export interface IPersistentSessionInfoV4 {
+    /** Version for this object. */
+    version: 4;
+    /** The persisted MediaKeySession's `id`. Used to load it at a later time. */
+    sessionId: string;
+    /** Type giving information about the format of the initialization data. */
+    initDataType: string | undefined;
+    /** All key ids linked to that `MediaKeySession`. */
+    keyIds: Array<ByteArrayContainer | string>;
+    /**
+     * Every saved initialization data for that session, used as IDs.
+     * Elements are sorted in systemId alphabetical order (putting the `undefined`
+     * ones last).
+     */
+    values: Array<{
+        /**
+         * Hex encoded system id, which identifies the key system.
+         * https://dashif.org/identifiers/content_protection/
+         *
+         * If `undefined`, we don't know the system id for that initialization data.
+         * In that case, the initialization data might even be a concatenation of
+         * the initialization data from multiple system ids.
+         */
+        systemId: string | undefined;
+        /**
+         * A hash of the initialization data (generated by the `hashBuffer` function,
+         * at the time of v3.20.1 at least). Allows for a faster comparison than just
+         * comparing initialization data multiple times.
+         */
+        hash: number;
+        /**
+         * The initialization data associated to the systemId, wrapped in a
+         * container to allow efficient serialization.
+         */
+        data: ByteArrayContainer | string;
+    }>;
+}
+/**
+ * Stored information about a single persistent `MediaKeySession`, when created
+ * from the v3.24.0 RxPlayer version included to the v3.26.2 included.
  */
 export interface IPersistentSessionInfoV3 {
     /** Version for this object. */
@@ -367,13 +245,13 @@ export interface IPersistentSessionInfoV3 {
          * The initialization data associated to the systemId, wrapped in a
          * container to allow efficient serialization.
          */
-        data: IInitDataContainer;
+        data: ByteArrayContainer | string;
     }>;
 }
 /**
  * Stored information about a single persistent `MediaKeySession`, when created
  * between the RxPlayer versions v3.21.0 and v3.21.1 included.
- * The previous implementation (version 1) was fine enough but did not linearize
+ * The previous implementation (version 1) was fine enough but did not serialize
  * well due to it containing an Uint8Array. This data is now wrapped into a
  * container which will convert it to base64 when linearized through
  * `JSON.stringify`.
@@ -387,7 +265,7 @@ export interface IPersistentSessionInfoV2 {
      * The initialization data associated to the `MediaKeySession`, wrapped in a
      * container to allow efficient linearization.
      */
-    initData: IInitDataContainer;
+    initData: ByteArrayContainer;
     /**
      * A hash of the initialization data (generated by the `hashBuffer` function,
      * at the time of v3.20.1 at least). Allows for a faster comparison than just
@@ -442,7 +320,7 @@ export interface IPersistentSessionInfoV0 {
 /** Persistent MediaKeySession storage interface. */
 export interface IPersistentSessionStorage {
     /** Load persistent MediaKeySessions previously saved through the `save` callback. */
-    load(): IPersistentSessionInfo[];
+    load(): IPersistentSessionInfo[] | undefined | null;
     /**
      * Save new persistent MediaKeySession information.
      * The given argument should be returned by the next `load` call.
@@ -506,7 +384,7 @@ export interface IKeySystemOption {
      * closed when the current playback stops.
      */
     closeSessionsOnStop?: boolean;
-    singleLicensePer?: "content" | "init-data";
+    singleLicensePer?: "content" | "periods" | "init-data";
     /**
      * Maximum number of `MediaKeySession` that should be created on the same
      * MediaKeys.

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import InitDataContainer from "./init_data_container";
+import SerializableBytes from "./serializable_bytes";
 /**
  * Returns `true` if both values are compatible initialization data, which
  * means that one is completely contained in the other.
@@ -26,9 +26,9 @@ import InitDataContainer from "./init_data_container";
 export default function areInitializationValuesCompatible(stored: Array<{
     systemId: string | undefined;
     hash: number;
-    data: Uint8Array | InitDataContainer;
+    data: Uint8Array | SerializableBytes | string;
 }>, newElts: Array<{
     systemId: string | undefined;
     hash: number;
-    data: Uint8Array | InitDataContainer;
+    data: Uint8Array | SerializableBytes | string;
 }>): boolean;

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import areArraysOfNumbersEqual from "../../../utils/are_arrays_of_numbers_equal";
-import InitDataContainer from "./init_data_container";
+import SerializableBytes from "./serializable_bytes";
 /**
  * Returns `true` if both values are compatible initialization data, which
  * means that one is completely contained in the other.
@@ -67,10 +67,10 @@ function _isAInB(a, b) {
             return false;
         }
         var aData = firstAElt.data instanceof Uint8Array ? firstAElt.data :
-            typeof firstAElt.data === "string" ? InitDataContainer.decode(firstAElt.data) :
+            typeof firstAElt.data === "string" ? SerializableBytes.decode(firstAElt.data) :
                 firstAElt.data.initData;
         var bData = bElt.data instanceof Uint8Array ? bElt.data :
-            typeof bElt.data === "string" ? InitDataContainer.decode(bElt.data) :
+            typeof bElt.data === "string" ? SerializableBytes.decode(bElt.data) :
                 bElt.data.initData;
         if (!areArraysOfNumbersEqual(aData, bData)) {
             return false;
@@ -91,10 +91,10 @@ function _isAInB(a, b) {
                     return false;
                 }
                 var aNewData = aElt.data instanceof Uint8Array ? aElt.data :
-                    typeof aElt.data === "string" ? InitDataContainer.decode(aElt.data) :
+                    typeof aElt.data === "string" ? SerializableBytes.decode(aElt.data) :
                         aElt.data.initData;
                 var bNewData = bNewElt.data instanceof Uint8Array ? bNewElt.data :
-                    typeof bNewElt.data === "string" ? InitDataContainer.decode(bNewElt.data) :
+                    typeof bNewElt.data === "string" ? SerializableBytes.decode(bNewElt.data) :
                         bNewElt.data.initData;
                 if (!areArraysOfNumbersEqual(aNewData, bNewData)) {
                     return false;

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

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ICustomMediaKeySession } from "../../compat";
-import { IEMEWarningEvent } from "./types";
+import { ICustomMediaKeySession } from "../../../compat";
+import { IEMEWarningEvent } from "../types";
 export interface IKeyStatusesCheckingOptions {
     /**
      * If explicitely set to `false`, we won't throw on error when a used license

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

@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import getUUIDKidFromKeyStatusKID from "../../compat/eme/get_uuid_kid_from_keystatus_kid";
-import { EncryptedMediaError } from "../../errors";
-import { bytesToHex } from "../../utils/string_parsing";
+/* eslint-disable-next-line max-len */
+import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
+import { EncryptedMediaError } from "../../../errors";
+import { bytesToHex } from "../../../utils/string_parsing";
 var KEY_STATUSES = { EXPIRED: "expired",
     INTERNAL_ERROR: "internal-error",
     OUTPUT_RESTRICTED: "output-restricted" };

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

@@ -13,13 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
-import { ICustomMediaKeySession } from "../../../compat";
+import LoadedSessionsStore from "./loaded_sessions_store";
 /**
- * Close a MediaKeySession with multiple attempts if needed and do not throw if
- * this action throws an error.
- * Emits then complete when done.
- * @param {MediaKeySession} mediaKeySession
+ * 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 safelyCloseMediaKeySession(mediaKeySession: MediaKeySession | ICustomMediaKeySession): Observable<unknown>;
+export default function cleanOldLoadedSessions(loadedSessionsStore: LoadedSessionsStore, limit: number): Promise<void>;

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

@@ -0,0 +1,85 @@
+/**
+ * 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.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import PPromise from "../../../utils/promise";
+/**
+ * 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, limit) {
+    return __awaiter(this, void 0, void 0, function () {
+        var proms, entries, toDelete, i, entry;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (limit < 0 || limit >= loadedSessionsStore.getLength()) {
+                        return [2 /*return*/];
+                    }
+                    proms = [];
+                    entries = loadedSessionsStore.getAll().slice();
+                    toDelete = entries.length - limit;
+                    for (i = 0; i < toDelete; i++) {
+                        entry = entries[i];
+                        proms.push(loadedSessionsStore.closeSession(entry.mediaKeySession));
+                    }
+                    return [4 /*yield*/, PPromise.all(proms)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}

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

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import PersistentSessionsStore from "./utils/persistent_sessions_store";
+import PersistentSessionsStore from "./persistent_sessions_store";
 /**
  * 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