rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/_esm5.processed/compat/eme/custom_media_keys/webkit_media_keys_constructor.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,20 +14,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNode from "../../is_node";
-var WebKitMediaKeysConstructor;
-if (!isNode) {
-    /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    var WebKitMediaKeys = window.WebKitMediaKeys;
-    if (WebKitMediaKeys !== undefined &&
-        typeof WebKitMediaKeys.isTypeSupported === "function" &&
-        typeof WebKitMediaKeys.prototype.createSession === "function" &&
-        typeof HTMLMediaElement.prototype
-            .webkitSetMediaKeys === "function") {
-        WebKitMediaKeysConstructor = WebKitMediaKeys;
-    }
-    /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebKitMediaKeysConstructor = void 0;
+const global_scope_1 = require("../../global_scope");
+let WebKitMediaKeysConstructor;
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const { WebKitMediaKeys } = global_scope_1.default;
+if (WebKitMediaKeys !== undefined &&
+    typeof WebKitMediaKeys.isTypeSupported === "function" &&
+    typeof WebKitMediaKeys.prototype.createSession === "function" &&
+    typeof HTMLMediaElement.prototype
+        .webkitSetMediaKeys === "function") {
+    exports.WebKitMediaKeysConstructor = WebKitMediaKeysConstructor = WebKitMediaKeys;
 }
-export { WebKitMediaKeysConstructor, };

package/dist/_esm5.processed/compat/eme/eme-api-implementation.d.ts

@@ -0,0 +1,78 @@
+import { CancellationSignal } from "../../utils/task_canceller";
+import { IEventTargetLike } from "../event_listeners";
+import CustomMediaKeySystemAccess from "./custom_key_system_access";
+import { ICustomMediaKeys } from "./custom_media_keys/types";
+/**
+ * Automatically detect and set which EME implementation should be used in the
+ * current platform.
+ *
+ * You can call `getEmeApiImplementation` for a different implementation.
+ */
+declare const defaultEmeImplementation: IEmeApiImplementation;
+export default defaultEmeImplementation;
+/**
+ * Generic interface harmonizing the structure of the different EME API
+ * implementations the RxPlayer could use.
+ */
+export interface IEmeApiImplementation {
+    /**
+     * API implementing the `navigator.requestMediaKeySystemAccess` static method
+     * from EME.
+     * @param {string} keyType - Key system name, as a reverse domain name.
+     * @param {Array.<MediaKeySystemMediaCapability>} Wanted configurations, from
+     * the most wanted to the least.
+     * @returns {Promise}
+     */
+    requestMediaKeySystemAccess: (keyType: string, config: MediaKeySystemConfiguration[]) => Promise<MediaKeySystemAccess | CustomMediaKeySystemAccess>;
+    /**
+     * API allowing to listen for `"encrypted"` events, presumably sent by the
+     * HTMLMediaElement on which encrypted content is pushed.
+     * @param {EventTarget} The element on which the event will be listened to.
+     * Generally it is the HTMLMediaElement.
+     * @param {Function} listener - The event listener on which that event's
+     * payload will be dispatched.
+     * @param {Object} cancelSignal - The event listener will be removed once that
+     * `CancellationSignal` emits.
+     */
+    onEncrypted: (target: IEventTargetLike, listener: (evt: unknown) => void, cancelSignal: CancellationSignal) => void;
+    /**
+     * API allowing to attach a `MediaKeys` instance (or an `ICustomMediaKeys`) to
+     * the HTMLMediaElement so it can start decoding.
+     * @param {HTMLMediaElement} The HTMLMediaElement on which the content plays.
+     * @param {MediaKeys} mediaKeys - The MediaKeys instance to attach.
+     * @returns {Promise} - That promise resolves if the `MediaKeys` instance was
+     * attached to the `HTMLMediaElement` with success, or rejects on the opposite
+     * scenario.
+     */
+    setMediaKeys: (mediaElement: HTMLMediaElement, mediaKeys: MediaKeys | ICustomMediaKeys | null) => Promise<unknown>;
+    /**
+     * String describing the currently used EME implementation:
+     *
+     *   - "standard": regular EME implementation
+     *
+     *   - "webkit": The webkit-prefixed variant of the EME API
+     *
+     *   - "older-webkit": An even older webkit-prefixed variant of the EME API
+     *
+     *   - "ms": The ms-prefixed variant of the EME API
+     *
+     *   - "moz": The moz-prefixed variant of the EME API
+     *
+     *   - "unknown": An unidentified variant of the EME API
+     */
+    implementation: "standard" | "webkit" | "older-webkit" | "ms" | "moz" | "unknown";
+}
+/**
+ * Union of all the different value the preferred EME API type can be set to:
+ *
+ *   - "auto": The implementation will be chosen automatically based on what
+ *     we've most confidence on on the current device.
+ *
+ *   - "standard": If present, the standard EME API will be given precedence
+ *     over custom and browser-specific ones.
+ *
+ *   - "webkit": The webkit-prefixed variant of the EME API will be given
+ *     precedence over any other one if present.
+ *
+ */
+export type IPreferredEmeApiType = "auto" | "standard" | "webkit";

package/dist/_esm5.processed/compat/eme/eme-api-implementation.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../errors");
+const assert_1 = require("../../utils/assert");
+const is_null_or_undefined_1 = require("../../utils/is_null_or_undefined");
+const browser_detection_1 = require("../browser_detection");
+const event_listeners_1 = require("../event_listeners");
+const global_scope_1 = require("../global_scope");
+const is_node_1 = require("../is_node");
+const should_favour_custom_safari_EME_1 = require("../should_favour_custom_safari_EME");
+const custom_key_system_access_1 = require("./custom_key_system_access");
+const ie11_media_keys_1 = require("./custom_media_keys/ie11_media_keys");
+const moz_media_keys_constructor_1 = require("./custom_media_keys/moz_media_keys_constructor");
+const old_webkit_media_keys_1 = require("./custom_media_keys/old_webkit_media_keys");
+const webkit_media_keys_1 = require("./custom_media_keys/webkit_media_keys");
+const webkit_media_keys_constructor_1 = require("./custom_media_keys/webkit_media_keys_constructor");
+/**
+ * Automatically detect and set which EME implementation should be used in the
+ * current platform.
+ *
+ * You can call `getEmeApiImplementation` for a different implementation.
+ */
+const defaultEmeImplementation = getEmeApiImplementation("auto");
+exports.default = defaultEmeImplementation;
+/**
+ * Returns the current EME implementation based on what's present on the device
+ * and the given preference.
+ * @param {string} preferredApiType - EME API preference
+ * (@see IPreferredEmeApiType).
+ * @returns {Object}
+ */
+function getEmeApiImplementation(preferredApiType) {
+    let requestMediaKeySystemAccess;
+    let onEncrypted;
+    let setMediaKeys = defaultSetMediaKeys;
+    let implementation;
+    if ((preferredApiType === "standard" ||
+        (preferredApiType === "auto" && !(0, should_favour_custom_safari_EME_1.default)())) &&
+        (
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        is_node_1.default || !(0, is_null_or_undefined_1.default)(navigator.requestMediaKeySystemAccess))) {
+        requestMediaKeySystemAccess = (...args) => navigator.requestMediaKeySystemAccess(...args);
+        onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["encrypted"]);
+        implementation = "standard";
+    }
+    else {
+        let isTypeSupported;
+        let createCustomMediaKeys;
+        if (preferredApiType === "webkit" && webkit_media_keys_constructor_1.WebKitMediaKeysConstructor !== undefined) {
+            onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["needkey"]);
+            const callbacks = (0, webkit_media_keys_1.default)();
+            isTypeSupported = callbacks.isTypeSupported;
+            createCustomMediaKeys = callbacks.createCustomMediaKeys;
+            setMediaKeys = callbacks.setMediaKeys;
+            implementation = "webkit";
+        }
+        else {
+            // This is for Chrome with unprefixed EME api
+            if ((0, old_webkit_media_keys_1.isOldWebkitMediaElement)(HTMLVideoElement.prototype)) {
+                onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["needkey"]);
+                const callbacks = (0, old_webkit_media_keys_1.default)();
+                isTypeSupported = callbacks.isTypeSupported;
+                createCustomMediaKeys = callbacks.createCustomMediaKeys;
+                setMediaKeys = callbacks.setMediaKeys;
+                implementation = "older-webkit";
+                // This is for WebKit with prefixed EME api
+            }
+            else if (webkit_media_keys_constructor_1.WebKitMediaKeysConstructor !== undefined) {
+                onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["needkey"]);
+                const callbacks = (0, webkit_media_keys_1.default)();
+                isTypeSupported = callbacks.isTypeSupported;
+                createCustomMediaKeys = callbacks.createCustomMediaKeys;
+                setMediaKeys = callbacks.setMediaKeys;
+                implementation = "webkit";
+            }
+            else if (browser_detection_1.isIE11 && ie11_media_keys_1.MSMediaKeysConstructor !== undefined) {
+                onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["encrypted", "needkey"]);
+                const callbacks = (0, ie11_media_keys_1.default)();
+                isTypeSupported = callbacks.isTypeSupported;
+                createCustomMediaKeys = callbacks.createCustomMediaKeys;
+                setMediaKeys = callbacks.setMediaKeys;
+                implementation = "ms";
+            }
+            else if (moz_media_keys_constructor_1.MozMediaKeysConstructor !== undefined) {
+                onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["encrypted", "needkey"]);
+                const callbacks = (0, moz_media_keys_constructor_1.default)();
+                isTypeSupported = callbacks.isTypeSupported;
+                createCustomMediaKeys = callbacks.createCustomMediaKeys;
+                setMediaKeys = callbacks.setMediaKeys;
+                implementation = "moz";
+            }
+            else {
+                onEncrypted = (0, event_listeners_1.createCompatibleEventListener)(["encrypted", "needkey"]);
+                const MK = global_scope_1.default.MediaKeys;
+                const checkForStandardMediaKeys = () => {
+                    if (MK === undefined) {
+                        throw new errors_1.MediaError("MEDIA_KEYS_NOT_SUPPORTED", "No `MediaKeys` implementation found " +
+                            "in the current browser.");
+                    }
+                    if (typeof MK.isTypeSupported === "undefined") {
+                        const message = "This browser seems to be unable to play encrypted " +
+                            "contents currently." +
+                            "Note: Some browsers do not allow decryption " +
+                            "in some situations, like when not using HTTPS.";
+                        throw new Error(message);
+                    }
+                };
+                isTypeSupported = (keyType) => {
+                    checkForStandardMediaKeys();
+                    (0, assert_1.default)(typeof MK.isTypeSupported === "function");
+                    return MK.isTypeSupported(keyType);
+                };
+                createCustomMediaKeys = (keyType) => {
+                    checkForStandardMediaKeys();
+                    return new MK(keyType);
+                };
+                implementation = "unknown";
+            }
+        }
+        requestMediaKeySystemAccess = function (keyType, keySystemConfigurations) {
+            if (!isTypeSupported(keyType)) {
+                return Promise.reject(new Error("Unsupported key type"));
+            }
+            for (let i = 0; i < keySystemConfigurations.length; i++) {
+                const keySystemConfiguration = keySystemConfigurations[i];
+                const { videoCapabilities, audioCapabilities, initDataTypes, distinctiveIdentifier } = keySystemConfiguration;
+                let supported = true;
+                supported = supported &&
+                    (initDataTypes == null ||
+                        initDataTypes.some((idt) => idt === "cenc"));
+                supported = supported && (distinctiveIdentifier !== "required");
+                if (supported) {
+                    const keySystemConfigurationResponse = {
+                        initDataTypes: ["cenc"],
+                        distinctiveIdentifier: "not-allowed",
+                        persistentState: "required",
+                        sessionTypes: ["temporary", "persistent-license"],
+                    };
+                    if (videoCapabilities !== undefined) {
+                        keySystemConfigurationResponse.videoCapabilities = videoCapabilities;
+                    }
+                    if (audioCapabilities !== undefined) {
+                        keySystemConfigurationResponse.audioCapabilities = audioCapabilities;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    const customMediaKeys = createCustomMediaKeys(keyType);
+                    return Promise.resolve(new custom_key_system_access_1.default(keyType, customMediaKeys, keySystemConfigurationResponse));
+                }
+            }
+            return Promise.reject(new Error("Unsupported configuration"));
+        };
+    }
+    return { requestMediaKeySystemAccess,
+        onEncrypted,
+        setMediaKeys,
+        implementation };
+}
+/**
+ * Set the given MediaKeys on the given HTMLMediaElement.
+ * Emits null when done then complete.
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Object} mediaKeys
+ * @returns {Promise}
+ */
+function defaultSetMediaKeys(mediaElement, mediaKeys) {
+    try {
+        let ret;
+        const elt = mediaElement;
+        /* eslint-disable @typescript-eslint/unbound-method */
+        if (typeof elt.setMediaKeys === "function") {
+            ret = elt.setMediaKeys(mediaKeys);
+        }
+        /* eslint-enable @typescript-eslint/unbound-method */
+        // If we get in the following code, it means that no compat case has been
+        // found and no standard setMediaKeys API exists. This case is particulary
+        // rare. We will try to call each API with native media keys.
+        else if (typeof elt.webkitSetMediaKeys === "function") {
+            ret = elt.webkitSetMediaKeys(mediaKeys);
+        }
+        else if (typeof elt.mozSetMediaKeys === "function") {
+            ret = elt.mozSetMediaKeys(mediaKeys);
+        }
+        else if (typeof elt.msSetMediaKeys === "function" && mediaKeys !== null) {
+            ret = elt.msSetMediaKeys(mediaKeys);
+        }
+        if (typeof ret === "object" &&
+            ret !== null &&
+            typeof ret.then === "function") {
+            return ret;
+        }
+        else {
+            return Promise.resolve(ret);
+        }
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+}

package/dist/_esm5.processed/compat/eme/generate_key_request.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,10 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../log";
-import { getNextBoxOffsets } from "../../parsers/containers/isobmff";
-import { be4toi, concat, } from "../../utils/byte_parsing";
-import { PSSH_TO_INTEGER } from "./constants";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchInitData = void 0;
+const log_1 = require("../../log");
+const isobmff_1 = require("../../parsers/containers/isobmff");
+const byte_parsing_1 = require("../../utils/byte_parsing");
+const constants_1 = require("./constants");
 /**
  * Modify "initialization data" sent to a `generateKeyRequest` EME call to
  * improve the player's browser compatibility:
@@ -43,24 +46,24 @@ import { PSSH_TO_INTEGER } from "./constants";
  * @param {Uint8Array} initData - Initialization data you want to patch
  * @returns {Uint8Array} - Initialization data, patched
  */
-export function patchInitData(initData) {
-    log.info("Compat: Trying to move CENC PSSH from init data at the end of it.");
-    var foundCencV1 = false;
-    var concatenatedCencs = new Uint8Array();
-    var resInitData = new Uint8Array();
-    var offset = 0;
+function patchInitData(initData) {
+    log_1.default.info("Compat: Trying to move CENC PSSH from init data at the end of it.");
+    let foundCencV1 = false;
+    let concatenatedCencs = new Uint8Array();
+    let resInitData = new Uint8Array();
+    let offset = 0;
     while (offset < initData.length) {
         if (initData.length < offset + 8 ||
-            be4toi(initData, offset + 4) !== PSSH_TO_INTEGER) {
-            log.warn("Compat: unrecognized initialization data. Cannot patch it.");
+            (0, byte_parsing_1.be4toi)(initData, offset + 4) !== constants_1.PSSH_TO_INTEGER) {
+            log_1.default.warn("Compat: unrecognized initialization data. Cannot patch it.");
             throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
         }
-        var len = be4toi(new Uint8Array(initData), offset);
+        const len = (0, byte_parsing_1.be4toi)(new Uint8Array(initData), offset);
         if (offset + len > initData.length) {
-            log.warn("Compat: unrecognized initialization data. Cannot patch it.");
+            log_1.default.warn("Compat: unrecognized initialization data. Cannot patch it.");
             throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
         }
-        var currentPSSH = initData.subarray(offset, offset + len);
+        const currentPSSH = initData.subarray(offset, offset + len);
         // yep
         if (initData[offset + 12] === 0x10 &&
             initData[offset + 13] === 0x77 &&
@@ -78,38 +81,39 @@ export function patchInitData(initData) {
             initData[offset + 25] === 0xE2 &&
             initData[offset + 26] === 0xFB &&
             initData[offset + 27] === 0x4B) {
-            var cencOffsets = getNextBoxOffsets(currentPSSH);
-            var version = cencOffsets === null ? undefined :
+            const cencOffsets = (0, isobmff_1.getNextBoxOffsets)(currentPSSH);
+            const version = cencOffsets === null ? undefined :
                 currentPSSH[cencOffsets[1]];
-            log.info("Compat: CENC PSSH found with version", version);
+            log_1.default.info("Compat: CENC PSSH found with version", version);
             if (version === undefined) {
-                log.warn("Compat: could not read version of CENC PSSH");
+                log_1.default.warn("Compat: could not read version of CENC PSSH");
             }
             else if (foundCencV1 === (version === 1)) {
                 // Either `concatenatedCencs` only contains v1 or does not contain any
-                concatenatedCencs = concat(concatenatedCencs, currentPSSH);
+                concatenatedCencs = (0, byte_parsing_1.concat)(concatenatedCencs, currentPSSH);
             }
             else if (version === 1) {
-                log.warn("Compat: cenc version 1 encountered, " +
+                log_1.default.warn("Compat: cenc version 1 encountered, " +
                     "removing every other cenc pssh box.");
                 concatenatedCencs = currentPSSH;
                 foundCencV1 = true;
             }
             else {
-                log.warn("Compat: filtering out cenc pssh box with wrong version", version);
+                log_1.default.warn("Compat: filtering out cenc pssh box with wrong version", version);
             }
         }
         else {
-            resInitData = concat(resInitData, currentPSSH);
+            resInitData = (0, byte_parsing_1.concat)(resInitData, currentPSSH);
         }
         offset += len;
     }
     if (offset !== initData.length) {
-        log.warn("Compat: unrecognized initialization data. Cannot patch it.");
+        log_1.default.warn("Compat: unrecognized initialization data. Cannot patch it.");
         throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
     }
-    return concat(resInitData, concatenatedCencs);
+    return (0, byte_parsing_1.concat)(resInitData, concatenatedCencs);
 }
+exports.patchInitData = patchInitData;
 /**
  * Generate a request from session.
  * @param {MediaKeySession} session - MediaKeySession on which the request will
@@ -120,18 +124,18 @@ export function patchInitData(initData) {
  * the "encrypted" event for the corresponding request.
  * @returns {Promise} - Emit when done. Errors if fails.
  */
-export default function generateKeyRequest(session, initializationDataType, initializationData) {
-    log.debug("Compat: Calling generateRequest on the MediaKeySession");
-    var patchedInit;
+function generateKeyRequest(session, initializationDataType, initializationData) {
+    log_1.default.debug("Compat: Calling generateRequest on the MediaKeySession");
+    let patchedInit;
     try {
         patchedInit = patchInitData(initializationData);
     }
     catch (_e) {
         patchedInit = initializationData;
     }
-    var initDataType = initializationDataType !== null && initializationDataType !== void 0 ? initializationDataType : "";
+    const initDataType = initializationDataType !== null && initializationDataType !== void 0 ? initializationDataType : "";
     return session.generateRequest(initDataType, patchedInit)
-        .catch(function (error) {
+        .catch((error) => {
         if (initDataType !== "" || !(error instanceof TypeError)) {
             throw error;
         }
@@ -140,8 +144,9 @@ export default function generateKeyRequest(session, initializationDataType, init
         // a rejected promise with a TypeError in that case).
         // Retry with a default "cenc" value for initialization data type if
         // we're in that condition.
-        log.warn("Compat: error while calling `generateRequest` with an empty " +
+        log_1.default.warn("Compat: error while calling `generateRequest` with an empty " +
             "initialization data type. Retrying with a default \"cenc\" value.", error);
         return session.generateRequest("cenc", patchedInit);
     });
 }
+exports.default = generateKeyRequest;

package/dist/_esm5.processed/compat/eme/get_init_data.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,11 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../log";
-import { getPsshSystemID } from "../../parsers/containers/isobmff";
-import areArraysOfNumbersEqual from "../../utils/are_arrays_of_numbers_equal";
-import { be4toi } from "../../utils/byte_parsing";
-import { PSSH_TO_INTEGER } from "./constants";
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../log");
+const isobmff_1 = require("../../parsers/containers/isobmff");
+const are_arrays_of_numbers_equal_1 = require("../../utils/are_arrays_of_numbers_equal");
+const byte_parsing_1 = require("../../utils/byte_parsing");
+const constants_1 = require("./constants");
 /**
  * Take in input initialization data from an encrypted event and generate the
  * corresponding array of initialization data values from it.
@@ -30,31 +32,31 @@ import { PSSH_TO_INTEGER } from "./constants";
  * @returns {Array.<Object>}
  */
 function getInitializationDataValues(initData) {
-    var result = [];
-    var offset = 0;
+    const result = [];
+    let offset = 0;
     while (offset < initData.length) {
         if (initData.length < offset + 8 ||
-            be4toi(initData, offset + 4) !== PSSH_TO_INTEGER) {
-            log.warn("Compat: Unrecognized initialization data. Use as is.");
+            (0, byte_parsing_1.be4toi)(initData, offset + 4) !== constants_1.PSSH_TO_INTEGER) {
+            log_1.default.warn("Compat: Unrecognized initialization data. Use as is.");
             return [{ systemId: undefined,
                     data: initData }];
         }
-        var len = be4toi(new Uint8Array(initData), offset);
+        const len = (0, byte_parsing_1.be4toi)(new Uint8Array(initData), offset);
         if (offset + len > initData.length) {
-            log.warn("Compat: Unrecognized initialization data. Use as is.");
+            log_1.default.warn("Compat: Unrecognized initialization data. Use as is.");
             return [{ systemId: undefined,
                     data: initData }];
         }
-        var currentPSSH = initData.subarray(offset, offset + len);
-        var systemId = getPsshSystemID(currentPSSH, 8);
-        var currentItem = { systemId: systemId, data: currentPSSH };
+        const currentPSSH = initData.subarray(offset, offset + len);
+        const systemId = (0, isobmff_1.getPsshSystemID)(currentPSSH, 8);
+        const currentItem = { systemId, data: currentPSSH };
         if (isPSSHAlreadyEncountered(result, currentItem)) {
             // As we observed on some browsers (IE and Edge), the initialization data on
             // some segments have sometimes duplicated PSSH when sent through an encrypted
             // event (but not when the corresponding segment has been pushed to the
             // SourceBuffer).
             // We prefer filtering them out, to avoid further issues.
-            log.warn("Compat: Duplicated PSSH found in initialization data, removing it.");
+            log_1.default.warn("Compat: Duplicated PSSH found in initialization data, removing it.");
         }
         else {
             result.push(currentItem);
@@ -62,7 +64,7 @@ function getInitializationDataValues(initData) {
         offset += len;
     }
     if (offset !== initData.length) {
-        log.warn("Compat: Unrecognized initialization data. Use as is.");
+        log_1.default.warn("Compat: Unrecognized initialization data. Use as is.");
         return [{ systemId: undefined,
                 data: initData }];
     }
@@ -77,12 +79,12 @@ function getInitializationDataValues(initData) {
  * @returns {boolean}
  */
 function isPSSHAlreadyEncountered(encounteredPSSHs, pssh) {
-    for (var i = 0; i < encounteredPSSHs.length; i++) {
-        var item = encounteredPSSHs[i];
+    for (let i = 0; i < encounteredPSSHs.length; i++) {
+        const item = encounteredPSSHs[i];
         if (pssh.systemId === undefined ||
             item.systemId === undefined ||
             pssh.systemId === item.systemId) {
-            if (areArraysOfNumbersEqual(pssh.data, item.data)) {
+            if ((0, are_arrays_of_numbers_equal_1.default)(pssh.data, item.data)) {
                 return true;
             }
         }
@@ -100,13 +102,14 @@ function isPSSHAlreadyEncountered(encounteredPSSHs, pssh) {
  * @throws {EncryptedMediaError} - Throws if no initialization data is
  * encountered in the given event.
  */
-export default function getInitData(encryptedEvent) {
-    var initData = encryptedEvent.initData, initDataType = encryptedEvent.initDataType;
+function getInitData(encryptedEvent) {
+    const { initData, initDataType } = encryptedEvent;
     if (initData == null) {
-        log.warn("Compat: No init data found on media encrypted event.");
+        log_1.default.warn("Compat: No init data found on media encrypted event.");
         return null;
     }
-    var initDataBytes = new Uint8Array(initData);
-    var values = getInitializationDataValues(initDataBytes);
-    return { type: initDataType, values: values };
+    const initDataBytes = new Uint8Array(initData);
+    const values = getInitializationDataValues(initDataBytes);
+    return { type: initDataType, values };
 }
+exports.default = getInitData;

package/dist/_esm5.processed/compat/eme/get_uuid_kid_from_keystatus_kid.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,8 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { guidToUuid } from "../../utils/string_parsing";
-import { isEdgeChromium, isIEOrEdge, } from "../browser_detection";
+Object.defineProperty(exports, "__esModule", { value: true });
+const string_parsing_1 = require("../../utils/string_parsing");
+const browser_detection_1 = require("../browser_detection");
 /**
  * Get KID from MediaKeySession keyStatus, and convert it in usual big-endian kid
  * if necessary. On EDGE, Microsoft Playready KID are presented into little-endian GUID.
@@ -22,10 +24,11 @@ import { isEdgeChromium, isIEOrEdge, } from "../browser_detection";
  * @param {Uint8Array} baseKeyId
  * @returns {Uint8Array}
  */
-export default function getUUIDKIDFromKeyStatusKID(keySystem, baseKeyId) {
+function getUUIDKIDFromKeyStatusKID(keySystem, baseKeyId) {
     if (keySystem.indexOf("playready") !== -1 &&
-        (isIEOrEdge || isEdgeChromium)) {
-        return guidToUuid(baseKeyId);
+        (browser_detection_1.isIEOrEdge || browser_detection_1.isEdgeChromium)) {
+        return (0, string_parsing_1.guidToUuid)(baseKeyId);
     }
     return baseKeyId;
 }
+exports.default = getUUIDKIDFromKeyStatusKID;