senza-sdk 4.4.1-daf0312.0 → 4.4.2-efcb53d.0

package/src/implementation/senzaShakaPlayer.js

@@ -1,10 +1,9 @@
 import { SenzaShakaPlayer as SenzaShakaInterface, shaka } from "../interface/senzaShakaPlayer";
-
+import * as shakaDebug from "shaka-player/dist/shaka-player.compiled.debug.js";
 import { remotePlayer, lifecycle, getPlatformInfo } from "./api";
-import { sdkLogger, iso6393to1 } from "./utils";
+import { sdkLogger } from "./utils";
 import moment from "moment";
 
-
 //  Define custom error category
 shaka.util.Error.Category.SENZA_PLAYER_ERROR = 50;
 shaka.util.Error.Code.SENZA_PLAYER_ERROR = 10500;
@@ -32,7 +31,6 @@ class SenzaError extends shaka.util.Error {
     }
 }
 
-
 export class SenzaShakaPlayer extends SenzaShakaInterface {
     /** @private {SenzaShakaPlayer|null} Previous instance of the player */
     static _prevInstance = null;
@@ -120,13 +118,27 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         },
         "pause": () => {
             this._resetPlayPromise();
-            this.remotePlayer.pause()
-                .catch(error => {
-                    sdkLogger.error("Failed to pause remote player:", error);
-                    this.handleSenzaError(error.code, error.message || "Unknown pause error");
-                });
-            // Force move to foreground when pausing as current implementation of remote player doesn't support for exapmle to do load while in background
-            lifecycle.moveToForeground();
+            if (!this._pauseForDelayedSeek) {
+                this.remotePlayer.pause()
+                    .catch(error => {
+                        sdkLogger.error("Failed to pause remote player:", error);
+                        this.handleSenzaError(error.code, error.message || "Unknown pause error");
+                    });
+                lifecycle.moveToForeground();
+            } else {
+                // in case of background seek, pause was called on local player, calling play() on local player will wait until "playing" event arrives (or timesout)
+                sdkLogger.info("senzaShakaPlayer pause Callback calling play() on local player. playing event should follow");
+                this._pauseForDelayedSeek = false;
+                this.videoElement.play();
+            }
+        },
+        "seeked": () => {
+            // In case of background seek - we need to pause the local player after "seeked" until remote player is "playing" to avoid difference between the players.
+            if (this.isInRemotePlayback) {
+                this._pauseForDelayedSeek = true;
+                sdkLogger.info("senzaShakaPlayer seeked Callback: pausing local player. play should follow");
+                this.videoElement.pause();
+            }
         }
     };
 
@@ -150,57 +162,57 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         },
         "license-request": async (event) => {
             sdkLogger.log("remotePlayer", "license-request", "Got license-request event from remote player");
+            let responseBody = "Unknown Error";
+            let status = 500;
 
-            // Extract license body from event
-            const requestBuffer = event?.detail?.licenseRequest;
-            const requestBufferStr = String.fromCharCode.apply(null, new Uint8Array(requestBuffer));
-            const decodedLicenseRequest = window.atob(requestBufferStr); // Decode from base64
-            const licenseRequestBytes = Uint8Array.from(decodedLicenseRequest, (l) => l.charCodeAt(0));
-
-            const request = {
-                body: licenseRequestBytes.buffer,
-                uris: [this.getConfiguration().drm.servers["com.widevine.alpha"]], // TODO: safe gaurd against undefined and other server types
-                method: "POST",
-                originatesFromRemotePlayer: true
-            };
+            try {
 
-            const response = await this.getNetworkingEngine().request(shaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
+                if (!this?.getConfiguration()?.drm?.servers?.["com.widevine.alpha"]) {
+                    status = 400;
+                    responseBody = "Missing Widevine license server";
+                    sdkLogger.warn("remotePlayer", "license-request", "missing Widevine license server");
+                    return; // the finally will send the response
+                }
+                // Extract license body from event
+                const requestBuffer = event?.detail?.licenseRequest;
+                if (!requestBuffer) {
+                    status = 400;
+                    responseBody = "Missing license request buffer";
+                    sdkLogger.warn("remotePlayer", "license-request", "missing license request buffer");
+                    return; // the finally will send the response
+                }
+                const requestBufferStr = String.fromCharCode.apply(null, new Uint8Array(requestBuffer));
+                const decodedLicenseRequest = window.atob(requestBufferStr); // Decode from base64
+                const licenseRequestBytes = Uint8Array.from(decodedLicenseRequest, (l) => l.charCodeAt(0));
 
-            let responseBody = response.data;
-            if (response.status < 200 || response.status >= 300) {
-                responseBody = response.data ?? String.fromCharCode(new Uint8Array(response.data));
-                sdkLogger.error("remotePlayer", "license-request", "failed to to get response from widevine:", response.status, responseBody);
-            }
-            // Write response to remote player
-            sdkLogger.log("remotePlayer", "license-request", "Writing response to remote player", response.status);
-            event.writeLicenseResponse(response.status, responseBody);
+                const request = {
+                    body: licenseRequestBytes.buffer,
+                    uris: [this.getConfiguration().drm.servers["com.widevine.alpha"]],
+                    method: "POST",
+                    originatesFromRemotePlayer: true
+                };
 
-        },
-        "tracksupdate": () => {
-            this._audioTracksMap = {};
-            this._textTracksMap = {};
-            // create a map between language code and track id to be used for selection. If the language appears more than once the last one will be taken.
-            const audioTracks = remotePlayer.getAudioTracks();
-            for (const track of audioTracks) {
-                let lang = track.lang;
-
-                if (lang.length === 3) {
-                    lang = iso6393to1[lang] || lang;
-                }
-                this._audioTracksMap[lang] = track.id;
-            }
+                const response = await this.getNetworkingEngine().request(shaka.net.NetworkingEngine.RequestType.LICENSE, request).promise;
 
-            const textTracks = remotePlayer.getTextTracks();
-            for (const track of textTracks) {
-                if (!track.autoTranslate) {
-                    let lang = track.lang;
+                responseBody = response.data;
+                status = response.status;
 
-                    if (lang.length === 3) {
-                        lang = iso6393to1[lang] || lang;
-                    }
-                    this._textTracksMap[lang] = track.id;
+                if (status < 200 || status >= 300) {
+                    responseBody = response.data ?? String.fromCharCode(new Uint8Array(response.data));
+                    sdkLogger.error("remotePlayer", "license-request", "failed to to get response from widevine:", status, responseBody);
                 }
+            } catch (error) {
+                sdkLogger.error("remotePlayer", "license-request", "License request failed:", error);
+                // For network errors, the error.data array contains [uri, status, responseText, ...]
+                status = error?.data?.[1] ?? 500;
+                responseBody = error?.data?.[2] ?? `Error response: ${error.message || error.toString()}`;
+                sdkLogger.error("remotePlayer", "license-request", "failed to get response from widevine:", status, responseBody);
+            } finally {
+                // Write response to remote player
+                sdkLogger.log("remotePlayer", "license-request", "Writing response to remote player", status);
+                event.writeLicenseResponse(status, responseBody);
             }
+
         },
         "playing": async () => {
             sdkLogger.info("remotePlayer playing event received");
@@ -348,7 +360,7 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
             this._minSuggestedPresentationDelay = uiSettings.minSuggestedPresentationDelay;
             sdkLogger.info(`Using configured minSuggestedPresentationDelay: ${this._minSuggestedPresentationDelay}s`);
         }
-
+        this._pauseForDelayedSeek = false;
         // if video element is provided, add the listeres here. In this case ,there is no need to call attach.
         if (videoElement) {
             this._attach(videoElement);
@@ -439,8 +451,6 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         }
 
         await super.detach(keepAdManager);
-        this._audioTracksMap = {};
-        this._textTracksMap = {};
         this._removeVideoElementEventListeners();
         try {
             if (remotePlayer.getAssetUri() !== "") {
@@ -470,30 +480,65 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
     }
 
     getTextLanguages() {
-        return Object.keys(this._textTracksMap);
+        const tracks = this.remotePlayer.getTextTracks();
+        return [...new Set(tracks.map(item => item.lang))];
     }
 
     getAudioLanguages() {
-        return Object.keys(this._audioTracksMap);
+        const tracks = this.remotePlayer.getAudioTracks();
+        return [...new Set(tracks.map(item => item.lang))];
+    }
+
+
+    selectVariantTrack(track, clearBuffer = false, safeMargin = 0) {
+        const audioLang = track.language;
+        const audioRole = Array.isArray(track.audioRoles) && track.audioRoles.length > 0
+            ? track.audioRoles[0]
+            : null;
+        const audioId = track.audioId;
+        sdkLogger.log(`selectVariantTrack() called: audio id ${audioId} language ${audioLang}, role ${audioRole}, accessibilityPurpose: ${track.accessibilityPurpose}`);
+
+        const apCode = this._getAccessibilityCodeFromPurpose(track.accessibilityPurpose);
+        remotePlayer.selectAudioLanguage(audioLang, audioRole, apCode);
+
+        super.selectVariantTrack(track, clearBuffer, safeMargin);
+
+    }
+
+    selectAudioTrack(audioTrack, safeMargin = 0) {
+        const audioId = audioTrack.id;
+        const audioLang = audioTrack.language;
+        const role = Array.isArray(audioTrack.roles) && audioTrack.roles.length > 0
+            ? audioTrack.roles[0]
+            : null;
+        sdkLogger.log(`selectAudioTrack() called: audio id ${audioId} language ${audioLang}, role ${role}, accessibilityPurpose: ${audioTrack.accessibilityPurpose}`);
+        const apCode = this._getAccessibilityCodeFromPurpose(audioTrack.accessibilityPurpose);
+        remotePlayer.selectAudioLanguage(audioLang, role, apCode);
+
+        super.selectAudioTrack(audioTrack, safeMargin);
     }
 
     selectAudioLanguage(language, role) {
-        sdkLogger.log("Selecting audio language:", language, "with role: ", role);
-        if (this._audioTracksMap[language]) {
-            remotePlayer.selectAudioTrack(this._audioTracksMap[language]);
-        } else {
-            sdkLogger.warn(`Language ${language} not found in audio tracks map`);
-        }
+        sdkLogger.log("selectAudioLanguage() Selecting audio language:", language, "with role: ", role);
+        remotePlayer.selectAudioLanguage(language, role);
         super.selectAudioLanguage(language, role);
     }
 
+    selectTextTrack(textTrack) {
+        const textId = textTrack.id;
+        const textLang = textTrack.language;
+        const role = Array.isArray(textTrack.roles) && textTrack.roles.length > 0
+            ? textTrack.roles[0]
+            : null;
+        sdkLogger.log(`selectTextTrack() called: text id ${textId} language ${textLang}, role ${role}, accessibilityPurpose: ${textTrack.accessibilityPurpose}`);
+        const apCode = this._getAccessibilityCodeFromPurpose(textTrack.accessibilityPurpose);
+        remotePlayer.selectTextLanguage(textLang, role, apCode);
+
+        super.selectTextTrack(textTrack);
+    }
     selectTextLanguage(language, role) {
-        sdkLogger.log("Selecting text language:", language, "with role:", role);
-        if (this._textTracksMap[language]) {
-            remotePlayer.selectTextTrack(this._textTracksMap[language]);
-        } else {
-            sdkLogger.warn(`Language ${language} not found in text tracks map`);
-        }
+        sdkLogger.log("selectTextLanguage() Selecting text language:", language, "with role: ", role);
+        remotePlayer.selectTextLanguage(language, role);
         super.selectTextLanguage(language, role);
     }
 
@@ -720,7 +765,6 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         };
 
         if (!this.isInRemotePlayback || remotePlayer.getAssetUri() !== url) {
-            this._audioTracksMap = {};
             this._videoTracksMap = {};
             try {
                 if (this.remotePlayer.getLoadMode() === this.remotePlayer.LoadMode.UNLOADING) {
@@ -775,6 +819,32 @@ export class SenzaShakaPlayer extends SenzaShakaInterface {
         }
     }
 
+    /**
+     * Returns accessibility code of Shaka's accessibility purpose string
+     * @param {string} purpose
+     * @returns {null|string}
+     * @private
+     */
+    _getAccessibilityCodeFromPurpose(purpose) {
+        switch (purpose) {
+        case shakaDebug.media.ManifestParser.AccessibilityPurpose.VISUALLY_IMPAIRED:
+            return remotePlayer.AccessibilityPurposeCode.VISUALLY_IMPAIRED;
+        case shakaDebug.media.ManifestParser.AccessibilityPurpose.HARD_OF_HEARING:
+            return remotePlayer.AccessibilityPurposeCode.HARD_OF_HEARING;
+        case shakaDebug.media.ManifestParser.AccessibilityPurpose.SPOKEN_SUBTITLES:
+            return remotePlayer.AccessibilityPurposeCode.SPOKEN_SUBTITLES;
+        case undefined:
+        case null:
+        case "":
+            return remotePlayer.AccessibilityPurposeCode.NONE;
+        default:
+            sdkLogger.warn(`_getAccessibilityCodeFromPurpose(): unknown accessibilityPurpose ${purpose}`);
+            return remotePlayer.AccessibilityPurposeCode.NONE;
+        }
+
+    }
+
+
 }
 
 shaka.Player = SenzaShakaPlayer;

package/src/implementation/utils.js

@@ -135,6 +135,24 @@ export function isSubtitlesTranslationPattern(lang) {
     return (lang?.toString() || "").startsWith("*:");
 }
 
+export function isAppVersionAboveOrEqual(appVersion, minAppVersion) {
+    const version = appVersion.replace(/-dev|-prod/g, "").replace(/^.*\//, "");
+
+    sdkLogger.info(`isAppVersionAboveOrEqual: Comparing appVersion: ${version} with minAppVersion: ${minAppVersion}`);
+    const v1Parts = version.split(".").map(num => parseInt(num, 10) || 0);
+    const v2Parts = minAppVersion.split(".").map(num => parseInt(num, 10) || 0);
+
+    const maxLength = Math.max(v1Parts.length, v2Parts.length);
+    for (let i = 0; i < maxLength; i++) {
+        const v1 = v1Parts[i] ?? 0; // default missing parts to 0
+        const v2 = v2Parts[i] ?? 0;
+        if (v1 > v2) return true; // `appVersion` is newer
+        if (v1 < v2) return false; // `appVersion` is older
+    }
+    return true; // equal.
+}
+
+
 // These StreamType constants are used as a mask for the client to play/stop the specific types
 export const StreamType = Object.freeze({
     NONE: 0,
@@ -163,209 +181,3 @@ export const TargetPlayingState = Object.freeze({
     PLAYING_UI: "playingUi",
     PLAYING_ABR: "playingAbr"
 });
-
-export const iso6393to1 = {
-    "aar": "aa",
-    "abk": "ab",
-    "afr": "af",
-    "aka": "ak",
-    "alb": "sq",
-    "amh": "am",
-    "ara": "ar",
-    "arg": "an",
-    "arm": "hy",
-    "asm": "as",
-    "ava": "av",
-    "ave": "ae",
-    "aym": "ay",
-    "aze": "az",
-    "bak": "ba",
-    "bam": "bm",
-    "baq": "eu",
-    "bel": "be",
-    "ben": "bn",
-    "bih": "bh",
-    "bis": "bi",
-    "bod": "bo",
-    "bos": "bs",
-    "bre": "br",
-    "bul": "bg",
-    "bur": "my",
-    "cat": "ca",
-    "ces": "cs",
-    "cha": "ch",
-    "che": "ce",
-    "chi": "zh",
-    "chu": "cu",
-    "chv": "cv",
-    "cor": "kw",
-    "cos": "co",
-    "cre": "cr",
-    "cym": "cy",
-    "dan": "da",
-    "deu": "de",
-    "div": "dv",
-    "dut": "nl",
-    "dzo": "dz",
-    "ell": "el",
-    "eng": "en",
-    "epo": "eo",
-    "est": "et",
-    "eus": "eu",
-    "ewe": "ee",
-    "fao": "fo",
-    "fas": "fa",
-    "fij": "fj",
-    "fin": "fi",
-    "fra": "fr",
-    "fre": "fr",
-    "fry": "fy",
-    "ful": "ff",
-    "geo": "ka",
-    "ger": "de",
-    "gla": "gd",
-    "gle": "ga",
-    "glg": "gl",
-    "glv": "gv",
-    "gre": "el",
-    "grn": "gn",
-    "guj": "gu",
-    "hat": "ht",
-    "hau": "ha",
-    "heb": "he",
-    "her": "hz",
-    "hin": "hi",
-    "hmo": "ho",
-    "hrv": "hr",
-    "hun": "hu",
-    "hye": "hy",
-    "ibo": "ig",
-    "ice": "is",
-    "ido": "io",
-    "iii": "ii",
-    "iku": "iu",
-    "ile": "ie",
-    "ina": "ia",
-    "ind": "id",
-    "ipk": "ik",
-    "isl": "is",
-    "ita": "it",
-    "jav": "jv",
-    "jpn": "ja",
-    "kal": "kl",
-    "kan": "kn",
-    "kas": "ks",
-    "kat": "ka",
-    "kau": "kr",
-    "kaz": "kk",
-    "khm": "km",
-    "kik": "ki",
-    "kin": "rw",
-    "kir": "ky",
-    "kom": "kv",
-    "kon": "kg",
-    "kor": "ko",
-    "kua": "kj",
-    "kur": "ku",
-    "lao": "lo",
-    "lat": "la",
-    "lav": "lv",
-    "lim": "li",
-    "lin": "ln",
-    "lit": "lt",
-    "ltz": "lb",
-    "lub": "lu",
-    "lug": "lg",
-    "mac": "mk",
-    "mah": "mh",
-    "mal": "ml",
-    "mao": "mi",
-    "mar": "mr",
-    "may": "ms",
-    "mkd": "mk",
-    "mlg": "mg",
-    "mlt": "mt",
-    "mon": "mn",
-    "mri": "mi",
-    "msa": "ms",
-    "mya": "my",
-    "nau": "na",
-    "nav": "nv",
-    "nbl": "nr",
-    "nde": "nd",
-    "ndo": "ng",
-    "nep": "ne",
-    "nld": "nl",
-    "nno": "nn",
-    "nob": "nb",
-    "nor": "no",
-    "nya": "ny",
-    "oci": "oc",
-    "oji": "oj",
-    "ori": "or",
-    "orm": "om",
-    "oss": "os",
-    "pan": "pa",
-    "per": "fa",
-    "pli": "pi",
-    "pol": "pl",
-    "por": "pt",
-    "pus": "ps",
-    "que": "qu",
-    "roh": "rm",
-    "ron": "ro",
-    "rum": "ro",
-    "run": "rn",
-    "rus": "ru",
-    "sag": "sg",
-    "san": "sa",
-    "sin": "si",
-    "slk": "sk",
-    "slo": "sk",
-    "slv": "sl",
-    "sme": "se",
-    "smo": "sm",
-    "sna": "sn",
-    "snd": "sd",
-    "som": "so",
-    "sot": "st",
-    "spa": "es",
-    "sqi": "sq",
-    "srd": "sc",
-    "srp": "sr",
-    "ssw": "ss",
-    "sun": "su",
-    "swa": "sw",
-    "swe": "sv",
-    "tah": "ty",
-    "tam": "ta",
-    "tat": "tt",
-    "tel": "te",
-    "tgk": "tg",
-    "tgl": "tl",
-    "tha": "th",
-    "tib": "bo",
-    "tir": "ti",
-    "ton": "to",
-    "tsn": "tn",
-    "tso": "ts",
-    "tuk": "tk",
-    "tur": "tr",
-    "twi": "tw",
-    "uig": "ug",
-    "ukr": "uk",
-    "urd": "ur",
-    "uzb": "uz",
-    "ven": "ve",
-    "vie": "vi",
-    "vol": "vo",
-    "wel": "cy",
-    "wln": "wa",
-    "wol": "wo",
-    "xho": "xh",
-    "yid": "yi",
-    "yor": "yo",
-    "zha": "za",
-    "zho": "zh",
-    "zul": "zu"
-};

package/src/interface/remotePlayer.js

@@ -217,6 +217,21 @@ class RemotePlayer extends EventTarget {
         UNLOADING: "unloading"
     });
 
+
+    /**
+     * @typedef {Object} AccessibilityPurposeCode
+     * @property {string} NONE
+     * @property {string} VISUALLY_IMPAIRED
+     * @property {string} HARD_OF_HEARING
+     * @property {string} SPOKEN_SUBTITLES
+     */
+    AccessibilityPurposeCode = {
+        NONE: "",
+        VISUALLY_IMPAIRED: "1",
+        HARD_OF_HEARING: "2",
+        SPOKEN_SUBTITLES: "9"
+    };
+
     /** get the player configuration.
      * @returns {Config}
      * */
@@ -280,8 +295,8 @@ class RemotePlayer extends EventTarget {
      * @returns {Promise}
      * @throws {RemotePlayerError} error object contains code & msg
      */
-    async play(autoPlay = false) {
-        return noop("RemotePlayer.play", autoPlay);
+    async play() {
+        return noop("RemotePlayer.play");
     }
 
     /** Pauses the currently playing audio or video
@@ -328,10 +343,13 @@ class RemotePlayer extends EventTarget {
         return this.LoadMode.NOT_LOADED;
     }
 
+
     /**
     * @typedef {Object} TextTrack
     * @property {string} id - A unique ID for the track
     * @property {string} lang - The track's language
+    * @property {string[]} roles - The track's roles
+    * @property {string=} accessibilityPurpose - The track's accessibilityPurpose code
     * @property {boolean} selected - Whether the track is selected
     * @property {boolean} autoTranslate - (Optional) Whether the track is an auto-translated language
     */
@@ -353,6 +371,8 @@ class RemotePlayer extends EventTarget {
     * @typedef {Object} AudioTrack
     * @property {string} id - A unique ID for the track
     * @property {string} lang - The track's language
+    * @property {string[]} roles - The track's roles
+    * @property {string=} accessibilityPurpose - The track's accessibilityPurpose code
     * @property {boolean} selected - Whether the track is selected
     */
     /** Get all the audio tracks.
@@ -377,10 +397,22 @@ class RemotePlayer extends EventTarget {
         return noop("RemotePlayer.selectAudioTrack", audioTrackId);
     }
 
-    /** Select a specific text (subtitle) track.
+    /** Selects an audio track based on given language, role and accessibility.
+     * Tf exact track match - Best track will be selected by the internal system
+     * @private
+     * @param {string} language - The language of the track to select.
+     * @param {string=} role - The role of the track to select.
+     * @param {AccessibilityPurposeCode=} accessibilityPurposeCode - The accessibilityPurposeCode of the track to select. Based on DASH manifest role "urn:tva:metadata:cs:AudioPurposeCS:2007"
+     * @returns {Promise<void>} A Promise that resolves once the selection process is complete.
+     **/
+    async selectAudioLanguage(language, role="", accessibilityPurposeCode=this.AccessibilityPurposeCode.NONE) {
+        return noop("RemotePlayer.selectAudioLanguage", language, role, accessibilityPurposeCode);
+    }
+
+    /** Select a text track based on given language, role and accessibility.
      * Track id should come from a call to getTextTracks.
      * If no tracks exist - this is a no-op.
-     * If the id does not match the id of any of the existing tracks - this is a no-op.
+     * Tf no tracks exist - fallback ID will be used by internal system to select best matching track.
      * @param {string} textTrackId - The ID of the text track to select.
      * @returns {Promise<void>} A Promise that resolves once the selection process is complete.
      * @throws {RemotePlayerError} If the player is not initialized or not loaded.
@@ -389,6 +421,17 @@ class RemotePlayer extends EventTarget {
         return noop("RemotePlayer.selectTextTrack", textTrackId);
     }
 
+    /** Selects a text track based on given language, role and accessibility.
+     * Tf exact track match - Best track will be selected by the internal system
+     * @private
+     * @param {string} language - The language of the track to select.
+     * @param {string=} role - The role of the track to select.
+     * @param {AccessibilityPurposeCode=} accessibilityPurposeCode - The accessibilityPurposeCode of the track to select. Based on DASH manifest role "urn:tva:metadata:cs:AudioPurposeCS:2007"
+     * @returns {Promise<void>} A Promise that resolves once the selection process is complete.
+     **/
+    async selectTextLanguage(language, role="", accessibilityPurposeCode=this.AccessibilityPurposeCode.NONE) {
+        return noop("RemotePlayer.selectTextLanguage", language, role, accessibilityPurposeCode);
+    }
     /**
      * Enable or disable the subtitles.
      * If the player is in an unloaded state, the request will be applied next time content is played.

package/src/interface/version.js

@@ -1 +1 @@
-export const version = "4.4.1-daf0312.0";
+export const version = "4.4.2-efcb53d.0";