rx-player 4.3.1-dev.2025041002 → 4.4.0-dev.2025041400

package/dist/es2017/main_thread/init/utils/initialize_content_decryption.js

@@ -100,7 +100,11 @@ export default function initializeContentDecryption(mediaElement, keySystems, ca
         contentDecryptor: { enabled: true, value: contentDecryptor },
     };
     function createEmeDisabledReference(errMsg) {
-        const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
+        const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg, {
+            keyStatuses: undefined,
+            keySystemConfiguration: undefined,
+            keySystem: undefined,
+        });
         const ref = new SharedReference({
             initializationState: { type: "initialized", value: null },
             drmSystemId: undefined,

package/dist/rx-player.js

@@ -4514,9 +4514,9 @@
       this.code = code;
       this._originalMessage = reason;
       this.fatal = false;
-      if (typeof (supplementaryInfos == null ? void 0 : supplementaryInfos.keyStatuses) === "string") {
-        this.keyStatuses = supplementaryInfos.keyStatuses;
-      }
+      this.keyStatuses = supplementaryInfos.keyStatuses;
+      this.keySystemConfiguration = supplementaryInfos.keySystemConfiguration;
+      this.keySystem = supplementaryInfos.keySystem;
     }
     /**
      * If that error has to be communicated through another thread, this method
@@ -4529,7 +4529,9 @@
         name: this.name,
         code: this.code,
         reason: this._originalMessage,
-        keyStatuses: this.keyStatuses
+        keyStatuses: this.keyStatuses,
+        keySystemConfiguration: this.keySystemConfiguration,
+        keySystem: this.keySystem
       };
     }
   };
@@ -6069,7 +6071,12 @@
       const errMessage = err instanceof Error ? err.toString() : "Unknown Error";
       throw new EncryptedMediaError(
         "MEDIA_KEYS_ATTACHMENT_ERROR",
-        "Could not attach the MediaKeys to the media element: " + errMessage
+        "Could not attach the MediaKeys to the media element: " + errMessage,
+        {
+          keyStatuses: void 0,
+          keySystemConfiguration: mediaKeysInfo.mediaKeySystemAccess.getConfiguration(),
+          keySystem: mediaKeysInfo.mediaKeySystemAccess.keySystem
+        }
       );
     }
   }
@@ -9196,7 +9203,12 @@
       if (index >= keySystemsType.length) {
         throw new EncryptedMediaError(
           "INCOMPATIBLE_KEYSYSTEMS",
-          "No key system compatible with your wanted configuration has been found in the current browser."
+          "No key system compatible with your wanted configuration has been found in the current browser.",
+          {
+            keyStatuses: void 0,
+            keySystemConfiguration: void 0,
+            keySystem: void 0
+          }
         );
       }
       if (isNullOrUndefined(eme_default.requestMediaKeySystemAccess)) {
@@ -10294,7 +10306,11 @@
       return mediaKeys;
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error when creating MediaKeys.";
-      throw new EncryptedMediaError("CREATE_MEDIA_KEYS_ERROR", message);
+      throw new EncryptedMediaError("CREATE_MEDIA_KEYS_ERROR", message, {
+        keyStatuses: void 0,
+        keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+        keySystem: mediaKeySystemAccess.keySystem
+      });
     }
   }
 
@@ -10382,7 +10398,7 @@
     INTERNAL_ERROR: "internal-error",
     OUTPUT_RESTRICTED: "output-restricted"
   };
-  function checkKeyStatuses(session, options, keySystem) {
+  function checkKeyStatuses(session, options, mediaKeySystemAccess) {
     const { onKeyInternalError, onKeyOutputRestricted, onKeyExpiration } = options;
     const blacklistedKeyIds = [];
     const whitelistedKeyIds = [];
@@ -10392,7 +10408,10 @@
         const [keyStatus, keyStatusKeyId] = /* @__PURE__ */ (() => {
           return typeof _arg1 === "string" ? [_arg1, _arg2] : [_arg2, _arg1];
         })();
-        const keyId = getUUIDKIDFromKeyStatusKID(keySystem, new Uint8Array(keyStatusKeyId));
+        const keyId = getUUIDKIDFromKeyStatusKID(
+          mediaKeySystemAccess.keySystem,
+          new Uint8Array(keyStatusKeyId)
+        );
         const keyStatusObj = { keyId: keyId.buffer, keyStatus };
         if (log_default.hasLevel("DEBUG")) {
           log_default.debug(`DRM: key status update (${bytesToHex(keyId)}): ${keyStatus}`);
@@ -10402,7 +10421,11 @@
             const error = new EncryptedMediaError(
               "KEY_STATUS_CHANGE_ERROR",
               `A decryption key expired (${bytesToHex(keyId)})`,
-              { keyStatuses: [keyStatusObj, ...badKeyStatuses] }
+              {
+                keyStatuses: [keyStatusObj, ...badKeyStatuses],
+                keySystem: mediaKeySystemAccess.keySystem,
+                keySystemConfiguration: mediaKeySystemAccess.getConfiguration()
+              }
             );
             if (onKeyExpiration === "error" || onKeyExpiration === void 0) {
               throw error;
@@ -10428,7 +10451,11 @@
             const error = new EncryptedMediaError(
               "KEY_STATUS_CHANGE_ERROR",
               `A "${keyStatus}" status has been encountered (${bytesToHex(keyId)})`,
-              { keyStatuses: [keyStatusObj, ...badKeyStatuses] }
+              {
+                keyStatuses: [keyStatusObj, ...badKeyStatuses],
+                keySystem: mediaKeySystemAccess.keySystem,
+                keySystemConfiguration: mediaKeySystemAccess.getConfiguration()
+              }
             );
             switch (onKeyInternalError) {
               case void 0:
@@ -10456,7 +10483,11 @@
             const error = new EncryptedMediaError(
               "KEY_STATUS_CHANGE_ERROR",
               `A "${keyStatus}" status has been encountered (${bytesToHex(keyId)})`,
-              { keyStatuses: [keyStatusObj, ...badKeyStatuses] }
+              {
+                keyStatuses: [keyStatusObj, ...badKeyStatuses],
+                keySystem: mediaKeySystemAccess.keySystem,
+                keySystemConfiguration: mediaKeySystemAccess.getConfiguration()
+              }
             );
             switch (onKeyOutputRestricted) {
               case void 0:
@@ -10489,14 +10520,18 @@
       warning = new EncryptedMediaError(
         "KEY_STATUS_CHANGE_ERROR",
         "One or several problematic key statuses have been encountered",
-        { keyStatuses: badKeyStatuses }
+        {
+          keyStatuses: badKeyStatuses,
+          keySystem: mediaKeySystemAccess.keySystem,
+          keySystemConfiguration: mediaKeySystemAccess.getConfiguration()
+        }
       );
     }
     return { warning, blacklistedKeyIds, whitelistedKeyIds };
   }
 
   // src/main_thread/decrypt/session_events_listener.ts
-  function SessionEventsListener(session, keySystemOptions, keySystem, callbacks, cancelSignal) {
+  function SessionEventsListener(session, keySystemOptions, mediaKeySystemAccess, callbacks, cancelSignal) {
     log_default.info("DRM: Binding session events", session.sessionId);
     const { getLicenseConfig = {} } = keySystemOptions;
     const manualCanceller = new TaskCanceller();
@@ -10514,7 +10549,13 @@
       session,
       (evt) => {
         manualCanceller.cancel();
-        callbacks.onError(new EncryptedMediaError("KEY_ERROR", evt.type));
+        callbacks.onError(
+          new EncryptedMediaError("KEY_ERROR", evt.type, {
+            keyStatuses: void 0,
+            keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+            keySystem: mediaKeySystemAccess.keySystem
+          })
+        );
       },
       manualCanceller.signal
     );
@@ -10555,7 +10596,11 @@
               log_default.info("DRM: No license given, skipping session.update");
             } else {
               try {
-                await updateSessionWithMessage(session, licenseObject);
+                await updateSessionWithMessage(
+                  session,
+                  licenseObject,
+                  mediaKeySystemAccess
+                );
               } catch (err) {
                 manualCanceller.cancel();
                 callbacks.onError(err);
@@ -10567,7 +10612,7 @@
               return;
             }
             manualCanceller.cancel();
-            const formattedError = formatGetLicenseError(err);
+            const formattedError = formatGetLicenseError(err, mediaKeySystemAccess);
             if (!isNullOrUndefined(err)) {
               const { fallbackOnLastTry } = err;
               if (fallbackOnLastTry === true) {
@@ -10594,7 +10639,7 @@
       const { warning, blacklistedKeyIds, whitelistedKeyIds } = checkKeyStatuses(
         session,
         keySystemOptions,
-        keySystem
+        mediaKeySystemAccess
       );
       if (warning !== void 0) {
         callbacks.onWarning(warning);
@@ -10644,33 +10689,47 @@
         baseDelay: 200,
         maxDelay: 3e3,
         shouldRetry: (error) => error instanceof GetLicenseTimeoutError || isNullOrUndefined(error) || error.noRetry !== true,
-        onRetry: (error) => callbacks.onWarning(formatGetLicenseError(error))
+        onRetry: (error) => callbacks.onWarning(formatGetLicenseError(error, mediaKeySystemAccess))
       };
     }
   }
-  function formatGetLicenseError(error) {
+  function formatGetLicenseError(error, mediaKeySystemAccess) {
     if (error instanceof GetLicenseTimeoutError) {
       return new EncryptedMediaError(
         "KEY_LOAD_TIMEOUT",
-        "The license server took too much time to respond."
+        "The license server took too much time to respond.",
+        {
+          keyStatuses: void 0,
+          keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+          keySystem: mediaKeySystemAccess.keySystem
+        }
       );
     }
     const err = new EncryptedMediaError(
       "KEY_LOAD_ERROR",
-      "An error occured when calling `getLicense`."
+      "An error occured when calling `getLicense`.",
+      {
+        keyStatuses: void 0,
+        keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+        keySystem: mediaKeySystemAccess.keySystem
+      }
     );
     if (!isNullOrUndefined(error) && isNonEmptyString(error.message)) {
       err.message = error.message;
     }
     return err;
   }
-  async function updateSessionWithMessage(session, message) {
+  async function updateSessionWithMessage(session, message, mediaKeySystemAccess) {
     log_default.info("DRM: Updating MediaKeySession with message");
     try {
       await session.update(message);
     } catch (error) {
       const reason = error instanceof Error ? error.toString() : "`session.update` failed";
-      throw new EncryptedMediaError("KEY_UPDATE_ERROR", reason);
+      throw new EncryptedMediaError("KEY_UPDATE_ERROR", reason, {
+        keyStatuses: void 0,
+        keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+        keySystem: mediaKeySystemAccess.keySystem
+      });
     }
     log_default.info("DRM: MediaKeySession update succeeded.");
   }
@@ -10690,7 +10749,7 @@
   };
 
   // src/main_thread/decrypt/set_server_certificate.ts
-  async function setServerCertificate(mediaKeys, serverCertificate) {
+  async function setServerCertificate(mediaKeys, serverCertificate, mediaKeySystemAccess) {
     try {
       const res = await mediaKeys.setServerCertificate(serverCertificate);
       return res;
@@ -10700,10 +10759,14 @@
         error instanceof Error ? error : ""
       );
       const reason = error instanceof Error ? error.toString() : "`setServerCertificate` error";
-      throw new EncryptedMediaError("LICENSE_SERVER_CERTIFICATE_ERROR", reason);
+      throw new EncryptedMediaError("LICENSE_SERVER_CERTIFICATE_ERROR", reason, {
+        keyStatuses: void 0,
+        keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+        keySystem: mediaKeySystemAccess.keySystem
+      });
     }
   }
-  async function trySettingServerCertificate(mediaKeys, serverCertificate) {
+  async function trySettingServerCertificate(mediaKeys, serverCertificate, mediaKeySystemAccess) {
     if (server_certificate_store_default.hasOne(mediaKeys) === true) {
       log_default.info("DRM: The MediaKeys already has a server certificate, skipping...");
       return { type: "already-has-one" };
@@ -10717,13 +10780,22 @@
     log_default.info("DRM: Setting server certificate on the MediaKeys");
     server_certificate_store_default.prepare(mediaKeys);
     try {
-      const result = await setServerCertificate(mediaKeys, serverCertificate);
+      const result = await setServerCertificate(
+        mediaKeys,
+        serverCertificate,
+        mediaKeySystemAccess
+      );
       server_certificate_store_default.set(mediaKeys, serverCertificate);
       return { type: "success", value: result };
     } catch (error) {
       const formattedErr = isKnownError(error) ? error : new EncryptedMediaError(
         "LICENSE_SERVER_CERTIFICATE_ERROR",
-        "Unknown error when setting the server certificate."
+        "Unknown error when setting the server certificate.",
+        {
+          keyStatuses: void 0,
+          keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+          keySystem: mediaKeySystemAccess.keySystem
+        }
       );
       return { type: "error", value: formattedErr };
     }
@@ -10983,7 +11055,11 @@
         this._stateData.isMediaKeysAttached = 2 /* Attached */;
         const { serverCertificate } = options;
         if (!isNullOrUndefined(serverCertificate)) {
-          const resSsc = await trySettingServerCertificate(mediaKeys, serverCertificate);
+          const resSsc = await trySettingServerCertificate(
+            mediaKeys,
+            serverCertificate,
+            mediaKeySystemAccess
+          );
           if (resSsc.type === "error") {
             this.trigger("warning", resSsc.value);
           }
@@ -11205,7 +11281,7 @@
       SessionEventsListener(
         mediaKeySession,
         options,
-        mediaKeySystemAccess.keySystem,
+        mediaKeySystemAccess,
         {
           onKeyUpdate: (value) => {
             const linkedKeys = getKeyIdsLinkedToSession(
@@ -11309,7 +11385,12 @@
           }
           throw new EncryptedMediaError(
             "KEY_GENERATE_REQUEST_ERROR",
-            error instanceof Error ? error.toString() : "Unknown error"
+            error instanceof Error ? error.toString() : "Unknown error",
+            {
+              keyStatuses: void 0,
+              keySystemConfiguration: mediaKeySystemAccess.getConfiguration(),
+              keySystem: mediaKeySystemAccess.keySystem
+            }
           );
         }
       }
@@ -20796,7 +20877,11 @@
       contentDecryptor: { enabled: true, value: contentDecryptor }
     };
     function createEmeDisabledReference(errMsg) {
-      const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg);
+      const err = new EncryptedMediaError("MEDIA_IS_ENCRYPTED_ERROR", errMsg, {
+        keyStatuses: void 0,
+        keySystemConfiguration: void 0,
+        keySystem: void 0
+      });
       const ref = new reference_default({
         initializationState: { type: "initialized", value: null },
         drmSystemId: void 0
@@ -38135,7 +38220,7 @@ ${event}`
       } = parseConstructorOptions(options);
       videoElement.preload = "auto";
       this.version = /* PLAYER_VERSION */
-      "4.3.1-dev.2025041002";
+      "4.4.0-dev.2025041400";
       this.log = log_default;
       this.state = "STOPPED";
       this.videoElement = videoElement;
@@ -40760,7 +40845,7 @@ ${event}`
   _Player._priv_currentlyUsedVideoElements = /* @__PURE__ */ new WeakSet();
   var Player = _Player;
   Player.version = /* PLAYER_VERSION */
-  "4.3.1-dev.2025041002";
+  "4.4.0-dev.2025041400";
   var public_api_default = Player;
 
   // src/main_thread/api/index.ts