rx-player 4.0.0-dev.2023102700 → 4.0.0-dev.2023110700

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,17 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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;
+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 */
 }
+export { WebKitMediaKeysConstructor, };

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

@@ -1,27 +1,24 @@
-"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");
+import { MediaError } from "../../errors";
+import assert from "../../utils/assert";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import { isIE11 } from "../browser_detection";
+import { createCompatibleEventListener } from "../event_listeners";
+import isNode from "../is_node";
+import shouldFavourCustomSafariEME from "../should_favour_custom_safari_EME";
+import CustomMediaKeySystemAccess from "./custom_key_system_access";
+import getIE11MediaKeysCallbacks, { MSMediaKeysConstructor, } from "./custom_media_keys/ie11_media_keys";
+import getMozMediaKeysCallbacks, { MozMediaKeysConstructor, } from "./custom_media_keys/moz_media_keys_constructor";
+import getOldKitWebKitMediaKeyCallbacks, { isOldWebkitMediaElement, } from "./custom_media_keys/old_webkit_media_keys";
+import getWebKitMediaKeysCallbacks from "./custom_media_keys/webkit_media_keys";
+import { WebKitMediaKeysConstructor, } from "./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;
+var defaultEmeImplementation = getEmeApiImplementation("auto");
+export default defaultEmeImplementation;
 /**
  * Returns the current EME implementation based on what's present on the device
  * and the given preference.
@@ -30,107 +27,113 @@ exports.default = defaultEmeImplementation;
  * @returns {Object}
  */
 function getEmeApiImplementation(preferredApiType) {
-    let requestMediaKeySystemAccess;
-    let onEncrypted;
-    let setMediaKeys = defaultSetMediaKeys;
-    let implementation;
+    var requestMediaKeySystemAccess;
+    var onEncrypted;
+    var setMediaKeys = defaultSetMediaKeys;
+    var implementation;
     if ((preferredApiType === "standard" ||
-        (preferredApiType === "auto" && !(0, should_favour_custom_safari_EME_1.default)())) &&
+        (preferredApiType === "auto" && !shouldFavourCustomSafariEME())) &&
         (
         // 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"]);
+        isNode || !isNullOrUndefined(navigator.requestMediaKeySystemAccess))) {
+        requestMediaKeySystemAccess = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return navigator.requestMediaKeySystemAccess.apply(navigator, args);
+        };
+        onEncrypted = 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;
+        var isTypeSupported_1;
+        var createCustomMediaKeys_1;
+        if (preferredApiType === "webkit" && WebKitMediaKeysConstructor !== undefined) {
+            onEncrypted = createCompatibleEventListener(["needkey"]);
+            var callbacks = getWebKitMediaKeysCallbacks();
+            isTypeSupported_1 = callbacks.isTypeSupported;
+            createCustomMediaKeys_1 = 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;
+            if (isOldWebkitMediaElement(HTMLVideoElement.prototype)) {
+                onEncrypted = createCompatibleEventListener(["needkey"]);
+                var callbacks = getOldKitWebKitMediaKeyCallbacks();
+                isTypeSupported_1 = callbacks.isTypeSupported;
+                createCustomMediaKeys_1 = 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;
+            else if (WebKitMediaKeysConstructor !== undefined) {
+                onEncrypted = createCompatibleEventListener(["needkey"]);
+                var callbacks = getWebKitMediaKeysCallbacks();
+                isTypeSupported_1 = callbacks.isTypeSupported;
+                createCustomMediaKeys_1 = 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;
+            else if (isIE11 && MSMediaKeysConstructor !== undefined) {
+                onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
+                var callbacks = getIE11MediaKeysCallbacks();
+                isTypeSupported_1 = callbacks.isTypeSupported;
+                createCustomMediaKeys_1 = 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;
+            else if (MozMediaKeysConstructor !== undefined) {
+                onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
+                var callbacks = getMozMediaKeysCallbacks();
+                isTypeSupported_1 = callbacks.isTypeSupported;
+                createCustomMediaKeys_1 = 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 " +
+                onEncrypted = createCompatibleEventListener(["encrypted", "needkey"]);
+                var MK_1 = window.MediaKeys;
+                var checkForStandardMediaKeys_1 = function () {
+                    if (MK_1 === undefined) {
+                        throw new 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 " +
+                    if (typeof MK_1.isTypeSupported === "undefined") {
+                        var 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);
+                isTypeSupported_1 = function (keyType) {
+                    checkForStandardMediaKeys_1();
+                    assert(typeof MK_1.isTypeSupported === "function");
+                    return MK_1.isTypeSupported(keyType);
                 };
-                createCustomMediaKeys = (keyType) => {
-                    checkForStandardMediaKeys();
-                    return new MK(keyType);
+                createCustomMediaKeys_1 = function (keyType) {
+                    checkForStandardMediaKeys_1();
+                    return new MK_1(keyType);
                 };
                 implementation = "unknown";
             }
         }
         requestMediaKeySystemAccess = function (keyType, keySystemConfigurations) {
-            if (!isTypeSupported(keyType)) {
+            if (!isTypeSupported_1(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;
+            for (var i = 0; i < keySystemConfigurations.length; i++) {
+                var keySystemConfiguration = keySystemConfigurations[i];
+                var videoCapabilities = keySystemConfiguration.videoCapabilities, audioCapabilities = keySystemConfiguration.audioCapabilities, initDataTypes = keySystemConfiguration.initDataTypes, distinctiveIdentifier = keySystemConfiguration.distinctiveIdentifier;
+                var supported = true;
                 supported = supported &&
                     (initDataTypes == null ||
-                        initDataTypes.some((idt) => idt === "cenc"));
+                        initDataTypes.some(function (idt) { return idt === "cenc"; }));
                 supported = supported && (distinctiveIdentifier !== "required");
                 if (supported) {
-                    const keySystemConfigurationResponse = {
+                    var keySystemConfigurationResponse = {
                         initDataTypes: ["cenc"],
                         distinctiveIdentifier: "not-allowed",
                         persistentState: "required",
@@ -143,17 +146,14 @@ function getEmeApiImplementation(preferredApiType) {
                         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));
+                    var customMediaKeys = createCustomMediaKeys_1(keyType);
+                    return Promise.resolve(new CustomMediaKeySystemAccess(keyType, customMediaKeys, keySystemConfigurationResponse));
                 }
             }
             return Promise.reject(new Error("Unsupported configuration"));
         };
     }
-    return { requestMediaKeySystemAccess,
-        onEncrypted,
-        setMediaKeys,
-        implementation };
+    return { requestMediaKeySystemAccess: requestMediaKeySystemAccess, onEncrypted: onEncrypted, setMediaKeys: setMediaKeys, implementation: implementation };
 }
 /**
  * Set the given MediaKeys on the given HTMLMediaElement.
@@ -164,8 +164,8 @@ function getEmeApiImplementation(preferredApiType) {
  */
 function defaultSetMediaKeys(mediaElement, mediaKeys) {
     try {
-        let ret;
-        const elt = mediaElement;
+        var ret = void 0;
+        var elt = mediaElement;
         /* eslint-disable @typescript-eslint/unbound-method */
         if (typeof elt.setMediaKeys === "function") {
             ret = elt.setMediaKeys(mediaKeys);

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,12 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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");
+import log from "../../log";
+import { getNextBoxOffsets } from "../../parsers/containers/isobmff";
+import { be4toi, concat, } from "../../utils/byte_parsing";
+import { PSSH_TO_INTEGER } from "./constants";
 /**
  * Modify "initialization data" sent to a `generateKeyRequest` EME call to
  * improve the player's browser compatibility:
@@ -46,24 +43,24 @@ const constants_1 = require("./constants");
  * @param {Uint8Array} initData - Initialization data you want to patch
  * @returns {Uint8Array} - Initialization data, patched
  */
-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;
+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;
     while (offset < initData.length) {
         if (initData.length < offset + 8 ||
-            (0, byte_parsing_1.be4toi)(initData, offset + 4) !== constants_1.PSSH_TO_INTEGER) {
-            log_1.default.warn("Compat: unrecognized initialization data. Cannot patch it.");
+            be4toi(initData, offset + 4) !== PSSH_TO_INTEGER) {
+            log.warn("Compat: unrecognized initialization data. Cannot patch it.");
             throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
         }
-        const len = (0, byte_parsing_1.be4toi)(new Uint8Array(initData), offset);
+        var len = be4toi(new Uint8Array(initData), offset);
         if (offset + len > initData.length) {
-            log_1.default.warn("Compat: unrecognized initialization data. Cannot patch it.");
+            log.warn("Compat: unrecognized initialization data. Cannot patch it.");
             throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
         }
-        const currentPSSH = initData.subarray(offset, offset + len);
+        var currentPSSH = initData.subarray(offset, offset + len);
         // yep
         if (initData[offset + 12] === 0x10 &&
             initData[offset + 13] === 0x77 &&
@@ -81,39 +78,38 @@ function patchInitData(initData) {
             initData[offset + 25] === 0xE2 &&
             initData[offset + 26] === 0xFB &&
             initData[offset + 27] === 0x4B) {
-            const cencOffsets = (0, isobmff_1.getNextBoxOffsets)(currentPSSH);
-            const version = cencOffsets === null ? undefined :
+            var cencOffsets = getNextBoxOffsets(currentPSSH);
+            var version = cencOffsets === null ? undefined :
                 currentPSSH[cencOffsets[1]];
-            log_1.default.info("Compat: CENC PSSH found with version", version);
+            log.info("Compat: CENC PSSH found with version", version);
             if (version === undefined) {
-                log_1.default.warn("Compat: could not read version of CENC PSSH");
+                log.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 = (0, byte_parsing_1.concat)(concatenatedCencs, currentPSSH);
+                concatenatedCencs = concat(concatenatedCencs, currentPSSH);
             }
             else if (version === 1) {
-                log_1.default.warn("Compat: cenc version 1 encountered, " +
+                log.warn("Compat: cenc version 1 encountered, " +
                     "removing every other cenc pssh box.");
                 concatenatedCencs = currentPSSH;
                 foundCencV1 = true;
             }
             else {
-                log_1.default.warn("Compat: filtering out cenc pssh box with wrong version", version);
+                log.warn("Compat: filtering out cenc pssh box with wrong version", version);
             }
         }
         else {
-            resInitData = (0, byte_parsing_1.concat)(resInitData, currentPSSH);
+            resInitData = concat(resInitData, currentPSSH);
         }
         offset += len;
     }
     if (offset !== initData.length) {
-        log_1.default.warn("Compat: unrecognized initialization data. Cannot patch it.");
+        log.warn("Compat: unrecognized initialization data. Cannot patch it.");
         throw new Error("Compat: unrecognized initialization data. Cannot patch it.");
     }
-    return (0, byte_parsing_1.concat)(resInitData, concatenatedCencs);
+    return concat(resInitData, concatenatedCencs);
 }
-exports.patchInitData = patchInitData;
 /**
  * Generate a request from session.
  * @param {MediaKeySession} session - MediaKeySession on which the request will
@@ -124,18 +120,18 @@ exports.patchInitData = patchInitData;
  * the "encrypted" event for the corresponding request.
  * @returns {Promise} - Emit when done. Errors if fails.
  */
-function generateKeyRequest(session, initializationDataType, initializationData) {
-    log_1.default.debug("Compat: Calling generateRequest on the MediaKeySession");
-    let patchedInit;
+export default function generateKeyRequest(session, initializationDataType, initializationData) {
+    log.debug("Compat: Calling generateRequest on the MediaKeySession");
+    var patchedInit;
     try {
         patchedInit = patchInitData(initializationData);
     }
     catch (_e) {
         patchedInit = initializationData;
     }
-    const initDataType = initializationDataType !== null && initializationDataType !== void 0 ? initializationDataType : "";
+    var initDataType = initializationDataType !== null && initializationDataType !== void 0 ? initializationDataType : "";
     return session.generateRequest(initDataType, patchedInit)
-        .catch((error) => {
+        .catch(function (error) {
         if (initDataType !== "" || !(error instanceof TypeError)) {
             throw error;
         }
@@ -144,9 +140,8 @@ function generateKeyRequest(session, initializationDataType, initializationData)
         // 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_1.default.warn("Compat: error while calling `generateRequest` with an empty " +
+        log.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,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,12 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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");
+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";
 /**
  * Take in input initialization data from an encrypted event and generate the
  * corresponding array of initialization data values from it.
@@ -32,31 +30,31 @@ const constants_1 = require("./constants");
  * @returns {Array.<Object>}
  */
 function getInitializationDataValues(initData) {
-    const result = [];
-    let offset = 0;
+    var result = [];
+    var offset = 0;
     while (offset < initData.length) {
         if (initData.length < offset + 8 ||
-            (0, byte_parsing_1.be4toi)(initData, offset + 4) !== constants_1.PSSH_TO_INTEGER) {
-            log_1.default.warn("Compat: Unrecognized initialization data. Use as is.");
+            be4toi(initData, offset + 4) !== PSSH_TO_INTEGER) {
+            log.warn("Compat: Unrecognized initialization data. Use as is.");
             return [{ systemId: undefined,
                     data: initData }];
         }
-        const len = (0, byte_parsing_1.be4toi)(new Uint8Array(initData), offset);
+        var len = be4toi(new Uint8Array(initData), offset);
         if (offset + len > initData.length) {
-            log_1.default.warn("Compat: Unrecognized initialization data. Use as is.");
+            log.warn("Compat: Unrecognized initialization data. Use as is.");
             return [{ systemId: undefined,
                     data: initData }];
         }
-        const currentPSSH = initData.subarray(offset, offset + len);
-        const systemId = (0, isobmff_1.getPsshSystemID)(currentPSSH, 8);
-        const currentItem = { systemId, data: currentPSSH };
+        var currentPSSH = initData.subarray(offset, offset + len);
+        var systemId = getPsshSystemID(currentPSSH, 8);
+        var currentItem = { systemId: 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_1.default.warn("Compat: Duplicated PSSH found in initialization data, removing it.");
+            log.warn("Compat: Duplicated PSSH found in initialization data, removing it.");
         }
         else {
             result.push(currentItem);
@@ -64,7 +62,7 @@ function getInitializationDataValues(initData) {
         offset += len;
     }
     if (offset !== initData.length) {
-        log_1.default.warn("Compat: Unrecognized initialization data. Use as is.");
+        log.warn("Compat: Unrecognized initialization data. Use as is.");
         return [{ systemId: undefined,
                 data: initData }];
     }
@@ -79,12 +77,12 @@ function getInitializationDataValues(initData) {
  * @returns {boolean}
  */
 function isPSSHAlreadyEncountered(encounteredPSSHs, pssh) {
-    for (let i = 0; i < encounteredPSSHs.length; i++) {
-        const item = encounteredPSSHs[i];
+    for (var i = 0; i < encounteredPSSHs.length; i++) {
+        var item = encounteredPSSHs[i];
         if (pssh.systemId === undefined ||
             item.systemId === undefined ||
             pssh.systemId === item.systemId) {
-            if ((0, are_arrays_of_numbers_equal_1.default)(pssh.data, item.data)) {
+            if (areArraysOfNumbersEqual(pssh.data, item.data)) {
                 return true;
             }
         }
@@ -102,14 +100,13 @@ function isPSSHAlreadyEncountered(encounteredPSSHs, pssh) {
  * @throws {EncryptedMediaError} - Throws if no initialization data is
  * encountered in the given event.
  */
-function getInitData(encryptedEvent) {
-    const { initData, initDataType } = encryptedEvent;
+export default function getInitData(encryptedEvent) {
+    var initData = encryptedEvent.initData, initDataType = encryptedEvent.initDataType;
     if (initData == null) {
-        log_1.default.warn("Compat: No init data found on media encrypted event.");
+        log.warn("Compat: No init data found on media encrypted event.");
         return null;
     }
-    const initDataBytes = new Uint8Array(initData);
-    const values = getInitializationDataValues(initDataBytes);
-    return { type: initDataType, values };
+    var initDataBytes = new Uint8Array(initData);
+    var values = getInitializationDataValues(initDataBytes);
+    return { type: initDataType, values: values };
 }
-exports.default = getInitData;

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,9 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const string_parsing_1 = require("../../utils/string_parsing");
-const browser_detection_1 = require("../browser_detection");
+import { guidToUuid } from "../../utils/string_parsing";
+import { isEdgeChromium, isIEOrEdge, } from "../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.
@@ -24,11 +22,10 @@ const browser_detection_1 = require("../browser_detection");
  * @param {Uint8Array} baseKeyId
  * @returns {Uint8Array}
  */
-function getUUIDKIDFromKeyStatusKID(keySystem, baseKeyId) {
+export default function getUUIDKIDFromKeyStatusKID(keySystem, baseKeyId) {
     if (keySystem.indexOf("playready") !== -1 &&
-        (browser_detection_1.isIEOrEdge || browser_detection_1.isEdgeChromium)) {
-        return (0, string_parsing_1.guidToUuid)(baseKeyId);
+        (isIEOrEdge || isEdgeChromium)) {
+        return guidToUuid(baseKeyId);
     }
     return baseKeyId;
 }
-exports.default = getUUIDKIDFromKeyStatusKID;

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

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -14,9 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-const byte_parsing_1 = require("../../utils/byte_parsing");
-const string_parsing_1 = require("../../utils/string_parsing");
+import { itole4, le4toi, } from "../../utils/byte_parsing";
+import { strToUtf16LE, utf16LEToStr, } from "../../utils/string_parsing";
 /**
  * Create formatted fairplay initdata for WebKit createSession.
  * Layout is :
@@ -26,35 +24,34 @@ const string_parsing_1 = require("../../utils/string_parsing");
  * @param {Uint8Array} serverCertificate
  * @returns {Uint8Array}
  */
-function getWebKitFairPlayInitData(initDataBytes, serverCertificateBytes) {
-    const initData = initDataBytes instanceof Uint8Array ? initDataBytes :
+export default function getWebKitFairPlayInitData(initDataBytes, serverCertificateBytes) {
+    var initData = initDataBytes instanceof Uint8Array ? initDataBytes :
         new Uint8Array(initDataBytes);
-    const serverCertificate = serverCertificateBytes instanceof Uint8Array ?
+    var serverCertificate = serverCertificateBytes instanceof Uint8Array ?
         serverCertificateBytes :
         new Uint8Array(serverCertificateBytes);
-    const length = (0, byte_parsing_1.le4toi)(initData, 0);
+    var length = le4toi(initData, 0);
     if (length + 4 !== initData.length) {
         throw new Error("Unsupported WebKit initData.");
     }
-    const initDataUri = (0, string_parsing_1.utf16LEToStr)(initData);
-    const skdIndexInInitData = initDataUri.indexOf("skd://");
-    const contentIdStr = skdIndexInInitData > -1 ?
+    var initDataUri = utf16LEToStr(initData);
+    var skdIndexInInitData = initDataUri.indexOf("skd://");
+    var contentIdStr = skdIndexInInitData > -1 ?
         initDataUri.substring(skdIndexInInitData + 6) :
         initDataUri;
-    const id = (0, string_parsing_1.strToUtf16LE)(contentIdStr);
-    let offset = 0;
-    const res = new Uint8Array(initData.byteLength
+    var id = strToUtf16LE(contentIdStr);
+    var offset = 0;
+    var res = new Uint8Array(initData.byteLength
         /* id length */ + 4 + id.byteLength
         /* certificate length */ + 4 + serverCertificate.byteLength);
     res.set(initData);
     offset += initData.length;
-    res.set((0, byte_parsing_1.itole4)(id.byteLength), offset);
+    res.set(itole4(id.byteLength), offset);
     offset += 4;
     res.set(id, offset);
     offset += id.byteLength;
-    res.set((0, byte_parsing_1.itole4)(serverCertificate.byteLength), offset);
+    res.set(itole4(serverCertificate.byteLength), offset);
     offset += 4;
     res.set(serverCertificate, offset);
     return res;
 }
-exports.default = getWebKitFairPlayInitData;