rx-player 3.26.2 → 3.27.0-dev.20220317

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, };

package/dist/_esm5.processed/core/eme/utils/close_session.js

@@ -1,81 +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, mergeMap, of as observableOf, take, tap, timer, race as observableRace, } from "rxjs";
-import { closeSession, } from "../../../compat";
-import { onKeyMessage$, onKeyStatusesChange$ } from "../../../compat/event_listeners";
-import config from "../../../config";
-import log from "../../../log";
-var EME_SESSION_CLOSING_MAX_RETRY = config.EME_SESSION_CLOSING_MAX_RETRY, EME_SESSION_CLOSING_INITIAL_DELAY = config.EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY = config.EME_SESSION_CLOSING_MAX_DELAY;
-/**
- * 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
- * @returns {Observable}
- */
-export default function safelyCloseMediaKeySession(mediaKeySession) {
-    return recursivelyTryToCloseMediaKeySession(0);
-    /**
-     * Perform a new attempt at closing the MediaKeySession.
-     * If this operation fails due to a not-"callable" (an EME term)
-     * MediaKeySession, retry based on either a timer or on MediaKeySession
-     * events, whichever comes first.
-     * Emits then complete when done.
-     * @param {number} retryNb - The attempt number starting at 0.
-     * @returns {Observable}
-     */
-    function recursivelyTryToCloseMediaKeySession(retryNb) {
-        log.debug("EME: Trying to close a MediaKeySession", mediaKeySession.sessionId, retryNb);
-        return closeSession(mediaKeySession).pipe(tap(function () { log.debug("EME: Succeeded to close MediaKeySession"); }), catchError(function (err) {
-            // Unitialized MediaKeySession may not close properly until their
-            // corresponding `generateRequest` or `load` call are handled by the
-            // browser.
-            // In that case the EME specification tells us that the browser is
-            // supposed to reject the `close` call with an InvalidStateError.
-            if (!(err instanceof Error) || err.name !== "InvalidStateError" ||
-                mediaKeySession.sessionId !== "") {
-                return failToCloseSession(err);
-            }
-            // We will retry either:
-            //   - when an event indicates that the MediaKeySession is
-            //     initialized (`callable` is the proper EME term here)
-            //   - after a delay, raising exponentially
-            var nextRetryNb = retryNb + 1;
-            if (nextRetryNb > EME_SESSION_CLOSING_MAX_RETRY) {
-                return failToCloseSession(err);
-            }
-            var delay = Math.min(Math.pow(2, retryNb) * EME_SESSION_CLOSING_INITIAL_DELAY, EME_SESSION_CLOSING_MAX_DELAY);
-            log.warn("EME: attempt to close a mediaKeySession failed, " +
-                "scheduling retry...", delay);
-            return observableRace([timer(delay),
-                onKeyStatusesChange$(mediaKeySession),
-                onKeyMessage$(mediaKeySession)])
-                .pipe(take(1), mergeMap(function () { return recursivelyTryToCloseMediaKeySession(nextRetryNb); }));
-        }));
-    }
-    /**
-     * Log error anouncing that we could not close the MediaKeySession and emits
-     * then complete through Observable.
-     * TODO Emit warning?
-     * @returns {Observable}
-     */
-    function failToCloseSession(err) {
-        log.error("EME: Could not close MediaKeySession: " +
-            (err instanceof Error ? err.toString() :
-                "Unknown error"));
-        return observableOf(null);
-    }
-}

package/dist/_esm5.processed/core/eme/utils/init_data_store.d.ts

@@ -1,115 +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 { IInitializationDataInfo } from "../types";
-/**
- * Store a unique value associated to an initData and initDataType.
- * @class InitDataStore
- */
-export default class InitDataStore<T> {
-    /**
-     * Contains every stored elements alongside the corresponding initialization
-     * data, in storage chronological order (from first stored to last stored).
-     */
-    private _storage;
-    /** Construct a new InitDataStore.  */
-    constructor();
-    /**
-     * Returns all stored value, in the order in which they have been stored.
-     * Note: it is possible to move a value to the end of this array by calling
-     * the `getAndReuse` method.
-     * @returns {Array}
-     */
-    getAll(): T[];
-    /**
-     * Returns the number of stored values.
-     * @returns {number}
-     */
-    getLength(): number;
-    /**
-     * Returns `true` if no initialization data is stored yet in this
-     * InitDataStore.
-     * Returns `false` otherwise.
-     * @returns {boolean}
-     */
-    isEmpty(): boolean;
-    /**
-     * Returns the element associated with the given initData and initDataType.
-     * Returns `undefined` if not found.
-     * @param {Uint8Array} initData
-     * @param {string|undefined} initDataType
-     * @returns {*}
-     */
-    get(initializationData: IInitializationDataInfo): T | undefined;
-    /**
-     * Like `get`, but also move the corresponding value at the end of the store
-     * (as returned by `getAll`) if found.
-     * This can be used for example to tell when a previously-stored value is
-     * re-used to then be able to implement a caching replacement algorithm based
-     * on the least-recently-used values by just evicting the first values
-     * returned by `getAll`.
-     * @param {Uint8Array} initData
-     * @param {string|undefined} initDataType
-     * @returns {*}
-     */
-    getAndReuse(initializationData: IInitializationDataInfo): T | undefined;
-    /**
-     * Add to the store a value linked to the corresponding initData and
-     * initDataType.
-     * If a value was already stored linked to those, replace it.
-     * @param {Object} initializationData
-     * @param {*} payload
-     */
-    store(initializationData: IInitializationDataInfo, payload: T): void;
-    /**
-     * Add to the store a value linked to the corresponding initData and
-     * initDataType.
-     * If a value linked to those was already stored, do nothing and returns
-     * `false`.
-     * If not, add the value and return `true`.
-     *
-     * This can be used as a more performant version of doing both a `get` call -
-     * to see if a value is stored linked to that data - and then if not doing a
-     * store. `storeIfNone` is more performant as it will only perform hashing
-     * and a look-up a single time.
-     * @param {Object} initializationData
-     * @param {*} payload
-     * @returns {boolean}
-     */
-    storeIfNone(initializationData: IInitializationDataInfo, payload: T): boolean;
-    /**
-     * Remove an initDataType and initData combination from this store.
-     * Returns the associated value if it has been found, `undefined` otherwise.
-     * @param {Uint8Array} initData
-     * @param {string|undefined} initDataType
-     * @returns {*}
-     */
-    remove(initializationData: IInitializationDataInfo): T | undefined;
-    /**
-     * Find the index of the corresponding initialization data in `this._storage`.
-     * Returns `-1` if not found.
-     * @param {Object} initializationData
-     * @returns {boolean}
-     */
-    private _findIndex;
-    /**
-     * Format given initializationData's values so they are ready to be stored:
-     *   - sort them by systemId, so they are faster to compare
-     *   - add hash for each initialization data encountered.
-     * @param {Array.<Object>} initialValues
-     * @returns {Array.<Object>}
-     */
-    private _formatValuesForStore;
-}