rx-player 4.3.0-dev.2024112900 → 4.3.0-dev.2025012900

package/dist/rx-player.js

@@ -628,7 +628,7 @@
       isPanasonic = true;
     } else if (navigator.userAgent.indexOf("Xbox") !== -1) {
       isXbox = true;
-    } else if (navigator.userAgent.indexOf("Model/a1-kstb40xx")) {
+    } else if (navigator.userAgent.indexOf("Model/a1-kstb40xx") !== -1) {
       isA1KStb40xx = true;
     }
   })();
@@ -3380,6 +3380,11 @@
     });
   }
 
+  // src/utils/is_non_empty_string.ts
+  function isNonEmptyString(x) {
+    return typeof x === "string" && x.length > 0;
+  }
+
   // src/utils/starts_with.ts
   function startsWith(completeString, searchString, position) {
     if (typeof String.prototype.startsWith === "function") {
@@ -3446,11 +3451,11 @@
     }
     let result = relativePath;
     if (relativePath === "" && newParts.query === baseParts.query) {
-    } else if (newParts.query) {
+    } else if (isNonEmptyString(newParts.query)) {
       result += "?";
       result += newParts.query;
     }
-    if (newParts.fragment) {
+    if (isNonEmptyString(newParts.fragment)) {
       result += "#";
       result += newParts.fragment;
     }
@@ -3459,7 +3464,7 @@
   function _resolveURL(base, relative) {
     const baseParts = parseURL(base);
     const relativeParts = parseURL(relative);
-    if (relativeParts.scheme) {
+    if (isNonEmptyString(relativeParts.scheme)) {
       return formatURL(relativeParts);
     }
     const target = {
@@ -3469,14 +3474,14 @@
       query: relativeParts.query,
       fragment: relativeParts.fragment
     };
-    if (relativeParts.authority) {
+    if (isNonEmptyString(relativeParts.authority)) {
       target.authority = relativeParts.authority;
       target.path = removeDotSegment(relativeParts.path);
       return formatURL(target);
     }
     if (relativeParts.path === "") {
       target.path = baseParts.path;
-      if (!relativeParts.query) {
+      if (!isNonEmptyString(relativeParts.query)) {
         target.query = baseParts.query;
       }
     } else {
@@ -3522,17 +3527,17 @@
   }
   function formatURL(parts) {
     let url = "";
-    if (parts.scheme) {
+    if (isNonEmptyString(parts.scheme)) {
       url += parts.scheme + ":";
     }
-    if (parts.authority) {
+    if (isNonEmptyString(parts.authority)) {
       url += "//" + parts.authority;
     }
     url += parts.path;
-    if (parts.query) {
+    if (isNonEmptyString(parts.query)) {
       url += "?" + parts.query;
     }
-    if (parts.fragment) {
+    if (isNonEmptyString(parts.fragment)) {
       url += "#" + parts.fragment;
     }
     return url;
@@ -3563,7 +3568,7 @@
     return output.join("");
   }
   function mergePaths(baseParts, relativePath) {
-    if (baseParts.authority && baseParts.path === "") {
+    if (isNonEmptyString(baseParts.authority) && baseParts.path === "") {
       return "/" + relativePath;
     }
     const basePath = baseParts.path;
@@ -3776,7 +3781,7 @@
       props.st = content.manifest.isDynamic ? "l" : "v";
       props.tb = content.adaptation.representations.reduce(
         (acc, representation) => {
-          if (representation.isSupported !== true || representation.decipherable === false) {
+          if (representation.isPlayable() !== true) {
             return acc;
           }
           if (acc === void 0) {
@@ -4106,11 +4111,6 @@
     return typeof global_scope_default.fetch === "function" && !isNullOrUndefined(_AbortController) && !isNullOrUndefined(_Headers);
   }
 
-  // src/utils/is_non_empty_string.ts
-  function isNonEmptyString(x) {
-    return typeof x === "string" && x.length > 0;
-  }
-
   // src/utils/request/xhr.ts
   var DEFAULT_RESPONSE_TYPE = "json";
   function request(options) {
@@ -4975,6 +4975,211 @@
     return true;
   }
 
+  // src/manifest/utils.ts
+  var SUPPORTED_ADAPTATIONS_TYPE = ["audio", "video", "text"];
+  function getMinimumSafePosition(manifest) {
+    var _a2, _b2;
+    const windowData = manifest.timeBounds;
+    if (windowData.timeshiftDepth === null) {
+      return (_a2 = windowData.minimumSafePosition) != null ? _a2 : 0;
+    }
+    const { maximumTimeData } = windowData;
+    let maximumTime;
+    if (!windowData.maximumTimeData.isLinear) {
+      maximumTime = maximumTimeData.maximumSafePosition;
+    } else {
+      const timeDiff = monotonic_timestamp_default() - maximumTimeData.time;
+      maximumTime = maximumTimeData.maximumSafePosition + timeDiff / 1e3;
+    }
+    const theoricalMinimum = maximumTime - windowData.timeshiftDepth;
+    return Math.max((_b2 = windowData.minimumSafePosition) != null ? _b2 : 0, theoricalMinimum);
+  }
+  function getLivePosition(manifest) {
+    const { maximumTimeData } = manifest.timeBounds;
+    if (!manifest.isLive || maximumTimeData.livePosition === void 0) {
+      return void 0;
+    }
+    if (!maximumTimeData.isLinear) {
+      return maximumTimeData.livePosition;
+    }
+    const timeDiff = monotonic_timestamp_default() - maximumTimeData.time;
+    return maximumTimeData.livePosition + timeDiff / 1e3;
+  }
+  function getMaximumSafePosition(manifest) {
+    const { maximumTimeData } = manifest.timeBounds;
+    if (!maximumTimeData.isLinear) {
+      return maximumTimeData.maximumSafePosition;
+    }
+    const timeDiff = monotonic_timestamp_default() - maximumTimeData.time;
+    return maximumTimeData.maximumSafePosition + timeDiff / 1e3;
+  }
+  function getSupportedAdaptations(period, type) {
+    if (type === void 0) {
+      return getAdaptations(period).filter((ada) => {
+        return ada.supportStatus.hasSupportedCodec !== false && ada.supportStatus.isDecipherable !== false;
+      });
+    }
+    const adaptationsForType = period.adaptations[type];
+    if (adaptationsForType === void 0) {
+      return [];
+    }
+    return adaptationsForType.filter((ada) => {
+      return ada.supportStatus.hasSupportedCodec !== false && ada.supportStatus.isDecipherable !== false;
+    });
+  }
+  function getPeriodForTime(manifest, time) {
+    let nextPeriod = null;
+    for (const period of manifest.periods) {
+      if (periodContainsTime(period, time, nextPeriod)) {
+        return period;
+      }
+      nextPeriod = period;
+    }
+  }
+  function getPeriodAfter(manifest, period) {
+    const endOfPeriod = period.end;
+    if (endOfPeriod === void 0) {
+      return null;
+    }
+    const nextPeriod = arrayFind(manifest.periods, (_period) => {
+      return _period.end === void 0 || endOfPeriod < _period.end;
+    });
+    return nextPeriod === void 0 ? null : nextPeriod;
+  }
+  function periodContainsTime(period, time, nextPeriod) {
+    if (time >= period.start && (period.end === void 0 || time < period.end)) {
+      return true;
+    } else if (time === period.end && (nextPeriod === null || nextPeriod.start > period.end)) {
+      return true;
+    }
+    return false;
+  }
+  function getAdaptations(period) {
+    const adaptationsByType = period.adaptations;
+    return objectValues(adaptationsByType).reduce(
+      // Note: the second case cannot happen. TS is just being dumb here
+      (acc, adaptations) => !isNullOrUndefined(adaptations) ? acc.concat(adaptations) : acc,
+      []
+    );
+  }
+  function toAudioTrack(adaptation, filterPlayable) {
+    var _a2, _b2;
+    const formatted = {
+      language: (_a2 = adaptation.language) != null ? _a2 : "",
+      normalized: (_b2 = adaptation.normalizedLanguage) != null ? _b2 : "",
+      audioDescription: adaptation.isAudioDescription === true,
+      id: adaptation.id,
+      representations: (filterPlayable ? adaptation.representations.filter((r) => isRepresentationPlayable(r)) : adaptation.representations).map(toAudioRepresentation),
+      label: adaptation.label
+    };
+    if (adaptation.isDub === true) {
+      formatted.dub = true;
+    }
+    return formatted;
+  }
+  function toTextTrack(adaptation) {
+    var _a2, _b2;
+    return {
+      language: (_a2 = adaptation.language) != null ? _a2 : "",
+      normalized: (_b2 = adaptation.normalizedLanguage) != null ? _b2 : "",
+      closedCaption: adaptation.isClosedCaption === true,
+      id: adaptation.id,
+      label: adaptation.label,
+      forced: adaptation.isForcedSubtitles
+    };
+  }
+  function toVideoTrack(adaptation, filterPlayable) {
+    const trickModeTracks = adaptation.trickModeTracks !== void 0 ? adaptation.trickModeTracks.map((trickModeAdaptation) => {
+      const representations = (filterPlayable ? trickModeAdaptation.representations.filter(
+        (r) => isRepresentationPlayable(r) === true
+      ) : trickModeAdaptation.representations).map(toVideoRepresentation);
+      const trickMode = {
+        id: trickModeAdaptation.id,
+        representations,
+        isTrickModeTrack: true
+      };
+      if (trickModeAdaptation.isSignInterpreted === true) {
+        trickMode.signInterpreted = true;
+      }
+      return trickMode;
+    }) : void 0;
+    const videoTrack = {
+      id: adaptation.id,
+      representations: (filterPlayable ? adaptation.representations.filter((r) => isRepresentationPlayable(r) === true) : adaptation.representations).map(toVideoRepresentation),
+      label: adaptation.label
+    };
+    if (adaptation.isSignInterpreted === true) {
+      videoTrack.signInterpreted = true;
+    }
+    if (adaptation.isTrickModeTrack === true) {
+      videoTrack.isTrickModeTrack = true;
+    }
+    if (trickModeTracks !== void 0) {
+      videoTrack.trickModeTracks = trickModeTracks;
+    }
+    return videoTrack;
+  }
+  function toAudioRepresentation(representation) {
+    const { id, bitrate, codecs, isSpatialAudio, isSupported, decipherable } = representation;
+    return {
+      id,
+      bitrate,
+      codec: codecs == null ? void 0 : codecs[0],
+      isSpatialAudio,
+      isCodecSupported: isSupported,
+      decipherable
+    };
+  }
+  function toVideoRepresentation(representation) {
+    const {
+      id,
+      bitrate,
+      frameRate,
+      width,
+      height,
+      codecs,
+      hdrInfo,
+      isSupported,
+      decipherable,
+      contentProtections
+    } = representation;
+    return {
+      id,
+      bitrate,
+      frameRate,
+      width,
+      height,
+      codec: codecs == null ? void 0 : codecs[0],
+      hdrInfo,
+      isCodecSupported: isSupported,
+      decipherable,
+      contentProtections: contentProtections !== void 0 ? {
+        keyIds: contentProtections.keyIds
+      } : void 0
+    };
+  }
+  function toTaggedTrack(adaptation) {
+    switch (adaptation.type) {
+      case "audio":
+        return { type: "audio", track: toAudioTrack(adaptation, false) };
+      case "video":
+        return { type: "video", track: toVideoTrack(adaptation, false) };
+      case "text":
+        return { type: "text", track: toTextTrack(adaptation) };
+    }
+  }
+  function isRepresentationPlayable(representation) {
+    if (representation.decipherable === false) {
+      return false;
+    }
+    return representation.isSupported;
+  }
+  function createRepresentationFilterFromFnString(fnString) {
+    return new Function(
+      `return (${fnString}(arguments[0], arguments[1]))`
+    );
+  }
+
   // src/utils/id_generator.ts
   function idGenerator() {
     let prefix = "";
@@ -5262,6 +5467,22 @@
       this.contentProtections.initData.push({ type: initDataType, values: data });
       return true;
     }
+    /**
+     * Returns `true` if the `Representation` has a high chance of being playable on
+     * the current device (its codec seems supported and we don't consider it to be
+     * un-decipherable).
+     *
+     * Returns `false` if the `Representation` has a high chance of being unplayable
+     * on the current device (its codec seems unsupported and/or we consider it to
+     * be un-decipherable).
+     *
+     * Returns `undefined` if we don't know as the codec has not been checked yet.
+     *
+     * @returns {boolean|undefined}
+     */
+    isPlayable() {
+      return isRepresentationPlayable(this);
+    }
     /**
      * Format the current `Representation`'s properties into a
      * `IRepresentationMetadata` format which can better be communicated through
@@ -5534,56 +5755,177 @@
     ]);
   }
 
-  // src/main_thread/decrypt/utils/media_keys_infos_store.ts
+  // src/main_thread/decrypt/utils/media_keys_attacher.ts
   var currentMediaState = /* @__PURE__ */ new WeakMap();
-  var media_keys_infos_store_default = {
+  var media_keys_attacher_default = {
     /**
-     * Update MediaKeys infos set on a HMTLMediaElement
+     * Attach new MediaKeys infos set on a HMTLMediaElement.
      * @param {HTMLMediaElement} mediaElement
-     * @param {Object} state
+     * @param {Object} mediaKeysInfo
+     * @returns {Promise}
      */
-    setState(mediaElement, state) {
-      currentMediaState.set(mediaElement, state);
+    async attach(mediaElement, mediaKeysInfo) {
+      const previousState = currentMediaState.get(mediaElement);
+      const pendingTask = attachMediaKeys(mediaElement, previousState, mediaKeysInfo).then(
+        () => {
+          currentMediaState.set(mediaElement, {
+            pendingTask: null,
+            mediaKeysState: mediaKeysInfo
+          });
+        },
+        () => {
+          currentMediaState.set(mediaElement, {
+            pendingTask: null,
+            mediaKeysState: null
+          });
+        }
+      );
+      currentMediaState.set(mediaElement, {
+        pendingTask,
+        mediaKeysState: mediaKeysInfo
+      });
+      return pendingTask;
     },
     /**
-     * Get MediaKeys infos currently set on a HMTLMediaElement
+     * Get MediaKeys information expected to be linked to the given
+     * `HTMLMediaElement`.
+     *
+     * Unlike `getAttachedMediaKeysState`, this method is synchronous and will
+     * also return the expected state when `MediaKeys` attachment is still
+     * pending and thus when that state is not truly applied (and where it
+     * might fail before being applied).
+     *
+     * As such, only call this method if you want the currently expected state,
+     * not the actual one.
      * @param {HTMLMediaElement} mediaElement
-     * @returns {Object}
+     * @returns {Array}
+     */
+    getAwaitedState(mediaElement) {
+      var _a2;
+      const currentState = currentMediaState.get(mediaElement);
+      return (_a2 = currentState == null ? void 0 : currentState.mediaKeysState) != null ? _a2 : null;
+    },
+    /**
+     * Get MediaKeys information set on a HMTLMediaElement.
+     *
+     * This method is asynchronous because that state may still be in a process
+     * of being attached to the `HTMLMediaElement` (and the state we're
+     * currently setting may not work out).
+     * @param {HTMLMediaElement} mediaElement
+     * @returns {Object|null}
      */
-    getState(mediaElement) {
+    async getAttachedMediaKeysState(mediaElement) {
       const currentState = currentMediaState.get(mediaElement);
-      return currentState === void 0 ? null : currentState;
+      if (currentState === void 0) {
+        return null;
+      }
+      if (currentState.pendingTask !== null) {
+        await currentState.pendingTask;
+        return this.getAttachedMediaKeysState(mediaElement);
+      }
+      return currentState.mediaKeysState;
     },
     /**
-     * Remove MediaKeys infos currently set on a HMTLMediaElement
+     * Remove MediaKeys currently set on a HMTLMediaElement and update state
+     * accordingly.
      * @param {HTMLMediaElement} mediaElement
+     * @returns {Promise}
      */
-    clearState(mediaElement) {
-      currentMediaState.set(mediaElement, null);
+    clearMediaKeys(mediaElement) {
+      const previousState = currentMediaState.get(mediaElement);
+      const pendingTask = clearMediaKeys(mediaElement, previousState).then(
+        () => {
+          currentMediaState.set(mediaElement, {
+            pendingTask: null,
+            mediaKeysState: null
+          });
+        },
+        () => {
+          currentMediaState.set(mediaElement, {
+            pendingTask: null,
+            mediaKeysState: null
+          });
+        }
+      );
+      currentMediaState.set(mediaElement, {
+        pendingTask,
+        mediaKeysState: null
+      });
+      return pendingTask;
     }
   };
-
-  // src/main_thread/decrypt/dispose_decryption_resources.ts
-  async function disposeDecryptionResources(mediaElement) {
-    const currentState = media_keys_infos_store_default.getState(mediaElement);
-    if (currentState === null) {
-      return void 0;
+  async function awaitMediaKeysAttachment(previousState) {
+    const promise = previousState.pendingTask;
+    if (isNullOrUndefined(promise)) {
+      return;
+    }
+    log_default.info("DRM: Awaiting previous MediaKeys attachment operation");
+    try {
+      await previousState.pendingTask;
+    } catch (err) {
+      log_default.info(
+        "DRM: previous MediaKeys attachment operation failed",
+        err instanceof Error ? err : "Unknown error"
+      );
+    }
+  }
+  async function attachMediaKeys(mediaElement, previousState, mediaKeysInfo) {
+    if (previousState !== void 0) {
+      if (previousState.pendingTask !== null) {
+        await awaitMediaKeysAttachment(previousState);
+      }
+      const closeAllSessions = !isNullOrUndefined(previousState.mediaKeysState) && previousState.mediaKeysState.loadedSessionsStore !== mediaKeysInfo.loadedSessionsStore ? previousState.mediaKeysState.loadedSessionsStore.closeAllSessions() : Promise.resolve();
+      await closeAllSessions;
+      if (mediaElement.mediaKeys === mediaKeysInfo.mediaKeys) {
+        log_default.debug("DRM: Right MediaKeys already set");
+        return;
+      }
+    }
+    log_default.info("DRM: Attaching MediaKeys to the media element");
+    try {
+      await setMediaKeys(
+        mediaKeysInfo.emeImplementation,
+        mediaElement,
+        mediaKeysInfo.mediaKeys
+      );
+      log_default.info("DRM: MediaKeys attached with success");
+    } catch (err) {
+      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
+      );
+    }
+  }
+  async function clearMediaKeys(mediaElement, previousState) {
+    if (previousState === void 0) {
+      return;
+    }
+    if (previousState.pendingTask !== null) {
+      await awaitMediaKeysAttachment(previousState);
+    }
+    if (previousState.mediaKeysState === null) {
+      return;
     }
     log_default.info("DRM: Disposing of the current MediaKeys");
-    const { loadedSessionsStore } = currentState;
-    media_keys_infos_store_default.clearState(mediaElement);
+    const { loadedSessionsStore } = previousState.mediaKeysState;
     await loadedSessionsStore.closeAllSessions();
-    return setMediaKeys(currentState.emeImplementation, mediaElement, null);
+    return setMediaKeys(previousState.mediaKeysState.emeImplementation, mediaElement, null);
+  }
+
+  // src/main_thread/decrypt/dispose_decryption_resources.ts
+  async function disposeDecryptionResources(mediaElement) {
+    return media_keys_attacher_default.clearMediaKeys(mediaElement);
   }
 
   // src/main_thread/decrypt/clear_on_stop.ts
-  function clearOnStop(mediaElement) {
+  async function clearOnStop(mediaElement) {
     log_default.info("DRM: Clearing-up DRM session.");
     if (shouldUnsetMediaKeys()) {
       log_default.info("DRM: disposing current MediaKeys.");
       return disposeDecryptionResources(mediaElement);
     }
-    const currentState = media_keys_infos_store_default.getState(mediaElement);
+    const currentState = await media_keys_attacher_default.getAttachedMediaKeysState(mediaElement);
     if (currentState !== null && currentState.keySystemOptions.closeSessionsOnStop === true) {
       log_default.info("DRM: closing all current sessions.");
       return currentState.loadedSessionsStore.closeAllSessions();
@@ -8135,50 +8477,6 @@
     return false;
   }
 
-  // src/main_thread/decrypt/attach_media_keys.ts
-  function disableMediaKeys(mediaElement) {
-    var _a2;
-    const previousState = media_keys_infos_store_default.getState(mediaElement);
-    media_keys_infos_store_default.setState(mediaElement, null);
-    return setMediaKeys((_a2 = previousState == null ? void 0 : previousState.emeImplementation) != null ? _a2 : eme_default, mediaElement, null);
-  }
-  async function attachMediaKeys(mediaElement, {
-    emeImplementation,
-    keySystemOptions,
-    askedConfiguration,
-    loadedSessionsStore,
-    mediaKeySystemAccess,
-    mediaKeys
-  }, cancelSignal) {
-    const previousState = media_keys_infos_store_default.getState(mediaElement);
-    const closeAllSessions = previousState !== null && previousState.loadedSessionsStore !== loadedSessionsStore ? previousState.loadedSessionsStore.closeAllSessions() : Promise.resolve();
-    await closeAllSessions;
-    if (cancelSignal.isCancelled()) {
-      throw cancelSignal.cancellationError;
-    }
-    media_keys_infos_store_default.setState(mediaElement, {
-      emeImplementation,
-      keySystemOptions,
-      mediaKeySystemAccess,
-      mediaKeys,
-      loadedSessionsStore,
-      askedConfiguration
-    });
-    if (mediaElement.mediaKeys === mediaKeys) {
-      return;
-    }
-    log_default.info("DRM: Attaching MediaKeys to the media element");
-    return setMediaKeys(emeImplementation, mediaElement, mediaKeys).then(() => {
-      log_default.info("DRM: MediaKeys attached with success");
-    }).catch((err) => {
-      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
-      );
-    });
-  }
-
   // src/main_thread/decrypt/utils/is_session_usable.ts
   function isSessionUsable(loadedSession) {
     if (loadedSession.sessionId === "") {
@@ -8486,25 +8784,49 @@
   }
 
   // src/main_thread/decrypt/find_key_system.ts
-  function checkCachedMediaKeySystemAccess(keySystem, askedConfiguration, currentKeySystemAccess, currentKeySystemOptions) {
-    const mksConfiguration = currentKeySystemAccess.getConfiguration();
-    if (shouldRenewMediaKeySystemAccess() || isNullOrUndefined(mksConfiguration)) {
-      return null;
+  function isNewMediaKeySystemConfigurationCompatibleWithPreviousOne(newConfiguration, prevConfiguration) {
+    var _a2, _b2, _c2, _d2, _e2, _f, _g, _h, _i, _j;
+    if (newConfiguration.label !== prevConfiguration.label) {
+      return false;
     }
-    if (keySystem.type !== currentKeySystemOptions.type) {
-      return null;
+    const prevDistinctiveIdentifier = (_a2 = prevConfiguration.distinctiveIdentifier) != null ? _a2 : "optional";
+    const newDistinctiveIdentifier = (_b2 = newConfiguration.distinctiveIdentifier) != null ? _b2 : "optional";
+    if (prevDistinctiveIdentifier !== newDistinctiveIdentifier) {
+      return false;
     }
-    if ((!isNullOrUndefined(keySystem.persistentLicenseConfig) || keySystem.persistentState === "required") && mksConfiguration.persistentState !== "required") {
-      return null;
+    const prevPersistentState = (_c2 = prevConfiguration.persistentState) != null ? _c2 : "optional";
+    const newPersistentState = (_d2 = newConfiguration.persistentState) != null ? _d2 : "optional";
+    if (prevPersistentState !== newPersistentState) {
+      return false;
     }
-    if (keySystem.distinctiveIdentifier === "required" && mksConfiguration.distinctiveIdentifier !== "required") {
-      return null;
+    const prevInitDataTypes = (_e2 = prevConfiguration.initDataTypes) != null ? _e2 : [];
+    const newInitDataTypes = (_f = newConfiguration.initDataTypes) != null ? _f : [];
+    if (!isArraySubsetOf(newInitDataTypes, prevInitDataTypes)) {
+      return false;
     }
-    return {
-      keySystemOptions: keySystem,
-      keySystemAccess: currentKeySystemAccess,
-      askedConfiguration
-    };
+    const prevSessionTypes = (_g = prevConfiguration.sessionTypes) != null ? _g : [];
+    const newSessionTypes = (_h = newConfiguration.sessionTypes) != null ? _h : [];
+    if (!isArraySubsetOf(newSessionTypes, prevSessionTypes)) {
+      return false;
+    }
+    for (const prop of ["audioCapabilities", "videoCapabilities"]) {
+      const newCapabilities = (_i = newConfiguration[prop]) != null ? _i : [];
+      const prevCapabilities = (_j = prevConfiguration[prop]) != null ? _j : [];
+      const wasFound = newCapabilities.every((n) => {
+        var _a3, _b3, _c3, _d3, _e3, _f2;
+        for (let i = 0; i < prevCapabilities.length; i++) {
+          const prevCap = prevCapabilities[i];
+          if (((_a3 = prevCap.robustness) != null ? _a3 : "") === ((_b3 = n.robustness) != null ? _b3 : "") || ((_c3 = prevCap.encryptionScheme) != null ? _c3 : null) === ((_d3 = n.encryptionScheme) != null ? _d3 : null) || ((_e3 = prevCap.robustness) != null ? _e3 : "") === ((_f2 = n.robustness) != null ? _f2 : "")) {
+            return true;
+          }
+        }
+        return false;
+      });
+      if (!wasFound) {
+        return false;
+      }
+    }
+    return true;
   }
   function findKeySystemCanonicalName(ksType) {
     const { EME_KEY_SYSTEMS } = config_default.getCurrent();
@@ -8517,12 +8839,19 @@
   }
   function buildKeySystemConfigurations(keySystemTypeInfo) {
     const { keyName, keyType, keySystemOptions: keySystem } = keySystemTypeInfo;
-    const sessionTypes = ["temporary"];
+    let sessionTypes;
     let persistentState = "optional";
     let distinctiveIdentifier = "optional";
-    if (!isNullOrUndefined(keySystem.persistentLicenseConfig)) {
+    if (Array.isArray(keySystem.wantedSessionTypes)) {
+      sessionTypes = keySystem.wantedSessionTypes;
+      if (arrayIncludes(keySystem.wantedSessionTypes, "persistent-license") && !isNullOrUndefined(keySystem.persistentLicenseConfig)) {
+        persistentState = "required";
+      }
+    } else if (!isNullOrUndefined(keySystem.persistentLicenseConfig)) {
       persistentState = "required";
-      sessionTypes.push("persistent-license");
+      sessionTypes = ["persistent-license"];
+    } else {
+      sessionTypes = ["temporary"];
     }
     if (!isNullOrUndefined(keySystem.persistentState)) {
       persistentState = keySystem.persistentState;
@@ -8690,40 +9019,34 @@
         throw new Error("requestMediaKeySystemAccess is not implemented in your browser.");
       }
       const chosenType = keySystemsType[index];
-      const currentState = media_keys_infos_store_default.getState(mediaElement);
-      if (currentState !== null) {
-        if (eme_default.implementation === currentState.emeImplementation.implementation) {
-          const cachedKeySystemAccess = checkCachedMediaKeySystemAccess(
-            chosenType.keySystemOptions,
-            currentState.askedConfiguration,
-            currentState.mediaKeySystemAccess,
-            currentState.keySystemOptions
-          );
-          if (cachedKeySystemAccess !== null) {
-            log_default.info("DRM: Found cached compatible keySystem");
-            return Promise.resolve({
-              type: "reuse-media-key-system-access",
-              value: {
-                mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
-                askedConfiguration: cachedKeySystemAccess.askedConfiguration,
-                options: cachedKeySystemAccess.keySystemOptions,
-                codecSupport: extractCodecSupportListFromConfiguration(
-                  cachedKeySystemAccess.askedConfiguration,
-                  cachedKeySystemAccess.keySystemAccess.getConfiguration()
-                )
-              }
-            });
-          }
-        }
-      }
       const { keyType, keySystemOptions } = chosenType;
       const keySystemConfigurations = buildKeySystemConfigurations(chosenType);
       log_default.debug(
         `DRM: Request keysystem access ${keyType},${index + 1} of ${keySystemsType.length}`
       );
       let keySystemAccess;
+      const currentState = await media_keys_attacher_default.getAttachedMediaKeysState(mediaElement);
       for (let configIdx = 0; configIdx < keySystemConfigurations.length; configIdx++) {
         const keySystemConfiguration = keySystemConfigurations[configIdx];
+        if (currentState !== null && !shouldRenewMediaKeySystemAccess() && // TODO: Do it with MediaKeySystemAccess.prototype.keySystem instead?
+        keyType === currentState.mediaKeySystemAccess.keySystem && eme_default.implementation === currentState.emeImplementation.implementation && isNewMediaKeySystemConfigurationCompatibleWithPreviousOne(
+          keySystemConfiguration,
+          currentState.askedConfiguration
+        )) {
+          log_default.info("DRM: Found cached compatible keySystem");
+          return Promise.resolve({
+            type: "reuse-media-key-system-access",
+            value: {
+              mediaKeySystemAccess: currentState.mediaKeySystemAccess,
+              askedConfiguration: currentState.askedConfiguration,
+              options: keySystemOptions,
+              codecSupport: extractCodecSupportListFromConfiguration(
+                currentState.askedConfiguration,
+                currentState.mediaKeySystemAccess.getConfiguration()
+              )
+            }
+          });
+        }
         try {
           keySystemAccess = await testKeySystem(keyType, [keySystemConfiguration]);
           log_default.info("DRM: Found compatible keysystem", keyType, index + 1);
@@ -8770,6 +9093,14 @@
     }
     return keySystemAccess;
   }
+  function isArraySubsetOf(arr1, arr2) {
+    for (let i = 0; i < arr1.length; i++) {
+      if (!arrayIncludes(arr2, arr1[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
 
   // src/main_thread/decrypt/utils/key_id_comparison.ts
   function areAllKeyIdsContainedIn(wantedKeyIds, keyIdsArr) {
@@ -9746,7 +10077,7 @@
       throw cancelSignal.cancellationError;
     }
     const { options, mediaKeySystemAccess, askedConfiguration, codecSupport } = evt.value;
-    const currentState = media_keys_infos_store_default.getState(mediaElement);
+    const currentState = await media_keys_attacher_default.getAttachedMediaKeysState(mediaElement);
     const persistentSessionsStore = createPersistentSessionsStorage(options);
     if (evt.value.options.reuseMediaKeys !== false && canReuseMediaKeys() && currentState !== null && evt.type === "reuse-media-key-system-access") {
       log_default.debug("DRM: Reusing already created MediaKeys");
@@ -9796,7 +10127,7 @@
     const shouldDisableOldMediaKeys = mediaElement.mediaKeys !== null && mediaElement.mediaKeys !== void 0 && mediaKeys !== mediaElement.mediaKeys;
     if (shouldDisableOldMediaKeys) {
       log_default.debug("DRM: Disabling old MediaKeys");
-      await disableMediaKeys(mediaElement);
+      await media_keys_attacher_default.clearMediaKeys(mediaElement);
     }
     return mediaKeysInfo;
   }
@@ -10460,7 +10791,10 @@
         keySystemOptions: options
       };
       log_default.debug("DRM: Attaching current MediaKeys");
-      attachMediaKeys(mediaElement, stateToAttach, this._canceller.signal).then(async () => {
+      media_keys_attacher_default.attach(mediaElement, stateToAttach).then(async () => {
+        if (this._isStopped()) {
+          return;
+        }
         this._stateData.isMediaKeysAttached = 2 /* Attached */;
         const { serverCertificate } = options;
         if (!isNullOrUndefined(serverCertificate)) {
@@ -10654,13 +10988,10 @@
       }
       this._lockInitDataQueue();
       let wantedSessionType;
-      if (isNullOrUndefined(options.persistentLicenseConfig)) {
-        wantedSessionType = "temporary";
-      } else if (!canCreatePersistentSession(mediaKeySystemAccess)) {
-        log_default.warn('DRM: Cannot create "persistent-license" session: not supported');
-        wantedSessionType = "temporary";
-      } else {
+      if (canCreatePersistentSession(mediaKeySystemAccess) && (!isNullOrUndefined(options.persistentLicenseConfig) || !canCreateTemporarySession(mediaKeySystemAccess))) {
         wantedSessionType = "persistent-license";
+      } else {
+        wantedSessionType = "temporary";
       }
       const {
         EME_DEFAULT_MAX_SIMULTANEOUS_MEDIA_KEY_SESSIONS,
@@ -10985,6 +11316,10 @@
     const { sessionTypes } = mediaKeySystemAccess.getConfiguration();
     return sessionTypes !== void 0 && arrayIncludes(sessionTypes, "persistent-license");
   }
+  function canCreateTemporarySession(mediaKeySystemAccess) {
+    const { sessionTypes } = mediaKeySystemAccess.getConfiguration();
+    return sessionTypes !== void 0 && arrayIncludes(sessionTypes, "temporary");
+  }
   function getMissingKeyIds(expectedKeyIds, actualKeyIds) {
     return expectedKeyIds.filter((expected) => {
       return !actualKeyIds.some((actual) => areArraysOfNumbersEqual(actual, expected));
@@ -11093,7 +11428,7 @@
 
   // src/main_thread/decrypt/get_key_system_configuration.ts
   function getKeySystemConfiguration(mediaElement) {
-    const currentState = media_keys_infos_store_default.getState(mediaElement);
+    const currentState = media_keys_attacher_default.getAwaitedState(mediaElement);
     if (currentState === null) {
       return null;
     }
@@ -11141,209 +11476,6 @@
     }
   }
 
-  // src/manifest/utils.ts
-  var SUPPORTED_ADAPTATIONS_TYPE = ["audio", "video", "text"];
-  function getMinimumSafePosition(manifest) {
-    var _a2, _b2;
-    const windowData = manifest.timeBounds;
-    if (windowData.timeshiftDepth === null) {
-      return (_a2 = windowData.minimumSafePosition) != null ? _a2 : 0;
-    }
-    const { maximumTimeData } = windowData;
-    let maximumTime;
-    if (!windowData.maximumTimeData.isLinear) {
-      maximumTime = maximumTimeData.maximumSafePosition;
-    } else {
-      const timeDiff = monotonic_timestamp_default() - maximumTimeData.time;
-      maximumTime = maximumTimeData.maximumSafePosition + timeDiff / 1e3;
-    }
-    const theoricalMinimum = maximumTime - windowData.timeshiftDepth;
-    return Math.max((_b2 = windowData.minimumSafePosition) != null ? _b2 : 0, theoricalMinimum);
-  }
-  function getLivePosition(manifest) {
-    const { maximumTimeData } = manifest.timeBounds;
-    if (!manifest.isLive || maximumTimeData.livePosition === void 0) {
-      return void 0;
-    }
-    if (!maximumTimeData.isLinear) {
-      return maximumTimeData.livePosition;
-    }
-    const timeDiff = monotonic_timestamp_default() - maximumTimeData.time;
-    return maximumTimeData.livePosition + timeDiff / 1e3;
-  }
-  function getMaximumSafePosition(manifest) {
-    const { maximumTimeData } = manifest.timeBounds;
-    if (!maximumTimeData.isLinear) {
-      return maximumTimeData.maximumSafePosition;
-    }
-    const timeDiff = monotonic_timestamp_default() - maximumTimeData.time;
-    return maximumTimeData.maximumSafePosition + timeDiff / 1e3;
-  }
-  function getSupportedAdaptations(period, type) {
-    if (type === void 0) {
-      return getAdaptations(period).filter((ada) => {
-        return ada.supportStatus.hasSupportedCodec !== false && ada.supportStatus.isDecipherable !== false;
-      });
-    }
-    const adaptationsForType = period.adaptations[type];
-    if (adaptationsForType === void 0) {
-      return [];
-    }
-    return adaptationsForType.filter((ada) => {
-      return ada.supportStatus.hasSupportedCodec !== false && ada.supportStatus.isDecipherable !== false;
-    });
-  }
-  function getPeriodForTime(manifest, time) {
-    let nextPeriod = null;
-    for (const period of manifest.periods) {
-      if (periodContainsTime(period, time, nextPeriod)) {
-        return period;
-      }
-      nextPeriod = period;
-    }
-  }
-  function getPeriodAfter(manifest, period) {
-    const endOfPeriod = period.end;
-    if (endOfPeriod === void 0) {
-      return null;
-    }
-    const nextPeriod = arrayFind(manifest.periods, (_period) => {
-      return _period.end === void 0 || endOfPeriod < _period.end;
-    });
-    return nextPeriod === void 0 ? null : nextPeriod;
-  }
-  function periodContainsTime(period, time, nextPeriod) {
-    if (time >= period.start && (period.end === void 0 || time < period.end)) {
-      return true;
-    } else if (time === period.end && (nextPeriod === null || nextPeriod.start > period.end)) {
-      return true;
-    }
-    return false;
-  }
-  function getAdaptations(period) {
-    const adaptationsByType = period.adaptations;
-    return objectValues(adaptationsByType).reduce(
-      // Note: the second case cannot happen. TS is just being dumb here
-      (acc, adaptations) => !isNullOrUndefined(adaptations) ? acc.concat(adaptations) : acc,
-      []
-    );
-  }
-  function toAudioTrack(adaptation, filterPlayable) {
-    var _a2, _b2;
-    const formatted = {
-      language: (_a2 = adaptation.language) != null ? _a2 : "",
-      normalized: (_b2 = adaptation.normalizedLanguage) != null ? _b2 : "",
-      audioDescription: adaptation.isAudioDescription === true,
-      id: adaptation.id,
-      representations: (filterPlayable ? adaptation.representations.filter(
-        (r) => r.isSupported === true && r.decipherable !== false
-      ) : adaptation.representations).map(toAudioRepresentation),
-      label: adaptation.label
-    };
-    if (adaptation.isDub === true) {
-      formatted.dub = true;
-    }
-    return formatted;
-  }
-  function toTextTrack(adaptation) {
-    var _a2, _b2;
-    return {
-      language: (_a2 = adaptation.language) != null ? _a2 : "",
-      normalized: (_b2 = adaptation.normalizedLanguage) != null ? _b2 : "",
-      closedCaption: adaptation.isClosedCaption === true,
-      id: adaptation.id,
-      label: adaptation.label,
-      forced: adaptation.isForcedSubtitles
-    };
-  }
-  function toVideoTrack(adaptation, filterPlayable) {
-    const trickModeTracks = adaptation.trickModeTracks !== void 0 ? adaptation.trickModeTracks.map((trickModeAdaptation) => {
-      const representations = (filterPlayable ? trickModeAdaptation.representations.filter(
-        (r) => r.isSupported === true && r.decipherable !== false
-      ) : trickModeAdaptation.representations).map(toVideoRepresentation);
-      const trickMode = {
-        id: trickModeAdaptation.id,
-        representations,
-        isTrickModeTrack: true
-      };
-      if (trickModeAdaptation.isSignInterpreted === true) {
-        trickMode.signInterpreted = true;
-      }
-      return trickMode;
-    }) : void 0;
-    const videoTrack = {
-      id: adaptation.id,
-      representations: (filterPlayable ? adaptation.representations.filter(
-        (r) => r.isSupported === true && r.decipherable !== false
-      ) : adaptation.representations).map(toVideoRepresentation),
-      label: adaptation.label
-    };
-    if (adaptation.isSignInterpreted === true) {
-      videoTrack.signInterpreted = true;
-    }
-    if (adaptation.isTrickModeTrack === true) {
-      videoTrack.isTrickModeTrack = true;
-    }
-    if (trickModeTracks !== void 0) {
-      videoTrack.trickModeTracks = trickModeTracks;
-    }
-    return videoTrack;
-  }
-  function toAudioRepresentation(representation) {
-    const { id, bitrate, codecs, isSpatialAudio, isSupported, decipherable } = representation;
-    return {
-      id,
-      bitrate,
-      codec: codecs == null ? void 0 : codecs[0],
-      isSpatialAudio,
-      isCodecSupported: isSupported,
-      decipherable
-    };
-  }
-  function toVideoRepresentation(representation) {
-    const {
-      id,
-      bitrate,
-      frameRate,
-      width,
-      height,
-      codecs,
-      hdrInfo,
-      isSupported,
-      decipherable,
-      contentProtections
-    } = representation;
-    return {
-      id,
-      bitrate,
-      frameRate,
-      width,
-      height,
-      codec: codecs == null ? void 0 : codecs[0],
-      hdrInfo,
-      isCodecSupported: isSupported,
-      decipherable,
-      contentProtections: contentProtections !== void 0 ? {
-        keyIds: contentProtections.keyIds
-      } : void 0
-    };
-  }
-  function toTaggedTrack(adaptation) {
-    switch (adaptation.type) {
-      case "audio":
-        return { type: "audio", track: toAudioTrack(adaptation, false) };
-      case "video":
-        return { type: "video", track: toVideoTrack(adaptation, false) };
-      case "text":
-        return { type: "text", track: toTextTrack(adaptation) };
-    }
-  }
-  function createRepresentationFilterFromFnString(fnString) {
-    return new Function(
-      `return (${fnString}(arguments[0], arguments[1]))`
-    );
-  }
-
   // src/manifest/classes/codec_support_cache.ts
   var CodecSupportCache = class {
     /**
@@ -17536,7 +17668,7 @@
     let previouslyEmittedBitrate;
     const initialRepIds = content.representations.getValue().representationIds;
     const initialRepresentations = content.adaptation.representations.filter(
-      (r) => arrayIncludes(initialRepIds, r.id) && r.decipherable !== false && r.isSupported !== false
+      (r) => arrayIncludes(initialRepIds, r.id) && r.isPlayable() !== false
     );
     const representationsList = new reference_default(
       initialRepresentations,
@@ -17702,11 +17834,11 @@
         representation
       };
       currentRepresentation.setValue(representation);
-      if (adapStreamCanceller.isUsed()) {
+      if (fnCancelSignal.isCancelled()) {
         return;
       }
       callbacks.representationChange(repInfo);
-      if (adapStreamCanceller.isUsed()) {
+      if (fnCancelSignal.isCancelled()) {
         return;
       }
       const representationStreamCallbacks = {
@@ -17784,7 +17916,7 @@
               representationStreamCallbacks.error(formattedError);
               return;
             }
-            cancellableSleep(4e3, adapStreamCanceller.signal).then(() => {
+            cancellableSleep(4e3, fnCancelSignal).then(() => {
               return createRepresentationStream(
                 representation,
                 terminateCurrentStream,
@@ -17933,7 +18065,7 @@
   }
   function hasCompatibleCodec(adaptation, segmentSinkCodec) {
     return adaptation.representations.some(
-      (rep) => rep.isSupported === true && rep.decipherable !== false && are_codecs_compatible_default(rep.getMimeTypeString(), segmentSinkCodec)
+      (rep) => rep.isPlayable() === true && are_codecs_compatible_default(rep.getMimeTypeString(), segmentSinkCodec)
     );
   }
 
@@ -18225,9 +18357,9 @@
     return segmentSinksStore.createSegmentSink(bufferType, codec);
   }
   function getFirstDeclaredMimeType(adaptation) {
-    const representations = adaptation.representations.filter((r) => {
-      return r.isSupported === true && r.decipherable !== false;
-    });
+    const representations = adaptation.representations.filter(
+      (r) => r.isPlayable() !== false
+    );
     if (representations.length === 0) {
       const noRepErr = new MediaError(
         "NO_PLAYABLE_REPRESENTATION",
@@ -20303,15 +20435,18 @@
           if (position.isAwaitingFuturePosition()) {
             playbackRateUpdater.stopRebuffering();
             log_default.debug("Init: let rebuffering happen as we're awaiting a future position");
-            this.trigger("stalled", stalledReason);
-            return;
+          } else {
+            playbackRateUpdater.startRebuffering();
           }
-          playbackRateUpdater.startRebuffering();
-          if (this._manifest === null || is_seeking_approximate_default && monotonic_timestamp_default() - rebuffering.timestamp <= 1e3) {
+          if (this._manifest === null || is_seeking_approximate_default && // Don't handle discontinuities on devices with broken seeks before
+          // enough time have passed because seeking brings more risks to
+          // lead to a lengthy rebuffering-exiting process
+          monotonic_timestamp_default() - rebuffering.timestamp <= 1e3) {
             this.trigger("stalled", stalledReason);
             return;
           }
           const { position: stalledPosition } = rebuffering;
+          const targetTime = observation.position.isAwaitingFuturePosition() ? observation.position.getWanted() : this._playbackObserver.getCurrentTime();
           if (stalledPosition !== null && stalledPosition !== void 0 && this._speed.getValue() > 0) {
             const skippableDiscontinuity = findSeekableDiscontinuity(
               discontinuitiesStore,
@@ -20320,10 +20455,10 @@
             );
             if (skippableDiscontinuity !== null) {
               const realSeekTime = skippableDiscontinuity + 1e-3;
-              if (realSeekTime <= this._playbackObserver.getCurrentTime()) {
+              if (realSeekTime <= targetTime) {
                 log_default.info(
                   "Init: position to seek already reached, no seeking",
-                  this._playbackObserver.getCurrentTime(),
+                  targetTime,
                   realSeekTime
                 );
               } else {
@@ -20348,7 +20483,7 @@
           );
           if ((!is_seeking_approximate_default || monotonic_timestamp_default() - rebuffering.timestamp > 1e3) && this._speed.getValue() > 0 && nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
             const seekTo = positionBlockedAt + nextBufferRangeGap + EPSILON2;
-            if (this._playbackObserver.getCurrentTime() < seekTo) {
+            if (targetTime < seekTo) {
               log_default.warn(
                 "Init: discontinuity encountered inferior to the threshold",
                 positionBlockedAt,
@@ -20366,7 +20501,7 @@
           for (let i = this._manifest.periods.length - 2; i >= 0; i--) {
             const period = this._manifest.periods[i];
             if (period.end !== void 0 && period.end <= positionBlockedAt) {
-              if (this._manifest.periods[i + 1].start > positionBlockedAt && this._manifest.periods[i + 1].start > this._playbackObserver.getCurrentTime()) {
+              if (this._manifest.periods[i + 1].start > positionBlockedAt && this._manifest.periods[i + 1].start > targetTime) {
                 const nextPeriod = this._manifest.periods[i + 1];
                 this._playbackObserver.setCurrentTime(nextPeriod.start);
                 this.trigger(
@@ -20410,7 +20545,7 @@
         this.start();
       }
       const observation = this._playbackObserver.getReference().getValue();
-      if (!observation.rebuffering || observation.paused || this._speed.getValue() <= 0 || bufferType !== "audio" && bufferType !== "video") {
+      if (observation.rebuffering === null || observation.paused || this._speed.getValue() <= 0 || bufferType !== "audio" && bufferType !== "video") {
         return;
       }
       const loadedPos = observation.position.getWanted();
@@ -24614,7 +24749,7 @@
           return { eotf: "hlg" };
       }
     }
-    if (codecs !== void 0 && /^vp(08|09|10)/.exec(codecs)) {
+    if (codecs !== void 0 && /^vp(08|09|10)/.test(codecs)) {
       return getWEBMHDRInformation(codecs);
     }
   }
@@ -24671,7 +24806,7 @@
       if (representation.children.supplementalProperties !== void 0 && arrayFind(
         representation.children.supplementalProperties,
         (r) => r.schemeIdUri === "tag:dolby.com,2018:dash:EC3_ExtensionType:2018" && r.value === "JOC"
-      )) {
+      ) !== void 0) {
         parsedRepresentation.isSpatialAudio = true;
       }
       let codecs;
@@ -29591,7 +29726,7 @@
           }
         }
       }
-      if (cuesBuffer.length) {
+      if (cuesBuffer.length > 0) {
         const lastCue = cuesBuffer[cuesBuffer.length - 1];
         if (areNearlyEqual(lastCue.end, start, relativeDelta)) {
           lastCue.end = start;
@@ -35319,7 +35454,7 @@ ${event}`
   }
   function getFreezingStatus(prevObservation, currentInfo, currentEvt, bufferGap) {
     const { MINIMUM_BUFFER_AMOUNT_BEFORE_FREEZING } = config_default.getCurrent();
-    if (prevObservation.freezing) {
+    if (prevObservation.freezing !== null) {
       if (currentInfo.ended || currentInfo.paused || currentInfo.readyState === 0 || currentInfo.playbackRate === 0 || prevObservation.position.getPolled() !== currentInfo.position) {
         return null;
       }
@@ -35461,9 +35596,7 @@ ${event}`
         let playableRepresentations;
         if (repSettings === null) {
           playableRepresentations = trackInfo.adaptation.representations.filter(
-            (representation) => {
-              return representation.isSupported === true && representation.decipherable !== false;
-            }
+            (representation) => isRepresentationPlayable(representation) === true
           );
           switchingMode = "lazy";
         } else {
@@ -35473,7 +35606,7 @@ ${event}`
             (r) => arrayIncludes(representationIds, r.id)
           );
           playableRepresentations = representations.filter(
-            (r) => r.isSupported === true && r.decipherable !== false
+            (representation) => isRepresentationPlayable(representation) === true
           );
           if (playableRepresentations.length === 0) {
             self2.trigger("noPlayableLockedRepresentation", null);
@@ -35749,7 +35882,7 @@ ${event}`
               return false;
             }
             const playableRepresentations = adaptation.representations.filter(
-              (r) => r.isSupported === true && r.decipherable !== false
+              (r) => isRepresentationPlayable(r) === true
             );
             return playableRepresentations.length > 0;
           }
@@ -37033,7 +37166,7 @@ ${event}`
       } = parseConstructorOptions(options);
       videoElement.preload = "auto";
       this.version = /* PLAYER_VERSION */
-      "4.3.0-dev.2024112900";
+      "4.3.0-dev.2025012900";
       this.log = log_default;
       this.state = "STOPPED";
       this.videoElement = videoElement;
@@ -37815,7 +37948,7 @@ ${event}`
      * `false` otherwise.
      */
     isPaused() {
-      if (this.videoElement) {
+      if (this.videoElement !== null) {
         if (arrayIncludes(["LOADING", "RELOADING"], this.state)) {
           return !this._priv_lastAutoPlay;
         } else {
@@ -39113,7 +39246,7 @@ ${event}`
       const tracksStore = (_b2 = this._priv_contentInfos) == null ? void 0 : _b2.tracksStore;
       if (!isNullOrUndefined(tracksStore)) {
         const periodRef = tracksStore.getPeriodObjectFromPeriod(period);
-        if (periodRef) {
+        if (periodRef !== void 0) {
           const audioTrack = tracksStore.getChosenAudioTrack(periodRef, true);
           this._priv_triggerEventIfNotStopped("audioTrackChange", audioTrack, cancelSignal);
           const textTrack = tracksStore.getChosenTextTrack(periodRef);
@@ -39574,7 +39707,7 @@ ${event}`
   _Player._priv_currentlyUsedVideoElements = /* @__PURE__ */ new WeakSet();
   var Player = _Player;
   Player.version = /* PLAYER_VERSION */
-  "4.3.0-dev.2024112900";
+  "4.3.0-dev.2025012900";
   var public_api_default = Player;
 
   // src/main_thread/api/index.ts