diff --git a/.editorconfig b/.editorconfig
index 92cf9dc59..84ba69407 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -8,5 +8,5 @@ trim_trailing_whitespace = true
 insert_final_newline = true
 end_of_line = lf
 
-[json]
+[*.json]
 indent_size = 2
diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 73f40aaca..c51cd6b31 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -36,6 +36,7 @@
  - [MrTimscampi](https://github.com/MrTimscampi)
  - [Sarab Singh](https://github.com/sarab97)
  - [Andrei Oanca](https://github.com/OancaAndrei)
+ - [Cromefire_](https://github.com/cromefire)
 
 # Emby Contributors
 
diff --git a/package.json b/package.json
index 00b9f70f5..9ce8db2e4 100644
--- a/package.json
+++ b/package.json
@@ -148,6 +148,7 @@
           "src/components/prompt/prompt.js",
           "src/components/sanatizefilename.js",
           "src/components/scrollManager.js",
+          "src/plugins/htmlVideoPlayer/plugin.js",
           "src/components/search/searchfields.js",
           "src/components/search/searchresults.js",
           "src/components/settingshelper.js",
diff --git a/src/plugins/htmlVideoPlayer/plugin.js b/src/plugins/htmlVideoPlayer/plugin.js
index f9d0e1909..083a61670 100644
--- a/src/plugins/htmlVideoPlayer/plugin.js
+++ b/src/plugins/htmlVideoPlayer/plugin.js
@@ -1,15 +1,43 @@
+import browser from 'browser';
+import events from 'events';
+import appHost from 'apphost';
+import loading from 'loading';
+import dom from 'dom';
+import playbackManager from 'playbackManager';
+import appRouter from 'appRouter';
+import connectionManager from 'connectionManager';
+import {
+    bindEventsToHlsPlayer,
+    destroyHlsPlayer,
+    destroyFlvPlayer,
+    destroyCastPlayer,
+    getCrossOriginValue,
+    enableHlsJsPlayer,
+    applySrc,
+    playWithPromise,
+    onEndedInternal,
+    saveVolume,
+    seekOnPlaybackStart,
+    onErrorInternal,
+    handleHlsJsMediaError,
+    getSavedVolume,
+    isValidDuration,
+    getBufferedRanges
+} from 'htmlMediaHelper';
+import itemHelper from 'itemHelper';
+import screenfull from 'screenfull';
+import globalize from 'globalize';
 
-define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackManager', 'appRouter', 'appSettings', 'connectionManager', 'htmlMediaHelper', 'itemHelper', 'screenfull', 'globalize'], function (browser, require, events, appHost, loading, dom, playbackManager, appRouter, appSettings, connectionManager, htmlMediaHelper, itemHelper, screenfull, globalize) {
-    'use strict';
+/* eslint-disable indent */
 
-    function tryRemoveElement(elem) {
-        var parentNode = elem.parentNode;
+function tryRemoveElement(elem) {
+        const parentNode = elem.parentNode;
         if (parentNode) {
             // Seeing crashes in edge webview
             try {
                 parentNode.removeChild(elem);
             } catch (err) {
-                console.error('error removing dialog element: ' + err);
+                console.error(`error removing dialog element: ${err}`);
             }
         }
     }
@@ -22,7 +50,7 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
         }
 
         if (browser.firefox) {
-            if ((currentSrc || '').toLowerCase().indexOf('.m3u8') !== -1) {
+            if ((currentSrc || '').toLowerCase().includes('.m3u8')) {
                 return false;
             }
         }
@@ -48,7 +76,7 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
         }
 
         if (track) {
-            var format = (track.Codec || '').toLowerCase();
+            const format = (track.Codec || '').toLowerCase();
             if (format === 'ssa' || format === 'ass') {
                 return false;
             }
@@ -58,7 +86,7 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
     }
 
     function requireHlsPlayer(callback) {
-        require(['hlsjs'], function (hls) {
+        import('hlsjs').then(({default: hls}) => {
             window.Hls = hls;
             callback();
         });
@@ -84,9 +112,9 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
     }
 
     function zoomIn(elem) {
-        return new Promise(function (resolve, reject) {
-            var duration = 240;
-            elem.style.animation = 'htmlvideoplayer-zoomin ' + duration + 'ms ease-in normal';
+        return new Promise(resolve => {
+            const duration = 240;
+            elem.style.animation = `htmlvideoplayer-zoomin ${duration}ms ease-in normal`;
             hidePrePlaybackPage();
             dom.addEventListener(elem, dom.whichAnimationEvent(), resolve, {
                 once: true
@@ -95,7 +123,7 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
     }
 
     function normalizeTrackEventText(text, useHtml) {
-        var result = text.replace(/\\N/gi, '\n').replace(/\r/gi, '');
+        const result = text.replace(/\\N/gi, '\n').replace(/\r/gi, '');
         return useHtml ? result.replace(/\n/gi, '<br>') : result;
     }
 
@@ -104,7 +132,7 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             return track.Path;
         }
 
-        var url = playbackManager.getSubtitleUrl(track, item.ServerId);
+        let url = playbackManager.getSubtitleUrl(track, item.ServerId);
         if (format) {
             url = url.replace('.vtt', format);
         }
@@ -113,84 +141,189 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
     }
 
     function getDefaultProfile() {
-        return new Promise(function (resolve, reject) {
-            require(['browserdeviceprofile'], function (profileBuilder) {
-                resolve(profileBuilder({}));
-            });
+        return import('browserdeviceprofile').then(({default: profileBuilder}) => {
+            return profileBuilder({});
         });
     }
 
-    function HtmlVideoPlayer() {
-        if (browser.edgeUwp) {
-            this.name = 'Windows Video Player';
-        } else {
-            this.name = 'Html Video Player';
-        }
+    export class HtmlVideoPlayer {
+        /**
+         * @type {string}
+         */
+        name
+        /**
+         * @type {string}
+         */
+        type = 'mediaplayer';
+        /**
+         * @type {string}
+         */
+        id = 'htmlvideoplayer';
+        /**
+         * Let any players created by plugins take priority
+         *
+         * @type {number}
+         */
+        priority = 1;
+        /**
+         * @type {boolean}
+         */
+        isFetching = false;
 
-        this.type = 'mediaplayer';
-        this.id = 'htmlvideoplayer';
+        /**
+         * @type {HTMLDivElement | null | undefined}
+         */
+        #videoDialog;
+        /**
+         * @type {number | undefined}
+         */
+        #subtitleTrackIndexToSetOnPlaying;
+        /**
+         * @type {number | null}
+         */
+        #audioTrackIndexToSetOnPlaying;
+        /**
+         * @type {null | undefined}
+         */
+        #currentClock;
+        /**
+         * @type {any | null | undefined}
+         */
+        #currentSubtitlesOctopus;
+        /**
+         * @type {null | undefined}
+         */
+        #currentAssRenderer;
+        /**
+         * @type {number | undefined}
+         */
+        #customTrackIndex;
+        /**
+         * @type {boolean | undefined}
+         */
+        #showTrackOffset;
+        /**
+         * @type {number | undefined}
+         */
+        #currentTrackOffset;
+        /**
+         * @type {HTMLElement | null | undefined}
+         */
+        #videoSubtitlesElem;
+        /**
+         * @type {any | null | undefined}
+         */
+        #currentTrackEvents;
+        /**
+         * @type {string[] | undefined}
+         */
+        #supportedFeatures;
+        /**
+         * @type {HTMLVideoElement | null | undefined}
+         */
+        #mediaElement;
+        /**
+         * @type {number}
+         */
+        #fetchQueue = 0;
+        /**
+         * @type {string | undefined}
+         */
+        #currentSrc;
+        /**
+         * @type {boolean | undefined}
+         */
+        #started;
+        /**
+         * @type {boolean | undefined}
+         */
+        #timeUpdated;
+        /**
+         * @type {number | null | undefined}
+         */
+        #currentTime;
+        /**
+         * @type {any | undefined}
+         */
+        #flvPlayer;
+        /**
+         * @private (used in other files)
+         * @type {any | undefined}
+         */
+        _hlsPlayer;
+        /**
+         * @private (used in other files)
+         * @type {any | null | undefined}
+         */
+        _castPlayer;
+        /**
+         * @private (used in other files)
+         * @type {any | undefined}
+         */
+        _currentPlayOptions;
+        /**
+         * @type {any | undefined}
+         */
+        #lastProfile;
+        /**
+         * @type {MutationObserver | IntersectionObserver | undefined} (Unclear observer typing)
+         */
+        #resizeObserver;
 
-        // Let any players created by plugins take priority
-        this.priority = 1;
-
-        var videoDialog;
-
-        var subtitleTrackIndexToSetOnPlaying;
-        var audioTrackIndexToSetOnPlaying;
-
-        var currentClock;
-        var currentSubtitlesOctopus;
-        var currentAssRenderer;
-        var customTrackIndex = -1;
-
-        var showTrackOffset;
-        var currentTrackOffset;
-
-        var videoSubtitlesElem;
-        var currentTrackEvents;
-
-        var self = this;
-
-        self.currentSrc = function () {
-            return self._currentSrc;
-        };
-
-        self._fetchQueue = 0;
-        self.isFetching = false;
-
-        function incrementFetchQueue() {
-            if (self._fetchQueue <= 0) {
-                self.isFetching = true;
-                events.trigger(self, 'beginFetch');
-            }
-
-            self._fetchQueue++;
-        }
-
-        function decrementFetchQueue() {
-            self._fetchQueue--;
-
-            if (self._fetchQueue <= 0) {
-                self.isFetching = false;
-                events.trigger(self, 'endFetch');
+        constructor() {
+            if (browser.edgeUwp) {
+                this.name = 'Windows Video Player';
+            } else {
+                this.name = 'Html Video Player';
             }
         }
 
-        function updateVideoUrl(streamInfo) {
-            var isHls = streamInfo.url.toLowerCase().indexOf('.m3u8') !== -1;
+        currentSrc() {
+            return this.#currentSrc;
+        }
 
-            var mediaSource = streamInfo.mediaSource;
-            var item = streamInfo.item;
+        /**
+         * @private
+         */
+        incrementFetchQueue() {
+            if (this.#fetchQueue <= 0) {
+                this.isFetching = true;
+                events.trigger(this, 'beginFetch');
+            }
+
+            this.#fetchQueue++;
+        }
+
+        /**
+         * @private
+         */
+        decrementFetchQueue() {
+            this.#fetchQueue--;
+
+            if (this.#fetchQueue <= 0) {
+                this.isFetching = false;
+                events.trigger(this, 'endFetch');
+            }
+        }
+
+        /**
+         * @private
+         */
+        updateVideoUrl(streamInfo) {
+            const isHls = streamInfo.url.toLowerCase().includes('.m3u8');
+
+            const mediaSource = streamInfo.mediaSource;
+            const item = streamInfo.item;
 
             // Huge hack alert. Safari doesn't seem to like if the segments aren't available right away when playback starts
             // This will start the transcoding process before actually feeding the video url into the player
             // Edit: Also seeing stalls from hls.js
             if (mediaSource && item && !mediaSource.RunTimeTicks && isHls && streamInfo.playMethod === 'Transcode' && (browser.iOS || browser.osx)) {
-                var hlsPlaylistUrl = streamInfo.url.replace('master.m3u8', 'live.m3u8');
+                const hlsPlaylistUrl = streamInfo.url.replace('master.m3u8', 'live.m3u8');
 
                 loading.show();
 
-                console.debug('prefetching hls playlist: ' + hlsPlaylistUrl);
+                console.debug(`prefetching hls playlist: ${hlsPlaylistUrl}`);
 
                 return connectionManager.getApiClient(item.ServerId).ajax({
 
@@ -198,42 +331,41 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                     url: hlsPlaylistUrl
 
                 }).then(function () {
-                    console.debug('completed prefetching hls playlist: ' + hlsPlaylistUrl);
+                    console.debug(`completed prefetching hls playlist: ${hlsPlaylistUrl}`);
 
                     loading.hide();
                     streamInfo.url = hlsPlaylistUrl;
-
-                    return Promise.resolve();
                 }, function () {
-                    console.error('error prefetching hls playlist: ' + hlsPlaylistUrl);
+                    console.error(`error prefetching hls playlist: ${hlsPlaylistUrl}`);
 
                     loading.hide();
-                    return Promise.resolve();
                 });
             } else {
                 return Promise.resolve();
             }
         }
 
-        self.play = function (options) {
-            self._started = false;
-            self._timeUpdated = false;
+        play(options) {
+            this.#started = false;
+            this.#timeUpdated = false;
 
-            self._currentTime = null;
+            this.#currentTime = null;
 
-            self.resetSubtitleOffset();
+            this.resetSubtitleOffset();
 
-            return createMediaElement(options).then(function (elem) {
-                return updateVideoUrl(options).then(function () {
-                    return setCurrentSrc(elem, options);
+            return this.createMediaElement(options).then(elem => {
+                return this.updateVideoUrl(options).then(() => {
+                    return this.setCurrentSrc(elem, options);
                 });
             });
-        };
+        }
 
-        function setSrcWithFlvJs(instance, elem, options, url) {
-            return new Promise(function (resolve, reject) {
-                require(['flvjs'], function (flvjs) {
-                    var flvPlayer = flvjs.createPlayer({
+        /**
+         * @private
+         */
+        setSrcWithFlvJs(elem, options, url) {
+            return import('flvjs').then(({default: flvjs}) => {
+                const flvPlayer = flvjs.createPlayer({
                         type: 'flv',
                         url: url
                     },
@@ -242,117 +374,126 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                         lazyLoad: false
                     });
 
-                    flvPlayer.attachMediaElement(elem);
-                    flvPlayer.load();
+                flvPlayer.attachMediaElement(elem);
+                flvPlayer.load();
 
-                    flvPlayer.play().then(resolve, reject);
-                    instance._flvPlayer = flvPlayer;
+                this.#flvPlayer = flvPlayer;
 
-                    // This is needed in setCurrentTrackElement
-                    self._currentSrc = url;
-                });
+                // This is needed in setCurrentTrackElement
+                this.#currentSrc = url;
+
+                return flvPlayer.play();
             });
         }
 
-        function setSrcWithHlsJs(instance, elem, options, url) {
-            return new Promise(function (resolve, reject) {
-                requireHlsPlayer(function () {
-                    var hls = new Hls({
+        /**
+         * @private
+         */
+        setSrcWithHlsJs(elem, options, url) {
+            return new Promise((resolve, reject) => {
+                requireHlsPlayer(() => {
+                    const hls = new Hls({
                         manifestLoadingTimeOut: 20000,
-                        xhrSetup: function(xhr, xhr_url) {
+                        xhrSetup(xhr) {
                             xhr.withCredentials = true;
                         }
                     });
                     hls.loadSource(url);
                     hls.attachMedia(elem);
 
-                    htmlMediaHelper.bindEventsToHlsPlayer(self, hls, elem, onError, resolve, reject);
+                    bindEventsToHlsPlayer(this, hls, elem, this.onError, resolve, reject);
 
-                    self._hlsPlayer = hls;
+                    this._hlsPlayer = hls;
 
                     // This is needed in setCurrentTrackElement
-                    self._currentSrc = url;
+                    this.#currentSrc = url;
                 });
             });
         }
 
-        function setCurrentSrc(elem, options) {
-            elem.removeEventListener('error', onError);
+        /**
+         * @private
+         */
+        setCurrentSrc(elem, options) {
+            elem.removeEventListener('error', this.onError);
 
-            var val = options.url;
-            console.debug('playing url: ' + val);
+            let val = options.url;
+            console.debug(`playing url: ${val}`);
 
             // Convert to seconds
-            var seconds = (options.playerStartPositionTicks || 0) / 10000000;
+            const seconds = (options.playerStartPositionTicks || 0) / 10000000;
             if (seconds) {
-                val += '#t=' + seconds;
+                val += `#t=${seconds}`;
             }
 
-            htmlMediaHelper.destroyHlsPlayer(self);
-            htmlMediaHelper.destroyFlvPlayer(self);
-            htmlMediaHelper.destroyCastPlayer(self);
+            destroyHlsPlayer(this);
+            destroyFlvPlayer(this);
+            destroyCastPlayer(this);
 
-            subtitleTrackIndexToSetOnPlaying = options.mediaSource.DefaultSubtitleStreamIndex == null ? -1 : options.mediaSource.DefaultSubtitleStreamIndex;
-            if (subtitleTrackIndexToSetOnPlaying != null && subtitleTrackIndexToSetOnPlaying >= 0) {
-                var initialSubtitleStream = options.mediaSource.MediaStreams[subtitleTrackIndexToSetOnPlaying];
+            this.#subtitleTrackIndexToSetOnPlaying = options.mediaSource.DefaultSubtitleStreamIndex == null ? -1 : options.mediaSource.DefaultSubtitleStreamIndex;
+            if (this.#subtitleTrackIndexToSetOnPlaying != null && this.#subtitleTrackIndexToSetOnPlaying >= 0) {
+                const initialSubtitleStream = options.mediaSource.MediaStreams[this.#subtitleTrackIndexToSetOnPlaying];
                 if (!initialSubtitleStream || initialSubtitleStream.DeliveryMethod === 'Encode') {
-                    subtitleTrackIndexToSetOnPlaying = -1;
+                    this.#subtitleTrackIndexToSetOnPlaying = -1;
                 }
             }
 
-            audioTrackIndexToSetOnPlaying = options.playMethod === 'Transcode' ? null : options.mediaSource.DefaultAudioStreamIndex;
+            this.#audioTrackIndexToSetOnPlaying = options.playMethod === 'Transcode' ? null : options.mediaSource.DefaultAudioStreamIndex;
 
-            self._currentPlayOptions = options;
+            this._currentPlayOptions = options;
 
-            var crossOrigin = htmlMediaHelper.getCrossOriginValue(options.mediaSource);
+            const crossOrigin = getCrossOriginValue(options.mediaSource);
             if (crossOrigin) {
                 elem.crossOrigin = crossOrigin;
             }
 
-            if (htmlMediaHelper.enableHlsJsPlayer(options.mediaSource.RunTimeTicks, 'Video') && val.indexOf('.m3u8') !== -1) {
-                return setSrcWithHlsJs(self, elem, options, val);
+            if (enableHlsJsPlayer(options.mediaSource.RunTimeTicks, 'Video') && val.includes('.m3u8')) {
+                return this.setSrcWithHlsJs(elem, options, val);
             } else if (options.playMethod !== 'Transcode' && options.mediaSource.Container === 'flv') {
-                return setSrcWithFlvJs(self, elem, options, val);
+                return this.setSrcWithFlvJs(elem, options, val);
             } else {
                 elem.autoplay = true;
 
                 // Safari will not send cookies without this
                 elem.crossOrigin = 'use-credentials';
 
-                return htmlMediaHelper.applySrc(elem, val, options).then(function () {
-                    self._currentSrc = val;
+                return applySrc(elem, val, options).then(() => {
+                    this.#currentSrc = val;
 
-                    return htmlMediaHelper.playWithPromise(elem, onError);
+                    return playWithPromise(elem, this.onError);
                 });
             }
         }
 
-        self.setSubtitleStreamIndex = function (index) {
-            setCurrentTrackElement(index);
-        };
+        setSubtitleStreamIndex(index) {
+            this.setCurrentTrackElement(index);
+        }
 
-        self.resetSubtitleOffset = function() {
-            currentTrackOffset = 0;
-            showTrackOffset = false;
-        };
+        resetSubtitleOffset() {
+            this.#currentTrackOffset = 0;
+            this.#showTrackOffset = false;
+        }
 
-        self.enableShowingSubtitleOffset = function() {
-            showTrackOffset = true;
-        };
+        enableShowingSubtitleOffset() {
+            this.#showTrackOffset = true;
+        }
 
-        self.disableShowingSubtitleOffset = function() {
-            showTrackOffset = false;
-        };
+        disableShowingSubtitleOffset() {
+            this.#showTrackOffset = false;
+        }
 
-        self.isShowingSubtitleOffsetEnabled = function() {
-            return showTrackOffset;
-        };
+        isShowingSubtitleOffsetEnabled() {
+            return this.#showTrackOffset;
+        }
 
-        function getTextTrack() {
-            var videoElement = self._mediaElement;
+        /**
+         * @private
+         */
+        getTextTrack() {
+            const videoElement = this.#mediaElement;
             if (videoElement) {
                 return Array.from(videoElement.textTracks)
-                    .find(function(trackElement) {
+                    .find(function (trackElement) {
                         // get showing .vtt textTack
                         return trackElement.mode === 'showing';
                     });
@@ -361,64 +502,79 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             }
         }
 
-        self.setSubtitleOffset = function(offset) {
-            var offsetValue = parseFloat(offset);
+        /**
+         * @private
+         */
+        setSubtitleOffset(offset) {
+            const offsetValue = parseFloat(offset);
 
             // if .ass currently rendering
-            if (currentSubtitlesOctopus) {
-                updateCurrentTrackOffset(offsetValue);
-                currentSubtitlesOctopus.timeOffset = (self._currentPlayOptions.transcodingOffsetTicks || 0) / 10000000 + offsetValue;
+            if (this.#currentSubtitlesOctopus) {
+                this.updateCurrentTrackOffset(offsetValue);
+                this.#currentSubtitlesOctopus.timeOffset = (this._currentPlayOptions.transcodingOffsetTicks || 0) / 10000000 + offsetValue;
             } else {
-                var trackElement = getTextTrack();
+                const trackElement = this.getTextTrack();
                 // if .vtt currently rendering
                 if (trackElement) {
-                    setTextTrackSubtitleOffset(trackElement, offsetValue);
-                } else if (currentTrackEvents) {
-                    setTrackEventsSubtitleOffset(currentTrackEvents, offsetValue);
+                    this.setTextTrackSubtitleOffset(trackElement, offsetValue);
+                } else if (this.#currentTrackEvents) {
+                    this.setTrackEventsSubtitleOffset(this.#currentTrackEvents, offsetValue);
                 } else {
                     console.debug('No available track, cannot apply offset: ', offsetValue);
                 }
             }
-        };
+        }
 
-        function updateCurrentTrackOffset(offsetValue) {
-            var relativeOffset = offsetValue;
-            var newTrackOffset = offsetValue;
-            if (currentTrackOffset) {
-                relativeOffset -= currentTrackOffset;
+        /**
+         * @private
+         */
+        updateCurrentTrackOffset(offsetValue) {
+            let relativeOffset = offsetValue;
+            const newTrackOffset = offsetValue;
+            if (this.#currentTrackOffset) {
+                relativeOffset -= this.#currentTrackOffset;
             }
-            currentTrackOffset = newTrackOffset;
+            this.#currentTrackOffset = newTrackOffset;
             // relative to currentTrackOffset
             return relativeOffset;
         }
 
-        function setTextTrackSubtitleOffset(currentTrack, offsetValue) {
+        /**
+         * @private
+         */
+        setTextTrackSubtitleOffset(currentTrack, offsetValue) {
             if (currentTrack.cues) {
-                offsetValue = updateCurrentTrackOffset(offsetValue);
+                offsetValue = this.updateCurrentTrackOffset(offsetValue);
                 Array.from(currentTrack.cues)
-                    .forEach(function(cue) {
+                    .forEach(function (cue) {
                         cue.startTime -= offsetValue;
                         cue.endTime -= offsetValue;
                     });
             }
         }
 
-        function setTrackEventsSubtitleOffset(trackEvents, offsetValue) {
+        /**
+         * @private
+         */
+        setTrackEventsSubtitleOffset(trackEvents, offsetValue) {
             if (Array.isArray(trackEvents)) {
-                offsetValue = updateCurrentTrackOffset(offsetValue) * 1e7; // ticks
-                trackEvents.forEach(function(trackEvent) {
+                offsetValue = this.updateCurrentTrackOffset(offsetValue) * 1e7; // ticks
+                trackEvents.forEach(function (trackEvent) {
                     trackEvent.StartPositionTicks -= offsetValue;
                     trackEvent.EndPositionTicks -= offsetValue;
                 });
             }
         }
 
-        self.getSubtitleOffset = function() {
-            return currentTrackOffset;
-        };
+        getSubtitleOffset() {
+            return this.#currentTrackOffset;
+        }
 
-        function isAudioStreamSupported(stream, deviceProfile) {
-            var codec = (stream.Codec || '').toLowerCase();
+        /**
+         * @private
+         */
+        isAudioStreamSupported(stream, deviceProfile) {
+            const codec = (stream.Codec || '').toLowerCase();
 
             if (!codec) {
                 return true;
@@ -429,7 +585,7 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                 return true;
             }
 
-            var profiles = deviceProfile.DirectPlayProfiles || [];
+            const profiles = deviceProfile.DirectPlayProfiles || [];
 
             return profiles.filter(function (p) {
                 if (p.Type === 'Video') {
@@ -437,37 +593,35 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                         return true;
                     }
 
-                    return p.AudioCodec.toLowerCase().indexOf(codec) !== -1;
+                    return p.AudioCodec.toLowerCase().includes(codec);
                 }
 
                 return false;
             }).length > 0;
         }
 
-        function getSupportedAudioStreams() {
-            var profile = self._lastProfile;
+        /**
+         * @private
+         */
+        getSupportedAudioStreams() {
+            const profile = this.#lastProfile;
 
-            return getMediaStreamAudioTracks(self._currentPlayOptions.mediaSource).filter(function (stream) {
-                return isAudioStreamSupported(stream, profile);
+            return getMediaStreamAudioTracks(this._currentPlayOptions.mediaSource).filter((stream) => {
+                return this.isAudioStreamSupported(stream, profile);
             });
         }
 
-        self.setAudioStreamIndex = function (index) {
-            var streams = getSupportedAudioStreams();
+        setAudioStreamIndex(index) {
+            const streams = this.getSupportedAudioStreams();
 
             if (streams.length < 2) {
                 // If there's only one supported stream then trust that the player will handle it on it's own
                 return;
             }
 
-            var audioIndex = -1;
-            var i;
-            var length;
-            var stream;
-
-            for (i = 0, length = streams.length; i < length; i++) {
-                stream = streams[i];
+            let audioIndex = -1;
 
+            for (const stream of streams) {
                 audioIndex++;
 
                 if (stream.Index === index) {
@@ -479,76 +633,79 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                 return;
             }
 
-            var elem = self._mediaElement;
+            const elem = this.#mediaElement;
             if (!elem) {
                 return;
             }
 
-            // https://msdn.microsoft.com/en-us/library/hh772507(v=vs.85).aspx
+            // https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/audioTracks
 
-            var elemAudioTracks = elem.audioTracks || [];
-            console.debug('found ' + elemAudioTracks.length + ' audio tracks');
+            /**
+             * @type {ArrayLike<any>|any[]}
+             */
+            const elemAudioTracks = elem.audioTracks || [];
+            console.debug(`found ${elemAudioTracks.length} audio tracks`);
 
-            for (i = 0, length = elemAudioTracks.length; i < length; i++) {
+            for (const [i, audioTrack] of Array.from(elemAudioTracks).entries()) {
                 if (audioIndex === i) {
-                    console.debug('setting audio track ' + i + ' to enabled');
-                    elemAudioTracks[i].enabled = true;
+                    console.debug(`setting audio track ${i} to enabled`);
+                    audioTrack.enabled = true;
                 } else {
-                    console.debug('setting audio track ' + i + ' to disabled');
-                    elemAudioTracks[i].enabled = false;
+                    console.debug(`setting audio track ${i} to disabled`);
+                    audioTrack.enabled = false;
                 }
             }
-        };
+        }
 
-        self.stop = function (destroyPlayer) {
-            var elem = self._mediaElement;
-            var src = self._currentSrc;
+        stop(destroyPlayer) {
+            const elem = this.#mediaElement;
+            const src = this.#currentSrc;
 
             if (elem) {
                 if (src) {
                     elem.pause();
                 }
 
-                htmlMediaHelper.onEndedInternal(self, elem, onError);
+                onEndedInternal(this, elem, this.onError);
 
                 if (destroyPlayer) {
-                    self.destroy();
+                    this.destroy();
                 }
             }
 
-            destroyCustomTrack(elem);
+            this.destroyCustomTrack(elem);
 
             return Promise.resolve();
-        };
+        }
 
-        self.destroy = function () {
-            htmlMediaHelper.destroyHlsPlayer(self);
-            htmlMediaHelper.destroyFlvPlayer(self);
+        destroy() {
+            destroyHlsPlayer(this);
+            destroyFlvPlayer(this);
 
             appRouter.setTransparency('none');
 
-            var videoElement = self._mediaElement;
+            const videoElement = this.#mediaElement;
 
             if (videoElement) {
-                self._mediaElement = null;
+                this.#mediaElement = null;
 
-                destroyCustomTrack(videoElement);
-                videoElement.removeEventListener('timeupdate', onTimeUpdate);
-                videoElement.removeEventListener('ended', onEnded);
-                videoElement.removeEventListener('volumechange', onVolumeChange);
-                videoElement.removeEventListener('pause', onPause);
-                videoElement.removeEventListener('playing', onPlaying);
-                videoElement.removeEventListener('play', onPlay);
-                videoElement.removeEventListener('click', onClick);
-                videoElement.removeEventListener('dblclick', onDblClick);
-                videoElement.removeEventListener('waiting', onWaiting);
+                this.destroyCustomTrack(videoElement);
+                videoElement.removeEventListener('timeupdate', this.onTimeUpdate);
+                videoElement.removeEventListener('ended', this.onEnded);
+                videoElement.removeEventListener('volumechange', this.onVolumeChange);
+                videoElement.removeEventListener('pause', this.onPause);
+                videoElement.removeEventListener('playing', this.onPlaying);
+                videoElement.removeEventListener('play', this.onPlay);
+                videoElement.removeEventListener('click', this.onClick);
+                videoElement.removeEventListener('dblclick', this.onDblClick);
+                videoElement.removeEventListener('waiting', this.onWaiting);
 
                 videoElement.parentNode.removeChild(videoElement);
             }
 
-            var dlg = videoDialog;
+            const dlg = this.#videoDialog;
             if (dlg) {
-                videoDialog = null;
+                this.#videoDialog = null;
                 dlg.parentNode.removeChild(dlg);
             }
 
@@ -560,128 +717,188 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                     document.webkitCancelFullscreen();
                 }
             }
-        };
-
-        function onEnded() {
-            destroyCustomTrack(this);
-            htmlMediaHelper.onEndedInternal(self, this, onError);
         }
 
-        function onTimeUpdate(e) {
-            // get the player position and the transcoding offset
-            var time = this.currentTime;
+        /**
+         * @private
+         * @param e {Event} The event received from the `<video>` element
+         */
+        onEnded = (e) => {
+            /**
+             * @type {HTMLMediaElement}
+             */
+            const elem = e.target;
+            this.destroyCustomTrack(elem);
+            onEndedInternal(this, elem, this.onError);
+        }
 
-            if (time && !self._timeUpdated) {
-                self._timeUpdated = true;
-                ensureValidVideo(this);
+        /**
+         * @private
+         * @param e {Event} The event received from the `<video>` element
+         */
+        onTimeUpdate = (e) => {
+            /**
+             * @type {HTMLMediaElement}
+             */
+            const elem = e.target;
+            // get the player position and the transcoding offset
+            const time = elem.currentTime;
+
+            if (time && !this.#timeUpdated) {
+                this.#timeUpdated = true;
+                this.ensureValidVideo(elem);
             }
 
-            self._currentTime = time;
+            this.#currentTime = time;
 
-            var currentPlayOptions = self._currentPlayOptions;
+            const currentPlayOptions = this._currentPlayOptions;
             // Not sure yet how this is coming up null since we never null it out, but it is causing app crashes
             if (currentPlayOptions) {
-                var timeMs = time * 1000;
+                let timeMs = time * 1000;
                 timeMs += ((currentPlayOptions.transcodingOffsetTicks || 0) / 10000);
-                updateSubtitleText(timeMs);
+                this.updateSubtitleText(timeMs);
             }
 
-            events.trigger(self, 'timeupdate');
+            events.trigger(this, 'timeupdate');
         }
 
-        function onVolumeChange() {
-            htmlMediaHelper.saveVolume(this.volume);
-            events.trigger(self, 'volumechange');
+        /**
+         * @private
+         * @param e {Event} The event received from the `<video>` element
+         */
+        onVolumeChange = (e) => {
+            /**
+             * @type {HTMLMediaElement}
+             */
+            const elem = e.target;
+            saveVolume(elem.volume);
+            events.trigger(this, 'volumechange');
         }
 
-        function onNavigatedToOsd() {
-            var dlg = videoDialog;
+        /**
+         * @private
+         */
+        onNavigatedToOsd = () => {
+            const dlg = this.#videoDialog;
             if (dlg) {
                 dlg.classList.remove('videoPlayerContainer-onTop');
 
-                onStartedAndNavigatedToOsd();
+                this.onStartedAndNavigatedToOsd();
             }
         }
 
-        function onStartedAndNavigatedToOsd() {
+        /**
+         * @private
+         */
+        onStartedAndNavigatedToOsd() {
             // If this causes a failure during navigation we end up in an awkward UI state
-            setCurrentTrackElement(subtitleTrackIndexToSetOnPlaying);
+            this.setCurrentTrackElement(this.#subtitleTrackIndexToSetOnPlaying);
 
-            if (audioTrackIndexToSetOnPlaying != null && self.canSetAudioStreamIndex()) {
-                self.setAudioStreamIndex(audioTrackIndexToSetOnPlaying);
+            if (this.#audioTrackIndexToSetOnPlaying != null && this.canSetAudioStreamIndex()) {
+                this.setAudioStreamIndex(this.#audioTrackIndexToSetOnPlaying);
             }
         }
 
-        function onPlaying(e) {
-            if (!self._started) {
-                self._started = true;
-                this.removeAttribute('controls');
+        /**
+         * @private
+         * @param e {Event} The event received from the `<video>` element
+         */
+        onPlaying = (e) => {
+            /**
+             * @type {HTMLMediaElement}
+             */
+            const elem = e.target;
+            if (!this.#started) {
+                this.#started = true;
+                elem.removeAttribute('controls');
 
                 loading.hide();
 
-                htmlMediaHelper.seekOnPlaybackStart(self, e.target, self._currentPlayOptions.playerStartPositionTicks, function () {
-                    if (currentSubtitlesOctopus) {
-                        currentSubtitlesOctopus.timeOffset = (self._currentPlayOptions.transcodingOffsetTicks || 0) / 10000000 + currentTrackOffset;
-                        currentSubtitlesOctopus.resize();
-                        currentSubtitlesOctopus.resetRenderAheadCache(false);
+                seekOnPlaybackStart(this, e.target, this._currentPlayOptions.playerStartPositionTicks, () => {
+                    if (this.#currentSubtitlesOctopus) {
+                        this.#currentSubtitlesOctopus.timeOffset = (this._currentPlayOptions.transcodingOffsetTicks || 0) / 10000000 + this.#currentTrackOffset;
+                        this.#currentSubtitlesOctopus.resize();
+                        this.#currentSubtitlesOctopus.resetRenderAheadCache(false);
                     }
                 });
 
-                if (self._currentPlayOptions.fullscreen) {
-                    appRouter.showVideoOsd().then(onNavigatedToOsd);
+                if (this._currentPlayOptions.fullscreen) {
+                    appRouter.showVideoOsd().then(this.onNavigatedToOsd);
                 } else {
                     appRouter.setTransparency('backdrop');
-                    videoDialog.classList.remove('videoPlayerContainer-onTop');
+                    this.#videoDialog.classList.remove('videoPlayerContainer-onTop');
 
-                    onStartedAndNavigatedToOsd();
+                    this.onStartedAndNavigatedToOsd();
                 }
             }
-            events.trigger(self, 'playing');
+            events.trigger(this, 'playing');
         }
 
-        function onPlay(e) {
-            events.trigger(self, 'unpause');
+        /**
+         * @private
+         */
+        onPlay = () => {
+            events.trigger(this, 'unpause');
         }
 
-        function ensureValidVideo(elem) {
-            if (elem !== self._mediaElement) {
+        /**
+         * @private
+         */
+        ensureValidVideo(elem) {
+            if (elem !== this.#mediaElement) {
                 return;
             }
 
             if (elem.videoWidth === 0 && elem.videoHeight === 0) {
-                var mediaSource = (self._currentPlayOptions || {}).mediaSource;
+                const mediaSource = (this._currentPlayOptions || {}).mediaSource;
 
                 // Only trigger this if there is media info
                 // Avoid triggering in situations where it might not actually have a video stream (audio only live tv channel)
                 if (!mediaSource || mediaSource.RunTimeTicks) {
-                    htmlMediaHelper.onErrorInternal(self, 'mediadecodeerror');
-                    return;
+                    onErrorInternal(this, 'mediadecodeerror');
                 }
             }
         }
 
-        function onClick() {
-            events.trigger(self, 'click');
+        /**
+         * @private
+         */
+        onClick = () => {
+            events.trigger(this, 'click');
         }
 
-        function onDblClick() {
-            events.trigger(self, 'dblclick');
+        /**
+         * @private
+         */
+        onDblClick = () => {
+            events.trigger(this, 'dblclick');
         }
 
-        function onPause() {
-            events.trigger(self, 'pause');
+        /**
+         * @private
+         */
+        onPause = () => {
+            events.trigger(this, 'pause');
         }
 
-        function onWaiting() {
-            events.trigger(self, 'waiting');
+        onWaiting() {
+            events.trigger(this, 'waiting');
         }
 
-        function onError() {
-            var errorCode = this.error ? (this.error.code || 0) : 0;
-            var errorMessage = this.error ? (this.error.message || '') : '';
-            console.error('media element error: ' + errorCode.toString() + ' ' + errorMessage);
+        /**
+         * @private
+         * @param e {Event} The event received from the `<video>` element
+         */
+        onError = (e) => {
+            /**
+             * @type {HTMLMediaElement}
+             */
+            const elem = e.target;
+            const errorCode = elem.error ? (elem.error.code || 0) : 0;
+            const errorMessage = elem.error ? (elem.error.message || '') : '';
+            console.error(`media element error: ${errorCode} ${errorMessage}`);
 
-            var type;
+            let type;
 
             switch (errorCode) {
                 case 1:
@@ -694,8 +911,8 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                     break;
                 case 3:
                     // MEDIA_ERR_DECODE
-                    if (self._hlsPlayer) {
-                        htmlMediaHelper.handleHlsJsMediaError(self);
+                    if (this._hlsPlayer) {
+                        handleHlsJsMediaError(this);
                         return;
                     } else {
                         type = 'mediadecodeerror';
@@ -711,124 +928,128 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                     return;
             }
 
-            htmlMediaHelper.onErrorInternal(self, type);
+            onErrorInternal(this, type);
         }
 
-        function destroyCustomTrack(videoElement) {
-            if (self._resizeObserver) {
-                self._resizeObserver.disconnect();
-                self._resizeObserver = null;
+        /**
+         * @private
+         */
+        destroyCustomTrack(videoElement) {
+            if (this.#resizeObserver) {
+                this.#resizeObserver.disconnect();
+                this.#resizeObserver = null;
             }
 
-            if (videoSubtitlesElem) {
-                var subtitlesContainer = videoSubtitlesElem.parentNode;
+            if (this.#videoSubtitlesElem) {
+                const subtitlesContainer = this.#videoSubtitlesElem.parentNode;
                 if (subtitlesContainer) {
                     tryRemoveElement(subtitlesContainer);
                 }
-                videoSubtitlesElem = null;
+                this.#videoSubtitlesElem = null;
             }
 
-            currentTrackEvents = null;
+            this.#currentTrackEvents = null;
 
             if (videoElement) {
-                var allTracks = videoElement.textTracks || []; // get list of tracks
-                for (var i = 0; i < allTracks.length; i++) {
-                    var currentTrack = allTracks[i];
-
-                    if (currentTrack.label.indexOf('manualTrack') !== -1) {
-                        currentTrack.mode = 'disabled';
+                const allTracks = videoElement.textTracks || []; // get list of tracks
+                for (const track of allTracks) {
+                    if (track.label.includes('manualTrack')) {
+                        track.mode = 'disabled';
                     }
                 }
             }
 
-            customTrackIndex = -1;
-            currentClock = null;
-            self._currentAspectRatio = null;
+            this.#customTrackIndex = -1;
+            this.#currentClock = null;
+            this._currentAspectRatio = null;
 
-            var octopus = currentSubtitlesOctopus;
+            const octopus = this.#currentSubtitlesOctopus;
             if (octopus) {
                 octopus.dispose();
             }
-            currentSubtitlesOctopus = null;
+            this.#currentSubtitlesOctopus = null;
 
-            var renderer = currentAssRenderer;
+            const renderer = this.#currentAssRenderer;
             if (renderer) {
                 renderer.setEnabled(false);
             }
-            currentAssRenderer = null;
+            this.#currentAssRenderer = null;
         }
 
-        self.destroyCustomTrack = destroyCustomTrack;
-
-        function fetchSubtitlesUwp(track, item) {
+        /**
+         * @private
+         */
+        fetchSubtitlesUwp(track) {
             return Windows.Storage.StorageFile.getFileFromPathAsync(track.Path).then(function (storageFile) {
-                return Windows.Storage.FileIO.readTextAsync(storageFile).then(function (text) {
-                    return JSON.parse(text);
-                });
+                return Windows.Storage.FileIO.readTextAsync(storageFile);
+            }).then(function (text) {
+                return JSON.parse(text);
             });
         }
 
-        function fetchSubtitles(track, item) {
+        /**
+         * @private
+         */
+        async fetchSubtitles(track, item) {
             if (window.Windows && itemHelper.isLocalItem(item)) {
-                return fetchSubtitlesUwp(track, item);
+                return this.fetchSubtitlesUwp(track, item);
             }
 
-            incrementFetchQueue();
-            return new Promise(function (resolve, reject) {
-                var xhr = new XMLHttpRequest();
+            this.incrementFetchQueue();
+            try {
+                const response = await fetch(getTextTrackUrl(track, item, '.js'));
 
-                var url = getTextTrackUrl(track, item, '.js');
+                if (!response.ok) {
+                    throw new Error(response);
+                }
 
-                xhr.open('GET', url, true);
-
-                xhr.onload = function (e) {
-                    resolve(JSON.parse(this.response));
-                    decrementFetchQueue();
-                };
-
-                xhr.onerror = function (e) {
-                    reject(e);
-                    decrementFetchQueue();
-                };
-
-                xhr.send();
-            });
+                return response.json();
+            } finally {
+                this.decrementFetchQueue();
+            }
         }
 
-        function setTrackForDisplay(videoElement, track) {
+        /**
+         * @private
+         */
+        setTrackForDisplay(videoElement, track) {
             if (!track) {
-                destroyCustomTrack(videoElement);
+                this.destroyCustomTrack(videoElement);
                 return;
             }
 
             // skip if already playing this track
-            if (customTrackIndex === track.Index) {
+            if (this.#customTrackIndex === track.Index) {
                 return;
             }
 
-            self.resetSubtitleOffset();
-            var item = self._currentPlayOptions.item;
+            this.resetSubtitleOffset();
+            const item = this._currentPlayOptions.item;
 
-            destroyCustomTrack(videoElement);
-            customTrackIndex = track.Index;
-            renderTracksEvents(videoElement, track, item);
+            this.destroyCustomTrack(videoElement);
+            this.#customTrackIndex = track.Index;
+            this.renderTracksEvents(videoElement, track, item);
         }
 
-        function renderSsaAss(videoElement, track, item) {
-            var attachments = self._currentPlayOptions.mediaSource.MediaAttachments || [];
-            var apiClient = connectionManager.getApiClient(item);
-            var options = {
+        /**
+         * @private
+         */
+        renderSsaAss(videoElement, track, item) {
+            const attachments = this._currentPlayOptions.mediaSource.MediaAttachments || [];
+            const apiClient = connectionManager.getApiClient(item);
+            const htmlVideoPlayer = this;
+            const options = {
                 video: videoElement,
                 subUrl: getTextTrackUrl(track, item),
                 fonts: attachments.map(function (i) {
                     return apiClient.getUrl(i.DeliveryUrl);
                 }),
-                workerUrl: appRouter.baseUrl() + '/libraries/subtitles-octopus-worker.js',
-                legacyWorkerUrl: appRouter.baseUrl() + '/libraries/subtitles-octopus-worker-legacy.js',
-                onError: function() {
-                    htmlMediaHelper.onErrorInternal(self, 'mediadecodeerror');
+                workerUrl: `${appRouter.baseUrl()}/libraries/subtitles-octopus-worker.js`,
+                legacyWorkerUrl: `${appRouter.baseUrl()}/libraries/subtitles-octopus-worker-legacy.js`,
+                onError() {
+                    onErrorInternal(htmlVideoPlayer, 'mediadecodeerror');
                 },
-                timeOffset: (self._currentPlayOptions.transcodingOffsetTicks || 0) / 10000000,
+                timeOffset: (this._currentPlayOptions.transcodingOffsetTicks || 0) / 10000000,
 
                 // new octopus options; override all, even defaults
                 renderMode: 'blend',
@@ -842,12 +1063,15 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                 resizeVariation: 0.2,
                 renderAhead: 90
             };
-            require(['JavascriptSubtitlesOctopus'], function(SubtitlesOctopus) {
-                currentSubtitlesOctopus = new SubtitlesOctopus(options);
+            import('JavascriptSubtitlesOctopus').then(({default: SubtitlesOctopus}) => {
+                this.#currentSubtitlesOctopus = new SubtitlesOctopus(options);
             });
         }
 
-        function requiresCustomSubtitlesElement() {
+        /**
+         * @private
+         */
+        requiresCustomSubtitlesElement() {
             // after a system update, ps4 isn't showing anything when creating a track element dynamically
             // going to have to do it ourselves
             if (browser.ps4) {
@@ -864,9 +1088,9 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             }
 
             if (browser.iOS) {
-                var userAgent = navigator.userAgent.toLowerCase();
+                const userAgent = navigator.userAgent.toLowerCase();
                 // works in the browser but not the native app
-                if ((userAgent.indexOf('os 9') !== -1 || userAgent.indexOf('os 8') !== -1) && userAgent.indexOf('safari') === -1) {
+                if ((userAgent.includes('os 9') || userAgent.includes('os 8')) && !userAgent.includes('safari')) {
                     return true;
                 }
             }
@@ -874,22 +1098,28 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             return false;
         }
 
-        function renderSubtitlesWithCustomElement(videoElement, track, item) {
-            fetchSubtitles(track, item).then(function (data) {
-                if (!videoSubtitlesElem) {
-                    var subtitlesContainer = document.createElement('div');
+        /**
+         * @private
+         */
+        renderSubtitlesWithCustomElement(videoElement, track, item) {
+            this.fetchSubtitles(track, item).then((data) => {
+                if (!this.#videoSubtitlesElem) {
+                    const subtitlesContainer = document.createElement('div');
                     subtitlesContainer.classList.add('videoSubtitles');
                     subtitlesContainer.innerHTML = '<div class="videoSubtitlesInner"></div>';
-                    videoSubtitlesElem = subtitlesContainer.querySelector('.videoSubtitlesInner');
-                    setSubtitleAppearance(subtitlesContainer, videoSubtitlesElem);
+                    this.#videoSubtitlesElem = subtitlesContainer.querySelector('.videoSubtitlesInner');
+                    this.setSubtitleAppearance(subtitlesContainer, this.#videoSubtitlesElem);
                     videoElement.parentNode.appendChild(subtitlesContainer);
-                    currentTrackEvents = data.TrackEvents;
+                    this.#currentTrackEvents = data.TrackEvents;
                 }
             });
         }
 
-        function setSubtitleAppearance(elem, innerElem) {
-            require(['userSettings', 'subtitleAppearanceHelper'], function (userSettings, subtitleAppearanceHelper) {
+        /**
+         * @private
+         */
+        setSubtitleAppearance(elem, innerElem) {
+            Promise.all([import('userSettings'), import('subtitleAppearanceHelper')]).then(([userSettings, subtitleAppearanceHelper]) => {
                 subtitleAppearanceHelper.applyStyles({
                     text: innerElem,
                     window: elem
@@ -897,49 +1127,51 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             });
         }
 
-        function getCueCss(appearance, selector) {
-            var html = selector + '::cue {';
-
-            html += appearance.text.map(function (s) {
-                return s.name + ':' + s.value + '!important;';
-            }).join('');
-
-            html += '}';
-
-            return html;
+        /**
+         * @private
+         */
+        getCueCss(appearance, selector) {
+            return `${selector}::cue {
+                ${appearance.text.map((s) => `${s.name}:${s.value}!important;`).join('')}
+            }`;
         }
 
-        function setCueAppearance() {
-            require(['userSettings', 'subtitleAppearanceHelper'], function (userSettings, subtitleAppearanceHelper) {
-                var elementId = self.id + '-cuestyle';
+        /**
+         * @private
+         */
+        setCueAppearance() {
+            Promise.all([import('userSettings'), import('subtitleAppearanceHelper')]).then(([userSettings, subtitleAppearanceHelper]) => {
+                const elementId = `${this.id}-cuestyle`;
 
-                var styleElem = document.querySelector('#' + elementId);
+                let styleElem = document.querySelector(`#${elementId}`);
                 if (!styleElem) {
                     styleElem = document.createElement('style');
                     styleElem.id = elementId;
-                    styleElem.type = 'text/css';
                     document.getElementsByTagName('head')[0].appendChild(styleElem);
                 }
 
-                styleElem.innerHTML = getCueCss(subtitleAppearanceHelper.getStyles(userSettings.getSubtitleAppearanceSettings(), true), '.htmlvideoplayer');
+                styleElem.innerHTML = this.getCueCss(subtitleAppearanceHelper.getStyles(userSettings.getSubtitleAppearanceSettings(), true), '.htmlvideoplayer');
             });
         }
 
-        function renderTracksEvents(videoElement, track, item) {
+        /**
+         * @private
+         */
+        renderTracksEvents(videoElement, track, item) {
             if (!itemHelper.isLocalItem(item) || track.IsExternal) {
-                var format = (track.Codec || '').toLowerCase();
+                const format = (track.Codec || '').toLowerCase();
                 if (format === 'ssa' || format === 'ass') {
-                    renderSsaAss(videoElement, track, item);
+                    this.renderSsaAss(videoElement, track, item);
                     return;
                 }
 
-                if (requiresCustomSubtitlesElement()) {
-                    renderSubtitlesWithCustomElement(videoElement, track, item);
+                if (this.requiresCustomSubtitlesElement()) {
+                    this.renderSubtitlesWithCustomElement(videoElement, track, item);
                     return;
                 }
             }
 
-            var trackElement = null;
+            let trackElement = null;
             if (videoElement.textTracks && videoElement.textTracks.length > 0) {
                 trackElement = videoElement.textTracks[0];
 
@@ -962,42 +1194,44 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             }
 
             // download the track json
-            fetchSubtitles(track, item).then(function (data) {
+            this.fetchSubtitles(track, item).then(function (data) {
                 // show in ui
-                console.debug('downloaded ' + data.TrackEvents.length + ' track events');
+                console.debug(`downloaded ${data.TrackEvents.length} track events`);
                 // add some cues to show the text
                 // in safari, the cues need to be added before setting the track mode to showing
-                data.TrackEvents.forEach(function (trackEvent) {
-                    var trackCueObject = window.VTTCue || window.TextTrackCue;
-                    var cue = new trackCueObject(trackEvent.StartPositionTicks / 10000000, trackEvent.EndPositionTicks / 10000000, normalizeTrackEventText(trackEvent.Text, false));
+                for (const trackEvent of data.TrackEvents) {
+                    const trackCueObject = window.VTTCue || window.TextTrackCue;
+                    const cue = new trackCueObject(trackEvent.StartPositionTicks / 10000000, trackEvent.EndPositionTicks / 10000000, normalizeTrackEventText(trackEvent.Text, false));
 
                     trackElement.addCue(cue);
-                });
+                }
                 trackElement.mode = 'showing';
             });
         }
 
-        function updateSubtitleText(timeMs) {
-            var clock = currentClock;
+        /**
+         * @private
+         */
+        updateSubtitleText(timeMs) {
+            const clock = this.#currentClock;
             if (clock) {
                 try {
                     clock.seek(timeMs / 1000);
                 } catch (err) {
-                    console.error('error in libjass: ' + err);
+                    console.error(`error in libjass: ${err}`);
                 }
                 return;
             }
 
-            var trackEvents = currentTrackEvents;
-            var subtitleTextElement = videoSubtitlesElem;
+            const trackEvents = this.#currentTrackEvents;
+            const subtitleTextElement = this.#videoSubtitlesElem;
 
             if (trackEvents && subtitleTextElement) {
-                var ticks = timeMs * 10000;
-                var selectedTrackEvent;
-                for (var i = 0; i < trackEvents.length; i++) {
-                    var currentTrackEvent = trackEvents[i];
-                    if (currentTrackEvent.StartPositionTicks <= ticks && currentTrackEvent.EndPositionTicks >= ticks) {
-                        selectedTrackEvent = currentTrackEvent;
+                const ticks = timeMs * 10000;
+                let selectedTrackEvent;
+                for (const trackEvent of trackEvents) {
+                    if (trackEvent.StartPositionTicks <= ticks && trackEvent.EndPositionTicks >= ticks) {
+                        selectedTrackEvent = trackEvent;
                         break;
                     }
                 }
@@ -1011,19 +1245,22 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             }
         }
 
-        function setCurrentTrackElement(streamIndex) {
-            console.debug('setting new text track index to: ' + streamIndex);
+        /**
+         * @private
+         */
+        setCurrentTrackElement(streamIndex) {
+            console.debug(`setting new text track index to: ${streamIndex}`);
 
-            var mediaStreamTextTracks = getMediaStreamTextTracks(self._currentPlayOptions.mediaSource);
+            const mediaStreamTextTracks = getMediaStreamTextTracks(this._currentPlayOptions.mediaSource);
 
-            var track = streamIndex === -1 ? null : mediaStreamTextTracks.filter(function (t) {
+            let track = streamIndex === -1 ? null : mediaStreamTextTracks.filter(function (t) {
                 return t.Index === streamIndex;
             })[0];
 
-            setTrackForDisplay(self._mediaElement, track);
-            if (enableNativeTrackSupport(self._currentSrc, track)) {
+            this.setTrackForDisplay(this.#mediaElement, track);
+            if (enableNativeTrackSupport(this.#currentSrc, track)) {
                 if (streamIndex !== -1) {
-                    setCueAppearance();
+                    this.setCueAppearance();
                 }
             } else {
                 // null these out to disable the player's native display (handled below)
@@ -1032,15 +1269,17 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             }
         }
 
-        function createMediaElement(options) {
-            return new Promise(function (resolve, reject) {
-                var dlg = document.querySelector('.videoPlayerContainer');
+        /**
+         * @private
+         */
+        createMediaElement(options) {
+            const dlg = document.querySelector('.videoPlayerContainer');
 
                 if (!dlg) {
-                    require(['css!./style'], function () {
+                    return import('css!./style').then(() => {
                         loading.show();
 
-                        var dlg = document.createElement('div');
+                        const dlg = document.createElement('div');
 
                         dlg.classList.add('videoPlayerContainer');
 
@@ -1048,8 +1287,8 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                             dlg.classList.add('videoPlayerContainer-onTop');
                         }
 
-                        var html = '';
-                        var cssClass = 'htmlvideoplayer';
+                        let html = '';
+                        let cssClass = 'htmlvideoplayer';
 
                         // Can't autoplay in these browsers so we need to use the full controls, at least until playback starts
                         if (!appHost.supports('htmlvideoautoplay')) {
@@ -1062,64 +1301,73 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                         html += '</video>';
 
                         dlg.innerHTML = html;
-                        var videoElement = dlg.querySelector('video');
+                        const videoElement = dlg.querySelector('video');
 
-                        videoElement.volume = htmlMediaHelper.getSavedVolume();
-                        videoElement.addEventListener('timeupdate', onTimeUpdate);
-                        videoElement.addEventListener('ended', onEnded);
-                        videoElement.addEventListener('volumechange', onVolumeChange);
-                        videoElement.addEventListener('pause', onPause);
-                        videoElement.addEventListener('playing', onPlaying);
-                        videoElement.addEventListener('play', onPlay);
-                        videoElement.addEventListener('click', onClick);
-                        videoElement.addEventListener('dblclick', onDblClick);
-                        videoElement.addEventListener('waiting', onWaiting);
+                        videoElement.volume = getSavedVolume();
+                        videoElement.addEventListener('timeupdate', this.onTimeUpdate);
+                        videoElement.addEventListener('ended', this.onEnded);
+                        videoElement.addEventListener('volumechange', this.onVolumeChange);
+                        videoElement.addEventListener('pause', this.onPause);
+                        videoElement.addEventListener('playing', this.onPlaying);
+                        videoElement.addEventListener('play', this.onPlay);
+                        videoElement.addEventListener('click', this.onClick);
+                        videoElement.addEventListener('dblclick', this.onDblClick);
+                        videoElement.addEventListener('waiting', this.onWaiting);
                         if (options.backdropUrl) {
                             videoElement.poster = options.backdropUrl;
                         }
 
                         document.body.insertBefore(dlg, document.body.firstChild);
-                        videoDialog = dlg;
-                        self._mediaElement = videoElement;
+                        this.#videoDialog = dlg;
+                        this.#mediaElement = videoElement;
 
                         // don't animate on smart tv's, too slow
                         if (options.fullscreen && browser.supportsCssAnimation() && !browser.slow) {
-                            zoomIn(dlg).then(function () {
-                                resolve(videoElement);
+                            return zoomIn(dlg).then(function () {
+                                return videoElement;
                             });
                         } else {
                             hidePrePlaybackPage();
-                            resolve(videoElement);
+                            return videoElement;
                         }
                     });
                 } else {
-                    resolve(dlg.querySelector('video'));
+                    return Promise.resolve(dlg.querySelector('video'));
                 }
-            });
         }
+
+    /**
+     * @private
+     */
+    canPlayMediaType(mediaType) {
+        return (mediaType || '').toLowerCase() === 'video';
     }
 
-    HtmlVideoPlayer.prototype.canPlayMediaType = function (mediaType) {
-        return (mediaType || '').toLowerCase() === 'video';
-    };
-
-    HtmlVideoPlayer.prototype.supportsPlayMethod = function (playMethod, item) {
+    /**
+     * @private
+     */
+    supportsPlayMethod(playMethod, item) {
         if (appHost.supportsPlayMethod) {
             return appHost.supportsPlayMethod(playMethod, item);
         }
 
         return true;
-    };
+    }
 
-    HtmlVideoPlayer.prototype.getDeviceProfile = function (item, options) {
-        var instance = this;
-        return getDeviceProfileInternal(item, options).then(function (profile) {
-            instance._lastProfile = profile;
+    /**
+     * @private
+     */
+    getDeviceProfile(item, options) {
+        return HtmlVideoPlayer.getDeviceProfileInternal(item, options).then((profile) => {
+            this.#lastProfile = profile;
             return profile;
         });
-    };
+    }
 
-    function getDeviceProfileInternal(item, options) {
+    /**
+     * @private
+     */
+    static getDeviceProfileInternal(item, options) {
         if (appHost.getDeviceProfile) {
             return appHost.getDeviceProfile(item, options);
         }
@@ -1127,12 +1375,13 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
         return getDefaultProfile();
     }
 
-    var supportedFeatures;
+    /**
+     * @private
+     */
+    static getSupportedFeatures() {
+        const list = [];
 
-    function getSupportedFeatures() {
-        var list = [];
-
-        var video = document.createElement('video');
+        const video = document.createElement('video');
         if (video.webkitSupportsPresentationMode && typeof video.webkitSetPresentationMode === 'function' || document.pictureInPictureEnabled) {
             list.push('PictureInPicture');
         } else if (window.Windows) {
@@ -1155,50 +1404,50 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
         return list;
     }
 
-    HtmlVideoPlayer.prototype.supports = function (feature) {
-        if (!supportedFeatures) {
-            supportedFeatures = getSupportedFeatures();
+    supports(feature) {
+        if (!this.#supportedFeatures) {
+            this.#supportedFeatures = HtmlVideoPlayer.getSupportedFeatures();
         }
 
-        return supportedFeatures.indexOf(feature) !== -1;
-    };
+        return this.#supportedFeatures.includes(feature);
+    }
 
     // Save this for when playback stops, because querying the time at that point might return 0
-    HtmlVideoPlayer.prototype.currentTime = function (val) {
-        var mediaElement = this._mediaElement;
+    currentTime(val) {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             if (val != null) {
                 mediaElement.currentTime = val / 1000;
                 return;
             }
 
-            var currentTime = this._currentTime;
+            const currentTime = this.#currentTime;
             if (currentTime) {
                 return currentTime * 1000;
             }
 
             return (mediaElement.currentTime || 0) * 1000;
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.duration = function (val) {
-        var mediaElement = this._mediaElement;
+    duration() {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
-            var duration = mediaElement.duration;
-            if (htmlMediaHelper.isValidDuration(duration)) {
+            const duration = mediaElement.duration;
+            if (isValidDuration(duration)) {
                 return duration * 1000;
             }
         }
 
         return null;
-    };
+    }
 
-    HtmlVideoPlayer.prototype.canSetAudioStreamIndex = function (index) {
+    canSetAudioStreamIndex() {
         if (browser.tizen || browser.orsay) {
             return true;
         }
 
-        var video = this._mediaElement;
+        const video = this.#mediaElement;
         if (video) {
             if (video.audioTracks) {
                 return true;
@@ -1206,21 +1455,21 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
         }
 
         return false;
-    };
-
-    function onPictureInPictureError(err) {
-        console.error('Picture in picture error: ' + err.toString());
     }
 
-    HtmlVideoPlayer.prototype.setPictureInPictureEnabled = function (isEnabled) {
-        var video = this._mediaElement;
+    static onPictureInPictureError(err) {
+        console.error(`Picture in picture error: ${err}`);
+    }
+
+    setPictureInPictureEnabled(isEnabled) {
+        const video = this.#mediaElement;
 
         if (document.pictureInPictureEnabled) {
             if (video) {
                 if (isEnabled) {
-                    video.requestPictureInPicture().catch(onPictureInPictureError);
+                    video.requestPictureInPicture().catch(HtmlVideoPlayer.onPictureInPictureError);
                 } else {
-                    document.exitPictureInPicture().catch(onPictureInPictureError);
+                    document.exitPictureInPicture().catch(HtmlVideoPlayer.onPictureInPictureError);
                 }
             }
         } else if (window.Windows) {
@@ -1235,33 +1484,33 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
                 video.webkitSetPresentationMode(isEnabled ? 'picture-in-picture' : 'inline');
             }
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.isPictureInPictureEnabled = function () {
+    isPictureInPictureEnabled() {
         if (document.pictureInPictureEnabled) {
-            return document.pictureInPictureElement ? true : false;
+            return !!document.pictureInPictureElement;
         } else if (window.Windows) {
             return this.isPip || false;
         } else {
-            var video = this._mediaElement;
+            const video = this.#mediaElement;
             if (video) {
                 return video.webkitPresentationMode === 'picture-in-picture';
             }
         }
 
         return false;
-    };
+    }
 
-    HtmlVideoPlayer.prototype.isAirPlayEnabled = function () {
+    static isAirPlayEnabled() {
         if (document.AirPlayEnabled) {
-            return document.AirplayElement ? true : false;
+            return !!document.AirplayElement;
         }
 
         return false;
-    };
+    }
 
-    HtmlVideoPlayer.prototype.setAirPlayEnabled = function (isEnabled) {
-        var video = this._mediaElement;
+    setAirPlayEnabled(isEnabled) {
+        const video = this.#mediaElement;
 
         if (document.AirPlayEnabled) {
             if (video) {
@@ -1278,46 +1527,46 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
         } else {
             video.webkitShowPlaybackTargetPicker();
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.setBrightness = function (val) {
-        var elem = this._mediaElement;
+    setBrightness(val) {
+        const elem = this.#mediaElement;
 
         if (elem) {
             val = Math.max(0, val);
             val = Math.min(100, val);
 
-            var rawValue = val;
+            let rawValue = val;
             rawValue = Math.max(20, rawValue);
 
-            var cssValue = rawValue >= 100 ? 'none' : (rawValue / 100);
-            elem.style['-webkit-filter'] = 'brightness(' + cssValue + ');';
-            elem.style.filter = 'brightness(' + cssValue + ')';
+            const cssValue = rawValue >= 100 ? 'none' : (rawValue / 100);
+            elem.style['-webkit-filter'] = `brightness(${cssValue})`;
+            elem.style.filter = `brightness(${cssValue})`;
             elem.brightnessValue = val;
             events.trigger(this, 'brightnesschange');
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.getBrightness = function () {
-        var elem = this._mediaElement;
+    getBrightness() {
+        const elem = this.#mediaElement;
         if (elem) {
-            var val = elem.brightnessValue;
+            const val = elem.brightnessValue;
             return val == null ? 100 : val;
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.seekable = function () {
-        var mediaElement = this._mediaElement;
+    seekable() {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
-            var seekable = mediaElement.seekable;
+            const seekable = mediaElement.seekable;
             if (seekable && seekable.length) {
-                var start = seekable.start(0);
-                var end = seekable.end(0);
+                let start = seekable.start(0);
+                let end = seekable.end(0);
 
-                if (!htmlMediaHelper.isValidDuration(start)) {
+                if (!isValidDuration(start)) {
                     start = 0;
                 }
-                if (!htmlMediaHelper.isValidDuration(end)) {
+                if (!isValidDuration(end)) {
                     end = 0;
                 }
 
@@ -1326,93 +1575,93 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
 
             return false;
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.pause = function () {
-        var mediaElement = this._mediaElement;
+    pause() {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             mediaElement.pause();
         }
-    };
+    }
 
     // This is a retry after error
-    HtmlVideoPlayer.prototype.resume = function () {
-        var mediaElement = this._mediaElement;
+    resume() {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             mediaElement.play();
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.unpause = function () {
-        var mediaElement = this._mediaElement;
+    unpause() {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             mediaElement.play();
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.paused = function () {
-        var mediaElement = this._mediaElement;
+    paused() {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             return mediaElement.paused;
         }
 
         return false;
-    };
+    }
 
-    HtmlVideoPlayer.prototype.setPlaybackRate = function (value) {
-        var mediaElement = this._mediaElement;
+    setPlaybackRate(value) {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             mediaElement.playbackRate = value;
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.getPlaybackRate = function () {
-        var mediaElement = this._mediaElement;
+    getPlaybackRate() {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             return mediaElement.playbackRate;
         }
         return null;
-    };
+    }
 
-    HtmlVideoPlayer.prototype.setVolume = function (val) {
-        var mediaElement = this._mediaElement;
+    setVolume(val) {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             mediaElement.volume = val / 100;
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.getVolume = function () {
-        var mediaElement = this._mediaElement;
+    getVolume() {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             return Math.min(Math.round(mediaElement.volume * 100), 100);
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.volumeUp = function () {
+    volumeUp() {
         this.setVolume(Math.min(this.getVolume() + 2, 100));
-    };
+    }
 
-    HtmlVideoPlayer.prototype.volumeDown = function () {
+    volumeDown() {
         this.setVolume(Math.max(this.getVolume() - 2, 0));
-    };
+    }
 
-    HtmlVideoPlayer.prototype.setMute = function (mute) {
-        var mediaElement = this._mediaElement;
+    setMute(mute) {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             mediaElement.muted = mute;
         }
-    };
+    }
 
-    HtmlVideoPlayer.prototype.isMuted = function () {
-        var mediaElement = this._mediaElement;
+    isMuted() {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             return mediaElement.muted;
         }
         return false;
-    };
+    }
 
-    HtmlVideoPlayer.prototype.setAspectRatio = function (val) {
-        var mediaElement = this._mediaElement;
+    setAspectRatio(val) {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
             if ('auto' === val) {
                 mediaElement.style.removeProperty('object-fit');
@@ -1421,13 +1670,13 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             }
         }
         this._currentAspectRatio = val;
-    };
+    }
 
-    HtmlVideoPlayer.prototype.getAspectRatio = function () {
+    getAspectRatio() {
         return this._currentAspectRatio || 'auto';
-    };
+    }
 
-    HtmlVideoPlayer.prototype.getSupportedAspectRatios = function () {
+    getSupportedAspectRatios() {
         return [{
             name: 'Auto',
             id: 'auto'
@@ -1438,30 +1687,30 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             name: 'Fill',
             id: 'fill'
         }];
-    };
+    }
 
-    HtmlVideoPlayer.prototype.togglePictureInPicture = function () {
+    togglePictureInPicture() {
         return this.setPictureInPictureEnabled(!this.isPictureInPictureEnabled());
-    };
+    }
 
-    HtmlVideoPlayer.prototype.toggleAirPlay = function () {
+    toggleAirPlay() {
         return this.setAirPlayEnabled(!this.isAirPlayEnabled());
-    };
+    }
 
-    HtmlVideoPlayer.prototype.getBufferedRanges = function () {
-        var mediaElement = this._mediaElement;
+    getBufferedRanges() {
+        const mediaElement = this.#mediaElement;
         if (mediaElement) {
-            return htmlMediaHelper.getBufferedRanges(this, mediaElement);
+            return getBufferedRanges(this, mediaElement);
         }
 
         return [];
-    };
+    }
 
-    HtmlVideoPlayer.prototype.getStats = function () {
-        var mediaElement = this._mediaElement;
-        var playOptions = this._currentPlayOptions || [];
+    getStats() {
+        const mediaElement = this.#mediaElement;
+        const playOptions = this._currentPlayOptions || [];
 
-        var categories = [];
+        const categories = [];
 
         if (!mediaElement) {
             return Promise.resolve({
@@ -1469,7 +1718,7 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             });
         }
 
-        var mediaCategory = {
+        const mediaCategory = {
             stats: [],
             type: 'media'
         };
@@ -1477,10 +1726,10 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
 
         if (playOptions.url) {
             //  create an anchor element (note: no need to append this element to the document)
-            var link = document.createElement('a');
+            let link = document.createElement('a');
             //  set href to any path
             link.setAttribute('href', playOptions.url);
-            var protocol = (link.protocol || '').replace(':', '');
+            const protocol = (link.protocol || '').replace(':', '');
 
             if (protocol) {
                 mediaCategory.stats.push({
@@ -1504,21 +1753,21 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
             });
         }
 
-        var videoCategory = {
+        const videoCategory = {
             stats: [],
             type: 'video'
         };
         categories.push(videoCategory);
 
-        var rect = mediaElement.getBoundingClientRect ? mediaElement.getBoundingClientRect() : {};
-        var height = parseInt(rect.height);
-        var width = parseInt(rect.width);
+        const rect = mediaElement.getBoundingClientRect ? mediaElement.getBoundingClientRect() : {};
+        let height = parseInt(rect.height);
+        let width = parseInt(rect.width);
 
         // Don't show player dimensions on smart TVs because the app UI could be lower resolution than the video and this causes users to think there is a problem
         if (width && height && !browser.tv) {
             videoCategory.stats.push({
                 label: globalize.translate('LabelPlayerDimensions'),
-                value: width + 'x' + height
+                value: `${width}x${height}`
             });
         }
 
@@ -1528,33 +1777,33 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
         if (width && height) {
             videoCategory.stats.push({
                 label: globalize.translate('LabelVideoResolution'),
-                value: width + 'x' + height
+                value: `${width}x${height}`
             });
         }
 
         if (mediaElement.getVideoPlaybackQuality) {
-            var playbackQuality = mediaElement.getVideoPlaybackQuality();
+            const playbackQuality = mediaElement.getVideoPlaybackQuality();
 
-            var droppedVideoFrames = playbackQuality.droppedVideoFrames || 0;
+            const droppedVideoFrames = playbackQuality.droppedVideoFrames || 0;
             videoCategory.stats.push({
                 label: globalize.translate('LabelDroppedFrames'),
                 value: droppedVideoFrames
             });
 
-            var corruptedVideoFrames = playbackQuality.corruptedVideoFrames || 0;
+            const corruptedVideoFrames = playbackQuality.corruptedVideoFrames || 0;
             videoCategory.stats.push({
                 label: globalize.translate('LabelCorruptedFrames'),
                 value: corruptedVideoFrames
             });
         }
 
-        var audioCategory = {
+        const audioCategory = {
             stats: [],
             type: 'audio'
         };
         categories.push(audioCategory);
 
-        var sinkId = mediaElement.sinkId;
+        const sinkId = mediaElement.sinkId;
         if (sinkId) {
             audioCategory.stats.push({
                 label: 'Sink Id:',
@@ -1565,7 +1814,8 @@ define(['browser', 'require', 'events', 'apphost', 'loading', 'dom', 'playbackMa
         return Promise.resolve({
             categories: categories
         });
-    };
+    }
+    }
+/* eslint-enable indent */
 
-    return HtmlVideoPlayer;
-});
+export default HtmlVideoPlayer;